cmaparameters.h

#ifndef CMAPARAMETERS_H
#define CMAPARAMETERS_H

#include "parameters.h"
#include "eo_matrix.h"
#include <float.h>

namespace libcmaes
{
  template <class TGenoPheno=GenoPheno<NoBoundStrategy> >
  class CMAParameters : public Parameters<TGenoPheno>
    {
      friend class CMASolutions;
      template <class U, class V> friend class CMAStrategy;
      template <class U, class V, class W> friend class ESOStrategy;
      template <class U> friend class CMAStopCriteria;
      template <class U, class V> friend class IPOPCMAStrategy;
      template <class U, class V> friend class BIPOPCMAStrategy;
      friend class CovarianceUpdate;
      friend class ACovarianceUpdate;
      template <class U> friend class errstats;
      friend class VDCMAUpdate;
      
    public:
      CMAParameters() {} //TODO: var init even if this constructor is not supposed to be used for now.
      
      CMAParameters(const int &dim,
            const double *x0,
            const double &sigma,
            const int &lambda=-1,
            const uint64_t &seed=0,
            const TGenoPheno &gp=TGenoPheno());
      
      CMAParameters(const std::vector<double> &x0,
            const double &sigma,
            const int &lambda=-1,
            const uint64_t &seed=0,
            const TGenoPheno &gp=TGenoPheno());
      
      CMAParameters(const std::vector<double> &x0,
            const std::vector<double> &sigma,
            const int &lambda=-1,
            const std::vector<double> &lbounds=std::vector<double>(),
            const std::vector<double> &ubounds=std::vector<double>(),
            const uint64_t &seed=0);
      
      ~CMAParameters();
      
      void initialize_parameters();

      
      void reset_as_fixed(const int &k);
      
      void set_noisy();
      
      void set_algo(const int &algo)
      {
    this->_algo = algo;
    /*if (this->_tpa != 0
        && (this->_algo == 6 // sepCMAES
        || this->_algo == 7 //sepIPOP_CMAES
        || this->_algo == 8 //sepBIPOP_CMAES
        || this->_algo == 9 //sepaCMAES
        || this->_algo == 10 //sepaIPOP_CMAES
        || this->_algo == 11 //sepBIPOP_CMAES
        || this->_algo == 12 //VD_CMAES
        || this->_algo == 13 //VD_IPOP_CMAES
        || this->_algo == 14)) //VD_BIPOP_CMAES
        set_tpa(2); */ // XXX: deactivated until flaw is fixed
      }

      void set_str_algo(const std::string &algo)
      {
    std::map<std::string,int>::const_iterator mit;
    if ((mit = Parameters<TGenoPheno>::_algos.find(algo))!=Parameters<TGenoPheno>::_algos.end())
      Parameters<TGenoPheno>::_algo = (*mit).second;
    else LOG(ERROR) << "unknown algorithm " << algo << std::endl;
    if (algo.find("sep")!=std::string::npos)
      set_sep();
    if (algo.find("vd")!=std::string::npos)
      set_vd();
      }

      double get_sigma_init() const
      {
    return _sigma_init;
      }

      void set_gradient(const bool &gradient)
      {
    this->_with_gradient = gradient;
    /*if (this->_tpa != 0)
      set_tpa(2);*/ // TPA default when gradient is activated.
      }
      
      void set_sep();

      bool is_sep() const { return _sep; }

      void set_vd();

      bool is_vd() const { return _vd; }
      
      void set_fixed_p(const int &index, const double &value);
      
      void unset_fixed_p(const int &index);
      
      inline void set_restarts(const int &nrestarts) { _nrestarts = nrestarts; }

      inline int get_restarts() const { return _nrestarts; }

      inline void set_lazy_update(const bool &lz) { _lazy_update = lz; }

      inline bool get_lazy_update() { return _lazy_update; }

      inline void set_elitism(const int &e)
      {
    if (e == 0)
      _elitist = _initial_elitist = _initial_elitist_on_restart;
    else if (e == 1)
      {
        _elitist = true;
        _initial_elitist = _initial_elitist_on_restart = false;
      }
    else if (e == 2)
      {
        _initial_elitist = true;
        _elitist = _initial_elitist_on_restart = false;
      }
    else if (e == 3)
      {
        _initial_elitist_on_restart = true;
        _elitist = _initial_elitist = false;
      }
      }
      
      inline void set_stopping_criteria(const int &criteria,
                    const bool &active)
      {
    _stoppingcrit.insert(std::pair<int,bool>(criteria,active));
      }

      void set_tpa(const int &b); // overrides def in parameters.h in order to reset dsigma

      void set_tpa_dsigma(const double &d) { _dsigma = d; }
      
    private:
      int _mu; 
      dVec _weights; 
      double _csigma; 
      double _c1; 
      double _cmu; 
      double _cc; 
      double _muw; 
      double _dsigma; 
      // computed once at init for speeding up operations.
      double _fact_ps;
      double _fact_pc;
      double _chi; 
      double _sigma_init; 
      int _nrestarts = 9; 
      bool _lazy_update; 
      double _lazy_value; 
      // active cma.
      double _cm; 
      double _alphacov; 
      double _alphaminusold; 
      double _deltamaxsigma; 
      double _lambdamintarget; 
      double _alphaminusmin; 
      // sep cma (diagonal cov).
      bool _sep = false; 
      bool _vd = false;
      
      bool _elitist = false; 
      bool _initial_elitist = false; 
      bool _initial_elitist_on_restart = false; 
      // stopping criteria
      std::map<int,bool> _stoppingcrit; 
    };

  template<class TGenoPheno>
    std::map<std::string,int> Parameters<TGenoPheno>::_algos = {{"cmaes",0},{"ipop",1},{"bipop",2},{"acmaes",3},{"aipop",4},{"abipop",5},{"sepcmaes",6},{"sepipop",7},{"sepbipop",8},{"sepacmaes",9},{"sepipop",10},{"sepbipop",11},{"vdcma",12},{"vdipopcma",13},{"vdbipopcma",14}};
}

#endif