nojhan/paradiseo
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

RC for ParadisEO 2.0

Browse source 
git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@2709 331e1502-861f-0410-8da2-ba01fb791d7f
This commit is contained in:
quemy 2012-07-16 07:25:10 +00:00
commit 6f384f4a59
995 changed files with 136161 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

113
branches/rc2.0/paradiseo-mo/tutorial/Lesson1/CMakeLists.txt Normal file
View file

@ -0,0 +1,113 @@
######################################################################################
### 1) Include the sources
######################################################################################
INCLUDE_DIRECTORIES(${EO_SRC_DIR}/src
${MO_SRC_DIR}/src
${PROBLEMS_SRC_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/../src)
######################################################################################
### 2) Specify where CMake can find the libraries
######################################################################################
LINK_DIRECTORIES(${EO_BIN_DIR}/lib)
######################################################################################
### 3) Define your target(s): just an executable here
######################################################################################
IF(CMAKE_GENERATOR STREQUAL "Visual Studio 8 2005" OR CMAKE_GENERATOR STREQUAL "Visual Studio 9 2008" OR CMAKE_GENERATOR STREQUAL "Visual Studio 10")
SOURCE_GROUP(src FILES lesson1_simpleHC.cpp
lesson1_firstImprHC.cpp
lesson1_randomBestHC.cpp
lesson1_neutralHC.cpp
lesson1_iterContinuator.cpp
lesson1_fitContinuator.cpp
lesson1_fullEvalContinuator.cpp
lesson1_evalContinuator.cpp
lesson1_combinedContinuator.cpp
firstImprHC_maxSAT.cpp)
ADD_EXECUTABLE(lesson1_simpleHC
lesson1_simpleHC.cpp
${MO_BIN_DIR}/tutorial/lesson1/lesson1_simpleHC.param
)
ADD_EXECUTABLE(lesson1_firstImprHC
lesson1_firstImprHC.cpp
${MO_BIN_DIR}/tutorial/lesson1/lesson1_firstImprHC.param
)
ADD_EXECUTABLE(lesson1_randomBestHC
lesson1_randomBestHC.cpp
${MO_BIN_DIR}/tutorial/lesson1/lesson1_randomBestHC.param
)
ADD_EXECUTABLE(lesson1_neutralHC
lesson1_neutralHC.cpp
${MO_BIN_DIR}/tutorial/lesson1/lesson1_neutralHC.param
)
ADD_EXECUTABLE(lesson1_iterContinuator
lesson1_iterContinuator.cpp
${MO_BIN_DIR}/tutorial/lesson1/lesson1_iterContinuator.param
)
ADD_EXECUTABLE(lesson1_fitContinuator
lesson1_fitContinuator.cpp
${MO_BIN_DIR}/tutorial/lesson1/lesson1_fitContinuator.param
)
ADD_EXECUTABLE(lesson1_fullEvalContinuator
lesson1_fullEvalContinuator.cpp
${MO_BIN_DIR}/tutorial/lesson1/lesson1_fullEvalContinuator.param
)
ADD_EXECUTABLE(lesson1_evalContinuator
lesson1_evalContinuator.cpp
${MO_BIN_DIR}/tutorial/lesson1/lesson1_evalContinuator.param
)
ADD_EXECUTABLE(lesson1_combinedContinuator
lesson1_combinedContinuator.cpp
${MO_BIN_DIR}/tutorial/lesson1/lesson1_combinedContinuator.param
)
ADD_EXECUTABLE(firstImprHC_maxSAT
firstImprHC_maxSAT.cpp
${MO_BIN_DIR}/tutorial/lesson1/firstImprHC_maxSAT.param
)
ELSE(CMAKE_GENERATOR STREQUAL "Visual Studio 8 2005" OR CMAKE_GENERATOR STREQUAL "Visual Studio 9 2008" OR CMAKE_GENERATOR STREQUAL "Visual Studio 10")
ADD_COMMANDS_NEWMO()
ADD_TARGET_NEWMO(lesson1)
IF(ENABLE_CMAKE_EXAMPLE)
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_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)
ADD_EXECUTABLE(firstImprHC_maxSAT firstImprHC_maxSAT.cpp)
ELSE(ENABLE_CMAKE_EXAMPLE)
ADD_EXECUTABLE(lesson1_simpleHC EXCLUDE_FROM_ALL lesson1_simpleHC.cpp)
ADD_EXECUTABLE(lesson1_firstImprHC EXCLUDE_FROM_ALL lesson1_firstImprHC.cpp)
ADD_EXECUTABLE(lesson1_randomBestHC EXCLUDE_FROM_ALL lesson1_randomBestHC.cpp)
ADD_EXECUTABLE(lesson1_neutralHC EXCLUDE_FROM_ALL lesson1_neutralHC.cpp)
ADD_EXECUTABLE(lesson1_iterContinuator EXCLUDE_FROM_ALL lesson1_iterContinuator.cpp)
ADD_EXECUTABLE(lesson1_fitContinuator EXCLUDE_FROM_ALL lesson1_fitContinuator.cpp)
ADD_EXECUTABLE(lesson1_fullEvalContinuator EXCLUDE_FROM_ALL lesson1_fullEvalContinuator.cpp)
ADD_EXECUTABLE(lesson1_evalContinuator EXCLUDE_FROM_ALL lesson1_evalContinuator.cpp)
ADD_EXECUTABLE(lesson1_combinedContinuator EXCLUDE_FROM_ALL lesson1_combinedContinuator.cpp)
ADD_EXECUTABLE(firstImprHC_maxSAT EXCLUDE_FROM_ALL firstImprHC_maxSAT.cpp)
ENDIF(ENABLE_CMAKE_EXAMPLE)
ENDIF(CMAKE_GENERATOR STREQUAL "Visual Studio 8 2005" OR CMAKE_GENERATOR STREQUAL "Visual Studio 9 2008" OR CMAKE_GENERATOR STREQUAL "Visual Studio 10")
######################################################################################
### 4) Link the librairies for your target(s)
######################################################################################
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_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)
TARGET_LINK_LIBRARIES(firstImprHC_maxSAT eoutils ga eo)

222
branches/rc2.0/paradiseo-mo/tutorial/Lesson1/firstImprHC_maxSAT.cpp Normal file
View file

@ -0,0 +1,222 @@
//-----------------------------------------------------------------------------
/** firstImprHC_maxSAT.cpp
*
* SV - 05/05/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>
// 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/maxSATeval.h>
#include <problems/eval/moMaxSATincrEval.h>
#include <eval/moFullEvalByModif.h>
//-----------------------------------------------------------------------------
// neighborhood description
#include <neighborhood/moRndWithoutReplNeighborhood.h> // visit all neighbors in random order without repeating any neighbor
//-----------------------------------------------------------------------------
// the first improvement Hill-Climbing local search
#include <algo/moFirstImprHC.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();
// Number of clauses of the max SAT problem
eoValueParam<unsigned int> ncParam(10, "nbClauses", "Number of clauses", 'm');
parser.processParam( ncParam, "Representation" );
unsigned nbClause = ncParam.value();
// Number of litteral by clauses
eoValueParam<unsigned int> kParam(3, "nbLitt", "Number of litteral by clauses", 'k');
parser.processParam( kParam, "Representation" );
unsigned nbLitteral = kParam.value();
// the name of the instance file
string str_in = "" ; // default value
eoValueParam<string> inParam(str_in.c_str(), "in", "Input file of the file in ncf format", 'f');
parser.processParam(inParam, "Persistence" );
str_in = inParam.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);
/* =========================================================
*
* Eval fitness function (full evaluation)
*
* ========================================================= */
// the max SAT evaluation
MaxSATeval<Indi> * fullEval;
if (str_in.compare("") == 0)
fullEval = new MaxSATeval<Indi>(vecSize, nbClause, nbLitteral);
else {
fullEval = new MaxSATeval<Indi>(str_in);
vecSize = fullEval->nbVar ;
}
// string out = "cnf.dat";
// fullEval->save(out);
/* =========================================================
*
* 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:
moMaxSATincrEval<Neighbor> neighborEval(*fullEval);
/* =========================================================
*
* 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);
/* =========================================================
*
* the neighborhood of a solution
*
* ========================================================= */
// Exploration of the neighborhood in random order of the neigbor's index:
// each neighbor is visited only once
moRndWithoutReplNeighborhood<Neighbor> neighborhood(vecSize);
/* =========================================================
*
* the local search algorithm
*
* ========================================================= */
moFirstImprHC<Neighbor> hc(neighborhood, *fullEval, neighborEval);
/* =========================================================
*
* 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;
}

14
branches/rc2.0/paradiseo-mo/tutorial/Lesson1/firstImprHC_maxSAT.param Normal file
View file

@ -0,0 +1,14 @@
###### General ######
# --help=0 # -h : Prints this message
# --stopOnUnknownParam=1 # Stop if unkown param entered
# --seed=1276179091 # -S : Random number seed
###### Persistence ######
# --in= # -f : Input file of the file in ncf format
# --status=./firstImprHC_maxSAT.status # Status file
###### Representation ######
# --vecSize=20 # -V : Genotype size
# --nbClauses=10 # -m : Number of clauses
# --nbLitt=3 # -k : Number of litteral by clauses

251
branches/rc2.0/paradiseo-mo/tutorial/Lesson1/lesson1_combinedContinuator.cpp Normal file
View file

@ -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;
}

15
branches/rc2.0/paradiseo-mo/tutorial/Lesson1/lesson1_combinedContinuator.param Normal file
View file

@ -0,0 +1,15 @@
###### General ######
# --help=0 # -h : Prints this message
# --stopOnUnknownParam=1 # Stop if unkown param entered
# --seed=1276174177 # -S : Random number seed
###### Persistence ######
# --status=./lesson1_combinedContinuator.status # Status file
###### Representation ######
# --vecSize=20 # -V : Genotype size
# --fulleval=2 # Maximum number of full evaluation
# --eval=30 # -e : Maximum number of neighbor evaluation
# --fitness=16 # -f : Maximum fitness value to reach
# --iter=10 # -i : Maximum number of iterations

218
branches/rc2.0/paradiseo-mo/tutorial/Lesson1/lesson1_evalContinuator.cpp Normal file
View file

@ -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;
}

12
branches/rc2.0/paradiseo-mo/tutorial/Lesson1/lesson1_evalContinuator.param Normal file
View file

@ -0,0 +1,12 @@
###### General ######
# --help=0 # -h : Prints this message
# --stopOnUnknownParam=1 # Stop if unkown param entered
# --seed=1276179018 # -S : Random number seed
###### Persistence ######
# --status=./lesson1_evalContinuator.status # Status file
###### Representation ######
# --vecSize=20 # -V : Genotype size
# --eval=30 # -e : Maximum number of neighbor evaluation

196
branches/rc2.0/paradiseo-mo/tutorial/Lesson1/lesson1_firstImprHC.cpp Normal file
View file

@ -0,0 +1,196 @@
//-----------------------------------------------------------------------------
/** lesson1_firstImprHC.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/moRndWithoutReplNeighborhood.h> // visit all neighbors in random order without repeating any neighbor
//-----------------------------------------------------------------------------
// the first improvement Hill-Climbing local search
#include <algo/moFirstImprHC.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();
// 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 random order of the neigbor's index:
// each neighbor is visited only once
moRndWithoutReplNeighborhood<Neighbor> neighborhood(vecSize);
/* =========================================================
*
* the local search algorithm
*
* ========================================================= */
moFirstImprHC<Neighbor> hc(neighborhood, fullEval, neighborEval);
/* =========================================================
*
* 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;
}

11
branches/rc2.0/paradiseo-mo/tutorial/Lesson1/lesson1_firstImprHC.param Normal file
View file

@ -0,0 +1,11 @@
###### General ######
# --help=0 # -h : Prints this message
# --stopOnUnknownParam=1 # Stop if unkown param entered
# --seed=1276179046 # -S : Random number seed
###### Persistence ######
# --status=./lesson1_firstImprHC.status # Status file
###### Representation ######
# --vecSize=20 # -V : Genotype size

213
branches/rc2.0/paradiseo-mo/tutorial/Lesson1/lesson1_fitContinuator.cpp Normal file
View file

@ -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;
}

12
branches/rc2.0/paradiseo-mo/tutorial/Lesson1/lesson1_fitContinuator.param Normal file
View file

@ -0,0 +1,12 @@
###### General ######
# --help=0 # -h : Prints this message
# --stopOnUnknownParam=1 # Stop if unkown param entered
# --seed=1276179024 # -S : Random number seed
###### Persistence ######
# --status=./lesson1_fitContinuator.status # Status file
###### Representation ######
# --vecSize=20 # -V : Genotype size
# --fitness=16 # -f : Maximum fitness value to reach

218
branches/rc2.0/paradiseo-mo/tutorial/Lesson1/lesson1_fullEvalContinuator.cpp Normal file
View file

@ -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;
}

12
branches/rc2.0/paradiseo-mo/tutorial/Lesson1/lesson1_fullEvalContinuator.param Normal file
View file

@ -0,0 +1,12 @@
###### General ######
# --help=0 # -h : Prints this message
# --stopOnUnknownParam=1 # Stop if unkown param entered
# --seed=1276179068 # -S : Random number seed
###### Persistence ######
# --status=./lesson1_fullEvalContinuator.status # Status file
###### Representation ######
# --vecSize=20 # -V : Genotype size
# --fulleval=2 # -e : Maximum number of full evaluation

215
branches/rc2.0/paradiseo-mo/tutorial/Lesson1/lesson1_iterContinuator.cpp Normal file
View file

@ -0,0 +1,215 @@
//-----------------------------------------------------------------------------
/** lesson1_iterContinuator.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 iteration continuators
#include <continuator/moIterContinuator.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 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> 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
*
* ========================================================= */
moIterContinuator<Neighbor> continuator(iterMax);
/* =========================================================
*
* 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: " << 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;
}

12
branches/rc2.0/paradiseo-mo/tutorial/Lesson1/lesson1_iterContinuator.param Normal file
View file

@ -0,0 +1,12 @@
###### General ######
# --help=0 # -h : Prints this message
# --stopOnUnknownParam=1 # Stop if unkown param entered
# --seed=1276179030 # -S : Random number seed
###### Persistence ######
# --status=./lesson1_iterContinuator.status # Status file
###### Representation ######
# --vecSize=20 # -V : Genotype size
# --iter=10 # -i : Maximum number of iterations

200
branches/rc2.0/paradiseo-mo/tutorial/Lesson1/lesson1_neutralHC.cpp Normal file
View file

@ -0,0 +1,200 @@
//-----------------------------------------------------------------------------
/** lesson1_neutralHC.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 neutral Hill-Climbing local search: move one of random best solution even it is the same fitness
#include <algo/moNeutralHC.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();
eoValueParam<unsigned int> stepParam(10, "nbStepMax", "Number of steps of the random walk", 'n');
parser.processParam( stepParam, "Representation" );
unsigned nbStepMax = 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
// 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 local search algorithm
*
* ========================================================= */
moNeutralHC<Neighbor> hc(neighborhood, fullEval, neighborEval, nbStepMax);
/* =========================================================
*
* 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;
}

12
branches/rc2.0/paradiseo-mo/tutorial/Lesson1/lesson1_neutralHC.param Normal file
View file

@ -0,0 +1,12 @@
###### General ######
# --help=0 # -h : Prints this message
# --stopOnUnknownParam=1 # Stop if unkown param entered
# --seed=1276179072 # -S : Random number seed
###### Persistence ######
# --status=./lesson1_neutralHC.status # Status file
###### Representation ######
# --vecSize=20 # -V : Genotype size
# --nbStepMax=10 # -n : Number of steps of the random walk

196
branches/rc2.0/paradiseo-mo/tutorial/Lesson1/lesson1_randomBestHC.cpp Normal file
View file

@ -0,0 +1,196 @@
//-----------------------------------------------------------------------------
/** first_randomBestHC.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 Hill-Climbing local search which randomly one of the best solution
#include <algo/moRandomBestHC.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();
// 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 local search algorithm
*
* ========================================================= */
moRandomBestHC<Neighbor> hc(neighborhood, fullEval, neighborEval);
/* =========================================================
*
* 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;
}

11
branches/rc2.0/paradiseo-mo/tutorial/Lesson1/lesson1_randomBestHC.param Normal file
View file

@ -0,0 +1,11 @@
###### General ######
# --help=0 # -h : Prints this message
# --stopOnUnknownParam=1 # Stop if unkown param entered
# --seed=1276179038 # -S : Random number seed
###### Persistence ######
# --status=./lesson1_randomBestHC.status # Status file
###### Representation ######
# --vecSize=20 # -V : Genotype size

196
branches/rc2.0/paradiseo-mo/tutorial/Lesson1/lesson1_simpleHC.cpp Normal file
View file

@ -0,0 +1,196 @@
//-----------------------------------------------------------------------------
/** lesson1_simpleHC.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 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();
// 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 local search algorithm
*
* ========================================================= */
moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval);
/* =========================================================
*
* 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;
}

11
branches/rc2.0/paradiseo-mo/tutorial/Lesson1/lesson1_simpleHC.param Normal file
View file

@ -0,0 +1,11 @@
###### General ######
# --help=0 # -h : Prints this message
# --stopOnUnknownParam=1 # Stop if unkown param entered
# --seed=1276179075 # -S : Random number seed
###### Persistence ######
# --status=./lesson1_simpleHC.status # Status file
###### Representation ######
# --vecSize=20 # -V : Genotype size