eoReduceMergeReduce.h

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

#ifndef _eoReduceMergeReduce_h
#define _eoReduceMergeReduce_h


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

template <class EOT>
class eoReduceMergeReduce : public eoReplacement<EOT>
{
public:
  eoReduceMergeReduce(eoHowMany _howManyElite,
                      bool _strongElitism,
                      eoHowMany _howManyReducedParents,
                      eoReduce<EOT> & _reduceParents,
                      eoHowMany _howManyReducedOffspring,
                      eoReduce<EOT> & _reduceOffspring,
                      eoReduce<EOT> & _reduceFinal) :
    howManyElite(_howManyElite),
    strongElitism(_strongElitism),
    howManyReducedParents(_howManyReducedParents),
    howManyReducedOffspring (_howManyReducedOffspring),
    reduceParents(_reduceParents),
    reduceOffspring(_reduceOffspring),
    reduceFinal(_reduceFinal)
  {}

    void operator()(eoPop<EOT> & _parents, eoPop<EOT> & _offspring)
    {
      eoPop<EOT> temp;
      unsigned int finalPopSize = _parents.size();
      unsigned int offSize = _offspring.size();

      unsigned int elite = howManyElite(finalPopSize);
      if (elite)                   // some parents MUST be saved somewhere
        {
          temp.resize(elite);
          _parents.nth_element(elite);
          std::copy(_parents.begin(), _parents.begin()+elite, temp.begin());
          _parents.erase(_parents.begin(), _parents.begin()+elite);
        }

      // the reduce steps. First the parents
      unsigned reducedParentSize = howManyReducedParents(_parents.size());
      if (!reducedParentSize)
        _parents.clear();
      else if (reducedParentSize != _parents.size())
        reduceParents(_parents, reducedParentSize);

      // then the offspring
      unsigned reducedOffspringSize = howManyReducedOffspring(offSize);
      if (!reducedOffspringSize)
        throw std::runtime_error("No offspring left after reduction!");
      if (reducedOffspringSize != offSize) // need reduction
        reduceOffspring(_offspring, reducedOffspringSize);

      // now merge reduced populations
      _parents.resize(reducedParentSize + _offspring.size());
      std::copy(_offspring.begin(), _offspring.end(),
                _parents.begin()+reducedParentSize);

      // reduce the resulting population
      // size depstd::ends on elitism
      if (elite && strongElitism)
        {
          if (_parents.size() != finalPopSize-elite)
            reduceFinal(_parents, finalPopSize-elite);
          // and put back the elite
          unsigned oldPSize = _parents.size();
          _parents.resize(_parents.size()+elite);
          std::copy(temp.begin(), temp.end(), _parents.begin()+oldPSize);
        }
      else
        {                   // only reduce final pop to right size
          if (_parents.size() != finalPopSize)
            reduceFinal(_parents, finalPopSize);
          if (elite)       // then treat weak elitism
            {
              unsigned toSave = 0;
              _parents.sort();
              EOT & eoLimit = _parents[elite-1];
              unsigned index=0;
              while ( (temp[index++] > eoLimit) && (index < temp.size()) )
                toSave++;
              if (toSave)
                for (unsigned i=0; i<toSave; i++)
                  _parents[finalPopSize-1-i] = temp[i];
            }
        }
    }

private:
  eoHowMany howManyElite;          // if 0, no elitism at all
  bool strongElitism;              // if false -> weak estd::listism
  eoHowMany howManyReducedParents; // if 0, no parent in final replacement
  eoHowMany howManyReducedOffspring; // if 0, std::runtime_error
  // the reducers
  eoReduce<EOT> & reduceParents;
  eoReduce<EOT> & reduceOffspring;
  eoReduce<EOT> & reduceFinal;
};

#endif