---

EvolutionStrategy.cpp

Go to the documentation of this file.

// EvolutionStrategy.cpp: implementation of the CEvolutionStrategy class.
//

#include "EvolutionStrategy.h"

// Construction/Destruction

CEvolutionStrategy::CEvolutionStrategy(CParameterFilter *pFilter)
{
        m_iMu = 15;
        m_iRho = 2;
        m_iLambda = 100;
        m_iNGenerations = 1000;
        m_pRNG = new Rand();
        m_pFilter = pFilter;
}

CEvolutionStrategy::CEvolutionStrategy(CParameterFilter *pFilter, int mu, int rho, int lambda, int nGenerations, int seed)
{
        m_iMu = mu;
        m_iRho = rho;
        m_iLambda = lambda;
        m_iNGenerations = nGenerations;
        m_pRNG = new Rand(seed);
        m_pFilter = pFilter;
}

CEvolutionStrategy::~CEvolutionStrategy()
{
        int i;
        if(0 != m_pRNG) delete m_pRNG;
        for(i = 0; i < m_iMu; i++)
        {
                delete m_vpPopulation[i];
        }
        for(i = 0; i < m_iLambda; i++)
        {
                delete m_vpOffspring[i];
        }
}

double CEvolutionStrategy::Minimize(double *parameters, Minimizable *minimizable)
{
        // define variables/allocate memory
        m_dAvgCost = 0.0;
        nParameters = minimizable->GetNParameters();
        // fill the parent vector with dummies
        for(int i = 0; i < m_iRho; i++) { m_viParents.push_back(0); }
        // filter the variables; all genetic operators work with the 
        // filtered parameters
        m_pFilter->ForwardTransformation(parameters,nParameters);

        cout << "Generating initial population . . ." << endl;

        InitializePopulation(parameters);

        for(int genCount = 0; genCount < m_iNGenerations; genCount++)
        {
                cout << "Generation " << genCount << " of " << m_iNGenerations << endl;
                // generate lambda offspring
                for(int nOff = 0; nOff < m_iLambda; nOff++)
                {
                        SelectParents();
                        Recombination(nOff);
                        Mutation(nOff);
                        // now evaluate the new individual (stored as the nOffd element 
                        // of the Offpring array)
                        double cost = EvaluateOffspring(minimizable,nOff);
                        m_dAvgCost += cost;
                }
                // perform selection on the offspring, which generates the new population
                Select();

                cout << "Best cost in new population " << m_vpPopulation[0]->GetObjFuncValue();
                cout << ", worst cost in new population " << m_vpPopulation[m_iMu-1]->GetObjFuncValue();
                cout << endl;
        }

        m_dAvgCost = 0.0;

        // write the final population to a file
        fstream *pfPars = new fstream("population.par",ios::out);
        *pfPars << "##################################################################" << endl;
        *pfPars << "# POPULATION UPON TERMINATION - \"#\" IS SEPARATOR" << endl;
        *pfPars << "##################################################################" << endl;
        for(int popNum = 0; popNum < m_iMu; popNum++)
        {
                double *pars = m_vpPopulation[popNum]->GetObjectParameters();
                double func = m_vpPopulation[popNum]->GetObjFuncValue();
                m_dAvgCost += func;
                *pfPars << "# COST = " << func << endl;
                int term = m_vpPopulation[popNum]->GetNObjectParameters();
                for(int j = 0; j < term; j++)
                {
                        *pfPars << m_pFilter->OperatorInverse(m_vpPopulation[popNum]->GetObjectParameter(j)) << endl;
                }
        }
        delete pfPars;

        m_dAvgCost = m_dAvgCost/m_iMu;

        return m_dAvgCost; 
}

double CEvolutionStrategy::EvaluateOffspring(Minimizable *minimizable, int whichOffspring)
{
        m_pFilter->BackwardTransformation(m_vpOffspring[whichOffspring]->GetObjectParameters(),nParameters);
        m_vpOffspring[whichOffspring]->SetObjFuncValue(minimizable->ObjectiveFunction(m_vpOffspring[whichOffspring]->GetObjectParameters()));
        m_pFilter->ForwardTransformation(m_vpOffspring[whichOffspring]->GetObjectParameters(),nParameters);
        return m_vpOffspring[whichOffspring]->GetObjFuncValue();
}

---