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

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

@ -1,7 +1,7 @@
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
/** firstImprHC_maxSAT.cpp /** firstImprHC_maxSAT.cpp
* *
* SV - 05/05/10 * SV - 05/05/10
* *
*/ */
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@ -45,7 +45,7 @@ using namespace std;
// Indi is the typedef of the solution type like in paradisEO-eo // Indi is the typedef of the solution type like in paradisEO-eo
typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type
// Neighbor is the typedef of the neighbor type, // Neighbor is the typedef of the neighbor type,
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// all classes from paradisEO-mo use this template type // all classes from paradisEO-mo use this template type
typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type
@ -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
// i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) {
parser.printHelp(cout);
exit(1);
}
if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file
}
/* ========================================================= // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
* // i.e. in case you need parameters somewhere else, postpone these
* Random seed if (parser.userNeedsHelp()) {
* parser.printHelp(cout);
* ========================================================= */ exit(1);
}
if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file
}
// 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) * Random seed
rng.reseed(seed); *
* ========================================================= */
/* ========================================================= // reproducible random seed: if you don't change SEED above,
* // you'll aways get the same result, NOT a random run
* Eval fitness function (full evaluation) // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
* rng.reseed(seed);
* ========================================================= */
// the max SAT evaluation /* =========================================================
MaxSATeval<Indi> * fullEval; *
* Eval fitness function (full evaluation)
*
* ========================================================= */
if (str_in.compare("") == 0) // the max SAT evaluation
fullEval = new MaxSATeval<Indi>(vecSize, nbClause, nbLitteral); MaxSATeval<Indi> * fullEval;
else {
fullEval = new MaxSATeval<Indi>(str_in);
vecSize = fullEval->nbVar ;
}
// string out = "cnf.dat"; if (str_in.compare("") == 0)
// fullEval->save(out); fullEval = new MaxSATeval<Indi>(vecSize, nbClause, nbLitteral);
else {
fullEval = new MaxSATeval<Indi>(str_in);
vecSize = fullEval->nbVar ;
}
/* ========================================================= // string out = "cnf.dat";
* // fullEval->save(out);
* evaluation of a neighbor solution
*
* ========================================================= */
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution /* =========================================================
// moFullEvalByModif<Neighbor> neighborEval(*fullEval); *
* evaluation of a neighbor solution
*
* ========================================================= */
// Incremental evaluation of the neighbor: // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
moMaxSATincrEval<Neighbor> neighborEval(*fullEval); // moFullEvalByModif<Neighbor> neighborEval(*fullEval);
/* ========================================================= // Incremental evaluation of the neighbor:
* moMaxSATincrEval<Neighbor> neighborEval(*fullEval);
* Initialization of the solution
*
* ========================================================= */
// a Indi random initializer: each bit is random /* =========================================================
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) *
eoUniformGenerator<bool> uGen; * Initialization of the solution
eoInitFixedLength<Indi> random(vecSize, uGen); *
* ========================================================= */
/* ========================================================= // a Indi random initializer: each bit is random
* // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
* the neighborhood of a solution eoUniformGenerator<bool> uGen;
* eoInitFixedLength<Indi> random(vecSize, uGen);
* ========================================================= */
// Exploration of the neighborhood in random order of the neigbor's index: /* =========================================================
// each neighbor is visited only once *
moRndWithoutReplNeighborhood<Neighbor> neighborhood(vecSize); * the neighborhood of a solution
*
* ========================================================= */
/* ========================================================= // Exploration of the neighborhood in random order of the neigbor's index:
* // each neighbor is visited only once
* the local search algorithm moRndWithoutReplNeighborhood<Neighbor> neighborhood(vecSize);
*
* ========================================================= */
moFirstImprHC<Neighbor> hc(neighborhood, *fullEval, neighborEval); /* =========================================================
*
* the local search algorithm
*
* ========================================================= */
/* ========================================================= moFirstImprHC<Neighbor> hc(neighborhood, *fullEval, neighborEval);
*
* executes the local search from a random solution
*
* ========================================================= */
// The current solution /* =========================================================
Indi solution; *
* executes the local search from a random solution
*
* ========================================================= */
// Apply random initialization // The current solution
random(solution); Indi solution;
// Evaluation of the initial solution: // Apply random initialization
// can be evaluated here, or else it will be done at the beginning of the local search random(solution);
(*fullEval)(solution);
// Output: the intial solution // Evaluation of the initial solution:
std::cout << "initial: " << solution << std::endl ; // can be evaluated here, or else it will be done at the beginning of the local search
(*fullEval)(solution);
// Apply the local search on the solution ! // Output: the intial solution
hc(solution); std::cout << "initial: " << solution << std::endl ;
// Output: the final solution // Apply the local search on the solution !
std::cout << "final: " << solution << std::endl ; hc(solution);
// Output: the final solution
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;
} }

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

@ -55,7 +55,7 @@ using namespace std;
// Indi is the typedef of the solution type like in paradisEO-eo // Indi is the typedef of the solution type like in paradisEO-eo
typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type
// Neighbor is the typedef of the neighbor type, // Neighbor is the typedef of the neighbor type,
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// all classes from paradisEO-mo use this template type // all classes from paradisEO-mo use this template type
typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type
@ -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;
} }

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

@ -50,7 +50,7 @@ using namespace std;
// Indi is the typedef of the solution type like in paradisEO-eo // Indi is the typedef of the solution type like in paradisEO-eo
typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type
// Neighbor is the typedef of the neighbor type, // Neighbor is the typedef of the neighbor type,
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// all classes from paradisEO-mo use this template type // all classes from paradisEO-mo use this template type
typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type
@ -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;
} }

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

@ -45,7 +45,7 @@ using namespace std;
// Indi is the typedef of the solution type like in paradisEO-eo // Indi is the typedef of the solution type like in paradisEO-eo
typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type
// Neighbor is the typedef of the neighbor type, // Neighbor is the typedef of the neighbor type,
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// all classes from paradisEO-mo use this template type // all classes from paradisEO-mo use this template type
typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type
@ -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;
} }

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

@ -49,7 +49,7 @@ using namespace std;
// Indi is the typedef of the solution type like in paradisEO-eo // Indi is the typedef of the solution type like in paradisEO-eo
typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type
// Neighbor is the typedef of the neighbor type, // Neighbor is the typedef of the neighbor type,
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// all classes from paradisEO-mo use this template type // all classes from paradisEO-mo use this template type
typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type
@ -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;
} }

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

@ -50,7 +50,7 @@ using namespace std;
// Indi is the typedef of the solution type like in paradisEO-eo // Indi is the typedef of the solution type like in paradisEO-eo
typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type
// Neighbor is the typedef of the neighbor type, // Neighbor is the typedef of the neighbor type,
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// all classes from paradisEO-mo use this template type // all classes from paradisEO-mo use this template type
typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type
@ -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;
} }

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

@ -49,7 +49,7 @@ using namespace std;
// Indi is the typedef of the solution type like in paradisEO-eo // Indi is the typedef of the solution type like in paradisEO-eo
typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type
// Neighbor is the typedef of the neighbor type, // Neighbor is the typedef of the neighbor type,
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// all classes from paradisEO-mo use this template type // all classes from paradisEO-mo use this template type
typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type
@ -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;
} }

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

@ -45,7 +45,7 @@ using namespace std;
// Indi is the typedef of the solution type like in paradisEO-eo // Indi is the typedef of the solution type like in paradisEO-eo
typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type
// Neighbor is the typedef of the neighbor type, // Neighbor is the typedef of the neighbor type,
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// all classes from paradisEO-mo use this template type // all classes from paradisEO-mo use this template type
typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type
@ -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
string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED // the name of the "status" file where all actual parameter values will be saved
// i.e. in case you need parameters somewhere else, postpone these string str_status = parser.ProgramName() + ".status"; // default value
if (parser.userNeedsHelp()) { eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.printHelp(cout); parser.processParam( statusParam, "Persistence" );
exit(1);
}
if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file
}
/* ========================================================= // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
* // i.e. in case you need parameters somewhere else, postpone these
* Random seed if (parser.userNeedsHelp()) {
* parser.printHelp(cout);
* ========================================================= */ exit(1);
}
if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file
}
// 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) * Random seed
rng.reseed(seed); *
* ========================================================= */
/* ========================================================= // reproducible random seed: if you don't change SEED above,
* // you'll aways get the same result, NOT a random run
* Initialization of the solution // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
* rng.reseed(seed);
* ========================================================= */
// a Indi random initializer: each bit is random /* =========================================================
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) *
eoUniformGenerator<bool> uGen; * Initialization of the solution
eoInitFixedLength<Indi> random(vecSize, uGen); *
* ========================================================= */
/* ========================================================= // a Indi random initializer: each bit is random
* // more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
* Eval fitness function (full evaluation) eoUniformGenerator<bool> uGen;
* eoInitFixedLength<Indi> random(vecSize, uGen);
* ========================================================= */
// the fitness function is just the number of 1 in the bit string /* =========================================================
oneMaxEval<Indi> fullEval; *
* Eval fitness function (full evaluation)
*
* ========================================================= */
/* ========================================================= // the fitness function is just the number of 1 in the bit string
* oneMaxEval<Indi> fullEval;
* evaluation of a neighbor solution
*
* ========================================================= */
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution /* =========================================================
// moFullEvalByModif<Neighbor> neighborEval(fullEval); *
* evaluation of a neighbor solution
*
* ========================================================= */
// Incremental evaluation of the neighbor: fitness is modified by +/- 1 // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
moOneMaxIncrEval<Neighbor> neighborEval; // moFullEvalByModif<Neighbor> neighborEval(fullEval);
/* ========================================================= // Incremental evaluation of the neighbor: fitness is modified by +/- 1
* moOneMaxIncrEval<Neighbor> neighborEval;
* the neighborhood of a solution
*
* ========================================================= */
// Exploration of the neighborhood in increasing order of the neigbor's index: /* =========================================================
// bit-flip from bit 0 to bit (vecSize - 1) *
moOrderNeighborhood<Neighbor> neighborhood(vecSize); * the neighborhood of a solution
*
* ========================================================= */
/* ========================================================= // Exploration of the neighborhood in increasing order of the neigbor's index:
* // bit-flip from bit 0 to bit (vecSize - 1)
* the local search algorithm moOrderNeighborhood<Neighbor> neighborhood(vecSize);
*
* ========================================================= */
moNeutralHC<Neighbor> hc(neighborhood, fullEval, neighborEval, nbStepMax); /* =========================================================
*
* the local search algorithm
*
* ========================================================= */
/* ========================================================= moNeutralHC<Neighbor> hc(neighborhood, fullEval, neighborEval, nbStepMax);
*
* executes the local search from a random solution
*
* ========================================================= */
// The current solution /* =========================================================
Indi solution; *
* executes the local search from a random solution
*
* ========================================================= */
// Apply random initialization // The current solution
random(solution); Indi solution;
// Evaluation of the initial solution: // Apply random initialization
// can be evaluated here, or else it will be done at the beginning of the local search random(solution);
fullEval(solution);
// Output: the intial solution // Evaluation of the initial solution:
std::cout << "initial: " << solution << std::endl ; // can be evaluated here, or else it will be done at the beginning of the local search
fullEval(solution);
// Apply the local search on the solution ! // Output: the intial solution
hc(solution); std::cout << "initial: " << solution << std::endl ;
// Output: the final solution // Apply the local search on the solution !
std::cout << "final: " << solution << std::endl ; hc(solution);
// Output: the final solution
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;
} }

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

@ -45,7 +45,7 @@ using namespace std;
// Indi is the typedef of the solution type like in paradisEO-eo // Indi is the typedef of the solution type like in paradisEO-eo
typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type
// Neighbor is the typedef of the neighbor type, // Neighbor is the typedef of the neighbor type,
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// all classes from paradisEO-mo use this template type // all classes from paradisEO-mo use this template type
typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type
@ -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;
} }

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

@ -45,7 +45,7 @@ using namespace std;
// Indi is the typedef of the solution type like in paradisEO-eo // Indi is the typedef of the solution type like in paradisEO-eo
typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type
// Neighbor is the typedef of the neighbor type, // Neighbor is the typedef of the neighbor type,
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// all classes from paradisEO-mo use this template type // all classes from paradisEO-mo use this template type
typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type
@ -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();

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -49,191 +49,191 @@ using namespace std;
// Indi is the typedef of the solution type like in paradisEO-eo // Indi is the typedef of the solution type like in paradisEO-eo
typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type
// Neighbor is the typedef of the neighbor type, // Neighbor is the typedef of the neighbor type,
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// all classes from paradisEO-mo use this template type // all classes from paradisEO-mo use this template type
typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type
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,
// and assign the value to the variable
// random seed parameter // For each parameter, define Parameter, read it through the parser,
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S'); // and assign the value to the variable
parser.processParam( seedParam );
unsigned seed = seedParam.value();
// length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value();
// size of the block
eoValueParam<unsigned int> blockSizeParam(4, "blockSize", "Block size of the Royal Road", 'k');
parser.processParam( blockSizeParam, "Representation" );
unsigned blockSize = blockSizeParam.value();
// the number of steps of the random walk
eoValueParam<unsigned int> stepParam(100, "nbStep", "Number of steps of the random walk", 'n');
parser.processParam( stepParam, "Representation" );
unsigned nbStep = stepParam.value();
// the name of the output file
string str_out = "out.dat"; // default value
eoValueParam<string> outParam(str_out.c_str(), "out", "Output file of the sampling", 'o');
parser.processParam(outParam, "Persistence" );
// the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) {
parser.printHelp(cout);
exit(1);
}
if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file
}
/* ========================================================= // random seed parameter
* eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
* Random seed parser.processParam( seedParam );
* unsigned seed = seedParam.value();
* ========================================================= */
// reproducible random seed: if you don't change SEED above, // length of the bit string
// you'll aways get the same result, NOT a random run eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp) parser.processParam( vecSizeParam, "Representation" );
rng.reseed(seed); unsigned vecSize = vecSizeParam.value();
/* ========================================================= // size of the block
* eoValueParam<unsigned int> blockSizeParam(4, "blockSize", "Block size of the Royal Road", 'k');
* Eval fitness function (full evaluation) parser.processParam( blockSizeParam, "Representation" );
* unsigned blockSize = blockSizeParam.value();
* ========================================================= */
// the fitness function is the royal function (oneMax is a Royal Road with block of 1) // the number of steps of the random walk
RoyalRoadEval<Indi> fullEval(blockSize); eoValueParam<unsigned int> stepParam(100, "nbStep", "Number of steps of the random walk", 'n');
parser.processParam( stepParam, "Representation" );
unsigned nbStep = stepParam.value();
/* ========================================================= // the name of the output file
* string str_out = "out.dat"; // default value
* evaluation of a neighbor solution eoValueParam<string> outParam(str_out.c_str(), "out", "Output file of the sampling", 'o');
* parser.processParam(outParam, "Persistence" );
* ========================================================= */
// Incremental evaluation of the neighbor: fitness is modified by +1 , 0 or -1 // the name of the "status" file where all actual parameter values will be saved
moRoyalRoadIncrEval<Neighbor> neighborEval(fullEval); string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" );
/* ========================================================= // do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
* // i.e. in case you need parameters somewhere else, postpone these
* the neighborhood of a solution if (parser.userNeedsHelp()) {
* parser.printHelp(cout);
* ========================================================= */ exit(1);
}
// Exploration of the neighborhood in random order if (statusParam.value() != "") {
// at each step one bit is randomly generated ofstream os(statusParam.value().c_str());
moRndWithoutReplNeighborhood<Neighbor> neighborhood(vecSize); os << parser;// and you can use that file as parameter file
/* =========================================================
*
* 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

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

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