Debut du decoupage des leçons: Lesson1 Compile OK

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

trunk/paradiseo-mo/src/problems/eval/oneMaxFullEval.h

@@ -0,0 +1,53 @@
+/*
+<oneMaxFullEval.h>
+Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2010
+
+Sébastien Verel, Arnaud Liefooghe, Jérémie Humeau
+
+This software is governed by the CeCILL license under French law and
+abiding by the rules of distribution of free software.  You can  ue,
+modify and/ or redistribute the software under the terms of the CeCILL
+license as circulated by CEA, CNRS and INRIA at the following URL
+"http://www.cecill.info".
+
+In this respect, the user's attention is drawn to the risks associated
+with loading,  using,  modifying and/or developing or reproducing the
+software by the user in light of its specific status of free software,
+that may mean  that it is complicated to manipulate,  and  that  also
+therefore means  that it is reserved for developers  and  experienced
+professionals having in-depth computer knowledge. Users are therefore
+encouraged to load and test the software's suitability as regards their
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and,  more generally, to use and operate it in the
+same conditions as regards security.
+The fact that you are presently reading this means that you have had
+knowledge of the CeCILL license and that you accept its terms.
+
+ParadisEO WebSite : http://paradiseo.gforge.inria.fr
+Contact: paradiseo-help@lists.gforge.inria.fr
+*/
+
+#ifndef _oneMaxFullEval_h
+#define _oneMaxFullEval_h
+
+/**
+ * Full evalution Function for OneMax problem
+ */
+template< class EOT >
+class oneMaxFullEval : public eoEvalFunc<EOT>
+{
+public:
+
+	/**
+	 * Count the number of 1 in a bitString
+	 * @param _sol the solution to evaluate
+	 */
+    void operator() (EOT& _sol) {
+        unsigned int sum = 0;
+        for (unsigned int i = 0; i < _sol.size(); i++)
+            sum += _sol[i];
+        _sol.fitness(sum);
+    }
+};
+
+#endif

trunk/paradiseo-mo/tutorial/CMakeLists.txt

@@ -1 +1 @@
-ADD_SUBDIRECTORY(oneMax)
+ADD_SUBDIRECTORY(Lesson1)

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

@@ -0,0 +1,18 @@
+INCLUDE_DIRECTORIES(${EO_SRC_DIR}/src
+					${MO_SRC_DIR}/src
+					${CMAKE_CURRENT_SOURCE_DIR}/../src)
+					
+LINK_DIRECTORIES(${EO_BIN_DIR}/lib)	
+
+ADD_EXECUTABLE(testSimpleHC testSimpleHC.cpp) 
+ADD_EXECUTABLE(testFirstImpr testFirstImpr.cpp) 
+ADD_EXECUTABLE(testRandomBestHC testRandomBestHC.cpp) 
+ADD_EXECUTABLE(testHCneutral testHCneutral.cpp) 
+
+TARGET_LINK_LIBRARIES(testSimpleHC eoutils ga eo) 
+TARGET_LINK_LIBRARIES(testFirstImpr eoutils ga eo) 
+TARGET_LINK_LIBRARIES(testRandomBestHC eoutils ga eo) 
+TARGET_LINK_LIBRARIES(testHCneutral eoutils ga eo) 
+
+
+ 

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

@@ -0,0 +1,197 @@
+//-----------------------------------------------------------------------------
+/** testFirstImpr.cpp
+ *
+ * SV - 12/01/10
+ *
+ */
+//-----------------------------------------------------------------------------
+
+// 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>
+#include <ga.h>
+
+using namespace std;
+
+//-----------------------------------------------------------------------------
+// fitness function
+#include <problems/eval/oneMaxFullEval.h>
+#include <problems/bitString/moBitNeighbor.h>
+#include <eoInt.h>
+#include <neighborhood/moRndWithoutReplNeighborhood.h>
+
+#include <eval/moFullEvalByModif.h>
+#include <eval/moFullEvalByCopy.h>
+#include <comparator/moNeighborComparator.h>
+#include <comparator/moSolNeighborComparator.h>
+#include <continuator/moTrueContinuator.h>
+#include <algo/moLocalSearch.h>
+#include <explorer/moFirstImprExplorer.h>
+
+// REPRESENTATION
+//-----------------------------------------------------------------------------
+typedef eoBit<unsigned> Indi;
+typedef moBitNeighbor<unsigned int> Neighbor ; // incremental evaluation
+typedef moRndWithoutReplNeighborhood<Neighbor> Neighborhood ;
+
+void main_function(int argc, char **argv)
+{
+    /* =========================================================
+    *
+    * Parameters
+    *
+    * ========================================================= */
+
+    // 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
+
+    eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
+    parser.processParam( seedParam );
+    unsigned seed = seedParam.value();
+
+    // description of genotype
+    eoValueParam<unsigned int> vecSizeParam(8, "vecSize", "Genotype size", 'V');
+    parser.processParam( vecSizeParam, "Representation" );
+    unsigned vecSize = vecSizeParam.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
+    rng.reseed(seed);
+
+
+    /* =========================================================
+     *
+     * Eval fitness function
+     *
+     * ========================================================= */
+
+    oneMaxFullEval<Indi> eval;
+
+
+    /* =========================================================
+     *
+     * Initilisation of the solution
+     *
+     * ========================================================= */
+
+    // a Indi random initializer
+    eoUniformGenerator<bool> uGen;
+    eoInitFixedLength<Indi> random(vecSize, uGen);
+
+
+    /* =========================================================
+     *
+     * evaluation of a neighbor solution
+     *
+     * ========================================================= */
+
+    moFullEvalByModif<Neighbor> fulleval(eval);
+
+    //An eval by copy can be used instead of the eval by modif
+    //moFullEvalByCopy<Neighbor> fulleval(eval);
+
+
+    /* =========================================================
+     *
+     * Comparator of neighbors
+     *
+     * ========================================================= */
+
+    moNeighborComparator<Neighbor> comparator;
+    moSolNeighborComparator<Neighbor> solComparator;
+
+
+    /* =========================================================
+     *
+     * the neighborhood of a solution
+     *
+     * ========================================================= */
+
+    Neighborhood neighborhood(vecSize);
+
+
+    /* =========================================================
+     *
+     * a neighborhood explorer solution
+     *
+     * ========================================================= */
+
+    moFirstImprExplorer<Neighbor> explorer(neighborhood, fulleval, comparator, solComparator);
+
+
+    /* =========================================================
+     *
+     * the local search algorithm
+     *
+     * ========================================================= */
+
+    moTrueContinuator<Neighbor> continuator;//always continue
+
+    moLocalSearch< Neighbor > localSearch(explorer, continuator, eval);
+
+    /* =========================================================
+     *
+     * execute the local search from random sollution
+     *
+     * ========================================================= */
+
+    Indi solution;
+
+    random(solution);
+
+    //Can be eval here, else it will be done at the beginning of the localSearch
+    //eval(solution);
+
+    std::cout << "initial: " << solution << std::endl ;
+
+    localSearch(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/testHCneutral.cpp

@@ -0,0 +1,201 @@
+//-----------------------------------------------------------------------------
+/** testHCneutral.cpp
+ *
+ * SV - 24/01/10
+ *
+ */
+//-----------------------------------------------------------------------------
+
+// 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>
+#include <ga.h>
+
+using namespace std;
+
+//-----------------------------------------------------------------------------
+// fitness function
+#include <problems/eval/oneMaxFullEval.h>
+#include <problems/bitString/moBitNeighbor.h>
+#include <eoInt.h>
+#include <neighborhood/moOrderNeighborhood.h>
+
+#include <eval/moFullEvalByModif.h>
+#include <eval/moFullEvalByCopy.h>
+#include <comparator/moNeighborComparator.h>
+#include <comparator/moSolNeighborComparator.h>
+#include <continuator/moTrueContinuator.h>
+#include <algo/moLocalSearch.h>
+#include <explorer/moHCneutralExplorer.h>
+
+// REPRESENTATION
+//-----------------------------------------------------------------------------
+typedef eoBit<unsigned> Indi;
+typedef moBitNeighbor<unsigned int> Neighbor ; // incremental evaluation
+typedef moOrderNeighborhood<Neighbor> Neighborhood ;
+
+void main_function(int argc, char **argv)
+{
+    /* =========================================================
+    *
+    * Parameters
+    *
+    * ========================================================= */
+
+    // 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
+
+    eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
+    parser.processParam( seedParam );
+    unsigned seed = seedParam.value();
+
+    // description of genotype
+    eoValueParam<unsigned int> vecSizeParam(8, "vecSize", "Genotype size", 'V');
+    parser.processParam( vecSizeParam, "Representation" );
+    unsigned vecSize = vecSizeParam.value();
+
+    eoValueParam<unsigned int> stepParam(10, "nbStep", "Number of steps of the random walk", 'n');
+    parser.processParam( stepParam, "Representation" );
+    unsigned nbStep = stepParam.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
+    rng.reseed(seed);
+
+
+    /* =========================================================
+     *
+     * Eval fitness function
+     *
+     * ========================================================= */
+
+    oneMaxFullEval<Indi> eval;
+
+
+    /* =========================================================
+     *
+     * Initilisation of the solution
+     *
+     * ========================================================= */
+
+    // a Indi random initializer
+    eoUniformGenerator<bool> uGen;
+    eoInitFixedLength<Indi> random(vecSize, uGen);
+
+
+    /* =========================================================
+     *
+     * evaluation of a neighbor solution
+     *
+     * ========================================================= */
+
+    moFullEvalByModif<Neighbor> fulleval(eval);
+
+    //An eval by copy can be used instead of the eval by modif
+    //moFullEvalByCopy<Neighbor> fulleval(eval);
+
+
+    /* =========================================================
+     *
+     * Comparator of neighbors
+     *
+     * ========================================================= */
+
+    moNeighborComparator<Neighbor> comparator;
+    moSolNeighborComparator<Neighbor> solComparator;
+
+
+    /* =========================================================
+     *
+     * the neighborhood of a solution
+     *
+     * ========================================================= */
+
+    Neighborhood neighborhood(vecSize);
+
+
+    /* =========================================================
+     *
+     * a neighborhood explorer solution
+     *
+     * ========================================================= */
+
+    moHCneutralExplorer<Neighbor> explorer(neighborhood, fulleval, comparator, solComparator, nbStep);
+
+
+    /* =========================================================
+     *
+     * the local search algorithm
+     *
+     * ========================================================= */
+
+    moTrueContinuator<Neighbor> continuator;//always continue
+
+    moLocalSearch<Neighbor> localSearch(explorer, continuator, eval);
+
+    /* =========================================================
+     *
+     * execute the local search from random sollution
+     *
+     * ========================================================= */
+
+    Indi solution;
+
+    random(solution);
+
+    //Can be eval here, else it will be done at the beginning of the localSearch
+    //eval(solution);
+
+    std::cout << "initial: " << solution << std::endl ;
+
+    localSearch(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/testRandomBestHC.cpp

@@ -0,0 +1,197 @@
+//-----------------------------------------------------------------------------
+/** testRandomBestHC.cpp
+ *
+ * SV - 24/01/10
+ *
+ */
+//-----------------------------------------------------------------------------
+
+// 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>
+#include <ga.h>
+
+using namespace std;
+
+//-----------------------------------------------------------------------------
+// fitness function
+#include <problems/eval/oneMaxFullEval.h>
+#include <problems/bitString/moBitNeighbor.h>
+#include <eoInt.h>
+#include <neighborhood/moOrderNeighborhood.h>
+
+#include <eval/moFullEvalByModif.h>
+#include <eval/moFullEvalByCopy.h>
+#include <comparator/moNeighborComparator.h>
+#include <comparator/moSolNeighborComparator.h>
+#include <continuator/moTrueContinuator.h>
+#include <algo/moLocalSearch.h>
+#include <explorer/moRandomBestHCExplorer.h>
+
+// REPRESENTATION
+//-----------------------------------------------------------------------------
+typedef eoBit<unsigned> Indi;
+typedef moBitNeighbor<unsigned int> Neighbor ; // incremental evaluation
+typedef moOrderNeighborhood<Neighbor> Neighborhood ;
+
+void main_function(int argc, char **argv)
+{
+    /* =========================================================
+    *
+    * Parameters
+    *
+    * ========================================================= */
+
+    // 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
+
+    eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
+    parser.processParam( seedParam );
+    unsigned seed = seedParam.value();
+
+    // description of genotype
+    eoValueParam<unsigned int> vecSizeParam(8, "vecSize", "Genotype size", 'V');
+    parser.processParam( vecSizeParam, "Representation" );
+    unsigned vecSize = vecSizeParam.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
+    rng.reseed(seed);
+
+
+    /* =========================================================
+     *
+     * Eval fitness function
+     *
+     * ========================================================= */
+
+    oneMaxFullEval<Indi> eval;
+
+
+    /* =========================================================
+     *
+     * Initilisation of the solution
+     *
+     * ========================================================= */
+
+    // a Indi random initializer
+    eoUniformGenerator<bool> uGen;
+    eoInitFixedLength<Indi> random(vecSize, uGen);
+
+
+    /* =========================================================
+     *
+     * evaluation of a neighbor solution
+     *
+     * ========================================================= */
+
+    moFullEvalByModif<Neighbor> fulleval(eval);
+
+    //An eval by copy can be used instead of the eval by modif
+    //moFullEvalByCopy<Neighbor> fulleval(eval);
+
+
+    /* =========================================================
+     *
+     * Comparator of neighbors
+     *
+     * ========================================================= */
+
+    moNeighborComparator<Neighbor> comparator;
+    moSolNeighborComparator<Neighbor> solComparator;
+
+
+    /* =========================================================
+     *
+     * the neighborhood of a solution
+     *
+     * ========================================================= */
+
+    Neighborhood neighborhood(vecSize);
+
+
+    /* =========================================================
+     *
+     * a neighborhood explorer solution
+     *
+     * ========================================================= */
+
+    moRandomBestHCExplorer<Neighbor> explorer(neighborhood, fulleval, comparator, solComparator);
+
+
+    /* =========================================================
+     *
+     * the local search algorithm
+     *
+     * ========================================================= */
+
+    moTrueContinuator<Neighbor> continuator;//always continue
+
+    moLocalSearch<Neighbor> localSearch(explorer, continuator, eval);
+
+    /* =========================================================
+     *
+     * execute the local search from random sollution
+     *
+     * ========================================================= */
+
+    Indi solution;
+
+    random(solution);
+
+    //Can be eval here, else it will be done at the beginning of the localSearch
+    //eval(solution);
+
+    std::cout << "initial: " << solution << std::endl ;
+
+    localSearch(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/testSimpleHC.cpp

@@ -0,0 +1,197 @@
+//-----------------------------------------------------------------------------
+/** testSimpleHC.cpp
+ *
+ * SV - 12/01/10
+ *
+ */
+//-----------------------------------------------------------------------------
+
+// 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>
+#include <ga.h>
+
+using namespace std;
+
+//-----------------------------------------------------------------------------
+// fitness function
+#include <problems/eval/oneMaxFullEval.h>
+#include <problems/bitString/moBitNeighbor.h>
+#include <eoInt.h>
+#include <neighborhood/moOrderNeighborhood.h>
+
+#include <eval/moFullEvalByModif.h>
+#include <eval/moFullEvalByCopy.h>
+#include <comparator/moNeighborComparator.h>
+#include <comparator/moSolNeighborComparator.h>
+#include <continuator/moTrueContinuator.h>
+#include <algo/moLocalSearch.h>
+#include <explorer/moSimpleHCexplorer.h>
+
+// REPRESENTATION
+//-----------------------------------------------------------------------------
+typedef eoBit<unsigned> Indi;
+typedef moBitNeighbor<unsigned int> Neighbor ; // incremental evaluation
+typedef moOrderNeighborhood<Neighbor> Neighborhood ;
+
+void main_function(int argc, char **argv)
+{
+    /* =========================================================
+    *
+    * Parameters
+    *
+    * ========================================================= */
+
+    // 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
+
+    eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
+    parser.processParam( seedParam );
+    unsigned seed = seedParam.value();
+
+    // description of genotype
+    eoValueParam<unsigned int> vecSizeParam(8, "vecSize", "Genotype size", 'V');
+    parser.processParam( vecSizeParam, "Representation" );
+    unsigned vecSize = vecSizeParam.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
+    rng.reseed(seed);
+
+
+    /* =========================================================
+     *
+     * Eval fitness function
+     *
+     * ========================================================= */
+
+    oneMaxFullEval<Indi> eval;
+
+
+    /* =========================================================
+     *
+     * Initilisation of the solution
+     *
+     * ========================================================= */
+
+    // a Indi random initializer
+    eoUniformGenerator<bool> uGen;
+    eoInitFixedLength<Indi> random(vecSize, uGen);
+
+
+    /* =========================================================
+     *
+     * evaluation of a neighbor solution
+     *
+     * ========================================================= */
+
+    moFullEvalByModif<Neighbor> fulleval(eval);
+
+    //An eval by copy can be used instead of the eval by modif
+    //moFullEvalByCopy<Neighbor> fulleval(eval);
+
+
+    /* =========================================================
+     *
+     * Comparator of neighbors
+     *
+     * ========================================================= */
+
+    moNeighborComparator<Neighbor> comparator;
+    moSolNeighborComparator<Neighbor> solComparator;
+
+
+    /* =========================================================
+     *
+     * the neighborhood of a solution
+     *
+     * ========================================================= */
+
+    Neighborhood neighborhood(vecSize);
+
+
+    /* =========================================================
+     *
+     * a neighborhood explorer solution
+     *
+     * ========================================================= */
+
+    moSimpleHCexplorer<Neighbor> explorer(neighborhood, fulleval, comparator, solComparator);
+
+
+    /* =========================================================
+     *
+     * the local search algorithm
+     *
+     * ========================================================= */
+
+    moTrueContinuator<Neighbor> continuator;//always continue
+
+    moLocalSearch< Neighbor > localSearch(explorer, continuator, eval);
+
+    /* =========================================================
+     *
+     * execute the local search from random sollution
+     *
+     * ========================================================= */
+
+    Indi solution;
+
+    random(solution);
+
+    //Can be eval here, else it will be done at the beginning of the localSearch
+    //eval(solution);
+
+    std::cout << "initial: " << solution << std::endl ;
+
+    localSearch(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/Lesson3/testSimulatedAnnealing.cpp

@@ -0,0 +1,205 @@
+//-----------------------------------------------------------------------------
+/** testSimulatedAnnealing.cpp
+ *
+ * SV - 29/03/10
+ *
+ */
+//-----------------------------------------------------------------------------
+
+// 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>
+#include <ga.h>
+
+using namespace std;
+
+//-----------------------------------------------------------------------------
+// fitness function
+#include <funcOneMax.h>
+#include <eoInt.h>
+#include <neighborhood/moRndWithReplNeighborhood.h>
+#include <oneMaxBitNeighbor.h>
+
+#include <eval/moFullEvalByModif.h>
+#include <eval/moFullEvalByCopy.h>
+#include <comparator/moNeighborComparator.h>
+#include <comparator/moSolNeighborComparator.h>
+#include <continuator/moTrueContinuator.h>
+#include <algo/moLocalSearch.h>
+#include <explorer/moSAexplorer.h>
+#include <coolingSchedule/moSimpleCoolingSchedule.h>
+
+// REPRESENTATION
+//-----------------------------------------------------------------------------
+typedef eoBit<unsigned> Indi;
+typedef moBitNeighbor<unsigned int> Neighbor ; // incremental evaluation
+typedef moRndWithReplNeighborhood<Neighbor> Neighborhood ;
+
+void main_function(int argc, char **argv)
+{
+    /* =========================================================
+    *
+    * Parameters
+    *
+    * ========================================================= */
+
+    // 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
+
+    eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
+    parser.processParam( seedParam );
+    unsigned seed = seedParam.value();
+
+    // description of genotype
+    eoValueParam<unsigned int> vecSizeParam(8, "vecSize", "Genotype size", 'V');
+    parser.processParam( vecSizeParam, "Representation" );
+    unsigned vecSize = vecSizeParam.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
+    rng.reseed(seed);
+
+
+    /* =========================================================
+     *
+     * Eval fitness function
+     *
+     * ========================================================= */
+
+    FuncOneMax<Indi> eval(vecSize);
+
+
+    /* =========================================================
+     *
+     * Initilisation of the solution
+     *
+     * ========================================================= */
+
+    // a Indi random initializer
+    eoUniformGenerator<bool> uGen;
+    eoInitFixedLength<Indi> random(vecSize, uGen);
+
+
+    /* =========================================================
+     *
+     * evaluation of a neighbor solution
+     *
+     * ========================================================= */
+
+    moFullEvalByModif<Neighbor> fulleval(eval);
+
+    //An eval by copy can be used instead of the eval by modif
+    //moFullEvalByCopy<Neighbor> fulleval(eval);
+
+
+    /* =========================================================
+     *
+     * Comparator of neighbors
+     *
+     * ========================================================= */
+
+    moSolNeighborComparator<Neighbor> solComparator;
+
+
+    /* =========================================================
+     *
+     * the neighborhood of a solution
+     *
+     * ========================================================= */
+
+    Neighborhood neighborhood(vecSize);
+
+
+    /* =========================================================
+     *
+     * the cooling schedule of the process
+     *
+     * ========================================================= */
+
+    // initial temp, factor of decrease, number of steps without decrease, final temp.
+    moSimpleCoolingSchedule<Indi> coolingSchedule(10, 0.9, 1, 0.01);
+
+    /* =========================================================
+     *
+     * a neighborhood explorer solution
+     *
+     * ========================================================= */
+
+    moSAexplorer<Neighbor> explorer(neighborhood, fulleval, solComparator, coolingSchedule);
+
+    /* =========================================================
+     *
+     * the local search algorithm
+     *
+     * ========================================================= */
+
+    moTrueContinuator<Neighbor> continuator;//always continue
+
+    moLocalSearch<Neighbor> localSearch(explorer, continuator, eval);
+
+    /* =========================================================
+     *
+     * execute the local search from random sollution
+     *
+     * ========================================================= */
+
+    Indi solution;
+
+    random(solution);
+
+    //Can be eval here, else it will be done at the beginning of the localSearch
+    //eval(solution);
+
+    std::cout << "initial: " << solution << std::endl ;
+
+    localSearch(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/Lesson4/testSimpleTS.cpp

@@ -0,0 +1,203 @@
+//-----------------------------------------------------------------------------
+/** testSimpleHC.cpp
+ *
+ * SV - 12/01/10
+ *
+ */
+//-----------------------------------------------------------------------------
+
+// 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>
+#include <ga.h>
+
+using namespace std;
+
+//-----------------------------------------------------------------------------
+// fitness function
+#include <funcOneMax.h>
+#include <eoInt.h>
+#include <neighborhood/moOrderNeighborhood.h>
+#include <oneMaxBitNeighbor.h>
+
+#include <mo>
+
+#include <eval/moFullEvalByModif.h>
+#include <eval/moFullEvalByCopy.h>
+#include <comparator/moNeighborComparator.h>
+#include <comparator/moSolNeighborComparator.h>
+#include <continuator/moTrueContinuator.h>
+#include <algo/moLocalSearch.h>
+#include <explorer/moSimpleHCexplorer.h>
+
+// REPRESENTATION
+//-----------------------------------------------------------------------------
+typedef eoBit<unsigned> Indi;
+typedef moBitNeighbor<unsigned int> Neighbor ; // incremental evaluation
+typedef moOrderNeighborhood<Neighbor> Neighborhood ;
+
+void main_function(int argc, char **argv)
+{
+    /* =========================================================
+    *
+    * Parameters
+    *
+    * ========================================================= */
+
+    // 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
+
+    eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
+    parser.processParam( seedParam );
+    unsigned seed = seedParam.value();
+
+    // description of genotype
+    eoValueParam<unsigned int> vecSizeParam(8, "vecSize", "Genotype size", 'V');
+    parser.processParam( vecSizeParam, "Representation" );
+    unsigned vecSize = vecSizeParam.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
+    rng.reseed(seed);
+
+
+    /* =========================================================
+     *
+     * Eval fitness function
+     *
+     * ========================================================= */
+
+    FuncOneMax<Indi> fulleval(vecSize);
+
+
+    /* =========================================================
+     *
+     * Initilisation of the solution
+     *
+     * ========================================================= */
+
+    // a Indi random initializer
+    eoUniformGenerator<bool> uGen;
+    eoInitFixedLength<Indi> random(vecSize, uGen);
+
+
+    /* =========================================================
+     *
+     * evaluation of a neighbor solution
+     *
+     * ========================================================= */
+
+    moFullEvalByModif<Neighbor> eval(fulleval);
+
+    //An eval by copy can be used instead of the eval by modif
+    //moFullEvalByCopy<Neighbor> fulleval(eval);
+
+
+    /* =========================================================
+     *
+     * Comparator of neighbors
+     *
+     * ========================================================= */
+
+    moNeighborComparator<Neighbor> comparator;
+    moSolNeighborComparator<Neighbor> solComparator;
+
+
+    /* =========================================================
+     *
+     * the neighborhood of a solution
+     *
+     * ========================================================= */
+
+    Neighborhood neighborhood(vecSize);
+
+
+    /* =========================================================
+     *
+     * a neighborhood explorer solution
+     *
+     * ========================================================= */
+
+    moSolVectorTabuList<Neighbor> tl(10,10);
+    moDummyIntensification<Neighbor> inten;
+    moDummyDiversification<Neighbor> div;
+    moBestImprAspiration<Neighbor> asp;
+    moTSExplorer<Neighbor> explorer(neighborhood, eval, comparator, solComparator, tl, inten, div, asp);
+
+
+    /* =========================================================
+     *
+     * the local search algorithm
+     *
+     * ========================================================= */
+
+    moTrueContinuator<Neighbor> continuator;//always continue
+
+    moLocalSearch<Neighbor> localSearch(explorer, continuator, fulleval);
+
+    /* =========================================================
+     *
+     * execute the local search from random sollution
+     *
+     * ========================================================= */
+
+    Indi solution;
+
+    random(solution);
+
+    //Can be eval here, else it will be done at the beginning of the localSearch
+    //eval(solution);
+
+    std::cout << "initial: " << solution << std::endl ;
+
+    localSearch(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/Lesson5/testILS.cpp

@@ -0,0 +1,234 @@
+//-----------------------------------------------------------------------------
+/** testILS.cpp
+ *
+ * SV - 12/01/10
+ *
+ */
+//-----------------------------------------------------------------------------
+
+// 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>
+#include <ga.h>
+#include <ga/eoBitOp.h>
+
+using namespace std;
+
+//-----------------------------------------------------------------------------
+// fitness function
+#include <funcOneMax.h>
+#include <funcNK.h>
+#include <eoInt.h>
+#include <neighborhood/moOrderNeighborhood.h>
+#include <neighborhood/moRndWithoutReplNeighborhood.h>
+#include <oneMaxBitNeighbor.h>
+
+#include <neighborhood/moDummyNeighbor.h>
+
+#include <eval/moFullEvalByModif.h>
+#include <eval/moFullEvalByCopy.h>
+#include <comparator/moNeighborComparator.h>
+#include <comparator/moSolNeighborComparator.h>
+#include <continuator/moTrueContinuator.h>
+#include <algo/moLocalSearch.h>
+#include <explorer/moSimpleHCexplorer.h>
+#include <explorer/moILSexplorer.h>
+
+#include <perturb/moMonOpPerturb.h>
+#include <perturb/moRestartPerturb.h>
+#include <perturb/moNeighborhoodPerturb.h>
+#include <acceptCrit/moAlwaysAcceptCrit.h>
+#include <acceptCrit/moBetterAcceptCrit.h>
+#include <continuator/moIterContinuator.h>
+
+// REPRESENTATION
+//-----------------------------------------------------------------------------
+typedef eoBit<unsigned int> Indi;
+typedef moBitNeighbor<unsigned int> Neighbor ; // incremental evaluation
+typedef moOrderNeighborhood<Neighbor> Neighborhood ;
+typedef moRndWithoutReplNeighborhood<Neighbor> Neighborhood2 ;
+typedef moSimpleHCexplorer<Neighborhood> NHE;
+
+void main_function(int argc, char **argv)
+{
+    /* =========================================================
+    *
+    * Parameters
+    *
+    * ========================================================= */
+
+    // 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
+
+    eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
+    parser.processParam( seedParam );
+    unsigned seed = seedParam.value();
+
+    // description of genotype
+    eoValueParam<unsigned int> vecSizeParam(8, "vecSize", "Genotype size", 'V');
+    parser.processParam( vecSizeParam, "Representation" );
+    unsigned vecSize = vecSizeParam.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
+    rng.reseed(seed);
+
+
+    /* =========================================================
+     *
+     * Eval fitness function
+     *
+     * ========================================================= */
+
+    FuncOneMax<Indi> eval(vecSize);
+
+    //FuncNK<Indi> eval(vecSize, 2);
+
+    /* =========================================================
+     *
+     * Initilisation of the solution
+     *
+     * ========================================================= */
+
+    // a Indi random initializer
+    eoUniformGenerator<bool> uGen;
+    eoInitFixedLength<Indi> random(vecSize, uGen);
+
+
+    /* =========================================================
+     *
+     * evaluation of a neighbor solution
+     *
+     * ========================================================= */
+
+    moFullEvalByModif<Neighbor> fulleval(eval);
+
+    //An eval by copy can be used instead of the eval by modif
+    //moFullEvalByCopy<Neighbor> fulleval(eval);
+
+
+    /* =========================================================
+     *
+     * Comparator of neighbors
+     *
+     * ========================================================= */
+
+    moNeighborComparator<Neighbor> comparator;
+    moSolNeighborComparator<Neighbor> solComparator;
+
+
+    /* =========================================================
+     *
+     * the neighborhood of a solution
+     *
+     * ========================================================= */
+
+    Neighborhood neighborhood(vecSize);
+    Neighborhood2 neighborhood2(vecSize);
+
+
+    /* =========================================================
+     *
+     * a neighborhood explorer solution
+     *
+     * ========================================================= */
+
+    moSimpleHCexplorer<Neighbor> explorer(neighborhood, fulleval, comparator, solComparator);
+
+
+    /* =========================================================
+     *
+     * the local search algorithm
+     *
+     * ========================================================= */
+
+    moTrueContinuator<Neighbor> continuator;//always continue
+
+    moLocalSearch< Neighbor > hc(explorer, continuator, eval);
+
+    eoBitMutation<Indi> monOp(1.0/vecSize);
+
+    moMonOpPerturb<Neighbor> perturb(monOp, eval);
+
+    //moRestartPerturb<Neighbor> perturb(random, eval, 5);
+
+	//moNeighborhoodPerturb<Neighbor, Neighborhood2> perturb(neighborhood2, fulleval);
+
+    moSolComparator<Indi> comp;
+
+    //moAlwaysAcceptCrit<Neighbor> accept;
+    moBetterAcceptCrit<Neighbor> accept(comp);
+
+    moILSexplorer< Neighbor > explorerILS(hc, perturb, accept);
+
+    moIterContinuator<moDummyNeighbor<Indi> > continuatorILS(100);
+
+    moLocalSearch<moDummyNeighbor<Indi> >localSearch(explorerILS, continuatorILS, eval);
+
+
+    /* =========================================================
+     *
+     * execute the local search from random sollution
+     *
+     * ========================================================= */
+
+    Indi solution;
+
+    random(solution);
+
+    //Can be eval here, else it will be done at the beginning of the localSearch
+    //eval(solution);
+
+    std::cout << "initial: " << solution << std::endl ;
+
+    localSearch(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/Lesson6/testMetropolisHasting.cpp

@@ -0,0 +1,201 @@
+//-----------------------------------------------------------------------------
+/** testMetropolisHasting.cpp
+ *
+ * SV - 22/01/10
+ *
+ */
+//-----------------------------------------------------------------------------
+
+// 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>
+#include <ga.h>
+
+using namespace std;
+
+//-----------------------------------------------------------------------------
+// fitness function
+#include <funcOneMax.h>
+#include <eoInt.h>
+#include <neighborhood/moRndWithReplNeighborhood.h>
+#include <oneMaxBitNeighbor.h>
+
+#include <eval/moFullEvalByModif.h>
+#include <eval/moFullEvalByCopy.h>
+#include <comparator/moNeighborComparator.h>
+#include <comparator/moSolNeighborComparator.h>
+#include <continuator/moTrueContinuator.h>
+#include <algo/moLocalSearch.h>
+#include <explorer/moMetropolisHastingExplorer.h>
+
+// REPRESENTATION
+//-----------------------------------------------------------------------------
+typedef eoBit<unsigned> Indi;
+typedef moBitNeighbor<unsigned int> Neighbor ; // incremental evaluation
+typedef moRndWithReplNeighborhood<Neighbor> Neighborhood ;
+
+void main_function(int argc, char **argv)
+{
+    /* =========================================================
+    *
+    * Parameters
+    *
+    * ========================================================= */
+
+    // 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
+
+    eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
+    parser.processParam( seedParam );
+    unsigned seed = seedParam.value();
+
+    // description of genotype
+    eoValueParam<unsigned int> vecSizeParam(8, "vecSize", "Genotype size", 'V');
+    parser.processParam( vecSizeParam, "Representation" );
+    unsigned vecSize = vecSizeParam.value();
+
+    eoValueParam<unsigned int> stepParam(10, "nbStep", "Number of steps of the random walk", 'n');
+    parser.processParam( stepParam, "Representation" );
+    unsigned nbStep = stepParam.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
+    rng.reseed(seed);
+
+
+    /* =========================================================
+     *
+     * Eval fitness function
+     *
+     * ========================================================= */
+
+    FuncOneMax<Indi> eval(vecSize);
+
+
+    /* =========================================================
+     *
+     * Initilisation of the solution
+     *
+     * ========================================================= */
+
+    // a Indi random initializer
+    eoUniformGenerator<bool> uGen;
+    eoInitFixedLength<Indi> random(vecSize, uGen);
+
+
+    /* =========================================================
+     *
+     * evaluation of a neighbor solution
+     *
+     * ========================================================= */
+
+    moFullEvalByModif<Neighbor> fulleval(eval);
+
+    //An eval by copy can be used instead of the eval by modif
+    //moFullEvalByCopy<Neighbor> fulleval(eval);
+
+
+    /* =========================================================
+     *
+     * Comparator of neighbors
+     *
+     * ========================================================= */
+
+    moNeighborComparator<Neighbor> comparator;
+    moSolNeighborComparator<Neighbor> solComparator;
+
+
+    /* =========================================================
+     *
+     * the neighborhood of a solution
+     *
+     * ========================================================= */
+
+    Neighborhood neighborhood(vecSize);
+
+
+    /* =========================================================
+     *
+     * a neighborhood explorer solution
+     *
+     * ========================================================= */
+
+    moMetropolisHastingExplorer<Neighbor> explorer(neighborhood, fulleval, comparator, solComparator, nbStep);
+
+
+    /* =========================================================
+     *
+     * the local search algorithm
+     *
+     * ========================================================= */
+
+    moTrueContinuator<Neighbor> continuator;//always continue
+
+    moLocalSearch<Neighbor> localSearch(explorer, continuator, eval);
+
+    /* =========================================================
+     *
+     * execute the local search from random sollution
+     *
+     * ========================================================= */
+
+    Indi solution;
+
+    random(solution);
+
+    //Can be eval here, else it will be done at the beginning of the localSearch
+    //eval(solution);
+
+    std::cout << "initial: " << solution << std::endl ;
+
+    localSearch(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/Lesson6/testRandomNeutralWalk.cpp

@@ -0,0 +1,278 @@
+//-----------------------------------------------------------------------------
+/** testRandomNeutralWalk.cpp
+ *
+ * SV - 22/02/10
+ *
+ */
+//-----------------------------------------------------------------------------
+
+// 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>
+#include <ga.h>
+
+using namespace std;
+
+//-----------------------------------------------------------------------------
+// fitness function
+#include <funcRoyalRoad.h>
+#include <eoInt.h>
+#include <neighborhood/moRndWithoutReplNeighborhood.h>
+#include <problems/bitString/moBitNeighbor.h>
+
+#include <eval/moFullEvalByModif.h>
+#include <eval/moFullEvalByCopy.h>
+#include <comparator/moNeighborComparator.h>
+#include <comparator/moSolNeighborComparator.h>
+#include <continuator/moTrueContinuator.h>
+#include <algo/moLocalSearch.h>
+#include <explorer/moRandomNeutralWalkExplorer.h>
+
+#include <continuator/moCheckpoint.h>
+#include <continuator/moFitnessStat.h>
+#include <utils/eoDistance.h>
+#include <continuator/moDistanceStat.h>
+#include <neighborhood/moOrderNeighborhood.h>
+#include <continuator/moNeighborhoodStat.h>
+#include <continuator/moMinNeighborStat.h>
+#include <continuator/moMaxNeighborStat.h>
+#include <continuator/moSecondMomentNeighborStat.h>
+#include <continuator/moNbInfNeighborStat.h>
+#include <continuator/moNbSupNeighborStat.h>
+#include <continuator/moNeutralDegreeNeighborStat.h>
+#include <continuator/moSizeNeighborStat.h>
+
+// REPRESENTATION
+//-----------------------------------------------------------------------------
+typedef eoBit<unsigned> Indi;
+typedef moBitNeighbor<unsigned int> Neighbor ; // incremental evaluation
+typedef moRndWithoutReplNeighborhood<Neighbor> Neighborhood ;
+
+void main_function(int argc, char **argv)
+{
+    /* =========================================================
+    *
+    * Parameters
+    *
+    * ========================================================= */
+
+    // 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
+
+    eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
+    parser.processParam( seedParam );
+    unsigned seed = seedParam.value();
+
+    // description of genotype
+    eoValueParam<unsigned int> vecSizeParam(8, "vecSize", "Genotype size", 'V');
+    parser.processParam( vecSizeParam, "Representation" );
+    unsigned vecSize = vecSizeParam.value();
+
+    eoValueParam<unsigned int> blockSizeParam(2, "blockSize", "Size of block in the royal road", 'k');
+    parser.processParam( blockSizeParam, "Representation" );
+    unsigned blockSize = blockSizeParam.value();
+
+    eoValueParam<unsigned int> stepParam(10, "nbStep", "Number of steps of the random walk", 'n');
+    parser.processParam( stepParam, "Representation" );
+    unsigned nbStep = stepParam.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
+    rng.reseed(seed);
+
+
+    /* =========================================================
+     *
+     * Eval fitness function
+     *
+     * ========================================================= */
+
+    FuncRoyalRoad<Indi> eval(vecSize / blockSize, blockSize);
+
+
+    /* =========================================================
+     *
+     * Initilisazor of the solution
+     *
+     * ========================================================= */
+
+    // a Indi random initializer
+    eoUniformGenerator<bool> uGen;
+    eoInitFixedLength<Indi> random(vecSize, uGen);
+
+
+    /* =========================================================
+     *
+     * Evaluation of a neighbor solution
+     *
+     * ========================================================= */
+
+    moFullEvalByModif<Neighbor> nhEval(eval);
+
+    //An eval by copy can be used instead of the eval by modif
+    //moFullEvalByCopy<Neighbor> nhEval(eval);
+
+
+    /* =========================================================
+     *
+     * Comparator of neighbors
+     *
+     * ========================================================= */
+
+    moNeighborComparator<Neighbor> comparator;
+    moSolNeighborComparator<Neighbor> solComparator;
+
+
+    /* =========================================================
+     *
+     * the neighborhood of a solution
+     *
+     * ========================================================= */
+
+    Neighborhood neighborhood(vecSize);
+
+
+    /* =========================================================
+     *
+     * a neighborhood explorer solution
+     *
+     * ========================================================= */
+
+    moRandomNeutralWalkExplorer<Neighbor> explorer(neighborhood, nhEval, solComparator, nbStep);
+
+
+    /* =========================================================
+     *
+     * initial random solution
+     *
+     * ========================================================= */
+
+    Indi solution;
+
+    random(solution);
+
+    //Can be eval here, else it will be done at the beginning of the localSearch
+    eval(solution);
+
+    /* =========================================================
+     *
+     * the continuator and the checkpoint
+     *
+     * ========================================================= */
+
+    moTrueContinuator<Neighbor> continuator;//always continue
+
+    moCheckpoint<Neighbor> checkpoint(continuator);
+
+    moFitnessStat<Indi, unsigned> fStat;
+
+    eoHammingDistance<Indi> distance;
+    moDistanceStat<Indi, unsigned> distStat(distance, solution);  // distance from the intial solution
+
+    moOrderNeighborhood<Neighbor> nh(vecSize);
+    moNeighborhoodStat< Neighbor > neighborhoodStat(nh, nhEval, comparator, solComparator);
+    moMinNeighborStat< Neighbor > minStat(neighborhoodStat);
+    moSecondMomentNeighborStat< Neighbor > secondMomentStat(neighborhoodStat);
+    moMaxNeighborStat< Neighbor > maxStat(neighborhoodStat);
+
+    moNbSupNeighborStat< Neighbor > nbSupStat(neighborhoodStat);
+    moNbInfNeighborStat< Neighbor > nbInfStat(neighborhoodStat);
+    moNeutralDegreeNeighborStat< Neighbor > ndStat(neighborhoodStat);
+    moSizeNeighborStat< Neighbor > sizeStat(neighborhoodStat);
+
+    eoValueParam<unsigned int> genCounter(-1,"Gen");
+    eoIncrementor<unsigned int> increm(genCounter.value());
+
+    checkpoint.add(fStat);
+    checkpoint.add(distStat);
+    checkpoint.add(neighborhoodStat);
+    checkpoint.add(minStat);
+    checkpoint.add(secondMomentStat);
+    checkpoint.add(maxStat);
+    checkpoint.add(nbInfStat);
+    checkpoint.add(ndStat);
+    checkpoint.add(nbSupStat);
+    checkpoint.add(sizeStat);
+    checkpoint.add(increm);
+
+    eoFileMonitor outputfile("out.dat", " ");
+    checkpoint.add(outputfile);
+
+    outputfile.add(genCounter);
+    outputfile.add(fStat);
+    outputfile.add(distStat);
+    outputfile.add(minStat);
+    outputfile.add(secondMomentStat);
+    outputfile.add(maxStat);
+    outputfile.add(nbInfStat);
+    outputfile.add(ndStat);
+    outputfile.add(nbSupStat);
+    outputfile.add(sizeStat);
+
+    /* =========================================================
+     *
+     * the local search algorithm
+     *
+     * ========================================================= */
+
+    moLocalSearch<Neighbor> localSearch(explorer, checkpoint, eval);
+
+    /* =========================================================
+     *
+     * execute the local search from random sollution
+     *
+     * ========================================================= */
+
+    std::cout << "initial: " << solution << std::endl ;
+
+    localSearch(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/Lesson6/testRandomWalk.cpp

@@ -0,0 +1,243 @@
+//-----------------------------------------------------------------------------
+/** testRandomWalk.cpp
+ *
+ * SV - 22/01/10
+ *
+ */
+//-----------------------------------------------------------------------------
+
+// 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>
+#include <ga.h>
+
+using namespace std;
+
+//-----------------------------------------------------------------------------
+// fitness function
+#include <funcOneMax.h>
+#include <eoInt.h>
+#include <neighborhood/moRndWithReplNeighborhood.h>
+#include <oneMaxBitNeighbor.h>
+
+#include <eval/moFullEvalByModif.h>
+#include <eval/moFullEvalByCopy.h>
+#include <continuator/moTrueContinuator.h>
+#include <algo/moLocalSearch.h>
+#include <explorer/moRandomWalkExplorer.h>
+#include <continuator/moCheckpoint.h>
+#include <continuator/moFitnessStat.h>
+#include <continuator/moSolutionStat.h>
+#include <utils/eoDistance.h>
+#include <continuator/moDistanceStat.h>
+
+#include <utils/eoFileMonitor.h>
+#include <utils/eoUpdater.h>
+
+// REPRESENTATION
+//-----------------------------------------------------------------------------
+typedef eoBit<unsigned> Indi;
+typedef moBitNeighbor<unsigned int> Neighbor ; // incremental evaluation
+typedef moRndWithReplNeighborhood<Neighbor> Neighborhood ;
+
+void main_function(int argc, char **argv)
+{
+    /* =========================================================
+    *
+    * Parameters
+    *
+    * ========================================================= */
+
+    // 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
+
+    eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
+    parser.processParam( seedParam );
+    unsigned seed = seedParam.value();
+
+    // description of genotype
+    eoValueParam<unsigned int> vecSizeParam(8, "vecSize", "Genotype size", 'V');
+    parser.processParam( vecSizeParam, "Representation" );
+    unsigned vecSize = vecSizeParam.value();
+
+    eoValueParam<unsigned int> stepParam(10, "nbStep", "Number of steps of the random walk", 'n');
+    parser.processParam( stepParam, "Representation" );
+    unsigned nbStep = stepParam.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
+    rng.reseed(seed);
+
+
+    /* =========================================================
+     *
+     * Eval fitness function
+     *
+     * ========================================================= */
+
+    FuncOneMax<Indi> eval(vecSize);
+
+
+    /* =========================================================
+     *
+     * Initilisation of the solution
+     *
+     * ========================================================= */
+
+    // a Indi random initializer
+    eoUniformGenerator<bool> uGen;
+    eoInitFixedLength<Indi> random(vecSize, uGen);
+
+
+    /* =========================================================
+     *
+     * evaluation of a neighbor solution
+     *
+     * ========================================================= */
+
+    moFullEvalByModif<Neighbor> nhEval(eval);
+
+    //An eval by copy can be used instead of the eval by modif
+    //moFullEvalByCopy<Neighbor> nhEval(eval);
+
+
+    /* =========================================================
+     *
+     * the neighborhood of a solution
+     *
+     * ========================================================= */
+
+    Neighborhood neighborhood(vecSize);
+
+
+    /* =========================================================
+     *
+     * a neighborhood explorer solution
+     *
+     * ========================================================= */
+
+    moRandomWalkExplorer<Neighbor> explorer(neighborhood, nhEval, nbStep);
+
+
+    /* =========================================================
+     *
+     * the continuator and the checkpoint
+     *
+     * ========================================================= */
+
+    moTrueContinuator<Neighbor> continuator;//always continue
+
+    moCheckpoint<Neighbor> checkpoint(continuator);
+
+    moFitnessStat<Indi, unsigned> fStat;
+    eoHammingDistance<Indi> distance;
+    Indi bestSolution(vecSize, true);
+    moDistanceStat<Indi, unsigned> distStat(distance, bestSolution);
+    //	moSolutionStat<Indi> solStat;
+
+    checkpoint.add(fStat);
+    checkpoint.add(distStat);
+    //	checkpoint.add(solStat);
+
+    eoValueParam<unsigned int> genCounter(-1,"Gen");
+    eoIncrementor<unsigned int> increm(genCounter.value());
+    checkpoint.add(increm);
+
+    eoFileMonitor outputfile("out.dat", " ");
+    checkpoint.add(outputfile);
+
+    outputfile.add(genCounter);
+    outputfile.add(fStat);
+    outputfile.add(distStat);
+    //	outputfile.add(solStat);
+
+    Indi solution; // current solution of the search process
+
+    /*
+    // to save the solution at each iteration
+    eoState outState;
+
+    // Register the algorithm into the state (so it has something to save!!
+
+    outState.registerObject(solution);
+
+    // and feed the state to state savers
+    // save state every 10th iteration
+    eoCountedStateSaver stateSaver(10, outState, "iteration");
+
+      // Don't forget to add the two savers to the checkpoint
+    checkpoint.add(stateSaver);
+    */
+
+    /* =========================================================
+     *
+     * the local search algorithm
+     *
+     * ========================================================= */
+
+    moLocalSearch<Neighbor> localSearch(explorer, checkpoint, eval);
+
+    /* =========================================================
+     *
+     * execute the local search from random sollution
+     *
+     * ========================================================= */
+
+    random(solution);
+
+    //Can be eval here, else it will be done at the beginning of the localSearch
+    //eval(solution);
+
+    std::cout << "initial: " << solution << std::endl ;
+
+    localSearch(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;
+}