cmasolutions.h

 
#ifndef CMASOLUTIONS_H
#define CMASOLUTIONS_H
 
#include <libcmaes/libcmaes_config.h>
#include <libcmaes/candidate.h>
#include <libcmaes/eo_matrix.h>
#include <libcmaes/cmaparameters.h>
#include <libcmaes/cmastopcriteria.h>
#include <libcmaes/pli.h>
#include <vector>
#include <algorithm>
 
namespace libcmaes
{
  
  class CMAES_EXPORT CMASolutions
  {
    template <class U, class V> friend class CMAStrategy;
    template <class U, class V, class W> friend class ESOptimizer;
    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;
#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
    friend class VDCMAUpdate;
    
  public:
    CMASolutions() {}
 
    template<class TGenoPheno=GenoPheno<NoBoundStrategy> >
    CMASolutions(Parameters<TGenoPheno> &p);
    
    ~CMASolutions();
 
    void sort_candidates()
    {
      std::stable_sort(_candidates.begin(),_candidates.end(),
        [](Candidate const &c1, Candidate const &c2){return c1.get_fvalue() < c2.get_fvalue();});
    }
 
    void update_best_candidates();
 
    void update_eigenv(const dVec &eigenvalues,
               const dMat &eigenvectors);
 
    inline Candidate best_candidate() const
    {
      if (_best_candidates_hist.empty()) // iter = 0
    {
      if (_initial_candidate.get_x_size())
        return _initial_candidate;
      else return Candidate(std::numeric_limits<double>::quiet_NaN(),_xmean);
    }
      return _best_candidates_hist.back();
    }
 
    inline Candidate get_best_seen_candidate() const
    {
      return _best_seen_candidate;
    }
 
    inline Candidate get_worst_seen_candidate() const
    {
      return _worst_seen_candidate;
    }
 
    inline Candidate& get_candidate(const int &r)
      {
    return _candidates.at(r);
      }
 
    inline Candidate get_candidate(const int &r) const
    {
      return _candidates.at(r);
    }
 
    inline std::vector<Candidate>& candidates()
    {
      return _candidates;
    }
    
    inline int size() const
    {
      return _candidates.size();
    }
 
    void reset();
    
    void reset_as_fixed(const int &k);
 
    bool get_pli(const int &k, pli &p) const
    {
      std::map<int,pli>::const_iterator mit;
      if ((mit=_pls.find(k))!=_pls.end())
    {
      p = (*mit).second;
      return true;
    }
      return false;
    }
 
    inline int dim() const
    {
      return _xmean.size();
    }
    
    inline double edm() const
    {
      return _edm;
    }
 
    inline dMat cov() const
    {
      return _cov;
    }
 
    inline const dMat& cov_ref() const
    {
      return _cov;
    }
    
    inline const double* cov_data() const
    {
      return _cov.data();
    }
    
    dMat full_cov() const;
 
    inline dMat sepcov() const
    {
      return _sepcov;
    }
 
    inline const dMat& sepcov_ref() const
    {
      return _sepcov;
    }
    
    inline const double* sepcov_data() const
    {
      return _sepcov.data();
    }
 
    inline dMat csqinv() const
    {
      return _csqinv;
    }
 
    inline dMat sepcsqinv() const
    {
      return _sepcsqinv;
    }
 
    template<class TGenoPheno=GenoPheno<NoBoundStrategy> >
      inline dVec stds(const CMAParameters<TGenoPheno> &cmaparams) const
    {
      dVec phen_xmean = cmaparams.get_gp().pheno(_xmean);
      dVec stds;
      if (!cmaparams.is_sep() && !cmaparams.is_vd())
    stds = _cov.diagonal().cwiseSqrt();
      else if (cmaparams.is_sep())
    stds = _sepcov.cwiseSqrt();
      else if (cmaparams.is_vd())
    stds = (dVec::Constant(cmaparams.dim(),1.0)+_v.cwiseProduct(_v)).cwiseSqrt().cwiseProduct(_sepcov);
      dVec phen_xmean_std = cmaparams.get_gp().pheno(static_cast<dVec>(_xmean + stds));
      return (phen_xmean_std - phen_xmean).cwiseAbs();
    }
    
    template<class TGenoPheno=GenoPheno<NoBoundStrategy> >
      inline dVec errors(const CMAParameters<TGenoPheno> &cmaparams) const
      {
    return std::sqrt(_sigma)*stds(cmaparams);
      }
 
    dMat corr() const;
 
    double corr(const int &i, const int &j) const;
 
    inline double sigma() const
    {
      return _sigma;
    }
 
    inline void set_sigma(const double &sigma)
    {
      _sigma = sigma;
    }
 
    inline dVec xmean() const
    {
      return _xmean;
    }
 
    inline void set_xmean(const dVec &xmean)
    {
      _xmean = xmean;
    }
    
    inline int run_status() const
    {
      return _run_status;
    }
 
    inline std::string status_msg() const
      {
    return CMAStopCriteria<>::_scriterias[_run_status];
      }
 
    inline int elapsed_time() const
    {
      return _elapsed_time;
    }
 
    inline int elapsed_last_iter() const
    {
      return _elapsed_last_iter;
    }
    
    inline int niter() const
    {
      return _niter;
    }
 
    inline int nevals() const
    {
      return _nevals;
    }
    
    inline double min_eigenv() const
    {
      return _min_eigenv;
    }
 
    inline double max_eigenv() const
    {
      return _max_eigenv;
    }
 
    inline bool updated_eigen() const
    {
      return _updated_eigen;
    }
 
    inline int fevals() const
    {
      return _nevals;
    }
 
    inline dVec eigenvalues() const
    {
      return _leigenvalues;
    }
    
    inline dMat eigenvectors() const
    {
      return _leigenvectors;
    }
    
    template <class TGenoPheno=GenoPheno<NoBoundStrategy> >
    std::ostream& print(std::ostream &out,
            const int &verb_level=0,
            const TGenoPheno &gp=TGenoPheno()) const;
 
  private:
    dMat _cov; 
    dMat _csqinv; 
    dMat _sepcov;
    dMat _sepcsqinv;
    dVec _xmean; 
    dVec _psigma; 
    dVec _pc; 
    short _hsig = 1; 
    double _sigma; 
    std::vector<Candidate> _candidates; 
    std::vector<Candidate> _best_candidates_hist; 
    int _max_hist = -1; 
    double _max_eigenv = 0.0; 
    double _min_eigenv = 0.0; 
    dVec _leigenvalues; 
    dMat _leigenvectors; 
    int _niter = 0; 
    int _nevals = 0; 
    int _kcand = 1;
    std::vector<Candidate> _k_best_candidates_hist; 
    std::vector<double> _bfvalues; 
    std::vector<double> _median_fvalues; 
    int _eigeniter = 0; 
    bool _updated_eigen = true; 
    // status of the run.
    int _run_status = 0; 
    int _elapsed_time = 0; 
    int _elapsed_last_iter = 0; 
#ifdef HAVE_DEBUG
    int _elapsed_eval = 0;
    int _elapsed_ask = 0;
    int _elapsed_tell = 0;
    int _elapsed_stop = 0;
#endif
 
    std::map<int,pli> _pls; 
    double _edm = 0.0; 
    Candidate _best_seen_candidate; 
    int _best_seen_iter;
    Candidate _worst_seen_candidate;
    Candidate _initial_candidate;
    
    dVec _v; 
    std::vector<RankedCandidate> _candidates_uh; 
    int _lambda_reev; 
    double _suh; 
    double _tpa_s = 0.0;
    int _tpa_p1 = 0;
    int _tpa_p2 = 1;
    dVec _tpa_x1;
    dVec _tpa_x2;
    dVec _xmean_prev; 
  };
 
  CMAES_EXPORT std::ostream& operator<<(std::ostream &out,const CMASolutions &cmas);
}
 
#endif