void System::spawnWave() { if(wave == 10) { std::cout << "Game completed" << std::endl; } wave++; double dAngle = 2 * M_PI / wave; double angle = 0.001; std::default_random_engine generator; generator.seed(wave); auto distribution = std::uniform_int_distribution<int>(0,1000); auto angleDist = std::uniform_real_distribution<double>(0.0015,0.005); std::function<double()> randGen = std::bind ( distribution, generator ); while(angle < 2*M_PI) { ships.emplace_back(Tuple(cos(angle) * killRadius/2,sin(angle) * killRadius / 2), randGen() / 5+10,randGen() /20 + 10, randGen()/70 + 15,randGen()/7 + 150 ,angleDist(generator) ); angle += dAngle; } if(wave > 3) for(auto &ship : ships) ship.cannibalizeWeapon(Crate::generateWeapon()); if(wave > 5) for(int i = wave; i > 5; i--) ships[4].cannibalizeWeapon(Crate::generateWeapon()); }
// Thread methods void Scan( BufferManager* bm, uint32_t pagesOnDisk, bool& stop, uint32_t& fails ) { // Construct a random device to seed the random generator with true random numbers std::random_device rd; std::minstd_rand randGen( rd() ); // scan all pages and check if the counters are not decreasing std::vector<uint32_t> counters( pagesOnDisk, 0 ); while ( !stop ) { uint32_t start = randGen() % (pagesOnDisk - 10); for ( uint32_t page = start; page < start + 10; page++ ) { BufferFrame& bf = bm->FixPage( BufferManager::MergePageId( DB_TEST_SEGMENT, page), false ); uint32_t newcount = reinterpret_cast<uint32_t*>(bf.GetData())[0]; if (newcount < counters[page]) { ++fails; } counters[page] = newcount; bm->UnfixPage( bf, false ); } } }
uint32_t ReadWrite( BufferManager* bm, uint32_t threadNum, uint32_t threadCount, uint32_t pagesOnDisk ) { // Construct a random device to seed the random generator with true random numbers std::random_device rd; std::minstd_rand randGen( rd() ); std::normal_distribution<float> normalDist(0.0f, 0.2f); uint32_t count = 0; for ( uint32_t i = 0; i < 100000 / threadCount; i++ ) { bool isWrite = randGen() % 128 < 10; BufferFrame& bf = bm->FixPage( BufferManager::MergePageId( DB_TEST_SEGMENT, RandomPage( normalDist( randGen ), pagesOnDisk ) ), isWrite ); if ( isWrite ) { ++count; reinterpret_cast<uint32_t*>(bf.GetData())[0]++; } bm->UnfixPage( bf, isWrite ); } return count; }
Challenge::Challenge(uint32_t challengeSeqNum, UserNumber_t num, HMACAlgorithm algorithm, ChallengeReason reason) : seqNum(challengeSeqNum), userNum(num), hmacAlgorithm(algorithm), challengeReason(reason) { randGen(challengeData, MIN_CHALLENGE_SIZE); }
void OPTICSFilter::extractDBSCANClustering(const std::string& seedString) { std::vector<OPTICSObject_Ptr> currentCluster; // needed for use of uniform dist typedef std::mt19937_64 RNG; std::seed_seq seed(seedString.begin(), seedString.end()); std::unique_ptr<RNG> randGen(new RNG); randGen->seed(seed); // we start with cluster 1 and use 0 as noise int clusterID = 1; for (OPTICSObject_Ptr& obj : _orderedObjects) { if (obj->reachabilityDistance > _epsDBSCAN) { if (obj->coreDistance <= _epsDBSCAN) { // get random obj from currentCluster and append to locations if (currentCluster.empty() == false) { std::uniform_int_distribution<int> elemDist(0, currentCluster.size() - 1); OPTICSObject_Ptr randObj = currentCluster.at(elemDist(*randGen)); _locations->push_back(randObj->node); } currentCluster.clear(); clusterID++; obj->clusterId = clusterID; currentCluster.push_back(obj); } else { obj->clusterId = 0; // noise _locations->push_back(obj->node); } } else { obj->clusterId = clusterID; currentCluster.push_back(obj); } } }
void Solver::findPossibleSlots( const int box, std::vector<std::stack<std::pair<int,int>>>& backTrackStack, const int num) { int highestRow = (box/3)*3; //Row of upper-left box int highestCol = (box%3)*3; //Column of upper-left box std::vector<std::pair<int,int>> shuffleVec; /* Reversed the order so first item on stack is the upper-leftmost slot */ for(int rowIter = 2; rowIter >= 0; --rowIter) { for(int colIter = 2; colIter >= 0; --colIter) { bool existsRow = checkRow(highestRow + rowIter, num); bool existsCol = checkColumn(highestCol + colIter, num); if(!existsRow && !existsCol) { shuffleVec.push_back(std::make_pair(rowIter,colIter)); #ifdef DEBUG std::cout << "Adding possible slot " << rowIter << "," << colIter << " for " << num << std::endl; #endif } else if(existsRow) break; else continue; } } std::random_device seedGen; std::mt19937 randGen(seedGen()); std::shuffle(shuffleVec.begin(), shuffleVec.end(), randGen); for(auto p : shuffleVec) backTrackStack[num-1].push(p); }
//+--------------------------------------------------------------------------+ //| From PFOperatorMaterialStaticState::IPFActionState | //+--------------------------------------------------------------------------+ IOResult PFOperatorMaterialStaticState::Save(ISave* isave) const { ULONG nb; IOResult res; isave->BeginChunk(IPFActionState::kChunkActionHandle); ULONG handle = actionHandle(); if ((res = isave->Write(&handle, sizeof(ULONG), &nb)) != IO_OK) return res; isave->EndChunk(); isave->BeginChunk(IPFActionState::kChunkRandGen); if ((res = isave->Write(randGen(), sizeof(RandGenerator), &nb)) != IO_OK) return res; isave->EndChunk(); isave->BeginChunk(IPFActionState::kChunkData); float offset = cycleOffset(); if ((res = isave->Write(&offset, sizeof(float), &nb)) != IO_OK) return res; isave->EndChunk(); isave->BeginChunk(IPFActionState::kChunkData2); TimeValue time = offsetTime(); if ((res = isave->Write(&time, sizeof(TimeValue), &nb)) != IO_OK) return res; isave->EndChunk(); return IO_OK; }
int main(int argc, char *argv[]){ // too many or not enough if(argc < 2 || argc > 2){ printf("usage:\n\tkeygen [keyLength] //keyLength required\n"); exit(0); } // bad number else if(atoi(argv[1]) < 1){ printf("usage:\n\tkeygen [keyLength] //keyLength must be > 0\n"); exit(1); } // just right else { int keysize = atoi((argv[1])); srand(time(NULL)); int i; for(i = 0; i < keysize; i++){ printf("%c", convertNumeric(randGen())); } printf("\n"); return 0; } }
//================================================================== void HiderSampleCoordsBuffer::Init( u_int wd, u_int he, u_int subPixelDimLog2 ) { mWd = wd; mHe = he; mSubPixelDimLog2 = subPixelDimLog2; u_int sampsPerPixel = 1 << (subPixelDimLog2*2); size_t sampArrSize = (size_t)mWd * (size_t)mHe * sampsPerPixel; mpSampCoords = DNEW HiderSampleCoords [ sampArrSize ]; mpBaseSampCoords = DNEW HiderBaseSampleCoords [ sampArrSize ]; DUT::RandMT randGen( (U32)0x11112222 ); size_t sampsCnt = 0; for (u_int y=0; y < mHe; ++y) { for (u_int x=0; x < mWd; ++x, sampsCnt += sampsPerPixel) { initPixel( mpSampCoords + sampsCnt, mpBaseSampCoords + sampsCnt, subPixelDimLog2, randGen ); } } }
//+--------------------------------------------------------------------------+ //| From PFTestSplitByAmountState::IPFActionState | //+--------------------------------------------------------------------------+ IOResult PFTestSplitByAmountState::Save(ISave* isave) const { ULONG nb; IOResult res; isave->BeginChunk(IPFActionState::kChunkActionHandle); ULONG handle = actionHandle(); if ((res = isave->Write(&handle, sizeof(ULONG), &nb)) != IO_OK) return res; isave->EndChunk(); isave->BeginChunk(IPFActionState::kChunkRandGen); if ((res = isave->Write(randGen(), sizeof(RandGenerator), &nb)) != IO_OK) return res; isave->EndChunk(); isave->BeginChunk(IPFActionState::kChunkData); int wT = wentThru(); if ((res = isave->Write(&wT, sizeof(int), &nb)) != IO_OK) return res; isave->EndChunk(); isave->BeginChunk(IPFActionState::kChunkData2); int wTA = wentThruAccum(); if ((res = isave->Write(&wTA, sizeof(int), &nb)) != IO_OK) return res; isave->EndChunk(); isave->BeginChunk(IPFActionState::kChunkData3); int wTT = wentThruTotal(); if ((res = isave->Write(&wTT, sizeof(int), &nb)) != IO_OK) return res; isave->EndChunk(); return IO_OK; }
/* Random Sleep Number */ int randSleep() { int factor = 100000; int sleep_time = 1; while (factor != 1) { sleep_time += factor * (randGen() - 1); factor /= 10; } return sleep_time; }
int main() { cout << "Beginning random number test. No news is good news" << endl; // Test UniformInt32, the basic generator method cout << std::setbase(16); JKLRand randGen( jKLInt32List[0] ); JIndex i = 1; while (jKLInt32List[i] != 0) { JInt32 thisVal = randGen.UniformInt32(); if (jKLInt32List[i] != thisVal) { cout << " UniformInt32 failed on test value " << i << "; generated " << thisVal << " instead of " << jKLInt32List[i] << endl; } i++; } // Tests UniformClosedProb as well. cout << std::setbase(10); randGen.SetSeed( jKLLongList[0] ); i=1; while (jKLLongList[i] != 0) { long thisVal = randGen.UniformLong(0, 10000); if (jKLLongList[i] != thisVal) { cout << " UniformLong failed on test value " << i << "; generated " << thisVal << " instead of " << jKLLongList[i] << endl; } i++; } for (i=1;i<=1000000;i++) { double thisVal = randGen.UniformClosedProb(); if (thisVal < 0.0 || thisVal > 1.0) { cout << " UniformClosedProb returned " << thisVal; } } for (i=1;i<=1000000;i++) { double thisVal = randGen.UniformDouble(-100.0, 100.0); if (thisVal < -100.0 || thisVal > 100.0) { cout << " UniformDouble(-100.0, 100.0) returned " << thisVal; } } cout << "Finished random number test. If nothing printed out, it passed" << endl; return 0; }
vector<int> CountMin::returnHashFunctionsOfString(std::string word){ // First we hash the string to generate seeds for a random number generator boost::hash<std::string> string_hash; boost::mt19937 randGen(string_hash(word)); boost::uniform_int<> numrange(0, NUM_BINS-1); boost::variate_generator< boost::mt19937&, boost::uniform_int<> > GetRand(randGen, numrange); vector<int> hashes; for(int i =0;i<NUM_HASH;i++){ hashes.push_back(GetRand()); } return hashes; }
NTL::ZZ_pX YASHE::randomKeyPoly() { NTL::ZZ_pX output; output.SetLength(maxDegree + 1); for (long i = 0; i <= maxDegree; i++) { long choice = (randGen() % 3); choice -= 1; // choice is in {-1, 0, 1} output[i] = NTL::ZZ_p(choice); } return output; }
//+--------------------------------------------------------------------------+ //| From PFOperatorMaterialFrequencyState::IPFActionState | //+--------------------------------------------------------------------------+ IOResult PFOperatorMaterialFrequencyState::Save(ISave* isave) const { ULONG nb; IOResult res; isave->BeginChunk(IPFActionState::kChunkActionHandle); ULONG handle = actionHandle(); if ((res = isave->Write(&handle, sizeof(ULONG), &nb)) != IO_OK) return res; isave->EndChunk(); isave->BeginChunk(IPFActionState::kChunkRandGen); if ((res = isave->Write(randGen(), sizeof(RandGenerator), &nb)) != IO_OK) return res; isave->EndChunk(); return IO_OK; }
void Solver::solveSemiSeed(const int semiSeed) { /* Create RNG */ std::random_device seedGen; std::mt19937 randGen(seedGen()); /* Generate semiSeed first */ int highestRow = (semiSeed/3)*3; //Row of upper-left box int highestCol = (semiSeed%3)*3; //Column of upper-left box std::array<int, 9> nums = {1,2,3,4,5,6,7,8,9}; std::shuffle(nums.begin(), nums.end(), randGen); #ifdef DEBUG std::cout << "nums:" << std::endl; for(auto e : nums) std::cout << e << " "; std::cout << std::endl; #endif for(int valIter = 0; valIter < 9; valIter++) { for(int boxIter = 0; boxIter < 9; boxIter++) { int currentRow = highestRow+boxIter/3; int currentCol = highestCol+boxIter%3; bool rowExists = checkRow(currentRow,nums[valIter]); bool colExists = checkColumn(currentCol,nums[valIter]); if(!rowExists && !colExists) { if( !sudokuBoard[semiSeed].addNumber( boxIter/3, boxIter%3, nums[valIter]) ) { #ifdef DEBUG std::cout << "Did not add " << nums[valIter] << " to semiSeed at " << boxIter/3 << "," << boxIter%3 << std::endl; #endif } else break; } else if(rowExists) boxIter+=2; else continue; } } #ifdef DEBUG std::cout << "semiSeed values:" << std::endl; sudokuBoard[semiSeed].debugPrint(); #endif }
void NodeImporter::importCities(const std::string& seedString) { /* READ CITY POSITIONS ON EARTH SURFACE */ Config_Ptr config(new Config); Config_Ptr cityFilterConfig(config->subConfig("cityfilter")); int populationThreshold = cityFilterConfig->get<int>("citysizethreshold"); auto lr = std::make_shared<SQLiteLocationReader>(_dbFilename, populationThreshold); typedef std::map<std::string, std::vector<CityNode>> CountryMap; std::unique_ptr<CountryMap> countries(new CountryMap); while (lr->hasNext()) { CityNode next = lr->getNext(); (*countries)[next.country()].push_back(next); } std::unique_ptr<InternetUsageStatistics> stat(new InternetUsageStatistics(_dbFilename)); typedef std::mt19937_64 RNG; std::seed_seq seed(seedString.begin(), seedString.end()); std::unique_ptr<RNG> randGen(new RNG); randGen->seed(seed); std::uniform_real_distribution<double> dist(0.0, 1.0); // filter cities for (auto country : *countries) { std::string countryName = country.first; auto& cityVec = country.second; double percentInetUsers = (*stat)[countryName] / 100.0; for (auto city : cityVec) if (dist(*randGen) <= percentInetUsers) { city.setId(_nodenumber); ++_nodenumber; GeographicNode_Ptr np(new CityNode(city)); addNode(np); } } }
/* Producer Thread */ void * T1(void *t) { printf("Producer Started\n"); struct LList *ll = (struct LList*) t; int value; while (!done) { usleep(randSleep()); pthread_mutex_lock(&count_mutex); if (size == 10) { printf("Queue is full\n"); } else { /* Add to Queue */ value = randGen(); AddEntry(ll, value); size++; printf("Producer added %d to queue, size = %d\n", value, size); /* Wake up Threads and Mutex Locks */ pthread_cond_broadcast(&count_cond); } pthread_mutex_unlock(&count_mutex); } pthread_exit(NULL); }
float GenFloatRandom(float fMin, float fMax) { static boost::random::mt19937 rng((uint32_t)std::time(0)); boost::random::uniform_real_distribution<> randGen(fMin, fMax); return randGen(rng); }
// perform classification in separate threads void Classifier::runThread(FastaReader &reader) { DnaSequence seq; boost::mt19937 randGen(0); RandomGen generator(randGen); while(seq = reader.readSequence()) { // reproducible randomness randGen.seed(reader.numRead()); // get a query sequence and convert to kmers KmerSequence fwdSeq = kmerizer_.kmerize(seq); // and the reverse complement KmerSequence revSeq = kmerizer_.revComp(fwdSeq); // search against database using both forward and reverse sequences searchHit fwdHit = referenceData_.search(fwdSeq); searchHit revHit = referenceData_.search(revSeq); // use the direction which gave the highest scoring hit KmerSequence &querySeq = fwdHit.score > revHit.score ? fwdSeq : revSeq; searchHit &hit = fwdHit.score > revHit.score ? fwdHit : revHit; std::vector<float> bootstraps(referenceData_.numLevels(), 0.f); std::vector<std::string> annotations(referenceData_.numLevels(), "AMBIGUOUS"); // make each level annotations into a list of uniques for (unsigned int i=0; i< hit.annotationIds.size(); i++) { std::sort(hit.annotationIds[i].begin(), hit.annotationIds[i].end()); std::vector<unsigned int>::iterator it; it = std::unique(hit.annotationIds[i].begin(), hit.annotationIds[i].end()); hit.annotationIds[i].resize(std::distance(hit.annotationIds[i].begin(), it)); if (hit.annotationIds[i].size() == 1) annotations[i] = referenceData_.annotationFromId(*hit.annotationIds[i].begin()); } // bootstrap if(numBootstrap_ > 0) bootstraps = getBootstrap(querySeq, generator, hit); // output std::stringstream s; s << std::setprecision(2) << std::fixed; s << querySeq.header.substr(0, querySeq.header.find("\t")) << "\t"; s << hit.score << "\t"; //for(unsigned int i=0; i<bootstraps.size(); i++) unsigned int i=bootstraps.size(); while(i--) { s << annotations[i] << "\t"; s << bootstraps[i]; if(i>0) { s << "\t"; } else { // dump ambiguous species if (hit.annotationIds[i].size() > 1 && outputAmbiguous_) { s << "\t"; for(std::vector<unsigned int>::iterator it = hit.annotationIds[i].begin(); it != hit.annotationIds[i].end(); ++it) { if (it != hit.annotationIds[i].begin()) s << ","; s << referenceData_.annotationFromId(*it); } } s << std::endl; } } boost::mutex::scoped_lock lock(mutex_); std::cout << s.str(); } }
bool Solver::solve(const int box) { /* Create RNG */ std::random_device seedGen; std::mt19937 randGen(seedGen()); std::array<int, 9> nums = {1,2,3,4,5,6,7,8,9}; std::shuffle(nums.begin(), nums.end(), randGen); bool isSolved = true; #ifdef DEBUG std::cout << "solve2() random array" << std::endl; for(auto e : nums) std::cout << e << " "; std::cout << std::endl; #endif /* Create backtrack stack */ std::vector<std::stack<std::pair<int,int>>> backTrackStack(9); /* Find possible slots for each value */ for(int number = 1; number <= 9; ++number) findPossibleSlots(box, backTrackStack, number); for(int numsIter = 0; numsIter < 9; ++numsIter) { int number = nums[numsIter]-1; if(backTrackStack[number].empty()) { #ifdef DEBUG std::cout << "Empty at " << number+1 << std::endl; #endif findPossibleSlots(box, backTrackStack, number+1); numsIter--; if(numsIter == -1) { #ifdef DEBUG std::cout << "No solution possible for box " << box << std::endl; #endif isSolved = false; break; } number = nums[numsIter]-1; //Since numsIter is already decremented auto slot = backTrackStack[number].top(); int row = std::get<0>(slot); int col = std::get<1>(slot); sudokuBoard[box].removeNumber(row,col,number+1); backTrackStack[number].pop(); numsIter--; //Decrement even further continue; } auto slot = backTrackStack[number].top(); int row = std::get<0>(slot); int col = std::get<1>(slot); #ifdef DEBUG1 std::cout << "Adding " << number+1 << " at " << row << "," << col << std::endl; #endif if(!sudokuBoard[box].addNumber(row, col, number+1)) { #ifdef DEBUG1 std::cout << "Rejected " << number+1 << " at " << row << "," << col << std::endl; #endif /* Remove invalid slots */ backTrackStack[number].pop(); numsIter--; if(backTrackStack[number].empty()) { #ifdef DEBUG std::cout << "Empty at " << number+1 << std::endl; #endif findPossibleSlots(box, backTrackStack, number+1); number = nums[numsIter]-1; //Since numsIter is already decremented slot = backTrackStack[number].top(); row = std::get<0>(slot); col = std::get<1>(slot); sudokuBoard[box].removeNumber(row,col,number+1); backTrackStack[number].pop(); numsIter--; //Decrement even further if(numsIter <= -1) { #ifdef DEBUG std::cout << "No solution possible for box " << box << std::endl; #endif isSolved = false; break; } } } #ifdef DEBUG1 else std::cout << "Added!" << std::endl; #endif } //End of for-loop return isSolved; }
void fi::VPDetectionCloud::ClusterKDirectionPatches(const pcl::PointCloud<pcl::PointXYZ>::Ptr &_InCloud, Eigen::VectorXf &fRobustEstimatedVP) { unsigned int fNumOfNormals = _InCloud->points.size() * m_ModelParams->fPercentageOfNormals / 100; unsigned int fNumOfCrossProducts = m_ModelParams->fNumOfCrossProducts; unsigned int fNumberOfRansacIterations = m_ModelParams->fNumOfIterations; unsigned int m_k = m_ModelParams->m_k; if ( m_k == 0) { m_k = 5; } double fEPS = m_ModelParams->fEPSInDegrees; Eigen::Vector4f fEstimatedVP1; //// Create the normal estimation class, and pass the input dataset to it //pcl::NormalEstimation<pcl::PointXYZ, pcl::Normal> normal_estimation; //normal_estimation.setInputCloud (cloud); //// Create an empty kdtree representation, and pass it to the normal estimation object. //// Its content will be filled inside the object, based on the given input dataset (as no other search surface is given). //pcl::search::KdTree<pcl::PointXYZ>::Ptr tree (new pcl::search::KdTree<pcl::PointXYZ>); //normal_estimation.setSearchMethod (tree); //// Output datasets //pcl::PointCloud<pcl::Normal>::Ptr cloud_normals (new pcl::PointCloud<pcl::Normal>); //PtCloudDataPtr InPclDataPtr1(new PtCloudData()); ///*pcl::PointCloud<pcl::PointXYZ>::Ptr cloud(pclData);*/ //boost::shared_ptr<PtCloudData> InPclDataPtr(new PtCloudData(pclData)); int nPointCandidates = _InCloud->points.size(); // Consider using more precise timers such as gettimeofday on *nix or // GetTickCount/timeGetTime/QueryPerformanceCounter on Windows. boost::mt19937 randGen(std::time(0)); // Now we set up a distribution. Boost provides a bunch of these as well. // This is the preferred way to generate numbers in a certain range. // initialize a uniform distribution between 0 and the max=nPointCandidates boost::uniform_int<> uInt8Dist(0, nPointCandidates); // Finally, declare a variate_generator which maps the random number // generator and the distribution together. This variate_generator // is usable like a function call. boost::variate_generator< boost::mt19937&, boost::uniform_int<> > GetRand(randGen, uInt8Dist); //sample random points and compute their normals pcl::IndicesPtr indices(new std::vector<int>()); for (unsigned int i = 0; i < fNumOfNormals; i++) { indices->push_back(GetRand() % nPointCandidates); } /*pcl::NormalEstimationOMP fd;*/ // 6-8 times faster ? pcl::NormalEstimation<pcl::PointXYZ, pcl::Normal> ne; ne.setInputCloud (_InCloud); ne.setSearchMethod (pcl::search::KdTree<pcl::PointXYZ>::Ptr (new pcl::search::KdTree<pcl::PointXYZ>)); ne.setKSearch (m_k); //ne.setRadiusSearch (fRadius); //////toDo Set Cloud and radius hier correctly! //ne.setSearchSurface(source.surface); ne.setIndices(indices); pcl::PointCloud<pcl::Normal>::Ptr normals(new pcl::PointCloud<pcl::Normal>()); ne.compute (*normals); //typedef boost::scoped_ptr<Eigen::Vector4f> fXProds; std::vector<boost::shared_ptr<Eigen::Vector4f> > fVPHypothesis; std::vector<boost::shared_ptr<Eigen::Vector4f> > fVPHypothesisInliers; //sample random points and compute their normals for (unsigned int i = 0; i < fNumOfCrossProducts; i++) { unsigned int fIndexA = GetRand() % fNumOfNormals; unsigned int fIndexB = GetRand() % fNumOfNormals; pcl::Normal &fnormalA = normals->points.at(fIndexA); pcl::Normal &fnormalB = normals->points.at(fIndexB); Eigen::Vector4f fA(fnormalA.normal_x, fnormalA.normal_y, fnormalA.normal_z, 0); Eigen::Vector4f fB(fnormalB.normal_x, fnormalB.normal_y, fnormalB.normal_z, 0); Eigen::Vector4f fC = fA.cross3(fB); boost::shared_ptr<Eigen::Vector4f> ftmpRes(new Eigen::Vector4f(fC)); /*fXProds faVPHypothesis(new Eigen::Vector4f(fC));*/ fVPHypothesis.push_back(ftmpRes); //tmpdistances = sqrt ((line_pt - fPlaneB->points[j].getVector4fMap ()).cross3 (line_dir).squaredNorm ()); } //The Cross products are then the direction we are looking. Find the majority w.r.t a ref Direction! Eigen::Vector4f fRefDir (1.0, 0.0, 0.0, 0); //Validate the best using RANSAC w.r.t refDir unsigned int counterMax = 0; unsigned int iBest; for (unsigned int g = 0; g < fNumberOfRansacIterations; g++) { unsigned int gIndex = GetRand() % fNumOfCrossProducts; Eigen::Vector4f &fu1 = *fVPHypothesis.at(gIndex); double fAnglesInRadians = pcl::getAngle3D(fu1, fRefDir); double fAngleInDegrees = pcl::rad2deg(fAnglesInRadians); //score the selected hypothesis unsigned int sCounter = 0 ; for (unsigned int l = 0; l < fNumOfCrossProducts; l++) { //const float sAnglesInRadianstmp = Math3d::Angle(*((*crosProds)[l]), sRefDir); //const float sAnglesInDegreestmp = sAnglesInRadianstmp * 180.0f / CV_PI; Eigen::Vector4f &fu1tmp = *fVPHypothesis.at(l); double fAnglesInRadianstmp = pcl::getAngle3D(fu1tmp, fRefDir); double fAngleInDegreestmp = pcl::rad2deg(fAnglesInRadianstmp); if (fabsf(fAngleInDegreestmp - fAngleInDegrees) <= fEPS) //Tolerance of 2 Degress!!! { sCounter++; } } if (sCounter > counterMax) { counterMax = sCounter; iBest = gIndex; } } //Insert the Estimated VP! //fEstimatedVP1 = *fVPHypothesis.at(l); /*delete m_pclDataPtr;*/ //collect all the inliers and do WLeastSquaresFit Eigen::Vector4f &fBestModel = *fVPHypothesis.at(iBest); double fAnglesInRadiansBest = pcl::getAngle3D(fBestModel, fRefDir); double fAngleInDegreesBest = pcl::rad2deg(fAnglesInRadiansBest); pcl::PointCloud<pcl::PointXYZ>::Ptr fVPCandidates(new pcl::PointCloud<pcl::PointXYZ>); fVPCandidates->width = counterMax; fVPCandidates->height = 1; fVPCandidates->resize(fVPCandidates->width * fVPCandidates->height); unsigned int ii = 0; for (unsigned int l = 0; l < fNumOfCrossProducts; l++) { Eigen::Vector4f &fu1tmp = *fVPHypothesis.at(l); double fAnglesInRadianstmp = pcl::getAngle3D(fu1tmp, fRefDir); double fAngleInDegreestmp = pcl::rad2deg(fAnglesInRadianstmp); if (fabsf(fAngleInDegreestmp - fAngleInDegreesBest) <= fEPS) //Tolerance of 2 Degrees!!! { fVPCandidates->points[ii].x = fu1tmp(0); fVPCandidates->points[ii].y = fu1tmp(1); fVPCandidates->points[ii].z = fu1tmp(2); /*boost::scoped_ptr<Eigen::Vector4f> ftmpInliers(new Eigen::Vector4f(fu1tmp)); fVPHypothesisInliers.push_back(ftmpInliers);*/ if (ii > counterMax) { std::cout<<" Something went really wrong!..."<<std::endl; return; } ii++; } } //Robust fitting the inliers using WleastSquears fit //Eigen::VectorXf optimized_vp_coefficients; LSLineFitting(fVPCandidates, fRobustEstimatedVP); //collect data for }
int main(int argc, char *argv[]) { /*local variable for choice*/ int choice = 1; /* initialize random seed */ srand(time(NULL)); /* create struct, modify size */ struct name user; user.size = 16; /* menu prompt */ printf("Hello, please choose 1 or 2. \n"); while (choice != 0) { /* menu options */ printf("1. Enter your name. \n"); printf("2. Generate a random name. \n"); scanf("%i", &choice); /* option 1 for user defined name */ if (choice == 1) { printf("Enter your name(15 characters maximum) \n"); printf("Any entry beyond 15 characters will be truncated. \n"); scanf("%15s", user.userName); break; } /* option 2 for randomly generated name */ if (choice == 2) { /* generate initial random 0-12 */ int initRand = rand() % 13; /* * add 3 to initial random value so range is now * 3-15. I figure random names should have at least * 3 characters, and the cap is 15. */ int count = initRand + 3; /* ticker used to concat string */ int tick = 0; /* loop for string generation */ while (count > 0) { /* * index is random number corresponding to * the alphabet, 0-25. */ int index = rand() % 26; /* to store the char received from randGen */ char inputter = randGen(index); /* if no chars added, copy to userName */ if (tick == 0) { strcpy(user.userName, &inputter); } /* if character added, then concat string */ if (tick > 0) { strcat(user.userName, &inputter); } tick++; count--; } break; } /* error checking for invalid input */ else if (choice < 1 || choice > 2) { printf("Invalid Entry! Try again please. \n"); } } /* Print name */ printf("Your name is... %s", user.userName); printf("\n"); return 0; }
int main (int argc, char *argv[]){ //Print user info printf("\nAuthor : Bresia Prudente\n" "ACCC ID: bprude2\n\n"); /**********************/ /* PARSE COMMAND LINE */ /**********************/ if (argc < 7 && argc < 5) { printf("Usage: ./raceTest nBuffers nWorkers sleepMin sleepMax [randSeed] [-lock | -nolock]\n\n"); exit(-1); }//end if //Declare and initialize variables int nBuffers = atoi(argv[1]); int nWorkers = atoi(argv[2]); float sleepMin = atof(argv[3]); float sleepMax = atof(argv[4]); int randSeed; double randomized; bool semLock = FALSE; int semid; int bufArr[nBuffers]; //local array initialized to zero double nWorkerArr[nWorkers]; //for sorting array of rand numbers //initializing local array int tmp1; for (tmp1 = 0; tmp1 < nBuffers; tmp1++){ bufArr[tmp1] = 0; }//end for printf("Running simulation for %d workers accessing %d buffers, ", nWorkers, nBuffers); //Check if user enables lock or nolock if (argc == 7) { if (strcmp(argv[6], "-lock") == 0) { semLock = TRUE; printf("with locking.\n"); //sanity test }//end if else if (strcmp(argv[6], "-nolock") == 0){ semLock = FALSE; printf("without locking.\n"); //sanity test }//end else if }//end if //if user doesn't enter a value, default to unlock if (argc < 7){ semLock = FALSE; printf("without locking (default).\n"); //sanity test }//end if //Min and Max must be positive real numbers //min cannot be greater than max if (sleepMin > sleepMax) { printf("sleepMin cannot be greater than sleepMax!\n\n"); exit(-1); }//end if else if((sleepMin < 0) || (sleepMax < 0)){ printf("sleepMin and/or sleepMax values must be POSITIVE\n\n"); exit(-1); }//end else if printf("Sleeping from %f to %f seconds.\n", sleepMin, sleepMax); //To check randSeed if (argc >= 5) randSeed = atoi(argv[5]); else randSeed = -1; //if user enters nothing //nBuffers must be a positive prime integer less than 32 if (nBuffers < 0) { printf("nBuffers must be POSITIVE\n\n"); exit(-1); }//end if else if (nBuffers > 32){ printf("nBuffers must be less than 32\n\n"); exit(-1); }//end else if else if (nBuffers % 2 == 0){ printf("%d is NOT a prime number\n\n", nBuffers); exit(-1); }//end else if //nWorkers must be a positive integer less than nBuffers if (nWorkers > nBuffers){ printf("nWorkers must be less than nBuffers!\n\n"); exit(-1); }//end if else if (nWorkers < 0){ printf("nWorkers must be POSITIVE\n\n"); exit(-1); }//end else if /**********************/ /* SET UP WORKERS */ /**********************/ if (semLock){ semid = semget(IPC_PRIVATE, nBuffers, IPC_CREAT|0600); if (semid < 0){ perror("semget"); exit(-1); }//end if union semun argVal; argVal.val = 1; int c; for (c = 0; c < nBuffers; c++){ if(semctl(semid, c, SETVAL, argVal) < 0){ perror("semctl"); exit(-1); }//end if(semctl...) }//end for (c = 0...) }//end if (semLock...) else semid = -1; //Give each worker a random value printf("\n"); int x; for (x = 0; x < nWorkers; x++) { randomized = randGen(sleepMin, sleepMax, randSeed); nWorkerArr[x] = randomized; printf("sleepTime [ %d ] = %f\n", x, randomized); //sanity test }//end for printf("\n"); struct threadStruct strand[nWorkers]; //array of M structs //fill up these values int a; for ( a = 0; a < nWorkers; a++){ strand[a].nBuffers = nBuffers; strand[a].workerID = a + 1; strand[a].sleepTime = nWorkerArr[a]; strand[a].semID = semid; //strand[a].semID = -1; strand[a].mutexID = -1; strand[a].buffers = bufArr; strand[a].nReadErrors = 0; }//end for /**********************/ /* THREADS */ /**********************/ pthread_t isThread[nWorkers]; //create nWorker threads struct threadStruct *structPtr; //struct pointer long b; int rErrorCounter = 0, wErrorCounter = 0; for (b = 0; b < nWorkers; b++){ structPtr = &strand[b]; //assign a pointer to each struct //create M threads if(pthread_create(&isThread[b], NULL, worker, (void *)structPtr) != 0){ perror("pthread_create"); exit(-1); }//end if }//end for for (b = 0; b < nWorkers; b++){ //join threads if(pthread_join(isThread[b], NULL) != 0){ perror("pthread_join"); exit(-1); }//end if //have main increment read error counter if (strand[b].nReadErrors != 0){ rErrorCounter += strand[b].nReadErrors; }//end if }//end for /**********************/ /* MAIN PRINTS MSGS */ /**********************/ //examine the contents of each buffer element int noErrors = (int)(pow(2, nWorkers) - 1); //no errors contains (2^nWorkers)-1 int d; printf("\nAll buffers should hold %d\n\n", noErrors); //sanity test for (d = 0; d < nBuffers; d++){ printf("Buffer %d holds %d\n", d, strand->buffers[d]); //sanity test if (*(strand->buffers) != noErrors){ wErrorCounter++; }//end if }//end for printf("\n"); //save the bad bits counter into an array index int *badBitsArr; //initialize array with write error counter as its index badBitsArr = (int *)malloc(sizeof(int)*wErrorCounter); int badBitsIndex = 0; int e; for (e = 0; e < nBuffers; e++){ if (*(strand->buffers) != noErrors){ badBitsArr[badBitsIndex] = e; //save into the array badBitsIndex++; //increment accordingly //break out of it once it reaches value of write error counter if (badBitsIndex == wErrorCounter){ break; }//end if (badBitsIndex... }//end if (*(strand... else if(wErrorCounter == 0) break; }//end for //now actually make error reports int isBadBits, shiftBadBits; int wErrCount = 0; int *badBitsArr2; badBitsArr2 = (int *)malloc(sizeof(int)*32); //calling a 32 bit int array to store some values //initialize unused index to -1 int y; for (y = 0; y < 32; y++){ badBitsArr2[y] = -1; }//end for //Make error reports for each buffer int f, g; for (f = 0; f < wErrorCounter; f++){ g = badBitsArr[f]; isBadBits = strand->buffers[g]; //put contents of found bad bits into array printf("Error in buffer %d. ", g); //examine the bad bits shiftBadBits = (isBadBits ^ noErrors); int z, h = 0;; for (z = 0; z < 32; z++){ if(shiftBadBits & (1 << z)){ //tests which bits are lost to overwriting badBitsArr2[h] = z; h++; }//end if ((shiftBadBits... }//end for (z = 0... //print out the bad bits int i = 0; printf("( Bad bits = "); while(i < h){ if (i < (h-1)) //beautify it up printf("%d, ", badBitsArr2[i]); else printf("%d", badBitsArr2[i]); wErrCount++; i++; } printf(" )\n"); }//end for printf("\n"); //main prints the total number of errors printf("%d read errors and %d write errors encountered.\n\n", rErrorCounter, wErrCount); //detach semaphores if(semLock){ if (semctl(semid, 0, IPC_RMID)){ perror("semctl"); exit(-1); }//end if (semctl...) }//end if(semLock) printf("Program exiting...\n\n"); sleep(1); return 0; }//end main
int main(void) { int r = 5; //player positions int c = 4; int r2 = 80; //first ball positions int c2 = 120; int human_speed = 2; //guess what this is? int width = 2; //dont bother, this is the frame width int human_size = 10; //duh int size = 10; //size of computer int dr = 3; //speed of player int dc = 3; //should = dr int agression; //not being used right now int inRange = 0; //a random count variable int human_health = 100; //human starting health int comp_health = 100; //computer starting health int newgame = 1; //another count var int loopCount = 0; int numAttacks = 0; //number of times human attacks int justAttacked; //count var for computer attacks int result; //count var int death_radius = 4; //this is how many pixels the radius around the computer is that you have to be in to attack/be attacked int next_var1 = 0; int retreat = 0; int retreat_length = 100; //how long it is after going in to retreat mode that you win int next_var2 = 0; int junkVar = 0; //prebuild the binary search tree //make the data in each node be a pointer to a function, then the output of that function //decides which node is next NaryNode *root = NULL; root = createNaryNode(createIntData(0), 0); //make the root node (check health) appendChild(root, createNaryNode(createIntData(1), 0)); //make the first child (if health is ok) appendChild(root, createNaryNode(createIntData(2), 0)); //make the second child (if health is bad) appendChild(root->child[0], createNaryNode(createIntData(3), 0)); //treat the first child as the root and add another child appendChild(root->child[1], createNaryNode(createIntData(4), 0)); //treat the first child as the root and add another child appendChild(root->child[1]->child[4], createNaryNode(createIntData(5), 0)); //add another child on right parent int *tree1; int *tree2; int *tree3; tree1 = (int*)(root->child[1]); (int*)(root->child[1]) = 4; (int*)(root->child[0]) = 2; (int*)(root->child[1]->child[4]) = 1; //tree1 = root->child[1]; /* [root] / \ [child1] ----------child 2] / \ \ \ [child3] [child4] [child5] [child6] / / \ [child7] [child8] [child9] | | [child9] [child10] */ Junk first; first.margin = 40; //the margin for death for the computer first.comp_health_rate = 1; //how fast the you kill the computer first.human_health_rate = 2; //how fast the computer kills you while(keepGoing()) { waitForVBlank(ON); switch (gameState) { case START: //start mode 4 initializeGBA(MODE_4); FlipPage(ON); paintBackground(PressEnterBitmap); FlipPage(OFF); //in to mode 3 GBASetup(); initializeGBA(MODE_3); drawBackground(6); while(!keyHit(BUTTON_START)){ while(keyHit(BUTTON_START)){ break;} } //reset all the count vars and such newgame = 1; numAttacks = 0; loopCount = 0; justAttacked = 0; human_health = 100; //human starting health comp_health = 100; //computer starting health next_var1 = 0; next_var2 = 0; r = 5; //player positions c = 4; r2 = 80; //first ball positions c2 = 120; gameState = PLAY; retreat = 0; break; case PLAY: //start mode 3 FlipPage(OFF); GBASetup(); waitForVBlank(ON); loopCount++; drawRectDMA(0, 0, 160, 240, COLOR(0,0,0)); //the black background //nary tree usage tree3 = (int*)(root->child[1]); if(tree3){ junkVar++; } if(comp_health < first.margin){ gameState = WIN; } //frame drawRectDMA(1, 1, 240, 1, COLOR(0,0,31)); //left bar drawRectDMA(159, 1, 1, 240, COLOR(0,0,31));//bottom bar drawRectDMA(1, 1, 240, 1, COLOR(0,0,31));//bottom bar drawRectDMA(159, 1, 1, 240, COLOR(0,0,31));//bottom bar //draw health bars if(human_health == 100){ drawRectDMA(5, 4, 1, 1, COLOR(0,0,31)); //human starting health drawRectDMA(5, 6, 1, 1, COLOR(0,0,31)); drawRectDMA(5, 8, 1, 1, COLOR(0,0,31)); } if(comp_health == 100){ drawRectDMA(5, 230, 1, 1, COLOR(31,0,0)); //computer starting health drawRectDMA(5, 232, 1, 1, COLOR(31,0,0)); drawRectDMA(5, 234, 1, 1, COLOR(31,0,0)); //newgame = 0; } if((human_health < 100) && (human_health > 66)){ drawRectDMA(5, 4, 1, 1, COLOR(0,0,31)); //human health 2/3 drawRectDMA(5, 6, 1, 1, COLOR(0,0,31)); drawRectDMA(5, 8, 1, 1, COLOR(0,0,0)); } if((human_health < 66) && (human_health >33)){ drawRectDMA(5, 4, 1, 1, COLOR(0,0,31)); //human health 1/3 drawRectDMA(5, 6, 1, 1, COLOR(0,0,0)); drawRectDMA(5, 8, 1, 1, COLOR(0,0,0)); } if((human_health < 33) && (human_health >0)){ drawRectDMA(5, 4, 1, 1, COLOR(0,0,0)); //human health 0/3 drawRectDMA(5, 6, 1, 1, COLOR(0,0,0)); drawRectDMA(5, 8, 1, 1, COLOR(0,0,0)); } if((comp_health < 100) && (comp_health > 66)){ drawRectDMA(5, 230, 1, 1, COLOR(31,0,0)); //computer health 2/3 drawRectDMA(5, 232, 1, 1, COLOR(31,0,0)); drawRectDMA(5, 234, 1, 1, COLOR(0,0,0)); } if((comp_health < 66) && (comp_health > 33)){ drawRectDMA(5, 230, 1, 1, COLOR(31,0,0)); //computer health 1/3 drawRectDMA(5, 232, 1, 1, COLOR(0,0,0)); drawRectDMA(5, 234, 1, 1, COLOR(0,0,0)); } if((comp_health < 33) && (comp_health > 0)){ drawRectDMA(5, 230, 1, 1, COLOR(0,0,0)); //computer health 0/3 drawRectDMA(5, 232, 1, 1, COLOR(0,0,0)); drawRectDMA(5, 234, 1, 1, COLOR(0,0,0)); } waitForVBlank(ON); //player control //controls the boundries and the speed drawRectDMA( r, c, width, width, COLOR(0,0,0)); if(keyHit(BUTTON_UP)) { r = r - human_speed; if(r <= 1) r = 2; } if(keyHit(BUTTON_DOWN)) { r = r + human_speed; if(r >= 159+human_size) r = 159; } if(keyHit(BUTTON_LEFT)) { c = c - human_speed; if(c <= 1) c = 2; } if(keyHit(BUTTON_RIGHT)) { c = c + human_speed; if(c >= 239+human_size) c = 239; } //start ball code (makes ball move) drawRectDMA( r2, c2, size, size, COLOR(0,0,0) ); drawRectDMA( r2, c2, size, size, COLOR(0,0,31) ); //collision detection //walls (make ball bounce) //computer bouncing if((r2+size) > 156) dr = -dr; //top if((c2+size) > 236) dc = -dc; //bottom and right if((c2+size) < 15) dc = -dc; //left if(((r2) <= 3) || ((r2) >= 158)) dr = -dr; //top and bottom //draw player square drawRectDMA( r, c, human_size, human_size, COLOR(0,0,0)); drawRectDMA( r, c, human_size, human_size, COLOR(0,0,31) ); //the actual square //draw bouncing ball drawRectDMA( r2, c2, size, size, COLOR(31,0,0)); //right wall drawRectDMA( 1, 238, 72 , width - 1, COLOR(0,0,31) ); drawRectDMA( 87, 238, 73, width - 1, COLOR(0,0,31) ); //keep player in boundries if(r < 2) { r = 2; } if(r+size > (159)) { r = (148); } if((c+size > 239)) { c = 228; } if((c < 2)) { c = 2; } //keep computer in boundries //the computer boundry is smaller so he doesn't get stuck in corners if(r2 < 10) { r2 = 10; } if(r2+size >= (149)) { r2 = (138); } if((c2 < 10)) { c2 = 10; } if((c2+size > 229)) { c2 = 218; } //BEGIN AI //if the health is low if((retreatCheck(comp_health,(first.margin)))){ //retreat (int*)(root->child[1]) = 1; if(r < r2){ r2 = r2 + 1; } if(r > r2){ r2 = r2 - 1; } if(c < c2){ c2 = c2 + 1; } if(c > c2){ c2 = c2 - 1; } if(keyHit(BUTTON_A)){ retreat = retreat + 1; } } //nary tree usage tree2 = (int*)(root->child[1]); if(tree2){ junkVar++; } if(attackCheck(comp_health)){ //if health is ok //attack (int*)(root->child[0]) = 1; if(r < r2){ r2 = r2 - 1; } if(r > r2){ r2 = r2 + 1; } if(c < c2){ c2 = c2 - 1; } if(c > c2){ c2 = c2 + 1; } //see how aggressive the human is being agression = numAttacks/inRange; //see if the human is within striking distance if(inRadius(c2, death_radius, c, human_size, r2, r, size)){ //this function took forever to write inRange++; result = randGen(); if(result){ human_health = human_health - (first.human_health_rate); justAttacked++; } //If I ever get around to implementing this, this will allow the computer to retreat //when the human gets too aggressive /* if(agression > .15){ //retreat if(r < r2){ r2 = r2 + 1; } if(r > r2){ r2 = r2 - 1; } if(c < c2){ c2 = c2 + 1; } if(c > c2){ c2 = c2 = 1; } } */ //set up the health //computer (computer loses health under these conditions if(keyHit(BUTTON_A)){ comp_health = (comp_health - (first.comp_health_rate)); numAttacks++; } } } if(inRadius(c2, death_radius, c, human_size, r2, r, size)){ if(retreat >= retreat_length){ gameState = WIN; break;} if(human_health < 33){ gameState = DIE; next_var2 = 1; break; } } break; case WIN: //if they make it past level 5, display a win screen and reset some variables drawBackground(7); if(junkVar){ newgame = 1; } retreat = 0; if(keyHit(BUTTON_START)) { gameState = CREDITS; //next stop is the credits } while(keyHit(BUTTON_START)) { while(!keyHit(BUTTON_START)) { break; } next_var1 = 1;} break; case CREDITS: //display the Pony Shrapnel logo if(next_var1 == 1){ drawBackground(8); if(keyHit(BUTTON_START)) { gameState = START; //next stop is the start screen } while(keyHit(BUTTON_START)) { while(!keyHit(BUTTON_START)) { break; } } } case DIE: //if they die, then display a death screen, reset some variables, and go back to the start screen if(next_var2){ drawBackground(1); if(junkVar){ newgame = 0; } if(keyHit(BUTTON_START)) { gameState = CREDITS2; //next stop is the credits2 } while(keyHit(BUTTON_START)) { while(!keyHit(BUTTON_START)) { break; } } human_health = 100;} break; case CREDITS2: //display the Pony Shrapnel logo while(next_var2){ drawBackground(8); if(keyHit(BUTTON_START)) { gameState = START; //next stop is the start screen next_var2 = 0; } while(keyHit(BUTTON_START)) { while(!keyHit(BUTTON_START)) { break; } } break;} //end switch statements } } return 0; }
FitterResults SwarmFitterInterface::runFitter(ModelTuningParameters * startPoint) { int numberOfFlies = (int)(10.0+2.0*sqrt((double)toInt(fixedParams["Dimensions"]))); showMessage("Running Swarm Optimization with " + str(numberOfFlies) + " flies\n",3,fixedParams); vector< ModelTuningParameters > results; int maxInformed = 3; double w = 1.0/(2.0*log(2.0)); double c = 0.5 + log(2.0); double tempBestValue = 0; ///True if tempBestValue is initialized bool initBest = false; int numberOfRuns = toInt(fixedParams["NumberOfRuns"]); if (numberOfRuns < 0) crash("SwarmFitterInterface","Negative number of runs !!"); MTRand randGen( toInt(fixedParams["Seed"]) ); vector< SwarmFly > swarm(numberOfFlies, SwarmFly(w, c, &randGen, FixedParameters(fixedParams.getGlobals(),true))); vector< ModelTuningParameters > startPoints(numberOfFlies,ModelTuningParameters(*startPoint)); ModelTuningParameters startX; ModelTuningParameters startY; ////////////////////////////////// /// Initialize the swarm flies /// ////////////////////////////////// for (int i = 0; i < numberOfFlies; i++) { startPoints[i] = swarm[i].calculateRandomPosition(); } errorValue->calculateParallelErrorValue(startPoints); results.insert(results.end(),startPoints.begin(),startPoints.end()); for (int i = 0; i < numberOfFlies; i++) { swarm[i].setNewPositionErrorValue(startPoints[i]); } /////////////////////////// /// Initialize topology /// /////////////////////////// randomizeTopology(swarm, maxInformed, randGen); ///////////////////// /// Run Algorithm /// ///////////////////// vector< ModelTuningParameters > flyPositions(numberOfFlies); for (int i = 0; i < numberOfRuns; i++) { for (int j = 0; j < numberOfFlies; j++) { flyPositions[j] = swarm[j].calculateNewPosition(); } errorValue->calculateParallelErrorValue(flyPositions); results.insert(results.end(),flyPositions.begin(),flyPositions.end()); for (int j = 0; j < numberOfFlies; j++) { swarm[j].setNewPositionErrorValue(flyPositions[j]); } showMessage( "Best solution after run " + str(i) + " : " + SwarmFly::bestGlobalSolution.toString() + " : " + str(SwarmFly::bestGlobalSolution.getErrorValue()) + "\n",2,fixedParams); if (SwarmFly::bestGlobalSolution.getErrorValue() < tempBestValue || !initBest) { tempBestValue = SwarmFly::bestGlobalSolution.getErrorValue(); initBest = true; } else { showMessage("No better solution found in the last run: Randomizing swarm topology\n",3,fixedParams); //randomizeWorst(swarm); randomizeTopology(swarm, maxInformed, randGen); } } return FitterResults(results); }
uint32_t GenRandom(uint32_t uMin, uint32_t uMax) { static boost::random::mt19937 rng((uint32_t)std::time(0)); boost::random::uniform_int_distribution<> randGen(uMin, uMax); return randGen(rng); }