00001
00025
00026
00027 #ifndef _eoSurviveAndDie_h
00028 #define _eoSurviveAndDie_h
00029
00030
00031
00032 #include <eoPop.h>
00033 #include <eoFunctor.h>
00034 #include <eoMerge.h>
00035 #include <eoReduce.h>
00036 #include <utils/eoHowMany.h>
00037
00038
00052 template <class EOT>
00053 class eoSurviveAndDie : public eoBF<eoPop<EOT> &, eoPop<EOT> &, void>
00054 {
00055 public:
00056 eoSurviveAndDie(double _survive, double _die, bool _interpret_as_rate = true):
00057 howmanySurvive(_survive, _interpret_as_rate),
00058 howmanyDie(_die, _interpret_as_rate)
00059 {}
00060
00061 protected:
00062 eoHowMany howmanySurvive;
00063 eoHowMany howmanyDie;
00064
00065 };
00066
00072 template <class EOT>
00073 class eoDeterministicSurviveAndDie : public eoSurviveAndDie<EOT>
00074 {
00075 public:
00076
00077 using eoSurviveAndDie< EOT >::howmanyDie;
00078 using eoSurviveAndDie< EOT >::howmanySurvive;
00079
00081 eoDeterministicSurviveAndDie(double _survive, double _die, bool _interpret_as_rate = true)
00082 : eoSurviveAndDie< EOT >(_survive, _die, _interpret_as_rate)
00083 {}
00084
00085
00086 void operator()(eoPop<EOT> & _pop, eoPop<EOT> & _luckyGuys)
00087 {
00088 unsigned pSize = _pop.size();
00089 unsigned nbSurvive = howmanySurvive(pSize);
00090
00091 if (nbSurvive)
00092 {
00093 _pop.nth_element(nbSurvive);
00094
00095 _luckyGuys.resize(nbSurvive);
00096 std::copy(_pop.begin(), _pop.begin()+nbSurvive, _luckyGuys.begin());
00097
00098 _pop.erase(_pop.begin(), _pop.begin()+nbSurvive);
00099 }
00100 unsigned nbRemaining = _pop.size();
00101
00102
00103 unsigned nbDie = std::min(howmanyDie(pSize), pSize-nbSurvive);
00104 if (nbDie > nbRemaining)
00105 throw std::logic_error("eoDeterministicSurviveAndDie: Too many to kill!\n");
00106
00107 if (!nbDie)
00108 {
00109 return;
00110 }
00111
00112
00113 _pop.nth_element(nbRemaining-nbDie);
00114 _pop.resize(nbRemaining-nbDie);
00115 }
00116
00117 };
00118
00131 template <class EOT>
00132 class eoDeterministicSaDReplacement : public eoReplacement<EOT>
00133 {
00134 public:
00136 eoDeterministicSaDReplacement(eoReduce<EOT>& _reduceGlobal,
00137 double _surviveParents, double _dieParents=0,
00138 double _surviveOffspring=0, double _dieOffspring=0,
00139 bool _interpret_as_rate = true ) :
00140 reduceGlobal(_reduceGlobal),
00141 sAdParents(_surviveParents, _dieParents, _interpret_as_rate),
00142 sAdOffspring(_surviveOffspring, _dieOffspring, _interpret_as_rate)
00143 {}
00144
00146 eoDeterministicSaDReplacement(
00147 double _surviveParents, double _dieParents=0,
00148 double _surviveOffspring=0, double _dieOffspring=0,
00149 bool _interpret_as_rate = true ) :
00150 reduceGlobal(truncate),
00151 sAdParents(_surviveParents, _dieParents, _interpret_as_rate),
00152 sAdOffspring(_surviveOffspring, _dieOffspring, _interpret_as_rate)
00153 {}
00154
00155 void operator()(eoPop<EOT>& _parents, eoPop<EOT>& _offspring)
00156 {
00157 unsigned pSize = _parents.size();
00158
00159 eoPop<EOT> luckyParents;
00160 sAdParents(_parents, luckyParents);
00161
00162 eoPop<EOT> luckyOffspring;
00163 sAdOffspring(_offspring, luckyOffspring);
00164
00165 unsigned survivorSize = luckyOffspring.size() + luckyParents.size();
00166 if (survivorSize > pSize)
00167 throw std::logic_error("eoGeneralReplacement: More survivors than parents!\n");
00168
00169 plus(_parents, _offspring);
00170
00171 reduceGlobal(_offspring, pSize - survivorSize);
00172 plus(luckyParents, _offspring);
00173 plus(luckyOffspring, _offspring);
00174
00175 _parents.swap(_offspring);
00176
00177 }
00178
00179 private :
00180 eoReduce<EOT>& reduceGlobal;
00181 eoDeterministicSurviveAndDie<EOT> sAdParents;
00182 eoDeterministicSurviveAndDie<EOT> sAdOffspring;
00183
00184 eoPlus<EOT> plus;
00185
00186 eoTruncate<EOT> truncate;
00187 };
00188
00189
00190
00191 #endif