Adding eoPopEvalFunc, that handles evaluation globally: it receives

two populations, parents and offspring, and does whatever necessary.
The subclass eoPopLoopEval does the simple loop on the offspring.

eoEasyEA was subsequently modified to handle an eoPopEval passed in Ctor,
but also to encapsulate an eoEvalFunc into an eoPopLoopEval tranparently.

eo/src/eo

@@ -60,8 +60,8 @@
 // population
 #include <eoPop.h>
 
-// Evaluation functions
-#include <eoEvalFunc.h>
+// Evaluation functions (all include eoEvalFunc.h)
+#include <eoPopEvalFunc.h>
 #include <eoEvalFuncPtr.h>
 
 // Continuators - all include eoContinue.h

eo/src/eoEasyEA.h

@@ -42,20 +42,47 @@
     and any selection transformation, merging and evaluation
     algorithms; you can even change in runtime parameters of those
     sub-algorithms 
+
+Change (MS, July 3. 2001): 
+  Replaced the eoEvalFunc by an eoPopEvalFunc: this immediately
+  allows many useful constructs, such as co-evolution (e.g. game players),
+  parisian approach (the solution to the problem is the whole population)
+  or simple distribution of evaluations on a cluster.
+  In case an eoEvalFunc is passed, it is embedded on an eoPopLoopEval
+  This makes things a little uglier (required an additional "dummy" member
+
+Note: it looks ugly only because we wanted to authorize many different
+  constructors. Please only look at the operator() and there shall be light
 */
 
 template<class EOT> class eoEasyEA: public eoAlgo<EOT>
 {
  public:
 
-  /// Ctor taking a breed and merge.
+  /** Ctor taking a breed and merge */
      eoEasyEA(
          eoContinue<EOT>& _continuator,
          eoEvalFunc<EOT>& _eval,
          eoBreed<EOT>& _breed,
          eoReplacement<EOT>& _replace     
      ) : continuator(_continuator), 
-         eval(_eval),
+	 loopEval(_eval),
+	 popEval(loopEval),
+         selectTransform(dummySelect, dummyTransform),
+         breed(_breed),
+         mergeReduce(dummyMerge, dummyReduce),
+         replace(_replace)
+         {}
+
+  /** NEW Ctor taking a breed and merge and an eoPopEval */
+     eoEasyEA(
+         eoContinue<EOT>& _continuator,
+         eoPopEvalFunc<EOT>& _eval,
+         eoBreed<EOT>& _breed,
+         eoReplacement<EOT>& _replace     
+     ) : continuator(_continuator), 
+	 loopEval(dummyEval),
+         popEval(_eval),
          selectTransform(dummySelect, dummyTransform),
          breed(_breed),
          mergeReduce(dummyMerge, dummyReduce),
@@ -70,7 +97,8 @@ template<class EOT> class eoEasyEA: public eoAlgo<EOT>
          eoMerge<EOT>& _merge,
          eoReduce<EOT>& _reduce
      ) : continuator(_continuator), 
-         eval(_eval),
+	 loopEval(_eval),
+	 popEval(loopEval),
          selectTransform(dummySelect, dummyTransform),
          breed(_breed),
          mergeReduce(_merge, _reduce),
@@ -85,7 +113,8 @@ template<class EOT> class eoEasyEA: public eoAlgo<EOT>
          eoTransform<EOT>& _transform,
          eoReplacement<EOT>& _replace     
      ) : continuator(_continuator), 
-         eval(_eval),
+	 loopEval(_eval),
+	 popEval(loopEval),
          selectTransform(_select, _transform),
          breed(selectTransform),
          mergeReduce(dummyMerge, dummyReduce),
@@ -101,7 +130,8 @@ template<class EOT> class eoEasyEA: public eoAlgo<EOT>
          eoMerge<EOT>&     _merge,
          eoReduce<EOT>&    _reduce
      ) : continuator(_continuator),
-         eval(_eval),
+	 loopEval(_eval),
+	 popEval(loopEval),
          selectTransform(_select, _transform),
          breed(selectTransform),
          mergeReduce(_merge, _reduce),
@@ -125,7 +155,7 @@ template<class EOT> class eoEasyEA: public eoAlgo<EOT>
 
          breed(_pop, offspring);
 
-         apply<EOT>(eval, offspring);
+         popEval(_pop, offspring); // eval of parents + offspring if necessary
 
          replace(_pop, offspring); // after replace, the new pop. is in _pop
 
@@ -154,9 +184,13 @@ template<class EOT> class eoEasyEA: public eoAlgo<EOT>
      class eoDummyTransform : public eoTransform<EOT>
      { public : void operator()(eoPop<EOT>&) {} } dummyTransform;
 
+  class eoDummyEval : public eoEvalFunc<EOT>
+  {public: void operator()(EOT &) {} } dummyEval;
 
   eoContinue<EOT>&          continuator;
-  eoEvalFunc<EOT>&          eval;
+
+  eoPopLoopEval<EOT>        loopEval;  
+  eoPopEvalFunc<EOT>&       popEval;
   
   eoSelectTransform<EOT>    selectTransform;
   eoBreed<EOT>&             breed;

eo/src/eoPopEvalFunc.h

@@ -0,0 +1,100 @@
+/** -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-
+
+-----------------------------------------------------------------------------
+    eoPopEvalFunc.h
+    Abstract class for global evaluation of the population
+
+    (c) GeNeura Team, 2000
+ 
+    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: todos@geneura.ugr.es, http://geneura.ugr.es
+ */
+//-----------------------------------------------------------------------------
+
+#ifndef eoPopEvalFunc_H
+#define eoPopEvalFunc_H
+
+#include <eoEvalFunc.h>
+
+/** eoPopEvalFunc: This abstract class is for GLOBAL evaluators 
+ *    of a population after variation.
+ *    It takes 2 populations (typically the parents and the offspring)
+ *    and is suppposed to evaluate them alltogether
+ *
+ *  Basic use: apply an embedded eoEvalFunc to the offspring 
+ *
+ *  Time-varying fitness: apply the embedded eoEvalFunc to both 
+ *     offspring and parents
+ *
+ *  Advanced uses: Co-evolution or "parisian" approach, or ...
+ *
+ *  Basic parallelization (synchronous standard evolution engine): 
+ *    call the slaves and wait for the results
+ */
+template<class EOT>
+class eoPopEvalFunc : public eoBF<eoPop<EOT> & , eoPop<EOT> &, void> 
+{};
+
+/////////////////////////////////////////////////////////////
+//           eoPopLoopEval
+/////////////////////////////////////////////////////////////
+
+/** eoPopLoopEval: an instance of eoPopEvalFunc that simply applies 
+ *     a private eoEvalFunc to all offspring
+ */
+template<class EOT>
+class eoPopLoopEval : public eoPopEvalFunc<EOT> {
+public:
+  /** Ctor: set value of embedded eoEvalFunc */
+  eoPopLoopEval(eoEvalFunc<EOT> & _eval) : eval(_eval) {}
+
+  /** Do the job: simple loop over the offspring */
+  void operator()(eoPop<EOT> & _parents, eoPop<EOT> & _offspring)
+  {
+    apply<EOT>(eval, _offspring);
+  }
+
+private:
+  eoEvalFunc<EOT> & eval;
+};
+
+/////////////////////////////////////////////////////////////
+//           eoTimeVaryingLoopEval
+/////////////////////////////////////////////////////////////
+
+/** eoPopLoopEval: an instance of eoPopEvalFunc that simply applies 
+ *     a private eoEvalFunc to all offspring AND ALL PARENTS
+ *     as the fitness is supposed here to vary 
+ */
+template<class EOT>
+class eoTimeVaryingLoopEval : public eoPopEvalFunc<EOT> {
+public:
+  /** Ctor: set value of embedded eoEvalFunc */
+  eoTimeVaryingLoopEval(eoEvalFunc<EOT> & _eval) : eval(_eval) {}
+
+  /** Do the job: simple loop over the offspring */
+  void operator()(eoPop<EOT> & _parents, eoPop<EOT> & _offspring)
+  {
+    apply<EOT>(eval, _parents);
+    apply<EOT>(eval, _offspring);
+  }
+
+private:
+  eoEvalFunc<EOT> & eval;
+};
+
+#endif
+