cmasolutions.h

#ifndef CMASOLUTIONS_H
#define CMASOLUTIONS_H

#include "libcmaes_config.h"
#include "candidate.h"
#include "eo_matrix.h"
#include "cmaparameters.h"
#include "cmastopcriteria.h"
#include "pli.h"
#include <vector>
#include <algorithm>

namespace libcmaes
{
  
  class 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
    {
      if (!cmaparams.is_sep() && !cmaparams.is_vd())
    return cmaparams.get_gp().pheno(static_cast<dVec>(_cov.diagonal().cwiseSqrt()));
      else if (cmaparams.is_sep())
    return cmaparams.get_gp().pheno(static_cast<dVec>(_sepcov.cwiseSqrt()));
      else if (cmaparams.is_vd())
    return cmaparams.get_gp().pheno(static_cast<dVec>((dVec::Constant(cmaparams.dim(),1.0)+_v.cwiseProduct(_v)).cwiseSqrt().cwiseProduct(_sepcov)));
      return dVec(); // should never reach here.
    }
    
    template<class TGenoPheno=GenoPheno<NoBoundStrategy>>
      inline dVec errors(const CMAParameters<TGenoPheno> &cmaparams) const
      {
    if (!cmaparams.is_sep() && !cmaparams.is_vd())
      return cmaparams.get_gp().pheno(static_cast<dVec>(std::sqrt(_sigma)*_cov.diagonal().cwiseSqrt()));
    else if (cmaparams.is_sep())
      return cmaparams.get_gp().pheno(static_cast<dVec>(std::sqrt(_sigma)*_sepcov.cwiseSqrt()));
    else if (cmaparams.is_vd())
      return cmaparams.get_gp().pheno(static_cast<dVec>(std::sqrt(_sigma)*(dVec::Constant(cmaparams.dim(),1.0)+_v.cwiseProduct(_v)).cwiseSqrt().cwiseProduct(_sepcov)));
    return dVec(); // should never reach here.
      }

    dMat corr() const;

    double corr(const int &i, const int &j) const;

    inline double sigma() const
    {
      return _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; 
  };

  std::ostream& operator<<(std::ostream &out,const CMASolutions &cmas);
  
}

#endif