move paradiseo/eo to deprecated/ before merge with eodev

deprecated/eo/src/eoSelectFromWorth.h

@@ -0,0 +1,231 @@
+/** -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+   -----------------------------------------------------------------------------
+   eoSelectFromWorth.h
+   (c) Maarten Keijzer, Marc Schoenauer, 2001
+
+   This library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Lesser General Public
+   License as published by the Free Software Foundation; either
+   version 2 of the License, or (at your option) any later version.
+
+   This library is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   Lesser General Public License for more details.
+
+   You should have received a copy of the GNU Lesser General Public
+   License along with this library; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+    Contact: Marc.Schoenauer@polytechnique.fr
+             mkeijzer@dhi.dk
+ */
+//-----------------------------------------------------------------------------
+
+#ifndef _eoSelectFromWorth_h
+#define _eoSelectFromWorth_h
+
+#include <iostream>
+//-----------------------------------------------------------------------------
+#include <eoSelectOne.h>
+#include <eoPerf2Worth.h>
+#include <utils/selectors.h>
+//-----------------------------------------------------------------------------
+
+/** selects one element from a population (is an eoSelectOne)
+but the selection is based on a std::vector of Worth that is different
+from the fitnesses (e.g. EO fitness is what Koza terms "raw fitness",
+Worth is what the selection is based upon).
+
+see class eoPerf2Worth: an eoStat that transforms fitnesses into Worthes
+
+Note: Worthes will not always be doubles - see some multi-objective
+techniques where it is a std::pair of doubles ...
+
+It has to have a < operator it you want to call an existing
+selector (see selector.h) - but of course you can write the whole
+thing ...
+
+@ingroup Selectors
+*/
+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
+};
+
+
+/** An instance of eoSelectPerf2Worth that does selection from the Worthes
+ *  using a ... determinisitic tournament, yes!
+
+@ingroup Selectors
+ */
+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;
+};
+
+/** An instance of eoSelectPerf2Worth that does selection from the Worthes
+ *  using a ... stochastic tournament, yes!
+
+@ingroup Selectors
+ */
+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;
+};
+
+/** An instance of eoSelectPerf2Worth that does selection from the Worthes
+ *  using a ... roulette wheel selection, yes!
+
+@ingroup Selectors
+ */
+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