esostrategy.h

 
#ifndef ESOSTRATEGY_H
#define ESOSTRATEGY_H
 
#include <libcmaes/eo_matrix.h> // to include Eigen everywhere.
#include <libcmaes/candidate.h>
#include <libcmaes/eigenmvn.h>
#include <random>
 
namespace libcmaes
{
  typedef std::function<double (const double*, const int &n)> FitFunc;
  typedef std::function<dVec (const double*, const int &n)> GradFunc;
 
  typedef std::function<void(const dMat&, const dMat&)> EvalFunc;
  typedef std::function<dMat(void)> AskFunc;
  typedef std::function<void(void)> TellFunc;
  
  template<class TParameters,class TSolutions>
    using ProgressFunc = std::function<int (const TParameters&, const TSolutions&)>; // template aliasing.
 
  template<class TParameters,class TSolutions>
    using PlotFunc = std::function<int (const TParameters&, const TSolutions&, std::ofstream &fplotstream)>;
  
  template<class TParameters,class TSolutions,class TStopCriteria>
    class CMAES_EXPORT ESOStrategy
  {
  public:
    ESOStrategy()
      {
      }
    
    ESOStrategy(FitFunc &func,
        TParameters &parameters);
 
    ESOStrategy(FitFunc &func,
        TParameters &parameters,
        const TSolutions &solutions);
    
  protected:
    ~ESOStrategy();
 
  public:
    dMat ask();
 
    void eval(const dMat &candidates,
          const dMat &phenocandidates=dMat(0,0));
 
    void tell();
 
    bool stop();
 
    int optimize(const EvalFunc &evalf, const AskFunc &askf, const TellFunc &tellf);
    
    void inc_iter();
 
    void update_fevals(const int &evals);
 
    void set_gradient_func(GradFunc &gfunc) { _gfunc = gfunc; }
    
    void set_progress_func(ProgressFunc<TParameters,TSolutions> &pfunc) { _pfunc = pfunc; }
 
    void start_from_solution(const TSolutions &sol)
    {
      _parameters.set_x0(sol.best_candidate().get_x_dvec());
      _solutions = sol;
      _solutions.reset();
    }
 
    void set_plot_func(PlotFunc<TParameters,TSolutions> &pffunc) { if (!_parameters._full_fplot) _pffunc = pffunc; }
    
    dVec gradf(const dVec &x);
 
    dVec gradgp(const dVec &x) const;
 
    double edm();
 
    TSolutions& get_solutions() { return _solutions; }
 
    TParameters& get_parameters() { return _parameters; }
 
    double fitfunc(const double *x, const int N) { return _func(x,N); }
 
    void uncertainty_handling();
 
        void perform_uh(const dMat& candidates, const dMat& phenocandidates, int& nfcalls);
 
        void select_candidates_uh(const dMat& candidates, const dMat& phenocandidates, dMat& candidates_uh);
 
        void eval_candidates_uh(const dMat& candidates, const dMat& candidates_uh, std::vector<RankedCandidate>& nvcandidates, int& nfcalls);
 
        void set_candidates_uh(const std::vector<RankedCandidate>& nvcandidates);
 
 
    void tpa_update();
 
    // deprecated.
    Candidate best_solution() const;
 
    void set_initial_elitist(const bool &e) { _initial_elitist = e; }
    
  protected:
    FitFunc _func; 
    int _nevals;  
    int _niter;  
    TSolutions _solutions; 
    TParameters _parameters; 
    ProgressFunc<TParameters,TSolutions> _pfunc; 
    GradFunc _gfunc = nullptr; 
    PlotFunc<TParameters,TSolutions> _pffunc; 
    FitFunc _funcaux;
    bool _initial_elitist = false; 
  private:
    std::mt19937 _uhgen; 
    std::uniform_real_distribution<> _uhunif;
    Eigen::EigenMultivariateNormal<double> _uhesolver;
  };
  
}
 
#endif