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

FirstBitGA.html

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.

 
//-----------------------------------------------------------------------------
// FirstBitGA.cpp
//-----------------------------------------------------------------------------
//*
// An instance of a VERY simple Bitstring Genetic Algorithm
//
//-----------------------------------------------------------------------------
// standard includes
#include <stdexcept>  // runtime_error
#include <iostream>    // cout
#include <strstream>  // ostrstream, istrstream
// the general include for eo
#include <eo>
//-----------------------------------------------------------------------------
// define your individuals
typedef eoBin<double> Indi;        // A bitstring with fitness double
//-----------------------------------------------------------------------------
// a simple fitness function that computes the number of ones of a bitstring
//  @param _indi A biststring individual
double binary_value(const Indi & _indi)
{
 double sum = 0;
 for (unsigned i = 0; i < _indi.size(); i++)
     sum += _indi[i];
 return sum;
}
//-----------------------------------------------------------------------------
void main_function(int argc, char **argv)
{
 // all parameters are hard-coded!
 const unsigned int SEED = 42;          // seed for random number generator
 const unsigned int T_SIZE = 3;        // size for tournament selection
 const unsigned int VEC_SIZE = 8;    // Number of bits in genotypes
 const unsigned int POP_SIZE = 20;  // Size of population
 const unsigned int MAX_GEN = 100;  // Maximum number of generation before STOP
 const float CROSS_RATE = 0.8;          // Crossover rate
 const double P_MUT_PER_BIT = 0.01; // probability of bit-flip mutation
 const float MUT_RATE = 1.0;              // mutation rate
 //////////////////////////
 //  Random seed
 //////////////////////////
 //reproducible random seed: if you don't change SEED above,
 // you'll aways get the same result, NOT a random run
 rng.reseed(SEED);
 /////////////////////////////
 // Fitness function
 ////////////////////////////
 // Evaluation: from a plain C++ fn to an EvalFunc Object
 eoEvalFuncPtr<Indi> eval(  binary_value );
 ////////////////////////////////
 // Initilisation of population
 ////////////////////////////////
 // declare the population
 eoPop<Indi> pop;
 // fill it!
 for (unsigned int igeno=0; igeno<POP_SIZE; igeno++)
     {
         Indi v;                    // void individual, to be filled
         for (unsigned ivar=0; ivar<VEC_SIZE; ivar++)
             {
                 bool r = rng.flip(); // new value, random in {0,1}
                 v.push_back(r);          // append that random value to v
             }
         eval(v);                                // evaluate it
         pop.push_back(v);              // and put it in the population
     }
 // sort pop before printing it!
 pop.sort();
 // Print (sorted) intial population (raw printout)
 cout << "Initial Population" << endl;
 cout << pop;
 /////////////////////////////////////
 // selection and replacement
 ////////////////////////////////////
 // The robust tournament selection
 eoDetTournament<Indi> select(T_SIZE);  // T_SIZE in [2,POP_SIZE]
 // The simple GA evolution engine uses generational replacement
 // so no replacement procedure is needed
 //////////////////////////////////////
 // The variation operators
 //////////////////////////////////////
 // 1-point mutation for bitstring
 eoBinCrossover<Indi> xover;
 
 // standard bit-flip mutation for bitstring
 eoBinMutation<Indi>  mutation(P_MUT_PER_BIT);
 //////////////////////////////////////
 // termination condition
 /////////////////////////////////////
 // stop after MAX_GEN generations
 eoGenContinue<Indi> continuator(MAX_GEN);
 
 /////////////////////////////////////////
 // the algorithm
 ////////////////////////////////////////
 // standard Generational GA requires as parameters
 // selection, evaluation, crossover and mutation, stopping criterion

 eoSGA<Indi> gga(select, xover, CROSS_RATE, mutation, MUT_RATE,
                                 eval, continuator);
 // Apply algo to pop - that's it!
 gga(pop);
 
 // Print (sorted) intial population
 pop.sort();
 cout << "FINAL Population\n" << pop << endl;
}
// A main that catches the exceptions
int main(int argc, char **argv)
{
#ifdef _MSC_VER
 //  rng.reseed(42);
     int flag = _CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF);
       flag |= _CRTDBG_LEAK_CHECK_DF;
     _CrtSetDbgFlag(flag);
//    _CrtSetBreakAlloc(100);
#endif
     try
     {
             main_function(argc, argv);
     }
     catch(exception& e)
     {
             cout << "Exception: " << e.what() << '\n';
     }
     return 1;
}
Back to Lesson 1 - Tutorial main page - Algorithm-Based - Component-Based page - Programming hints - EO documentation
Marc Schoenauer

Last modified: Sun Nov 19 08:31:26 2000