eoReduceMerge.h

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

#ifndef _eoReduceMerge_h
#define _eoReduceMerge_h


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

template <class EOT>
class eoReduceMerge : public eoReplacement<EOT>
{
    public:
        eoReduceMerge(eoReduce<EOT>& _reduce, eoMerge<EOT>& _merge) :
        reduce(_reduce), merge(_merge)
        {}

        void operator()(eoPop<EOT>& _parents, eoPop<EOT>& _offspring)
        {
          if (_parents.size() < _offspring.size())
            throw std::logic_error("eoReduceMerge: More offspring than parents!\n");
          reduce(_parents, _parents.size() - _offspring.size());
          merge(_offspring, _parents);
        }

    private :
        eoReduce<EOT>& reduce;
        eoMerge<EOT>& merge;
};

template <class EOT>
class eoSSGAWorseReplacement : public eoReduceMerge<EOT>
{
    public :
        eoSSGAWorseReplacement() : eoReduceMerge<EOT>(truncate, plus) {}

    private :
        eoLinearTruncate<EOT> truncate;
        eoPlus<EOT> plus;
};

template <class EOT>
class eoSSGADetTournamentReplacement : public eoReduceMerge<EOT>
{
    public :
        eoSSGADetTournamentReplacement(unsigned _t_size) :
          eoReduceMerge<EOT>(truncate, plus), truncate(_t_size) {}

    private :
        eoDetTournamentTruncate<EOT> truncate;
        eoPlus<EOT> plus;
};

template <class EOT>
class eoSSGAStochTournamentReplacement : public eoReduceMerge<EOT>
{
    public :
        eoSSGAStochTournamentReplacement(double _t_rate) :
          eoReduceMerge<EOT>(truncate, plus), truncate(_t_rate) {}

    private :
        eoStochTournamentTruncate<EOT> truncate;
        eoPlus<EOT> plus;
};

#endif