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();
}
