diff --git a/trunk/paradiseo-mo/tutorial/Lesson1/firstImprHC_maxSAT.cpp b/trunk/paradiseo-mo/tutorial/Lesson1/firstImprHC_maxSAT.cpp index e7870423b..97f48ae31 100644 --- a/trunk/paradiseo-mo/tutorial/Lesson1/firstImprHC_maxSAT.cpp +++ b/trunk/paradiseo-mo/tutorial/Lesson1/firstImprHC_maxSAT.cpp @@ -1,7 +1,7 @@ //----------------------------------------------------------------------------- /** 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 typedef eoBit Indi; // bit string with unsigned fitness type // Neighbor is the typedef of the neighbor type, -// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) +// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // all classes from paradisEO-mo use this template type typedef moBitNeighbor Neighbor ; // bit string neighbor with unsigned fitness type @@ -54,157 +54,157 @@ typedef moBitNeighbor Neighbor ; // bit string neighbor wi //----------------------------------------------------------------------------- void main_function(int argc, char **argv) { - /* ========================================================= - * - * Parameters from parser - * - * ========================================================= */ - // more information on the input parameters: see EO tutorial lesson 3 - // but don't care at first it just read the parameters of the bit string size and the random seed. + /* ========================================================= + * + * Parameters from parser + * + * ========================================================= */ + // more information on the input parameters: see EO tutorial lesson 3 + // but don't care at first it just read the parameters of the bit string size and the random seed. - // First define a parser from the command-line arguments - eoParser parser(argc, argv); + // First define a parser from the command-line arguments + eoParser parser(argc, argv); - // For each parameter, define Parameter, read it through the parser, - // and assign the value to the variable + // For each parameter, define Parameter, read it through the parser, + // and assign the value to the variable - // random seed parameter - eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); - parser.processParam( seedParam ); - unsigned seed = seedParam.value(); + // random seed parameter + eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); + parser.processParam( seedParam ); + unsigned seed = seedParam.value(); - // length of the bit string - eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); - parser.processParam( vecSizeParam, "Representation" ); - unsigned vecSize = vecSizeParam.value(); + // length of the bit string + eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); + parser.processParam( vecSizeParam, "Representation" ); + unsigned vecSize = vecSizeParam.value(); - // Number of clauses of the max SAT problem - eoValueParam ncParam(10, "nbClauses", "Number of clauses", 'm'); - parser.processParam( ncParam, "Representation" ); - unsigned nbClause = ncParam.value(); + // Number of clauses of the max SAT problem + eoValueParam ncParam(10, "nbClauses", "Number of clauses", 'm'); + parser.processParam( ncParam, "Representation" ); + unsigned nbClause = ncParam.value(); - // Number of litteral by clauses - eoValueParam kParam(3, "nbLitt", "Number of litteral by clauses", 'k'); - parser.processParam( kParam, "Representation" ); - unsigned nbLitteral = kParam.value(); + // Number of litteral by clauses + eoValueParam kParam(3, "nbLitt", "Number of litteral by clauses", 'k'); + parser.processParam( kParam, "Representation" ); + unsigned nbLitteral = kParam.value(); - // the name of the instance file - string str_in = "" ; // default value - eoValueParam inParam(str_in.c_str(), "in", "Input file of the file in ncf format", 'f'); - parser.processParam(inParam, "Persistence" ); - str_in = inParam.value(); + // the name of the instance file + string str_in = "" ; // default value + eoValueParam inParam(str_in.c_str(), "in", "Input file of the file in ncf format", 'f'); + parser.processParam(inParam, "Persistence" ); + str_in = inParam.value(); - // the name of the "status" file where all actual parameter values will be saved - string str_status = parser.ProgramName() + ".status"; // default value - eoValueParam 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 - } + // the name of the "status" file where all actual parameter values will be saved + string str_status = parser.ProgramName() + ".status"; // default value + eoValueParam statusParam(str_status.c_str(), "status", "Status file"); + parser.processParam( statusParam, "Persistence" ); - /* ========================================================= - * - * Random seed - * - * ========================================================= */ + // 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 + } - // 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); + /* ========================================================= + * + * Random seed + * + * ========================================================= */ - /* ========================================================= - * - * Eval fitness function (full evaluation) - * - * ========================================================= */ + // 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); - // the max SAT evaluation - MaxSATeval * fullEval; + /* ========================================================= + * + * Eval fitness function (full evaluation) + * + * ========================================================= */ - if (str_in.compare("") == 0) - fullEval = new MaxSATeval(vecSize, nbClause, nbLitteral); - else { - fullEval = new MaxSATeval(str_in); - vecSize = fullEval->nbVar ; - } + // the max SAT evaluation + MaxSATeval * fullEval; - // string out = "cnf.dat"; - // fullEval->save(out); + if (str_in.compare("") == 0) + fullEval = new MaxSATeval(vecSize, nbClause, nbLitteral); + else { + fullEval = new MaxSATeval(str_in); + vecSize = fullEval->nbVar ; + } - /* ========================================================= - * - * evaluation of a neighbor solution - * - * ========================================================= */ + // string out = "cnf.dat"; + // fullEval->save(out); - // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution - // moFullEvalByModif neighborEval(*fullEval); + /* ========================================================= + * + * evaluation of a neighbor solution + * + * ========================================================= */ - // Incremental evaluation of the neighbor: - moMaxSATincrEval neighborEval(*fullEval); + // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution + // moFullEvalByModif neighborEval(*fullEval); - /* ========================================================= - * - * Initialization of the solution - * - * ========================================================= */ + // Incremental evaluation of the neighbor: + moMaxSATincrEval neighborEval(*fullEval); - // a Indi random initializer: each bit is random - // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) - eoUniformGenerator uGen; - eoInitFixedLength random(vecSize, uGen); + /* ========================================================= + * + * Initialization of the solution + * + * ========================================================= */ - /* ========================================================= - * - * the neighborhood of a solution - * - * ========================================================= */ + // a Indi random initializer: each bit is random + // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) + eoUniformGenerator uGen; + eoInitFixedLength random(vecSize, uGen); - // Exploration of the neighborhood in random order of the neigbor's index: - // each neighbor is visited only once - moRndWithoutReplNeighborhood neighborhood(vecSize); + /* ========================================================= + * + * the neighborhood of a solution + * + * ========================================================= */ - /* ========================================================= - * - * the local search algorithm - * - * ========================================================= */ + // Exploration of the neighborhood in random order of the neigbor's index: + // each neighbor is visited only once + moRndWithoutReplNeighborhood neighborhood(vecSize); - moFirstImprHC hc(neighborhood, *fullEval, neighborEval); + /* ========================================================= + * + * the local search algorithm + * + * ========================================================= */ - /* ========================================================= - * - * executes the local search from a random solution - * - * ========================================================= */ + moFirstImprHC hc(neighborhood, *fullEval, neighborEval); - // The current solution - Indi solution; + /* ========================================================= + * + * executes the local search from a random solution + * + * ========================================================= */ - // Apply random initialization - random(solution); + // The current solution + Indi solution; - // Evaluation of the initial solution: - // can be evaluated here, or else it will be done at the beginning of the local search - (*fullEval)(solution); + // Apply random initialization + random(solution); - // Output: the intial solution - std::cout << "initial: " << solution << std::endl ; + // Evaluation of the initial solution: + // 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 ! - hc(solution); + // Output: the intial solution + std::cout << "initial: " << solution << std::endl ; - // Output: the final solution - std::cout << "final: " << solution << std::endl ; + // Apply the local search on the solution ! + 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) { - try { - main_function(argc, argv); - } - catch (exception& e) { - cout << "Exception: " << e.what() << '\n'; - } - return 1; + try { + main_function(argc, argv); + } + catch (exception& e) { + cout << "Exception: " << e.what() << '\n'; + } + return 1; } diff --git a/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_combinedContinuator.cpp b/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_combinedContinuator.cpp index bb60509da..ba2d3de30 100644 --- a/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_combinedContinuator.cpp +++ b/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_combinedContinuator.cpp @@ -55,7 +55,7 @@ using namespace std; // Indi is the typedef of the solution type like in paradisEO-eo typedef eoBit Indi; // bit string with unsigned fitness type // Neighbor is the typedef of the neighbor type, -// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) +// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // all classes from paradisEO-mo use this template type typedef moBitNeighbor Neighbor ; // bit string neighbor with unsigned fitness type @@ -64,176 +64,176 @@ typedef moBitNeighbor Neighbor ; // bit string neighbor wi //----------------------------------------------------------------------------- void main_function(int argc, char **argv) { - /* ========================================================= - * - * Parameters from parser - * - * ========================================================= */ - // more information on the input parameters: see EO tutorial lesson 3 - // but don't care at first it just read the parameters of the bit string size and the random seed. + /* ========================================================= + * + * Parameters from parser + * + * ========================================================= */ + // more information on the input parameters: see EO tutorial lesson 3 + // but don't care at first it just read the parameters of the bit string size and the random seed. - // First define a parser from the command-line arguments - eoParser parser(argc, argv); + // First define a parser from the command-line arguments + eoParser parser(argc, argv); - // For each parameter, define Parameter, read it through the parser, - // and assign the value to the variable + // For each parameter, define Parameter, read it through the parser, + // and assign the value to the variable - // random seed parameter - eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); - parser.processParam( seedParam ); - unsigned seed = seedParam.value(); + // random seed parameter + eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); + parser.processParam( seedParam ); + unsigned seed = seedParam.value(); - // length of the bit string - eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); - parser.processParam( vecSizeParam, "Representation" ); - unsigned vecSize = vecSizeParam.value(); + // length of the bit string + eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); + parser.processParam( vecSizeParam, "Representation" ); + unsigned vecSize = vecSizeParam.value(); - // maximum number of full evaluation - eoValueParam fevalParam(2, "fulleval", "Maximum number of full evaluation"); - parser.processParam( fevalParam, "Representation" ); - unsigned fullevalMax = fevalParam.value(); + // maximum number of full evaluation + eoValueParam fevalParam(2, "fulleval", "Maximum number of full evaluation"); + parser.processParam( fevalParam, "Representation" ); + unsigned fullevalMax = fevalParam.value(); - // maximum number of full evaluation - eoValueParam evalParam(30, "eval", "Maximum number of neighbor evaluation", 'e'); - parser.processParam( evalParam, "Representation" ); - unsigned evalMax = evalParam.value(); + // maximum number of full evaluation + eoValueParam evalParam(30, "eval", "Maximum number of neighbor evaluation", 'e'); + parser.processParam( evalParam, "Representation" ); + unsigned evalMax = evalParam.value(); - // maximum fitness to reach - eoValueParam fitParam(16, "fitness", "Maximum fitness value to reach", 'f'); - parser.processParam( fitParam, "Representation" ); - unsigned fitnessMax = fitParam.value(); + // maximum fitness to reach + eoValueParam fitParam(16, "fitness", "Maximum fitness value to reach", 'f'); + parser.processParam( fitParam, "Representation" ); + unsigned fitnessMax = fitParam.value(); - // maximum number of iterations - eoValueParam iterParam(10, "iter", "Maximum number of iterations", 'i'); - parser.processParam( iterParam, "Representation" ); - unsigned iterMax = iterParam.value(); + // maximum number of iterations + eoValueParam iterParam(10, "iter", "Maximum number of iterations", 'i'); + parser.processParam( iterParam, "Representation" ); + unsigned iterMax = iterParam.value(); - // the name of the "status" file where all actual parameter values will be saved - string str_status = parser.ProgramName() + ".status"; // default value - eoValueParam statusParam(str_status.c_str(), "status", "Status file"); - parser.processParam( statusParam, "Persistence" ); + // the name of the "status" file where all actual parameter values will be saved + string str_status = parser.ProgramName() + ".status"; // default value + eoValueParam 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 - } + // 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 - * - * ========================================================= */ + /* ========================================================= + * + * 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); + // reproducible random seed: if you don't change SEED above, + // you'll aways get the same result, NOT a random run + // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) + rng.reseed(seed); - /* ========================================================= - * - * Initialization of the solution - * - * ========================================================= */ + /* ========================================================= + * + * Initialization of the solution + * + * ========================================================= */ - // a Indi random initializer: each bit is random - // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) - eoUniformGenerator uGen; - eoInitFixedLength random(vecSize, uGen); + // a Indi random initializer: each bit is random + // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) + eoUniformGenerator uGen; + eoInitFixedLength 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 - oneMaxEval fullEvalTmp; + // the fitness function is just the number of 1 in the bit string + oneMaxEval fullEvalTmp; - // to count the number of full evaluation - eoEvalFuncCounter fullEval(fullEvalTmp); + // to count the number of full evaluation + eoEvalFuncCounter 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 - // moFullEvalByModif neighborEval(fullEval); + // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution + // moFullEvalByModif neighborEval(fullEval); - // Incremental evaluation of the neighbor: fitness is modified by +/- 1 - moOneMaxIncrEval neighborEvalTmp; + // Incremental evaluation of the neighbor: fitness is modified by +/- 1 + moOneMaxIncrEval neighborEvalTmp; - // to count the number of neighbor evaluation - moEvalCounter neighborEval(neighborEvalTmp); + // to count the number of neighbor evaluation + moEvalCounter neighborEval(neighborEvalTmp); - /* ========================================================= - * - * the neighborhood of a solution - * - * ========================================================= */ + /* ========================================================= + * + * 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 neighborhood(vecSize); + // Exploration of the neighborhood in increasing order of the neigbor's index: + // bit-flip from bit 0 to bit (vecSize - 1) + moOrderNeighborhood neighborhood(vecSize); - /* ========================================================= - * - * the external continuators - * - * ========================================================= */ + /* ========================================================= + * + * the external continuators + * + * ========================================================= */ - moIterContinuator iterCont(iterMax); - moFitContinuator fitCont(fitnessMax); - moFullEvalContinuator fullevalCont(fullEval, fullevalMax); - moNeighborEvalContinuator evalCont(neighborEval, evalMax); + moIterContinuator iterCont(iterMax); + moFitContinuator fitCont(fitnessMax); + moFullEvalContinuator fullevalCont(fullEval, fullevalMax); + moNeighborEvalContinuator evalCont(neighborEval, evalMax); - moCombinedContinuator continuator(iterCont); - continuator.add(fitCont); - continuator.add(fullevalCont); - continuator.add(evalCont); + moCombinedContinuator continuator(iterCont); + continuator.add(fitCont); + continuator.add(fullevalCont); + continuator.add(evalCont); - /* ========================================================= - * - * the local search algorithm - * - * ========================================================= */ + /* ========================================================= + * + * the local search algorithm + * + * ========================================================= */ - moSimpleHC hc(neighborhood, fullEval, neighborEval, continuator); + moSimpleHC hc(neighborhood, fullEval, neighborEval, continuator); - /* ========================================================= - * - * executes the local search from a random solution - * - * ========================================================= */ + /* ========================================================= + * + * executes the local search from a random solution + * + * ========================================================= */ - // The current solution - Indi solution; + // The current solution + Indi solution; - // Apply random initialization - random(solution); + // Apply random initialization + random(solution); - // Evaluation of the initial solution: - // can be evaluated here, or else it will be done at the beginning of the local search - fullEval(solution); + // Evaluation of the initial solution: + // can be evaluated here, or else it will be done at the beginning of the local search + fullEval(solution); - // Output: the intial solution - std::cout << "initial: " << solution << std::endl ; + // Output: the intial solution + std::cout << "initial: " << solution << std::endl ; - // Apply the local search on the solution ! - hc(solution); + // Apply the local search on the solution ! + hc(solution); - // Output: the final solution - std::cout << "final: " << solution << std::endl ; - std::cout << "number of iteration: " << iterCont.value() << std::endl ; - std::cout << "Number of full evaluations during the local search: " << fullevalCont.value() << std::endl ; - std::cout << "Number of neighbor evaluations during the local search: " << evalCont.value() << std::endl ; + // Output: the final solution + std::cout << "final: " << solution << std::endl ; + std::cout << "number of iteration: " << iterCont.value() << std::endl ; + std::cout << "Number of full evaluations during the local search: " << fullevalCont.value() << std::endl ; + std::cout << "Number of neighbor evaluations during the local search: " << evalCont.value() << std::endl ; } @@ -241,11 +241,11 @@ void main_function(int argc, char **argv) int main(int argc, char **argv) { - try { - main_function(argc, argv); - } - catch (exception& e) { - cout << "Exception: " << e.what() << '\n'; - } - return 1; + try { + main_function(argc, argv); + } + catch (exception& e) { + cout << "Exception: " << e.what() << '\n'; + } + return 1; } diff --git a/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_evalContinuator.cpp b/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_evalContinuator.cpp index 5f6d7bd11..69cc1a3a7 100644 --- a/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_evalContinuator.cpp +++ b/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_evalContinuator.cpp @@ -50,7 +50,7 @@ using namespace std; // Indi is the typedef of the solution type like in paradisEO-eo typedef eoBit Indi; // bit string with unsigned fitness type // Neighbor is the typedef of the neighbor type, -// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) +// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // all classes from paradisEO-mo use this template type typedef moBitNeighbor Neighbor ; // bit string neighbor with unsigned fitness type @@ -59,148 +59,148 @@ typedef moBitNeighbor Neighbor ; // bit string neighbor wi //----------------------------------------------------------------------------- void main_function(int argc, char **argv) { - /* ========================================================= - * - * Parameters from parser - * - * ========================================================= */ - // more information on the input parameters: see EO tutorial lesson 3 - // but don't care at first it just read the parameters of the bit string size and the random seed. + /* ========================================================= + * + * Parameters from parser + * + * ========================================================= */ + // more information on the input parameters: see EO tutorial lesson 3 + // but don't care at first it just read the parameters of the bit string size and the random seed. - // First define a parser from the command-line arguments - eoParser parser(argc, argv); + // First define a parser from the command-line arguments + eoParser parser(argc, argv); - // For each parameter, define Parameter, read it through the parser, - // and assign the value to the variable + // For each parameter, define Parameter, read it through the parser, + // and assign the value to the variable - // random seed parameter - eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); - parser.processParam( seedParam ); - unsigned seed = seedParam.value(); + // random seed parameter + eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); + parser.processParam( seedParam ); + unsigned seed = seedParam.value(); - // length of the bit string - eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); - parser.processParam( vecSizeParam, "Representation" ); - unsigned vecSize = vecSizeParam.value(); + // length of the bit string + eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); + parser.processParam( vecSizeParam, "Representation" ); + unsigned vecSize = vecSizeParam.value(); - // maximum number of full evaluation - eoValueParam evalParam(30, "eval", "Maximum number of neighbor evaluation", 'e'); - parser.processParam( evalParam, "Representation" ); - unsigned evalMax = evalParam.value(); + // maximum number of full evaluation + eoValueParam evalParam(30, "eval", "Maximum number of neighbor evaluation", 'e'); + parser.processParam( evalParam, "Representation" ); + unsigned evalMax = evalParam.value(); - // the name of the "status" file where all actual parameter values will be saved - string str_status = parser.ProgramName() + ".status"; // default value - eoValueParam statusParam(str_status.c_str(), "status", "Status file"); - parser.processParam( statusParam, "Persistence" ); + // the name of the "status" file where all actual parameter values will be saved + string str_status = parser.ProgramName() + ".status"; // default value + eoValueParam 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 - } + // 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 - * - * ========================================================= */ + /* ========================================================= + * + * 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); + // reproducible random seed: if you don't change SEED above, + // you'll aways get the same result, NOT a random run + // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) + rng.reseed(seed); - /* ========================================================= - * - * Initialization of the solution - * - * ========================================================= */ + /* ========================================================= + * + * Initialization of the solution + * + * ========================================================= */ - // a Indi random initializer: each bit is random - // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) - eoUniformGenerator uGen; - eoInitFixedLength random(vecSize, uGen); + // a Indi random initializer: each bit is random + // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) + eoUniformGenerator uGen; + eoInitFixedLength 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 - oneMaxEval fullEval; + // the fitness function is just the number of 1 in the bit string + oneMaxEval 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 - // moFullEvalByModif neighborEval(fullEval); + // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution + // moFullEvalByModif neighborEval(fullEval); - // Incremental evaluation of the neighbor: fitness is modified by +/- 1 - moOneMaxIncrEval neighborEvalTmp; + // Incremental evaluation of the neighbor: fitness is modified by +/- 1 + moOneMaxIncrEval neighborEvalTmp; - // to count the number of neighbor evaluation - moEvalCounter neighborEval(neighborEvalTmp); + // to count the number of neighbor evaluation + moEvalCounter neighborEval(neighborEvalTmp); - /* ========================================================= - * - * the neighborhood of a solution - * - * ========================================================= */ + /* ========================================================= + * + * 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 neighborhood(vecSize); + // Exploration of the neighborhood in increasing order of the neigbor's index: + // bit-flip from bit 0 to bit (vecSize - 1) + moOrderNeighborhood neighborhood(vecSize); - /* ========================================================= - * - * the external continuators - * - * ========================================================= */ + /* ========================================================= + * + * the external continuators + * + * ========================================================= */ - moNeighborEvalContinuator continuator(neighborEval, evalMax); + moNeighborEvalContinuator continuator(neighborEval, evalMax); - /* ========================================================= - * - * the local search algorithm - * - * ========================================================= */ + /* ========================================================= + * + * the local search algorithm + * + * ========================================================= */ - moSimpleHC hc(neighborhood, fullEval, neighborEval, continuator); + moSimpleHC hc(neighborhood, fullEval, neighborEval, continuator); - /* ========================================================= - * - * executes the local search from a random solution - * - * ========================================================= */ + /* ========================================================= + * + * executes the local search from a random solution + * + * ========================================================= */ - // The current solution - Indi solution; + // The current solution + Indi solution; - // Apply random initialization - random(solution); + // Apply random initialization + random(solution); - // Evaluation of the initial solution: - // can be evaluated here, or else it will be done at the beginning of the local search - fullEval(solution); + // Evaluation of the initial solution: + // can be evaluated here, or else it will be done at the beginning of the local search + fullEval(solution); - // Output: the intial solution - std::cout << "initial: " << solution << std::endl ; + // Output: the intial solution + std::cout << "initial: " << solution << std::endl ; - // Apply the local search on the solution ! - hc(solution); + // Apply the local search on the solution ! + hc(solution); - // Output: the final solution - std::cout << "final: " << solution << std::endl ; - std::cout << "Number of neighbor evaluations during the local search: " << continuator.value() << std::endl ; + // Output: the final solution + std::cout << "final: " << solution << 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) { - try { - main_function(argc, argv); - } - catch (exception& e) { - cout << "Exception: " << e.what() << '\n'; - } - return 1; + try { + main_function(argc, argv); + } + catch (exception& e) { + cout << "Exception: " << e.what() << '\n'; + } + return 1; } diff --git a/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_firstImprHC.cpp b/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_firstImprHC.cpp index d39b96b70..db0158fce 100644 --- a/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_firstImprHC.cpp +++ b/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_firstImprHC.cpp @@ -45,7 +45,7 @@ using namespace std; // Indi is the typedef of the solution type like in paradisEO-eo typedef eoBit Indi; // bit string with unsigned fitness type // Neighbor is the typedef of the neighbor type, -// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) +// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // all classes from paradisEO-mo use this template type typedef moBitNeighbor Neighbor ; // bit string neighbor with unsigned fitness type @@ -54,131 +54,131 @@ typedef moBitNeighbor Neighbor ; // bit string neighbor wi //----------------------------------------------------------------------------- void main_function(int argc, char **argv) { - /* ========================================================= - * - * Parameters from parser - * - * ========================================================= */ - // more information on the input parameters: see EO tutorial lesson 3 - // but don't care at first it just read the parameters of the bit string size and the random seed. + /* ========================================================= + * + * Parameters from parser + * + * ========================================================= */ + // more information on the input parameters: see EO tutorial lesson 3 + // but don't care at first it just read the parameters of the bit string size and the random seed. - // First define a parser from the command-line arguments - eoParser parser(argc, argv); + // First define a parser from the command-line arguments + eoParser parser(argc, argv); - // For each parameter, define Parameter, read it through the parser, - // and assign the value to the variable + // For each parameter, define Parameter, read it through the parser, + // and assign the value to the variable - // random seed parameter - eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); - parser.processParam( seedParam ); - unsigned seed = seedParam.value(); + // random seed parameter + eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); + parser.processParam( seedParam ); + unsigned seed = seedParam.value(); - // length of the bit string - eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); - parser.processParam( vecSizeParam, "Representation" ); - unsigned vecSize = vecSizeParam.value(); + // length of the bit string + eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); + parser.processParam( vecSizeParam, "Representation" ); + unsigned vecSize = vecSizeParam.value(); - // the name of the "status" file where all actual parameter values will be saved - string str_status = parser.ProgramName() + ".status"; // default value - eoValueParam statusParam(str_status.c_str(), "status", "Status file"); - parser.processParam( statusParam, "Persistence" ); + // the name of the "status" file where all actual parameter values will be saved + string str_status = parser.ProgramName() + ".status"; // default value + eoValueParam 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 - } + // 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 - * - * ========================================================= */ + /* ========================================================= + * + * 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); + // reproducible random seed: if you don't change SEED above, + // you'll aways get the same result, NOT a random run + // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) + rng.reseed(seed); - /* ========================================================= - * - * Initialization of the solution - * - * ========================================================= */ + /* ========================================================= + * + * Initialization of the solution + * + * ========================================================= */ - // a Indi random initializer: each bit is random - // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) - eoUniformGenerator uGen; - eoInitFixedLength random(vecSize, uGen); + // a Indi random initializer: each bit is random + // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) + eoUniformGenerator uGen; + eoInitFixedLength 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 - oneMaxEval fullEval; + // the fitness function is just the number of 1 in the bit string + oneMaxEval 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 - // moFullEvalByModif neighborEval(fullEval); + // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution + // moFullEvalByModif neighborEval(fullEval); - // Incremental evaluation of the neighbor: fitness is modified by +/- 1 - moOneMaxIncrEval neighborEval; + // Incremental evaluation of the neighbor: fitness is modified by +/- 1 + moOneMaxIncrEval neighborEval; - /* ========================================================= - * - * the neighborhood of a solution - * - * ========================================================= */ + /* ========================================================= + * + * the neighborhood of a solution + * + * ========================================================= */ - // Exploration of the neighborhood in random order of the neigbor's index: - // each neighbor is visited only once - moRndWithoutReplNeighborhood neighborhood(vecSize); + // Exploration of the neighborhood in random order of the neigbor's index: + // each neighbor is visited only once + moRndWithoutReplNeighborhood neighborhood(vecSize); - /* ========================================================= - * - * the local search algorithm - * - * ========================================================= */ + /* ========================================================= + * + * the local search algorithm + * + * ========================================================= */ - moFirstImprHC hc(neighborhood, fullEval, neighborEval); + moFirstImprHC hc(neighborhood, fullEval, neighborEval); - /* ========================================================= - * - * executes the local search from a random solution - * - * ========================================================= */ + /* ========================================================= + * + * executes the local search from a random solution + * + * ========================================================= */ - // The current solution - Indi solution; + // The current solution + Indi solution; - // Apply random initialization - random(solution); + // Apply random initialization + random(solution); - // Evaluation of the initial solution: - // can be evaluated here, or else it will be done at the beginning of the local search - fullEval(solution); + // Evaluation of the initial solution: + // can be evaluated here, or else it will be done at the beginning of the local search + fullEval(solution); - // Output: the intial solution - std::cout << "initial: " << solution << std::endl ; + // Output: the intial solution + std::cout << "initial: " << solution << std::endl ; - // Apply the local search on the solution ! - hc(solution); + // Apply the local search on the solution ! + hc(solution); - // Output: the final solution - std::cout << "final: " << solution << std::endl ; + // Output: the final solution + std::cout << "final: " << solution << std::endl ; } @@ -186,11 +186,11 @@ void main_function(int argc, char **argv) int main(int argc, char **argv) { - try { - main_function(argc, argv); - } - catch (exception& e) { - cout << "Exception: " << e.what() << '\n'; - } - return 1; + try { + main_function(argc, argv); + } + catch (exception& e) { + cout << "Exception: " << e.what() << '\n'; + } + return 1; } diff --git a/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_fitContinuator.cpp b/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_fitContinuator.cpp index a009d4247..a72ca7963 100644 --- a/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_fitContinuator.cpp +++ b/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_fitContinuator.cpp @@ -49,7 +49,7 @@ using namespace std; // Indi is the typedef of the solution type like in paradisEO-eo typedef eoBit Indi; // bit string with unsigned fitness type // Neighbor is the typedef of the neighbor type, -// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) +// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // all classes from paradisEO-mo use this template type typedef moBitNeighbor Neighbor ; // bit string neighbor with unsigned fitness type @@ -58,144 +58,144 @@ typedef moBitNeighbor Neighbor ; // bit string neighbor wi //----------------------------------------------------------------------------- void main_function(int argc, char **argv) { - /* ========================================================= - * - * Parameters from parser - * - * ========================================================= */ - // more information on the input parameters: see EO tutorial lesson 3 - // but don't care at first it just read the parameters of the bit string size and the random seed. + /* ========================================================= + * + * Parameters from parser + * + * ========================================================= */ + // more information on the input parameters: see EO tutorial lesson 3 + // but don't care at first it just read the parameters of the bit string size and the random seed. - // First define a parser from the command-line arguments - eoParser parser(argc, argv); + // First define a parser from the command-line arguments + eoParser parser(argc, argv); - // For each parameter, define Parameter, read it through the parser, - // and assign the value to the variable + // For each parameter, define Parameter, read it through the parser, + // and assign the value to the variable - // random seed parameter - eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); - parser.processParam( seedParam ); - unsigned seed = seedParam.value(); + // random seed parameter + eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); + parser.processParam( seedParam ); + unsigned seed = seedParam.value(); - // length of the bit string - eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); - parser.processParam( vecSizeParam, "Representation" ); - unsigned vecSize = vecSizeParam.value(); + // length of the bit string + eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); + parser.processParam( vecSizeParam, "Representation" ); + unsigned vecSize = vecSizeParam.value(); - // maximum fitness to reach - eoValueParam fitParam(16, "fitness", "Maximum fitness value to reach", 'f'); - parser.processParam( fitParam, "Representation" ); - unsigned fitnessMax = fitParam.value(); + // maximum fitness to reach + eoValueParam fitParam(16, "fitness", "Maximum fitness value to reach", 'f'); + parser.processParam( fitParam, "Representation" ); + unsigned fitnessMax = fitParam.value(); - // the name of the "status" file where all actual parameter values will be saved - string str_status = parser.ProgramName() + ".status"; // default value - eoValueParam statusParam(str_status.c_str(), "status", "Status file"); - parser.processParam( statusParam, "Persistence" ); + // the name of the "status" file where all actual parameter values will be saved + string str_status = parser.ProgramName() + ".status"; // default value + eoValueParam 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 - } + // 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 - * - * ========================================================= */ + /* ========================================================= + * + * 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); + // reproducible random seed: if you don't change SEED above, + // you'll aways get the same result, NOT a random run + // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) + rng.reseed(seed); - /* ========================================================= - * - * Initialization of the solution - * - * ========================================================= */ + /* ========================================================= + * + * Initialization of the solution + * + * ========================================================= */ - // a Indi random initializer: each bit is random - // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) - eoUniformGenerator uGen; - eoInitFixedLength random(vecSize, uGen); + // a Indi random initializer: each bit is random + // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) + eoUniformGenerator uGen; + eoInitFixedLength 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 - oneMaxEval fullEval; + // the fitness function is just the number of 1 in the bit string + oneMaxEval 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 - // moFullEvalByModif neighborEval(fullEval); + // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution + // moFullEvalByModif neighborEval(fullEval); - // Incremental evaluation of the neighbor: fitness is modified by +/- 1 - moOneMaxIncrEval neighborEval; + // Incremental evaluation of the neighbor: fitness is modified by +/- 1 + moOneMaxIncrEval neighborEval; - /* ========================================================= - * - * the neighborhood of a solution - * - * ========================================================= */ + /* ========================================================= + * + * 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 neighborhood(vecSize); + // Exploration of the neighborhood in increasing order of the neigbor's index: + // bit-flip from bit 0 to bit (vecSize - 1) + moOrderNeighborhood neighborhood(vecSize); - /* ========================================================= - * - * the external continuators - * - * ========================================================= */ + /* ========================================================= + * + * the external continuators + * + * ========================================================= */ - moFitContinuator continuator(fitnessMax); + moFitContinuator continuator(fitnessMax); - /* ========================================================= - * - * the local search algorithm - * - * ========================================================= */ + /* ========================================================= + * + * the local search algorithm + * + * ========================================================= */ - moSimpleHC hc(neighborhood, fullEval, neighborEval, continuator); + moSimpleHC hc(neighborhood, fullEval, neighborEval, continuator); - /* ========================================================= - * - * executes the local search from a random solution - * - * ========================================================= */ + /* ========================================================= + * + * executes the local search from a random solution + * + * ========================================================= */ - // The current solution - Indi solution; + // The current solution + Indi solution; - // Apply random initialization - random(solution); + // Apply random initialization + random(solution); - // Evaluation of the initial solution: - // can be evaluated here, or else it will be done at the beginning of the local search - fullEval(solution); + // Evaluation of the initial solution: + // can be evaluated here, or else it will be done at the beginning of the local search + fullEval(solution); - // Output: the intial solution - std::cout << "initial: " << solution << std::endl ; + // Output: the intial solution + std::cout << "initial: " << solution << std::endl ; - // Apply the local search on the solution ! - hc(solution); + // Apply the local search on the solution ! + hc(solution); - // Output: the final solution - std::cout << "final: " << solution << std::endl ; + // Output: the final solution + std::cout << "final: " << solution << std::endl ; } @@ -203,11 +203,11 @@ void main_function(int argc, char **argv) int main(int argc, char **argv) { - try { - main_function(argc, argv); - } - catch (exception& e) { - cout << "Exception: " << e.what() << '\n'; - } - return 1; + try { + main_function(argc, argv); + } + catch (exception& e) { + cout << "Exception: " << e.what() << '\n'; + } + return 1; } diff --git a/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_fullEvalContinuator.cpp b/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_fullEvalContinuator.cpp index 5996eaa9e..34ec620e0 100644 --- a/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_fullEvalContinuator.cpp +++ b/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_fullEvalContinuator.cpp @@ -50,7 +50,7 @@ using namespace std; // Indi is the typedef of the solution type like in paradisEO-eo typedef eoBit Indi; // bit string with unsigned fitness type // Neighbor is the typedef of the neighbor type, -// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) +// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // all classes from paradisEO-mo use this template type typedef moBitNeighbor Neighbor ; // bit string neighbor with unsigned fitness type @@ -59,148 +59,148 @@ typedef moBitNeighbor Neighbor ; // bit string neighbor wi //----------------------------------------------------------------------------- void main_function(int argc, char **argv) { - /* ========================================================= - * - * Parameters from parser - * - * ========================================================= */ - // more information on the input parameters: see EO tutorial lesson 3 - // but don't care at first it just read the parameters of the bit string size and the random seed. + /* ========================================================= + * + * Parameters from parser + * + * ========================================================= */ + // more information on the input parameters: see EO tutorial lesson 3 + // but don't care at first it just read the parameters of the bit string size and the random seed. - // First define a parser from the command-line arguments - eoParser parser(argc, argv); + // First define a parser from the command-line arguments + eoParser parser(argc, argv); - // For each parameter, define Parameter, read it through the parser, - // and assign the value to the variable + // For each parameter, define Parameter, read it through the parser, + // and assign the value to the variable - // random seed parameter - eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); - parser.processParam( seedParam ); - unsigned seed = seedParam.value(); + // random seed parameter + eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); + parser.processParam( seedParam ); + unsigned seed = seedParam.value(); - // length of the bit string - eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); - parser.processParam( vecSizeParam, "Representation" ); - unsigned vecSize = vecSizeParam.value(); + // length of the bit string + eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); + parser.processParam( vecSizeParam, "Representation" ); + unsigned vecSize = vecSizeParam.value(); - // maximum number of full evaluation - eoValueParam evalParam(2, "fulleval", "Maximum number of full evaluation", 'e'); - parser.processParam( evalParam, "Representation" ); - unsigned fullevalMax = evalParam.value(); + // maximum number of full evaluation + eoValueParam evalParam(2, "fulleval", "Maximum number of full evaluation", 'e'); + parser.processParam( evalParam, "Representation" ); + unsigned fullevalMax = evalParam.value(); - // the name of the "status" file where all actual parameter values will be saved - string str_status = parser.ProgramName() + ".status"; // default value - eoValueParam statusParam(str_status.c_str(), "status", "Status file"); - parser.processParam( statusParam, "Persistence" ); + // the name of the "status" file where all actual parameter values will be saved + string str_status = parser.ProgramName() + ".status"; // default value + eoValueParam 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 - } + // 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 - * - * ========================================================= */ + /* ========================================================= + * + * 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); + // reproducible random seed: if you don't change SEED above, + // you'll aways get the same result, NOT a random run + // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) + rng.reseed(seed); - /* ========================================================= - * - * Initialization of the solution - * - * ========================================================= */ + /* ========================================================= + * + * Initialization of the solution + * + * ========================================================= */ - // a Indi random initializer: each bit is random - // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) - eoUniformGenerator uGen; - eoInitFixedLength random(vecSize, uGen); + // a Indi random initializer: each bit is random + // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) + eoUniformGenerator uGen; + eoInitFixedLength 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 - oneMaxEval fullEvalTmp; + // the fitness function is just the number of 1 in the bit string + oneMaxEval fullEvalTmp; - // to count the number of full evaluation - eoEvalFuncCounter fullEval(fullEvalTmp); + // to count the number of full evaluation + eoEvalFuncCounter 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 - // moFullEvalByModif neighborEval(fullEval); + // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution + // moFullEvalByModif neighborEval(fullEval); - // Incremental evaluation of the neighbor: fitness is modified by +/- 1 - moOneMaxIncrEval neighborEval; + // Incremental evaluation of the neighbor: fitness is modified by +/- 1 + moOneMaxIncrEval neighborEval; - /* ========================================================= - * - * the neighborhood of a solution - * - * ========================================================= */ + /* ========================================================= + * + * 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 neighborhood(vecSize); + // Exploration of the neighborhood in increasing order of the neigbor's index: + // bit-flip from bit 0 to bit (vecSize - 1) + moOrderNeighborhood neighborhood(vecSize); - /* ========================================================= - * - * the external continuators - * - * ========================================================= */ + /* ========================================================= + * + * the external continuators + * + * ========================================================= */ - moFullEvalContinuator continuator(fullEval, fullevalMax); + moFullEvalContinuator continuator(fullEval, fullevalMax); - /* ========================================================= - * - * the local search algorithm - * - * ========================================================= */ + /* ========================================================= + * + * the local search algorithm + * + * ========================================================= */ - moSimpleHC hc(neighborhood, fullEval, neighborEval, continuator); + moSimpleHC hc(neighborhood, fullEval, neighborEval, continuator); - /* ========================================================= - * - * executes the local search from a random solution - * - * ========================================================= */ + /* ========================================================= + * + * executes the local search from a random solution + * + * ========================================================= */ - // The current solution - Indi solution; + // The current solution + Indi solution; - // Apply random initialization - random(solution); + // Apply random initialization + random(solution); - // Evaluation of the initial solution: - // can be evaluated here, or else it will be done at the beginning of the local search - fullEval(solution); + // Evaluation of the initial solution: + // can be evaluated here, or else it will be done at the beginning of the local search + fullEval(solution); - // Output: the intial solution - std::cout << "initial: " << solution << std::endl ; + // Output: the intial solution + std::cout << "initial: " << solution << std::endl ; - // Apply the local search on the solution ! - hc(solution); + // Apply the local search on the solution ! + hc(solution); - // Output: the final solution - std::cout << "final: " << solution << std::endl ; - std::cout << "Number of full evaluations during the local search: " << continuator.value() << std::endl ; + // Output: the final solution + std::cout << "final: " << solution << 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) { - try { - main_function(argc, argv); - } - catch (exception& e) { - cout << "Exception: " << e.what() << '\n'; - } - return 1; + try { + main_function(argc, argv); + } + catch (exception& e) { + cout << "Exception: " << e.what() << '\n'; + } + return 1; } diff --git a/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_iterContinuator.cpp b/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_iterContinuator.cpp index 158694fe1..01671a8b7 100644 --- a/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_iterContinuator.cpp +++ b/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_iterContinuator.cpp @@ -49,7 +49,7 @@ using namespace std; // Indi is the typedef of the solution type like in paradisEO-eo typedef eoBit Indi; // bit string with unsigned fitness type // Neighbor is the typedef of the neighbor type, -// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) +// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // all classes from paradisEO-mo use this template type typedef moBitNeighbor Neighbor ; // bit string neighbor with unsigned fitness type @@ -58,146 +58,146 @@ typedef moBitNeighbor Neighbor ; // bit string neighbor wi //----------------------------------------------------------------------------- void main_function(int argc, char **argv) { - /* ========================================================= - * - * Parameters from parser - * - * ========================================================= */ - // more information on the input parameters: see EO tutorial lesson 3 - // but don't care at first it just read the parameters of the bit string size and the random seed. + /* ========================================================= + * + * Parameters from parser + * + * ========================================================= */ + // more information on the input parameters: see EO tutorial lesson 3 + // but don't care at first it just read the parameters of the bit string size and the random seed. - // First define a parser from the command-line arguments - eoParser parser(argc, argv); + // First define a parser from the command-line arguments + eoParser parser(argc, argv); - // For each parameter, define Parameter, read it through the parser, - // and assign the value to the variable + // For each parameter, define Parameter, read it through the parser, + // and assign the value to the variable - // random seed parameter - eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); - parser.processParam( seedParam ); - unsigned seed = seedParam.value(); + // random seed parameter + eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); + parser.processParam( seedParam ); + unsigned seed = seedParam.value(); - // length of the bit string - eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); - parser.processParam( vecSizeParam, "Representation" ); - unsigned vecSize = vecSizeParam.value(); + // length of the bit string + eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); + parser.processParam( vecSizeParam, "Representation" ); + unsigned vecSize = vecSizeParam.value(); - // maximum number of iterations - eoValueParam iterParam(10, "iter", "Maximum number of iterations", 'i'); - parser.processParam( iterParam, "Representation" ); - unsigned iterMax = iterParam.value(); + // maximum number of iterations + eoValueParam iterParam(10, "iter", "Maximum number of iterations", 'i'); + parser.processParam( iterParam, "Representation" ); + unsigned iterMax = iterParam.value(); - // the name of the "status" file where all actual parameter values will be saved - string str_status = parser.ProgramName() + ".status"; // default value - eoValueParam statusParam(str_status.c_str(), "status", "Status file"); - parser.processParam( statusParam, "Persistence" ); + // the name of the "status" file where all actual parameter values will be saved + string str_status = parser.ProgramName() + ".status"; // default value + eoValueParam 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 - } + // 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 - * - * ========================================================= */ + /* ========================================================= + * + * 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); + // reproducible random seed: if you don't change SEED above, + // you'll aways get the same result, NOT a random run + // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) + rng.reseed(seed); - /* ========================================================= - * - * Initialization of the solution - * - * ========================================================= */ + /* ========================================================= + * + * Initialization of the solution + * + * ========================================================= */ - // a Indi random initializer: each bit is random - // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) - eoUniformGenerator uGen; - eoInitFixedLength random(vecSize, uGen); + // a Indi random initializer: each bit is random + // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) + eoUniformGenerator uGen; + eoInitFixedLength 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 - oneMaxEval fullEval; + // the fitness function is just the number of 1 in the bit string + oneMaxEval 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 - // moFullEvalByModif neighborEval(fullEval); + // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution + // moFullEvalByModif neighborEval(fullEval); - // Incremental evaluation of the neighbor: fitness is modified by +/- 1 - moOneMaxIncrEval neighborEval; + // Incremental evaluation of the neighbor: fitness is modified by +/- 1 + moOneMaxIncrEval neighborEval; - /* ========================================================= - * - * the neighborhood of a solution - * - * ========================================================= */ + /* ========================================================= + * + * 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 neighborhood(vecSize); + // Exploration of the neighborhood in increasing order of the neigbor's index: + // bit-flip from bit 0 to bit (vecSize - 1) + moOrderNeighborhood neighborhood(vecSize); - /* ========================================================= - * - * the external continuators - * - * ========================================================= */ + /* ========================================================= + * + * the external continuators + * + * ========================================================= */ - moIterContinuator continuator(iterMax); + moIterContinuator continuator(iterMax); - /* ========================================================= - * - * the local search algorithm - * - * ========================================================= */ + /* ========================================================= + * + * the local search algorithm + * + * ========================================================= */ - moSimpleHC hc(neighborhood, fullEval, neighborEval, continuator); + moSimpleHC hc(neighborhood, fullEval, neighborEval, continuator); - /* ========================================================= - * - * executes the local search from a random solution - * - * ========================================================= */ + /* ========================================================= + * + * executes the local search from a random solution + * + * ========================================================= */ - // The current solution - Indi solution; + // The current solution + Indi solution; - // Apply random initialization - random(solution); + // Apply random initialization + random(solution); - // Evaluation of the initial solution: - // can be evaluated here, or else it will be done at the beginning of the local search - fullEval(solution); + // Evaluation of the initial solution: + // can be evaluated here, or else it will be done at the beginning of the local search + fullEval(solution); - // Output: the intial solution - std::cout << "initial: " << solution << std::endl ; + // Output: the intial solution + std::cout << "initial: " << solution << std::endl ; - // Apply the local search on the solution ! - hc(solution); + // Apply the local search on the solution ! + hc(solution); - // Output: the final solution - std::cout << "final: " << solution << std::endl ; + // Output: the final solution + 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) { - try { - main_function(argc, argv); - } - catch (exception& e) { - cout << "Exception: " << e.what() << '\n'; - } - return 1; + try { + main_function(argc, argv); + } + catch (exception& e) { + cout << "Exception: " << e.what() << '\n'; + } + return 1; } diff --git a/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_neutralHC.cpp b/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_neutralHC.cpp index d16d4d168..f00439209 100644 --- a/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_neutralHC.cpp +++ b/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_neutralHC.cpp @@ -45,7 +45,7 @@ using namespace std; // Indi is the typedef of the solution type like in paradisEO-eo typedef eoBit Indi; // bit string with unsigned fitness type // Neighbor is the typedef of the neighbor type, -// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) +// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // all classes from paradisEO-mo use this template type typedef moBitNeighbor Neighbor ; // bit string neighbor with unsigned fitness type @@ -54,135 +54,135 @@ typedef moBitNeighbor Neighbor ; // bit string neighbor wi //----------------------------------------------------------------------------- void main_function(int argc, char **argv) { - /* ========================================================= - * - * Parameters from parser - * - * ========================================================= */ - // more information on the input parameters: see EO tutorial lesson 3 - // but don't care at first it just read the parameters of the bit string size and the random seed. + /* ========================================================= + * + * Parameters from parser + * + * ========================================================= */ + // more information on the input parameters: see EO tutorial lesson 3 + // but don't care at first it just read the parameters of the bit string size and the random seed. - // First define a parser from the command-line arguments - eoParser parser(argc, argv); + // First define a parser from the command-line arguments + eoParser parser(argc, argv); - // For each parameter, define Parameter, read it through the parser, - // and assign the value to the variable + // For each parameter, define Parameter, read it through the parser, + // and assign the value to the variable - // random seed parameter - eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); - parser.processParam( seedParam ); - unsigned seed = seedParam.value(); + // random seed parameter + eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); + parser.processParam( seedParam ); + unsigned seed = seedParam.value(); - // length of the bit string - eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); - parser.processParam( vecSizeParam, "Representation" ); - unsigned vecSize = vecSizeParam.value(); + // length of the bit string + eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); + parser.processParam( vecSizeParam, "Representation" ); + unsigned vecSize = vecSizeParam.value(); - eoValueParam stepParam(10, "nbStepMax", "Number of steps of the random walk", 'n'); - parser.processParam( stepParam, "Representation" ); - unsigned nbStepMax = stepParam.value(); - - // the name of the "status" file where all actual parameter values will be saved - string str_status = parser.ProgramName() + ".status"; // default value - eoValueParam statusParam(str_status.c_str(), "status", "Status file"); - parser.processParam( statusParam, "Persistence" ); + eoValueParam stepParam(10, "nbStepMax", "Number of steps of the random walk", 'n'); + parser.processParam( stepParam, "Representation" ); + unsigned nbStepMax = stepParam.value(); - // 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 - } + // the name of the "status" file where all actual parameter values will be saved + string str_status = parser.ProgramName() + ".status"; // default value + eoValueParam statusParam(str_status.c_str(), "status", "Status file"); + parser.processParam( statusParam, "Persistence" ); - /* ========================================================= - * - * Random seed - * - * ========================================================= */ + // 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 + } - // 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); + /* ========================================================= + * + * Random seed + * + * ========================================================= */ - /* ========================================================= - * - * Initialization of the solution - * - * ========================================================= */ + // 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); - // a Indi random initializer: each bit is random - // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) - eoUniformGenerator uGen; - eoInitFixedLength random(vecSize, uGen); + /* ========================================================= + * + * Initialization of the solution + * + * ========================================================= */ - /* ========================================================= - * - * Eval fitness function (full evaluation) - * - * ========================================================= */ + // a Indi random initializer: each bit is random + // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) + eoUniformGenerator uGen; + eoInitFixedLength random(vecSize, uGen); - // the fitness function is just the number of 1 in the bit string - oneMaxEval fullEval; + /* ========================================================= + * + * Eval fitness function (full evaluation) + * + * ========================================================= */ - /* ========================================================= - * - * evaluation of a neighbor solution - * - * ========================================================= */ + // the fitness function is just the number of 1 in the bit string + oneMaxEval fullEval; - // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution - // moFullEvalByModif neighborEval(fullEval); + /* ========================================================= + * + * evaluation of a neighbor solution + * + * ========================================================= */ - // Incremental evaluation of the neighbor: fitness is modified by +/- 1 - moOneMaxIncrEval neighborEval; + // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution + // moFullEvalByModif neighborEval(fullEval); - /* ========================================================= - * - * the neighborhood of a solution - * - * ========================================================= */ + // Incremental evaluation of the neighbor: fitness is modified by +/- 1 + moOneMaxIncrEval neighborEval; - // Exploration of the neighborhood in increasing order of the neigbor's index: - // bit-flip from bit 0 to bit (vecSize - 1) - moOrderNeighborhood neighborhood(vecSize); + /* ========================================================= + * + * the neighborhood of a solution + * + * ========================================================= */ - /* ========================================================= - * - * the local search algorithm - * - * ========================================================= */ + // Exploration of the neighborhood in increasing order of the neigbor's index: + // bit-flip from bit 0 to bit (vecSize - 1) + moOrderNeighborhood neighborhood(vecSize); - moNeutralHC hc(neighborhood, fullEval, neighborEval, nbStepMax); + /* ========================================================= + * + * the local search algorithm + * + * ========================================================= */ - /* ========================================================= - * - * executes the local search from a random solution - * - * ========================================================= */ + moNeutralHC hc(neighborhood, fullEval, neighborEval, nbStepMax); - // The current solution - Indi solution; + /* ========================================================= + * + * executes the local search from a random solution + * + * ========================================================= */ - // Apply random initialization - random(solution); + // The current solution + Indi solution; - // Evaluation of the initial solution: - // can be evaluated here, or else it will be done at the beginning of the local search - fullEval(solution); + // Apply random initialization + random(solution); - // Output: the intial solution - std::cout << "initial: " << solution << std::endl ; + // Evaluation of the initial solution: + // 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 ! - hc(solution); + // Output: the intial solution + std::cout << "initial: " << solution << std::endl ; - // Output: the final solution - std::cout << "final: " << solution << std::endl ; + // Apply the local search on the solution ! + 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) { - try { - main_function(argc, argv); - } - catch (exception& e) { - cout << "Exception: " << e.what() << '\n'; - } - return 1; + try { + main_function(argc, argv); + } + catch (exception& e) { + cout << "Exception: " << e.what() << '\n'; + } + return 1; } diff --git a/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_randomBestHC.cpp b/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_randomBestHC.cpp index afdccb0af..868033b31 100644 --- a/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_randomBestHC.cpp +++ b/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_randomBestHC.cpp @@ -45,7 +45,7 @@ using namespace std; // Indi is the typedef of the solution type like in paradisEO-eo typedef eoBit Indi; // bit string with unsigned fitness type // Neighbor is the typedef of the neighbor type, -// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) +// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // all classes from paradisEO-mo use this template type typedef moBitNeighbor Neighbor ; // bit string neighbor with unsigned fitness type @@ -54,131 +54,131 @@ typedef moBitNeighbor Neighbor ; // bit string neighbor wi //----------------------------------------------------------------------------- void main_function(int argc, char **argv) { - /* ========================================================= - * - * Parameters from parser - * - * ========================================================= */ - // more information on the input parameters: see EO tutorial lesson 3 - // but don't care at first it just read the parameters of the bit string size and the random seed. + /* ========================================================= + * + * Parameters from parser + * + * ========================================================= */ + // more information on the input parameters: see EO tutorial lesson 3 + // but don't care at first it just read the parameters of the bit string size and the random seed. - // First define a parser from the command-line arguments - eoParser parser(argc, argv); + // First define a parser from the command-line arguments + eoParser parser(argc, argv); - // For each parameter, define Parameter, read it through the parser, - // and assign the value to the variable + // For each parameter, define Parameter, read it through the parser, + // and assign the value to the variable - // random seed parameter - eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); - parser.processParam( seedParam ); - unsigned seed = seedParam.value(); + // random seed parameter + eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); + parser.processParam( seedParam ); + unsigned seed = seedParam.value(); - // length of the bit string - eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); - parser.processParam( vecSizeParam, "Representation" ); - unsigned vecSize = vecSizeParam.value(); + // length of the bit string + eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); + parser.processParam( vecSizeParam, "Representation" ); + unsigned vecSize = vecSizeParam.value(); - // the name of the "status" file where all actual parameter values will be saved - string str_status = parser.ProgramName() + ".status"; // default value - eoValueParam statusParam(str_status.c_str(), "status", "Status file"); - parser.processParam( statusParam, "Persistence" ); + // the name of the "status" file where all actual parameter values will be saved + string str_status = parser.ProgramName() + ".status"; // default value + eoValueParam 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 - } + // 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 - * - * ========================================================= */ + /* ========================================================= + * + * 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); + // reproducible random seed: if you don't change SEED above, + // you'll aways get the same result, NOT a random run + // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) + rng.reseed(seed); - /* ========================================================= - * - * Initialization of the solution - * - * ========================================================= */ + /* ========================================================= + * + * Initialization of the solution + * + * ========================================================= */ - // a Indi random initializer: each bit is random - // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) - eoUniformGenerator uGen; - eoInitFixedLength random(vecSize, uGen); + // a Indi random initializer: each bit is random + // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) + eoUniformGenerator uGen; + eoInitFixedLength 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 - oneMaxEval fullEval; + // the fitness function is just the number of 1 in the bit string + oneMaxEval 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 - // moFullEvalByModif neighborEval(fullEval); + // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution + // moFullEvalByModif neighborEval(fullEval); - // Incremental evaluation of the neighbor: fitness is modified by +/- 1 - moOneMaxIncrEval neighborEval; + // Incremental evaluation of the neighbor: fitness is modified by +/- 1 + moOneMaxIncrEval neighborEval; - /* ========================================================= - * - * the neighborhood of a solution - * - * ========================================================= */ + /* ========================================================= + * + * 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 neighborhood(vecSize); + // Exploration of the neighborhood in increasing order of the neigbor's index: + // bit-flip from bit 0 to bit (vecSize - 1) + moOrderNeighborhood neighborhood(vecSize); - /* ========================================================= - * - * the local search algorithm - * - * ========================================================= */ + /* ========================================================= + * + * the local search algorithm + * + * ========================================================= */ - moRandomBestHC hc(neighborhood, fullEval, neighborEval); + moRandomBestHC hc(neighborhood, fullEval, neighborEval); - /* ========================================================= - * - * executes the local search from a random solution - * - * ========================================================= */ + /* ========================================================= + * + * executes the local search from a random solution + * + * ========================================================= */ - // The current solution - Indi solution; + // The current solution + Indi solution; - // Apply random initialization - random(solution); + // Apply random initialization + random(solution); - // Evaluation of the initial solution: - // can be evaluated here, or else it will be done at the beginning of the local search - fullEval(solution); + // Evaluation of the initial solution: + // can be evaluated here, or else it will be done at the beginning of the local search + fullEval(solution); - // Output: the intial solution - std::cout << "initial: " << solution << std::endl ; + // Output: the intial solution + std::cout << "initial: " << solution << std::endl ; - // Apply the local search on the solution ! - hc(solution); + // Apply the local search on the solution ! + hc(solution); - // Output: the final solution - std::cout << "final: " << solution << std::endl ; + // Output: the final solution + std::cout << "final: " << solution << std::endl ; } @@ -186,11 +186,11 @@ void main_function(int argc, char **argv) int main(int argc, char **argv) { - try { - main_function(argc, argv); - } - catch (exception& e) { - cout << "Exception: " << e.what() << '\n'; - } - return 1; + try { + main_function(argc, argv); + } + catch (exception& e) { + cout << "Exception: " << e.what() << '\n'; + } + return 1; } diff --git a/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_simpleHC.cpp b/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_simpleHC.cpp index 9e5bff196..199b0556c 100644 --- a/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_simpleHC.cpp +++ b/trunk/paradiseo-mo/tutorial/Lesson1/lesson1_simpleHC.cpp @@ -45,7 +45,7 @@ using namespace std; // Indi is the typedef of the solution type like in paradisEO-eo typedef eoBit Indi; // bit string with unsigned fitness type // Neighbor is the typedef of the neighbor type, -// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) +// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // all classes from paradisEO-mo use this template type typedef moBitNeighbor Neighbor ; // bit string neighbor with unsigned fitness type @@ -54,131 +54,131 @@ typedef moBitNeighbor Neighbor ; // bit string neighbor wi //----------------------------------------------------------------------------- void main_function(int argc, char **argv) { - /* ========================================================= - * - * Parameters from parser - * - * ========================================================= */ - // more information on the input parameters: see EO tutorial lesson 3 - // but don't care at first it just read the parameters of the bit string size and the random seed. + /* ========================================================= + * + * Parameters from parser + * + * ========================================================= */ + // more information on the input parameters: see EO tutorial lesson 3 + // but don't care at first it just read the parameters of the bit string size and the random seed. - // First define a parser from the command-line arguments - eoParser parser(argc, argv); + // First define a parser from the command-line arguments + eoParser parser(argc, argv); - // For each parameter, define Parameter, read it through the parser, - // and assign the value to the variable + // For each parameter, define Parameter, read it through the parser, + // and assign the value to the variable - // random seed parameter - eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); - parser.processParam( seedParam ); - unsigned seed = seedParam.value(); + // random seed parameter + eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); + parser.processParam( seedParam ); + unsigned seed = seedParam.value(); - // length of the bit string - eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); - parser.processParam( vecSizeParam, "Representation" ); - unsigned vecSize = vecSizeParam.value(); + // length of the bit string + eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); + parser.processParam( vecSizeParam, "Representation" ); + unsigned vecSize = vecSizeParam.value(); - // the name of the "status" file where all actual parameter values will be saved - string str_status = parser.ProgramName() + ".status"; // default value - eoValueParam statusParam(str_status.c_str(), "status", "Status file"); - parser.processParam( statusParam, "Persistence" ); + // the name of the "status" file where all actual parameter values will be saved + string str_status = parser.ProgramName() + ".status"; // default value + eoValueParam 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 - } + // 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 - * - * ========================================================= */ + /* ========================================================= + * + * 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); + // reproducible random seed: if you don't change SEED above, + // you'll aways get the same result, NOT a random run + // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) + rng.reseed(seed); - /* ========================================================= - * - * Initialization of the solution - * - * ========================================================= */ + /* ========================================================= + * + * Initialization of the solution + * + * ========================================================= */ - // a Indi random initializer: each bit is random - // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) - eoUniformGenerator uGen; - eoInitFixedLength random(vecSize, uGen); + // a Indi random initializer: each bit is random + // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) + eoUniformGenerator uGen; + eoInitFixedLength 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 - oneMaxEval fullEval; + // the fitness function is just the number of 1 in the bit string + oneMaxEval 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 - // moFullEvalByModif neighborEval(fullEval); + // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution + // moFullEvalByModif neighborEval(fullEval); - // Incremental evaluation of the neighbor: fitness is modified by +/- 1 - moOneMaxIncrEval neighborEval; + // Incremental evaluation of the neighbor: fitness is modified by +/- 1 + moOneMaxIncrEval neighborEval; - /* ========================================================= - * - * the neighborhood of a solution - * - * ========================================================= */ + /* ========================================================= + * + * 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 neighborhood(vecSize); + // Exploration of the neighborhood in increasing order of the neigbor's index: + // bit-flip from bit 0 to bit (vecSize - 1) + moOrderNeighborhood neighborhood(vecSize); - /* ========================================================= - * - * the local search algorithm - * - * ========================================================= */ + /* ========================================================= + * + * the local search algorithm + * + * ========================================================= */ - moSimpleHC hc(neighborhood, fullEval, neighborEval); + moSimpleHC hc(neighborhood, fullEval, neighborEval); - /* ========================================================= - * - * executes the local search from a random solution - * - * ========================================================= */ + /* ========================================================= + * + * executes the local search from a random solution + * + * ========================================================= */ - // The current solution - Indi solution; + // The current solution + Indi solution; - // Apply random initialization - random(solution); + // Apply random initialization + random(solution); - // Evaluation of the initial solution: - // can be evaluated here, or else it will be done at the beginning of the local search - fullEval(solution); + // Evaluation of the initial solution: + // can be evaluated here, or else it will be done at the beginning of the local search + fullEval(solution); - // Output: the intial solution - std::cout << "initial: " << solution << std::endl ; + // Output: the intial solution + std::cout << "initial: " << solution << std::endl ; - // Apply the local search on the solution ! - hc(solution); + // Apply the local search on the solution ! + hc(solution); - // Output: the final solution - std::cout << "final: " << solution << std::endl ; + // Output: the final solution + std::cout << "final: " << solution << std::endl ; } @@ -186,11 +186,11 @@ void main_function(int argc, char **argv) int main(int argc, char **argv) { - try { - main_function(argc, argv); - } - catch (exception& e) { - cout << "Exception: " << e.what() << '\n'; - } - return 1; + try { + main_function(argc, argv); + } + catch (exception& e) { + cout << "Exception: " << e.what() << '\n'; + } + return 1; } diff --git a/trunk/paradiseo-mo/tutorial/Lesson2/testNeighborhood.cpp b/trunk/paradiseo-mo/tutorial/Lesson2/testNeighborhood.cpp index 8b771d769..b20c3fc80 100644 --- a/trunk/paradiseo-mo/tutorial/Lesson2/testNeighborhood.cpp +++ b/trunk/paradiseo-mo/tutorial/Lesson2/testNeighborhood.cpp @@ -155,7 +155,7 @@ void main_function(int argc, char **argv) fullEval(solution); - std::cout << "Initial Solution:" << std::endl; + std::cout << "Initial Solution:" << 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 << "Neighbors List: (Neighbor -> fitness)" << std::endl; - swapNeighbor n1; + swapNeighbor n1; swapNH.init(solution, n1); swapEval(solution,n1); n1.print(); - while(swapNH.cont(solution)){ - swapNH.next(solution, n1); + while (swapNH.cont(solution)) { + swapNH.next(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 << "Neighbors List: (key: Neighbor -> fitness)" << std::endl; - shiftNeighbor n2; + shiftNeighbor n2; - orderShiftNH.init(solution, n2); + orderShiftNH.init(solution, n2); shiftEval(solution,n2); n2.print(); - while(orderShiftNH.cont(solution)){ - orderShiftNH.next(solution, n2); + while (orderShiftNH.cont(solution)) { + orderShiftNH.next(solution, n2); shiftEval(solution,n2); - n2.print(); + n2.print(); } std::cout << "\nSHIFT RANDOM WITHOUT REPLACEMENT NEIGHBORHOOD" << std::endl; std::cout << "---------------------------------------------" << std::endl; std::cout << "Neighbors List: (key: Neighbor -> fitness)" << std::endl; - rndNoReplShiftNH.init(solution, n2); + rndNoReplShiftNH.init(solution, n2); shiftEval(solution,n2); n2.print(); - while(rndNoReplShiftNH.cont(solution)){ - rndNoReplShiftNH.next(solution, n2); + while (rndNoReplShiftNH.cont(solution)) { + rndNoReplShiftNH.next(solution, n2); shiftEval(solution,n2); - n2.print(); + n2.print(); } std::cout << "\nSHIFT RANDOM WITH REPLACEMENT NEIGHBORHOOD" << std::endl; @@ -219,10 +219,10 @@ void main_function(int argc, char **argv) rndReplShiftNH.init(solution, n2); shiftEval(solution,n2); n2.print(); - for(unsigned int i=0; i<100; i++){ - rndReplShiftNH.next(solution, n2); + for (unsigned int i=0; i<100; i++) { + rndReplShiftNH.next(solution, n2); shiftEval(solution,n2); - n2.print(); + n2.print(); } } diff --git a/trunk/paradiseo-mo/tutorial/Lesson4/testSimpleTS.cpp b/trunk/paradiseo-mo/tutorial/Lesson4/testSimpleTS.cpp index c6831f296..db85527a5 100644 --- a/trunk/paradiseo-mo/tutorial/Lesson4/testSimpleTS.cpp +++ b/trunk/paradiseo-mo/tutorial/Lesson4/testSimpleTS.cpp @@ -65,7 +65,7 @@ void main_function(int argc, char **argv) // For each parameter, define Parameter, read it through the parser, // and assign the value to the variable - // seed + // seed eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); parser.processParam( seedParam ); unsigned seed = seedParam.value(); diff --git a/trunk/paradiseo-mo/tutorial/Lesson6/adaptiveWalks.cpp b/trunk/paradiseo-mo/tutorial/Lesson6/adaptiveWalks.cpp index bae65a273..36ab47ca0 100644 --- a/trunk/paradiseo-mo/tutorial/Lesson6/adaptiveWalks.cpp +++ b/trunk/paradiseo-mo/tutorial/Lesson6/adaptiveWalks.cpp @@ -45,154 +45,154 @@ using namespace std; // Indi is the typedef of the solution type like in paradisEO-eo typedef eoBit Indi; // bit string with unsigned fitness type // Neighbor is the typedef of the neighbor type, -// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) +// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // all classes from paradisEO-mo use this template type typedef moBitNeighbor Neighbor ; // bit string neighbor with unsigned fitness type void main_function(int argc, char **argv) { - /* ========================================================= - * - * Parameters - * - * ========================================================= */ - // 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. + /* ========================================================= + * + * Parameters + * + * ========================================================= */ + // more information on the input parameters: see EO tutorial lesson 3 + // but don't care at first it just read the parameters of the bit string size and the random seed. - // First define a parser from the command-line arguments - eoParser parser(argc, argv); - - // For each parameter, define Parameter, read it through the parser, - // and assign the value to the variable + // First define a parser from the command-line arguments + eoParser parser(argc, argv); - // random seed parameter - eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); - parser.processParam( seedParam ); - unsigned seed = seedParam.value(); - - // length of the bit string - eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); - parser.processParam( vecSizeParam, "Representation" ); - unsigned vecSize = vecSizeParam.value(); - - // the number of adaptive walks - eoValueParam 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 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 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 - } + // For each parameter, define Parameter, read it through the parser, + // and assign the value to the variable - /* ========================================================= - * - * Random seed - * - * ========================================================= */ + // random seed parameter + eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); + parser.processParam( seedParam ); + unsigned seed = seedParam.value(); - // 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); + // length of the bit string + eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); + parser.processParam( vecSizeParam, "Representation" ); + unsigned vecSize = vecSizeParam.value(); - /* ========================================================= - * - * Initialization of the solution - * - * ========================================================= */ + // the number of adaptive walks + eoValueParam solParam(100, "nbSol", "Number of adaptive walks", 'n'); + parser.processParam( solParam, "Representation" ); + unsigned nbSol = solParam.value(); - // a Indi random initializer: each bit is random - // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) - eoUniformGenerator uGen; - eoInitFixedLength random(vecSize, uGen); + // the name of the output file + string str_out = "out.dat"; // default value + eoValueParam outParam(str_out.c_str(), "out", "Output file of the sampling", 'o'); + parser.processParam(outParam, "Persistence" ); - /* ========================================================= - * - * Eval fitness function (full evaluation) - * - * ========================================================= */ + // the name of the "status" file where all actual parameter values will be saved + string str_status = parser.ProgramName() + ".status"; // default value + eoValueParam 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 - oneMaxEval fullEval; + // 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 + } - /* ========================================================= - * - * 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 - // moFullEvalByModif neighborEval(fullEval); + // 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); - // Incremental evaluation of the neighbor: fitness is modified by +/- 1 - moOneMaxIncrEval neighborEval; + /* ========================================================= + * + * Initialization of the solution + * + * ========================================================= */ - /* ========================================================= - * - * the neighborhood of a solution - * - * ========================================================= */ + // a Indi random initializer: each bit is random + // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) + eoUniformGenerator uGen; + eoInitFixedLength random(vecSize, uGen); - // Exploration of the neighborhood in order - // from bit 0 to bit vecSize-1 - moOrderNeighborhood neighborhood(vecSize); + /* ========================================================= + * + * Eval fitness function (full evaluation) + * + * ========================================================= */ - /* ========================================================= - * - * The sampling of the search space - * - * ========================================================= */ - - // sampling object : - // - random initialization - // - local search to sample the search space - // - one statistic to compute - moHillClimberSampling sampling(random, neighborhood, fullEval, neighborEval, nbSol); - - /* ========================================================= - * - * execute the sampling - * - * ========================================================= */ - - sampling(); - - /* ========================================================= - * - * export the sampling - * - * ========================================================= */ - - // to export the statistics into file - sampling.fileExport(str_out); + // the fitness function is just the number of 1 in the bit string + oneMaxEval fullEval; - // to get the values of statistics - // so, you can compute some statistics in c++ from the data - const std::vector & lengthValues = sampling.getValues(0); + /* ========================================================= + * + * evaluation of a neighbor solution + * + * ========================================================= */ - std::cout << "First values:" << std::endl; - std::cout << "Length " << lengthValues[0] << std::endl; + // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution + // moFullEvalByModif neighborEval(fullEval); - std::cout << "Last values:" << std::endl; - std::cout << "Length " << lengthValues[lengthValues.size() - 1] << std::endl; + // Incremental evaluation of the neighbor: fitness is modified by +/- 1 + moOneMaxIncrEval neighborEval; + + /* ========================================================= + * + * the neighborhood of a solution + * + * ========================================================= */ + + // Exploration of the neighborhood in order + // from bit 0 to bit vecSize-1 + moOrderNeighborhood neighborhood(vecSize); + + /* ========================================================= + * + * The sampling of the search space + * + * ========================================================= */ + + // sampling object : + // - random initialization + // - local search to sample the search space + // - one statistic to compute + moHillClimberSampling 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 & 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; } diff --git a/trunk/paradiseo-mo/tutorial/Lesson6/autocorrelation.cpp b/trunk/paradiseo-mo/tutorial/Lesson6/autocorrelation.cpp index 982fecf73..6f07d8ae7 100644 --- a/trunk/paradiseo-mo/tutorial/Lesson6/autocorrelation.cpp +++ b/trunk/paradiseo-mo/tutorial/Lesson6/autocorrelation.cpp @@ -49,166 +49,166 @@ using namespace std; // Indi is the typedef of the solution type like in paradisEO-eo typedef eoBit Indi; // bit string with unsigned fitness type // Neighbor is the typedef of the neighbor type, -// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) +// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // all classes from paradisEO-mo use this template type typedef moBitNeighbor Neighbor ; // bit string neighbor with unsigned fitness type void main_function(int argc, char **argv) { - /* ========================================================= - * - * Parameters - * - * ========================================================= */ - // 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. + /* ========================================================= + * + * Parameters + * + * ========================================================= */ + // more information on the input parameters: see EO tutorial lesson 3 + // but don't care at first it just read the parameters of the bit string size and the random seed. - // First define a parser from the command-line arguments - eoParser parser(argc, argv); - - // For each parameter, define Parameter, read it through the parser, - // and assign the value to the variable + // First define a parser from the command-line arguments + eoParser parser(argc, argv); - // random seed parameter - eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); - parser.processParam( seedParam ); - unsigned seed = seedParam.value(); - - // length of the bit string - eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); - parser.processParam( vecSizeParam, "Representation" ); - unsigned vecSize = vecSizeParam.value(); - - // the number of steps of the random walk - eoValueParam 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 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 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 - } + // For each parameter, define Parameter, read it through the parser, + // and assign the value to the variable - /* ========================================================= - * - * Random seed - * - * ========================================================= */ + // random seed parameter + eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); + parser.processParam( seedParam ); + unsigned seed = seedParam.value(); - // 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); + // length of the bit string + eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); + parser.processParam( vecSizeParam, "Representation" ); + unsigned vecSize = vecSizeParam.value(); - /* ========================================================= - * - * Initialization of the solution - * - * ========================================================= */ + // the number of steps of the random walk + eoValueParam stepParam(100, "nbStep", "Number of steps of the random walk", 'n'); + parser.processParam( stepParam, "Representation" ); + unsigned nbStep = stepParam.value(); - // a Indi random initializer: each bit is random - // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) - eoUniformGenerator uGen; - eoInitFixedLength random(vecSize, uGen); + // the name of the output file + string str_out = "out.dat"; // default value + eoValueParam outParam(str_out.c_str(), "out", "Output file of the sampling", 'o'); + parser.processParam(outParam, "Persistence" ); - /* ========================================================= - * - * Eval fitness function (full evaluation) - * - * ========================================================= */ + // the name of the "status" file where all actual parameter values will be saved + string str_status = parser.ProgramName() + ".status"; // default value + eoValueParam 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 - oneMaxEval fullEval; + // 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 + } - /* ========================================================= - * - * 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 - // moFullEvalByModif neighborEval(fullEval); + // 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); - // Incremental evaluation of the neighbor: fitness is modified by +/- 1 - moOneMaxIncrEval neighborEval; + /* ========================================================= + * + * Initialization of the solution + * + * ========================================================= */ - /* ========================================================= - * - * the neighborhood of a solution - * - * ========================================================= */ + // a Indi random initializer: each bit is random + // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) + eoUniformGenerator uGen; + eoInitFixedLength random(vecSize, uGen); - // Exploration of the neighborhood in random order - // at each step one bit is randomly generated - moRndWithReplNeighborhood neighborhood(vecSize); + /* ========================================================= + * + * Eval fitness function (full evaluation) + * + * ========================================================= */ - /* ========================================================= - * - * 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 sampling(random, neighborhood, fullEval, neighborEval, nbStep); - - /* ========================================================= - * - * execute the sampling - * - * ========================================================= */ - - sampling(); - - /* ========================================================= - * - * export the sampling - * - * ========================================================= */ - - // to export the statistics into file - sampling.fileExport(str_out); + // the fitness function is just the number of 1 in the bit string + oneMaxEval fullEval; - // to get the values of statistics - // so, you can compute some statistics in c++ from the data - const std::vector & fitnessValues = sampling.getValues(0); + /* ========================================================= + * + * evaluation of a neighbor solution + * + * ========================================================= */ - std::cout << "First values:" << std::endl; - std::cout << "Fitness " << fitnessValues[0] << std::endl; + // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution + // moFullEvalByModif neighborEval(fullEval); - std::cout << "Last values:" << std::endl; - std::cout << "Fitness " << fitnessValues[fitnessValues.size() - 1] << std::endl; + // Incremental evaluation of the neighbor: fitness is modified by +/- 1 + moOneMaxIncrEval neighborEval; - // more basic statistics on the distribution: - moStatistics statistics; + /* ========================================================= + * + * the neighborhood of a solution + * + * ========================================================= */ - vector rho, phi; + // Exploration of the neighborhood in random order + // at each step one bit is randomly generated + moRndWithReplNeighborhood neighborhood(vecSize); - statistics.autocorrelation(fitnessValues, 10, rho, phi); + /* ========================================================= + * + * The sampling of the search space + * + * ========================================================= */ - for(unsigned s = 0; s < rho.size(); s++) - std::cout << s << " " << "rho=" << rho[s] << ", phi=" << phi[s] << std::endl; + // sampling object : + // - random initialization + // - neighborhood to compute the next step + // - fitness function + // - neighbor evaluation + // - number of steps of the walk + moAutocorrelationSampling 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 & 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 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 diff --git a/trunk/paradiseo-mo/tutorial/Lesson6/densityOfStates.cpp b/trunk/paradiseo-mo/tutorial/Lesson6/densityOfStates.cpp index df4d5b424..a47323423 100644 --- a/trunk/paradiseo-mo/tutorial/Lesson6/densityOfStates.cpp +++ b/trunk/paradiseo-mo/tutorial/Lesson6/densityOfStates.cpp @@ -43,140 +43,140 @@ using namespace std; // Indi is the typedef of the solution type like in paradisEO-eo typedef eoBit Indi; // bit string with unsigned fitness type // Neighbor is the typedef of the neighbor type, -// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) +// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // all classes from paradisEO-mo use this template type typedef moBitNeighbor Neighbor ; // bit string neighbor with unsigned fitness type void main_function(int argc, char **argv) { - /* ========================================================= - * - * Parameters - * - * ========================================================= */ - // 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. + /* ========================================================= + * + * Parameters + * + * ========================================================= */ + // more information on the input parameters: see EO tutorial lesson 3 + // but don't care at first it just read the parameters of the bit string size and the random seed. - // First define a parser from the command-line arguments - eoParser parser(argc, argv); - - // For each parameter, define Parameter, read it through the parser, - // and assign the value to the variable + // First define a parser from the command-line arguments + eoParser parser(argc, argv); - // random seed parameter - eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); - parser.processParam( seedParam ); - unsigned seed = seedParam.value(); - - // length of the bit string - eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); - parser.processParam( vecSizeParam, "Representation" ); - unsigned vecSize = vecSizeParam.value(); - - // the number of solution sampled - eoValueParam 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 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 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 - } + // For each parameter, define Parameter, read it through the parser, + // and assign the value to the variable - /* ========================================================= - * - * Random seed - * - * ========================================================= */ + // random seed parameter + eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); + parser.processParam( seedParam ); + unsigned seed = seedParam.value(); - // 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); + // length of the bit string + eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); + parser.processParam( vecSizeParam, "Representation" ); + unsigned vecSize = vecSizeParam.value(); - /* ========================================================= - * - * Initialization of the solution - * - * ========================================================= */ + // the number of solution sampled + eoValueParam solParam(100, "nbSol", "Number of random solution", 'n'); + parser.processParam( solParam, "Representation" ); + unsigned nbSol = solParam.value(); - // a Indi random initializer: each bit is random - // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) - eoUniformGenerator uGen; - eoInitFixedLength random(vecSize, uGen); + // the name of the output file + string str_out = "out.dat"; // default value + eoValueParam outParam(str_out.c_str(), "out", "Output file of the sampling", 'o'); + parser.processParam(outParam, "Persistence" ); - /* ========================================================= - * - * Eval fitness function (full evaluation) - * - * ========================================================= */ + // the name of the "status" file where all actual parameter values will be saved + string str_status = parser.ProgramName() + ".status"; // default value + eoValueParam 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 - oneMaxEval fullEval; + // 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 + } - /* ========================================================= - * - * The sampling of the search space - * - * ========================================================= */ - - // sampling object : - // - random initialization - // - fitness function - // - number of solutions to sample - moDensityOfStatesSampling sampling(random, fullEval, nbSol); - - /* ========================================================= - * - * execute the sampling - * - * ========================================================= */ - - sampling(); - - /* ========================================================= - * - * export the sampling - * - * ========================================================= */ - - // to export the statistics into file - sampling.fileExport(str_out); + /* ========================================================= + * + * Random seed + * + * ========================================================= */ - // to get the values of statistics - // so, you can compute some statistics in c++ from the data - const std::vector & fitnessValues = sampling.getValues(0); + // 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); - std::cout << "First values:" << std::endl; - std::cout << "Fitness " << fitnessValues[0] << std::endl; + /* ========================================================= + * + * Initialization of the solution + * + * ========================================================= */ - std::cout << "Last values:" << std::endl; - std::cout << "Fitness " << fitnessValues[fitnessValues.size() - 1] << std::endl; + // a Indi random initializer: each bit is random + // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) + eoUniformGenerator uGen; + eoInitFixedLength random(vecSize, uGen); - // more basic statistics on the distribution: - double min, max, avg, std; - - moStatistics statistics; + /* ========================================================= + * + * Eval fitness function (full evaluation) + * + * ========================================================= */ - statistics.basic(fitnessValues, min, max, avg, std); - std::cout << "min=" << min << ", max=" << max << ", average=" << avg << ", std dev=" << std << std::endl; + // the fitness function is just the number of 1 in the bit string + oneMaxEval fullEval; + + /* ========================================================= + * + * The sampling of the search space + * + * ========================================================= */ + + // sampling object : + // - random initialization + // - fitness function + // - number of solutions to sample + moDensityOfStatesSampling 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 & 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 diff --git a/trunk/paradiseo-mo/tutorial/Lesson6/fdc.cpp b/trunk/paradiseo-mo/tutorial/Lesson6/fdc.cpp index f8c54adb7..a066e70ad 100644 --- a/trunk/paradiseo-mo/tutorial/Lesson6/fdc.cpp +++ b/trunk/paradiseo-mo/tutorial/Lesson6/fdc.cpp @@ -43,139 +43,139 @@ using namespace std; // Indi is the typedef of the solution type like in paradisEO-eo typedef eoBit Indi; // bit string with unsigned fitness type // Neighbor is the typedef of the neighbor type, -// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) +// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // all classes from paradisEO-mo use this template type typedef moBitNeighbor Neighbor ; // bit string neighbor with unsigned fitness type void main_function(int argc, char **argv) { - /* ========================================================= - * - * Parameters - * - * ========================================================= */ - // 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. + /* ========================================================= + * + * Parameters + * + * ========================================================= */ + // more information on the input parameters: see EO tutorial lesson 3 + // but don't care at first it just read the parameters of the bit string size and the random seed. - // First define a parser from the command-line arguments - eoParser parser(argc, argv); - - // For each parameter, define Parameter, read it through the parser, - // and assign the value to the variable + // First define a parser from the command-line arguments + eoParser parser(argc, argv); - // random seed parameter - eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); - parser.processParam( seedParam ); - unsigned seed = seedParam.value(); - - // length of the bit string - eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); - parser.processParam( vecSizeParam, "Representation" ); - unsigned vecSize = vecSizeParam.value(); - - // the number of solution sampled - eoValueParam 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 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 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 - } + // For each parameter, define Parameter, read it through the parser, + // and assign the value to the variable - /* ========================================================= - * - * Random seed - * - * ========================================================= */ + // random seed parameter + eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); + parser.processParam( seedParam ); + unsigned seed = seedParam.value(); - // 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); + // length of the bit string + eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); + parser.processParam( vecSizeParam, "Representation" ); + unsigned vecSize = vecSizeParam.value(); - /* ========================================================= - * - * Initialization of the solution - * - * ========================================================= */ + // the number of solution sampled + eoValueParam solParam(100, "nbSol", "Number of random solution", 'n'); + parser.processParam( solParam, "Representation" ); + unsigned nbSol = solParam.value(); - // a Indi random initializer: each bit is random - // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) - eoUniformGenerator uGen; - eoInitFixedLength random(vecSize, uGen); + // the name of the output file + string str_out = "out.dat"; // default value + eoValueParam outParam(str_out.c_str(), "out", "Output file of the sampling", 'o'); + parser.processParam(outParam, "Persistence" ); - /* ========================================================= - * - * Eval fitness function (full evaluation) - * - * ========================================================= */ + // the name of the "status" file where all actual parameter values will be saved + string str_status = parser.ProgramName() + ".status"; // default value + eoValueParam 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 - oneMaxEval fullEval; + // 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 + } - /* ========================================================= - * - * The sampling of the search space - * - * ========================================================= */ - - // Hamming distance to the global optimum - eoHammingDistance distance; // Hamming distance - Indi bestSolution(vecSize, true); // global optimum + /* ========================================================= + * + * Random seed + * + * ========================================================= */ - // sampling object : - // - random initialization - // - fitness function - // - number of solutions to sample - moFDCsampling sampling(random, fullEval, distance, bestSolution, nbSol); - - /* ========================================================= - * - * execute the sampling - * - * ========================================================= */ - - sampling(); - - /* ========================================================= - * - * export the sampling - * - * ========================================================= */ - - // to export the statistics into file - sampling.fileExport(str_out); + // 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); - // to get the values of statistics - // so, you can compute some statistics in c++ from the data - const std::vector & fitnessValues = sampling.getValues(0); - const std::vector & distValues = sampling.getValues(1); + /* ========================================================= + * + * Initialization of the solution + * + * ========================================================= */ - std::cout << "First values:" << std::endl; - std::cout << "Fitness " << fitnessValues[0] << std::endl; - std::cout << "Distance " << distValues[0] << std::endl; + // a Indi random initializer: each bit is random + // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) + eoUniformGenerator uGen; + eoInitFixedLength 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 fullEval; + + /* ========================================================= + * + * The sampling of the search space + * + * ========================================================= */ + + // Hamming distance to the global optimum + eoHammingDistance distance; // Hamming distance + Indi bestSolution(vecSize, true); // global optimum + + // sampling object : + // - random initialization + // - fitness function + // - number of solutions to sample + moFDCsampling 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 & fitnessValues = sampling.getValues(0); + const std::vector & 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 diff --git a/trunk/paradiseo-mo/tutorial/Lesson6/fitnessCloud.cpp b/trunk/paradiseo-mo/tutorial/Lesson6/fitnessCloud.cpp index f2eb5188c..ad92e9502 100644 --- a/trunk/paradiseo-mo/tutorial/Lesson6/fitnessCloud.cpp +++ b/trunk/paradiseo-mo/tutorial/Lesson6/fitnessCloud.cpp @@ -47,160 +47,160 @@ using namespace std; // Indi is the typedef of the solution type like in paradisEO-eo typedef eoBit Indi; // bit string with unsigned fitness type // Neighbor is the typedef of the neighbor type, -// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) +// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // all classes from paradisEO-mo use this template type typedef moBitNeighbor Neighbor ; // bit string neighbor with unsigned fitness type void main_function(int argc, char **argv) { - /* ========================================================= - * - * Parameters - * - * ========================================================= */ - // 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. + /* ========================================================= + * + * Parameters + * + * ========================================================= */ + // more information on the input parameters: see EO tutorial lesson 3 + // but don't care at first it just read the parameters of the bit string size and the random seed. - // First define a parser from the command-line arguments - eoParser parser(argc, argv); - - // For each parameter, define Parameter, read it through the parser, - // and assign the value to the variable + // First define a parser from the command-line arguments + eoParser parser(argc, argv); - // random seed parameter - eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); - parser.processParam( seedParam ); - unsigned seed = seedParam.value(); - - // length of the bit string - eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); - parser.processParam( vecSizeParam, "Representation" ); - unsigned vecSize = vecSizeParam.value(); - - // the number of solution sampled - eoValueParam 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 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 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 - } + // For each parameter, define Parameter, read it through the parser, + // and assign the value to the variable - /* ========================================================= - * - * Random seed - * - * ========================================================= */ + // random seed parameter + eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); + parser.processParam( seedParam ); + unsigned seed = seedParam.value(); - // 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); + // length of the bit string + eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); + parser.processParam( vecSizeParam, "Representation" ); + unsigned vecSize = vecSizeParam.value(); - /* ========================================================= - * - * Initialization of the solution - * - * ========================================================= */ + // the number of solution sampled + eoValueParam solParam(100, "nbSol", "Number of random solution", 'n'); + parser.processParam( solParam, "Representation" ); + unsigned nbSol = solParam.value(); - // a Indi random initializer: each bit is random - // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) - eoUniformGenerator uGen; - eoInitFixedLength random(vecSize, uGen); + // the name of the output file + string str_out = "out.dat"; // default value + eoValueParam outParam(str_out.c_str(), "out", "Output file of the sampling", 'o'); + parser.processParam(outParam, "Persistence" ); - /* ========================================================= - * - * Eval fitness function (full evaluation) - * - * ========================================================= */ + // the name of the "status" file where all actual parameter values will be saved + string str_status = parser.ProgramName() + ".status"; // default value + eoValueParam 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 - oneMaxEval fullEval; + // 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 + } - /* ========================================================= - * - * evaluation of a neighbor solution - * - * ========================================================= */ + /* ========================================================= + * + * Random seed + * + * ========================================================= */ - // Incremental evaluation of the neighbor: fitness is modified by +/- 1 - moOneMaxIncrEval neighborEval; + // 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); - /* ========================================================= - * - * the neighborhood of a solution - * - * ========================================================= */ + /* ========================================================= + * + * Initialization of the solution + * + * ========================================================= */ - // Exploration of the neighborhood in random order - // at each step one bit is randomly generated - moRndWithoutReplNeighborhood neighborhood(vecSize); + // a Indi random initializer: each bit is random + // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) + eoUniformGenerator uGen; + eoInitFixedLength random(vecSize, uGen); - /* ========================================================= - * - * 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 + /* ========================================================= + * + * Eval fitness function (full evaluation) + * + * ========================================================= */ - // moRndRndFitnessCloudSampling sampling(random, neighborhood, fullEval, neighborEval, nbSol); - // moMHRndFitnessCloudSampling sampling(random, neighborhood, fullEval, neighborEval, nbSol); - // moRndBestFitnessCloudSampling sampling(random, neighborhood, fullEval, neighborEval, nbSol); - moMHBestFitnessCloudSampling sampling(random, neighborhood, fullEval, neighborEval, nbSol); - - /* ========================================================= - * - * execute the sampling - * - * ========================================================= */ - - sampling(); - - /* ========================================================= - * - * export the sampling - * - * ========================================================= */ - - // to export the statistics into file - sampling.fileExport(str_out); + // the fitness function is just the number of 1 in the bit string + oneMaxEval fullEval; - // to get the values of statistics - // so, you can compute some statistics in c++ from the data - const std::vector & fitnessValues = sampling.getValues(0); - const std::vector & neighborFitnessValues = sampling.getValues(1); + /* ========================================================= + * + * evaluation of a neighbor solution + * + * ========================================================= */ - std::cout << "First values:" << std::endl; - std::cout << "Fitness " << fitnessValues[0] << std::endl; - std::cout << "Neighbor Fitness " << neighborFitnessValues[0] << std::endl; + // Incremental evaluation of the neighbor: fitness is modified by +/- 1 + moOneMaxIncrEval neighborEval; - 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 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 sampling(random, neighborhood, fullEval, neighborEval, nbSol); + // moMHRndFitnessCloudSampling sampling(random, neighborhood, fullEval, neighborEval, nbSol); + // moRndBestFitnessCloudSampling sampling(random, neighborhood, fullEval, neighborEval, nbSol); + moMHBestFitnessCloudSampling 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 & fitnessValues = sampling.getValues(0); + const std::vector & 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 diff --git a/trunk/paradiseo-mo/tutorial/Lesson6/neutralDegree.cpp b/trunk/paradiseo-mo/tutorial/Lesson6/neutralDegree.cpp index 2443c3ad0..55a346a11 100644 --- a/trunk/paradiseo-mo/tutorial/Lesson6/neutralDegree.cpp +++ b/trunk/paradiseo-mo/tutorial/Lesson6/neutralDegree.cpp @@ -44,161 +44,161 @@ using namespace std; // Indi is the typedef of the solution type like in paradisEO-eo typedef eoBit Indi; // bit string with unsigned fitness type // Neighbor is the typedef of the neighbor type, -// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) +// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // all classes from paradisEO-mo use this template type typedef moBitNeighbor Neighbor ; // bit string neighbor with unsigned fitness type void main_function(int argc, char **argv) { - /* ========================================================= - * - * Parameters - * - * ========================================================= */ - // 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. + /* ========================================================= + * + * Parameters + * + * ========================================================= */ + // more information on the input parameters: see EO tutorial lesson 3 + // but don't care at first it just read the parameters of the bit string size and the random seed. - // First define a parser from the command-line arguments - eoParser parser(argc, argv); - - // For each parameter, define Parameter, read it through the parser, - // and assign the value to the variable + // First define a parser from the command-line arguments + eoParser parser(argc, argv); - // random seed parameter - eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); - parser.processParam( seedParam ); - unsigned seed = seedParam.value(); - - // length of the bit string - eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); - parser.processParam( vecSizeParam, "Representation" ); - unsigned vecSize = vecSizeParam.value(); - - // size of the block - eoValueParam blockSizeParam(4, "blockSize", "Block size of the Royal Road", 'k'); - parser.processParam( blockSizeParam, "Representation" ); - unsigned blockSize = blockSizeParam.value(); - - // the number of solution sampled - eoValueParam 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 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 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 - } + // For each parameter, define Parameter, read it through the parser, + // and assign the value to the variable - /* ========================================================= - * - * Random seed - * - * ========================================================= */ + // random seed parameter + eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); + parser.processParam( seedParam ); + unsigned seed = seedParam.value(); - // 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); + // length of the bit string + eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); + parser.processParam( vecSizeParam, "Representation" ); + unsigned vecSize = vecSizeParam.value(); - /* ========================================================= - * - * Initialization of the solution - * - * ========================================================= */ + // size of the block + eoValueParam blockSizeParam(4, "blockSize", "Block size of the Royal Road", 'k'); + parser.processParam( blockSizeParam, "Representation" ); + unsigned blockSize = blockSizeParam.value(); - // a Indi random initializer: each bit is random - // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) - eoUniformGenerator uGen; - eoInitFixedLength random(vecSize, uGen); + // the number of solution sampled + eoValueParam solParam(100, "nbSol", "Number of random solution", 'n'); + parser.processParam( solParam, "Representation" ); + unsigned nbSol = solParam.value(); - /* ========================================================= - * - * Eval fitness function (full evaluation) - * - * ========================================================= */ + // the name of the output file + string str_out = "out.dat"; // default value + eoValueParam 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) - RoyalRoadEval fullEval(blockSize); + // the name of the "status" file where all actual parameter values will be saved + string str_status = parser.ProgramName() + ".status"; // default value + eoValueParam statusParam(str_status.c_str(), "status", "Status file"); + parser.processParam( statusParam, "Persistence" ); - /* ========================================================= - * - * evaluation of a neighbor solution - * - * ========================================================= */ + // 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 + } - // Incremental evaluation of the neighbor: fitness is modified by +1 , 0 or -1 - moRoyalRoadIncrEval neighborEval(fullEval); + /* ========================================================= + * + * Random seed + * + * ========================================================= */ - /* ========================================================= - * - * the neighborhood of a solution - * - * ========================================================= */ + // 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); - // Exploration of the neighborhood in increasing order of the neigbor's index: - // bit-flip from bit 0 to bit (vecSize - 1) - moOrderNeighborhood neighborhood(vecSize); + /* ========================================================= + * + * Initialization of the solution + * + * ========================================================= */ - /* ========================================================= - * - * 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 sampling(random, neighborhood, fullEval, neighborEval, nbSol); - - /* ========================================================= - * - * execute the sampling - * - * ========================================================= */ - - sampling(); - - /* ========================================================= - * - * export the sampling - * - * ========================================================= */ - - // to export the statistics into file - sampling.fileExport(str_out); + // a Indi random initializer: each bit is random + // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) + eoUniformGenerator uGen; + eoInitFixedLength random(vecSize, uGen); - // to get the values of statistics - // so, you can compute some statistics in c++ from the data - const std::vector & fitnessValues = sampling.getValues(0); - const std::vector & ndValues = sampling.getValues(1); + /* ========================================================= + * + * Eval fitness function (full evaluation) + * + * ========================================================= */ - std::cout << "First values:" << std::endl; - std::cout << "Fitness " << fitnessValues[0] << std::endl; - std::cout << "N. Degree " << ndValues[0] << std::endl; + // the fitness function is the royal function (oneMax is a Royal Road with block of 1) + RoyalRoadEval fullEval(blockSize); - 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 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 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 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 & fitnessValues = sampling.getValues(0); + const std::vector & 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 diff --git a/trunk/paradiseo-mo/tutorial/Lesson6/neutralWalk.cpp b/trunk/paradiseo-mo/tutorial/Lesson6/neutralWalk.cpp index b2a46bbea..a0af2c054 100644 --- a/trunk/paradiseo-mo/tutorial/Lesson6/neutralWalk.cpp +++ b/trunk/paradiseo-mo/tutorial/Lesson6/neutralWalk.cpp @@ -49,191 +49,191 @@ using namespace std; // Indi is the typedef of the solution type like in paradisEO-eo typedef eoBit Indi; // bit string with unsigned fitness type // Neighbor is the typedef of the neighbor type, -// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) +// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // all classes from paradisEO-mo use this template type typedef moBitNeighbor Neighbor ; // bit string neighbor with unsigned fitness type void main_function(int argc, char **argv) { - /* ========================================================= - * - * Parameters - * - * ========================================================= */ - // 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. + /* ========================================================= + * + * Parameters + * + * ========================================================= */ + // more information on the input parameters: see EO tutorial lesson 3 + // but don't care at first it just read the parameters of the bit string size and the random seed. - // First define a parser from the command-line arguments - eoParser parser(argc, argv); - - // For each parameter, define Parameter, read it through the parser, - // and assign the value to the variable + // First define a parser from the command-line arguments + eoParser parser(argc, argv); - // random seed parameter - eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); - parser.processParam( seedParam ); - unsigned seed = seedParam.value(); - - // length of the bit string - eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); - parser.processParam( vecSizeParam, "Representation" ); - unsigned vecSize = vecSizeParam.value(); - - // size of the block - eoValueParam 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 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 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 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 - } + // For each parameter, define Parameter, read it through the parser, + // and assign the value to the variable - /* ========================================================= - * - * Random seed - * - * ========================================================= */ + // random seed parameter + eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); + parser.processParam( seedParam ); + unsigned seed = seedParam.value(); - // 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); + // length of the bit string + eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); + parser.processParam( vecSizeParam, "Representation" ); + unsigned vecSize = vecSizeParam.value(); - /* ========================================================= - * - * Eval fitness function (full evaluation) - * - * ========================================================= */ + // size of the block + eoValueParam blockSizeParam(4, "blockSize", "Block size of the Royal Road", 'k'); + parser.processParam( blockSizeParam, "Representation" ); + unsigned blockSize = blockSizeParam.value(); - // the fitness function is the royal function (oneMax is a Royal Road with block of 1) - RoyalRoadEval fullEval(blockSize); + // the number of steps of the random walk + eoValueParam stepParam(100, "nbStep", "Number of steps of the random walk", 'n'); + parser.processParam( stepParam, "Representation" ); + unsigned nbStep = stepParam.value(); - /* ========================================================= - * - * evaluation of a neighbor solution - * - * ========================================================= */ + // the name of the output file + string str_out = "out.dat"; // default value + eoValueParam 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 - moRoyalRoadIncrEval neighborEval(fullEval); + // the name of the "status" file where all actual parameter values will be saved + string str_status = parser.ProgramName() + ".status"; // default value + eoValueParam statusParam(str_status.c_str(), "status", "Status file"); + parser.processParam( statusParam, "Persistence" ); - /* ========================================================= - * - * the neighborhood of a solution - * - * ========================================================= */ - - // Exploration of the neighborhood in random order - // at each step one bit is randomly generated - moRndWithoutReplNeighborhood neighborhood(vecSize); - - /* ========================================================= - * - * The sampling of the search space - * - * ========================================================= */ - - // Initial Solution of the random neutral walk - Indi initialSol(vecSize, false); - - // Hamming distance - eoHammingDistance distance; - - // sampling object : - // - random initialization - // - neighborhood to compute the next step - // - fitness function - // - neighbor evaluation - // - number of steps of the walk - moNeutralWalkSampling 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 & 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 > dist; - vector 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]); + // 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 } - 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 fullEval(blockSize); + + /* ========================================================= + * + * evaluation of a neighbor solution + * + * ========================================================= */ + + // Incremental evaluation of the neighbor: fitness is modified by +1 , 0 or -1 + moRoyalRoadIncrEval neighborEval(fullEval); + + /* ========================================================= + * + * the neighborhood of a solution + * + * ========================================================= */ + + // Exploration of the neighborhood in random order + // at each step one bit is randomly generated + moRndWithoutReplNeighborhood neighborhood(vecSize); + + /* ========================================================= + * + * The sampling of the search space + * + * ========================================================= */ + + // Initial Solution of the random neutral walk + Indi initialSol(vecSize, false); + + // Hamming distance + eoHammingDistance distance; + + // sampling object : + // - random initialization + // - neighborhood to compute the next step + // - fitness function + // - neighbor evaluation + // - number of steps of the walk + moNeutralWalkSampling 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 & 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 > dist; + vector 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 diff --git a/trunk/paradiseo-mo/tutorial/Lesson6/sampling.cpp b/trunk/paradiseo-mo/tutorial/Lesson6/sampling.cpp index 6b00e5f8d..4f1245e7d 100644 --- a/trunk/paradiseo-mo/tutorial/Lesson6/sampling.cpp +++ b/trunk/paradiseo-mo/tutorial/Lesson6/sampling.cpp @@ -56,190 +56,190 @@ using namespace std; // Indi is the typedef of the solution type like in paradisEO-eo typedef eoBit Indi; // bit string with unsigned fitness type // Neighbor is the typedef of the neighbor type, -// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) +// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness) // all classes from paradisEO-mo use this template type typedef moBitNeighbor Neighbor ; // bit string neighbor with unsigned fitness type void main_function(int argc, char **argv) { - /* ========================================================= - * - * Parameters - * - * ========================================================= */ - // 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. + /* ========================================================= + * + * Parameters + * + * ========================================================= */ + // more information on the input parameters: see EO tutorial lesson 3 + // but don't care at first it just read the parameters of the bit string size and the random seed. - // First define a parser from the command-line arguments - eoParser parser(argc, argv); - - // For each parameter, define Parameter, read it through the parser, - // and assign the value to the variable + // First define a parser from the command-line arguments + eoParser parser(argc, argv); - // random seed parameter - eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); - parser.processParam( seedParam ); - unsigned seed = seedParam.value(); - - // length of the bit string - eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); - parser.processParam( vecSizeParam, "Representation" ); - unsigned vecSize = vecSizeParam.value(); - - // the number of steps of the random walk - eoValueParam 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 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 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 - } + // For each parameter, define Parameter, read it through the parser, + // and assign the value to the variable - /* ========================================================= - * - * Random seed - * - * ========================================================= */ + // random seed parameter + eoValueParam seedParam(time(0), "seed", "Random number seed", 'S'); + parser.processParam( seedParam ); + unsigned seed = seedParam.value(); - // 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); + // length of the bit string + eoValueParam vecSizeParam(20, "vecSize", "Genotype size", 'V'); + parser.processParam( vecSizeParam, "Representation" ); + unsigned vecSize = vecSizeParam.value(); - /* ========================================================= - * - * Initialization of the solution - * - * ========================================================= */ + // the number of steps of the random walk + eoValueParam stepParam(100, "nbStep", "Number of steps of the random walk", 'n'); + parser.processParam( stepParam, "Representation" ); + unsigned nbStep = stepParam.value(); - // a Indi random initializer: each bit is random - // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) - eoUniformGenerator uGen; - eoInitFixedLength random(vecSize, uGen); + // the name of the output file + string str_out = "out.dat"; // default value + eoValueParam outParam(str_out.c_str(), "out", "Output file of the sampling", 'o'); + parser.processParam(outParam, "Persistence" ); - /* ========================================================= - * - * Eval fitness function (full evaluation) - * - * ========================================================= */ + // the name of the "status" file where all actual parameter values will be saved + string str_status = parser.ProgramName() + ".status"; // default value + eoValueParam 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 - oneMaxEval fullEval; + // 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 + } - /* ========================================================= - * - * 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 - // moFullEvalByModif neighborEval(fullEval); + // 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); - // Incremental evaluation of the neighbor: fitness is modified by +/- 1 - moOneMaxIncrEval neighborEval; + /* ========================================================= + * + * Initialization of the solution + * + * ========================================================= */ - /* ========================================================= - * - * the neighborhood of a solution - * - * ========================================================= */ + // a Indi random initializer: each bit is random + // more information: see EO tutorial lesson 1 (FirstBitGA.cpp) + eoUniformGenerator uGen; + eoInitFixedLength random(vecSize, uGen); - // Exploration of the neighborhood in random order - // at each step one bit is randomly generated - moRndWithReplNeighborhood neighborhood(vecSize); + /* ========================================================= + * + * Eval fitness function (full evaluation) + * + * ========================================================= */ - /* ========================================================= - * - * the local search algorithm to sample the search space - * - * ========================================================= */ + // the fitness function is just the number of 1 in the bit string + oneMaxEval fullEval; - moRandomWalk walk(neighborhood, fullEval, neighborEval, nbStep); + /* ========================================================= + * + * evaluation of a neighbor solution + * + * ========================================================= */ - /* ========================================================= - * - * the statistics to compute - * - * ========================================================= */ - - // fitness of the solution at each step - moFitnessStat fStat; + // Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution + // moFullEvalByModif neighborEval(fullEval); - // Hamming distance to the global optimum - eoHammingDistance distance; // Hamming distance - Indi bestSolution(vecSize, true); // global optimum + // Incremental evaluation of the neighbor: fitness is modified by +/- 1 + moOneMaxIncrEval neighborEval; - moDistanceStat distStat(distance, bestSolution); // statistic + /* ========================================================= + * + * the neighborhood of a solution + * + * ========================================================= */ - // "statistic" of the solution - moSolutionStat solStat; + // Exploration of the neighborhood in random order + // at each step one bit is randomly generated + moRndWithReplNeighborhood neighborhood(vecSize); - /* ========================================================= - * - * The sampling of the search space - * - * ========================================================= */ - - // sampling object : - // - random initialization - // - local search to sample the search space - // - one statistic to compute - moSampling sampling(random, walk, fStat); - - // to add another statistics - sampling.add(distStat); // distance - sampling.add(solStat); // solutions + /* ========================================================= + * + * the local search algorithm to sample the search space + * + * ========================================================= */ - /* ========================================================= - * - * execute the sampling - * - * ========================================================= */ - - sampling(); - - /* ========================================================= - * - * export the sampling - * - * ========================================================= */ - - // to export the statistics into file - sampling.fileExport(str_out); + moRandomWalk walk(neighborhood, fullEval, neighborEval, nbStep); - // to get the values of statistics - // so, you can compute some statistics in c++ from the data - const std::vector & fitnessValues = sampling.getValues(0); - const std::vector & distValues = sampling.getValues(1); - const std::vector & solutions = sampling.getSolutions(2); + /* ========================================================= + * + * the statistics to compute + * + * ========================================================= */ - 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; + // fitness of the solution at each step + moFitnessStat fStat; - 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; + // Hamming distance to the global optimum + eoHammingDistance distance; // Hamming distance + Indi bestSolution(vecSize, true); // global optimum + + moDistanceStat distStat(distance, bestSolution); // statistic + + // "statistic" of the solution + moSolutionStat solStat; + + /* ========================================================= + * + * The sampling of the search space + * + * ========================================================= */ + + // sampling object : + // - random initialization + // - local search to sample the search space + // - one statistic to compute + moSampling 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 & fitnessValues = sampling.getValues(0); + const std::vector & distValues = sampling.getValues(1); + const std::vector & 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 diff --git a/trunk/paradiseo-mo/tutorial/Lesson7/hybridAlgo.cpp b/trunk/paradiseo-mo/tutorial/Lesson7/hybridAlgo.cpp index 685f64b38..9f8b4c264 100644 --- a/trunk/paradiseo-mo/tutorial/Lesson7/hybridAlgo.cpp +++ b/trunk/paradiseo-mo/tutorial/Lesson7/hybridAlgo.cpp @@ -133,10 +133,10 @@ void main_function(int argc, char **argv) Queen tmp; - for(unsigned int i=0; i<20; i++){ - init(tmp); - fullEval(tmp); - pop.push_back(tmp); + for (unsigned int i=0; i<20; i++) { + init(tmp); + fullEval(tmp); + pop.push_back(tmp); } /* ========================================================= @@ -193,16 +193,16 @@ void main_function(int argc, char **argv) std::cout << "INITIAL POPULATION:" << std::endl; std::cout << "-------------------" << std::endl; - for(unsigned int i=0; i