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

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

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

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

@ -1,7 +1,7 @@
//-----------------------------------------------------------------------------
/** firstImprHC_maxSAT.cpp
*
* 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<unsigned int> Indi; // bit string with unsigned fitness type
// Neighbor is the typedef of the neighbor type,
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// all classes from paradisEO-mo use this template type
typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type
@ -54,157 +54,157 @@ typedef moBitNeighbor<unsigned int> 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<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam );
unsigned seed = seedParam.value();
// random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam );
unsigned seed = seedParam.value();
// length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value();
// length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value();
// Number of clauses of the max SAT problem
eoValueParam<unsigned int> ncParam(10, "nbClauses", "Number of clauses", 'm');
parser.processParam( ncParam, "Representation" );
unsigned nbClause = ncParam.value();
// Number of clauses of the max SAT problem
eoValueParam<unsigned int> ncParam(10, "nbClauses", "Number of clauses", 'm');
parser.processParam( ncParam, "Representation" );
unsigned nbClause = ncParam.value();
// Number of litteral by clauses
eoValueParam<unsigned int> kParam(3, "nbLitt", "Number of litteral by clauses", 'k');
parser.processParam( kParam, "Representation" );
unsigned nbLitteral = kParam.value();
// Number of litteral by clauses
eoValueParam<unsigned int> kParam(3, "nbLitt", "Number of litteral by clauses", 'k');
parser.processParam( kParam, "Representation" );
unsigned nbLitteral = kParam.value();
// the name of the instance file
string str_in = "" ; // default value
eoValueParam<string> inParam(str_in.c_str(), "in", "Input file of the file in ncf format", 'f');
parser.processParam(inParam, "Persistence" );
str_in = inParam.value();
// the name of the instance file
string str_in = "" ; // default value
eoValueParam<string> inParam(str_in.c_str(), "in", "Input file of the file in ncf format", 'f');
parser.processParam(inParam, "Persistence" );
str_in = inParam.value();
// the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) {
parser.printHelp(cout);
exit(1);
}
if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file
}
// the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" );
/* =========================================================
*
* 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<Indi> * fullEval;
/* =========================================================
*
* Eval fitness function (full evaluation)
*
* ========================================================= */
if (str_in.compare("") == 0)
fullEval = new MaxSATeval<Indi>(vecSize, nbClause, nbLitteral);
else {
fullEval = new MaxSATeval<Indi>(str_in);
vecSize = fullEval->nbVar ;
}
// the max SAT evaluation
MaxSATeval<Indi> * fullEval;
// string out = "cnf.dat";
// fullEval->save(out);
if (str_in.compare("") == 0)
fullEval = new MaxSATeval<Indi>(vecSize, nbClause, nbLitteral);
else {
fullEval = new MaxSATeval<Indi>(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<Neighbor> neighborEval(*fullEval);
/* =========================================================
*
* evaluation of a neighbor solution
*
* ========================================================= */
// Incremental evaluation of the neighbor:
moMaxSATincrEval<Neighbor> neighborEval(*fullEval);
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(*fullEval);
/* =========================================================
*
* Initialization of the solution
*
* ========================================================= */
// Incremental evaluation of the neighbor:
moMaxSATincrEval<Neighbor> neighborEval(*fullEval);
// a Indi random initializer: each bit is random
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
eoUniformGenerator<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen);
/* =========================================================
*
* 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<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen);
// Exploration of the neighborhood in random order of the neigbor's index:
// each neighbor is visited only once
moRndWithoutReplNeighborhood<Neighbor> neighborhood(vecSize);
/* =========================================================
*
* the neighborhood of a solution
*
* ========================================================= */
/* =========================================================
*
* the local search algorithm
*
* ========================================================= */
// Exploration of the neighborhood in random order of the neigbor's index:
// each neighbor is visited only once
moRndWithoutReplNeighborhood<Neighbor> neighborhood(vecSize);
moFirstImprHC<Neighbor> hc(neighborhood, *fullEval, neighborEval);
/* =========================================================
*
* the local search algorithm
*
* ========================================================= */
/* =========================================================
*
* executes the local search from a random solution
*
* ========================================================= */
moFirstImprHC<Neighbor> 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;
}

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

@ -55,7 +55,7 @@ using namespace std;
// Indi is the typedef of the solution type like in paradisEO-eo
typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type
// Neighbor is the typedef of the neighbor type,
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// all classes from paradisEO-mo use this template type
typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type
@ -64,176 +64,176 @@ typedef moBitNeighbor<unsigned int> 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<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam );
unsigned seed = seedParam.value();
// random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam );
unsigned seed = seedParam.value();
// length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value();
// length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value();
// maximum number of full evaluation
eoValueParam<unsigned int> fevalParam(2, "fulleval", "Maximum number of full evaluation");
parser.processParam( fevalParam, "Representation" );
unsigned fullevalMax = fevalParam.value();
// maximum number of full evaluation
eoValueParam<unsigned int> fevalParam(2, "fulleval", "Maximum number of full evaluation");
parser.processParam( fevalParam, "Representation" );
unsigned fullevalMax = fevalParam.value();
// maximum number of full evaluation
eoValueParam<unsigned int> evalParam(30, "eval", "Maximum number of neighbor evaluation", 'e');
parser.processParam( evalParam, "Representation" );
unsigned evalMax = evalParam.value();
// maximum number of full evaluation
eoValueParam<unsigned int> evalParam(30, "eval", "Maximum number of neighbor evaluation", 'e');
parser.processParam( evalParam, "Representation" );
unsigned evalMax = evalParam.value();
// maximum fitness to reach
eoValueParam<unsigned int> fitParam(16, "fitness", "Maximum fitness value to reach", 'f');
parser.processParam( fitParam, "Representation" );
unsigned fitnessMax = fitParam.value();
// maximum fitness to reach
eoValueParam<unsigned int> fitParam(16, "fitness", "Maximum fitness value to reach", 'f');
parser.processParam( fitParam, "Representation" );
unsigned fitnessMax = fitParam.value();
// maximum number of iterations
eoValueParam<unsigned int> iterParam(10, "iter", "Maximum number of iterations", 'i');
parser.processParam( iterParam, "Representation" );
unsigned iterMax = iterParam.value();
// maximum number of iterations
eoValueParam<unsigned int> iterParam(10, "iter", "Maximum number of iterations", 'i');
parser.processParam( iterParam, "Representation" );
unsigned iterMax = iterParam.value();
// the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" );
// the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) {
parser.printHelp(cout);
exit(1);
}
if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file
}
// 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<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen);
// a Indi random initializer: each bit is random
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
eoUniformGenerator<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen);
/* =========================================================
*
* Eval fitness function (full evaluation)
*
* ========================================================= */
/* =========================================================
*
* Eval fitness function (full evaluation)
*
* ========================================================= */
// the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEvalTmp;
// the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEvalTmp;
// to count the number of full evaluation
eoEvalFuncCounter<Indi> fullEval(fullEvalTmp);
// to count the number of full evaluation
eoEvalFuncCounter<Indi> fullEval(fullEvalTmp);
/* =========================================================
*
* evaluation of a neighbor solution
*
* ========================================================= */
/* =========================================================
*
* evaluation of a neighbor solution
*
* ========================================================= */
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEvalTmp;
// Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEvalTmp;
// to count the number of neighbor evaluation
moEvalCounter<Neighbor> neighborEval(neighborEvalTmp);
// to count the number of neighbor evaluation
moEvalCounter<Neighbor> neighborEval(neighborEvalTmp);
/* =========================================================
*
* the neighborhood of a solution
*
* ========================================================= */
/* =========================================================
*
* the neighborhood of a solution
*
* ========================================================= */
// Exploration of the neighborhood in increasing order of the neigbor's index:
// bit-flip from bit 0 to bit (vecSize - 1)
moOrderNeighborhood<Neighbor> neighborhood(vecSize);
// Exploration of the neighborhood in increasing order of the neigbor's index:
// bit-flip from bit 0 to bit (vecSize - 1)
moOrderNeighborhood<Neighbor> neighborhood(vecSize);
/* =========================================================
*
* the external continuators
*
* ========================================================= */
/* =========================================================
*
* the external continuators
*
* ========================================================= */
moIterContinuator<Neighbor> iterCont(iterMax);
moFitContinuator<Neighbor> fitCont(fitnessMax);
moFullEvalContinuator<Neighbor> fullevalCont(fullEval, fullevalMax);
moNeighborEvalContinuator<Neighbor> evalCont(neighborEval, evalMax);
moIterContinuator<Neighbor> iterCont(iterMax);
moFitContinuator<Neighbor> fitCont(fitnessMax);
moFullEvalContinuator<Neighbor> fullevalCont(fullEval, fullevalMax);
moNeighborEvalContinuator<Neighbor> evalCont(neighborEval, evalMax);
moCombinedContinuator<Neighbor> continuator(iterCont);
continuator.add(fitCont);
continuator.add(fullevalCont);
continuator.add(evalCont);
moCombinedContinuator<Neighbor> continuator(iterCont);
continuator.add(fitCont);
continuator.add(fullevalCont);
continuator.add(evalCont);
/* =========================================================
*
* the local search algorithm
*
* ========================================================= */
/* =========================================================
*
* the local search algorithm
*
* ========================================================= */
moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval, continuator);
moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval, continuator);
/* =========================================================
*
* executes the local search from a random solution
*
* ========================================================= */
/* =========================================================
*
* executes the local search from a random solution
*
* ========================================================= */
// The current solution
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;
}

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

@ -50,7 +50,7 @@ using namespace std;
// Indi is the typedef of the solution type like in paradisEO-eo
typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type
// Neighbor is the typedef of the neighbor type,
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// all classes from paradisEO-mo use this template type
typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type
@ -59,148 +59,148 @@ typedef moBitNeighbor<unsigned int> 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<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam );
unsigned seed = seedParam.value();
// random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam );
unsigned seed = seedParam.value();
// length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value();
// length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value();
// maximum number of full evaluation
eoValueParam<unsigned int> evalParam(30, "eval", "Maximum number of neighbor evaluation", 'e');
parser.processParam( evalParam, "Representation" );
unsigned evalMax = evalParam.value();
// maximum number of full evaluation
eoValueParam<unsigned int> evalParam(30, "eval", "Maximum number of neighbor evaluation", 'e');
parser.processParam( evalParam, "Representation" );
unsigned evalMax = evalParam.value();
// the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" );
// the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) {
parser.printHelp(cout);
exit(1);
}
if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file
}
// 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<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen);
// a Indi random initializer: each bit is random
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
eoUniformGenerator<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen);
/* =========================================================
*
* Eval fitness function (full evaluation)
*
* ========================================================= */
/* =========================================================
*
* Eval fitness function (full evaluation)
*
* ========================================================= */
// the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEval;
// the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEval;
/* =========================================================
*
* evaluation of a neighbor solution
*
* ========================================================= */
/* =========================================================
*
* evaluation of a neighbor solution
*
* ========================================================= */
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEvalTmp;
// Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEvalTmp;
// to count the number of neighbor evaluation
moEvalCounter<Neighbor> neighborEval(neighborEvalTmp);
// to count the number of neighbor evaluation
moEvalCounter<Neighbor> neighborEval(neighborEvalTmp);
/* =========================================================
*
* the neighborhood of a solution
*
* ========================================================= */
/* =========================================================
*
* the neighborhood of a solution
*
* ========================================================= */
// Exploration of the neighborhood in increasing order of the neigbor's index:
// bit-flip from bit 0 to bit (vecSize - 1)
moOrderNeighborhood<Neighbor> neighborhood(vecSize);
// Exploration of the neighborhood in increasing order of the neigbor's index:
// bit-flip from bit 0 to bit (vecSize - 1)
moOrderNeighborhood<Neighbor> neighborhood(vecSize);
/* =========================================================
*
* the external continuators
*
* ========================================================= */
/* =========================================================
*
* the external continuators
*
* ========================================================= */
moNeighborEvalContinuator<Neighbor> continuator(neighborEval, evalMax);
moNeighborEvalContinuator<Neighbor> continuator(neighborEval, evalMax);
/* =========================================================
*
* the local search algorithm
*
* ========================================================= */
/* =========================================================
*
* the local search algorithm
*
* ========================================================= */
moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval, continuator);
moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval, continuator);
/* =========================================================
*
* executes the local search from a random solution
*
* ========================================================= */
/* =========================================================
*
* executes the local search from a random solution
*
* ========================================================= */
// The current solution
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;
}

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

@ -45,7 +45,7 @@ using namespace std;
// Indi is the typedef of the solution type like in paradisEO-eo
typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type
// Neighbor is the typedef of the neighbor type,
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// all classes from paradisEO-mo use this template type
typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type
@ -54,131 +54,131 @@ typedef moBitNeighbor<unsigned int> 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<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam );
unsigned seed = seedParam.value();
// random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam );
unsigned seed = seedParam.value();
// length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value();
// length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value();
// the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" );
// the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) {
parser.printHelp(cout);
exit(1);
}
if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file
}
// 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<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen);
// a Indi random initializer: each bit is random
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
eoUniformGenerator<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen);
/* =========================================================
*
* Eval fitness function (full evaluation)
*
* ========================================================= */
/* =========================================================
*
* Eval fitness function (full evaluation)
*
* ========================================================= */
// the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEval;
// the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEval;
/* =========================================================
*
* evaluation of a neighbor solution
*
* ========================================================= */
/* =========================================================
*
* evaluation of a neighbor solution
*
* ========================================================= */
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEval;
// Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEval;
/* =========================================================
*
* the neighborhood of a solution
*
* ========================================================= */
/* =========================================================
*
* the neighborhood of a solution
*
* ========================================================= */
// Exploration of the neighborhood in random order of the neigbor's index:
// each neighbor is visited only once
moRndWithoutReplNeighborhood<Neighbor> neighborhood(vecSize);
// Exploration of the neighborhood in random order of the neigbor's index:
// each neighbor is visited only once
moRndWithoutReplNeighborhood<Neighbor> neighborhood(vecSize);
/* =========================================================
*
* the local search algorithm
*
* ========================================================= */
/* =========================================================
*
* the local search algorithm
*
* ========================================================= */
moFirstImprHC<Neighbor> hc(neighborhood, fullEval, neighborEval);
moFirstImprHC<Neighbor> hc(neighborhood, fullEval, neighborEval);
/* =========================================================
*
* executes the local search from a random solution
*
* ========================================================= */
/* =========================================================
*
* executes the local search from a random solution
*
* ========================================================= */
// The current solution
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;
}

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

@ -49,7 +49,7 @@ using namespace std;
// Indi is the typedef of the solution type like in paradisEO-eo
typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type
// Neighbor is the typedef of the neighbor type,
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// all classes from paradisEO-mo use this template type
typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type
@ -58,144 +58,144 @@ typedef moBitNeighbor<unsigned int> 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<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam );
unsigned seed = seedParam.value();
// random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam );
unsigned seed = seedParam.value();
// length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value();
// length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value();
// maximum fitness to reach
eoValueParam<unsigned int> fitParam(16, "fitness", "Maximum fitness value to reach", 'f');
parser.processParam( fitParam, "Representation" );
unsigned fitnessMax = fitParam.value();
// maximum fitness to reach
eoValueParam<unsigned int> fitParam(16, "fitness", "Maximum fitness value to reach", 'f');
parser.processParam( fitParam, "Representation" );
unsigned fitnessMax = fitParam.value();
// the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" );
// the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) {
parser.printHelp(cout);
exit(1);
}
if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file
}
// 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<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen);
// a Indi random initializer: each bit is random
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
eoUniformGenerator<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen);
/* =========================================================
*
* Eval fitness function (full evaluation)
*
* ========================================================= */
/* =========================================================
*
* Eval fitness function (full evaluation)
*
* ========================================================= */
// the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEval;
// the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEval;
/* =========================================================
*
* evaluation of a neighbor solution
*
* ========================================================= */
/* =========================================================
*
* evaluation of a neighbor solution
*
* ========================================================= */
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEval;
// Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEval;
/* =========================================================
*
* the neighborhood of a solution
*
* ========================================================= */
/* =========================================================
*
* the neighborhood of a solution
*
* ========================================================= */
// Exploration of the neighborhood in increasing order of the neigbor's index:
// bit-flip from bit 0 to bit (vecSize - 1)
moOrderNeighborhood<Neighbor> neighborhood(vecSize);
// Exploration of the neighborhood in increasing order of the neigbor's index:
// bit-flip from bit 0 to bit (vecSize - 1)
moOrderNeighborhood<Neighbor> neighborhood(vecSize);
/* =========================================================
*
* the external continuators
*
* ========================================================= */
/* =========================================================
*
* the external continuators
*
* ========================================================= */
moFitContinuator<Neighbor> continuator(fitnessMax);
moFitContinuator<Neighbor> continuator(fitnessMax);
/* =========================================================
*
* the local search algorithm
*
* ========================================================= */
/* =========================================================
*
* the local search algorithm
*
* ========================================================= */
moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval, continuator);
moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval, continuator);
/* =========================================================
*
* executes the local search from a random solution
*
* ========================================================= */
/* =========================================================
*
* executes the local search from a random solution
*
* ========================================================= */
// The current solution
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;
}

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

@ -50,7 +50,7 @@ using namespace std;
// Indi is the typedef of the solution type like in paradisEO-eo
typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type
// Neighbor is the typedef of the neighbor type,
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// all classes from paradisEO-mo use this template type
typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type
@ -59,148 +59,148 @@ typedef moBitNeighbor<unsigned int> 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<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam );
unsigned seed = seedParam.value();
// random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam );
unsigned seed = seedParam.value();
// length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value();
// length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value();
// maximum number of full evaluation
eoValueParam<unsigned int> evalParam(2, "fulleval", "Maximum number of full evaluation", 'e');
parser.processParam( evalParam, "Representation" );
unsigned fullevalMax = evalParam.value();
// maximum number of full evaluation
eoValueParam<unsigned int> evalParam(2, "fulleval", "Maximum number of full evaluation", 'e');
parser.processParam( evalParam, "Representation" );
unsigned fullevalMax = evalParam.value();
// the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" );
// the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) {
parser.printHelp(cout);
exit(1);
}
if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file
}
// 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<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen);
// a Indi random initializer: each bit is random
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
eoUniformGenerator<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen);
/* =========================================================
*
* Eval fitness function (full evaluation)
*
* ========================================================= */
/* =========================================================
*
* Eval fitness function (full evaluation)
*
* ========================================================= */
// the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEvalTmp;
// the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEvalTmp;
// to count the number of full evaluation
eoEvalFuncCounter<Indi> fullEval(fullEvalTmp);
// to count the number of full evaluation
eoEvalFuncCounter<Indi> fullEval(fullEvalTmp);
/* =========================================================
*
* evaluation of a neighbor solution
*
* ========================================================= */
/* =========================================================
*
* evaluation of a neighbor solution
*
* ========================================================= */
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEval;
// Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEval;
/* =========================================================
*
* the neighborhood of a solution
*
* ========================================================= */
/* =========================================================
*
* the neighborhood of a solution
*
* ========================================================= */
// Exploration of the neighborhood in increasing order of the neigbor's index:
// bit-flip from bit 0 to bit (vecSize - 1)
moOrderNeighborhood<Neighbor> neighborhood(vecSize);
// Exploration of the neighborhood in increasing order of the neigbor's index:
// bit-flip from bit 0 to bit (vecSize - 1)
moOrderNeighborhood<Neighbor> neighborhood(vecSize);
/* =========================================================
*
* the external continuators
*
* ========================================================= */
/* =========================================================
*
* the external continuators
*
* ========================================================= */
moFullEvalContinuator<Neighbor> continuator(fullEval, fullevalMax);
moFullEvalContinuator<Neighbor> continuator(fullEval, fullevalMax);
/* =========================================================
*
* the local search algorithm
*
* ========================================================= */
/* =========================================================
*
* the local search algorithm
*
* ========================================================= */
moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval, continuator);
moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval, continuator);
/* =========================================================
*
* executes the local search from a random solution
*
* ========================================================= */
/* =========================================================
*
* executes the local search from a random solution
*
* ========================================================= */
// The current solution
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;
}

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

@ -49,7 +49,7 @@ using namespace std;
// Indi is the typedef of the solution type like in paradisEO-eo
typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type
// Neighbor is the typedef of the neighbor type,
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// all classes from paradisEO-mo use this template type
typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type
@ -58,146 +58,146 @@ typedef moBitNeighbor<unsigned int> 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<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam );
unsigned seed = seedParam.value();
// random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam );
unsigned seed = seedParam.value();
// length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value();
// length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value();
// maximum number of iterations
eoValueParam<unsigned int> iterParam(10, "iter", "Maximum number of iterations", 'i');
parser.processParam( iterParam, "Representation" );
unsigned iterMax = iterParam.value();
// maximum number of iterations
eoValueParam<unsigned int> iterParam(10, "iter", "Maximum number of iterations", 'i');
parser.processParam( iterParam, "Representation" );
unsigned iterMax = iterParam.value();
// the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" );
// the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) {
parser.printHelp(cout);
exit(1);
}
if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file
}
// 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<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen);
// a Indi random initializer: each bit is random
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
eoUniformGenerator<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen);
/* =========================================================
*
* Eval fitness function (full evaluation)
*
* ========================================================= */
/* =========================================================
*
* Eval fitness function (full evaluation)
*
* ========================================================= */
// the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEval;
// the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEval;
/* =========================================================
*
* evaluation of a neighbor solution
*
* ========================================================= */
/* =========================================================
*
* evaluation of a neighbor solution
*
* ========================================================= */
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEval;
// Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEval;
/* =========================================================
*
* the neighborhood of a solution
*
* ========================================================= */
/* =========================================================
*
* the neighborhood of a solution
*
* ========================================================= */
// Exploration of the neighborhood in increasing order of the neigbor's index:
// bit-flip from bit 0 to bit (vecSize - 1)
moOrderNeighborhood<Neighbor> neighborhood(vecSize);
// Exploration of the neighborhood in increasing order of the neigbor's index:
// bit-flip from bit 0 to bit (vecSize - 1)
moOrderNeighborhood<Neighbor> neighborhood(vecSize);
/* =========================================================
*
* the external continuators
*
* ========================================================= */
/* =========================================================
*
* the external continuators
*
* ========================================================= */
moIterContinuator<Neighbor> continuator(iterMax);
moIterContinuator<Neighbor> continuator(iterMax);
/* =========================================================
*
* the local search algorithm
*
* ========================================================= */
/* =========================================================
*
* the local search algorithm
*
* ========================================================= */
moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval, continuator);
moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval, continuator);
/* =========================================================
*
* executes the local search from a random solution
*
* ========================================================= */
/* =========================================================
*
* executes the local search from a random solution
*
* ========================================================= */
// The current solution
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;
}

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

@ -45,7 +45,7 @@ using namespace std;
// Indi is the typedef of the solution type like in paradisEO-eo
typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type
// Neighbor is the typedef of the neighbor type,
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// all classes from paradisEO-mo use this template type
typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type
@ -54,135 +54,135 @@ typedef moBitNeighbor<unsigned int> 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<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam );
unsigned seed = seedParam.value();
// random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam );
unsigned seed = seedParam.value();
// length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value();
// length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value();
eoValueParam<unsigned int> stepParam(10, "nbStepMax", "Number of steps of the random walk", 'n');
parser.processParam( stepParam, "Representation" );
unsigned nbStepMax = stepParam.value();
// the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" );
eoValueParam<unsigned int> 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<string> 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<bool> uGen;
eoInitFixedLength<Indi> 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<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen);
// the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEval;
/* =========================================================
*
* Eval fitness function (full evaluation)
*
* ========================================================= */
/* =========================================================
*
* evaluation of a neighbor solution
*
* ========================================================= */
// the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEval;
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval);
/* =========================================================
*
* evaluation of a neighbor solution
*
* ========================================================= */
// Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEval;
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval);
/* =========================================================
*
* the neighborhood of a solution
*
* ========================================================= */
// Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEval;
// Exploration of the neighborhood in increasing order of the neigbor's index:
// bit-flip from bit 0 to bit (vecSize - 1)
moOrderNeighborhood<Neighbor> neighborhood(vecSize);
/* =========================================================
*
* the neighborhood of a solution
*
* ========================================================= */
/* =========================================================
*
* 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<Neighbor> neighborhood(vecSize);
moNeutralHC<Neighbor> hc(neighborhood, fullEval, neighborEval, nbStepMax);
/* =========================================================
*
* the local search algorithm
*
* ========================================================= */
/* =========================================================
*
* executes the local search from a random solution
*
* ========================================================= */
moNeutralHC<Neighbor> 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;
}

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

@ -45,7 +45,7 @@ using namespace std;
// Indi is the typedef of the solution type like in paradisEO-eo
typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type
// Neighbor is the typedef of the neighbor type,
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// all classes from paradisEO-mo use this template type
typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type
@ -54,131 +54,131 @@ typedef moBitNeighbor<unsigned int> 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<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam );
unsigned seed = seedParam.value();
// random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam );
unsigned seed = seedParam.value();
// length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value();
// length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value();
// the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" );
// the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) {
parser.printHelp(cout);
exit(1);
}
if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file
}
// 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<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen);
// a Indi random initializer: each bit is random
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
eoUniformGenerator<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen);
/* =========================================================
*
* Eval fitness function (full evaluation)
*
* ========================================================= */
/* =========================================================
*
* Eval fitness function (full evaluation)
*
* ========================================================= */
// the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEval;
// the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEval;
/* =========================================================
*
* evaluation of a neighbor solution
*
* ========================================================= */
/* =========================================================
*
* evaluation of a neighbor solution
*
* ========================================================= */
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEval;
// Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEval;
/* =========================================================
*
* the neighborhood of a solution
*
* ========================================================= */
/* =========================================================
*
* the neighborhood of a solution
*
* ========================================================= */
// Exploration of the neighborhood in increasing order of the neigbor's index:
// bit-flip from bit 0 to bit (vecSize - 1)
moOrderNeighborhood<Neighbor> neighborhood(vecSize);
// Exploration of the neighborhood in increasing order of the neigbor's index:
// bit-flip from bit 0 to bit (vecSize - 1)
moOrderNeighborhood<Neighbor> neighborhood(vecSize);
/* =========================================================
*
* the local search algorithm
*
* ========================================================= */
/* =========================================================
*
* the local search algorithm
*
* ========================================================= */
moRandomBestHC<Neighbor> hc(neighborhood, fullEval, neighborEval);
moRandomBestHC<Neighbor> hc(neighborhood, fullEval, neighborEval);
/* =========================================================
*
* executes the local search from a random solution
*
* ========================================================= */
/* =========================================================
*
* executes the local search from a random solution
*
* ========================================================= */
// The current solution
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;
}

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

@ -45,7 +45,7 @@ using namespace std;
// Indi is the typedef of the solution type like in paradisEO-eo
typedef eoBit<unsigned int> Indi; // bit string with unsigned fitness type
// Neighbor is the typedef of the neighbor type,
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// Neighbor = How to compute the neighbor from the solution + information on it (i.e. fitness)
// all classes from paradisEO-mo use this template type
typedef moBitNeighbor<unsigned int> Neighbor ; // bit string neighbor with unsigned fitness type
@ -54,131 +54,131 @@ typedef moBitNeighbor<unsigned int> 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<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam );
unsigned seed = seedParam.value();
// random seed parameter
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam );
unsigned seed = seedParam.value();
// length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value();
// length of the bit string
eoValueParam<unsigned int> vecSizeParam(20, "vecSize", "Genotype size", 'V');
parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value();
// the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" );
// the name of the "status" file where all actual parameter values will be saved
string str_status = parser.ProgramName() + ".status"; // default value
eoValueParam<string> statusParam(str_status.c_str(), "status", "Status file");
parser.processParam( statusParam, "Persistence" );
// do the following AFTER ALL PARAMETERS HAVE BEEN PROCESSED
// i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp()) {
parser.printHelp(cout);
exit(1);
}
if (statusParam.value() != "") {
ofstream os(statusParam.value().c_str());
os << parser;// and you can use that file as parameter file
}
// 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<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen);
// a Indi random initializer: each bit is random
// more information: see EO tutorial lesson 1 (FirstBitGA.cpp)
eoUniformGenerator<bool> uGen;
eoInitFixedLength<Indi> random(vecSize, uGen);
/* =========================================================
*
* Eval fitness function (full evaluation)
*
* ========================================================= */
/* =========================================================
*
* Eval fitness function (full evaluation)
*
* ========================================================= */
// the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEval;
// the fitness function is just the number of 1 in the bit string
oneMaxEval<Indi> fullEval;
/* =========================================================
*
* evaluation of a neighbor solution
*
* ========================================================= */
/* =========================================================
*
* evaluation of a neighbor solution
*
* ========================================================= */
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Use it if there is no incremental evaluation: a neighbor is evaluated by the full evaluation of a solution
// moFullEvalByModif<Neighbor> neighborEval(fullEval);
// Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEval;
// Incremental evaluation of the neighbor: fitness is modified by +/- 1
moOneMaxIncrEval<Neighbor> neighborEval;
/* =========================================================
*
* the neighborhood of a solution
*
* ========================================================= */
/* =========================================================
*
* the neighborhood of a solution
*
* ========================================================= */
// Exploration of the neighborhood in increasing order of the neigbor's index:
// bit-flip from bit 0 to bit (vecSize - 1)
moOrderNeighborhood<Neighbor> neighborhood(vecSize);
// Exploration of the neighborhood in increasing order of the neigbor's index:
// bit-flip from bit 0 to bit (vecSize - 1)
moOrderNeighborhood<Neighbor> neighborhood(vecSize);
/* =========================================================
*
* the local search algorithm
*
* ========================================================= */
/* =========================================================
*
* the local search algorithm
*
* ========================================================= */
moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval);
moSimpleHC<Neighbor> hc(neighborhood, fullEval, neighborEval);
/* =========================================================
*
* executes the local search from a random solution
*
* ========================================================= */
/* =========================================================
*
* executes the local search from a random solution
*
* ========================================================= */
// The current solution
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;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@ -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<pop.size(); i++)
std::cout << pop[i] << std::endl;
for (unsigned int i=0; i<pop.size(); i++)
std::cout << pop[i] << std::endl;
hybridAlgo(pop);
std::cout << std::endl;
std::cout << "FINAL POPULATION:" << std::endl;
std::cout << "-------------------" << std::endl;
for(unsigned int i=0; i<pop.size(); i++)
std::cout << pop[i] << std::endl;
for (unsigned int i=0; i<pop.size(); i++)
std::cout << pop[i] << std::endl;
}