Correction des continuators, Ajout dans lesson 1

git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@1765 331e1502-861f-0410-8da2-ba01fb791d7f

trunk/paradiseo-mo/src/continuator/moFullEvalContinuator.h

@@ -36,27 +36,32 @@ Contact: paradiseo-help@lists.gforge.inria.fr
 
 /**
  * Continue until a maximum fixed number of full evaluation is reached
+ *
+ * Becareful 1: The number of full evaluations considered is within the local search (not before it) 
+ * Becareful 2: Can not be used if the evaluation function is used in parallel
  */
 template< class Neighbor >
 class moFullEvalContinuator : public moContinuator<Neighbor>
 {
 public:
-    typedef typename Neighbor::EOT EOT ;
+  typedef typename Neighbor::EOT EOT ;
 
   /**
    * Default constructor
    * @param _eval evaluation function to count
    * @param _maxFullEval number maximum of iterations
    */
-  moFullEvalContinuator(eoEvalFuncCounter<EOT> & _eval, unsigned int _maxFullEval): maxFullEval(_maxFullEval){}
-
+  moFullEvalContinuator(eoEvalFuncCounter<EOT> & _eval, unsigned int _maxFullEval): eval(_eval), maxFullEval(_maxFullEval) {
+    nbEval_start = eval.value();
+  }
+  
   /**
    * Test if continue
    *@param _solution a solution
    *@return true if number of evaluations < maxFullEval
    */
   virtual bool operator()(EOT & _solution) {
-    return (eval.value()  < maxFullEval);
+    return (eval.value() - nbEval_start < maxFullEval);
   }
   
   /**
@@ -64,12 +69,21 @@ public:
    * @param _solution a solution
    */
   virtual void init(EOT & _solution) {
-    eval.value() = 0;
+    nbEval_start = eval.value();
   }
   
+    /**
+     * the current number of evaluation from the begining
+     * @return the number of evaluation
+     */
+    unsigned int value() {
+      return eval.value() - nbEval_start ;
+    }
+
 private:
   eoEvalFuncCounter<EOT> & eval;
-  unsigned int maxFullEval;
+  unsigned int nbEval_start ;
+  unsigned int maxFullEval ;
   
 };
 #endif

trunk/paradiseo-mo/src/continuator/moIterContinuator.h

@@ -51,7 +51,8 @@ public:
      *@return true if counter < maxIter
      */
     virtual bool operator()(EOT & _solution) {
-        return (cpt++ < maxIter);
+      cpt++;
+      return (cpt < maxIter);
     }
 
     /**
@@ -59,7 +60,15 @@ public:
      * @param _solution a solution
      */
     virtual void init(EOT & _solution) {
-    	cpt=0;
+    	cpt = 0;
+    }
+
+    /**
+     * the current number of iteration
+     * @return the number of iteration
+     */
+    unsigned int value() {
+      return cpt ;
     }
 
 private:

trunk/paradiseo-mo/src/continuator/moNeighborEvalContinuator.h

@@ -36,6 +36,9 @@ Contact: paradiseo-help@lists.gforge.inria.fr
 
 /**
  * Continue until a maximum fixed number of neighbor evaluation is reached
+ *
+ * Becareful 1: The number of full evaluations considered is within the local search (not before it) 
+ * Becareful 2: Can not be used if the evaluation function is used in parallel
  */
 template< class Neighbor >
 class moNeighborEvalContinuator : public moContinuator<Neighbor>
@@ -48,15 +51,15 @@ public:
    * @param _eval neighbor evaluation function to count
    * @param _maxNeighborEval number maximum of iterations
    */
-  moNeighborEvalContinuator(moEvalCounter<Neighbor> & _eval, unsigned int _maxNeighborEval): maxNeighborEval(_maxNeighborEval){}
+ moNeighborEvalContinuator(moEvalCounter<Neighbor> & _eval, unsigned int _maxNeighborEval): eval(_eval), maxNeighborEval(_maxNeighborEval){}
 
   /**
    * Test if continue
-   *@param _solution a solution
-   *@return true if number of evaluations < maxNeighborEval
+   * @param _solution a solution
+   * @return true if number of evaluations < maxNeighborEval
    */
   virtual bool operator()(EOT & _solution) {
-    return (eval.value()  < maxNeighborEval);
+    return (eval.value() - nbEval_start < maxNeighborEval);
   }
   
   /**
@@ -64,12 +67,21 @@ public:
    * @param _solution a solution
    */
   virtual void init(EOT & _solution) {
-    eval.value() = 0;
+    nbEval_start = eval.value();
+  }
+  
+  /**
+   * the current number of evaluation from the begining
+   * @return the number of evaluation
+   */
+  unsigned int value() {
+    return eval.value() - nbEval_start ;
   }
   
 private:
   moEvalCounter<Neighbor> & eval;
   unsigned int maxNeighborEval;
+  unsigned int nbEval_start ;
   
 };
 #endif

trunk/paradiseo-mo/tutorial/Lesson1/CMakeLists.txt

@@ -9,10 +9,18 @@ ADD_EXECUTABLE(lesson1_simpleHC lesson1_simpleHC.cpp)
 ADD_EXECUTABLE(lesson1_firstImprHC lesson1_firstImprHC.cpp) 
 ADD_EXECUTABLE(lesson1_randomBestHC lesson1_randomBestHC.cpp) 
 ADD_EXECUTABLE(lesson1_neutralHC lesson1_neutralHC.cpp) 
-ADD_EXECUTABLE(lesson1_continuator lesson1_continuator.cpp) 
+ADD_EXECUTABLE(lesson1_iterContinuator lesson1_iterContinuator.cpp) 
+ADD_EXECUTABLE(lesson1_fitContinuator lesson1_fitContinuator.cpp) 
+ADD_EXECUTABLE(lesson1_fullevalContinuator lesson1_fullevalContinuator.cpp) 
+ADD_EXECUTABLE(lesson1_evalContinuator lesson1_evalContinuator.cpp) 
+ADD_EXECUTABLE(lesson1_combinedContinuator lesson1_combinedContinuator.cpp) 
 
 TARGET_LINK_LIBRARIES(lesson1_simpleHC eoutils ga eo) 
 TARGET_LINK_LIBRARIES(lesson1_firstImprHC eoutils ga eo) 
 TARGET_LINK_LIBRARIES(lesson1_randomBestHC eoutils ga eo) 
 TARGET_LINK_LIBRARIES(lesson1_neutralHC eoutils ga eo) 
-TARGET_LINK_LIBRARIES(lesson1_continuator eoutils ga eo) 
+TARGET_LINK_LIBRARIES(lesson1_iterContinuator eoutils ga eo) 
+TARGET_LINK_LIBRARIES(lesson1_fitContinuator eoutils ga eo) 
+TARGET_LINK_LIBRARIES(lesson1_fullevalContinuator eoutils ga eo) 
+TARGET_LINK_LIBRARIES(lesson1_evalContinuator eoutils ga eo) 
+TARGET_LINK_LIBRARIES(lesson1_combinedContinuator eoutils ga eo) 

trunk/paradiseo-mo/tutorial/Lesson1/lesson1_combinedContinuator.cpp

@@ -0,0 +1,251 @@
+//-----------------------------------------------------------------------------
+/** lesson1_combinedContinuator.cpp
+ *
+ * SV - 27/04/10 - version 1
+ *
+ */
+//-----------------------------------------------------------------------------
+
+// standard includes
+#define HAVE_SSTREAM
+
+#include <stdexcept>  // runtime_error 
+#include <iostream>   // cout
+#include <sstream>    // ostrstream, istrstream
+#include <fstream>
+#include <string.h>
+
+// the general include for eo
+#include <eo>
+
+// declaration of the namespace
+using namespace std;
+
+//-----------------------------------------------------------------------------
+// representation of solutions, and neighbors
+#include <ga/eoBit.h>                         // bit string : see also EO tutorial lesson 1: FirstBitGA.cpp
+#include <problems/bitString/moBitNeighbor.h> // neighbor of bit string
+
+//-----------------------------------------------------------------------------
+// fitness function, and evaluation of neighbors
+#include <eval/oneMaxEval.h>
+#include <problems/eval/moOneMaxIncrEval.h>
+#include <eval/moFullEvalByModif.h>
+
+//-----------------------------------------------------------------------------
+// neighborhood description
+#include <neighborhood/moOrderNeighborhood.h> // visit all neighbors in increasing order of bit index
+
+//-----------------------------------------------------------------------------
+// the continuators
+#include <eoEvalFuncCounter.h>    // to import the fitness counter
+#include <eval/moEvalCounter.h>   // to import the neighbor evaluation counter
+#include <continuator/moIterContinuator.h>
+#include <continuator/moFitContinuator.h>
+#include <continuator/moFullEvalContinuator.h>
+#include <continuator/moNeighborEvalContinuator.h>
+#include <continuator/moCombinedContinuator.h>
+
+//-----------------------------------------------------------------------------
+// the simple Hill-Climbing local search
+#include <algo/moSimpleHC.h>
+
+// Declaration of types
+//-----------------------------------------------------------------------------
+// Indi is the typedef of the solution type like in paradisEO-eo
+typedef eoBit<unsigned int> Indi;                      // bit string with unsigned fitness type
+// Neighbor is the typedef of the neighbor type,
+// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)  
+// all classes from paradisEO-mo use this template type
+typedef moBitNeighbor<unsigned int> Neighbor ;         // bit string neighbor with unsigned fitness type
+
+
+// Main function
+//-----------------------------------------------------------------------------
+void main_function(int argc, char **argv)
+{
+  /* =========================================================
+   *
+   * Parameters from parser
+   *
+   * ========================================================= */
+  // more information on the input parameters: see EO tutorial lesson 3
+  // but don't care at first it just read the parameters of the bit string size and the random seed.
+
+  // First define a parser from the command-line arguments
+  eoParser parser(argc, argv);
+
+  // For each parameter, define Parameter, read it through the parser,
+  // and assign the value to the variable
+
+  // random seed parameter
+  eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
+  parser.processParam( seedParam );
+  unsigned seed = seedParam.value();
+
+  // length of the bit string
+  eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
+  parser.processParam( vecSizeParam, "Representation" );
+  unsigned vecSize = vecSizeParam.value();
+
+  // maximum number of full evaluation
+  eoValueParam<unsigned int> fevalParam(2, "fulleval", "Maximum number of full evaluation");
+  parser.processParam( fevalParam, "Representation" );
+  unsigned fullevalMax = fevalParam.value();
+
+  // maximum number of full evaluation
+  eoValueParam<unsigned int> evalParam(30, "eval", "Maximum number of neighbor evaluation", 'e');
+  parser.processParam( evalParam, "Representation" );
+  unsigned evalMax = evalParam.value();
+
+  // maximum fitness to reach
+  eoValueParam<unsigned int> fitParam(16, "fitness", "Maximum fitness value to reach", 'f');
+  parser.processParam( fitParam, "Representation" );
+  unsigned fitnessMax = fitParam.value();
+
+  // maximum number of iterations
+  eoValueParam<unsigned int> iterParam(10, "iter", "Maximum number of iterations", 'i');
+  parser.processParam( iterParam, "Representation" );
+  unsigned iterMax = iterParam.value();
+
+  // the name of the "status" file where all actual parameter values will be saved
+  string str_status = parser.ProgramName() + ".status"; // default value
+  eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
+  parser.processParam( statusParam, "Persistence" );
+
+  // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
+  // i.e. in case you need parameters somewhere else, postpone these
+  if (parser.userNeedsHelp()) {
+    parser.printHelp(cout);
+    exit(1);
+  }
+  if (statusParam.value() != "") {
+    ofstream os(statusParam.value().c_str());
+    os << parser;// and you can use that file as parameter file
+  }
+
+  /* =========================================================
+   *
+   * Random seed
+   *
+   * ========================================================= */
+
+  // reproducible random seed: if you don't change SEED above,
+  // you'll aways get the same result, NOT a random run
+  // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
+  rng.reseed(seed);
+
+  /* =========================================================
+   *
+   * Initialization of the solution
+   *
+   * ========================================================= */
+
+  // a Indi random initializer: each bit is random
+  // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
+  eoUniformGenerator<bool> uGen;
+  eoInitFixedLength<Indi> random(vecSize, uGen);
+
+  /* =========================================================
+   *
+   * Eval fitness function (full evaluation)
+   *
+   * ========================================================= */
+
+  // the fitness function is just the number of 1 in the bit string
+  oneMaxEval<Indi> fullEvalTmp;
+
+  // to count the number of full evaluation
+  eoEvalFuncCounter<Indi> fullEval(fullEvalTmp);
+
+  /* =========================================================
+   *
+   * evaluation of a neighbor solution
+   *
+   * ========================================================= */
+
+  // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
+  // moFullEvalByModif<Neighbor> neighborEval(fullEval);
+
+  // Incremental evaluation of the neighbor: fitness is modified by +/- 1
+  moOneMaxIncrEval<Neighbor> neighborEvalTmp;
+
+  // to count the number of neighbor evaluation
+  moEvalCounter<Neighbor> neighborEval(neighborEvalTmp);
+
+  /* =========================================================
+   *
+   * the neighborhood of a solution
+   *
+   * ========================================================= */
+
+  // Exploration of the neighborhood in increasing order of the neigbor's index:
+  // bit-flip from bit 0 to bit (vecSize - 1)
+  moOrderNeighborhood<Neighbor> neighborhood(vecSize);
+
+  /* =========================================================
+   *
+   * the external continuators
+   *
+   * ========================================================= */
+
+  moIterContinuator<Neighbor> iterCont(iterMax);
+  moFitContinuator<Neighbor> fitCont(fitnessMax); 
+  moFullEvalContinuator<Neighbor> fullevalCont(fullEval, fullevalMax);
+  moNeighborEvalContinuator<Neighbor> evalCont(neighborEval, evalMax);
+
+  moCombinedContinuator<Neighbor> continuator(iterCont);
+  continuator.add(fitCont);
+  continuator.add(fullevalCont);
+  continuator.add(evalCont);
+
+  /* =========================================================
+   *
+   * the local search algorithm
+   *
+   * ========================================================= */
+
+  moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval, continuator);
+
+  /* =========================================================
+   *
+   * executes the local search from a random solution
+   *
+   * ========================================================= */
+
+  // The current solution
+  Indi solution;
+
+  // Apply random initialization
+  random(solution);
+
+  // Evaluation of the initial solution:
+  // can be evaluated here, or else it will be done at the beginning of the local search
+  fullEval(solution);
+
+  // Output: the intial solution 
+  std::cout << "initial: " << solution << std::endl ;
+
+  // Apply the local search on the solution !
+  hc(solution);
+
+  // Output: the final solution 
+  std::cout << "final:   " << solution << std::endl ;
+  std::cout << "number of iteration: " << iterCont.value() << std::endl ;
+  std::cout << "Number of full evaluations during the local search: " << fullevalCont.value() << std::endl ;
+  std::cout << "Number of neighbor evaluations during the local search: " << evalCont.value() << std::endl ;
+
+}
+
+// A main that catches the exceptions
+
+int main(int argc, char **argv)
+{
+  try {
+    main_function(argc, argv);
+  }
+  catch (exception& e) {
+    cout << "Exception: " << e.what() << '\n';
+  }
+  return 1;
+}

trunk/paradiseo-mo/tutorial/Lesson1/lesson1_evalContinuator.cpp

@@ -0,0 +1,218 @@
+//-----------------------------------------------------------------------------
+/** lesson1_continuator.cpp
+ *
+ * SV - 27/04/10 - version 1
+ *
+ */
+//-----------------------------------------------------------------------------
+
+// standard includes
+#define HAVE_SSTREAM
+
+#include <stdexcept>  // runtime_error 
+#include <iostream>   // cout
+#include <sstream>    // ostrstream, istrstream
+#include <fstream>
+#include <string.h>
+
+// the general include for eo
+#include <eo>
+
+// declaration of the namespace
+using namespace std;
+
+//-----------------------------------------------------------------------------
+// representation of solutions, and neighbors
+#include <ga/eoBit.h>                         // bit string : see also EO tutorial lesson 1: FirstBitGA.cpp
+#include <problems/bitString/moBitNeighbor.h> // neighbor of bit string
+
+//-----------------------------------------------------------------------------
+// fitness function, and evaluation of neighbors
+#include <eval/oneMaxEval.h>
+#include <problems/eval/moOneMaxIncrEval.h>
+#include <eval/moFullEvalByModif.h>
+
+//-----------------------------------------------------------------------------
+// neighborhood description
+#include <neighborhood/moOrderNeighborhood.h> // visit all neighbors in increasing order of bit index
+
+//-----------------------------------------------------------------------------
+// the continuator based on the number of neighbor evaluations
+#include <eval/moEvalCounter.h>   // to import the neighbor evaluation counter
+#include <continuator/moNeighborEvalContinuator.h>
+
+//-----------------------------------------------------------------------------
+// the simple Hill-Climbing local search
+#include <algo/moSimpleHC.h>
+
+// Declaration of types
+//-----------------------------------------------------------------------------
+// Indi is the typedef of the solution type like in paradisEO-eo
+typedef eoBit<unsigned int> Indi;                      // bit string with unsigned fitness type
+// Neighbor is the typedef of the neighbor type,
+// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)  
+// all classes from paradisEO-mo use this template type
+typedef moBitNeighbor<unsigned int> Neighbor ;         // bit string neighbor with unsigned fitness type
+
+
+// Main function
+//-----------------------------------------------------------------------------
+void main_function(int argc, char **argv)
+{
+  /* =========================================================
+   *
+   * Parameters from parser
+   *
+   * ========================================================= */
+  // more information on the input parameters: see EO tutorial lesson 3
+  // but don't care at first it just read the parameters of the bit string size and the random seed.
+
+  // First define a parser from the command-line arguments
+  eoParser parser(argc, argv);
+
+  // For each parameter, define Parameter, read it through the parser,
+  // and assign the value to the variable
+
+  // random seed parameter
+  eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
+  parser.processParam( seedParam );
+  unsigned seed = seedParam.value();
+
+  // length of the bit string
+  eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
+  parser.processParam( vecSizeParam, "Representation" );
+  unsigned vecSize = vecSizeParam.value();
+
+  // maximum number of full evaluation
+  eoValueParam<unsigned int> evalParam(30, "eval", "Maximum number of neighbor evaluation", 'e');
+  parser.processParam( evalParam, "Representation" );
+  unsigned evalMax = evalParam.value();
+
+  // the name of the "status" file where all actual parameter values will be saved
+  string str_status = parser.ProgramName() + ".status"; // default value
+  eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
+  parser.processParam( statusParam, "Persistence" );
+
+  // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
+  // i.e. in case you need parameters somewhere else, postpone these
+  if (parser.userNeedsHelp()) {
+    parser.printHelp(cout);
+    exit(1);
+  }
+  if (statusParam.value() != "") {
+    ofstream os(statusParam.value().c_str());
+    os << parser;// and you can use that file as parameter file
+  }
+
+  /* =========================================================
+   *
+   * Random seed
+   *
+   * ========================================================= */
+
+  // reproducible random seed: if you don't change SEED above,
+  // you'll aways get the same result, NOT a random run
+  // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
+  rng.reseed(seed);
+
+  /* =========================================================
+   *
+   * Initialization of the solution
+   *
+   * ========================================================= */
+
+  // a Indi random initializer: each bit is random
+  // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
+  eoUniformGenerator<bool> uGen;
+  eoInitFixedLength<Indi> random(vecSize, uGen);
+
+  /* =========================================================
+   *
+   * Eval fitness function (full evaluation)
+   *
+   * ========================================================= */
+
+  // the fitness function is just the number of 1 in the bit string
+  oneMaxEval<Indi> fullEval;
+
+  /* =========================================================
+   *
+   * evaluation of a neighbor solution
+   *
+   * ========================================================= */
+
+  // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
+  // moFullEvalByModif<Neighbor> neighborEval(fullEval);
+
+  // Incremental evaluation of the neighbor: fitness is modified by +/- 1
+  moOneMaxIncrEval<Neighbor> neighborEvalTmp;
+
+  // to count the number of neighbor evaluation
+  moEvalCounter<Neighbor> neighborEval(neighborEvalTmp);
+
+  /* =========================================================
+   *
+   * the neighborhood of a solution
+   *
+   * ========================================================= */
+
+  // Exploration of the neighborhood in increasing order of the neigbor's index:
+  // bit-flip from bit 0 to bit (vecSize - 1)
+  moOrderNeighborhood<Neighbor> neighborhood(vecSize);
+
+  /* =========================================================
+   *
+   * the external continuators
+   *
+   * ========================================================= */
+
+  moNeighborEvalContinuator<Neighbor> continuator(neighborEval, evalMax);
+
+  /* =========================================================
+   *
+   * the local search algorithm
+   *
+   * ========================================================= */
+
+  moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval, continuator);
+
+  /* =========================================================
+   *
+   * executes the local search from a random solution
+   *
+   * ========================================================= */
+
+  // The current solution
+  Indi solution;
+
+  // Apply random initialization
+  random(solution);
+
+  // Evaluation of the initial solution:
+  // can be evaluated here, or else it will be done at the beginning of the local search
+  fullEval(solution);
+
+  // Output: the intial solution 
+  std::cout << "initial: " << solution << std::endl ;
+
+  // Apply the local search on the solution !
+  hc(solution);
+
+  // Output: the final solution 
+  std::cout << "final:   " << solution << std::endl ;
+  std::cout << "Number of neighbor evaluations during the local search: " << continuator.value() << std::endl ;
+
+}
+
+// A main that catches the exceptions
+
+int main(int argc, char **argv)
+{
+  try {
+    main_function(argc, argv);
+  }
+  catch (exception& e) {
+    cout << "Exception: " << e.what() << '\n';
+  }
+  return 1;
+}

trunk/paradiseo-mo/tutorial/Lesson1/lesson1_fitContinuator.cpp

@@ -0,0 +1,213 @@
+//-----------------------------------------------------------------------------
+/** lesson1_fitContinuator.cpp
+ *
+ * SV - 27/04/10 - version 1
+ *
+ */
+//-----------------------------------------------------------------------------
+
+// standard includes
+#define HAVE_SSTREAM
+
+#include <stdexcept>  // runtime_error 
+#include <iostream>   // cout
+#include <sstream>    // ostrstream, istrstream
+#include <fstream>
+#include <string.h>
+
+// the general include for eo
+#include <eo>
+
+// declaration of the namespace
+using namespace std;
+
+//-----------------------------------------------------------------------------
+// representation of solutions, and neighbors
+#include <ga/eoBit.h>                         // bit string : see also EO tutorial lesson 1: FirstBitGA.cpp
+#include <problems/bitString/moBitNeighbor.h> // neighbor of bit string
+
+//-----------------------------------------------------------------------------
+// fitness function, and evaluation of neighbors
+#include <eval/oneMaxEval.h>
+#include <problems/eval/moOneMaxIncrEval.h>
+#include <eval/moFullEvalByModif.h>
+
+//-----------------------------------------------------------------------------
+// neighborhood description
+#include <neighborhood/moOrderNeighborhood.h> // visit all neighbors in increasing order of bit index
+
+//-----------------------------------------------------------------------------
+// the continuator based on fitness
+#include <continuator/moFitContinuator.h>
+
+//-----------------------------------------------------------------------------
+// the simple Hill-Climbing local search
+#include <algo/moSimpleHC.h>
+
+// Declaration of types
+//-----------------------------------------------------------------------------
+// Indi is the typedef of the solution type like in paradisEO-eo
+typedef eoBit<unsigned int> Indi;                      // bit string with unsigned fitness type
+// Neighbor is the typedef of the neighbor type,
+// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)  
+// all classes from paradisEO-mo use this template type
+typedef moBitNeighbor<unsigned int> Neighbor ;         // bit string neighbor with unsigned fitness type
+
+
+// Main function
+//-----------------------------------------------------------------------------
+void main_function(int argc, char **argv)
+{
+  /* =========================================================
+   *
+   * Parameters from parser
+   *
+   * ========================================================= */
+  // more information on the input parameters: see EO tutorial lesson 3
+  // but don't care at first it just read the parameters of the bit string size and the random seed.
+
+  // First define a parser from the command-line arguments
+  eoParser parser(argc, argv);
+
+  // For each parameter, define Parameter, read it through the parser,
+  // and assign the value to the variable
+
+  // random seed parameter
+  eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
+  parser.processParam( seedParam );
+  unsigned seed = seedParam.value();
+
+  // length of the bit string
+  eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
+  parser.processParam( vecSizeParam, "Representation" );
+  unsigned vecSize = vecSizeParam.value();
+
+  // maximum fitness to reach
+  eoValueParam<unsigned int> fitParam(16, "fitness", "Maximum fitness value to reach", 'f');
+  parser.processParam( fitParam, "Representation" );
+  unsigned fitnessMax = fitParam.value();
+
+  // the name of the "status" file where all actual parameter values will be saved
+  string str_status = parser.ProgramName() + ".status"; // default value
+  eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
+  parser.processParam( statusParam, "Persistence" );
+
+  // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
+  // i.e. in case you need parameters somewhere else, postpone these
+  if (parser.userNeedsHelp()) {
+    parser.printHelp(cout);
+    exit(1);
+  }
+  if (statusParam.value() != "") {
+    ofstream os(statusParam.value().c_str());
+    os << parser;// and you can use that file as parameter file
+  }
+
+  /* =========================================================
+   *
+   * Random seed
+   *
+   * ========================================================= */
+
+  // reproducible random seed: if you don't change SEED above,
+  // you'll aways get the same result, NOT a random run
+  // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
+  rng.reseed(seed);
+
+  /* =========================================================
+   *
+   * Initialization of the solution
+   *
+   * ========================================================= */
+
+  // a Indi random initializer: each bit is random
+  // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
+  eoUniformGenerator<bool> uGen;
+  eoInitFixedLength<Indi> random(vecSize, uGen);
+
+  /* =========================================================
+   *
+   * Eval fitness function (full evaluation)
+   *
+   * ========================================================= */
+
+  // the fitness function is just the number of 1 in the bit string
+  oneMaxEval<Indi> fullEval;
+
+  /* =========================================================
+   *
+   * evaluation of a neighbor solution
+   *
+   * ========================================================= */
+
+  // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
+  // moFullEvalByModif<Neighbor> neighborEval(fullEval);
+
+  // Incremental evaluation of the neighbor: fitness is modified by +/- 1
+  moOneMaxIncrEval<Neighbor> neighborEval;
+
+  /* =========================================================
+   *
+   * the neighborhood of a solution
+   *
+   * ========================================================= */
+
+  // Exploration of the neighborhood in increasing order of the neigbor's index:
+  // bit-flip from bit 0 to bit (vecSize - 1)
+  moOrderNeighborhood<Neighbor> neighborhood(vecSize);
+
+  /* =========================================================
+   *
+   * the external continuators
+   *
+   * ========================================================= */
+
+  moFitContinuator<Neighbor> continuator(fitnessMax); 
+
+  /* =========================================================
+   *
+   * the local search algorithm
+   *
+   * ========================================================= */
+
+  moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval, continuator);
+
+  /* =========================================================
+   *
+   * executes the local search from a random solution
+   *
+   * ========================================================= */
+
+  // The current solution
+  Indi solution;
+
+  // Apply random initialization
+  random(solution);
+
+  // Evaluation of the initial solution:
+  // can be evaluated here, or else it will be done at the beginning of the local search
+  fullEval(solution);
+
+  // Output: the intial solution 
+  std::cout << "initial: " << solution << std::endl ;
+
+  // Apply the local search on the solution !
+  hc(solution);
+
+  // Output: the final solution 
+  std::cout << "final:   " << solution << std::endl ;
+
+}
+
+// A main that catches the exceptions
+
+int main(int argc, char **argv)
+{
+  try {
+    main_function(argc, argv);
+  }
+  catch (exception& e) {
+    cout << "Exception: " << e.what() << '\n';
+  }
+  return 1;
+}

trunk/paradiseo-mo/tutorial/Lesson1/lesson1_fullEvalContinuator.cpp

@@ -0,0 +1,218 @@
+//-----------------------------------------------------------------------------
+/** lesson1_fullEvalContinuator.cpp
+ *
+ * SV - 27/04/10 - version 1
+ *
+ */
+//-----------------------------------------------------------------------------
+
+// standard includes
+#define HAVE_SSTREAM
+
+#include <stdexcept>  // runtime_error 
+#include <iostream>   // cout
+#include <sstream>    // ostrstream, istrstream
+#include <fstream>
+#include <string.h>
+
+// the general include for eo
+#include <eo>
+
+// declaration of the namespace
+using namespace std;
+
+//-----------------------------------------------------------------------------
+// representation of solutions, and neighbors
+#include <ga/eoBit.h>                         // bit string : see also EO tutorial lesson 1: FirstBitGA.cpp
+#include <problems/bitString/moBitNeighbor.h> // neighbor of bit string
+
+//-----------------------------------------------------------------------------
+// fitness function, and evaluation of neighbors
+#include <eval/oneMaxEval.h>
+#include <problems/eval/moOneMaxIncrEval.h>
+#include <eval/moFullEvalByModif.h>
+
+//-----------------------------------------------------------------------------
+// neighborhood description
+#include <neighborhood/moOrderNeighborhood.h> // visit all neighbors in increasing order of bit index
+
+//-----------------------------------------------------------------------------
+// the continuator based on full eval number
+#include <eoEvalFuncCounter.h>   // to import the fitness counter
+#include <continuator/moFullEvalContinuator.h>
+
+//-----------------------------------------------------------------------------
+// the simple Hill-Climbing local search
+#include <algo/moSimpleHC.h>
+
+// Declaration of types
+//-----------------------------------------------------------------------------
+// Indi is the typedef of the solution type like in paradisEO-eo
+typedef eoBit<unsigned int> Indi;                      // bit string with unsigned fitness type
+// Neighbor is the typedef of the neighbor type,
+// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)  
+// all classes from paradisEO-mo use this template type
+typedef moBitNeighbor<unsigned int> Neighbor ;         // bit string neighbor with unsigned fitness type
+
+
+// Main function
+//-----------------------------------------------------------------------------
+void main_function(int argc, char **argv)
+{
+  /* =========================================================
+   *
+   * Parameters from parser
+   *
+   * ========================================================= */
+  // more information on the input parameters: see EO tutorial lesson 3
+  // but don't care at first it just read the parameters of the bit string size and the random seed.
+
+  // First define a parser from the command-line arguments
+  eoParser parser(argc, argv);
+
+  // For each parameter, define Parameter, read it through the parser,
+  // and assign the value to the variable
+
+  // random seed parameter
+  eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
+  parser.processParam( seedParam );
+  unsigned seed = seedParam.value();
+
+  // length of the bit string
+  eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
+  parser.processParam( vecSizeParam, "Representation" );
+  unsigned vecSize = vecSizeParam.value();
+
+  // maximum number of full evaluation
+  eoValueParam<unsigned int> evalParam(2, "fulleval", "Maximum number of full evaluation", 'e');
+  parser.processParam( evalParam, "Representation" );
+  unsigned fullevalMax = evalParam.value();
+
+  // the name of the "status" file where all actual parameter values will be saved
+  string str_status = parser.ProgramName() + ".status"; // default value
+  eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
+  parser.processParam( statusParam, "Persistence" );
+
+  // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
+  // i.e. in case you need parameters somewhere else, postpone these
+  if (parser.userNeedsHelp()) {
+    parser.printHelp(cout);
+    exit(1);
+  }
+  if (statusParam.value() != "") {
+    ofstream os(statusParam.value().c_str());
+    os << parser;// and you can use that file as parameter file
+  }
+
+  /* =========================================================
+   *
+   * Random seed
+   *
+   * ========================================================= */
+
+  // reproducible random seed: if you don't change SEED above,
+  // you'll aways get the same result, NOT a random run
+  // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
+  rng.reseed(seed);
+
+  /* =========================================================
+   *
+   * Initialization of the solution
+   *
+   * ========================================================= */
+
+  // a Indi random initializer: each bit is random
+  // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
+  eoUniformGenerator<bool> uGen;
+  eoInitFixedLength<Indi> random(vecSize, uGen);
+
+  /* =========================================================
+   *
+   * Eval fitness function (full evaluation)
+   *
+   * ========================================================= */
+
+  // the fitness function is just the number of 1 in the bit string
+  oneMaxEval<Indi> fullEvalTmp;
+
+  // to count the number of full evaluation
+  eoEvalFuncCounter<Indi> fullEval(fullEvalTmp);
+
+  /* =========================================================
+   *
+   * evaluation of a neighbor solution
+   *
+   * ========================================================= */
+
+  // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
+  // moFullEvalByModif<Neighbor> neighborEval(fullEval);
+
+  // Incremental evaluation of the neighbor: fitness is modified by +/- 1
+  moOneMaxIncrEval<Neighbor> neighborEval;
+
+  /* =========================================================
+   *
+   * the neighborhood of a solution
+   *
+   * ========================================================= */
+
+  // Exploration of the neighborhood in increasing order of the neigbor's index:
+  // bit-flip from bit 0 to bit (vecSize - 1)
+  moOrderNeighborhood<Neighbor> neighborhood(vecSize);
+
+  /* =========================================================
+   *
+   * the external continuators
+   *
+   * ========================================================= */
+
+  moFullEvalContinuator<Neighbor> continuator(fullEval, fullevalMax);
+
+  /* =========================================================
+   *
+   * the local search algorithm
+   *
+   * ========================================================= */
+
+  moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval, continuator);
+
+  /* =========================================================
+   *
+   * executes the local search from a random solution
+   *
+   * ========================================================= */
+
+  // The current solution
+  Indi solution;
+
+  // Apply random initialization
+  random(solution);
+
+  // Evaluation of the initial solution:
+  // can be evaluated here, or else it will be done at the beginning of the local search
+  fullEval(solution);
+
+  // Output: the intial solution 
+  std::cout << "initial: " << solution << std::endl ;
+
+  // Apply the local search on the solution !
+  hc(solution);
+
+  // Output: the final solution 
+  std::cout << "final:   " << solution << std::endl ;
+  std::cout << "Number of full evaluations during the local search: " << continuator.value() << std::endl ;
+
+}
+
+// A main that catches the exceptions
+
+int main(int argc, char **argv)
+{
+  try {
+    main_function(argc, argv);
+  }
+  catch (exception& e) {
+    cout << "Exception: " << e.what() << '\n';
+  }
+  return 1;
+}

trunk/paradiseo-mo/tutorial/Lesson1/lesson1_iterContinuator.cpp

@@ -1,5 +1,5 @@
 //-----------------------------------------------------------------------------
-/** lesson1_continuator.cpp
+/** lesson1_iterContinuator.cpp
  *
  * SV - 27/04/10 - version 1
  *
@@ -37,12 +37,8 @@ using namespace std;
 #include <neighborhood/moOrderNeighborhood.h> // visit all neighbors in increasing order of bit index
 
 //-----------------------------------------------------------------------------
-// the possible continuators
+// the iteration continuators
 #include <continuator/moIterContinuator.h>
-#include <continuator/moFitContinuator.h>
-#include <continuator/moFullEvalContinuator.h>
-#include <continuator/moNeighborEvalContinuator.h>
-#include <continuator/moCombinedContinuator.h>
 
 //-----------------------------------------------------------------------------
 // the simple Hill-Climbing local search
@@ -86,6 +82,11 @@ void main_function(int argc, char **argv)
   parser.processParam( vecSizeParam, "Representation" );
   unsigned vecSize = vecSizeParam.value();
 
+  // maximum number of iterations
+  eoValueParam<unsigned int> iterParam(10, "iter", "Maximum number of iterations", 'i');
+  parser.processParam( iterParam, "Representation" );
+  unsigned iterMax = iterParam.value();
+
   // the name of the "status" file where all actual parameter values will be saved
   string str_status = parser.ProgramName() + ".status"; // default value
   eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
@@ -161,10 +162,7 @@ void main_function(int argc, char **argv)
    *
    * ========================================================= */
 
-  moIterContinuator<Neighbor> continuator(10);         // maximum number of iterations : 10
-  //  moFitContinuator<Neighbor> continuator(17);          // fitness to reach : 17
-  //  moFullEvalContinuator<Neighbor> continuator(2);      // maximum number of full evaluation : 2
-  //  moNeighborEvalContinuator<Neighbor> continuator(20); // maximum number of neighbor evaluation : 20
+  moIterContinuator<Neighbor> continuator(iterMax);
 
   /* =========================================================
    *
@@ -199,6 +197,8 @@ void main_function(int argc, char **argv)
   // Output: the final solution 
   std::cout << "final:   " << solution << std::endl ;
 
+  std::cout << "number of iteration: " << continuator.value() << std::endl ;
+
 }
 
 // A main that catches the exceptions