Individual * Population::iterate (int iterations) { Individual * fittest = getFittest (); for (int i = 0; i < iterations; i++) { if (fittest->getFitness () == 0) { return fittest; } else { pop_stats.average_fitness.push_back (calcAvFitness (individuals, size)); pop_stats.highest_fitness.push_back (fittest->getFitness ()); Individual * winners = tournament (); mutation (winners); Individual * children = crossOver (winners); merge (winners, children); delete [] winners; delete [] children; calcFittest (); fittest = getFittest (); } } return fittest; }
Individual Population::getFittest(void) { Individual fittest = individuals[0]; int i; for (i = 0; i < getSize(); i++) { Individual k = getIndividual(i); if (fittest.getFitness() <= k.getFitness()) { fittest = k; } } return fittest; }
void Beagle::MPI::EvaluationOp::individualEvaluation(Individual& ioIndividal, Context& ioContext) { Fitness::Handle lFitness = evaluate(ioIndividal, ioContext); //Assign the fitness ioIndividal.setFitness(lFitness); ioIndividal.getFitness()->setValid(); return; }
int main() { srand(time(NULL)); Population population; for (int i = 0; i < POPULATION_COUNT; ++i) { Individual ind; Chromosome chromosome(targetString.size()); chromosome.randomize(); float fitness = evaluate(chromosome); ind.setChromosome(chromosome); ind.setFitness(fitness); population.addIndividual(ind); } population.sortPopulation(); std::string solution = ""; Individual bestInd; int generationCount = 0; int nth = 64; for (int i = 0; i < GENERATION_COUNT; ++i) { generationCount++; evolve(population); population.sortPopulation(); if (bestInd < population[0]) { bestInd = population[0]; } if (i % nth == 0) { std::cout << "Generation: " << generationCount << std::endl; std::cout << "Best individual: " << bestInd << std::endl; } if (bestInd.getFitness() >= 1){ break; } } std::cout << std::endl; std::cout << "Solved on generation " << generationCount << '!' << std::endl; std::cout << bestInd << std::endl << std::endl; std::cout << "Press enter to exit"; std::cin.get(); return 0; }
/*! * \brief Copy individual using the system. * \param inOriginal Individual to copy into current. * \param ioSystem Evolutionary system. */ void Individual::copy(const Individual& inOriginal, System& ioSystem) { Beagle_StackTraceBeginM(); const Factory& lFactory = ioSystem.getFactory(); // Copy members mMemberMap.clear(); for(MemberMap::const_iterator lIterMap=inOriginal.mMemberMap.begin(); lIterMap!=inOriginal.mMemberMap.end(); ++lIterMap) { Member::Handle lOrigMember = castHandleT<Member>(lIterMap->second); const std::string& lMemberType = lOrigMember->getType(); Member::Alloc::Handle lMemberAlloc = castHandleT<Member::Alloc>(lFactory.getAllocator(lMemberType)); Member::Handle lMember = castHandleT<Member>(lMemberAlloc->allocate()); lMember->copy(*lOrigMember, ioSystem); mMemberMap[lIterMap->first] = lMember; } // Copy fitness if(inOriginal.getFitness() == NULL) { mFitness = NULL; } else { const std::string& lFitnessType = inOriginal.getFitness()->getType(); Fitness::Alloc::Handle lFitnessAlloc = castHandleT<Fitness::Alloc>(lFactory.getAllocator(lFitnessType)); mFitness = castHandleT<Fitness>(lFitnessAlloc->allocate()); mFitness->copy(*inOriginal.getFitness(), ioSystem); } // Copy genotypes resize(inOriginal.size()); for(unsigned int i=0; i<inOriginal.size(); ++i) { const std::string& lGenotypeType = inOriginal[i]->getType(); Genotype::Alloc::Handle lGenotypeAlloc = castHandleT<Genotype::Alloc>(lFactory.getAllocator(lGenotypeType)); (*this)[i] = castHandleT<Genotype>(lGenotypeAlloc->allocate()); (*this)[i]->copy(*inOriginal[i], ioSystem); } Beagle_StackTraceEndM(); }
void Deme::colonize() { Individual ind; int i; for(i = 0; i < capacity; i++) { this_generation.push_back(ind); } max_fit = ind.getFitness(s); }
/*! * \brief Evaluate niche count of an individual over a pool of individuals. * \param inEvalIndividual Individual for which we need to evaluate crowding distance. * \param inIndividualPool Pool of individuals to evaluate distance on. * \return Niche count value. */ float NPGA2Op::evalNicheCount(const Individual& inEvalIndividual, const Individual::Bag& inIndividualPool) const { Beagle_StackTraceBeginM(); double lNicheCount = 0.; const Fitness::Handle lEvalFitness = inEvalIndividual.getFitness(); for(unsigned int i=0; i<inIndividualPool.size(); ++i) { float lDistance = lEvalFitness->getDistance(*inIndividualPool[i]->getFitness()); if(lDistance < mNicheRadius->getWrappedValue()) { lNicheCount += (1.0 - (lDistance / mNicheRadius->getWrappedValue())); } } return lNicheCount; Beagle_StackTraceEndM(); }
inline bool Population::compFitness(Individual indiv1, Individual indiv2) { return indiv1.getFitness() < indiv2.getFitness(); }
bool compareFunc(Individual left, Individual right) { return left.getFitness() > right.getFitness(); }
bool Individual::operator>(Individual& obj){ return this->mFitness>obj.getFitness(); }