esostrategy.h

#ifndef ESOSTRATEGY_H
#define ESOSTRATEGY_H

#include "eo_matrix.h" // to include Eigen everywhere.
#include "candidate.h"
#include "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 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 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