parameters.h

 
#ifndef PARAMETERS_H
#define PARAMETERS_H
 
#include <libcmaes/eo_matrix.h>
#include <libcmaes/genopheno.h>
#include <libcmaes/llogging.h>
#include <string>
#include <cmath>
#include <limits>
#include <unordered_map>
#include <map>
#include <chrono>
 
namespace libcmaes
{
  template <class TGenoPheno=GenoPheno<NoBoundStrategy> >
  class Parameters
    {
      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;
      friend class Candidate;
#ifdef HAVE_SURROG
      template <template <class X,class Y> class U, class V, class W> friend class SimpleSurrogateStrategy;
      template <template <class X,class Y> class U, class V, class W> friend class ACMSurrogateStrategy;
#endif      
 
    public:
    Parameters():_dim(0),_lambda(-1),_max_iter(0)
      {}
      
    Parameters(const int &dim, const double *x0, const int &lambda=-1,
           const uint64_t &seed=0, const TGenoPheno &gp=GenoPheno<NoBoundStrategy>())
      :_dim(dim),_lambda(lambda),_seed(seed),_gp(gp)
      {
    if (_lambda == -1 || _lambda < 2) // lambda is unspecified
      _lambda = 4 + floor(3.0*log(_dim));
    if (_seed == 0) // seed is not forced.
      _seed = static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count());
    set_x0(x0);
      }
      
      ~Parameters()
      {
      }
      
      void set_x0(const double &x0)
      {
    _x0min = _x0max = dVec::Constant(_dim,x0);
      }
      
      void set_x0(const double *x0)
      {
    _x0min = _x0max = dVec(_dim);
    for (int i=0;i<_dim;i++)
      _x0min(i) = _x0max(i) = x0[i];
      }
 
      void set_x0(const dVec &x0)
      {
    _x0min = x0;
    _x0max = x0;
      }
      
      void set_x0(const double &x0min, const double &x0max)
      {
    _x0min = dVec::Constant(_dim,x0min);
    _x0max = dVec::Constant(_dim,x0max);
      }
      
      void set_x0(const double *x0min, const double *x0max)
      {
    _x0min = dVec(_dim);
    _x0max = dVec(_dim);
    for (int i=0;i<_dim;i++)
      {
        _x0min(i) = x0min[i];
        _x0max(i) = x0max[i];
      }
      }
 
      void set_x0(const std::vector<double> &x0min, const std::vector<double> &x0max)
      {
    set_x0(&x0min[0],&x0max[0]);
      }
      
      void set_x0(const dVec &x0min, const dVec &x0max)
      {
    _x0min = x0min;
    _x0max = x0max;
      }
      
      inline dVec get_x0min() const
      {
    return _x0min;
      }
      
      inline dVec get_x0max() const
      {
    return _x0max;
      }
      
      void set_fixed_p(const int &index, const double &value)
      {
    _fixed_p.insert(std::pair<int,double>(index,value));
      }
      
      void unset_fixed_p(const int &index)
      {
    std::unordered_map<int,double>::iterator mit;
    if ((mit=_fixed_p.find(index))!=_fixed_p.end())
      _fixed_p.erase(mit);
      }
      
      void set_max_iter(const int &maxiter)
      {
    _max_iter = maxiter;
      }
      
      inline int get_max_iter() const
      {
    return _max_iter;
      }
      
      void set_max_fevals(const int &fevals)
      {
    _max_fevals = fevals;
      }
      
      inline int get_max_fevals() const
      {
    return _max_fevals;
      }
      
      void set_ftarget(const double &val)
      {
    _ftarget = val;
      }
      
      void reset_ftarget()
      {
    _ftarget = -std::numeric_limits<double>::infinity();
      }
      
      inline double get_ftarget() const
      {
    return _ftarget;
      }
      
      void set_seed(const int &seed)
      {
    if (_seed == 0)
      _seed = static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count());
    else _seed = seed;
      }
      
      inline int get_seed() const
      {
    return _seed;
      }
      
      void set_ftolerance(const double &v) { _ftolerance = v; }
      
      inline double get_ftolerance() const
      {
    return _ftolerance;
      }
      
      void set_xtolerance(const double &v)
      {
    _xtol = v;
      }
      
      double get_xtolerance() const
      {
    return _xtol;
      }
      
      inline int lambda() const
      {
    return _lambda;
      }
      
      inline int dim() const
      {
    return _dim;
      }
      
      void set_quiet(const bool &quiet)
      {
    _quiet = quiet;
      }
      
      inline bool quiet() const
      {
    return _quiet;
      }
      
      void set_algo(const int &algo)
      {
    _algo = algo;
      }
      
      inline int get_algo() const
      {
    return _algo;
      }
      
      void set_gp(const TGenoPheno &gp)
      {
    _gp = gp;
      }
      
      inline TGenoPheno get_gp() const
      {
    return _gp;
      }
      
      void set_fplot(const std::string &fplot)
      {
    _fplot = fplot;
      }
      
      void set_full_fplot(const bool &b)
      {
    _full_fplot = b;
      }
 
      inline std::string get_fplot() const
      {
    return _fplot;
      }
      
      void set_gradient(const bool &gradient)
      {
    _with_gradient = gradient;
    /*if (this->_tpa != 0)
      set_tpa(2); */ // TPA default when gradient is activated. XXX: deactivated until flaw is fixed.
      }
      
      inline bool get_gradient() const
      {
    return _with_gradient;
      }
      
      void set_edm(const bool &edm)
      {
    _with_edm = edm;
      }
      
      inline bool get_edm() const
      {
    return _with_edm;
      }
      
      void set_mt_feval(const bool &mt)
      {
    _mt_feval = mt;
      }
      
      inline bool get_mt_feval() const
      {
    return _mt_feval;
      }
      
      void set_max_hist(const int &m)
      {
    _max_hist = m;
      }
 
      void set_maximize(const bool &maximize)
      {
    _maximize = maximize;
      }
 
      bool get_maximize() const
      {
    return _maximize;
      }
 
      inline void set_initial_fvalue(const bool &b)
      {
    _initial_fvalue = b;
      }
 
      inline void set_uh(const bool &b)
      {
    _uh = b;
      }
 
      inline bool get_uh() const
      {
    return _uh;
      }
 
      inline void set_tpa(const int &b)
      {
    _tpa = b;
      }
 
      inline int get_tpa() const
      {
    return _tpa;
      }
      
    protected:
      int _dim; 
      int _lambda = -1; 
      int _max_iter = -1; 
      int _max_fevals = -1; 
      bool _quiet = true; 
      std::string _fplot = ""; 
      bool _full_fplot = false; 
      dVec _x0min; 
      dVec _x0max; 
      double _ftarget = -std::numeric_limits<double>::infinity(); 
      double _ftolerance = 1e-12; 
      double _xtol = 1e-12; 
      uint64_t _seed = 0; 
      int _algo = 0; 
      bool _with_gradient=false; 
      bool _with_edm=false; 
      std::unordered_map<int,double> _fixed_p; 
      TGenoPheno _gp; 
      bool _mt_feval = false; 
      int _max_hist = -1; 
      bool _maximize = false; 
      static std::map<std::string,int> _algos; 
      bool _initial_fvalue = false; 
      // uncertainty handling
      bool _uh = false; 
      double _rlambda; 
      double _epsuh = 1e-7; 
      double _thetauh = 0.2; 
      double _csuh = 1.0; 
      double _alphathuh = 1.0; 
      // two-point adaptation
      int _tpa = 1; 
      double _tpa_csigma = 0.3;
    };
}
 
#endif