Paradiseo-eo sources added

git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@40 331e1502-861f-0410-8da2-ba01fb791d7f

trunk/paradiseo-eo/tutorial/.cvsignore

@@ -0,0 +1 @@
+Makefile.in

trunk/paradiseo-eo/tutorial/CVS/Entries

@@ -0,0 +1,6 @@
+/.cvsignore/1.1/Fri Sep 17 16:53:15 2004//
+/Makefile.am/1.3/Tue Feb 22 14:12:19 2005//
+/Makefile.simple/1.1/Fri Sep 17 15:20:15 2004//
+/README/1.4/Tue Dec 19 18:18:08 2000//
+/index.html/1.3/Thu Jan  4 15:23:14 2001//
+D

trunk/paradiseo-eo/tutorial/CVS/Entries.Log

@@ -0,0 +1,10 @@
+A D/Lesson1////
+A D/Lesson2////
+A D/Lesson3////
+A D/Lesson4////
+A D/Lesson5////
+A D/ParadisEO////
+A D/Templates////
+A D/examples////
+A D/html////
+A D/pdf////

trunk/paradiseo-eo/tutorial/CVS/Repository

@@ -0,0 +1 @@
+eo/tutorial

trunk/paradiseo-eo/tutorial/CVS/Root

@@ -0,0 +1 @@
+:ext:evomarc@eodev.cvs.sourceforge.net:/cvsroot/eodev

trunk/paradiseo-eo/tutorial/Lesson1/.cvsignore

@@ -0,0 +1 @@
+Makefile.in

trunk/paradiseo-eo/tutorial/Lesson1/CVS/Entries

@@ -0,0 +1,7 @@
+/.cvsignore/1.1/Fri Sep 17 16:53:14 2004//
+/FirstBitGA.cpp/1.10/Wed Sep 28 21:49:26 2005//
+/FirstRealGA.cpp/1.9/Wed Sep 28 21:49:26 2005//
+/Makefile.am/1.2/Wed Sep 22 18:18:30 2004//
+/Makefile.simple/1.1/Fri Sep 17 15:20:17 2004//
+/exercise1.3.cpp/1.7/Wed Sep 28 21:49:26 2005//
+D

trunk/paradiseo-eo/tutorial/Lesson1/CVS/Repository

@@ -0,0 +1 @@
+eo/tutorial/Lesson1

trunk/paradiseo-eo/tutorial/Lesson1/CVS/Root

@@ -0,0 +1 @@
+:ext:evomarc@eodev.cvs.sourceforge.net:/cvsroot/eodev

trunk/paradiseo-eo/tutorial/Lesson1/FirstBitGA.cpp

@@ -0,0 +1,167 @@
+//-----------------------------------------------------------------------------
+// FirstBitGA.cpp
+//-----------------------------------------------------------------------------
+//*
+// An instance of a VERY simple Bitstring Genetic Algorithm
+//
+//-----------------------------------------------------------------------------
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdexcept>
+#include <iostream>
+
+#include <eo>
+#include <ga.h>
+
+// Use functions from namespace std
+using namespace std;
+
+// REPRESENTATION
+//-----------------------------------------------------------------------------
+// define your individuals
+typedef eoBit<double> Indi;     // A bitstring with fitness double
+
+// EVAL
+//-----------------------------------------------------------------------------
+// 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;
+}
+// GENERAL
+//-----------------------------------------------------------------------------
+void main_function(int argc, char **argv)
+{
+// PARAMETRES
+  // 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 = 16;   // Number of bits in genotypes
+  const unsigned int POP_SIZE = 100;  // Size of population
+  const unsigned int MAX_GEN = 400;  // 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
+
+// GENERAL
+  //////////////////////////
+  //  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);
+
+// EVAL
+  /////////////////////////////
+  // Fitness function
+  ////////////////////////////
+  // Evaluation: from a plain C++ fn to an EvalFunc Object
+  eoEvalFuncPtr<Indi> eval(  binary_value );
+
+// INIT
+  ////////////////////////////////
+  // 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
+    }
+
+// OUTPUT
+  // sort pop before printing it!
+  pop.sort();
+  // Print (sorted) intial population (raw printout)
+  cout << "Initial Population" << endl;
+  cout << pop;
+  // shuffle  - this is a test
+  pop.shuffle();
+  // Print (sorted) intial population (raw printout)
+  cout << "Shuffled Population" << endl;
+  cout << pop;
+
+// ENGINE
+  /////////////////////////////////////
+  // selection and replacement
+  ////////////////////////////////////
+// SELECT
+  // The robust tournament selection
+  eoDetTournamentSelect<Indi> select(T_SIZE);  // T_SIZE in [2,POP_SIZE]
+
+// REPLACE
+  // The simple GA evolution engine uses generational replacement
+  // so no replacement procedure is needed
+
+// OPERATORS
+  //////////////////////////////////////
+  // The variation operators
+  //////////////////////////////////////
+// CROSSOVER
+  // 1-point crossover for bitstring
+  eo1PtBitXover<Indi> xover;
+// MUTATION
+  // standard bit-flip mutation for bitstring
+  eoBitMutation<Indi>  mutation(P_MUT_PER_BIT);
+
+// STOP
+// CHECKPOINT
+  //////////////////////////////////////
+  // termination condition
+  /////////////////////////////////////
+  // stop after MAX_GEN generations
+  eoGenContinue<Indi> continuator(MAX_GEN);
+
+// GENERATION
+  /////////////////////////////////////////
+  // 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);
+
+// OUTPUT
+  // Print (sorted) intial population
+  pop.sort();
+  cout << "FINAL Population\n" << pop << endl;
+// GENERAL
+}
+ // A main that catches the exceptions
+
+int main(int argc, char **argv)
+{
+
+    try
+    {
+        main_function(argc, argv);
+    }
+    catch(exception& e)
+    {
+        cout << "Exception: " << e.what() << '\n';
+    }
+
+    return 1;
+}

trunk/paradiseo-eo/tutorial/Lesson1/FirstRealGA.cpp

@@ -0,0 +1,162 @@
+//-----------------------------------------------------------------------------
+// FirstRealGA.cpp
+//-----------------------------------------------------------------------------
+//*
+// An instance of a VERY simple Real-coded Genetic Algorithm
+//
+//-----------------------------------------------------------------------------
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdexcept>
+#include <iostream>
+#include <sstream>
+
+#include <eo>
+#include <es.h>
+
+// Use functions from namespace std
+using namespace std;
+
+// REPRESENTATION
+//-----------------------------------------------------------------------------
+// define your individuals
+ typedef eoReal<double> Indi;
+
+// EVAL
+//-----------------------------------------------------------------------------
+// a simple fitness function that computes the euclidian norm of a real vector
+//    @param _indi A real-valued individual
+
+double real_value(const Indi & _indi)
+{
+  double sum = 0;
+  for (unsigned i = 0; i < _indi.size(); i++)
+      sum += _indi[i]*_indi[i];
+  return (-sum);            // maximizing only
+}
+// GENERAL
+//-----------------------------------------------------------------------------
+void main_function(int argc, char **argv)
+{
+// PARAMETRES
+  // all parameters are hard-coded!
+  const unsigned int SEED = 42; // seed for random number generator
+  const unsigned int VEC_SIZE = 8; // Number of object variables in genotypes
+  const unsigned int POP_SIZE = 20; // Size of population
+  const unsigned int T_SIZE = 3; // size for tournament selection
+  const unsigned int MAX_GEN = 500; // Maximum number of generation before STOP
+  const float CROSS_RATE = 0.8; // Crossover rate
+  const double EPSILON = 0.01;  // range for real uniform mutation
+  const float MUT_RATE = 0.5;   // mutation rate
+
+// GENERAL
+  //////////////////////////
+  //  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);
+
+// EVAL
+  /////////////////////////////
+  // Fitness function
+  ////////////////////////////
+  // Evaluation: from a plain C++ fn to an EvalFunc Object
+  eoEvalFuncPtr<Indi> eval(  real_value );
+
+// INIT
+  ////////////////////////////////
+  // 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++)
+        {
+          double r = 2*rng.uniform() - 1; // new value, random in [-1,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
+    }
+
+// OUTPUT
+  // sort pop before printing it!
+  pop.sort();
+  // Print (sorted) intial population (raw printout)
+  cout << "Initial Population" << endl;
+  cout << pop;
+
+// ENGINE
+  /////////////////////////////////////
+  // selection and replacement
+  ////////////////////////////////////
+// SELECT
+  // The robust tournament selection
+  eoDetTournamentSelect<Indi> select(T_SIZE);       // T_SIZE in [2,POP_SIZE]
+
+// REPLACE
+  // eoSGA uses generational replacement by default
+  // so no replacement procedure has to be given
+
+// OPERATORS
+  //////////////////////////////////////
+  // The variation operators
+  //////////////////////////////////////
+// CROSSOVER
+  // offspring(i) is a linear combination of parent(i)
+  eoSegmentCrossover<Indi> xover;
+// MUTATION
+  // offspring(i) uniformly chosen in [parent(i)-epsilon, parent(i)+epsilon]
+  eoUniformMutation<Indi>  mutation(EPSILON);
+
+// STOP
+// CHECKPOINT
+  //////////////////////////////////////
+  // termination condition
+  /////////////////////////////////////
+  // stop after MAX_GEN generations
+  eoGenContinue<Indi> continuator(MAX_GEN);
+
+// GENERATION
+  /////////////////////////////////////////
+  // the algorithm
+  ////////////////////////////////////////
+  // standard Generational GA requires
+  // 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);
+
+// OUTPUT
+  // Print (sorted) intial population
+  pop.sort();
+  cout << "FINAL Population\n" << pop << endl;
+// GENERAL
+}
+
+// A main that catches the exceptions
+
+int main(int argc, char **argv)
+{
+    try
+    {
+        main_function(argc, argv);
+    }
+    catch(exception& e)
+    {
+        cout << "Exception: " << e.what() << '\n';
+    }
+
+    return 1;
+}

trunk/paradiseo-eo/tutorial/Lesson1/Makefile.am

@@ -0,0 +1,16 @@
+
+noinst_PROGRAMS		= FirstBitGA FirstRealGA exercise1.3
+
+FirstBitGA_SOURCES	= FirstBitGA.cpp
+
+FirstRealGA_SOURCES	= FirstRealGA.cpp
+
+exercise1_3_SOURCES	= exercise1.3.cpp
+
+
+LDADD			= -L$(top_builddir)/src -L$(top_builddir)/src/ga -L$(top_builddir)/src/utils
+
+LIBS			=  -lga -leoutils -leo
+
+INCLUDES		= -I$(top_srcdir)/src
+

trunk/paradiseo-eo/tutorial/Lesson1/Makefile.simple

@@ -0,0 +1,25 @@
+# if you use this Makefile as a starting point for another application
+# you might need to modify the following
+DIR_EO = ../../src
+
+.SUFFIXES: .cpp
+
+# Warning: $(CXX) in Linux (RedHat and Mandrake at least) is g++
+# However, if you are using this Makefile within xemacs, 
+# and have problems with the interpretation of the output (and its colors)
+# then you should use c++ instead (make CXX=c++ will do)
+
+.cpp: ; $(CXX)  -DPACKAGE=\"eo\" -DVERSION=\"0.9.3\" -I. -I$(DIR_EO) -Wall -g -pg  -o $@  $*.cpp $(DIR_EO)/utils/libeoutils.a $(DIR_EO)/libeo.a 
+
+.cpp.o: ; $(CXX) -DPACKAGE=\"eo\" -DVERSION=\"0.9.3\" -I. -I$(DIR_EO) -Wall -g -c -pg $*.cpp
+
+firstGA = FirstRealGA FirstBitGA
+
+ALL = $(firstGA) exercise1.3
+
+lesson1 : $(firstGA)
+
+all : $(ALL)
+
+clean : 
+	@/bin/rm $(ALL) *.o *~

trunk/paradiseo-eo/tutorial/Lesson1/exercise1.3.cpp

@@ -0,0 +1,162 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+//-----------------------------------------------------------------------------
+// FirstBitGA.cpp
+//-----------------------------------------------------------------------------
+//*
+// An instance of a VERY simple Bitstring Genetic Algorithm
+//
+//-----------------------------------------------------------------------------
+// standard includes
+#include <iostream>
+#include <stdexcept>
+
+// the general include for eo
+#include <eo>
+
+//-----------------------------------------------------------------------------
+// Include the corresponding file
+#include <ga.h>	         // bitstring representation & operators
+// define your individuals
+typedef eoBit<double> Indi;	// A bitstring with fitness double
+
+using namespace std;
+
+//-----------------------------------------------------------------------------
+/** 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)
+{
+  const unsigned int SEED = 42;	// seed for random number generator
+  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 = 500; // 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
+  ////////////////////////////////////
+
+  // solution solution solution: uncomment one of the following,
+  //                             comment out the eoDetTournament lines
+
+  // The well-known roulette
+  // eoProportionalSelect<Indi> select;
+
+  // could also use stochastic binary tournament selection
+  //
+  //  const double RATE = 0.75;
+  //  eoStochTournamentSelect<Indi> select(RATE);     // RATE in ]0.5,1]
+  // The robust tournament selection
+  const unsigned int T_SIZE = 3; // size for tournament selection
+  eoDetTournamentSelect<Indi> select(T_SIZE);       // T_SIZE in [2,POP_SIZE]
+
+  // and of course the random selection
+  // eoRandomSelect<Indi> select;
+
+  // The simple GA evolution engine uses generational replacement
+  // so no replacement procedure is needed
+
+  //////////////////////////////////////
+  // termination condition
+  /////////////////////////////////////
+  // stop after MAX_GEN generations
+  eoGenContinue<Indi> continuator(MAX_GEN);
+
+
+  //////////////////////////////////////
+  // The variation operators
+  //////////////////////////////////////
+  // standard bit-flip mutation for bitstring
+  eoBitMutation<Indi>  mutation(P_MUT_PER_BIT);
+  // 1-point mutation for bitstring
+  eo1PtBitXover<Indi> xover;
+
+  /////////////////////////////////////////
+  // 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)
+{
+
+    try
+    {
+        main_function(argc, argv);
+    }
+    catch(exception& e)
+    {
+        cout << "Exception: " << e.what() << '\n';
+    }
+
+    return 1;
+}

trunk/paradiseo-eo/tutorial/Lesson2/.cvsignore

@@ -0,0 +1 @@
+Makefile.in

trunk/paradiseo-eo/tutorial/Lesson2/CVS/Entries

@@ -0,0 +1,9 @@
+/.cvsignore/1.1/Fri Sep 17 16:53:14 2004//
+/FirstBitEA.cpp/1.11/Wed Sep 28 21:49:26 2005//
+/FirstRealEA.cpp/1.14/Wed Sep 28 21:49:26 2005//
+/Makefile.am/1.3/Sun Oct  2 21:42:08 2005//
+/Makefile.simple/1.1/Fri Sep 17 15:20:18 2004//
+/binary_value.h/1.2/Thu Feb 27 19:19:51 2003//
+/exercise2.3.cpp/1.8/Wed Sep 28 21:49:26 2005//
+/real_value.h/1.3/Tue Feb 27 05:09:09 2001//
+D

trunk/paradiseo-eo/tutorial/Lesson2/CVS/Repository

@@ -0,0 +1 @@
+eo/tutorial/Lesson2

trunk/paradiseo-eo/tutorial/Lesson2/CVS/Root

@@ -0,0 +1 @@
+:ext:evomarc@eodev.cvs.sourceforge.net:/cvsroot/eodev

trunk/paradiseo-eo/tutorial/Lesson2/FirstBitEA.cpp

@@ -0,0 +1,193 @@
+//-----------------------------------------------------------------------------
+// FirstBitEA.cpp
+//-----------------------------------------------------------------------------
+//*
+// Still an instance of a VERY simple Bitstring Genetic Algorithm
+// (see FirstBitGA.cpp) but now with  Breeder - and Combined Ops
+//
+//-----------------------------------------------------------------------------
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+// standard includes
+#include <stdexcept>  // runtime_error
+#include <iostream>   // cout
+
+// the general include for eo
+#include <eo>
+#include <ga.h>
+
+// Use functions from namespace std
+using namespace std;
+
+// REPRESENTATION
+//-----------------------------------------------------------------------------
+// define your individuals
+typedef eoBit<double> Indi;	// A bitstring with fitness double
+
+// EVALFUNC
+//-----------------------------------------------------------------------------
+// a simple fitness function that computes the number of ones of a bitstring
+// Now in a separate file, and declared as binary_value(const vector<bool> &)
+
+#include "binary_value.h"
+
+// GENERAL
+//-----------------------------------------------------------------------------
+
+void main_function(int argc, char **argv)
+{
+// PARAMETRES
+  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 = 500; // Maximum number of generation before STOP
+  const unsigned int MIN_GEN = 10;  // Minimum number of generation before ...
+  const unsigned int STEADY_GEN = 50; // stop after STEADY_GEN gen. without improvelent
+
+  const double P_CROSS = 0.8;	// Crossover probability
+  const double P_MUT = 1.0;	// mutation probability
+
+  const double P_MUT_PER_BIT = 0.01;	// internal probability for bit-flip mutation
+  // some parameters for chosing among different operators
+  const double onePointRate = 0.5;     // rate for 1-pt Xover
+  const double twoPointsRate = 0.5;     // rate for 2-pt Xover
+  const double URate = 0.5;            // rate for Uniform Xover
+  const double bitFlipRate = 0.5;      // rate for bit-flip mutation
+  const double oneBitRate = 0.5;       // rate for one-bit mutation
+
+// GENERAL
+  //////////////////////////
+  //  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);
+
+// EVAL
+  /////////////////////////////
+  // Fitness function
+  ////////////////////////////
+  // Evaluation: from a plain C++ fn to an EvalFunc Object
+  // you need to give the full description of the function
+  eoEvalFuncPtr<Indi, double, const vector<bool>& > eval(  binary_value );
+
+// INIT
+  ////////////////////////////////
+  // Initilisation of population
+  ////////////////////////////////
+
+  // based on boolean_generator class (see utils/eoRndGenerators.h)
+  eoUniformGenerator<bool> uGen;
+  eoInitFixedLength<Indi> random(VEC_SIZE, uGen);
+  // Initialization of the population
+  eoPop<Indi> pop(POP_SIZE, random);
+
+  // and evaluate it in one loop
+  apply<Indi>(eval, pop);	// STL syntax
+
+// OUTPUT
+  // sort pop before printing it!
+  pop.sort();
+  // Print (sorted) intial population (raw printout)
+  cout << "Initial Population" << endl;
+  cout << pop;
+
+// ENGINE
+  /////////////////////////////////////
+  // selection and replacement
+  ////////////////////////////////////
+// SELECT
+  // The robust tournament selection
+  eoDetTournamentSelect<Indi> selectOne(T_SIZE);       // T_SIZE in [2,POP_SIZE]
+  // is now encapsulated in a eoSelectPerc (entage)
+  eoSelectPerc<Indi> select(selectOne);// by default rate==1
+
+// REPLACE
+  // And we now have the full slection/replacement - though with
+  // no replacement (== generational replacement) at the moment :-)
+  eoGenerationalReplacement<Indi> replace;
+
+// OPERATORS
+  //////////////////////////////////////
+  // The variation operators
+  //////////////////////////////////////
+// CROSSOVER
+  // 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);
+
+// MUTATION
+  // standard bit-flip mutation for bitstring
+  eoBitMutation<Indi>  mutationBitFlip(P_MUT_PER_BIT);
+  // 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, P_CROSS, mutation, P_MUT);
+
+// STOP
+// CHECKPOINT
+  //////////////////////////////////////
+  // termination conditions: use more than one
+  /////////////////////////////////////
+  // stop after MAX_GEN generations
+  eoGenContinue<Indi> genCont(MAX_GEN);
+  // do MIN_GEN gen., then stop after STEADY_GEN gen. without improvement
+  eoSteadyFitContinue<Indi> steadyCont(MIN_GEN, STEADY_GEN);
+  // stop when fitness reaches a target (here VEC_SIZE)
+  eoFitContinue<Indi> fitCont(VEC_SIZE);
+  // do stop when one of the above says so
+  eoCombinedContinue<Indi> continuator(genCont);
+  continuator.add(steadyCont);
+  continuator.add(fitCont);
+
+// GENERATION
+  /////////////////////////////////////////
+  // the algorithm
+  ////////////////////////////////////////
+
+  // Easy EA requires
+  // selection, transformation, eval, replacement, and stopping criterion
+  eoEasyEA<Indi> gga(continuator, eval, select, transform, replace);
+
+  // Apply algo to pop - that's it!
+  cout << "\n        Here we go\n\n";
+  gga(pop);
+
+// OUTPUT
+  // Print (sorted) intial population
+  pop.sort();
+  cout << "FINAL Population\n" << pop << endl;
+// GENERAL
+}
+
+// A main that catches the exceptions
+
+int main(int argc, char **argv)
+{
+
+    try
+    {
+        main_function(argc, argv);
+    }
+    catch(exception& e)
+    {
+        cout << "Exception: " << e.what() << '\n';
+    }
+
+    return 1;
+}

trunk/paradiseo-eo/tutorial/Lesson2/FirstRealEA.cpp

@@ -0,0 +1,192 @@
+//-----------------------------------------------------------------------------
+// FirstRealEA.cpp
+//-----------------------------------------------------------------------------
+//*
+// Still an instance of a VERY simple Real-coded  Genetic Algorithm
+// (see FirstBitGA.cpp) but now with  Breeder - and Combined Ops
+//
+//-----------------------------------------------------------------------------
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+// standard includes
+#include <stdexcept>  // runtime_error
+#include <iostream>   // cout
+
+// the general include for eo
+#include <eo>
+#include <es.h>
+
+// REPRESENTATION
+//-----------------------------------------------------------------------------
+// define your individuals
+typedef eoReal<double> Indi;
+
+// Use functions from namespace std
+using namespace std;
+
+// EVALFUNC
+//-----------------------------------------------------------------------------
+// a simple fitness function that computes the euclidian norm of a real vector
+// Now in a separate file, and declared as binary_value(const vector<bool> &)
+
+#include "real_value.h"
+
+// GENERAL
+//-----------------------------------------------------------------------------
+
+void main_function(int argc, char **argv)
+{
+// PARAMETRES
+  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 object variables in genotypes
+  const unsigned int POP_SIZE = 20; // Size of population
+
+  const unsigned int MAX_GEN = 500; // Maximum number of generation before STOP
+  const unsigned int MIN_GEN = 10;  // Minimum number of generation before ...
+  const unsigned int STEADY_GEN = 50; // stop after STEADY_GEN gen. without improvelent
+
+  const float P_CROSS = 0.8;	// Crossover probability
+  const float P_MUT = 0.5;	// mutation probability
+
+  const double EPSILON = 0.01;	// range for real uniform mutation
+  double SIGMA = 0.3;       	// std dev. for normal mutation
+  // some parameters for chosing among different operators
+  const double hypercubeRate = 0.5;     // relative weight for hypercube Xover
+  const double segmentRate = 0.5;  // relative weight for segment Xover
+  const double uniformMutRate = 0.5;  // relative weight for uniform mutation
+  const double detMutRate = 0.5;      // relative weight for det-uniform mutation
+  const double normalMutRate = 0.5;   // relative weight for normal mutation
+
+// GENERAL
+  //////////////////////////
+  //  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);
+
+// EVAL
+  /////////////////////////////
+  // Fitness function
+  ////////////////////////////
+  // Evaluation: from a plain C++ fn to an EvalFunc Object
+  // you need to give the full description of the function
+  eoEvalFuncPtr<Indi, double, const vector<double>& > eval(  real_value );
+
+// INIT
+  ////////////////////////////////
+  // Initilisation of population
+  ////////////////////////////////
+  // based on a uniform generator
+  eoUniformGenerator<double> uGen(-1.0, 1.0);
+  eoInitFixedLength<Indi> random(VEC_SIZE, uGen);
+   // Initialization of the population
+  eoPop<Indi> pop(POP_SIZE, random);
+
+  // and evaluate it in one loop
+  apply<Indi>(eval, pop);	// STL syntax
+
+// OUTPUT
+  // sort pop before printing it!
+  pop.sort();
+  // Print (sorted) intial population (raw printout)
+  cout << "Initial Population" << endl;
+  cout << pop;
+
+// ENGINE
+  /////////////////////////////////////
+  // selection and replacement
+  ////////////////////////////////////
+// SELECT
+  // The robust tournament selection
+  eoDetTournamentSelect<Indi> selectOne(T_SIZE);
+  // is now encapsulated in a eoSelectPerc (entage)
+  eoSelectPerc<Indi> select(selectOne);// by default rate==1
+
+// REPLACE
+  // And we now have the full slection/replacement - though with
+  // no replacement (== generational replacement) at the moment :-)
+  eoGenerationalReplacement<Indi> replace;
+
+// OPERATORS
+  //////////////////////////////////////
+  // The variation operators
+  //////////////////////////////////////
+// CROSSOVER
+  // uniform chooce on segment made by the parents
+  eoSegmentCrossover<Indi> xoverS;
+  // uniform choice in hypercube built by the parents
+  eoHypercubeCrossover<Indi> xoverA;
+  // Combine them with relative weights
+  eoPropCombinedQuadOp<Indi> xover(xoverS, segmentRate);
+  xover.add(xoverA, hypercubeRate, true);
+
+// MUTATION
+  // offspring(i) uniformly chosen in [parent(i)-epsilon, parent(i)+epsilon]
+  eoUniformMutation<Indi>  mutationU(EPSILON);
+  // k (=1) coordinates of parents are uniformly modified
+  eoDetUniformMutation<Indi>  mutationD(EPSILON);
+  // all coordinates of parents are normally modified (stDev SIGMA)
+  eoNormalMutation<Indi>  mutationN(SIGMA);
+  // Combine them with relative weights
+  eoPropCombinedMonOp<Indi> mutation(mutationU, uniformMutRate);
+  mutation.add(mutationD, detMutRate);
+  mutation.add(mutationN, normalMutRate, true);
+
+// STOP
+// CHECKPOINT
+  //////////////////////////////////////
+  // termination conditions: use more than one
+  /////////////////////////////////////
+  // stop after MAX_GEN generations
+  eoGenContinue<Indi> genCont(MAX_GEN);
+  // do MIN_GEN gen., then stop after STEADY_GEN gen. without improvement
+  eoSteadyFitContinue<Indi> steadyCont(MIN_GEN, STEADY_GEN);
+  // stop when fitness reaches a target (here VEC_SIZE)
+  eoFitContinue<Indi> fitCont(0);
+  // do stop when one of the above says so
+  eoCombinedContinue<Indi> continuator(genCont);
+  continuator.add(steadyCont);
+  continuator.add(fitCont);
+
+  // The operators are  encapsulated into an eoTRansform object
+  eoSGATransform<Indi> transform(xover, P_CROSS, mutation, P_MUT);
+
+// GENERATION
+  /////////////////////////////////////////
+  // the algorithm
+  ////////////////////////////////////////
+
+  // Easy EA requires
+  // selection, transformation, eval, replacement, and stopping criterion
+  eoEasyEA<Indi> gga(continuator, eval, select, transform, replace);
+
+  // Apply algo to pop - that's it!
+  cout << "\n        Here we go\n\n";
+  gga(pop);
+
+// OUTPUT
+  // Print (sorted) intial population
+  pop.sort();
+  cout << "FINAL Population\n" << pop << endl;
+// GENERAL
+}
+
+// A main that catches the exceptions
+
+int main(int argc, char **argv)
+{
+    try
+    {
+        main_function(argc, argv);
+    }
+    catch(exception& e)
+    {
+        cout << "Exception: " << e.what() << '\n';
+    }
+
+    return 1;
+}