---

ClonalCommaES.cpp

Go to the documentation of this file.

// ClonalCommaES.cpp: implementation of the CClonalCommaES class.
//

#include "ClonalCommaES.h"

// Construction/Destruction

CClonalCommaES::CClonalCommaES(CParameterFilter *pFilter):CEvolutionStrategy(pFilter)
{
        m_dInitialSigma = 1.0;  
}

CClonalCommaES::CClonalCommaES(CParameterFilter *pFilter, double sigma, int lambda, int nGenerations, int seed)
:CEvolutionStrategy(pFilter,1,1,lambda,nGenerations,seed)
{
        // be sure std. dev. is positive.  It's OK to set it to zero, since in a (1,lambda) ES
        // the initial parent can just be the default parameters
        m_dInitialSigma = fabs(sigma);
}

CClonalCommaES::~CClonalCommaES()
{

}

void CClonalCommaES::InitializePopulation(double *parameters)
{
        int i;
        // this variant of ES just has nParameters std. deviations as the
        // strategy parameters
        m_iNStrategyParameters = nParameters;
        // tau,tau' are recommended to be some multiple of the following:
        //      - tau  ~   1/sqrt(2*sqrt(nParameters))
        //  - tau' ~   1/sqrt(2*nParameters)  
        m_dTau = 1.0/sqrt(2.0*sqrt((double)nParameters));
        m_dTauPrime = 1.0/(sqrt(2.0*nParameters));
        // allocate the space for the populations.  Starting objective function values
        // are just dummies.  Objective function values are rarely copied, since any
        // changes in the parameters require re-evaluation 
        for(i = 0; i < m_iMu; i++)
        {
                m_vpPopulation.push_back(new CEvolutionStrategyChromosome(nParameters,m_iNStrategyParameters));
                m_vpPopulation[i]->SetObjFuncValue(-1.0);
        }
        for(i = 0; i < m_iLambda; i++)
        {
                m_vpOffspring.push_back(new CEvolutionStrategyChromosome(nParameters,m_iNStrategyParameters));
                m_vpOffspring[i]->SetObjFuncValue(-1.0);
        }

        // now set up the initial parent pool; they are random large mutations 
        // of the starting parameters (with std. dev. given by m_dInitialSigma).  
        double *oVector = new double[nParameters];
        double *sVector = new double[nParameters];
        
        for(i = 0; i < m_iMu; i++)
        {
                for(int j = 0; j < nParameters; j++)
                {
                        oVector[j] = parameters[j] + m_dInitialSigma*m_pRNG->gaussian(1.0);
                        sVector[j] = 0.2;
                }
                m_vpPopulation[i]->SetObjectParameters(oVector);
                m_vpPopulation[i]->SetStrategyParameters(sVector);
        }

        delete [] oVector;
        delete [] sVector;
}

void CClonalCommaES::SelectParents()
{
        // Each offspring only has one parent; selection is random.  
        // If there's only one possible parent don't waste random numbers
        if(m_iMu > 1)
        {
                for(int i = 0; i < m_iRho; i++)
                {
                        m_viParents[i] = m_pRNG->discrete(0,m_iMu-1);
                }
        }
        else    // choose the only available parent
        {
                m_viParents[0] = 0;
        }
}

void CClonalCommaES::Recombination(int whichOffspring)
{
        // there's only one parent, so just do a straight copy
        double *oParams = new double[nParameters];
        double *sParams = new double[nParameters];
        // the object parameters use discrete recombination and the strategy 
        // parameters use intermediate recombination.  Remember, in this ES 
        // nObjPars = nStrategyPars.
        double objPar,stratPar;
        for(int i = 0; i < nParameters; i++)
        {
                // discrete for the object parameters
                int chooser = 0;
                objPar = m_vpPopulation[m_viParents[chooser]]->GetObjectParameter(i);
                // intermediate for the strategy parameters
                stratPar = m_vpPopulation[m_viParents[chooser]]->GetStrategyParameter(i);
                oParams[i] = objPar;
                sParams[i] = stratPar;
        }

        m_vpOffspring[whichOffspring]->SetObjectParameters(oParams);
        m_vpOffspring[whichOffspring]->SetStrategyParameters(sParams);

        delete [] oParams;
        delete [] sParams;
}

void CClonalCommaES::Mutation(int whichOffspring)
{
        double *oParams = new double[nParameters];
        double *sParams = new double[nParameters];

        // get the current parameters, then start mutating.  Mutate the strategy
        // parameters first and THEN use them to mutate the object parameters
        double fixedTerm = m_dTauPrime*m_pRNG->gaussian(1.0);
        for(int i = 0; i < nParameters; i++)
        {
                oParams[i] = m_vpOffspring[whichOffspring]->GetObjectParameter(i);
                sParams[i] = m_vpOffspring[whichOffspring]->GetStrategyParameter(i);
                double floatTerm = m_dTau*m_pRNG->gaussian(1.0);
                oParams[i] = oParams[i]*exp(fixedTerm + floatTerm);
                sParams[i] = sParams[i] + oParams[i]*m_pRNG->gaussian(1.0);
        }
        // copy back
        m_vpOffspring[whichOffspring]->SetObjectParameters(oParams);
        m_vpOffspring[whichOffspring]->SetStrategyParameters(sParams);
        
        delete [] oParams;
        delete [] sParams;
}

void CClonalCommaES::Select()
{
        // use STL sort with the correct comparator
        CEvolutionStrategyChromosome::CEvolutionStrategyChromosomeComparator comparator;
        std::sort(m_vpOffspring.begin(),m_vpOffspring.end(),comparator);
        // this selection scheme uses elitist selection, taking the mu most fit
        // individuals
        for(int i = 0; i < m_iMu; i++)
        {
                // set object parameters
                m_vpPopulation[i]->SetObjectParameters(m_vpOffspring[i]->GetObjectParameters());
                // set strategy parameters
                m_vpPopulation[i]->SetStrategyParameters(m_vpOffspring[i]->GetStrategyParameters());
                // set function value
                m_vpPopulation[i]->SetObjFuncValue(m_vpOffspring[i]->GetObjFuncValue());
        }
}

---