---

CommaStrategyOne.cpp

Go to the documentation of this file.

// CommaStrategyOne.cpp: implementation of the CCommaStrategyOne class.
//

#include "CommaStrategyOne.h"

// Construction/Destruction

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

CCommaStrategyOne::CCommaStrategyOne(CParameterFilter *pFilter, double sigma, int mu, int rho, int lambda, int nGenerations, int seed)
:CEvolutionStrategy(pFilter,mu,rho,lambda,nGenerations,seed)
{
        // be sure the std. dev. is positive
        m_dInitialSigma = fabs(sigma);
}

CCommaStrategyOne::~CCommaStrategyOne()
{

}

void CCommaStrategyOne::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_pRNG->gaussian(m_dInitialSigma);
                        sVector[j] = 0.5 + m_pRNG->uniform();
                }
                m_vpPopulation[i]->SetObjectParameters(oVector);
                m_vpPopulation[i]->SetStrategyParameters(sVector);
        }

        delete [] oVector;
        delete [] sVector;
}

void CCommaStrategyOne::SelectParents()
{
        // choose rho parents at random with replacement from a pool
        // of mu potentials
        for(int i = 0; i < m_iRho; i++)
        {
                m_viParents[i] = m_pRNG->discrete(0,m_iMu-1);
        }
}

void CCommaStrategyOne::Recombination(int whichOffspring)
{
        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 = m_pRNG->discrete(0,m_iRho-1);
                objPar = m_vpPopulation[m_viParents[chooser]]->GetObjectParameter(i);
                // intermediate for the strategy parameters
                stratPar = 0.0;
                for(int nParent = 0; nParent < m_iRho; nParent++)
                {
                        stratPar += (1.0/m_iRho)*(m_vpPopulation[nParent]->GetStrategyParameter(i));
                }
                
                oParams[i] = objPar;
                sParams[i] = stratPar;
        }

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

        delete [] oParams;
        delete [] sParams;
}

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

---