eoEsMutate.h

// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; fill-column: 80; -*-

//-----------------------------------------------------------------------------
// eoESMute.h : ES mutation
// (c) Maarten Keijzer 2000 & GeNeura Team, 1998 for the EO part
//     Th. Baeck 1994 and EEAAX 1999 for the ES part
/*
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

    Contact: todos@geneura.ugr.es, http://geneura.ugr.es
             marc.schoenauer@polytechnique.fr
                       http://eeaax.cmap.polytchnique.fr/
 */
//-----------------------------------------------------------------------------


#ifndef _EOESMUTATE_H
#define _EOESMUTATE_H

#include <cmath>
#include <eoInit.h>
#include <eoOp.h>
#include <es/eoEsMutationInit.h>
#include <es/eoEsSimple.h>
#include <es/eoEsStdev.h>
#include <es/eoEsFull.h>
#include <utils/eoRealBounds.h>
#include <utils/eoRNG.h>

#ifndef M_PI
#define M_PI 3.1415926535897932384626433832795
#endif

template <class EOT>
class eoEsMutate : public eoMonOp< EOT >
{
public:

    typedef typename EOT::Fitness FitT;


    eoEsMutate(eoEsMutationInit& _init, eoRealVectorBounds& _bounds) : bounds(_bounds)
    {
        init(EOT(), _init); // initialize on actual type used
    }


    virtual ~eoEsMutate() {};


    virtual std::string className() const {return "eoESMutate";};


    virtual bool operator()( eoEsSimple<FitT>& _eo)
        {
            _eo.stdev *= exp(TauLcl * rng.normal());
            if (_eo.stdev < stdev_eps)
                _eo.stdev = stdev_eps;
            // now apply to all
            for (unsigned i = 0; i < _eo.size(); ++i)
            {
                _eo[i] += _eo.stdev * rng.normal();
            }
            bounds.foldsInBounds(_eo);
            return true;
        }


    virtual bool operator()( eoEsStdev<FitT>& _eo )
        {
            double global = TauGlb * rng.normal();
            for (unsigned i = 0; i < _eo.size(); i++)
            {
                double stdev = _eo.stdevs[i];
                stdev *= exp( global + TauLcl * rng.normal() );
                if (stdev < stdev_eps)
                    stdev = stdev_eps;
                _eo.stdevs[i] = stdev;
                _eo[i] += stdev * rng.normal();
            }
            bounds.foldsInBounds(_eo);
            return true;
        }


    virtual bool operator()( eoEsFull<FitT> & _eo )
    // Code originally from Thomas Bäck
        {
            // First: mutate standard deviations (as for eoEsStdev<FitT>).
            double global = TauGlb * rng.normal();
            unsigned i;
            for (i = 0; i < _eo.size(); i++)
            {
                double stdev = _eo.stdevs[i];
                stdev *= exp( global + TauLcl*rng.normal() );
                if (stdev < stdev_eps)
                    stdev = stdev_eps;
                _eo.stdevs[i] = stdev;
            }
            // Mutate rotation angles.
            for (i = 0; i < _eo.correlations.size(); i++)
            {
                _eo.correlations[i] += TauBeta * rng.normal();
                if ( fabs(_eo.correlations[i]) > M_PI )
                {
                    _eo.correlations[i] -= M_PI * (int) (_eo.correlations[i]/M_PI) ;
                }
            }
            // Perform correlated mutations.
            unsigned k, n1, n2;
            double d1,d2, S, C;
            std::vector<double> VarStp(_eo.size());
            for (i = 0; i < _eo.size(); i++)
                VarStp[i] = _eo.stdevs[i] * rng.normal();
            unsigned nq = _eo.correlations.size() - 1;
            for (k = 0; k < _eo.size()-1; k++)
            {
                n1 = _eo.size() - k - 1;
                n2 = _eo.size() - 1;
                for (i = 0; i < k; i++)
                {
                    d1 = VarStp[n1];
                    d2 = VarStp[n2];
                    S  = sin( _eo.correlations[nq] );
                    C  = cos( _eo.correlations[nq] );
                    VarStp[n2] = d1 * S + d2 * C;
                    VarStp[n1] = d1 * C - d2 * S;
                    n2--;
                    nq--;
                }
            }
            for (i = 0; i < _eo.size(); i++)
                _eo[i] += VarStp[i];
            bounds.foldsInBounds(_eo);
            return true;
        }


  private :

    void init(eoEsSimple<FitT>, eoEsMutationInit& _init)
    {
        unsigned size = bounds.size();
        TauLcl = _init.TauLcl();
        TauLcl /= sqrt(2*(double) size);
        std::cout << "Init<eoEsSimple>: tau local " << TauLcl << std::endl;
    }


    void init(eoEsStdev<FitT>, eoEsMutationInit& _init)
    {
        unsigned size = bounds.size();
        TauLcl = _init.TauLcl();
        TauGlb = _init.TauGlb();
        // renormalization
        TauLcl /= sqrt( 2.0 * sqrt(double(size)) );
        TauGlb /= sqrt( 2.0 * double(size) );
        std::cout << "Init<eoStDev>: tau local " << TauLcl << " et global " << TauGlb << std::endl;
    }


    void init(eoEsFull<FitT>, eoEsMutationInit& _init)
    {
        init(eoEsStdev<FitT>(), _init);
        TauBeta = _init.TauBeta();
        std::cout << "Init<eoEsFull>: tau local " << TauLcl << " et global " << TauGlb << std::endl;
    }


    double TauLcl;

    double TauGlb;

    double TauBeta;

    eoRealVectorBounds& bounds;

    static const double stdev_eps;
};


// Minimum value of stdevs, see declaration for details.
template <class EOT>
const double eoEsMutate<EOT>::stdev_eps = 1.0e-40;

#endif