eoSurviveAndDie.h

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

#ifndef _eoSurviveAndDie_h
#define _eoSurviveAndDie_h


//-----------------------------------------------------------------------------
#include <eoPop.h>
#include <eoFunctor.h>
#include <eoMerge.h>
#include <eoReduce.h>
#include <utils/eoHowMany.h>
//-----------------------------------------------------------------------------

template <class EOT>
class eoSurviveAndDie : public eoBF<eoPop<EOT> &, eoPop<EOT> &, void>
{
public:
    eoSurviveAndDie(double _survive, double _die, bool _interpret_as_rate = true):
        howmanySurvive(_survive, _interpret_as_rate),
        howmanyDie(_die, _interpret_as_rate)
    {}

protected:
    eoHowMany howmanySurvive;
    eoHowMany howmanyDie;

};

template <class EOT>
class eoDeterministicSurviveAndDie : public eoSurviveAndDie<EOT>
{
public:

    using eoSurviveAndDie< EOT >::howmanyDie;
    using eoSurviveAndDie< EOT >::howmanySurvive;

    eoDeterministicSurviveAndDie(double _survive, double _die, bool _interpret_as_rate = true)
        : eoSurviveAndDie< EOT >(_survive, _die, _interpret_as_rate)
    {}


    void operator()(eoPop<EOT> & _pop, eoPop<EOT> & _luckyGuys)
    {
        unsigned pSize = _pop.size();
        unsigned nbSurvive = howmanySurvive(pSize);
        // first, save the best into _luckyGuys
        if (nbSurvive)
            {
                _pop.nth_element(nbSurvive);
                // copy best
                _luckyGuys.resize(nbSurvive);
                std::copy(_pop.begin(), _pop.begin()+nbSurvive, _luckyGuys.begin());
                // erase them from pop
                _pop.erase(_pop.begin(), _pop.begin()+nbSurvive);
            }
        unsigned nbRemaining = _pop.size();

        // carefull, we can have a rate of 1 if we want to kill all remaining
        unsigned nbDie = std::min(howmanyDie(pSize), pSize-nbSurvive);
        if (nbDie > nbRemaining)
            throw std::logic_error("eoDeterministicSurviveAndDie: Too many to kill!\n");

        if (!nbDie)
          {
            return;
          }
        // else
        // kill the worse nbDie
        _pop.nth_element(nbRemaining-nbDie);
        _pop.resize(nbRemaining-nbDie);
    }

};

template <class EOT>
class eoDeterministicSaDReplacement : public eoReplacement<EOT>
{
public:
  eoDeterministicSaDReplacement(eoReduce<EOT>& _reduceGlobal,
                 double _surviveParents, double _dieParents=0,
                 double _surviveOffspring=0, double _dieOffspring=0,
                 bool _interpret_as_rate = true ) :
        reduceGlobal(_reduceGlobal),
        sAdParents(_surviveParents, _dieParents, _interpret_as_rate),
        sAdOffspring(_surviveOffspring, _dieOffspring, _interpret_as_rate)
    {}

    eoDeterministicSaDReplacement(
                 double _surviveParents, double _dieParents=0,
                 double _surviveOffspring=0, double _dieOffspring=0,
                 bool _interpret_as_rate = true ) :
        reduceGlobal(truncate),
        sAdParents(_surviveParents, _dieParents, _interpret_as_rate),
        sAdOffspring(_surviveOffspring, _dieOffspring, _interpret_as_rate)
    {}

    void operator()(eoPop<EOT>& _parents, eoPop<EOT>& _offspring)
    {
        unsigned pSize = _parents.size(); // target number of individuals

        eoPop<EOT> luckyParents;       // to hold the absolute survivors
        sAdParents(_parents, luckyParents);

        eoPop<EOT> luckyOffspring;       // to hold the absolute survivors
        sAdOffspring(_offspring, luckyOffspring);

        unsigned survivorSize = luckyOffspring.size() + luckyParents.size();
        if (survivorSize > pSize)
            throw std::logic_error("eoGeneralReplacement: More survivors than parents!\n");

        plus(_parents, _offspring); // all that remain in _offspring

        reduceGlobal(_offspring, pSize - survivorSize);
        plus(luckyParents, _offspring);
        plus(luckyOffspring, _offspring);

        _parents.swap(_offspring);

    }

private :
  eoReduce<EOT>& reduceGlobal;
  eoDeterministicSurviveAndDie<EOT> sAdParents;
  eoDeterministicSurviveAndDie<EOT> sAdOffspring;
  // plus helper (could be replaced by operator+= ???)
  eoPlus<EOT> plus;
  // the default reduce: deterministic truncation
  eoTruncate<EOT> truncate;
};


#endif