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

Nettoyage des tutos ce coup ci c'est bon :)

Browse source 
git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@1815 331e1502-861f-0410-8da2-ba01fb791d7f
This commit is contained in:
jhumeau 2010-05-17 15:20:12 +00:00
commit 961dcba259
21 changed files with 2697 additions and 2697 deletions
Download patch file Download diff file Expand all files Collapse all files

254
trunk/paradiseo-mo/tutorial/Lesson1/firstImprHC_maxSAT.cpp
View file

@ -54,157 +54,157 @@ typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor wi
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void main_function(int argc, char **argv) void main_function(int argc, char **argv)
{ {
/* ========================================================= /* =========================================================
* *
* Parameters from parser * Parameters from parser
* *
* ========================================================= */ * ========================================================= */
// more information on the input parameters: see EO tutorial lesson 3 // 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. // 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 // First define a parser from the command-line arguments
eoParser parser(argc, argv); eoParser parser(argc, argv);
// For each parameter, define Parameter, read it through the parser, // For each parameter, define Parameter, read it through the parser,
// and assign the value to the variable // and assign the value to the variable
// random seed parameter // random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S'); eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam ); parser.processParam( seedParam );
unsigned seed = seedParam.value(); unsigned seed = seedParam.value();
// length of the bit string // length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V'); eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" ); parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value(); unsigned vecSize = vecSizeParam.value();
// Number of clauses of the max SAT problem // Number of clauses of the max SAT problem
eoValueParam<unsigned int> ncParam(10, "nbClauses", "Number of clauses", 'm'); eoValueParam<unsigned int> ncParam(10, "nbClauses", "Number of clauses", 'm');
parser.processParam( ncParam, "Representation" ); parser.processParam( ncParam, "Representation" );
unsigned nbClause = ncParam.value(); unsigned nbClause = ncParam.value();
// Number of litteral by clauses // Number of litteral by clauses
eoValueParam<unsigned int> kParam(3, "nbLitt", "Number of litteral by clauses", 'k'); eoValueParam<unsigned int> kParam(3, "nbLitt", "Number of litteral by clauses", 'k');
parser.processParam( kParam, "Representation" ); parser.processParam( kParam, "Representation" );
unsigned nbLitteral = kParam.value(); unsigned nbLitteral = kParam.value();
// the name of the instance file // the name of the instance file
string str_in = "" ; // default value string str_in = "" ; // default value
eoValueParam<string> inParam(str_in.c_str(), "in", "Input file of the file in ncf format", 'f'); eoValueParam<string> inParam(str_in.c_str(), "in", "Input file of the file in ncf format", 'f');
parser.processParam(inParam, "Persistence" ); parser.processParam(inParam, "Persistence" );
str_in = inParam.value(); str_in = inParam.value();
// the name of the "status" file where all actual parameter values will be saved // the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file"); eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" ); parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these // i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) { if (parser.userNeedsHelp()) {
parser.printHelp(cout); parser.printHelp(cout);
exit(1); exit(1);
} }
if (statusParam.value() != "") { if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str()); ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file os << parser;// and you can use that file as parameter file
} }
/* ========================================================= /* =========================================================
* *
* Random seed * Random seed
* *
* ========================================================= */ * ========================================================= */
// reproducible random seed: if you don't change SEED above, // reproducible random seed: if you don't change SEED above,
// you'll aways get the same result, NOT a random run // you'll aways get the same result, NOT a random run
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
rng.reseed(seed); rng.reseed(seed);
/* ========================================================= /* =========================================================
* *
* Eval fitness function (full evaluation) * Eval fitness function (full evaluation)
* *
* ========================================================= */ * ========================================================= */
// the max SAT evaluation // the max SAT evaluation
MaxSATeval<Indi> * fullEval; MaxSATeval<Indi> * fullEval;
if (str_in.compare("") == 0) if (str_in.compare("") == 0)
fullEval = new MaxSATeval<Indi>(vecSize, nbClause, nbLitteral); fullEval = new MaxSATeval<Indi>(vecSize, nbClause, nbLitteral);
else { else {
fullEval = new MaxSATeval<Indi>(str_in); fullEval = new MaxSATeval<Indi>(str_in);
vecSize = fullEval->nbVar ; vecSize = fullEval->nbVar ;
} }
// string out = "cnf.dat"; // string out = "cnf.dat";
// fullEval->save(out); // fullEval->save(out);
/* ========================================================= /* =========================================================
* *
* evaluation of a neighbor solution * evaluation of a neighbor solution
* *
* ========================================================= */ * ========================================================= */
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(*fullEval); // moFullEvalByModif<Neighbor> neighborEval(*fullEval);
// Incremental evaluation of the neighbor: // Incremental evaluation of the neighbor:
moMaxSATincrEval<Neighbor> neighborEval(*fullEval); moMaxSATincrEval<Neighbor> neighborEval(*fullEval);
/* ========================================================= /* =========================================================
* *
* Initialization of the solution * Initialization of the solution
* *
* ========================================================= */ * ========================================================= */
// a Indi random initializer: each bit is random // a Indi random initializer: each bit is random
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
eoUniformGenerator<bool> uGen; eoUniformGenerator<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen); eoInitFixedLength<Indi> random(vecSize, uGen);
/* ========================================================= /* =========================================================
* *
* the neighborhood of a solution * the neighborhood of a solution
* *
* ========================================================= */ * ========================================================= */
// Exploration of the neighborhood in random order of the neigbor's index: // Exploration of the neighborhood in random order of the neigbor's index:
// each neighbor is visited only once // each neighbor is visited only once
moRndWithoutReplNeighborhood<Neighbor> neighborhood(vecSize); moRndWithoutReplNeighborhood<Neighbor> neighborhood(vecSize);
/* ========================================================= /* =========================================================
* *
* the local search algorithm * the local search algorithm
* *
* ========================================================= */ * ========================================================= */
moFirstImprHC<Neighbor> hc(neighborhood, *fullEval, neighborEval); moFirstImprHC<Neighbor> hc(neighborhood, *fullEval, neighborEval);
/* ========================================================= /* =========================================================
* *
* executes the local search from a random solution * executes the local search from a random solution
* *
* ========================================================= */ * ========================================================= */
// The current solution // The current solution
Indi solution; Indi solution;
// Apply random initialization // Apply random initialization
random(solution); random(solution);
// Evaluation of the initial solution: // Evaluation of the initial solution:
// can be evaluated here, or else it will be done at the beginning of the local search // can be evaluated here, or else it will be done at the beginning of the local search
(*fullEval)(solution); (*fullEval)(solution);
// Output: the intial solution // Output: the intial solution
std::cout << "initial: " << solution << std::endl ; std::cout << "initial: " << solution << std::endl ;
// Apply the local search on the solution ! // Apply the local search on the solution !
hc(solution); hc(solution);
// Output: the final solution // Output: the final solution
std::cout << "final: " << solution << std::endl ; std::cout << "final: " << solution << std::endl ;
} }
@ -212,11 +212,11 @@ void main_function(int argc, char **argv)
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
try { try {
main_function(argc, argv); main_function(argc, argv);
} }
catch (exception& e) { catch (exception& e) {
cout << "Exception: " << e.what() << '\n'; cout << "Exception: " << e.what() << '\n';
} }
return 1; return 1;
} }

284
trunk/paradiseo-mo/tutorial/Lesson1/lesson1_combinedContinuator.cpp
View file

@ -64,176 +64,176 @@ typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor wi
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void main_function(int argc, char **argv) void main_function(int argc, char **argv)
{ {
/* ========================================================= /* =========================================================
* *
* Parameters from parser * Parameters from parser
* *
* ========================================================= */ * ========================================================= */
// more information on the input parameters: see EO tutorial lesson 3 // 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. // 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 // First define a parser from the command-line arguments
eoParser parser(argc, argv); eoParser parser(argc, argv);
// For each parameter, define Parameter, read it through the parser, // For each parameter, define Parameter, read it through the parser,
// and assign the value to the variable // and assign the value to the variable
// random seed parameter // random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S'); eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam ); parser.processParam( seedParam );
unsigned seed = seedParam.value(); unsigned seed = seedParam.value();
// length of the bit string // length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V'); eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" ); parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value(); unsigned vecSize = vecSizeParam.value();
// maximum number of full evaluation // maximum number of full evaluation
eoValueParam<unsigned int> fevalParam(2, "fulleval", "Maximum number of full evaluation"); eoValueParam<unsigned int> fevalParam(2, "fulleval", "Maximum number of full evaluation");
parser.processParam( fevalParam, "Representation" ); parser.processParam( fevalParam, "Representation" );
unsigned fullevalMax = fevalParam.value(); unsigned fullevalMax = fevalParam.value();
// maximum number of full evaluation // maximum number of full evaluation
eoValueParam<unsigned int> evalParam(30, "eval", "Maximum number of neighbor evaluation", 'e'); eoValueParam<unsigned int> evalParam(30, "eval", "Maximum number of neighbor evaluation", 'e');
parser.processParam( evalParam, "Representation" ); parser.processParam( evalParam, "Representation" );
unsigned evalMax = evalParam.value(); unsigned evalMax = evalParam.value();
// maximum fitness to reach // maximum fitness to reach
eoValueParam<unsigned int> fitParam(16, "fitness", "Maximum fitness value to reach", 'f'); eoValueParam<unsigned int> fitParam(16, "fitness", "Maximum fitness value to reach", 'f');
parser.processParam( fitParam, "Representation" ); parser.processParam( fitParam, "Representation" );
unsigned fitnessMax = fitParam.value(); unsigned fitnessMax = fitParam.value();
// maximum number of iterations // maximum number of iterations
eoValueParam<unsigned int> iterParam(10, "iter", "Maximum number of iterations", 'i'); eoValueParam<unsigned int> iterParam(10, "iter", "Maximum number of iterations", 'i');
parser.processParam( iterParam, "Representation" ); parser.processParam( iterParam, "Representation" );
unsigned iterMax = iterParam.value(); unsigned iterMax = iterParam.value();
// the name of the "status" file where all actual parameter values will be saved // the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file"); eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" ); parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these // i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) { if (parser.userNeedsHelp()) {
parser.printHelp(cout); parser.printHelp(cout);
exit(1); exit(1);
} }
if (statusParam.value() != "") { if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str()); ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file os << parser;// and you can use that file as parameter file
} }
/* ========================================================= /* =========================================================
* *
* Random seed * Random seed
* *
* ========================================================= */ * ========================================================= */
// reproducible random seed: if you don't change SEED above, // reproducible random seed: if you don't change SEED above,
// you'll aways get the same result, NOT a random run // you'll aways get the same result, NOT a random run
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
rng.reseed(seed); rng.reseed(seed);
/* ========================================================= /* =========================================================
* *
* Initialization of the solution * Initialization of the solution
* *
* ========================================================= */ * ========================================================= */
// a Indi random initializer: each bit is random // a Indi random initializer: each bit is random
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
eoUniformGenerator<bool> uGen; eoUniformGenerator<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen); eoInitFixedLength<Indi> random(vecSize, uGen);
/* ========================================================= /* =========================================================
* *
* Eval fitness function (full evaluation) * Eval fitness function (full evaluation)
* *
* ========================================================= */ * ========================================================= */
// the fitness function is just the number of 1 in the bit string // the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEvalTmp; oneMaxEval<Indi> fullEvalTmp;
// to count the number of full evaluation // to count the number of full evaluation
eoEvalFuncCounter<Indi> fullEval(fullEvalTmp); eoEvalFuncCounter<Indi> fullEval(fullEvalTmp);
/* ========================================================= /* =========================================================
* *
* evaluation of a neighbor solution * evaluation of a neighbor solution
* *
* ========================================================= */ * ========================================================= */
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval); // moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Incremental evaluation of the neighbor: fitness is modified by +/- 1 // Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEvalTmp; moOneMaxIncrEval<Neighbor> neighborEvalTmp;
// to count the number of neighbor evaluation // to count the number of neighbor evaluation
moEvalCounter<Neighbor> neighborEval(neighborEvalTmp); moEvalCounter<Neighbor> neighborEval(neighborEvalTmp);
/* ========================================================= /* =========================================================
* *
* the neighborhood of a solution * the neighborhood of a solution
* *
* ========================================================= */ * ========================================================= */
// Exploration of the neighborhood in increasing order of the neigbor's index: // Exploration of the neighborhood in increasing order of the neigbor's index:
// bit-flip from bit 0 to bit (vecSize - 1) // bit-flip from bit 0 to bit (vecSize - 1)
moOrderNeighborhood<Neighbor> neighborhood(vecSize); moOrderNeighborhood<Neighbor> neighborhood(vecSize);
/* ========================================================= /* =========================================================
* *
* the external continuators * the external continuators
* *
* ========================================================= */ * ========================================================= */
moIterContinuator<Neighbor> iterCont(iterMax); moIterContinuator<Neighbor> iterCont(iterMax);
moFitContinuator<Neighbor> fitCont(fitnessMax); moFitContinuator<Neighbor> fitCont(fitnessMax);
moFullEvalContinuator<Neighbor> fullevalCont(fullEval, fullevalMax); moFullEvalContinuator<Neighbor> fullevalCont(fullEval, fullevalMax);
moNeighborEvalContinuator<Neighbor> evalCont(neighborEval, evalMax); moNeighborEvalContinuator<Neighbor> evalCont(neighborEval, evalMax);
moCombinedContinuator<Neighbor> continuator(iterCont); moCombinedContinuator<Neighbor> continuator(iterCont);
continuator.add(fitCont); continuator.add(fitCont);
continuator.add(fullevalCont); continuator.add(fullevalCont);
continuator.add(evalCont); continuator.add(evalCont);
/* ========================================================= /* =========================================================
* *
* the local search algorithm * the local search algorithm
* *
* ========================================================= */ * ========================================================= */
moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval, continuator); moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval, continuator);
/* ========================================================= /* =========================================================
* *
* executes the local search from a random solution * executes the local search from a random solution
* *
* ========================================================= */ * ========================================================= */
// The current solution // The current solution
Indi solution; Indi solution;
// Apply random initialization // Apply random initialization
random(solution); random(solution);
// Evaluation of the initial solution: // Evaluation of the initial solution:
// can be evaluated here, or else it will be done at the beginning of the local search // can be evaluated here, or else it will be done at the beginning of the local search
fullEval(solution); fullEval(solution);
// Output: the intial solution // Output: the intial solution
std::cout << "initial: " << solution << std::endl ; std::cout << "initial: " << solution << std::endl ;
// Apply the local search on the solution ! // Apply the local search on the solution !
hc(solution); hc(solution);
// Output: the final solution // Output: the final solution
std::cout << "final: " << solution << std::endl ; std::cout << "final: " << solution << std::endl ;
std::cout << "number of iteration: " << iterCont.value() << 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 full evaluations during the local search: " << fullevalCont.value() << std::endl ;
std::cout << "Number of neighbor evaluations during the local search: " << evalCont.value() << std::endl ; std::cout << "Number of neighbor evaluations during the local search: " << evalCont.value() << std::endl ;
} }
@ -241,11 +241,11 @@ void main_function(int argc, char **argv)
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
try { try {
main_function(argc, argv); main_function(argc, argv);
} }
catch (exception& e) { catch (exception& e) {
cout << "Exception: " << e.what() << '\n'; cout << "Exception: " << e.what() << '\n';
} }
return 1; return 1;
} }

238
trunk/paradiseo-mo/tutorial/Lesson1/lesson1_evalContinuator.cpp
View file

@ -59,148 +59,148 @@ typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor wi
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void main_function(int argc, char **argv) void main_function(int argc, char **argv)
{ {
/* ========================================================= /* =========================================================
* *
* Parameters from parser * Parameters from parser
* *
* ========================================================= */ * ========================================================= */
// more information on the input parameters: see EO tutorial lesson 3 // 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. // 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 // First define a parser from the command-line arguments
eoParser parser(argc, argv); eoParser parser(argc, argv);
// For each parameter, define Parameter, read it through the parser, // For each parameter, define Parameter, read it through the parser,
// and assign the value to the variable // and assign the value to the variable
// random seed parameter // random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S'); eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam ); parser.processParam( seedParam );
unsigned seed = seedParam.value(); unsigned seed = seedParam.value();
// length of the bit string // length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V'); eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" ); parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value(); unsigned vecSize = vecSizeParam.value();
// maximum number of full evaluation // maximum number of full evaluation
eoValueParam<unsigned int> evalParam(30, "eval", "Maximum number of neighbor evaluation", 'e'); eoValueParam<unsigned int> evalParam(30, "eval", "Maximum number of neighbor evaluation", 'e');
parser.processParam( evalParam, "Representation" ); parser.processParam( evalParam, "Representation" );
unsigned evalMax = evalParam.value(); unsigned evalMax = evalParam.value();
// the name of the "status" file where all actual parameter values will be saved // the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file"); eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" ); parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these // i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) { if (parser.userNeedsHelp()) {
parser.printHelp(cout); parser.printHelp(cout);
exit(1); exit(1);
} }
if (statusParam.value() != "") { if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str()); ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file os << parser;// and you can use that file as parameter file
} }
/* ========================================================= /* =========================================================
* *
* Random seed * Random seed
* *
* ========================================================= */ * ========================================================= */
// reproducible random seed: if you don't change SEED above, // reproducible random seed: if you don't change SEED above,
// you'll aways get the same result, NOT a random run // you'll aways get the same result, NOT a random run
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
rng.reseed(seed); rng.reseed(seed);
/* ========================================================= /* =========================================================
* *
* Initialization of the solution * Initialization of the solution
* *
* ========================================================= */ * ========================================================= */
// a Indi random initializer: each bit is random // a Indi random initializer: each bit is random
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
eoUniformGenerator<bool> uGen; eoUniformGenerator<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen); eoInitFixedLength<Indi> random(vecSize, uGen);
/* ========================================================= /* =========================================================
* *
* Eval fitness function (full evaluation) * Eval fitness function (full evaluation)
* *
* ========================================================= */ * ========================================================= */
// the fitness function is just the number of 1 in the bit string // the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEval; oneMaxEval<Indi> fullEval;
/* ========================================================= /* =========================================================
* *
* evaluation of a neighbor solution * evaluation of a neighbor solution
* *
* ========================================================= */ * ========================================================= */
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval); // moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Incremental evaluation of the neighbor: fitness is modified by +/- 1 // Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEvalTmp; moOneMaxIncrEval<Neighbor> neighborEvalTmp;
// to count the number of neighbor evaluation // to count the number of neighbor evaluation
moEvalCounter<Neighbor> neighborEval(neighborEvalTmp); moEvalCounter<Neighbor> neighborEval(neighborEvalTmp);
/* ========================================================= /* =========================================================
* *
* the neighborhood of a solution * the neighborhood of a solution
* *
* ========================================================= */ * ========================================================= */
// Exploration of the neighborhood in increasing order of the neigbor's index: // Exploration of the neighborhood in increasing order of the neigbor's index:
// bit-flip from bit 0 to bit (vecSize - 1) // bit-flip from bit 0 to bit (vecSize - 1)
moOrderNeighborhood<Neighbor> neighborhood(vecSize); moOrderNeighborhood<Neighbor> neighborhood(vecSize);
/* ========================================================= /* =========================================================
* *
* the external continuators * the external continuators
* *
* ========================================================= */ * ========================================================= */
moNeighborEvalContinuator<Neighbor> continuator(neighborEval, evalMax); moNeighborEvalContinuator<Neighbor> continuator(neighborEval, evalMax);
/* ========================================================= /* =========================================================
* *
* the local search algorithm * the local search algorithm
* *
* ========================================================= */ * ========================================================= */
moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval, continuator); moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval, continuator);
/* ========================================================= /* =========================================================
* *
* executes the local search from a random solution * executes the local search from a random solution
* *
* ========================================================= */ * ========================================================= */
// The current solution // The current solution
Indi solution; Indi solution;
// Apply random initialization // Apply random initialization
random(solution); random(solution);
// Evaluation of the initial solution: // Evaluation of the initial solution:
// can be evaluated here, or else it will be done at the beginning of the local search // can be evaluated here, or else it will be done at the beginning of the local search
fullEval(solution); fullEval(solution);
// Output: the intial solution // Output: the intial solution
std::cout << "initial: " << solution << std::endl ; std::cout << "initial: " << solution << std::endl ;
// Apply the local search on the solution ! // Apply the local search on the solution !
hc(solution); hc(solution);
// Output: the final solution // Output: the final solution
std::cout << "final: " << solution << std::endl ; std::cout << "final: " << solution << std::endl ;
std::cout << "Number of neighbor evaluations during the local search: " << continuator.value() << std::endl ; std::cout << "Number of neighbor evaluations during the local search: " << continuator.value() << std::endl ;
} }
@ -208,11 +208,11 @@ void main_function(int argc, char **argv)
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
try { try {
main_function(argc, argv); main_function(argc, argv);
} }
catch (exception& e) { catch (exception& e) {
cout << "Exception: " << e.what() << '\n'; cout << "Exception: " << e.what() << '\n';
} }
return 1; return 1;
} }

212
trunk/paradiseo-mo/tutorial/Lesson1/lesson1_firstImprHC.cpp
View file

@ -54,131 +54,131 @@ typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor wi
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void main_function(int argc, char **argv) void main_function(int argc, char **argv)
{ {
/* ========================================================= /* =========================================================
* *
* Parameters from parser * Parameters from parser
* *
* ========================================================= */ * ========================================================= */
// more information on the input parameters: see EO tutorial lesson 3 // 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. // 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 // First define a parser from the command-line arguments
eoParser parser(argc, argv); eoParser parser(argc, argv);
// For each parameter, define Parameter, read it through the parser, // For each parameter, define Parameter, read it through the parser,
// and assign the value to the variable // and assign the value to the variable
// random seed parameter // random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S'); eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam ); parser.processParam( seedParam );
unsigned seed = seedParam.value(); unsigned seed = seedParam.value();
// length of the bit string // length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V'); eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" ); parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value(); unsigned vecSize = vecSizeParam.value();
// the name of the "status" file where all actual parameter values will be saved // the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file"); eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" ); parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these // i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) { if (parser.userNeedsHelp()) {
parser.printHelp(cout); parser.printHelp(cout);
exit(1); exit(1);
} }
if (statusParam.value() != "") { if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str()); ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file os << parser;// and you can use that file as parameter file
} }
/* ========================================================= /* =========================================================
* *
* Random seed * Random seed
* *
* ========================================================= */ * ========================================================= */
// reproducible random seed: if you don't change SEED above, // reproducible random seed: if you don't change SEED above,
// you'll aways get the same result, NOT a random run // you'll aways get the same result, NOT a random run
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
rng.reseed(seed); rng.reseed(seed);
/* ========================================================= /* =========================================================
* *
* Initialization of the solution * Initialization of the solution
* *
* ========================================================= */ * ========================================================= */
// a Indi random initializer: each bit is random // a Indi random initializer: each bit is random
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
eoUniformGenerator<bool> uGen; eoUniformGenerator<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen); eoInitFixedLength<Indi> random(vecSize, uGen);
/* ========================================================= /* =========================================================
* *
* Eval fitness function (full evaluation) * Eval fitness function (full evaluation)
* *
* ========================================================= */ * ========================================================= */
// the fitness function is just the number of 1 in the bit string // the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEval; oneMaxEval<Indi> fullEval;
/* ========================================================= /* =========================================================
* *
* evaluation of a neighbor solution * evaluation of a neighbor solution
* *
* ========================================================= */ * ========================================================= */
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval); // moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Incremental evaluation of the neighbor: fitness is modified by +/- 1 // Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEval; moOneMaxIncrEval<Neighbor> neighborEval;
/* ========================================================= /* =========================================================
* *
* the neighborhood of a solution * the neighborhood of a solution
* *
* ========================================================= */ * ========================================================= */
// Exploration of the neighborhood in random order of the neigbor's index: // Exploration of the neighborhood in random order of the neigbor's index:
// each neighbor is visited only once // each neighbor is visited only once
moRndWithoutReplNeighborhood<Neighbor> neighborhood(vecSize); moRndWithoutReplNeighborhood<Neighbor> neighborhood(vecSize);
/* ========================================================= /* =========================================================
* *
* the local search algorithm * the local search algorithm
* *
* ========================================================= */ * ========================================================= */
moFirstImprHC<Neighbor> hc(neighborhood, fullEval, neighborEval); moFirstImprHC<Neighbor> hc(neighborhood, fullEval, neighborEval);
/* ========================================================= /* =========================================================
* *
* executes the local search from a random solution * executes the local search from a random solution
* *
* ========================================================= */ * ========================================================= */
// The current solution // The current solution
Indi solution; Indi solution;
// Apply random initialization // Apply random initialization
random(solution); random(solution);
// Evaluation of the initial solution: // Evaluation of the initial solution:
// can be evaluated here, or else it will be done at the beginning of the local search // can be evaluated here, or else it will be done at the beginning of the local search
fullEval(solution); fullEval(solution);
// Output: the intial solution // Output: the intial solution
std::cout << "initial: " << solution << std::endl ; std::cout << "initial: " << solution << std::endl ;
// Apply the local search on the solution ! // Apply the local search on the solution !
hc(solution); hc(solution);
// Output: the final solution // Output: the final solution
std::cout << "final: " << solution << std::endl ; std::cout << "final: " << solution << std::endl ;
} }
@ -186,11 +186,11 @@ void main_function(int argc, char **argv)
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
try { try {
main_function(argc, argv); main_function(argc, argv);
} }
catch (exception& e) { catch (exception& e) {
cout << "Exception: " << e.what() << '\n'; cout << "Exception: " << e.what() << '\n';
} }
return 1; return 1;
} }

232
trunk/paradiseo-mo/tutorial/Lesson1/lesson1_fitContinuator.cpp
View file

@ -58,144 +58,144 @@ typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor wi
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void main_function(int argc, char **argv) void main_function(int argc, char **argv)
{ {
/* ========================================================= /* =========================================================
* *
* Parameters from parser * Parameters from parser
* *
* ========================================================= */ * ========================================================= */
// more information on the input parameters: see EO tutorial lesson 3 // 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. // 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 // First define a parser from the command-line arguments
eoParser parser(argc, argv); eoParser parser(argc, argv);
// For each parameter, define Parameter, read it through the parser, // For each parameter, define Parameter, read it through the parser,
// and assign the value to the variable // and assign the value to the variable
// random seed parameter // random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S'); eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam ); parser.processParam( seedParam );
unsigned seed = seedParam.value(); unsigned seed = seedParam.value();
// length of the bit string // length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V'); eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" ); parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value(); unsigned vecSize = vecSizeParam.value();
// maximum fitness to reach // maximum fitness to reach
eoValueParam<unsigned int> fitParam(16, "fitness", "Maximum fitness value to reach", 'f'); eoValueParam<unsigned int> fitParam(16, "fitness", "Maximum fitness value to reach", 'f');
parser.processParam( fitParam, "Representation" ); parser.processParam( fitParam, "Representation" );
unsigned fitnessMax = fitParam.value(); unsigned fitnessMax = fitParam.value();
// the name of the "status" file where all actual parameter values will be saved // the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file"); eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" ); parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these // i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) { if (parser.userNeedsHelp()) {
parser.printHelp(cout); parser.printHelp(cout);
exit(1); exit(1);
} }
if (statusParam.value() != "") { if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str()); ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file os << parser;// and you can use that file as parameter file
} }
/* ========================================================= /* =========================================================
* *
* Random seed * Random seed
* *
* ========================================================= */ * ========================================================= */
// reproducible random seed: if you don't change SEED above, // reproducible random seed: if you don't change SEED above,
// you'll aways get the same result, NOT a random run // you'll aways get the same result, NOT a random run
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
rng.reseed(seed); rng.reseed(seed);
/* ========================================================= /* =========================================================
* *
* Initialization of the solution * Initialization of the solution
* *
* ========================================================= */ * ========================================================= */
// a Indi random initializer: each bit is random // a Indi random initializer: each bit is random
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
eoUniformGenerator<bool> uGen; eoUniformGenerator<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen); eoInitFixedLength<Indi> random(vecSize, uGen);
/* ========================================================= /* =========================================================
* *
* Eval fitness function (full evaluation) * Eval fitness function (full evaluation)
* *
* ========================================================= */ * ========================================================= */
// the fitness function is just the number of 1 in the bit string // the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEval; oneMaxEval<Indi> fullEval;
/* ========================================================= /* =========================================================
* *
* evaluation of a neighbor solution * evaluation of a neighbor solution
* *
* ========================================================= */ * ========================================================= */
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval); // moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Incremental evaluation of the neighbor: fitness is modified by +/- 1 // Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEval; moOneMaxIncrEval<Neighbor> neighborEval;
/* ========================================================= /* =========================================================
* *
* the neighborhood of a solution * the neighborhood of a solution
* *
* ========================================================= */ * ========================================================= */
// Exploration of the neighborhood in increasing order of the neigbor's index: // Exploration of the neighborhood in increasing order of the neigbor's index:
// bit-flip from bit 0 to bit (vecSize - 1) // bit-flip from bit 0 to bit (vecSize - 1)
moOrderNeighborhood<Neighbor> neighborhood(vecSize); moOrderNeighborhood<Neighbor> neighborhood(vecSize);
/* ========================================================= /* =========================================================
* *
* the external continuators * the external continuators
* *
* ========================================================= */ * ========================================================= */
moFitContinuator<Neighbor> continuator(fitnessMax); moFitContinuator<Neighbor> continuator(fitnessMax);
/* ========================================================= /* =========================================================
* *
* the local search algorithm * the local search algorithm
* *
* ========================================================= */ * ========================================================= */
moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval, continuator); moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval, continuator);
/* ========================================================= /* =========================================================
* *
* executes the local search from a random solution * executes the local search from a random solution
* *
* ========================================================= */ * ========================================================= */
// The current solution // The current solution
Indi solution; Indi solution;
// Apply random initialization // Apply random initialization
random(solution); random(solution);
// Evaluation of the initial solution: // Evaluation of the initial solution:
// can be evaluated here, or else it will be done at the beginning of the local search // can be evaluated here, or else it will be done at the beginning of the local search
fullEval(solution); fullEval(solution);
// Output: the intial solution // Output: the intial solution
std::cout << "initial: " << solution << std::endl ; std::cout << "initial: " << solution << std::endl ;
// Apply the local search on the solution ! // Apply the local search on the solution !
hc(solution); hc(solution);
// Output: the final solution // Output: the final solution
std::cout << "final: " << solution << std::endl ; std::cout << "final: " << solution << std::endl ;
} }
@ -203,11 +203,11 @@ void main_function(int argc, char **argv)
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
try { try {
main_function(argc, argv); main_function(argc, argv);
} }
catch (exception& e) { catch (exception& e) {
cout << "Exception: " << e.what() << '\n'; cout << "Exception: " << e.what() << '\n';
} }
return 1; return 1;
} }

238
trunk/paradiseo-mo/tutorial/Lesson1/lesson1_fullEvalContinuator.cpp
View file

@ -59,148 +59,148 @@ typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor wi
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void main_function(int argc, char **argv) void main_function(int argc, char **argv)
{ {
/* ========================================================= /* =========================================================
* *
* Parameters from parser * Parameters from parser
* *
* ========================================================= */ * ========================================================= */
// more information on the input parameters: see EO tutorial lesson 3 // 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. // 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 // First define a parser from the command-line arguments
eoParser parser(argc, argv); eoParser parser(argc, argv);
// For each parameter, define Parameter, read it through the parser, // For each parameter, define Parameter, read it through the parser,
// and assign the value to the variable // and assign the value to the variable
// random seed parameter // random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S'); eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam ); parser.processParam( seedParam );
unsigned seed = seedParam.value(); unsigned seed = seedParam.value();
// length of the bit string // length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V'); eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" ); parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value(); unsigned vecSize = vecSizeParam.value();
// maximum number of full evaluation // maximum number of full evaluation
eoValueParam<unsigned int> evalParam(2, "fulleval", "Maximum number of full evaluation", 'e'); eoValueParam<unsigned int> evalParam(2, "fulleval", "Maximum number of full evaluation", 'e');
parser.processParam( evalParam, "Representation" ); parser.processParam( evalParam, "Representation" );
unsigned fullevalMax = evalParam.value(); unsigned fullevalMax = evalParam.value();
// the name of the "status" file where all actual parameter values will be saved // the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file"); eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" ); parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these // i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) { if (parser.userNeedsHelp()) {
parser.printHelp(cout); parser.printHelp(cout);
exit(1); exit(1);
} }
if (statusParam.value() != "") { if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str()); ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file os << parser;// and you can use that file as parameter file
} }
/* ========================================================= /* =========================================================
* *
* Random seed * Random seed
* *
* ========================================================= */ * ========================================================= */
// reproducible random seed: if you don't change SEED above, // reproducible random seed: if you don't change SEED above,
// you'll aways get the same result, NOT a random run // you'll aways get the same result, NOT a random run
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
rng.reseed(seed); rng.reseed(seed);
/* ========================================================= /* =========================================================
* *
* Initialization of the solution * Initialization of the solution
* *
* ========================================================= */ * ========================================================= */
// a Indi random initializer: each bit is random // a Indi random initializer: each bit is random
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
eoUniformGenerator<bool> uGen; eoUniformGenerator<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen); eoInitFixedLength<Indi> random(vecSize, uGen);
/* ========================================================= /* =========================================================
* *
* Eval fitness function (full evaluation) * Eval fitness function (full evaluation)
* *
* ========================================================= */ * ========================================================= */
// the fitness function is just the number of 1 in the bit string // the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEvalTmp; oneMaxEval<Indi> fullEvalTmp;
// to count the number of full evaluation // to count the number of full evaluation
eoEvalFuncCounter<Indi> fullEval(fullEvalTmp); eoEvalFuncCounter<Indi> fullEval(fullEvalTmp);
/* ========================================================= /* =========================================================
* *
* evaluation of a neighbor solution * evaluation of a neighbor solution
* *
* ========================================================= */ * ========================================================= */
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval); // moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Incremental evaluation of the neighbor: fitness is modified by +/- 1 // Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEval; moOneMaxIncrEval<Neighbor> neighborEval;
/* ========================================================= /* =========================================================
* *
* the neighborhood of a solution * the neighborhood of a solution
* *
* ========================================================= */ * ========================================================= */
// Exploration of the neighborhood in increasing order of the neigbor's index: // Exploration of the neighborhood in increasing order of the neigbor's index:
// bit-flip from bit 0 to bit (vecSize - 1) // bit-flip from bit 0 to bit (vecSize - 1)
moOrderNeighborhood<Neighbor> neighborhood(vecSize); moOrderNeighborhood<Neighbor> neighborhood(vecSize);
/* ========================================================= /* =========================================================
* *
* the external continuators * the external continuators
* *
* ========================================================= */ * ========================================================= */
moFullEvalContinuator<Neighbor> continuator(fullEval, fullevalMax); moFullEvalContinuator<Neighbor> continuator(fullEval, fullevalMax);
/* ========================================================= /* =========================================================
* *
* the local search algorithm * the local search algorithm
* *
* ========================================================= */ * ========================================================= */
moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval, continuator); moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval, continuator);
/* ========================================================= /* =========================================================
* *
* executes the local search from a random solution * executes the local search from a random solution
* *
* ========================================================= */ * ========================================================= */
// The current solution // The current solution
Indi solution; Indi solution;
// Apply random initialization // Apply random initialization
random(solution); random(solution);
// Evaluation of the initial solution: // Evaluation of the initial solution:
// can be evaluated here, or else it will be done at the beginning of the local search // can be evaluated here, or else it will be done at the beginning of the local search
fullEval(solution); fullEval(solution);
// Output: the intial solution // Output: the intial solution
std::cout << "initial: " << solution << std::endl ; std::cout << "initial: " << solution << std::endl ;
// Apply the local search on the solution ! // Apply the local search on the solution !
hc(solution); hc(solution);
// Output: the final solution // Output: the final solution
std::cout << "final: " << solution << std::endl ; std::cout << "final: " << solution << std::endl ;
std::cout << "Number of full evaluations during the local search: " << continuator.value() << std::endl ; std::cout << "Number of full evaluations during the local search: " << continuator.value() << std::endl ;
} }
@ -208,11 +208,11 @@ void main_function(int argc, char **argv)
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
try { try {
main_function(argc, argv); main_function(argc, argv);
} }
catch (exception& e) { catch (exception& e) {
cout << "Exception: " << e.what() << '\n'; cout << "Exception: " << e.what() << '\n';
} }
return 1; return 1;
} }

234
trunk/paradiseo-mo/tutorial/Lesson1/lesson1_iterContinuator.cpp
View file

@ -58,146 +58,146 @@ typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor wi
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void main_function(int argc, char **argv) void main_function(int argc, char **argv)
{ {
/* ========================================================= /* =========================================================
* *
* Parameters from parser * Parameters from parser
* *
* ========================================================= */ * ========================================================= */
// more information on the input parameters: see EO tutorial lesson 3 // 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. // 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 // First define a parser from the command-line arguments
eoParser parser(argc, argv); eoParser parser(argc, argv);
// For each parameter, define Parameter, read it through the parser, // For each parameter, define Parameter, read it through the parser,
// and assign the value to the variable // and assign the value to the variable
// random seed parameter // random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S'); eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam ); parser.processParam( seedParam );
unsigned seed = seedParam.value(); unsigned seed = seedParam.value();
// length of the bit string // length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V'); eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" ); parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value(); unsigned vecSize = vecSizeParam.value();
// maximum number of iterations // maximum number of iterations
eoValueParam<unsigned int> iterParam(10, "iter", "Maximum number of iterations", 'i'); eoValueParam<unsigned int> iterParam(10, "iter", "Maximum number of iterations", 'i');
parser.processParam( iterParam, "Representation" ); parser.processParam( iterParam, "Representation" );
unsigned iterMax = iterParam.value(); unsigned iterMax = iterParam.value();
// the name of the "status" file where all actual parameter values will be saved // the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file"); eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" ); parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these // i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) { if (parser.userNeedsHelp()) {
parser.printHelp(cout); parser.printHelp(cout);
exit(1); exit(1);
} }
if (statusParam.value() != "") { if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str()); ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file os << parser;// and you can use that file as parameter file
} }
/* ========================================================= /* =========================================================
* *
* Random seed * Random seed
* *
* ========================================================= */ * ========================================================= */
// reproducible random seed: if you don't change SEED above, // reproducible random seed: if you don't change SEED above,
// you'll aways get the same result, NOT a random run // you'll aways get the same result, NOT a random run
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
rng.reseed(seed); rng.reseed(seed);
/* ========================================================= /* =========================================================
* *
* Initialization of the solution * Initialization of the solution
* *
* ========================================================= */ * ========================================================= */
// a Indi random initializer: each bit is random // a Indi random initializer: each bit is random
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
eoUniformGenerator<bool> uGen; eoUniformGenerator<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen); eoInitFixedLength<Indi> random(vecSize, uGen);
/* ========================================================= /* =========================================================
* *
* Eval fitness function (full evaluation) * Eval fitness function (full evaluation)
* *
* ========================================================= */ * ========================================================= */
// the fitness function is just the number of 1 in the bit string // the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEval; oneMaxEval<Indi> fullEval;
/* ========================================================= /* =========================================================
* *
* evaluation of a neighbor solution * evaluation of a neighbor solution
* *
* ========================================================= */ * ========================================================= */
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval); // moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Incremental evaluation of the neighbor: fitness is modified by +/- 1 // Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEval; moOneMaxIncrEval<Neighbor> neighborEval;
/* ========================================================= /* =========================================================
* *
* the neighborhood of a solution * the neighborhood of a solution
* *
* ========================================================= */ * ========================================================= */
// Exploration of the neighborhood in increasing order of the neigbor's index: // Exploration of the neighborhood in increasing order of the neigbor's index:
// bit-flip from bit 0 to bit (vecSize - 1) // bit-flip from bit 0 to bit (vecSize - 1)
moOrderNeighborhood<Neighbor> neighborhood(vecSize); moOrderNeighborhood<Neighbor> neighborhood(vecSize);
/* ========================================================= /* =========================================================
* *
* the external continuators * the external continuators
* *
* ========================================================= */ * ========================================================= */
moIterContinuator<Neighbor> continuator(iterMax); moIterContinuator<Neighbor> continuator(iterMax);
/* ========================================================= /* =========================================================
* *
* the local search algorithm * the local search algorithm
* *
* ========================================================= */ * ========================================================= */
moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval, continuator); moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval, continuator);
/* ========================================================= /* =========================================================
* *
* executes the local search from a random solution * executes the local search from a random solution
* *
* ========================================================= */ * ========================================================= */
// The current solution // The current solution
Indi solution; Indi solution;
// Apply random initialization // Apply random initialization
random(solution); random(solution);
// Evaluation of the initial solution: // Evaluation of the initial solution:
// can be evaluated here, or else it will be done at the beginning of the local search // can be evaluated here, or else it will be done at the beginning of the local search
fullEval(solution); fullEval(solution);
// Output: the intial solution // Output: the intial solution
std::cout << "initial: " << solution << std::endl ; std::cout << "initial: " << solution << std::endl ;
// Apply the local search on the solution ! // Apply the local search on the solution !
hc(solution); hc(solution);
// Output: the final solution // Output: the final solution
std::cout << "final: " << solution << std::endl ; std::cout << "final: " << solution << std::endl ;
std::cout << "number of iteration: " << continuator.value() << std::endl ; std::cout << "number of iteration: " << continuator.value() << std::endl ;
} }
@ -205,11 +205,11 @@ void main_function(int argc, char **argv)
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
try { try {
main_function(argc, argv); main_function(argc, argv);
} }
catch (exception& e) { catch (exception& e) {
cout << "Exception: " << e.what() << '\n'; cout << "Exception: " << e.what() << '\n';
} }
return 1; return 1;
} }

218
trunk/paradiseo-mo/tutorial/Lesson1/lesson1_neutralHC.cpp
View file

@ -54,135 +54,135 @@ typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor wi
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void main_function(int argc, char **argv) void main_function(int argc, char **argv)
{ {
/* ========================================================= /* =========================================================
* *
* Parameters from parser * Parameters from parser
* *
* ========================================================= */ * ========================================================= */
// more information on the input parameters: see EO tutorial lesson 3 // 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. // 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 // First define a parser from the command-line arguments
eoParser parser(argc, argv); eoParser parser(argc, argv);
// For each parameter, define Parameter, read it through the parser, // For each parameter, define Parameter, read it through the parser,
// and assign the value to the variable // and assign the value to the variable
// random seed parameter // random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S'); eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam ); parser.processParam( seedParam );
unsigned seed = seedParam.value(); unsigned seed = seedParam.value();
// length of the bit string // length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V'); eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" ); parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value(); unsigned vecSize = vecSizeParam.value();
eoValueParam<unsigned int> stepParam(10, "nbStepMax", "Number of steps of the random walk", 'n'); eoValueParam<unsigned int> stepParam(10, "nbStepMax", "Number of steps of the random walk", 'n');
parser.processParam( stepParam, "Representation" ); parser.processParam( stepParam, "Representation" );
unsigned nbStepMax = stepParam.value(); unsigned nbStepMax = stepParam.value();
// the name of the "status" file where all actual parameter values will be saved // the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file"); eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" ); parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these // i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) { if (parser.userNeedsHelp()) {
parser.printHelp(cout); parser.printHelp(cout);
exit(1); exit(1);
} }
if (statusParam.value() != "") { if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str()); ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file os << parser;// and you can use that file as parameter file
} }
/* ========================================================= /* =========================================================
* *
* Random seed * Random seed
* *
* ========================================================= */ * ========================================================= */
// reproducible random seed: if you don't change SEED above, // reproducible random seed: if you don't change SEED above,
// you'll aways get the same result, NOT a random run // you'll aways get the same result, NOT a random run
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
rng.reseed(seed); rng.reseed(seed);
/* ========================================================= /* =========================================================
* *
* Initialization of the solution * Initialization of the solution
* *
* ========================================================= */ * ========================================================= */
// a Indi random initializer: each bit is random // a Indi random initializer: each bit is random
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
eoUniformGenerator<bool> uGen; eoUniformGenerator<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen); eoInitFixedLength<Indi> random(vecSize, uGen);
/* ========================================================= /* =========================================================
* *
* Eval fitness function (full evaluation) * Eval fitness function (full evaluation)
* *
* ========================================================= */ * ========================================================= */
// the fitness function is just the number of 1 in the bit string // the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEval; oneMaxEval<Indi> fullEval;
/* ========================================================= /* =========================================================
* *
* evaluation of a neighbor solution * evaluation of a neighbor solution
* *
* ========================================================= */ * ========================================================= */
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval); // moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Incremental evaluation of the neighbor: fitness is modified by +/- 1 // Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEval; moOneMaxIncrEval<Neighbor> neighborEval;
/* ========================================================= /* =========================================================
* *
* the neighborhood of a solution * the neighborhood of a solution
* *
* ========================================================= */ * ========================================================= */
// Exploration of the neighborhood in increasing order of the neigbor's index: // Exploration of the neighborhood in increasing order of the neigbor's index:
// bit-flip from bit 0 to bit (vecSize - 1) // bit-flip from bit 0 to bit (vecSize - 1)
moOrderNeighborhood<Neighbor> neighborhood(vecSize); moOrderNeighborhood<Neighbor> neighborhood(vecSize);
/* ========================================================= /* =========================================================
* *
* the local search algorithm * the local search algorithm
* *
* ========================================================= */ * ========================================================= */
moNeutralHC<Neighbor> hc(neighborhood, fullEval, neighborEval, nbStepMax); moNeutralHC<Neighbor> hc(neighborhood, fullEval, neighborEval, nbStepMax);
/* ========================================================= /* =========================================================
* *
* executes the local search from a random solution * executes the local search from a random solution
* *
* ========================================================= */ * ========================================================= */
// The current solution // The current solution
Indi solution; Indi solution;
// Apply random initialization // Apply random initialization
random(solution); random(solution);
// Evaluation of the initial solution: // Evaluation of the initial solution:
// can be evaluated here, or else it will be done at the beginning of the local search // can be evaluated here, or else it will be done at the beginning of the local search
fullEval(solution); fullEval(solution);
// Output: the intial solution // Output: the intial solution
std::cout << "initial: " << solution << std::endl ; std::cout << "initial: " << solution << std::endl ;
// Apply the local search on the solution ! // Apply the local search on the solution !
hc(solution); hc(solution);
// Output: the final solution // Output: the final solution
std::cout << "final: " << solution << std::endl ; std::cout << "final: " << solution << std::endl ;
} }
@ -190,11 +190,11 @@ void main_function(int argc, char **argv)
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
try { try {
main_function(argc, argv); main_function(argc, argv);
} }
catch (exception& e) { catch (exception& e) {
cout << "Exception: " << e.what() << '\n'; cout << "Exception: " << e.what() << '\n';
} }
return 1; return 1;
} }

212
trunk/paradiseo-mo/tutorial/Lesson1/lesson1_randomBestHC.cpp
View file

@ -54,131 +54,131 @@ typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor wi
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void main_function(int argc, char **argv) void main_function(int argc, char **argv)
{ {
/* ========================================================= /* =========================================================
* *
* Parameters from parser * Parameters from parser
* *
* ========================================================= */ * ========================================================= */
// more information on the input parameters: see EO tutorial lesson 3 // 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. // 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 // First define a parser from the command-line arguments
eoParser parser(argc, argv); eoParser parser(argc, argv);
// For each parameter, define Parameter, read it through the parser, // For each parameter, define Parameter, read it through the parser,
// and assign the value to the variable // and assign the value to the variable
// random seed parameter // random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S'); eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam ); parser.processParam( seedParam );
unsigned seed = seedParam.value(); unsigned seed = seedParam.value();
// length of the bit string // length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V'); eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" ); parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value(); unsigned vecSize = vecSizeParam.value();
// the name of the "status" file where all actual parameter values will be saved // the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file"); eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" ); parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these // i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) { if (parser.userNeedsHelp()) {
parser.printHelp(cout); parser.printHelp(cout);
exit(1); exit(1);
} }
if (statusParam.value() != "") { if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str()); ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file os << parser;// and you can use that file as parameter file
} }
/* ========================================================= /* =========================================================
* *
* Random seed * Random seed
* *
* ========================================================= */ * ========================================================= */
// reproducible random seed: if you don't change SEED above, // reproducible random seed: if you don't change SEED above,
// you'll aways get the same result, NOT a random run // you'll aways get the same result, NOT a random run
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
rng.reseed(seed); rng.reseed(seed);
/* ========================================================= /* =========================================================
* *
* Initialization of the solution * Initialization of the solution
* *
* ========================================================= */ * ========================================================= */
// a Indi random initializer: each bit is random // a Indi random initializer: each bit is random
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
eoUniformGenerator<bool> uGen; eoUniformGenerator<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen); eoInitFixedLength<Indi> random(vecSize, uGen);
/* ========================================================= /* =========================================================
* *
* Eval fitness function (full evaluation) * Eval fitness function (full evaluation)
* *
* ========================================================= */ * ========================================================= */
// the fitness function is just the number of 1 in the bit string // the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEval; oneMaxEval<Indi> fullEval;
/* ========================================================= /* =========================================================
* *
* evaluation of a neighbor solution * evaluation of a neighbor solution
* *
* ========================================================= */ * ========================================================= */
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval); // moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Incremental evaluation of the neighbor: fitness is modified by +/- 1 // Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEval; moOneMaxIncrEval<Neighbor> neighborEval;
/* ========================================================= /* =========================================================
* *
* the neighborhood of a solution * the neighborhood of a solution
* *
* ========================================================= */ * ========================================================= */
// Exploration of the neighborhood in increasing order of the neigbor's index: // Exploration of the neighborhood in increasing order of the neigbor's index:
// bit-flip from bit 0 to bit (vecSize - 1) // bit-flip from bit 0 to bit (vecSize - 1)
moOrderNeighborhood<Neighbor> neighborhood(vecSize); moOrderNeighborhood<Neighbor> neighborhood(vecSize);
/* ========================================================= /* =========================================================
* *
* the local search algorithm * the local search algorithm
* *
* ========================================================= */ * ========================================================= */
moRandomBestHC<Neighbor> hc(neighborhood, fullEval, neighborEval); moRandomBestHC<Neighbor> hc(neighborhood, fullEval, neighborEval);
/* ========================================================= /* =========================================================
* *
* executes the local search from a random solution * executes the local search from a random solution
* *
* ========================================================= */ * ========================================================= */
// The current solution // The current solution
Indi solution; Indi solution;
// Apply random initialization // Apply random initialization
random(solution); random(solution);
// Evaluation of the initial solution: // Evaluation of the initial solution:
// can be evaluated here, or else it will be done at the beginning of the local search // can be evaluated here, or else it will be done at the beginning of the local search
fullEval(solution); fullEval(solution);
// Output: the intial solution // Output: the intial solution
std::cout << "initial: " << solution << std::endl ; std::cout << "initial: " << solution << std::endl ;
// Apply the local search on the solution ! // Apply the local search on the solution !
hc(solution); hc(solution);
// Output: the final solution // Output: the final solution
std::cout << "final: " << solution << std::endl ; std::cout << "final: " << solution << std::endl ;
} }
@ -186,11 +186,11 @@ void main_function(int argc, char **argv)
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
try { try {
main_function(argc, argv); main_function(argc, argv);
} }
catch (exception& e) { catch (exception& e) {
cout << "Exception: " << e.what() << '\n'; cout << "Exception: " << e.what() << '\n';
} }
return 1; return 1;
} }

212
trunk/paradiseo-mo/tutorial/Lesson1/lesson1_simpleHC.cpp
View file

@ -54,131 +54,131 @@ typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor wi
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
void main_function(int argc, char **argv) void main_function(int argc, char **argv)
{ {
/* ========================================================= /* =========================================================
* *
* Parameters from parser * Parameters from parser
* *
* ========================================================= */ * ========================================================= */
// more information on the input parameters: see EO tutorial lesson 3 // 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. // 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 // First define a parser from the command-line arguments
eoParser parser(argc, argv); eoParser parser(argc, argv);
// For each parameter, define Parameter, read it through the parser, // For each parameter, define Parameter, read it through the parser,
// and assign the value to the variable // and assign the value to the variable
// random seed parameter // random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S'); eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam ); parser.processParam( seedParam );
unsigned seed = seedParam.value(); unsigned seed = seedParam.value();
// length of the bit string // length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V'); eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" ); parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value(); unsigned vecSize = vecSizeParam.value();
// the name of the "status" file where all actual parameter values will be saved // the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file"); eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" ); parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these // i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) { if (parser.userNeedsHelp()) {
parser.printHelp(cout); parser.printHelp(cout);
exit(1); exit(1);
} }
if (statusParam.value() != "") { if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str()); ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file os << parser;// and you can use that file as parameter file
} }
/* ========================================================= /* =========================================================
* *
* Random seed * Random seed
* *
* ========================================================= */ * ========================================================= */
// reproducible random seed: if you don't change SEED above, // reproducible random seed: if you don't change SEED above,
// you'll aways get the same result, NOT a random run // you'll aways get the same result, NOT a random run
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
rng.reseed(seed); rng.reseed(seed);
/* ========================================================= /* =========================================================
* *
* Initialization of the solution * Initialization of the solution
* *
* ========================================================= */ * ========================================================= */
// a Indi random initializer: each bit is random // a Indi random initializer: each bit is random
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
eoUniformGenerator<bool> uGen; eoUniformGenerator<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen); eoInitFixedLength<Indi> random(vecSize, uGen);
/* ========================================================= /* =========================================================
* *
* Eval fitness function (full evaluation) * Eval fitness function (full evaluation)
* *
* ========================================================= */ * ========================================================= */
// the fitness function is just the number of 1 in the bit string // the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEval; oneMaxEval<Indi> fullEval;
/* ========================================================= /* =========================================================
* *
* evaluation of a neighbor solution * evaluation of a neighbor solution
* *
* ========================================================= */ * ========================================================= */
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval); // moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Incremental evaluation of the neighbor: fitness is modified by +/- 1 // Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEval; moOneMaxIncrEval<Neighbor> neighborEval;
/* ========================================================= /* =========================================================
* *
* the neighborhood of a solution * the neighborhood of a solution
* *
* ========================================================= */ * ========================================================= */
// Exploration of the neighborhood in increasing order of the neigbor's index: // Exploration of the neighborhood in increasing order of the neigbor's index:
// bit-flip from bit 0 to bit (vecSize - 1) // bit-flip from bit 0 to bit (vecSize - 1)
moOrderNeighborhood<Neighbor> neighborhood(vecSize); moOrderNeighborhood<Neighbor> neighborhood(vecSize);
/* ========================================================= /* =========================================================
* *
* the local search algorithm * the local search algorithm
* *
* ========================================================= */ * ========================================================= */
moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval); moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval);
/* ========================================================= /* =========================================================
* *
* executes the local search from a random solution * executes the local search from a random solution
* *
* ========================================================= */ * ========================================================= */
// The current solution // The current solution
Indi solution; Indi solution;
// Apply random initialization // Apply random initialization
random(solution); random(solution);
// Evaluation of the initial solution: // Evaluation of the initial solution:
// can be evaluated here, or else it will be done at the beginning of the local search // can be evaluated here, or else it will be done at the beginning of the local search
fullEval(solution); fullEval(solution);
// Output: the intial solution // Output: the intial solution
std::cout << "initial: " << solution << std::endl ; std::cout << "initial: " << solution << std::endl ;
// Apply the local search on the solution ! // Apply the local search on the solution !
hc(solution); hc(solution);
// Output: the final solution // Output: the final solution
std::cout << "final: " << solution << std::endl ; std::cout << "final: " << solution << std::endl ;
} }
@ -186,11 +186,11 @@ void main_function(int argc, char **argv)
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
try { try {
main_function(argc, argv); main_function(argc, argv);
} }
catch (exception& e) { catch (exception& e) {
cout << "Exception: " << e.what() << '\n'; cout << "Exception: " << e.what() << '\n';
} }
return 1; return 1;
} }

34
trunk/paradiseo-mo/tutorial/Lesson2/testNeighborhood.cpp
View file

@ -155,7 +155,7 @@ void main_function(int argc, char **argv)
fullEval(solution); fullEval(solution);
std::cout << "Initial Solution:" << std::endl; std::cout << "Initial Solution:" << std::endl;
std::cout << solution << std::endl << std::endl; std::cout << solution << std::endl << std::endl;
/* ========================================================= /* =========================================================
@ -168,14 +168,14 @@ void main_function(int argc, char **argv)
std::cout << "-----------------" << std::endl; std::cout << "-----------------" << std::endl;
std::cout << "Neighbors List: (Neighbor -> fitness)" << std::endl; std::cout << "Neighbors List: (Neighbor -> fitness)" << std::endl;
swapNeighbor n1; swapNeighbor n1;
swapNH.init(solution, n1); swapNH.init(solution, n1);
swapEval(solution,n1); swapEval(solution,n1);
n1.print(); n1.print();
while(swapNH.cont(solution)){ while (swapNH.cont(solution)) {
swapNH.next(solution, n1); swapNH.next(solution, n1);
swapEval(solution,n1); swapEval(solution,n1);
n1.print(); n1.print();
} }
/* ========================================================= /* =========================================================
@ -188,28 +188,28 @@ void main_function(int argc, char **argv)
std::cout << "------------------------" << std::endl; std::cout << "------------------------" << std::endl;
std::cout << "Neighbors List: (key: Neighbor -> fitness)" << std::endl; std::cout << "Neighbors List: (key: Neighbor -> fitness)" << std::endl;
shiftNeighbor n2; shiftNeighbor n2;
orderShiftNH.init(solution, n2); orderShiftNH.init(solution, n2);
shiftEval(solution,n2); shiftEval(solution,n2);
n2.print(); n2.print();
while(orderShiftNH.cont(solution)){ while (orderShiftNH.cont(solution)) {
orderShiftNH.next(solution, n2); orderShiftNH.next(solution, n2);
shiftEval(solution,n2); shiftEval(solution,n2);
n2.print(); n2.print();
} }
std::cout << "\nSHIFT RANDOM WITHOUT REPLACEMENT NEIGHBORHOOD" << std::endl; std::cout << "\nSHIFT RANDOM WITHOUT REPLACEMENT NEIGHBORHOOD" << std::endl;
std::cout << "---------------------------------------------" << std::endl; std::cout << "---------------------------------------------" << std::endl;
std::cout << "Neighbors List: (key: Neighbor -> fitness)" << std::endl; std::cout << "Neighbors List: (key: Neighbor -> fitness)" << std::endl;
rndNoReplShiftNH.init(solution, n2); rndNoReplShiftNH.init(solution, n2);
shiftEval(solution,n2); shiftEval(solution,n2);
n2.print(); n2.print();
while(rndNoReplShiftNH.cont(solution)){ while (rndNoReplShiftNH.cont(solution)) {
rndNoReplShiftNH.next(solution, n2); rndNoReplShiftNH.next(solution, n2);
shiftEval(solution,n2); shiftEval(solution,n2);
n2.print(); n2.print();
} }
std::cout << "\nSHIFT RANDOM WITH REPLACEMENT NEIGHBORHOOD" << std::endl; std::cout << "\nSHIFT RANDOM WITH REPLACEMENT NEIGHBORHOOD" << std::endl;
@ -219,10 +219,10 @@ void main_function(int argc, char **argv)
rndReplShiftNH.init(solution, n2); rndReplShiftNH.init(solution, n2);
shiftEval(solution,n2); shiftEval(solution,n2);
n2.print(); n2.print();
for(unsigned int i=0; i<100; i++){ for (unsigned int i=0; i<100; i++) {
rndReplShiftNH.next(solution, n2); rndReplShiftNH.next(solution, n2);
shiftEval(solution,n2); shiftEval(solution,n2);
n2.print(); n2.print();
} }
} }

2
trunk/paradiseo-mo/tutorial/Lesson4/testSimpleTS.cpp
View file

@ -65,7 +65,7 @@ void main_function(int argc, char **argv)
// For each parameter, define Parameter, read it through the parser, // For each parameter, define Parameter, read it through the parser,
// and assign the value to the variable // and assign the value to the variable
// seed // seed
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S'); eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam ); parser.processParam( seedParam );
unsigned seed = seedParam.value(); unsigned seed = seedParam.value();

226
trunk/paradiseo-mo/tutorial/Lesson6/adaptiveWalks.cpp
View file

@ -52,147 +52,147 @@ typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor wi
void main_function(int argc, char **argv) void main_function(int argc, char **argv)
{ {
/* ========================================================= /* =========================================================
* *
* Parameters * Parameters
* *
* ========================================================= */ * ========================================================= */
// more information on the input parameters: see EO tutorial lesson 3 // 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. // 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 // First define a parser from the command-line arguments
eoParser parser(argc, argv); eoParser parser(argc, argv);
// For each parameter, define Parameter, read it through the parser, // For each parameter, define Parameter, read it through the parser,
// and assign the value to the variable // and assign the value to the variable
// random seed parameter // random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S'); eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam ); parser.processParam( seedParam );
unsigned seed = seedParam.value(); unsigned seed = seedParam.value();
// length of the bit string // length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V'); eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" ); parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value(); unsigned vecSize = vecSizeParam.value();
// the number of adaptive walks // the number of adaptive walks
eoValueParam<unsigned int> solParam(100, "nbSol", "Number of adaptive walks", 'n'); eoValueParam<unsigned int> solParam(100, "nbSol", "Number of adaptive walks", 'n');
parser.processParam( solParam, "Representation" ); parser.processParam( solParam, "Representation" );
unsigned nbSol = solParam.value(); unsigned nbSol = solParam.value();
// the name of the output file // the name of the output file
string str_out = "out.dat"; // default value string str_out = "out.dat"; // default value
eoValueParam<string> outParam(str_out.c_str(), "out", "Output file of the sampling", 'o'); eoValueParam<string> outParam(str_out.c_str(), "out", "Output file of the sampling", 'o');
parser.processParam(outParam, "Persistence" ); parser.processParam(outParam, "Persistence" );
// the name of the "status" file where all actual parameter values will be saved // the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file"); eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" ); parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these // i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) { if (parser.userNeedsHelp()) {
parser.printHelp(cout); parser.printHelp(cout);
exit(1); exit(1);
} }
if (statusParam.value() != "") { if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str()); ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file os << parser;// and you can use that file as parameter file
} }
/* ========================================================= /* =========================================================
* *
* Random seed * Random seed
* *
* ========================================================= */ * ========================================================= */
// reproducible random seed: if you don't change SEED above, // reproducible random seed: if you don't change SEED above,
// you'll aways get the same result, NOT a random run // you'll aways get the same result, NOT a random run
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
rng.reseed(seed); rng.reseed(seed);
/* ========================================================= /* =========================================================
* *
* Initialization of the solution * Initialization of the solution
* *
* ========================================================= */ * ========================================================= */
// a Indi random initializer: each bit is random // a Indi random initializer: each bit is random
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
eoUniformGenerator<bool> uGen; eoUniformGenerator<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen); eoInitFixedLength<Indi> random(vecSize, uGen);
/* ========================================================= /* =========================================================
* *
* Eval fitness function (full evaluation) * Eval fitness function (full evaluation)
* *
* ========================================================= */ * ========================================================= */
// the fitness function is just the number of 1 in the bit string // the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEval; oneMaxEval<Indi> fullEval;
/* ========================================================= /* =========================================================
* *
* evaluation of a neighbor solution * evaluation of a neighbor solution
* *
* ========================================================= */ * ========================================================= */
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval); // moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Incremental evaluation of the neighbor: fitness is modified by +/- 1 // Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEval; moOneMaxIncrEval<Neighbor> neighborEval;
/* ========================================================= /* =========================================================
* *
* the neighborhood of a solution * the neighborhood of a solution
* *
* ========================================================= */ * ========================================================= */
// Exploration of the neighborhood in order // Exploration of the neighborhood in order
// from bit 0 to bit vecSize-1 // from bit 0 to bit vecSize-1
moOrderNeighborhood<Neighbor> neighborhood(vecSize); moOrderNeighborhood<Neighbor> neighborhood(vecSize);
/* ========================================================= /* =========================================================
* *
* The sampling of the search space * The sampling of the search space
* *
* ========================================================= */ * ========================================================= */
// sampling object : // sampling object :
// - random initialization // - random initialization
// - local search to sample the search space // - local search to sample the search space
// - one statistic to compute // - one statistic to compute
moHillClimberSampling<Neighbor> sampling(random, neighborhood, fullEval, neighborEval, nbSol); moHillClimberSampling<Neighbor> sampling(random, neighborhood, fullEval, neighborEval, nbSol);
/* ========================================================= /* =========================================================
* *
* execute the sampling * execute the sampling
* *
* ========================================================= */ * ========================================================= */
sampling(); sampling();
/* ========================================================= /* =========================================================
* *
* export the sampling * export the sampling
* *
* ========================================================= */ * ========================================================= */
// to export the statistics into file // to export the statistics into file
sampling.fileExport(str_out); sampling.fileExport(str_out);
// to get the values of statistics // to get the values of statistics
// so, you can compute some statistics in c++ from the data // so, you can compute some statistics in c++ from the data
const std::vector<double> & lengthValues = sampling.getValues(0); const std::vector<double> & lengthValues = sampling.getValues(0);
std::cout << "First values:" << std::endl; std::cout << "First values:" << std::endl;
std::cout << "Length " << lengthValues[0] << std::endl; std::cout << "Length " << lengthValues[0] << std::endl;
std::cout << "Last values:" << std::endl; std::cout << "Last values:" << std::endl;
std::cout << "Length " << lengthValues[lengthValues.size() - 1] << std::endl; std::cout << "Length " << lengthValues[lengthValues.size() - 1] << std::endl;
} }

242
trunk/paradiseo-mo/tutorial/Lesson6/autocorrelation.cpp
View file

@ -56,159 +56,159 @@ typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor wi
void main_function(int argc, char **argv) void main_function(int argc, char **argv)
{ {
/* ========================================================= /* =========================================================
* *
* Parameters * Parameters
* *
* ========================================================= */ * ========================================================= */
// more information on the input parameters: see EO tutorial lesson 3 // 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. // 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 // First define a parser from the command-line arguments
eoParser parser(argc, argv); eoParser parser(argc, argv);
// For each parameter, define Parameter, read it through the parser, // For each parameter, define Parameter, read it through the parser,
// and assign the value to the variable // and assign the value to the variable
// random seed parameter // random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S'); eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam ); parser.processParam( seedParam );
unsigned seed = seedParam.value(); unsigned seed = seedParam.value();
// length of the bit string // length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V'); eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" ); parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value(); unsigned vecSize = vecSizeParam.value();
// the number of steps of the random walk // the number of steps of the random walk
eoValueParam<unsigned int> stepParam(100, "nbStep", "Number of steps of the random walk", 'n'); eoValueParam<unsigned int> stepParam(100, "nbStep", "Number of steps of the random walk", 'n');
parser.processParam( stepParam, "Representation" ); parser.processParam( stepParam, "Representation" );
unsigned nbStep = stepParam.value(); unsigned nbStep = stepParam.value();
// the name of the output file // the name of the output file
string str_out = "out.dat"; // default value string str_out = "out.dat"; // default value
eoValueParam<string> outParam(str_out.c_str(), "out", "Output file of the sampling", 'o'); eoValueParam<string> outParam(str_out.c_str(), "out", "Output file of the sampling", 'o');
parser.processParam(outParam, "Persistence" ); parser.processParam(outParam, "Persistence" );
// the name of the "status" file where all actual parameter values will be saved // the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file"); eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" ); parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these // i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) { if (parser.userNeedsHelp()) {
parser.printHelp(cout); parser.printHelp(cout);
exit(1); exit(1);
} }
if (statusParam.value() != "") { if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str()); ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file os << parser;// and you can use that file as parameter file
} }
/* ========================================================= /* =========================================================
* *
* Random seed * Random seed
* *
* ========================================================= */ * ========================================================= */
// reproducible random seed: if you don't change SEED above, // reproducible random seed: if you don't change SEED above,
// you'll aways get the same result, NOT a random run // you'll aways get the same result, NOT a random run
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
rng.reseed(seed); rng.reseed(seed);
/* ========================================================= /* =========================================================
* *
* Initialization of the solution * Initialization of the solution
* *
* ========================================================= */ * ========================================================= */
// a Indi random initializer: each bit is random // a Indi random initializer: each bit is random
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
eoUniformGenerator<bool> uGen; eoUniformGenerator<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen); eoInitFixedLength<Indi> random(vecSize, uGen);
/* ========================================================= /* =========================================================
* *
* Eval fitness function (full evaluation) * Eval fitness function (full evaluation)
* *
* ========================================================= */ * ========================================================= */
// the fitness function is just the number of 1 in the bit string // the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEval; oneMaxEval<Indi> fullEval;
/* ========================================================= /* =========================================================
* *
* evaluation of a neighbor solution * evaluation of a neighbor solution
* *
* ========================================================= */ * ========================================================= */
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval); // moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Incremental evaluation of the neighbor: fitness is modified by +/- 1 // Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEval; moOneMaxIncrEval<Neighbor> neighborEval;
/* ========================================================= /* =========================================================
* *
* the neighborhood of a solution * the neighborhood of a solution
* *
* ========================================================= */ * ========================================================= */
// Exploration of the neighborhood in random order // Exploration of the neighborhood in random order
// at each step one bit is randomly generated // at each step one bit is randomly generated
moRndWithReplNeighborhood<Neighbor> neighborhood(vecSize); moRndWithReplNeighborhood<Neighbor> neighborhood(vecSize);
/* ========================================================= /* =========================================================
* *
* The sampling of the search space * The sampling of the search space
* *
* ========================================================= */ * ========================================================= */
// sampling object : // sampling object :
// - random initialization // - random initialization
// - neighborhood to compute the next step // - neighborhood to compute the next step
// - fitness function // - fitness function
// - neighbor evaluation // - neighbor evaluation
// - number of steps of the walk // - number of steps of the walk
moAutocorrelationSampling<Neighbor> sampling(random, neighborhood, fullEval, neighborEval, nbStep); moAutocorrelationSampling<Neighbor> sampling(random, neighborhood, fullEval, neighborEval, nbStep);
/* ========================================================= /* =========================================================
* *
* execute the sampling * execute the sampling
* *
* ========================================================= */ * ========================================================= */
sampling(); sampling();
/* ========================================================= /* =========================================================
* *
* export the sampling * export the sampling
* *
* ========================================================= */ * ========================================================= */
// to export the statistics into file // to export the statistics into file
sampling.fileExport(str_out); sampling.fileExport(str_out);
// to get the values of statistics // to get the values of statistics
// so, you can compute some statistics in c++ from the data // so, you can compute some statistics in c++ from the data
const std::vector<double> & fitnessValues = sampling.getValues(0); const std::vector<double> & fitnessValues = sampling.getValues(0);
std::cout << "First values:" << std::endl; std::cout << "First values:" << std::endl;
std::cout << "Fitness " << fitnessValues[0] << std::endl; std::cout << "Fitness " << fitnessValues[0] << std::endl;
std::cout << "Last values:" << std::endl; std::cout << "Last values:" << std::endl;
std::cout << "Fitness " << fitnessValues[fitnessValues.size() - 1] << std::endl; std::cout << "Fitness " << fitnessValues[fitnessValues.size() - 1] << std::endl;
// more basic statistics on the distribution: // more basic statistics on the distribution:
moStatistics statistics; moStatistics statistics;
vector<double> rho, phi; vector<double> rho, phi;
statistics.autocorrelation(fitnessValues, 10, rho, phi); statistics.autocorrelation(fitnessValues, 10, rho, phi);
for(unsigned s = 0; s < rho.size(); s++) for (unsigned s = 0; s < rho.size(); s++)
std::cout << s << " " << "rho=" << rho[s] << ", phi=" << phi[s] << std::endl; std::cout << s << " " << "rho=" << rho[s] << ", phi=" << phi[s] << std::endl;
} }
// A main that catches the exceptions // A main that catches the exceptions

202
trunk/paradiseo-mo/tutorial/Lesson6/densityOfStates.cpp
View file

@ -50,133 +50,133 @@ typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor wi
void main_function(int argc, char **argv) void main_function(int argc, char **argv)
{ {
/* ========================================================= /* =========================================================
* *
* Parameters * Parameters
* *
* ========================================================= */ * ========================================================= */
// more information on the input parameters: see EO tutorial lesson 3 // 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. // 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 // First define a parser from the command-line arguments
eoParser parser(argc, argv); eoParser parser(argc, argv);
// For each parameter, define Parameter, read it through the parser, // For each parameter, define Parameter, read it through the parser,
// and assign the value to the variable // and assign the value to the variable
// random seed parameter // random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S'); eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam ); parser.processParam( seedParam );
unsigned seed = seedParam.value(); unsigned seed = seedParam.value();
// length of the bit string // length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V'); eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" ); parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value(); unsigned vecSize = vecSizeParam.value();
// the number of solution sampled // the number of solution sampled
eoValueParam<unsigned int> solParam(100, "nbSol", "Number of random solution", 'n'); eoValueParam<unsigned int> solParam(100, "nbSol", "Number of random solution", 'n');
parser.processParam( solParam, "Representation" ); parser.processParam( solParam, "Representation" );
unsigned nbSol = solParam.value(); unsigned nbSol = solParam.value();
// the name of the output file // the name of the output file
string str_out = "out.dat"; // default value string str_out = "out.dat"; // default value
eoValueParam<string> outParam(str_out.c_str(), "out", "Output file of the sampling", 'o'); eoValueParam<string> outParam(str_out.c_str(), "out", "Output file of the sampling", 'o');
parser.processParam(outParam, "Persistence" ); parser.processParam(outParam, "Persistence" );
// the name of the "status" file where all actual parameter values will be saved // the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file"); eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" ); parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these // i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) { if (parser.userNeedsHelp()) {
parser.printHelp(cout); parser.printHelp(cout);
exit(1); exit(1);
} }
if (statusParam.value() != "") { if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str()); ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file os << parser;// and you can use that file as parameter file
} }
/* ========================================================= /* =========================================================
* *
* Random seed * Random seed
* *
* ========================================================= */ * ========================================================= */
// reproducible random seed: if you don't change SEED above, // reproducible random seed: if you don't change SEED above,
// you'll aways get the same result, NOT a random run // you'll aways get the same result, NOT a random run
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
rng.reseed(seed); rng.reseed(seed);
/* ========================================================= /* =========================================================
* *
* Initialization of the solution * Initialization of the solution
* *
* ========================================================= */ * ========================================================= */
// a Indi random initializer: each bit is random // a Indi random initializer: each bit is random
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
eoUniformGenerator<bool> uGen; eoUniformGenerator<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen); eoInitFixedLength<Indi> random(vecSize, uGen);
/* ========================================================= /* =========================================================
* *
* Eval fitness function (full evaluation) * Eval fitness function (full evaluation)
* *
* ========================================================= */ * ========================================================= */
// the fitness function is just the number of 1 in the bit string // the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEval; oneMaxEval<Indi> fullEval;
/* ========================================================= /* =========================================================
* *
* The sampling of the search space * The sampling of the search space
* *
* ========================================================= */ * ========================================================= */
// sampling object : // sampling object :
// - random initialization // - random initialization
// - fitness function // - fitness function
// - number of solutions to sample // - number of solutions to sample
moDensityOfStatesSampling<Neighbor> sampling(random, fullEval, nbSol); moDensityOfStatesSampling<Neighbor> sampling(random, fullEval, nbSol);
/* ========================================================= /* =========================================================
* *
* execute the sampling * execute the sampling
* *
* ========================================================= */ * ========================================================= */
sampling(); sampling();
/* ========================================================= /* =========================================================
* *
* export the sampling * export the sampling
* *
* ========================================================= */ * ========================================================= */
// to export the statistics into file // to export the statistics into file
sampling.fileExport(str_out); sampling.fileExport(str_out);
// to get the values of statistics // to get the values of statistics
// so, you can compute some statistics in c++ from the data // so, you can compute some statistics in c++ from the data
const std::vector<double> & fitnessValues = sampling.getValues(0); const std::vector<double> & fitnessValues = sampling.getValues(0);
std::cout << "First values:" << std::endl; std::cout << "First values:" << std::endl;
std::cout << "Fitness " << fitnessValues[0] << std::endl; std::cout << "Fitness " << fitnessValues[0] << std::endl;
std::cout << "Last values:" << std::endl; std::cout << "Last values:" << std::endl;
std::cout << "Fitness " << fitnessValues[fitnessValues.size() - 1] << std::endl; std::cout << "Fitness " << fitnessValues[fitnessValues.size() - 1] << std::endl;
// more basic statistics on the distribution: // more basic statistics on the distribution:
double min, max, avg, std; double min, max, avg, std;
moStatistics statistics; moStatistics statistics;
statistics.basic(fitnessValues, min, max, avg, std); statistics.basic(fitnessValues, min, max, avg, std);
std::cout << "min=" << min << ", max=" << max << ", average=" << avg << ", std dev=" << std << std::endl; std::cout << "min=" << min << ", max=" << max << ", average=" << avg << ", std dev=" << std << std::endl;
} }
// A main that catches the exceptions // A main that catches the exceptions

204
trunk/paradiseo-mo/tutorial/Lesson6/fdc.cpp
View file

@ -50,132 +50,132 @@ typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor wi
void main_function(int argc, char **argv) void main_function(int argc, char **argv)
{ {
/* ========================================================= /* =========================================================
* *
* Parameters * Parameters
* *
* ========================================================= */ * ========================================================= */
// more information on the input parameters: see EO tutorial lesson 3 // 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. // 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 // First define a parser from the command-line arguments
eoParser parser(argc, argv); eoParser parser(argc, argv);
// For each parameter, define Parameter, read it through the parser, // For each parameter, define Parameter, read it through the parser,
// and assign the value to the variable // and assign the value to the variable
// random seed parameter // random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S'); eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam ); parser.processParam( seedParam );
unsigned seed = seedParam.value(); unsigned seed = seedParam.value();
// length of the bit string // length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V'); eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" ); parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value(); unsigned vecSize = vecSizeParam.value();
// the number of solution sampled // the number of solution sampled
eoValueParam<unsigned int> solParam(100, "nbSol", "Number of random solution", 'n'); eoValueParam<unsigned int> solParam(100, "nbSol", "Number of random solution", 'n');
parser.processParam( solParam, "Representation" ); parser.processParam( solParam, "Representation" );
unsigned nbSol = solParam.value(); unsigned nbSol = solParam.value();
// the name of the output file // the name of the output file
string str_out = "out.dat"; // default value string str_out = "out.dat"; // default value
eoValueParam<string> outParam(str_out.c_str(), "out", "Output file of the sampling", 'o'); eoValueParam<string> outParam(str_out.c_str(), "out", "Output file of the sampling", 'o');
parser.processParam(outParam, "Persistence" ); parser.processParam(outParam, "Persistence" );
// the name of the "status" file where all actual parameter values will be saved // the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file"); eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" ); parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these // i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) { if (parser.userNeedsHelp()) {
parser.printHelp(cout); parser.printHelp(cout);
exit(1); exit(1);
} }
if (statusParam.value() != "") { if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str()); ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file os << parser;// and you can use that file as parameter file
} }
/* ========================================================= /* =========================================================
* *
* Random seed * Random seed
* *
* ========================================================= */ * ========================================================= */
// reproducible random seed: if you don't change SEED above, // reproducible random seed: if you don't change SEED above,
// you'll aways get the same result, NOT a random run // you'll aways get the same result, NOT a random run
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
rng.reseed(seed); rng.reseed(seed);
/* ========================================================= /* =========================================================
* *
* Initialization of the solution * Initialization of the solution
* *
* ========================================================= */ * ========================================================= */
// a Indi random initializer: each bit is random // a Indi random initializer: each bit is random
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
eoUniformGenerator<bool> uGen; eoUniformGenerator<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen); eoInitFixedLength<Indi> random(vecSize, uGen);
/* ========================================================= /* =========================================================
* *
* Eval fitness function (full evaluation) * Eval fitness function (full evaluation)
* *
* ========================================================= */ * ========================================================= */
// the fitness function is just the number of 1 in the bit string // the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEval; oneMaxEval<Indi> fullEval;
/* ========================================================= /* =========================================================
* *
* The sampling of the search space * The sampling of the search space
* *
* ========================================================= */ * ========================================================= */
// Hamming distance to the global optimum // Hamming distance to the global optimum
eoHammingDistance<Indi> distance; // Hamming distance eoHammingDistance<Indi> distance; // Hamming distance
Indi bestSolution(vecSize, true); // global optimum Indi bestSolution(vecSize, true); // global optimum
// sampling object : // sampling object :
// - random initialization // - random initialization
// - fitness function // - fitness function
// - number of solutions to sample // - number of solutions to sample
moFDCsampling<Neighbor> sampling(random, fullEval, distance, bestSolution, nbSol); moFDCsampling<Neighbor> sampling(random, fullEval, distance, bestSolution, nbSol);
/* ========================================================= /* =========================================================
* *
* execute the sampling * execute the sampling
* *
* ========================================================= */ * ========================================================= */
sampling(); sampling();
/* ========================================================= /* =========================================================
* *
* export the sampling * export the sampling
* *
* ========================================================= */ * ========================================================= */
// to export the statistics into file // to export the statistics into file
sampling.fileExport(str_out); sampling.fileExport(str_out);
// to get the values of statistics // to get the values of statistics
// so, you can compute some statistics in c++ from the data // so, you can compute some statistics in c++ from the data
const std::vector<double> & fitnessValues = sampling.getValues(0); const std::vector<double> & fitnessValues = sampling.getValues(0);
const std::vector<double> & distValues = sampling.getValues(1); const std::vector<double> & distValues = sampling.getValues(1);
std::cout << "First values:" << std::endl; std::cout << "First values:" << std::endl;
std::cout << "Fitness " << fitnessValues[0] << std::endl; std::cout << "Fitness " << fitnessValues[0] << std::endl;
std::cout << "Distance " << distValues[0] << std::endl; std::cout << "Distance " << distValues[0] << std::endl;
std::cout << "Last values:" << std::endl; std::cout << "Last values:" << std::endl;
std::cout << "Fitness " << fitnessValues[fitnessValues.size() - 1] << std::endl; std::cout << "Fitness " << fitnessValues[fitnessValues.size() - 1] << std::endl;
std::cout << "Distance " << distValues[distValues.size() - 1] << std::endl; std::cout << "Distance " << distValues[distValues.size() - 1] << std::endl;
} }
// A main that catches the exceptions // A main that catches the exceptions

238
trunk/paradiseo-mo/tutorial/Lesson6/fitnessCloud.cpp
View file

@ -54,153 +54,153 @@ typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor wi
void main_function(int argc, char **argv) void main_function(int argc, char **argv)
{ {
/* ========================================================= /* =========================================================
* *
* Parameters * Parameters
* *
* ========================================================= */ * ========================================================= */
// more information on the input parameters: see EO tutorial lesson 3 // 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. // 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 // First define a parser from the command-line arguments
eoParser parser(argc, argv); eoParser parser(argc, argv);
// For each parameter, define Parameter, read it through the parser, // For each parameter, define Parameter, read it through the parser,
// and assign the value to the variable // and assign the value to the variable
// random seed parameter // random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S'); eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam ); parser.processParam( seedParam );
unsigned seed = seedParam.value(); unsigned seed = seedParam.value();
// length of the bit string // length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V'); eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" ); parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value(); unsigned vecSize = vecSizeParam.value();
// the number of solution sampled // the number of solution sampled
eoValueParam<unsigned int> solParam(100, "nbSol", "Number of random solution", 'n'); eoValueParam<unsigned int> solParam(100, "nbSol", "Number of random solution", 'n');
parser.processParam( solParam, "Representation" ); parser.processParam( solParam, "Representation" );
unsigned nbSol = solParam.value(); unsigned nbSol = solParam.value();
// the name of the output file // the name of the output file
string str_out = "out.dat"; // default value string str_out = "out.dat"; // default value
eoValueParam<string> outParam(str_out.c_str(), "out", "Output file of the sampling", 'o'); eoValueParam<string> outParam(str_out.c_str(), "out", "Output file of the sampling", 'o');
parser.processParam(outParam, "Persistence" ); parser.processParam(outParam, "Persistence" );
// the name of the "status" file where all actual parameter values will be saved // the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file"); eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" ); parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these // i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) { if (parser.userNeedsHelp()) {
parser.printHelp(cout); parser.printHelp(cout);
exit(1); exit(1);
} }
if (statusParam.value() != "") { if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str()); ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file os << parser;// and you can use that file as parameter file
} }
/* ========================================================= /* =========================================================
* *
* Random seed * Random seed
* *
* ========================================================= */ * ========================================================= */
// reproducible random seed: if you don't change SEED above, // reproducible random seed: if you don't change SEED above,
// you'll aways get the same result, NOT a random run // you'll aways get the same result, NOT a random run
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
rng.reseed(seed); rng.reseed(seed);
/* ========================================================= /* =========================================================
* *
* Initialization of the solution * Initialization of the solution
* *
* ========================================================= */ * ========================================================= */
// a Indi random initializer: each bit is random // a Indi random initializer: each bit is random
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
eoUniformGenerator<bool> uGen; eoUniformGenerator<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen); eoInitFixedLength<Indi> random(vecSize, uGen);
/* ========================================================= /* =========================================================
* *
* Eval fitness function (full evaluation) * Eval fitness function (full evaluation)
* *
* ========================================================= */ * ========================================================= */
// the fitness function is just the number of 1 in the bit string // the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEval; oneMaxEval<Indi> fullEval;
/* ========================================================= /* =========================================================
* *
* evaluation of a neighbor solution * evaluation of a neighbor solution
* *
* ========================================================= */ * ========================================================= */
// Incremental evaluation of the neighbor: fitness is modified by +/- 1 // Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEval; moOneMaxIncrEval<Neighbor> neighborEval;
/* ========================================================= /* =========================================================
* *
* the neighborhood of a solution * the neighborhood of a solution
* *
* ========================================================= */ * ========================================================= */
// Exploration of the neighborhood in random order // Exploration of the neighborhood in random order
// at each step one bit is randomly generated // at each step one bit is randomly generated
moRndWithoutReplNeighborhood<Neighbor> neighborhood(vecSize); moRndWithoutReplNeighborhood<Neighbor> neighborhood(vecSize);
/* ========================================================= /* =========================================================
* *
* The sampling of the search space * The sampling of the search space
* *
* ========================================================= */ * ========================================================= */
// sampling object : // sampling object :
// - random initialization // - random initialization
// - neighborhood to compute one random neighbor // - neighborhood to compute one random neighbor
// - fitness function // - fitness function
// - neighbor evaluation // - neighbor evaluation
// - number of solutions to sample // - number of solutions to sample
// moRndRndFitnessCloudSampling<Neighbor> sampling(random, neighborhood, fullEval, neighborEval, nbSol); // moRndRndFitnessCloudSampling<Neighbor> sampling(random, neighborhood, fullEval, neighborEval, nbSol);
// moMHRndFitnessCloudSampling<Neighbor> sampling(random, neighborhood, fullEval, neighborEval, nbSol); // moMHRndFitnessCloudSampling<Neighbor> sampling(random, neighborhood, fullEval, neighborEval, nbSol);
// moRndBestFitnessCloudSampling<Neighbor> sampling(random, neighborhood, fullEval, neighborEval, nbSol); // moRndBestFitnessCloudSampling<Neighbor> sampling(random, neighborhood, fullEval, neighborEval, nbSol);
moMHBestFitnessCloudSampling<Neighbor> sampling(random, neighborhood, fullEval, neighborEval, nbSol); moMHBestFitnessCloudSampling<Neighbor> sampling(random, neighborhood, fullEval, neighborEval, nbSol);
/* ========================================================= /* =========================================================
* *
* execute the sampling * execute the sampling
* *
* ========================================================= */ * ========================================================= */
sampling(); sampling();
/* ========================================================= /* =========================================================
* *
* export the sampling * export the sampling
* *
* ========================================================= */ * ========================================================= */
// to export the statistics into file // to export the statistics into file
sampling.fileExport(str_out); sampling.fileExport(str_out);
// to get the values of statistics // to get the values of statistics
// so, you can compute some statistics in c++ from the data // so, you can compute some statistics in c++ from the data
const std::vector<double> & fitnessValues = sampling.getValues(0); const std::vector<double> & fitnessValues = sampling.getValues(0);
const std::vector<double> & neighborFitnessValues = sampling.getValues(1); const std::vector<double> & neighborFitnessValues = sampling.getValues(1);
std::cout << "First values:" << std::endl; std::cout << "First values:" << std::endl;
std::cout << "Fitness " << fitnessValues[0] << std::endl; std::cout << "Fitness " << fitnessValues[0] << std::endl;
std::cout << "Neighbor Fitness " << neighborFitnessValues[0] << std::endl; std::cout << "Neighbor Fitness " << neighborFitnessValues[0] << std::endl;
std::cout << "Last values:" << std::endl; std::cout << "Last values:" << std::endl;
std::cout << "Fitness " << fitnessValues[fitnessValues.size() - 1] << std::endl; std::cout << "Fitness " << fitnessValues[fitnessValues.size() - 1] << std::endl;
std::cout << "Neighbor Fitness " << neighborFitnessValues[neighborFitnessValues.size() - 1] << std::endl; std::cout << "Neighbor Fitness " << neighborFitnessValues[neighborFitnessValues.size() - 1] << std::endl;
} }
// A main that catches the exceptions // A main that catches the exceptions

240
trunk/paradiseo-mo/tutorial/Lesson6/neutralDegree.cpp
View file

@ -51,154 +51,154 @@ typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor wi
void main_function(int argc, char **argv) void main_function(int argc, char **argv)
{ {
/* ========================================================= /* =========================================================
* *
* Parameters * Parameters
* *
* ========================================================= */ * ========================================================= */
// more information on the input parameters: see EO tutorial lesson 3 // 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. // 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 // First define a parser from the command-line arguments
eoParser parser(argc, argv); eoParser parser(argc, argv);
// For each parameter, define Parameter, read it through the parser, // For each parameter, define Parameter, read it through the parser,
// and assign the value to the variable // and assign the value to the variable
// random seed parameter // random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S'); eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam ); parser.processParam( seedParam );
unsigned seed = seedParam.value(); unsigned seed = seedParam.value();
// length of the bit string // length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V'); eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" ); parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value(); unsigned vecSize = vecSizeParam.value();
// size of the block // size of the block
eoValueParam<unsigned int> blockSizeParam(4, "blockSize", "Block size of the Royal Road", 'k'); eoValueParam<unsigned int> blockSizeParam(4, "blockSize", "Block size of the Royal Road", 'k');
parser.processParam( blockSizeParam, "Representation" ); parser.processParam( blockSizeParam, "Representation" );
unsigned blockSize = blockSizeParam.value(); unsigned blockSize = blockSizeParam.value();
// the number of solution sampled // the number of solution sampled
eoValueParam<unsigned int> solParam(100, "nbSol", "Number of random solution", 'n'); eoValueParam<unsigned int> solParam(100, "nbSol", "Number of random solution", 'n');
parser.processParam( solParam, "Representation" ); parser.processParam( solParam, "Representation" );
unsigned nbSol = solParam.value(); unsigned nbSol = solParam.value();
// the name of the output file // the name of the output file
string str_out = "out.dat"; // default value string str_out = "out.dat"; // default value
eoValueParam<string> outParam(str_out.c_str(), "out", "Output file of the sampling", 'o'); eoValueParam<string> outParam(str_out.c_str(), "out", "Output file of the sampling", 'o');
parser.processParam(outParam, "Persistence" ); parser.processParam(outParam, "Persistence" );
// the name of the "status" file where all actual parameter values will be saved // the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file"); eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" ); parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these // i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) { if (parser.userNeedsHelp()) {
parser.printHelp(cout); parser.printHelp(cout);
exit(1); exit(1);
} }
if (statusParam.value() != "") { if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str()); ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file os << parser;// and you can use that file as parameter file
} }
/* ========================================================= /* =========================================================
* *
* Random seed * Random seed
* *
* ========================================================= */ * ========================================================= */
// reproducible random seed: if you don't change SEED above, // reproducible random seed: if you don't change SEED above,
// you'll aways get the same result, NOT a random run // you'll aways get the same result, NOT a random run
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
rng.reseed(seed); rng.reseed(seed);
/* ========================================================= /* =========================================================
* *
* Initialization of the solution * Initialization of the solution
* *
* ========================================================= */ * ========================================================= */
// a Indi random initializer: each bit is random // a Indi random initializer: each bit is random
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
eoUniformGenerator<bool> uGen; eoUniformGenerator<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen); eoInitFixedLength<Indi> random(vecSize, uGen);
/* ========================================================= /* =========================================================
* *
* Eval fitness function (full evaluation) * Eval fitness function (full evaluation)
* *
* ========================================================= */ * ========================================================= */
// the fitness function is the royal function (oneMax is a Royal Road with block of 1) // the fitness function is the royal function (oneMax is a Royal Road with block of 1)
RoyalRoadEval<Indi> fullEval(blockSize); RoyalRoadEval<Indi> fullEval(blockSize);
/* ========================================================= /* =========================================================
* *
* evaluation of a neighbor solution * evaluation of a neighbor solution
* *
* ========================================================= */ * ========================================================= */
// Incremental evaluation of the neighbor: fitness is modified by +1 , 0 or -1 // Incremental evaluation of the neighbor: fitness is modified by +1 , 0 or -1
moRoyalRoadIncrEval<Neighbor> neighborEval(fullEval); moRoyalRoadIncrEval<Neighbor> neighborEval(fullEval);
/* ========================================================= /* =========================================================
* *
* the neighborhood of a solution * the neighborhood of a solution
* *
* ========================================================= */ * ========================================================= */
// Exploration of the neighborhood in increasing order of the neigbor's index: // Exploration of the neighborhood in increasing order of the neigbor's index:
// bit-flip from bit 0 to bit (vecSize - 1) // bit-flip from bit 0 to bit (vecSize - 1)
moOrderNeighborhood<Neighbor> neighborhood(vecSize); moOrderNeighborhood<Neighbor> neighborhood(vecSize);
/* ========================================================= /* =========================================================
* *
* The sampling of the search space * The sampling of the search space
* *
* ========================================================= */ * ========================================================= */
// sampling object : // sampling object :
// - random initialization // - random initialization
// - neighborhood to compute the neutral degree // - neighborhood to compute the neutral degree
// - fitness function // - fitness function
// - neighbor evaluation // - neighbor evaluation
// - number of solutions to sample // - number of solutions to sample
moNeutralDegreeSampling<Neighbor> sampling(random, neighborhood, fullEval, neighborEval, nbSol); moNeutralDegreeSampling<Neighbor> sampling(random, neighborhood, fullEval, neighborEval, nbSol);
/* ========================================================= /* =========================================================
* *
* execute the sampling * execute the sampling
* *
* ========================================================= */ * ========================================================= */
sampling(); sampling();
/* ========================================================= /* =========================================================
* *
* export the sampling * export the sampling
* *
* ========================================================= */ * ========================================================= */
// to export the statistics into file // to export the statistics into file
sampling.fileExport(str_out); sampling.fileExport(str_out);
// to get the values of statistics // to get the values of statistics
// so, you can compute some statistics in c++ from the data // so, you can compute some statistics in c++ from the data
const std::vector<double> & fitnessValues = sampling.getValues(0); const std::vector<double> & fitnessValues = sampling.getValues(0);
const std::vector<double> & ndValues = sampling.getValues(1); const std::vector<double> & ndValues = sampling.getValues(1);
std::cout << "First values:" << std::endl; std::cout << "First values:" << std::endl;
std::cout << "Fitness " << fitnessValues[0] << std::endl; std::cout << "Fitness " << fitnessValues[0] << std::endl;
std::cout << "N. Degree " << ndValues[0] << std::endl; std::cout << "N. Degree " << ndValues[0] << std::endl;
std::cout << "Last values:" << std::endl; std::cout << "Last values:" << std::endl;
std::cout << "Fitness " << fitnessValues[fitnessValues.size() - 1] << std::endl; std::cout << "Fitness " << fitnessValues[fitnessValues.size() - 1] << std::endl;
std::cout << "N. Degree " << ndValues[fitnessValues.size() - 1] << std::endl; std::cout << "N. Degree " << ndValues[fitnessValues.size() - 1] << std::endl;
} }
// A main that catches the exceptions // A main that catches the exceptions

334
trunk/paradiseo-mo/tutorial/Lesson6/neutralWalk.cpp
View file

@ -56,184 +56,184 @@ typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor wi
void main_function(int argc, char **argv) void main_function(int argc, char **argv)
{ {
/* ========================================================= /* =========================================================
* *
* Parameters * Parameters
* *
* ========================================================= */ * ========================================================= */
// more information on the input parameters: see EO tutorial lesson 3 // 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. // 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 // First define a parser from the command-line arguments
eoParser parser(argc, argv); eoParser parser(argc, argv);
// For each parameter, define Parameter, read it through the parser, // For each parameter, define Parameter, read it through the parser,
// and assign the value to the variable // and assign the value to the variable
// random seed parameter // random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S'); eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam ); parser.processParam( seedParam );
unsigned seed = seedParam.value(); unsigned seed = seedParam.value();
// length of the bit string // length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V'); eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" ); parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value(); unsigned vecSize = vecSizeParam.value();
// size of the block // size of the block
eoValueParam<unsigned int> blockSizeParam(4, "blockSize", "Block size of the Royal Road", 'k'); eoValueParam<unsigned int> blockSizeParam(4, "blockSize", "Block size of the Royal Road", 'k');
parser.processParam( blockSizeParam, "Representation" ); parser.processParam( blockSizeParam, "Representation" );
unsigned blockSize = blockSizeParam.value(); unsigned blockSize = blockSizeParam.value();
// the number of steps of the random walk // the number of steps of the random walk
eoValueParam<unsigned int> stepParam(100, "nbStep", "Number of steps of the random walk", 'n'); eoValueParam<unsigned int> stepParam(100, "nbStep", "Number of steps of the random walk", 'n');
parser.processParam( stepParam, "Representation" ); parser.processParam( stepParam, "Representation" );
unsigned nbStep = stepParam.value(); unsigned nbStep = stepParam.value();
// the name of the output file // the name of the output file
string str_out = "out.dat"; // default value string str_out = "out.dat"; // default value
eoValueParam<string> outParam(str_out.c_str(), "out", "Output file of the sampling", 'o'); eoValueParam<string> outParam(str_out.c_str(), "out", "Output file of the sampling", 'o');
parser.processParam(outParam, "Persistence" ); parser.processParam(outParam, "Persistence" );
// the name of the "status" file where all actual parameter values will be saved // the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file"); eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" ); parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these // i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) { if (parser.userNeedsHelp()) {
parser.printHelp(cout); parser.printHelp(cout);
exit(1); exit(1);
} }
if (statusParam.value() != "") { if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str()); ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file 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 fitness function is the royal function (oneMax is a Royal Road with block of 1)
RoyalRoadEval<Indi> fullEval(blockSize);
/* =========================================================
*
* evaluation of a neighbor solution
*
* ========================================================= */
// Incremental evaluation of the neighbor: fitness is modified by +1 , 0 or -1
moRoyalRoadIncrEval<Neighbor> neighborEval(fullEval);
/* =========================================================
*
* the neighborhood of a solution
*
* ========================================================= */
// Exploration of the neighborhood in random order
// at each step one bit is randomly generated
moRndWithoutReplNeighborhood<Neighbor> neighborhood(vecSize);
/* =========================================================
*
* The sampling of the search space
*
* ========================================================= */
// Initial Solution of the random neutral walk
Indi initialSol(vecSize, false);
// Hamming distance
eoHammingDistance<Indi> distance;
// sampling object :
// - random initialization
// - neighborhood to compute the next step
// - fitness function
// - neighbor evaluation
// - number of steps of the walk
moNeutralWalkSampling<Neighbor> sampling(initialSol, neighborhood, fullEval, neighborEval, distance, nbStep);
/* =========================================================
*
* execute the sampling
*
* ========================================================= */
// nearly 2 blocks are complete
for(unsigned i = 0; i < blockSize - 1; i++) {
initialSol[i] = true;
initialSol[blockSize + i] = true;
initialSol[2 * blockSize + i] = true;
}
// first block is complete
initialSol[blockSize - 1] = true;
fullEval(initialSol);
std::cout << "Initial Solution: " << initialSol << std::endl;
// the sampling
sampling();
/* =========================================================
*
* export the sampling
*
* ========================================================= */
// to export the statistics into file
sampling.fileExport(str_out);
// to get the values of statistics
// so, you can compute some statistics in c++ from the data
const std::vector<Indi> & solutions = sampling.getSolutions(0);
std::cout << "First values:" << std::endl;
std::cout << "Solution " << solutions[0] << std::endl;
std::cout << "Last values:" << std::endl;
std::cout << "Solution " << solutions[solutions.size() - 1] << std::endl;
// export only the solution into file
sampling.fileExport(0, str_out + "_sol");
// more basic statistics on the distribution:
moStatistics statistics;
vector< vector<double> > dist;
vector<double> v;
statistics.distances(solutions, distance, dist);
for(unsigned i = 0; i < dist.size(); i++) {
for(unsigned j = 0; j < dist.size(); j++) {
std::cout << dist[i][j] << " " ;
if (j < i)
v.push_back(dist[i][j]);
} }
std::cout << std::endl;
}
double min, max, avg, std; /* =========================================================
statistics.basic(v, min, max, avg, std); *
std::cout << "min=" << min << ", max=" << max << ", average=" << avg << ", std dev=" << std << std::endl; * 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 fitness function is the royal function (oneMax is a Royal Road with block of 1)
RoyalRoadEval<Indi> fullEval(blockSize);
/* =========================================================
*
* evaluation of a neighbor solution
*
* ========================================================= */
// Incremental evaluation of the neighbor: fitness is modified by +1 , 0 or -1
moRoyalRoadIncrEval<Neighbor> neighborEval(fullEval);
/* =========================================================
*
* the neighborhood of a solution
*
* ========================================================= */
// Exploration of the neighborhood in random order
// at each step one bit is randomly generated
moRndWithoutReplNeighborhood<Neighbor> neighborhood(vecSize);
/* =========================================================
*
* The sampling of the search space
*
* ========================================================= */
// Initial Solution of the random neutral walk
Indi initialSol(vecSize, false);
// Hamming distance
eoHammingDistance<Indi> distance;
// sampling object :
// - random initialization
// - neighborhood to compute the next step
// - fitness function
// - neighbor evaluation
// - number of steps of the walk
moNeutralWalkSampling<Neighbor> sampling(initialSol, neighborhood, fullEval, neighborEval, distance, nbStep);
/* =========================================================
*
* execute the sampling
*
* ========================================================= */
// nearly 2 blocks are complete
for (unsigned i = 0; i < blockSize - 1; i++) {
initialSol[i] = true;
initialSol[blockSize + i] = true;
initialSol[2 * blockSize + i] = true;
}
// first block is complete
initialSol[blockSize - 1] = true;
fullEval(initialSol);
std::cout << "Initial Solution: " << initialSol << std::endl;
// the sampling
sampling();
/* =========================================================
*
* export the sampling
*
* ========================================================= */
// to export the statistics into file
sampling.fileExport(str_out);
// to get the values of statistics
// so, you can compute some statistics in c++ from the data
const std::vector<Indi> & solutions = sampling.getSolutions(0);
std::cout << "First values:" << std::endl;
std::cout << "Solution " << solutions[0] << std::endl;
std::cout << "Last values:" << std::endl;
std::cout << "Solution " << solutions[solutions.size() - 1] << std::endl;
// export only the solution into file
sampling.fileExport(0, str_out + "_sol");
// more basic statistics on the distribution:
moStatistics statistics;
vector< vector<double> > dist;
vector<double> v;
statistics.distances(solutions, distance, dist);
for (unsigned i = 0; i < dist.size(); i++) {
for (unsigned j = 0; j < dist.size(); j++) {
std::cout << dist[i][j] << " " ;
if (j < i)
v.push_back(dist[i][j]);
}
std::cout << std::endl;
}
double min, max, avg, std;
statistics.basic(v, min, max, avg, std);
std::cout << "min=" << min << ", max=" << max << ", average=" << avg << ", std dev=" << std << std::endl;
} }
// A main that catches the exceptions // A main that catches the exceptions

282
trunk/paradiseo-mo/tutorial/Lesson6/sampling.cpp
View file

@ -63,183 +63,183 @@ typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor wi
void main_function(int argc, char **argv) void main_function(int argc, char **argv)
{ {
/* ========================================================= /* =========================================================
* *
* Parameters * Parameters
* *
* ========================================================= */ * ========================================================= */
// more information on the input parameters: see EO tutorial lesson 3 // 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. // 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 // First define a parser from the command-line arguments
eoParser parser(argc, argv); eoParser parser(argc, argv);
// For each parameter, define Parameter, read it through the parser, // For each parameter, define Parameter, read it through the parser,
// and assign the value to the variable // and assign the value to the variable
// random seed parameter // random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S'); eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam ); parser.processParam( seedParam );
unsigned seed = seedParam.value(); unsigned seed = seedParam.value();
// length of the bit string // length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V'); eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" ); parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value(); unsigned vecSize = vecSizeParam.value();
// the number of steps of the random walk // the number of steps of the random walk
eoValueParam<unsigned int> stepParam(100, "nbStep", "Number of steps of the random walk", 'n'); eoValueParam<unsigned int> stepParam(100, "nbStep", "Number of steps of the random walk", 'n');
parser.processParam( stepParam, "Representation" ); parser.processParam( stepParam, "Representation" );
unsigned nbStep = stepParam.value(); unsigned nbStep = stepParam.value();
// the name of the output file // the name of the output file
string str_out = "out.dat"; // default value string str_out = "out.dat"; // default value
eoValueParam<string> outParam(str_out.c_str(), "out", "Output file of the sampling", 'o'); eoValueParam<string> outParam(str_out.c_str(), "out", "Output file of the sampling", 'o');
parser.processParam(outParam, "Persistence" ); parser.processParam(outParam, "Persistence" );
// the name of the "status" file where all actual parameter values will be saved // the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file"); eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" ); parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these // i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) { if (parser.userNeedsHelp()) {
parser.printHelp(cout); parser.printHelp(cout);
exit(1); exit(1);
} }
if (statusParam.value() != "") { if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str()); ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file os << parser;// and you can use that file as parameter file
} }
/* ========================================================= /* =========================================================
* *
* Random seed * Random seed
* *
* ========================================================= */ * ========================================================= */
// reproducible random seed: if you don't change SEED above, // reproducible random seed: if you don't change SEED above,
// you'll aways get the same result, NOT a random run // you'll aways get the same result, NOT a random run
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
rng.reseed(seed); rng.reseed(seed);
/* ========================================================= /* =========================================================
* *
* Initialization of the solution * Initialization of the solution
* *
* ========================================================= */ * ========================================================= */
// a Indi random initializer: each bit is random // a Indi random initializer: each bit is random
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
eoUniformGenerator<bool> uGen; eoUniformGenerator<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen); eoInitFixedLength<Indi> random(vecSize, uGen);
/* ========================================================= /* =========================================================
* *
* Eval fitness function (full evaluation) * Eval fitness function (full evaluation)
* *
* ========================================================= */ * ========================================================= */
// the fitness function is just the number of 1 in the bit string // the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEval; oneMaxEval<Indi> fullEval;
/* ========================================================= /* =========================================================
* *
* evaluation of a neighbor solution * evaluation of a neighbor solution
* *
* ========================================================= */ * ========================================================= */
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval); // moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Incremental evaluation of the neighbor: fitness is modified by +/- 1 // Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEval; moOneMaxIncrEval<Neighbor> neighborEval;
/* ========================================================= /* =========================================================
* *
* the neighborhood of a solution * the neighborhood of a solution
* *
* ========================================================= */ * ========================================================= */
// Exploration of the neighborhood in random order // Exploration of the neighborhood in random order
// at each step one bit is randomly generated // at each step one bit is randomly generated
moRndWithReplNeighborhood<Neighbor> neighborhood(vecSize); moRndWithReplNeighborhood<Neighbor> neighborhood(vecSize);
/* ========================================================= /* =========================================================
* *
* the local search algorithm to sample the search space * the local search algorithm to sample the search space
* *
* ========================================================= */ * ========================================================= */
moRandomWalk<Neighbor> walk(neighborhood, fullEval, neighborEval, nbStep); moRandomWalk<Neighbor> walk(neighborhood, fullEval, neighborEval, nbStep);
/* ========================================================= /* =========================================================
* *
* the statistics to compute * the statistics to compute
* *
* ========================================================= */ * ========================================================= */
// fitness of the solution at each step // fitness of the solution at each step
moFitnessStat<Indi> fStat; moFitnessStat<Indi> fStat;
// Hamming distance to the global optimum // Hamming distance to the global optimum
eoHammingDistance<Indi> distance; // Hamming distance eoHammingDistance<Indi> distance; // Hamming distance
Indi bestSolution(vecSize, true); // global optimum Indi bestSolution(vecSize, true); // global optimum
moDistanceStat<Indi, unsigned> distStat(distance, bestSolution); // statistic moDistanceStat<Indi, unsigned> distStat(distance, bestSolution); // statistic
// "statistic" of the solution // "statistic" of the solution
moSolutionStat<Indi> solStat; moSolutionStat<Indi> solStat;
/* ========================================================= /* =========================================================
* *
* The sampling of the search space * The sampling of the search space
* *
* ========================================================= */ * ========================================================= */
// sampling object : // sampling object :
// - random initialization // - random initialization
// - local search to sample the search space // - local search to sample the search space
// - one statistic to compute // - one statistic to compute
moSampling<Neighbor> sampling(random, walk, fStat); moSampling<Neighbor> sampling(random, walk, fStat);
// to add another statistics // to add another statistics
sampling.add(distStat); // distance sampling.add(distStat); // distance
sampling.add(solStat); // solutions sampling.add(solStat); // solutions
/* ========================================================= /* =========================================================
* *
* execute the sampling * execute the sampling
* *
* ========================================================= */ * ========================================================= */
sampling(); sampling();
/* ========================================================= /* =========================================================
* *
* export the sampling * export the sampling
* *
* ========================================================= */ * ========================================================= */
// to export the statistics into file // to export the statistics into file
sampling.fileExport(str_out); sampling.fileExport(str_out);
// to get the values of statistics // to get the values of statistics
// so, you can compute some statistics in c++ from the data // so, you can compute some statistics in c++ from the data
const std::vector<double> & fitnessValues = sampling.getValues(0); const std::vector<double> & fitnessValues = sampling.getValues(0);
const std::vector<double> & distValues = sampling.getValues(1); const std::vector<double> & distValues = sampling.getValues(1);
const std::vector<Indi> & solutions = sampling.getSolutions(2); const std::vector<Indi> & solutions = sampling.getSolutions(2);
std::cout << "First values:" << std::endl; std::cout << "First values:" << std::endl;
std::cout << "Fitness " << fitnessValues[0] << std::endl; std::cout << "Fitness " << fitnessValues[0] << std::endl;
std::cout << "Distance " << distValues[0] << std::endl; std::cout << "Distance " << distValues[0] << std::endl;
std::cout << "Solution " << solutions[0] << std::endl << std::endl; std::cout << "Solution " << solutions[0] << std::endl << std::endl;
std::cout << "Last values:" << std::endl; std::cout << "Last values:" << std::endl;
std::cout << "Fitness " << fitnessValues[fitnessValues.size() - 1] << std::endl; std::cout << "Fitness " << fitnessValues[fitnessValues.size() - 1] << std::endl;
std::cout << "Distance " << distValues[distValues.size() - 1] << std::endl; std::cout << "Distance " << distValues[distValues.size() - 1] << std::endl;
std::cout << "Solution " << solutions[solutions.size() - 1] << std::endl; std::cout << "Solution " << solutions[solutions.size() - 1] << std::endl;
} }
// A main that catches the exceptions // A main that catches the exceptions

16
trunk/paradiseo-mo/tutorial/Lesson7/hybridAlgo.cpp
View file

@ -133,10 +133,10 @@ void main_function(int argc, char **argv)
Queen tmp; Queen tmp;
for(unsigned int i=0; i<20; i++){ for (unsigned int i=0; i<20; i++) {
init(tmp); init(tmp);
fullEval(tmp); fullEval(tmp);
pop.push_back(tmp); pop.push_back(tmp);
} }
/* ========================================================= /* =========================================================
@ -193,16 +193,16 @@ void main_function(int argc, char **argv)
std::cout << "INITIAL POPULATION:" << std::endl; std::cout << "INITIAL POPULATION:" << std::endl;
std::cout << "-------------------" << std::endl; std::cout << "-------------------" << std::endl;
for(unsigned int i=0; i<pop.size(); i++) for (unsigned int i=0; i<pop.size(); i++)
std::cout << pop[i] << std::endl; std::cout << pop[i] << std::endl;
hybridAlgo(pop); hybridAlgo(pop);
std::cout << std::endl; std::cout << std::endl;
std::cout << "FINAL POPULATION:" << std::endl; std::cout << "FINAL POPULATION:" << std::endl;
std::cout << "-------------------" << std::endl; std::cout << "-------------------" << std::endl;
for(unsigned int i=0; i<pop.size(); i++) for (unsigned int i=0; i<pop.size(); i++)
std::cout << pop[i] << std::endl; std::cout << pop[i] << std::endl;
} }