pli.h

 
#ifndef PLI_H
#define PLI_H
 
#include <libcmaes/eo_matrix.h>
#include <vector>
 
namespace libcmaes
{
 
  class pli
  {
    friend class CMASolutions;
    template <class U> friend class errstats;
    
  public:
    pli() {}
    
  pli(const int &k, const int &samplesize, const int &dim,
      const dVec &xm, const double &fvalue, const double &fup, const double &delta)
    :_k(k),_samplesize(samplesize),_fvaluem(dVec::Zero(2*samplesize+1)),_xm(dMat::Zero(2*samplesize+1,dim)),_min(0.0),_max(0.0),_err(2*samplesize+1),_fup(fup),_delta(delta)
      {
    _fvaluem[samplesize] = fvalue;
    _xm.row(samplesize) = xm.transpose();
    _err[samplesize] = 1; // should be current sol status...
      }
    
    ~pli() {};
    
    std::pair<double,double> getMinMax(const double &fvalue,
                       int &minindex, int &maxindex)
    {
      (_fvaluem.head(_samplesize) - dVec::Constant(_samplesize,fvalue)).cwiseAbs().minCoeff(&minindex);
      (_fvaluem.tail(_samplesize) - dVec::Constant(_samplesize,fvalue)).cwiseAbs().minCoeff(&maxindex);
      double min = _xm(minindex,_k);
      double max = _xm(_samplesize + 1 + maxindex,_k);
      if (min > max)
    std::swap(min,max);
      return std::pair<double,double>(min,max);
    }
 
    void setMinMax()
    {
      std::pair<double,double> mm = getMinMax(_fvaluem[_samplesize]+_fup,_minindex,_maxindex);
      _min = mm.first;
      _max = mm.second;
    }
 
    void setErrMinMax()
    {
      setMinMax();
      _errmin = _min - _xm(_samplesize,_k);
      _errmax = _max - _xm(_samplesize,_k);
    }
 
    inline double get_err_min() const
    {
      return _errmin;
    }
 
    inline double get_err_max() const
    {
      return _errmax;
    }
    
    // accessors
    inline int get_k() const
    {
      return _k;
    }
 
    inline int get_samplesize() const
    {
      return _samplesize;
    }
    
    inline dVec get_fvaluem() const
    {
      return _fvaluem;
    }
 
    inline dMat get_xm() const
    {
      return _xm;
    }
 
    inline double get_min() const
    {
      return this->_min;
    }
 
    inline double get_max() const
    {
      return _max;
    }
 
    private:
    int _k = -1;
    int _samplesize = 0;
    dVec _fvaluem;
    dMat _xm; // in phenotype
    double _min = 0.0;
    double _max = 0.0;
    double _errmin = 0.0;
    double _errmax = 0.0;
    int _minindex = -1;
    int _maxindex = -1;
    std::vector<int> _err; // errors from profile likelihood computations as run status codes.
    double _fup; // the function deviation for which this profile likelihood was computed.
    double _delta; // the tolerance around fvalue + fup for which this profile likelihood was computed.
  };
 
}
 
#endif