unsigned int ompl::control::SpaceInformation::propagateWhileValid(const base::State *state, const Control *control, int steps, base::State *result) const { if (steps == 0) { if (result != state) copyState(result, state); return 0; } double signedStepSize = steps > 0 ? stepSize_ : -stepSize_; steps = abs(steps); // perform the first step of propagation statePropagator_->propagate(state, control, signedStepSize, result); // if we found a valid state after one step, we can go on if (isValid(result)) { base::State *temp1 = result; base::State *temp2 = allocState(); base::State *toDelete = temp2; unsigned int r = steps; // for the remaining number of steps for (int i = 1; i < steps; ++i) { statePropagator_->propagate(temp1, control, signedStepSize, temp2); if (isValid(temp2)) std::swap(temp1, temp2); else { // the last valid state is temp1; r = i; break; } } // if we finished the for-loop without finding an invalid state, the last valid state is temp1 // make sure result contains that information if (result != temp1) copyState(result, temp1); // free the temporary memory freeState(toDelete); return r; } // if the first propagation step produced an invalid step, return 0 steps // the last valid state is the starting one (assumed to be valid) else { if (result != state) copyState(result, state); return 0; } }
/* Based on code from : Copyright (c) 2003-2006 Gino van den Bergen / Erwin Coumans http://continuousphysics.com/Bullet/ */ void ompl::base::SO3StateSpace::interpolate(const State *from, const State *to, const double t, State *state) const { assert(fabs(norm(static_cast<const StateType*>(from)) - 1.0) < MAX_QUATERNION_NORM_ERROR); assert(fabs(norm(static_cast<const StateType*>(to)) - 1.0) < MAX_QUATERNION_NORM_ERROR); double theta = arcLength(from, to); if (theta > std::numeric_limits<double>::epsilon()) { double d = 1.0 / sin(theta); double s0 = sin((1.0 - t) * theta); double s1 = sin(t * theta); const StateType *qs1 = static_cast<const StateType*>(from); const StateType *qs2 = static_cast<const StateType*>(to); StateType *qr = static_cast<StateType*>(state); double dq = qs1->x * qs2->x + qs1->y * qs2->y + qs1->z * qs2->z + qs1->w * qs2->w; if (dq < 0) // Take care of long angle case see http://en.wikipedia.org/wiki/Slerp s1 = -s1; qr->x = (qs1->x * s0 + qs2->x * s1) * d; qr->y = (qs1->y * s0 + qs2->y * s1) * d; qr->z = (qs1->z * s0 + qs2->z * s1) * d; qr->w = (qs1->w * s0 + qs2->w * s1) * d; } else { if (state != from) copyState(state, from); } }
//============================================================================== SE2::ScopedState SE2::cloneState(const StateSpace::State* stateIn) const { auto newState = createState(); copyState(stateIn, newState); return newState; }
Board::Board( const Board & other ) : QAbstractListModel( Q_NULLPTR ) , m_figures( std::move( initFigures() ) ) , m_whiteKing( static_cast< King* > ( m_figures.at( 20 ).data() ) ) , m_blackKing( static_cast< King* > ( m_figures.at( 4 ).data() ) ) { copyState( other ); }
/** * Proces the slow and fast aggregator and copy between them if needed. *The aggregators are implicitly copied * The copy is triggered when the slow filter process a stream that was dropped by the fast filter. */ void step() { // call the slow aggregator streams in the relevant order while( slow_aggr->step() ); //this logic is for determining if a copy is needed, so only triggered if there is no pending copy if(!copy) { //Check which streams were dropped by the fast filter, but weren't dropped by the slow filter. for( int i = 0; i < stream_size; i++) { const aggregator::StreamStatus &status_fast( fast_aggr->getBufferStatus(i) ); const aggregator::StreamStatus &status_slow( slow_aggr->getBufferStatus(i) ); int total_stream_dropped_fast = status_fast.samples_dropped_buffer_full + status_fast.samples_dropped_late_arriving; int total_stream_dropped_slow = status_slow.samples_dropped_buffer_full + status_slow.samples_dropped_late_arriving; int current_dif = total_stream_dropped_fast - total_stream_dropped_slow; //verify if a stream was dropped by the fast filter, but wasen't dropped by the slow filter if( current_dif > 0 ) { //verify if that stream of that type was procces by the slow filter if( prev_num_processed_streams_slow[i] < status_slow.samples_processed) { //if the stream process was of a type dropped by the fast filter there need to be a copy copy = true; break; } } prev_num_processed_streams_slow[i] = status_slow.samples_processed; } } //std::cout << " MUST COPY " << copy << std::endl; //verify if there is a need to procces the fast aggregator if ( slow_aggr->getLatency().toSeconds() > fast_aggr->getTimeOut().toSeconds() ) { if( copy ) { copy = false; fast_aggr->copyState( *slow_aggr ); copyState(); //since there was a copy this get the new ammount of stream dropped for( int i = 0; i < stream_size; i++) { const aggregator::StreamStatus &status_slow( slow_aggr->getBufferStatus(i) ); prev_num_processed_streams_slow[i] = status_slow.samples_processed; } } while( fast_aggr->step() ); } }
int findDrawLocation(){ int cycle =currentState.round - twoOfPowerState.round; State state1; State state2; copyState(&state1, &initState); copyState(&state2, &initState); int cycleCount = cycle; while(cycleCount-- /** debugging , cycle--**/ ){ dispatchOneCard( &state2); darwCardsFromPack( &state2); state2.round++; getWhichTurn( &state2); } int i=15; /** int i=14; debugging, because round is start by 1**/ for ( ;i<=currentState.round;i++ ){ dispatchOneCard( &state1); darwCardsFromPack( &state1); dispatchOneCard( &state2); darwCardsFromPack( &state2); if (isDraw(&state1 , &state2) ==1 ){ return state1.round + cycle; /**debugging return state1.round; **/ } state1.round++; state2.round++; getWhichTurn( &state1); getWhichTurn( &state2); } return -1; }
Board & Board::operator = ( const Board & other ) { if( this != &other ) { m_figures = std::move( initFigures() ); m_whiteKing = static_cast< King* > ( m_figures.at( 20 ).data() ); m_blackKing = static_cast< King* > ( m_figures.at( 4 ).data() ); copyState( other ); } return *this; }
bool ompl::base::SpaceInformation::searchValidNearby(State *state, const State *near, double distance, unsigned int attempts) const { if (satisfiesBounds(near) && isValid(near)) { if (state != near) copyState(state, near); return true; } else { // try to find a valid state nearby UniformValidStateSampler *uvss = new UniformValidStateSampler(this); uvss->setNrAttempts(attempts); return searchValidNearby(ValidStateSamplerPtr(uvss), state, near, distance); } }
void ompl::control::SpaceInformation::propagate(const base::State *state, const Control *control, int steps, base::State *result) const { if (steps == 0) { if (result != state) copyState(result, state); } else { double signedStepSize = steps > 0 ? stepSize_ : -stepSize_; steps = abs(steps); statePropagator_->propagate(state, control, signedStepSize, result); for (int i = 1; i < steps; ++i) statePropagator_->propagate(result, control, signedStepSize, result); } }
sequential_soo_instance* sequential_soo_initInstance(state* initial, double gamma, unsigned int H, char dropTerminal) { unsigned int i = 0; sequential_soo_instance* newInstance = (sequential_soo_instance*)malloc(sizeof(sequential_soo_instance)); newInstance->H = H; newInstance->initial = copyState(initial); newInstance->instances = (soo**)malloc(sizeof(soo*) * H); for(;i < H; i++) newInstance->instances[i] = soo_init(hMax); newInstance->gamma = gamma; for(i = 0; i < NUMBER_OF_DIMENSIONS_OF_ACTION; i++) newInstance->crtOptimalAction[i] = 0.5; newInstance->crtMaxSumOfDiscountedRewards = 0.0; newInstance->rewards = (double*)malloc(sizeof(double) * H); newInstance->crtNbEvaluations = 0; newInstance->dropTerminal = dropTerminal; return newInstance; }
void copyStates( ESMoL::Stateflow inputStateflow, ESMoL::Stateflow outputStateflow ) { getConnectorRefList().clear(); getTransConnectorMap().clear(); StateVector stateVector = inputStateflow.State_kind_children(); for( StateVector::iterator stvItr = stateVector.begin() ; stvItr != stateVector.end() ; ++stvItr ) { ESMoL::State inputState = *stvItr; ESMoL::State outputState = ESMoL::State::Create( outputStateflow ); copyState( inputState, outputState ); } for( ConnectorRefList::iterator crlItr = getConnectorRefList().begin() ; crlItr != getConnectorRefList().end() ; ++crlItr ) { ESMoL::ConnectorRef inputConnectorRef = *crlItr; ESMoL::TransConnector inputTransConnector = inputConnectorRef.ref(); if ( inputTransConnector == Udm::null ) { std::cerr << "Warning: ConnectorRef is a null reference!" << std::endl; continue; } TransConnectorMap::iterator tcmItr = getTransConnectorMap().find( inputConnectorRef ); if ( tcmItr == getTransConnectorMap().end() ) { std::cerr << "Warning: ConnectorRef has no copy in TransConnectorMap" << std::endl; continue; } ESMoL::TransConnector outputTransConnector = tcmItr->second; if ( outputTransConnector.type() != ESMoL::ConnectorRef::meta ) { std::cerr << "Warning: TransConnector should be a ConnectorRef" << std::endl; continue; } ESMoL::ConnectorRef outputConnectorRef = ESMoL::ConnectorRef::Cast( outputTransConnector ); tcmItr = getTransConnectorMap().find( inputTransConnector ); if ( tcmItr == getTransConnectorMap().end() ) { std::cerr << "Warning: TransConnector has no copy in TransConnectorMap" << std::endl; continue; } outputTransConnector = tcmItr->second; outputConnectorRef.ref() = outputTransConnector; } }
bool ompl::base::SpaceInformation::searchValidNearby(const ValidStateSamplerPtr &sampler, State *state, const State *near, double distance) const { if (state != near) copyState(state, near); // fix bounds, if needed if (!satisfiesBounds(state)) enforceBounds(state); bool result = isValid(state); if (!result) { // try to find a valid state nearby State *temp = cloneState(state); result = sampler->sampleNear(state, temp, distance); freeState(temp); } return result; }
AlphaReal FeaturewiseLearner::run( vector<int>& colIndices ) { AlphaReal bestEnergy = -numeric_limits<AlphaReal>::max(); FeaturewiseLearner* bestClassifier = NULL; // for each fearture given in colIndices run the learner for( vector<int>::iterator it = colIndices.begin(); it != colIndices.end(); ++it ) { AlphaReal tmpEnergy = this->run(*it); if ( tmpEnergy > bestEnergy ) { // keep the best classifier if (bestClassifier) delete bestClassifier; bestClassifier = reinterpret_cast<FeaturewiseLearner*>(copyState()); bestEnergy = tmpEnergy; } } // copy the best classifier subCopyState(bestClassifier); delete bestClassifier; return bestEnergy; };
int main(int argc, char* argv[]) { #ifdef BALL double discountFactor = 0.9; #else #ifdef CART_POLE double discountFactor = 0.95; #else #ifdef DOUBLE_CART_POLE double discountFactor = 0.95; #else #ifdef MOUNTAIN_CAR double discountFactor = 0.99; #else #ifdef ACROBOT double discountFactor = 0.95; #else #ifdef BOAT double discountFactor = 0.95; #else #ifdef CART_POLE_BINARY double discountFactor = 0.95; #else #ifdef SWIMMER double discountFactor = 0.95; #endif #endif #endif #endif #endif #endif #endif #endif FILE* initFileFd = NULL; state** initialStates = NULL; FILE* results = NULL; char str[1024]; unsigned int i = 0; unsigned int h = 0; unsigned int* ns = NULL; unsigned int nbN = 0; unsigned int n = 0; unsigned int nbSteps = 0; unsigned int timestamp = time(NULL); int readFscanf = -1; optimistic_instance* optimistic = NULL; struct arg_file* initFile = arg_file1(NULL, "init", "<file>", "File containing the inital state"); struct arg_str* r = arg_str1("n", NULL, "<s>", "List of maximum numbers of evaluations"); struct arg_int* s = arg_int1("s", NULL, "<n>", "Number of steps"); struct arg_int* k = arg_int1("k", NULL, "<n>", "Branching factor of the problem"); struct arg_file* where = arg_file1(NULL, "where", "<file>", "Directory where we save the outputs"); struct arg_end* end = arg_end(6); int nerrors = 0; void* argtable[6]; argtable[0] = initFile; argtable[1] = r; argtable[2] = s; argtable[3] = k; argtable[4] = where; argtable[5] = end; if(arg_nullcheck(argtable) != 0) { printf("error: insufficient memory\n"); arg_freetable(argtable, 6); return EXIT_FAILURE; } nerrors = arg_parse(argc, argv, argtable); if(nerrors > 0) { printf("%s:", argv[0]); arg_print_syntax(stdout, argtable, "\n"); arg_print_errors(stdout, end, argv[0]); arg_freetable(argtable, 6); return EXIT_FAILURE; } initGenerativeModelParameters(); K = k->ival[0]; initGenerativeModel(); initFileFd = fopen(initFile->filename[0], "r"); readFscanf = fscanf(initFileFd, "%u\n", &n); initialStates = (state**)malloc(sizeof(state*) * n); for(; i < n; i++) { readFscanf = fscanf(initFileFd, "%s\n", str); initialStates[i] = makeState(str); } fclose(initFileFd); nbSteps = s->ival[0]; ns = parseUnsignedIntList((char*)r->sval[0], &nbN); optimistic = optimistic_initInstance(NULL, discountFactor); sprintf(str, "%s/%u_results_%u_%u.csv", where->filename[0], timestamp, K, nbSteps); results = fopen(str, "w"); for(h = 0; h < nbN; h++) { double sumRewards = 0.0; for(i = 0; i < n; i++) { unsigned int j = 0; state* crt = copyState(initialStates[i]); optimistic_resetInstance(optimistic, crt); for(; j < nbSteps; j++) { char isTerminal = 0; double reward = 0.0; state* nextState = NULL; optimistic_keepSubtree(optimistic); action* optimalAction = optimistic_planning(optimistic, ns[h]); isTerminal = nextStateReward(crt, optimalAction, &nextState, &reward) < 0 ? 1 : 0; freeState(crt); crt = nextState; sumRewards += reward; if(isTerminal) break; } optimistic_resetInstance(optimistic, crt); freeState(crt); printf(">>>>>>>>>>>>>> %uth initial state processed\n", i + 1); fflush(NULL); } fprintf(results, "%u,%.15f\n", ns[h], sumRewards / (double)n); printf(">>>>>>>>>>>>>> n = %u done\n\n", ns[h]); fflush(NULL); } fclose(results); arg_freetable(argtable, 6); for(i = 0; i < n; i++) freeState(initialStates[i]); free(initialStates); optimistic_uninitInstance(&optimistic); freeGenerativeModel(); freeGenerativeModelParameters(); return EXIT_SUCCESS; }
int main(int argc, char* argv[]) { #ifdef BALL double discountFactor = 0.9; #else #ifdef CART_POLE double discountFactor = 0.95; #else #ifdef DOUBLE_CART_POLE double discountFactor = 0.95; #else #ifdef MOUNTAIN_CAR double discountFactor = 0.95; #else #ifdef ACROBOT double discountFactor = 0.95; #else #ifdef BOAT double discountFactor = 0.95; #else #ifdef CART_POLE_BINARY double discountFactor = 0.95; #else #ifdef SWIMMER double discountFactor = 0.95; #endif #endif #endif #endif #endif #endif #endif #endif FILE* initFileFd = NULL; state** initialStates = NULL; unsigned int maxDepth = 0; FILE* combinedFd = NULL; FILE* results = NULL; char str[1024]; unsigned int i = 0; unsigned int minDepth = 1; unsigned int crtDepth = 0; unsigned int n = 0; unsigned int maxNbIterations = 0; unsigned int nbSteps = 0; unsigned int timestamp = time(NULL); int readFscanf = -1; optimistic_instance* optimistic = NULL; random_search_instance* random_search = NULL; uct_instance* uct = NULL; uniform_instance* uniform = NULL; struct arg_file* initFile = arg_file1(NULL, "init", "<file>", "File containing the inital state"); struct arg_int* d = arg_int1("d", NULL, "<n>", "Maximum depth of an uniform tree which the number of call per step"); struct arg_int* d2 = arg_int0(NULL, "min", "<n>", "Minimun depth to start from (min > 0)"); struct arg_int* s = arg_int1("s", NULL, "<n>", "Number of steps"); struct arg_int* k = arg_int1("k", NULL, "<n>", "Branching factor of the problem"); struct arg_file* where = arg_file1(NULL, "where", "<file>", "Directory where we save the outputs"); struct arg_end* end = arg_end(7); int nerrors = 0; void* argtable[7]; argtable[0] = initFile; argtable[1] = d2; argtable[2] = d; argtable[3] = s; argtable[4] = k; argtable[5] = where; argtable[6] = end; if(arg_nullcheck(argtable) != 0) { printf("error: insufficient memory\n"); arg_freetable(argtable, 7); return EXIT_FAILURE; } nerrors = arg_parse(argc, argv, argtable); if(nerrors > 0) { printf("%s:", argv[0]); arg_print_syntax(stdout, argtable, "\n"); arg_print_errors(stdout, end, argv[0]); arg_freetable(argtable, 7); return EXIT_FAILURE; } initGenerativeModelParameters(); K = k->ival[0]; initGenerativeModel(); initFileFd = fopen(initFile->filename[0], "r"); readFscanf = fscanf(initFileFd, "%u\n", &n); initialStates = (state**)malloc(sizeof(state*) * n); for(; i < n; i++) { readFscanf = fscanf(initFileFd, "%s\n", str); initialStates[i] = makeState(str); } fclose(initFileFd); if(d2->count) minDepth = d2->ival[0]; maxDepth = d->ival[0]; maxNbIterations = K; nbSteps = s->ival[0]; optimistic = optimistic_initInstance(NULL, discountFactor); random_search = random_search_initInstance(NULL, discountFactor); uct = uct_initInstance(NULL, discountFactor); uniform = uniform_initInstance(NULL, discountFactor); sprintf(str, "%s/%u_results_%u_%u.csv", where->filename[0], timestamp, K, nbSteps); results = fopen(str, "w"); for(crtDepth = 1; crtDepth < minDepth; crtDepth++) maxNbIterations += pow(K, crtDepth+1); for(crtDepth = minDepth; crtDepth <= maxDepth; crtDepth++) { double averages[4] = {0.0, 0.0, 0.0, 0.0}; sprintf(str, "%s/%u_combined_%u_%u(%u)_%u.csv", where->filename[0], timestamp, K, crtDepth, maxNbIterations, nbSteps); combinedFd = fopen(str, "w"); fprintf(combinedFd, "nbIterations,optimistic,optimistic(discounted),optimistic depth,random search,random search(discounted),random search depth,uct,uct(discounted),uct depth,uniform,uniform(discounted),uniform depth\n"); for(i = 0; i < n; i++) { unsigned int j = 0; double sumRewards = 0.0; double discountedSumRewards = 0.0; unsigned int sumDepths = 0; state* crt = copyState(initialStates[i]); optimistic_resetInstance(optimistic, crt); for(; j < nbSteps; j++) { char isTerminal = 0; double reward = 0.0; state* nextState = NULL; optimistic_keepSubtree(optimistic); action* optimalAction = optimistic_planning(optimistic, maxNbIterations); isTerminal = nextStateReward(crt, optimalAction, &nextState, &reward); freeState(crt); crt = nextState; sumRewards += reward; sumDepths += optimistic_getMaxDepth(optimistic); discountedSumRewards += optimistic->gammaPowers[j] * reward; if(isTerminal < 0) break; } optimistic_resetInstance(optimistic, crt); freeState(crt); fprintf(combinedFd, "%u,%.15f,%.15f,%.15f,",maxNbIterations, sumRewards, discountedSumRewards, sumDepths / (double)((j == nbSteps) ? nbSteps : (j + 1))); averages[0] += sumRewards; printf("Optimistic : %uth initial state processed\n", i + 1); sumRewards = 0.0; discountedSumRewards = 0.0; sumDepths = 0; crt = copyState(initialStates[i]); for(j = 0; j < nbSteps; j++) { char isTerminal = 0; double reward = 0.0; state* nextState = NULL; random_search_resetInstance(random_search, crt); action* optimalAction = random_search_planning(random_search, maxNbIterations); isTerminal = nextStateReward(crt, optimalAction, &nextState, &reward); freeState(crt); crt = nextState; sumRewards += reward; sumDepths += random_search_getMaxDepth(random_search); discountedSumRewards += random_search->gammaPowers[j] * reward; if(isTerminal < 0) break; } random_search_resetInstance(random_search, crt); freeState(crt); fprintf(combinedFd, "%.15f,%.15f,%.15f,", sumRewards, discountedSumRewards, sumDepths / (double)((j == nbSteps) ? nbSteps : (j + 1))); averages[1] += sumRewards; printf("Random search: %uth initial state processed\n", i + 1); sumRewards = 0.0; discountedSumRewards = 0.0; sumDepths = 0; crt = copyState(initialStates[i]); uct_resetInstance(uct, crt); for(j = 0; j < nbSteps; j++) { char isTerminal = 0; double reward = 0.0; state* nextState = NULL; uct_keepSubtree(uct); action* optimalAction = uct_planning(uct, maxNbIterations); isTerminal = nextStateReward(crt, optimalAction, &nextState, &reward); freeState(crt); crt = nextState; sumRewards += reward; sumDepths += uct_getMaxDepth(uct); discountedSumRewards += uct->gammaPowers[j] * reward; if(isTerminal < 0) break; } uct_resetInstance(uct, crt); freeState(crt); fprintf(combinedFd, "%.15f,%.15f,%.15f,", sumRewards, discountedSumRewards, sumDepths / (double)((j == nbSteps) ? nbSteps : (j + 1))); averages[2] += sumRewards; printf("Uct : %uth initial state processed\n", i + 1); sumRewards = 0.0; discountedSumRewards = 0.0; crt = copyState(initialStates[i]); uniform_resetInstance(uniform, crt); for(j = 0; j < nbSteps; j++) { char isTerminal = 0; double reward = 0.0; state* nextState = NULL; uniform_keepSubtree(uniform); action* optimalAction = uniform_planning(uniform, maxNbIterations); isTerminal = nextStateReward(crt, optimalAction, &nextState, &reward); freeState(crt); crt = nextState; sumRewards += reward; discountedSumRewards += uniform->gammaPowers[j] * reward; if(isTerminal < 0) break; } uniform_resetInstance(uniform, crt); freeState(crt); fprintf(combinedFd, "%.15f,%.15f,%u\n", sumRewards, discountedSumRewards, crtDepth -1); fflush(combinedFd); averages[3] += sumRewards; printf("Uniform : %uth initial state processed\n", i + 1); printf(">>>>>>>>>>>>>> %uth initial state processed\n", i + 1); } fprintf(results, "%u,%.15f,%.15f,%.15f,%.15f\n", maxNbIterations, averages[0] / (double)n, averages[1] / (double)n, averages[2] / (double)n, averages[3] / (double)n); fflush(results); printf(">>>>>>>>>>>>>> %u depth done\n\n", crtDepth); fclose(combinedFd); maxNbIterations += pow(K, crtDepth+1); } fclose(results); arg_freetable(argtable, 7); for(i = 0; i < n; i++) freeState(initialStates[i]); free(initialStates); optimistic_uninitInstance(&optimistic); random_search_uninitInstance(&random_search); uct_uninitInstance(&uct); uniform_uninitInstance(&uniform); freeGenerativeModel(); freeGenerativeModelParameters(); return EXIT_SUCCESS; }
unsigned int ompl::base::SpaceInformation::getMotionStates(const State *s1, const State *s2, std::vector<State *> &states, unsigned int count, bool endpoints, bool alloc) const { // add 1 to the number of states we want to add between s1 & s2. This gives us the number of segments to split the // motion into count++; if (count < 2) { unsigned int added = 0; // if they want endpoints, then at most endpoints are included if (endpoints) { if (alloc) { states.resize(2); states[0] = allocState(); states[1] = allocState(); } if (states.size() > 0) { copyState(states[0], s1); added++; } if (states.size() > 1) { copyState(states[1], s2); added++; } } else if (alloc) states.resize(0); return added; } if (alloc) { states.resize(count + (endpoints ? 1 : -1)); if (endpoints) states[0] = allocState(); } unsigned int added = 0; if (endpoints && states.size() > 0) { copyState(states[0], s1); added++; } /* find the states in between */ for (unsigned int j = 1; j < count && added < states.size(); ++j) { if (alloc) states[added] = allocState(); stateSpace_->interpolate(s1, s2, (double)j / (double)count, states[added]); added++; } if (added < states.size() && endpoints) { if (alloc) states[added] = allocState(); copyState(states[added], s2); added++; } return added; }
int main(int argc, char* argv[]) { #ifdef BALL double discountFactor = 0.9; #else #ifdef CART_POLE double discountFactor = 0.95; #else #ifdef DOUBLE_CART_POLE double discountFactor = 0.95; #else #ifdef MOUNTAIN_CAR double discountFactor = 0.99; #else #ifdef ACROBOT double discountFactor = 0.95; #else #ifdef BOAT double discountFactor = 0.95; #else #ifdef SWIMMER double discountFactor = 0.95; #endif #endif #endif #endif #endif #endif #endif FILE* initFileFd = NULL; state** initialStates = NULL; FILE* results = NULL; char str[1024]; unsigned int i = 0; unsigned int* ns = NULL; unsigned int nbN = 0; unsigned int* hs = NULL; unsigned int nbH = 0; unsigned int n = 0; unsigned int nbSteps = 0; unsigned int nbIterations = 1; unsigned int timestamp = time(NULL); int readFscanf = -1; random_search_instance* random_search = NULL; struct arg_file* initFile = arg_file1(NULL, "init", "<file>", "File containing the inital state"); struct arg_str* r = arg_str1("n", NULL, "<s>", "List of maximum numbers of evaluations"); struct arg_str* d = arg_str1("h", NULL, "<s>", "List of depth"); struct arg_int* s = arg_int1("s", NULL, "<n>", "Number of steps"); struct arg_int* it = arg_int1("i", NULL, "<n>", "Number of iteration"); struct arg_file* where = arg_file1(NULL, "where", "<file>", "Directory where we save the outputs"); struct arg_end* end = arg_end(7); int nerrors = 0; void* argtable[7]; argtable[0] = initFile; argtable[1] = r; argtable[2] = d; argtable[3] = s; argtable[4] = it; argtable[5] = where; argtable[6] = end; if(arg_nullcheck(argtable) != 0) { printf("error: insufficient memory\n"); arg_freetable(argtable, 7); return EXIT_FAILURE; } nerrors = arg_parse(argc, argv, argtable); if(nerrors > 0) { printf("%s:", argv[0]); arg_print_syntax(stdout, argtable, "\n"); arg_print_errors(stdout, end, argv[0]); arg_freetable(argtable, 7); return EXIT_FAILURE; } initGenerativeModelParameters(); initGenerativeModel(); initFileFd = fopen(initFile->filename[0], "r"); readFscanf = fscanf(initFileFd, "%u\n", &n); initialStates = (state**)malloc(sizeof(state*) * n); for(; i < n; i++) { readFscanf = fscanf(initFileFd, "%s\n", str); initialStates[i] = makeState(str); } fclose(initFileFd); nbSteps = s->ival[0]; nbIterations = it->ival[0]; ns = parseUnsignedIntList((char*)r->sval[0], &nbN); hs = parseUnsignedIntList((char*)d->sval[0], &nbH); random_search = random_search_initInstance(NULL, discountFactor); h_max = h_max_crt_depth; sprintf(str, "%s/%u_results_random_search_%s.csv", where->filename[0], timestamp,(char*)r->sval[0]); results = fopen(str, "w"); for(i = 0; i < nbIterations; i++) { unsigned int j = 0; for(;j < nbH; j++) { unsigned int k = 0; crtDepth = hs[j]; for(; k < nbN; k++) { unsigned int l = 0; double sumRewards = 0.0; for(; l < n; l++) { unsigned int m = 0; state* crt = copyState(initialStates[l]); for(; m < nbSteps; m++) { char isTerminal = 0; double reward = 0.0; state* nextState = NULL; double* optimalAction = NULL; random_search_resetInstance(random_search, crt); optimalAction = random_search_planning(random_search, ns[k]); isTerminal = nextStateReward(crt, optimalAction, &nextState, &reward) < 0 ? 1 : 0; freeState(crt); free(optimalAction); crt = nextState; sumRewards += reward; if(isTerminal) break; } random_search_resetInstance(random_search, crt); freeState(crt); printf(">>>>>>>>>>>>>> %uth initial state processed with h=%u and n=%u of iteration %u\n", l + 1, hs[j], ns[k], i+1); fflush(NULL); } fprintf(results, "%u,%u,%.15f\n", hs[j],ns[k], sumRewards / (double)n); printf(">>>>>>>>>>>>>> n = %u done\n\n", ns[k]); fflush(NULL); } printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> h = %u done \n\n", hs[j]); fflush(NULL); } fprintf(results,"\n"); printf(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ITERATION %u DONE <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n\n\n", i+1); fflush(NULL); } fclose(results); arg_freetable(argtable, 7); for(i = 0; i < n; i++) freeState(initialStates[i]); free(initialStates); random_search_uninitInstance(&random_search); freeGenerativeModel(); freeGenerativeModelParameters(); return EXIT_SUCCESS; }
// Test the discardCard() function // // discardCard(): // Removes card from player's hand and either puts it in the played pile // (if not trashed) or not (if trashed). // // handPos - enumerated card // currentPlayer - the index of the current player // state - holds the game state // trashFlag - determines whether the card is trashed (>= 1) or not (< 1) // // Always returns 0. // int testDiscardCard(int handPos, int currentPlayer, struct gameState *state, int trashFlag) { struct gameState *origState; // copy of game state // Make a copy of the original game state // origState = copyState(state); // Run discardCard() // discardCard(handPos, currentPlayer, state, trashFlag); // If the card was trashed, the card should not be added to the played // card pile and played card count should not increment. Otherwise, // add the card to the played card pile and increment the count. // if(trashFlag >= 1) { if(state->playedCardCount == origState->playedCardCount) { printf("discardCard: PASS trashed card did not increment playedCardCount\n"); } else { printf("discardCard: FAIL trashed card incremented playedCardCount\n"); } } else { // If the card was NOT trashed, the card SHOULD be added to the played // card pile and played card count SHOULD increment // if(state->playedCardCount == origState->playedCardCount + 1) { printf("discardCard: PASS non-trashed card incremented playedCardCount\n"); } else { printf("discardCard: FAIL non-trashed card did not incremenet playedCardCount\n"); } if(state->playedCards[state->playedCardCount-1] == origState->hand[currentPlayer][handPos]) { printf("discardCard: PASS non-trashed card added to played card pile\n"); } else { printf("discardCard: FAIL non-trashed card not added to played card pile\n"); } } // Remove the card from the player's hand // if(handPos == origState->handCount[currentPlayer] - 1) { if(state->handCount[currentPlayer] == origState->handCount[currentPlayer] - 1) { printf("discardCard: PASS card removal decremented current player handcount\n"); } else { printf("discardCard: FAIL card removal did not decrement current player handcount\n"); } } else if(origState->handCount[currentPlayer] == 1) { if(state->handCount[currentPlayer] == origState->handCount[currentPlayer] - 1) { printf("discardCard: PASS card removal decremented current player handcount\n"); } else { printf("discardCard: FAIL card removal did not decrement current player handcount\n"); } } else { // Check if discarded card was replaced with last card in hand // if(state->hand[currentPlayer][handPos] == origState->hand[currentPlayer][(origState->handCount[currentPlayer] - 1)]) { printf("discardCard: PASS discarded card was replaced with last card in hand\n"); } else { printf("discardCard: FAIL discarded card was not replaced with last card in hand\n"); } // Check if last card was set to -1 // if(state->hand[currentPlayer][origState->handCount[currentPlayer] - 1] == -1) { printf("discardCard: PASS last card set to -1\n"); } else { printf("discardCard: FAIL last card not set to -1\n"); } // Check if the number of cards in hand was reduced // if(state->handCount[currentPlayer] == origState->handCount[currentPlayer] - 1) { printf("discardCard: PASS card removal decremented current player handcount\n"); } else { printf("discardCard: FAIL card removal did not decrement current player handcount\n"); } } // Report what, if anything, changed in the game state // whatChanged(origState, state); printf("\n"); return 0; }
int main(){ #if !defined(ONLINE_JUDGE) freopen("246.in","r",stdin); ///freopen("error_input.txt","r",stdin); freopen("output.txt","w",stdout); #endif currentState = getNewState(); initState = getNewState(); twoOfPowerState = getNewState(); int i=0; int topCard=0; while ( scanf("%d",&topCard) != EOF && topCard ){ clearState(¤tState); clearState(&initState); clearState(&twoOfPowerState); currentState.handCard[51] = topCard; for(i=0;i<51;i++){ scanf("%d",¤tState.handCard[50-i]); } currentState.handCardLength =52; currentState.round = 1; /** debugging for round start with 1 **/ for (i=1;i<=14;i++){ /** turn = getWhichTurn( ¤tState); debug for all cardsLength is zero **/ int handCard = currentState.handCard[ (currentState.handCardLength -1) ]; int cardLength = currentState.cardsLength[currentState.whichTurn]; currentState.cards[currentState.whichTurn][ cardLength] =handCard; currentState.handCardLength--; currentState.cardsLength[currentState.whichTurn]++; if ( is2OfPower(i) >0 ){ copyState( &twoOfPowerState , ¤tState); } outputForDebug(¤tState); /** debugging , put on the last part after dispatching card.**/ currentState.whichTurn= (currentState.whichTurn +1 ) % 7; currentState.round ++; /** debugging put it than copyState **/ } copyState(&initState, ¤tState); /** use initSate when try to find loop's location. **/ while (1){ /** for debugging if ( currentState.round == 82 ){ int bbb=1; } **/ dispatchOneCard( ¤tState); darwCardsFromPack( ¤tState); if ( currentState.handCardLength == 52){ printf("Win : %d\n", currentState.round); break; }else if ( currentState.handCardLength ==0 ){ printf("Loss: %d\n", currentState.round); break; }else if (isDraw(¤tState, &twoOfPowerState)>0 ){ int roundLocation = findDrawLocation(); printf("Draw: %d\n", roundLocation); break; } /** debugging, should be put behind isDraw()!! before copying currentState to towOfPowerState, it should be done the isDraw action. **/ if ( is2OfPower(currentState.round ) >0 ){ /**debugging is2OfPower(i) **/ copyState( &twoOfPowerState , ¤tState); } currentState.round++; getWhichTurn( ¤tState ); } } return 0; }
int main(int argc, char* argv[]) { double discountFactor = 0.9; FILE* initFileFd = NULL; double* setPoints = NULL; FILE* results = NULL; char str[1024]; unsigned int i = 0; unsigned int nbSetPoints = 0; unsigned int* ns = NULL; unsigned int nbN = 0; unsigned int* hs = NULL; unsigned int nbH = 0; unsigned int nbSteps = 0; unsigned int timestamp = time(NULL); int readFscanf = -1; struct arg_file* initFile = arg_file1(NULL, "init", "<file>", "File containing the set points"); struct arg_int* s = arg_int1("s", NULL, "<n>", "Number of steps"); struct arg_str* r = arg_str1("n", NULL, "<s>", "List of ressources"); struct arg_str* z = arg_str1("h", NULL, "<s>", "List of length for the sequences"); struct arg_file* where = arg_file1(NULL, "where", "<file>", "Directory where we save the outputs"); struct arg_end* end = arg_end(6); int nerrors = 0; void* argtable[6]; argtable[0] = initFile; argtable[1] = r; argtable[2] = s; argtable[3] = z; argtable[4] = where; argtable[5] = end; if(arg_nullcheck(argtable) != 0) { printf("error: insufficient memory\n"); arg_freetable(argtable, 6); return EXIT_FAILURE; } nerrors = arg_parse(argc, argv, argtable); if(nerrors > 0) { printf("%s:", argv[0]); arg_print_syntax(stdout, argtable, "\n"); arg_print_errors(stdout, end, argv[0]); arg_freetable(argtable, 6); return EXIT_FAILURE; } initGenerativeModelParameters(); initGenerativeModel(); initFileFd = fopen(initFile->filename[0], "r"); readFscanf = fscanf(initFileFd, "%u\n", &nbSetPoints); setPoints = (double*)malloc(sizeof(double) * nbSetPoints); for(; i < nbSetPoints; i++) { readFscanf = fscanf(initFileFd, "%s\n", str); setPoints[i] = strtod(str, NULL); } fclose(initFileFd); nbSteps = s->ival[0]; hs = parseUnsignedIntList((char*)z->sval[0], &nbH); ns = parseUnsignedIntList((char*)r->sval[0], &nbN); sprintf(str, "%s/%u_results_%s_%s.csv", where->filename[0], timestamp, z->sval[0], r->sval[0]); results = fopen(str, "w"); for(i = 0; i < nbN; i++) { /* Loop on the computational ressources */ printf("Starting with %u computational ressources\n", ns[i]); fprintf(results, "%u", ns[i]); fflush(NULL); unsigned int j = 0; for(; j < nbH; j++) { /* Loop on the length of the sequences */ unsigned int k = 0; state* crt1 = initState(); state* crt2 = copyState(crt1); double averages[2] = {0.0,0.0}; for(; k < nbSetPoints; k++) { /* Loop on the initial states */ unsigned int l = 0; parameters[10] = setPoints[k]; for(; l < nbSteps; l++) { /* Loop on the step */ char isTerminal = 0; double reward = 0.0; state* nextState = NULL; sequential_direct_instance* sequential_direct = sequential_direct_initInstance(crt1, discountFactor, hs[j],1); double* optimalAction = sequential_direct_planning(sequential_direct, ns[i]); isTerminal = nextStateReward(crt1, optimalAction, &nextState, &reward) < 0 ? 1 : 0; freeState(crt1); crt1 = nextState; averages[0] += reward; sequential_direct_uninitInstance(&sequential_direct); if(isTerminal) break; } printf("direct: %u set point done for h=%u\n", k, hs[j]); fflush(NULL); for(l = 0; l < nbSteps; l++) { /* Loop on the step */ char isTerminal = 0; double reward = 0.0; state* nextState = NULL; sequential_soo_instance* sequential_soo = sequential_soo_initInstance(crt2, discountFactor, hs[j],1); double* optimalAction = sequential_soo_planning(sequential_soo, ns[i]); isTerminal = nextStateReward(crt2, optimalAction, &nextState, &reward); freeState(crt2); crt2 = nextState; averages[1] += reward; sequential_soo_uninitInstance(&sequential_soo); if(isTerminal) break; } printf("soo: %u set point done for h=%u\n", k, hs[j]); fflush(NULL); } freeState(crt1); freeState(crt2); averages[0] = averages[0] /(double)nbSetPoints; averages[1] = averages[1] /(double)nbSetPoints; printf("Computation with h=%u and n=%u done\n", hs[j], ns[i]); fprintf(results, ",%.15f,%.15f", averages[0],averages[1]); fflush(NULL); } printf("Computation with %u computational ressources done\n\n", ns[i]); fprintf(results, "\n"); fflush(NULL); } fclose(results); arg_freetable(argtable, 6); free(setPoints); freeGenerativeModel(); freeGenerativeModelParameters(); return EXIT_SUCCESS; }
int main(int argc, char* argv[]) { double discountFactor = 0.9; FILE* initFileFd = NULL; double* setPoints = NULL; unsigned int nbSetPoints = 0; unsigned int maxDepth = 0; FILE* results = NULL; char str[1024]; unsigned int i = 0; unsigned int minDepth = 1; unsigned int crtDepth = 0; unsigned int maxNbIterations = 0; unsigned int nbSteps = 0; unsigned int timestamp = time(NULL); int readFscanf = -1; optimistic_instance* optimistic = NULL; random_search_instance* random_search = NULL; uct_instance* uct = NULL; uniform_instance* uniform = NULL; struct arg_file* initFile = arg_file1(NULL, "init", "<file>", "File containing the set points"); struct arg_int* d2 = arg_int0(NULL, "min", "<n>", "Minimum depth to start from (min>0)"); struct arg_int* d = arg_int1("d", NULL, "<n>", "Maximum depth of an uniform tree which the number of call per step"); struct arg_int* s = arg_int1("s", NULL, "<n>", "Number of steps"); struct arg_int* k = arg_int1("k", NULL, "<n>", "Branching factor of the problem"); struct arg_file* where = arg_file1(NULL, "where", "<file>", "Directory where we save the outputs"); struct arg_end* end = arg_end(7); int nerrors = 0; void* argtable[7]; argtable[0] = initFile; argtable[1] = d2; argtable[2] = d; argtable[3] = s; argtable[4] = k; argtable[5] = where; argtable[6] = end; if(arg_nullcheck(argtable) != 0) { printf("error: insufficient memory\n"); arg_freetable(argtable, 7); return EXIT_FAILURE; } nerrors = arg_parse(argc, argv, argtable); if(nerrors > 0) { printf("%s:", argv[0]); arg_print_syntax(stdout, argtable, "\n"); arg_print_errors(stdout, end, argv[0]); arg_freetable(argtable, 7); return EXIT_FAILURE; } initGenerativeModelParameters(); K = k->ival[0]; initGenerativeModel(); initFileFd = fopen(initFile->filename[0], "r"); readFscanf = fscanf(initFileFd, "%u\n", &nbSetPoints); setPoints = (double*)malloc(sizeof(double) * nbSetPoints); for(; i < nbSetPoints; i++) { readFscanf = fscanf(initFileFd, "%s\n", str); setPoints[i] = strtod(str, NULL); } fclose(initFileFd); if(d2->count) minDepth = d2->ival[0]; maxDepth = d->ival[0]; maxNbIterations = K; nbSteps = s->ival[0]; optimistic = optimistic_initInstance(NULL, discountFactor); random_search = random_search_initInstance(NULL, discountFactor); uct = uct_initInstance(NULL, discountFactor); uniform = uniform_initInstance(NULL, discountFactor); sprintf(str, "%s/%u_results_%u_%u.csv", where->filename[0], timestamp, K, nbSteps); results = fopen(str, "w"); for(crtDepth = 1; crtDepth < minDepth; crtDepth++) maxNbIterations += pow(K, crtDepth+1); for(crtDepth = minDepth; crtDepth <= maxDepth; crtDepth++) { double averages[4] = {0.0, 0.0, 0.0, 0.0}; state* crt1 = initState(); state* crt2 = copyState(crt1); state* crt3 = copyState(crt1); state* crt4 = copyState(crt1); optimistic_resetInstance(optimistic, crt1); uct_resetInstance(uct, crt3); uniform_resetInstance(uniform, crt4); for(i = 0; i < nbSetPoints; i++) { unsigned int j = 0; parameters[10] = setPoints[i]; for(; j < nbSteps; j++) { char isTerminal = 0; double reward = 0.0; state* nextState = NULL; optimistic_keepSubtree(optimistic); action* optimalAction = optimistic_planning(optimistic, maxNbIterations); isTerminal = nextStateReward(crt1, optimalAction, &nextState, &reward); freeState(crt1); crt1 = nextState; averages[0] += reward; if(isTerminal < 0) break; } optimistic_resetInstance(optimistic, crt1); printf("Optimistic : %uth set point processed\n", i + 1); for(j = 0; j < nbSteps; j++) { char isTerminal = 0; double reward = 0.0; state* nextState = NULL; random_search_resetInstance(random_search, crt2); action* optimalAction = random_search_planning(random_search, maxNbIterations); isTerminal = nextStateReward(crt2, optimalAction, &nextState, &reward); freeState(crt2); crt2 = nextState; averages[1] += reward; if(isTerminal < 0) break; } random_search_resetInstance(random_search, crt1); printf("Random search: %uth set point processed\n", i + 1); for(j = 0; j < nbSteps; j++) { char isTerminal = 0; double reward = 0.0; state* nextState = NULL; uct_keepSubtree(uct); action* optimalAction = uct_planning(uct, maxNbIterations); isTerminal = nextStateReward(crt3, optimalAction, &nextState, &reward); freeState(crt3); crt3 = nextState; averages[2] += reward; if(isTerminal < 0) break; } uct_resetInstance(uct, crt3); printf("Uct : %uth set point processed\n", i + 1); for(j = 0; j < nbSteps; j++) { char isTerminal = 0; double reward = 0.0; state* nextState = NULL; uniform_keepSubtree(uniform); action* optimalAction = uniform_planning(uniform, maxNbIterations); isTerminal = nextStateReward(crt4, optimalAction, &nextState, &reward); freeState(crt4); crt4 = nextState; averages[3] += reward; if(isTerminal < 0) break; } uniform_resetInstance(uniform, crt4); printf("Uniform : %uth set point processed\n", i + 1); printf(">>>>>>>>>>>>>> %uth set point processed\n", i + 1); } fprintf(results, "%u,%.15f,%.15f,%.15f,%.15f\n", maxNbIterations, averages[0] / (double)nbSetPoints, averages[1] / (double)nbSetPoints, averages[2] / (double)nbSetPoints, averages[3] / (double)nbSetPoints); fflush(results); freeState(crt1); freeState(crt2); freeState(crt3); freeState(crt4); printf(">>>>>>>>>>>>>> %u depth done\n\n", crtDepth); maxNbIterations += pow(K, crtDepth+1); } fclose(results); arg_freetable(argtable, 7); free(setPoints); optimistic_uninitInstance(&optimistic); random_search_uninitInstance(&random_search); uct_uninitInstance(&uct); uniform_uninitInstance(&uniform); freeGenerativeModel(); freeGenerativeModelParameters(); return EXIT_SUCCESS; }
// Test the treasure map card // // NOTE: YOU ADDED A BUG: changed the code that trashes both treasure // cards to no longer trash them (trashFlag changed from 1 to -1). // // From the Dominion Card Game Wiki (dominioncg.wikia.com): // // Trash this and another copy of treasure map from your hand. If you do // trash two treasure maps, gain 4 gold cards, putting them on top of your // deck. // // If you play this and you do not have another treasure map card in your // hand, you gain nothing. Two cards are required to get gold. // // If there aren't enough gold cards left, you gain what you can. // int testTreasureMapCard(struct gameState *state, int handPos, int currentPlayer) { struct gameState *origState; // copy of game state int origNumTreasureMap = 0; int newNumTreasureMap = 0; int newTopGolds = 0; int origTopGolds = 0; int idx; // Make a copy of the original game state // origState = copyState(state); treasureMapCard(state, handPos); for(idx = 0; idx < origState->handCount[currentPlayer]; idx++) { if(origState->hand[currentPlayer][idx] == treasure_map) origNumTreasureMap++; } for(idx = 0; idx < state->handCount[currentPlayer]; idx++) { if(state->hand[currentPlayer][idx] == treasure_map) newNumTreasureMap++; } // See how many cards on top of the original deck were golds (if any) // for(idx = origState->deckCount[currentPlayer]-1; idx > 0 && idx > *(origState->deck[currentPlayer])-5; idx--) { if(origState->deck[currentPlayer][idx] == gold) origTopGolds++; } // See how many cards on top of the new deck are golds (if any) // for(idx = state->deckCount[currentPlayer]-1; idx > 0 && idx > *(state->deck[currentPlayer])-5; idx--) { if(state->deck[currentPlayer][idx] == gold) newTopGolds++; } // See if golds were added correctly // if(origNumTreasureMap >= 2) { // We started with two treasure map cards. See how many were // discarded. // if(origNumTreasureMap - newNumTreasureMap == 2) { // We discarded two treasure map cards. Check golds. // if(newTopGolds == 4 && newTopGolds - origTopGolds == 4) { printf("treasureMapCard: PASS two TMs discarded, four golds added to top of deck\n"); } else { printf("treasureMapCard: FAIL two TMs discarded, four golds not added to top of deck\n"); } } // We did not discard two treasure map cards. Check golds. // if(newTopGolds == 4 && newTopGolds - origTopGolds == 4) { printf("treasureMapCard: FAIL did not discard two TMs, four golds added to top of deck\n"); } else { printf("treasureMapCard: PASS did not discard two TMs, golds not added to top of deck\n"); } } else { // We started with one treasure map card. Discarding it does // nothing but discard a card. Check to make sure no golds were // added to the top of the deck. // if(newTopGolds == 4 && newTopGolds - origTopGolds == 4) { printf("treasureMapCard: FAIL did not discard two TMs, four golds added to top of deck\n"); } else { printf("treasureMapCard: PASS did not discard two TMs, golds not added to top of deck\n"); } } // Report what, if anything, changed in the game state // whatChanged(origState, state); printf("\n"); return 0; }
int main(int argc, char* argv[]) { #ifdef BALL double discountFactor = 0.9; #else #ifdef CART_POLE double discountFactor = 0.95; #else #ifdef DOUBLE_CART_POLE double discountFactor = 0.95; #else #ifdef MOUNTAIN_CAR double discountFactor = 0.99; #else #ifdef ACROBOT double discountFactor = 0.95; #else #ifdef BOAT double discountFactor = 0.95; #else #ifdef SWIMMER double discountFactor = 0.95; #endif #endif #endif #endif #endif #endif #endif FILE* initFileFd = NULL; state** initialStates = NULL; FILE* results = NULL; char str[1024]; unsigned int i = 0; unsigned int nbInitialStates = 0; unsigned int* ns = NULL; unsigned int nbN = 0; double* Ls = NULL; unsigned int nbL = 0; unsigned int nbSteps = 0; unsigned int timestamp = time(NULL); int readFscanf = -1; lipschitzian_instance* lipschitzian = NULL; struct arg_file* initFile = arg_file1(NULL, "init", "<file>", "File containing the inital state"); struct arg_int* s = arg_int1("s", NULL, "<n>", "Number of steps"); struct arg_str* r = arg_str1("n", NULL, "<s>", "List of ressources"); struct arg_str* z = arg_str1("L", NULL, "<s>", "List of Lipschitz coefficients to try"); struct arg_file* where = arg_file1(NULL, "where", "<file>", "Directory where we save the outputs"); struct arg_end* end = arg_end(6); int nerrors = 0; void* argtable[6]; argtable[0] = initFile; argtable[1] = r; argtable[2] = s; argtable[3] = z; argtable[4] = where; argtable[5] = end; if(arg_nullcheck(argtable) != 0) { printf("error: insufficient memory\n"); arg_freetable(argtable, 6); return EXIT_FAILURE; } nerrors = arg_parse(argc, argv, argtable); if(nerrors > 0) { printf("%s:", argv[0]); arg_print_syntax(stdout, argtable, "\n"); arg_print_errors(stdout, end, argv[0]); arg_freetable(argtable, 6); return EXIT_FAILURE; } initGenerativeModelParameters(); initGenerativeModel(); initFileFd = fopen(initFile->filename[0], "r"); readFscanf = fscanf(initFileFd, "%u\n", &nbInitialStates); initialStates = (state**)malloc(sizeof(state*) * nbInitialStates); for(; i < nbInitialStates; i++) { readFscanf = fscanf(initFileFd, "%s\n", str); initialStates[i] = makeState(str); } fclose(initFileFd); nbSteps = s->ival[0]; Ls = parseDoubleList((char*)z->sval[0], &nbL); ns = parseUnsignedIntList((char*)r->sval[0], &nbN); sprintf(str, "%s/%u_results_%s_%s.csv", where->filename[0], timestamp, z->sval[0], r->sval[0]); results = fopen(str, "w"); lipschitzian = lipschitzian_initInstance(NULL, discountFactor, 0.0); for(i = 0; i < nbN; i++) { /* Loop on the computational ressources */ fprintf(results, "%u", ns[i]); printf("Starting with %u computational ressources\n", ns[i]); fflush(NULL); unsigned int j = 0; for(; j < nbL; j++) { /* Loop on the Lispchitz constant */ unsigned int k = 0; double average = 0.0; lipschitzian->L = Ls[j]; for(; k < nbInitialStates; k++) { /* Loop on the initial states */ unsigned int l = 0; double sumRewards = 0.0; state* crt = copyState(initialStates[k]); lipschitzian_resetInstance(lipschitzian, crt); for(; l < nbSteps; l++) { /* Loop on the step */ char isTerminal = 0; double reward = 0.0; state* nextState = NULL; double* optimalAction = lipschitzian_planning(lipschitzian, ns[i]); isTerminal = nextStateReward(crt, optimalAction, &nextState, &reward) < 0 ? 1 : 0; free(optimalAction); freeState(crt); crt = nextState; sumRewards += reward; lipschitzian_resetInstance(lipschitzian,crt); if(isTerminal) break; } average += sumRewards; freeState(crt); printf("Computation of the %u initial state done with L=%f\n", k, Ls[j]); fflush(NULL); } average = average /(double)nbInitialStates; fprintf(results, ",%.15f", average); printf("Computation with L=%f and n=%u done\n", Ls[j], ns[i]); fflush(NULL); } fprintf(results,"\n"); printf("Computation with %u computational ressources done\n\n", ns[i]); fflush(NULL); } fclose(results); arg_freetable(argtable, 6); for(i = 0; i < nbInitialStates; i++) freeState(initialStates[i]); free(initialStates); lipschitzian_uninitInstance(&lipschitzian); free(ns); free(Ls); freeGenerativeModel(); freeGenerativeModelParameters(); return EXIT_SUCCESS; }
void copyState( ESMoL::State inputState, ESMoL::State outputState ) { UdmEngine::copyState( inputState, outputState ); TransStartVector transStartVector = inputState.TransStart_kind_children(); for( TransStartVector::iterator tsvItr = transStartVector.begin() ; tsvItr != transStartVector.end() ; ++tsvItr ) { ESMoL::TransStart inputTransStart = *tsvItr; ESMoL::TransStart outputTransStart = ESMoL::TransStart::Create( outputState ); getTransConnectorMap().insert( std::make_pair( inputTransStart, outputTransStart ) ); } DataVector dataVector = inputState.Data_kind_children(); for( DataVector::iterator dtvItr = dataVector.begin() ; dtvItr != dataVector.end() ; ++dtvItr ) { copyData( *dtvItr, ESMoL::Data::Create( outputState ) ); } EventVector eventVector = inputState.Event_kind_children(); for( EventVector::iterator envItr = eventVector.begin() ; envItr != eventVector.end() ; ++envItr ) { copyEvent( *envItr, ESMoL::Event::Create( outputState ) ); } JunctionVector junctionVector = inputState.Junction_kind_children(); for( JunctionVector::iterator jnvItr = junctionVector.begin() ; jnvItr != junctionVector.end() ; ++jnvItr ) { ESMoL::Junction inputJunction = *jnvItr; ESMoL::Junction outputJunction = ESMoL::Junction::Create( outputState ); getTransConnectorMap().insert( std::make_pair( inputJunction, outputJunction ) ); } StateVector stateVector = inputState.State_kind_children(); for( StateVector::iterator stvItr = stateVector.begin() ; stvItr != stateVector.end() ; ++stvItr ) { ESMoL::State inputSubState = *stvItr; ESMoL::State outputSubState = ESMoL::State::Create( outputState ); getTransConnectorMap().insert( std::make_pair( inputSubState, outputSubState ) ); copyState( inputSubState, outputSubState ); } ConnectorRefVector connectorRefVector = inputState.ConnectorRef_kind_children(); for( ConnectorRefVector::iterator jnvItr = connectorRefVector.begin() ; jnvItr != connectorRefVector.end() ; ++jnvItr ) { ESMoL::ConnectorRef inputConnectorRef = *jnvItr; ESMoL::ConnectorRef outputConnectorRef = ESMoL::ConnectorRef::Create( outputState ); getTransConnectorMap().insert( std::make_pair( inputConnectorRef, outputConnectorRef ) ); getConnectorRefList().push_back( inputConnectorRef ); } TransitionVector transitionVector = inputState.Transition_kind_children(); for( TransitionVector::iterator trvItr = transitionVector.begin() ; trvItr != transitionVector.end() ; ++trvItr ) { ESMoL::Transition inputTransition = *trvItr; ESMoL::TransConnector inputSrcTransConnector = inputTransition.srcTransition_end(); TransConnectorMap::iterator tcmItr = getTransConnectorMap().find( inputSrcTransConnector ); if ( tcmItr == getTransConnectorMap().end() ) { std::cerr << "WARNING: transconnector does not map to copy" << std::endl; continue; } ESMoL::TransConnector outputSrcTransConnector = tcmItr->second; ESMoL::TransConnector inputDstTransConnector = inputTransition.dstTransition_end(); tcmItr = getTransConnectorMap().find( inputDstTransConnector ); if ( tcmItr == getTransConnectorMap().end() ) { std::cerr << "WARNING: transconnector does not map to copy" << std::endl; continue; } ESMoL::TransConnector outputDstTransConnector = tcmItr->second; ESMoL::Transition outputTransition = ESMoL::Transition::Create( outputState ); UdmEngine::copyTransition( inputTransition, outputTransition ); outputTransition.srcTransition_end() = outputSrcTransConnector; outputTransition.dstTransition_end() = outputDstTransConnector; } }