eoPerf2Worth.h

//-----------------------------------------------------------------------------

#ifndef eoPerf2Worth_h
#define eoPerf2Worth_h

#include <utils/eoParam.h>
#include <eoPop.h>
#include <eoFunctor.h>

#include <algorithm>
#include <vector>
#include <string>

template <class EOT, class WorthT = double>
class eoPerf2Worth : public eoUF<const eoPop<EOT>&, void>, public eoValueParam<std::vector<WorthT> >
{
public:

    using eoValueParam<std::vector<WorthT> >::value;

    eoPerf2Worth(std::string _description = "Worths")
        : eoValueParam<std::vector<WorthT> >(std::vector<WorthT>(0), _description)
        {}

  virtual void sort_pop(eoPop<EOT>& _pop)
  { // start with a std::vector of indices
      std::vector<unsigned> indices(_pop.size());

    unsigned i;
    for (i = 0; i < _pop.size();++i)
    { // could use generate, but who cares
      indices[i] = i;
    }

    std::sort(indices.begin(), indices.end(), compare_worth(value()));

    eoPop<EOT>      tmp_pop;
    tmp_pop.resize(_pop.size());
    std::vector<WorthT>  tmp_worths(value().size());

    for (i = 0; i < _pop.size(); ++i)
    {
      tmp_pop[i] = _pop[indices[i]];
      tmp_worths[i] = value()[indices[i]];
    }

    std::swap(_pop, tmp_pop);
    std::swap(value(), tmp_worths);
  }

    class compare_worth
    {
    public:

        compare_worth(const std::vector<WorthT>& _worths) : worths(_worths) {}

        bool operator()(unsigned a, unsigned b) const {
            return worths[b] < worths[a]; // sort in descending (!) order
        }

    private:

        const std::vector<WorthT>& worths;
    };



    virtual void resize(eoPop<EOT>& _pop, unsigned sz) {
        _pop.resize(sz);
        value().resize(sz);
    };

};

template <class EOT, class WorthT = typename EOT::Fitness>
class eoPerf2WorthCached : public eoPerf2Worth<EOT, WorthT>
{
public:

    using eoPerf2Worth<EOT, WorthT>::value;

    eoPerf2WorthCached(std::string _description = "Worths") : eoPerf2Worth<EOT, WorthT>(_description) {}


  void operator()(const eoPop<EOT>& _pop)
  {
    unsigned i;
      if (fitness_cache.size() == _pop.size())
      {
        bool in_sync = true;
        for (i = 0; i < _pop.size(); ++i)
        {
          if (fitness_cache[i] != _pop[i].fitness())
          {
            in_sync = false;
            fitness_cache[i] = _pop[i].fitness();
          }
        }

        if (in_sync)
        { // worths are up to date
          return;
        }
      }
      else // just cache the fitness
      {
        fitness_cache.resize(_pop.size());
        for (i = 0; i < _pop.size(); ++i)
        {
          fitness_cache[i] = _pop[i].fitness();
        }
      }

    // call derived implementation of perf2worth mapping
    calculate_worths(_pop);
  }

  virtual void calculate_worths(const eoPop<EOT>& _pop) = 0;

  virtual void sort_pop(eoPop<EOT>& _pop)
  { // start with a std::vector of indices
      std::vector<unsigned> indices(_pop.size());

    unsigned i;
    for (i = 0; i < _pop.size();++i)
    { // could use generate, but who cares
      indices[i] = i;
    }

    std::sort(indices.begin(), indices.end(), compare_worth(value()));

    eoPop<EOT>      tmp_pop;
    tmp_pop.resize(_pop.size());
    std::vector<WorthT>  tmp_worths(value().size());

#ifdef _MSC_VER
    std::vector<EOT::Fitness> tmp_cache(_pop.size());
#else
    std::vector<typename EOT::Fitness> tmp_cache(_pop.size());
#endif
    for (i = 0; i < _pop.size(); ++i)
    {
      tmp_pop[i] = _pop[indices[i]];
      tmp_worths[i] = value()[indices[i]];

      tmp_cache[i] = fitness_cache[indices[i]];
    }

    std::swap(_pop, tmp_pop);
    std::swap(value(), tmp_worths);
    std::swap(fitness_cache, tmp_cache);
  }

  class compare_worth
  {
  public :
    compare_worth(const std::vector<WorthT>& _worths) : worths(_worths) {}

    bool operator()(unsigned a, unsigned b) const
    {
      return worths[b] < worths[a]; // sort in descending (!) order
    }

  private :

    const std::vector<WorthT>& worths;
  };

  virtual void resize(eoPop<EOT>& _pop, unsigned sz)
  {
    _pop.resize(sz);
    value().resize(sz);
    fitness_cache.resize(sz);
  }

  private :
  std::vector <typename EOT::Fitness> fitness_cache;
};



template <class EOT>
class eoNoPerf2Worth : public eoPerf2Worth<EOT, typename EOT::Fitness>
{
public:

    using eoValueParam< EOT >::value;

    // default behaviour, just copy fitnesses
    void operator()(const eoPop<EOT>& _pop) {
        unsigned i;
        value().resize(_pop.size());
        for (i = 0; i < _pop.size(); ++i)
            value()[i]=_pop[i];
    }
};



#endif