Back to Lesson 3 - Tutorial main page - Algorithm-Based - Component-Based - Programming hints - EO documentation


Click on the figure to see the corresponding code.
In the code, the colors are meaningfull
The actual code is in boldface and the comment in normal face.

For this particular program, as all new lines are concerned with program parameter input and information output, the font color for program-parameter-related sections will refer to the section where the parameters are used whereas the background color will remain blue.

// SecondGA.cpp
// Same code than FirstBitEA as far as Evolutionary Computation is concerned
// but now you learn to enter the parameters in a more flexible way
// and to twidle the output to your preferences!
// standard includes
#include <stdexcept>  // runtime_error 
#include <iostream>   // cout
#include <strstream>  // ostrstream, istrstream
#include <fstream>
// the general include for eo
#include <eo>
// a simple fitness function that computes the number of ones of a bitstring
#include "binary_value.h"
// define your genotype and fitness types
typedef eoBit<double> Indi;
// the main_function: nothing changed(!), except variable initialization
void main_function(int argc, char **argv)
// instead of having all values of useful parameters as constants, read them:
// either on the command line (--option=value or -o=value)
//        or in a parameter file (same syntax, order independent, 
//                                    # = usual comment character 
//        or in the environment (TODO)

// 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

eoValueParam<uint32> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam );
unsigned seed = seedParam.value();

// decription of genotype
eoValueParam<unsigned int>& vecSizeParam(8, "vecSize", "Genotype size",'V');
parser.processParam( vecSizeParam, "Representation" );
unsigned vecSize = vecSizeParam.value();

// parameters for evolution engine
eoValueParam<unsigned int>& popSizeParam(10, "popSize", "Population size",'P');
parser.processParam( popSizeParam, "Evolution engine" );
unsigned popSize = popSizeParam.value();

eoValueParam<unsigned int>& tSizeParam(10, "tSize", "Tournament size",'T');
parser.processParam( seedParam );
unsigned tSize = tSizeParam.value();

   // init and stop
eoValueParam<string> loadNameParam("", "Load","A save file to restart from",'L');
parser.processParam( loadNameParam, "Persistence" );
string loadName = loadNameParam.value();

eoValueParam<unsigned int> maxGenParam(100, "maxGen", "Maximum number of generations",'G');
parser.processParam( maxGenParam, "Stopping criterion" );
unsigned maxGen = maxGenParam.value();

eoValueParam<unsigned int> minGenParam(100, "minGen", "Minimum number of generations",'g');
parser.processParam( minGenParam, "Stopping criterion" );
unsigned minGen = minGenParam.value();

eoValueParam<unsigned int> steadyGenParam(100, "steadyGen", "Number of generations with no improvement",'s');
parser.processParam( steadyGenParam, "Stopping criterion" );
unsigned steadyGen = steadyGenParam.value();

// operators probabilities at the algorithm level
eoValueParam<double> pCrossParam(0.6, "pCross", "Probability of Crossover", 'C'); 
parser.processParam( pCrossParam, "Genetic Operators" );
double pCross = pCrossParam.value();

eoValueParam<double> pMutParam(0.1, "pMut", "Probability of Mutation", 'M');
parser.processParam( pMutParam, "Genetic Operators" );
double pMut = pMutParam.value();

// relative rates for crossovers
eoValueParam<double> onePointRateParam(1, "onePointRate", "Relative rate for one point crossover", '1');
parser.processParam( onePointRateParam, "Genetic Operators" );
double onePointRate = onePointRateParam.value();

eoValueParam<double> twoPointsRateParam(1, "twoPointRate", "Relative rate for two point crossover", '2');
parser.processParam( twoPointsRateParam, "Genetic Operators" );
double twoPointsRate = twoPointsRateParam.value();

eoValueParam<double> uRateParam(2, "uRate", "Relative rate for uniform crossover", 'U');
parser.processParam( uRateParam, "Genetic Operators" );
double URate =  uRateParam.value();

// relative rates and private parameters for mutations;
eoValueParam<double> pMutPerBitParam(0.01, "pMutPerBit", "Probability of flipping 1 bit in bit-flip mutation", 'b');
parser.processParam( pMutPerBitParam, "Genetic Operators" );
double pMutPerBit = pMutPerBitParam.value();

eoValueParam<double> bitFlipRateParam(0.01, "bitFlipRate", "Relative rate for bit-flip mutation", 'B');
parser.processParam( bitFlipRateParam, "Genetic Operators" );
double bitFlipRate =  bitFlipRateParam.value();

eoValueParam<double> oneBitRateParam(0.01, "oneBitRate", "Relative rate for deterministic bit-flip mutation", 'D');
parser.processParam( oneBitRateParam, "Genetic Operators" );
double oneBitRate = oneBitRateParam.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",'S');
parser.processParam( statusParam, "Persistence" );

// i.e. in case you need parameters somewhere else, postpone these
if (parser.userNeedsHelp())
if (statusParam.value() != "")
      ofstream os(statusParam.value().c_str());
      os << parser; // and you can use that file as parameter file

 // Fitness function
 // Evaluation: from a plain C++ fn to an EvalFunc Object ...
 eoEvalFuncPtr<Indi, double, const vector<bool>& > plainEval( binary_value );
// ... to an object that counts the nb of actual evaluations
 eoEvalFuncCounter<Indi> eval(plainEval);
 // Initilisation of population
 // Either load or initialize
 // create an empty pop
 eoPop<Indi> pop;
 // create a state for reading
 eoState inState; // a state for loading - WITHOUT the parser
// register the rng and the pop in the state, so they can be loaded,
 // and the present run will be the exact conitnuation of the saved run
 // eventually with different parameters

if (load_name != "")
         inState.load(load_name); //  load the pop and the rng
       // the fitness is read in the file: 
       // do only evaluate the pop if the fitness has changed
       // a Indi random initializer
       // based on eoUniformGenerator class (see utils/eoRndGenerators.h)
       eoUniformGenerator<bool> uGen;
       eoInitFixedLength<Indi> random(vecSize, uGen);
       // Init pop from the randomizer: need to use the append function
         pop.append(popSize, random); 
       // and evaluate pop (STL syntax) 
         apply<Indi>(eval, pop);
     } // end of initialization of the population

 // sort pop for pretty printout
 // Print (sorted) intial population (raw printout)
 cout << "Initial Population" << endl << pop << endl;
 // selection and replacement
 // The robust tournament selection
 eoDetTournamentSelect<Indi> selectOne(tSize);       // tSize in [2,POPSIZE]
 // is now encapsulated in a eoSelectPerc (entage)
 eoSelectPerc<Indi> select(selectOne);
 // or eoSelectPerc<Indi> select(selectOne, rate); 
 // but by default rate==1
 // And we now have the full slection/replacement - though with 
 // the same generational replacement at the moment :-)
 eoGenerationalReplacement<Indi> replace; 
 // The variation operators
 // 1-point crossover for bitstring
 eo1PtBitXover<Indi> xover1;
 // uniform crossover for bitstring
 eoUBitXover<Indi> xoverU;
 // 2-pots xover
 eoNPtsBitXover<Indi> xover2(2);
 // Combine them with relative rates
 eoPropCombinedQuadOp<Indi> xover(xover1, onePointRate);
 xover.add(xoverU, URate);
 xover.add(xover2, twoPointsRate, true);
 // standard bit-flip mutation for bitstring
 eoBitMutation<Indi>  mutationBitFlip(pMutPerBit);
 // mutate exactly 1 bit per individual
 eoDetBitFlip<Indi> mutationOneBit; 
 // Combine them with relative rates
 eoPropCombinedMonOp<Indi> mutation(mutationBitFlip, bitFlipRate);
 mutation.add(mutationOneBit, oneBitRate, true);
 // The operators are  encapsulated into an eoTRansform object
 eoSGATransform<Indi> transform(xover, pCross, mutation, pMut);
 // termination condition see FirstBitEA.cpp
 eoGenContinue<Indi> genCont(maxGen);
 eoSteadyFitContinue<Indi> steadyCont(minGen, steadyGen);
 eoFitContinue<Indi> fitCont(vecSize);
 eoCombinedContinue<Indi> continuator(genCont);
 // but now you want to make many different things every generation 
 // (e.g. statistics, plots, ...).
 // the class eoCheckPoint is dedicated to just that:
 // Declare a checkpoint (from a continuator: an eoCheckPoint 
 // IS AN eoContinue and will be called in the loop of all algorithms)
 eoCheckPoint<Indi> checkpoint(continuator);

  // Create a counter parameter
     eoValueParam<unsigned> generationCounter(0, "Gen.");

   // Create an incrementor (sub-class of eoUpdater). Note that the 
     // parameter's value is passed by reference, 
     // so every time the incrementer is updated (every generation),
     // the data in generationCounter will change.
     eoIncrementor<unsigned> increment(generationCounter.value());
  // Add it to the checkpoint, 
     // so the counter is updated (here, incremented) every generation
  // now some statistics on the population:
     // Best fitness in population
     eoBestFitnessStat<Indi> bestStat;
     // Second moment stats: average and stdev
     eoSecondMomentStats<Indi> SecondStat;
   // Add them to the checkpoint to get them called at the appropriate time
     // The Stdout monitor will print parameters to the screen ...
     eoStdoutMonitor monitor(false);

     // when called by the checkpoint (i.e. at every generation)
     // the monitor will output a series of parameters: add them 
     monitor.add(eval); // because now eval is an eoEvalFuncCounter!
     // A file monitor: will print parameters to ... a File, yes, you got it!
     eoFileMonitor fileMonitor("stats.xg", " ");

     // the checkpoint mechanism can handle multiple monitors
     // the fileMonitor can monitor parameters, too, but you must tell it!
     // Last type of item the eoCheckpoint can handle: state savers:
     eoState outState;
     // Register the algorithm into the state
     // and feed the state to state savers
// save state every 100th  generation
     eoCountedStateSaver stateSaver1(100, outState, "generation"); 
     // save state every 1 seconds 
     eoTimedStateSaver    stateSaver2(1, outState, "time"); 
  // Don't forget to add the two savers to the checkpoint
     // and that's it for the (control and) output

 // the algorithm
 // Easy EA requires 
 // stopping criterion, eval, selection, transformation, replacement
 eoEasyEA<Indi> gga(checkpoint, eval, select, transform, replace);
 // Apply algo to pop - that's it!
 // Print (sorted) final population
 cout << "FINAL Population\n" << pop << endl;
// A main that catches the exceptions
int main(int argc, char **argv)
#ifdef _MSC_VER
     int flag = _CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF);
       flag |= _CRTDBG_LEAK_CHECK_DF;
//    _CrtSetBreakAlloc(100);
             main_function(argc, argv);
     catch(exception& e)
             cout << "Exception: " << e.what() << '\n';
     return 1;

Back to Lesson 3 - Tutorial main page - Algorithm-Based - Component-Based - Programming hints - EO documentation
Marc Schoenauer

Last modified: Sun Nov 26 09:31:04 2000