eoSelectFromWorth.h

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

#ifndef _eoSelectFromWorth_h
#define _eoSelectFromWorth_h

#include <iostream>
//-----------------------------------------------------------------------------
#include <eoSelectOne.h>
#include <eoPerf2Worth.h>
#include <utils/selectors.h>
//-----------------------------------------------------------------------------

template <class EOT, class WorthType = double>
class eoSelectFromWorth : public eoSelectOne<EOT>
{
public:

    /* Default ctor from an eoPerf2Worth object */
    eoSelectFromWorth(eoPerf2Worth<EOT, WorthType>& _perf2Worth)
        : perf2Worth(_perf2Worth)
        {}

    /* setup the worthes */
    virtual void setup(const eoPop<EOT>& pop) {
        perf2Worth(pop);
#ifndef NDEBUG
        fitness.resize(pop.size());
        for (unsigned i = 0; i < pop.size(); ++i) {
            fitness[i] = pop[i].fitness();
        }
#endif
    }


protected:

    eoPerf2Worth<EOT, WorthType>& perf2Worth;

#ifndef NDEBUG
    std::vector<typename EOT::Fitness> fitness;
    void check_sync(unsigned index, const EOT& _eo) {
        if (fitness[index] != _eo.fitness()) {
            throw std::runtime_error("eoSelectFromWorth: fitnesses are not in sync");
        }
    }
#endif
};


template <class EOT, class WorthT = double>
class eoDetTournamentWorthSelect : public eoSelectFromWorth<EOT, WorthT>
{
public:

    using eoSelectFromWorth<EOT, WorthT>::perf2Worth;

    typedef typename std::vector<WorthT>::iterator worthIterator;

    /* Default ctor from an eoPerf2Worth object +  tournament size */
    eoDetTournamentWorthSelect(eoPerf2Worth<EOT, WorthT>& perf2Worth,
                               unsigned _tSize)
        : eoSelectFromWorth<EOT, WorthT>(perf2Worth), tSize(_tSize) {}

    /* Perform deterministic tournament on worthes by calling the
       appropriate fn see selectors.h */
    virtual const EOT& operator()(const eoPop<EOT>& pop) {
        worthIterator it = deterministic_tournament(perf2Worth.value().begin(),
                                                    perf2Worth.value().end(),
                                                    tSize);
        unsigned index = it - perf2Worth.value().begin();
#ifndef NDEBUG
        // check whether the stuff is still in sync
        check_sync(index, pop[index]);
#endif
        return pop[index];
    }


private:

    unsigned tSize;
};

template <class EOT, class WorthT = double>
class eoStochTournamentWorthSelect : public eoSelectFromWorth<EOT, WorthT>
{
public:

    using eoSelectFromWorth<EOT, WorthT>::perf2Worth;

    typedef typename std::vector<WorthT>::iterator worthIterator;

    /* Default ctor from an eoPerf2Worth object +  tournament rate */
    eoStochTournamentWorthSelect(eoPerf2Worth<EOT, WorthT> &_perf2Worth, double _tRate)
        : eoSelectFromWorth<EOT, WorthT>(_perf2Worth), tRate(_tRate)
        {}

  /* Perform stochastic tournament on worthes
     by calling the appropriate fn in selectors.h
  */
  virtual const EOT& operator()(const eoPop<EOT>& _pop) {
      worthIterator it = stochastic_tournament(perf2Worth.value().begin(),
                                               perf2Worth.value().end(),
                                               tRate);

    unsigned index = it - perf2Worth.value().begin();

#ifndef NDEBUG
  // check whether the stuff is still in sync
  check_sync(index, _pop[index]);
#endif

    return _pop[index];
  }

private:
  double tRate;
};

template <class EOT, class WorthT = double>
class eoRouletteWorthSelect : public eoSelectFromWorth<EOT, WorthT>
{
public:

    using eoSelectFromWorth<EOT, WorthT>::perf2Worth;

    typedef typename std::vector<WorthT>::iterator worthIterator;


    /* Default ctor from an eoPerf2Worth object */
    eoRouletteWorthSelect(eoPerf2Worth<EOT, WorthT> &_perf2Worth)
        : eoSelectFromWorth<EOT, WorthT>(_perf2Worth)
        {}

  /* We have to override the default behavior to compute the total
   * only once!
   */
  virtual void setup(const eoPop<EOT>& _pop)
  {
    eoSelectFromWorth<EOT, WorthT>::setup(_pop);
    total = 0.0;
    for (worthIterator it = perf2Worth.value().begin();
         it<perf2Worth.value().end(); ++it)
      total += (*it);
  }

  /* Perform roulette wheel on worthes
     by calling the appropriate fn
     see selectors.h
  */
  virtual const EOT& operator()(const eoPop<EOT>& _pop) {
 //     cout << "On affiche les worths\n";
 //     for (unsigned i=0;
 //      i<perf2Worth.value().size();
 //      i++)
 //       cout << perf2Worth.value().operator[](i) << "\n";
 //     cout << endl;
      worthIterator it = roulette_wheel(perf2Worth.value().begin(),
                                        perf2Worth.value().end(),
                                        total);

   unsigned index = it - perf2Worth.value().begin();

#ifndef NDEBUG
  // check whether the stuff is still in sync
  this->check_sync(index, _pop[index]);
#endif

    return _pop[index];
    return _pop[it - perf2Worth.value().begin()];
  }

private:
  double total;
};

#endif