Migration from SVN

eo/tutorial/Lesson1/CMakeLists.txt

@@ -0,0 +1,64 @@
+######################################################################################
+### 1) Include the sources
+######################################################################################
+
+INCLUDE_DIRECTORIES(${EO_SOURCE_DIR}/src)
+INCLUDE_DIRECTORIES(${EO_SOURCE_DIR}/src/ga)
+INCLUDE_DIRECTORIES(${EO_SOURCE_DIR}/src/utils)
+
+######################################################################################
+### 2) Specify where CMake can find the libraries
+######################################################################################
+
+IF(NOT WIN32 OR CYGWIN)
+  LINK_DIRECTORIES(${EO_BINARY_DIR}/lib)
+ENDIF(NOT WIN32 OR CYGWIN)
+
+# especially for Visual Studio
+IF(WIN32 AND NOT CYGWIN)
+  	LINK_DIRECTORIES(${EO_BINARY_DIR}\\lib\\${CMAKE_BUILD_TYPE})
+ENDIF(WIN32 AND NOT CYGWIN)
+
+######################################################################################
+### 3) Define your targets
+######################################################################################
+
+# no matter what is the OS, hopefully
+ADD_EXECUTABLE(FirstBitGA FirstBitGA.cpp)
+ADD_EXECUTABLE(FirstRealGA FirstRealGA.cpp)
+ADD_EXECUTABLE(exercise1.3 exercise1.3.cpp)
+
+ADD_DEPENDENCIES(FirstBitGA ga eo eoutils)
+ADD_DEPENDENCIES(FirstRealGA ga eo eoutils)
+ADD_DEPENDENCIES(exercise1.3 ga eo eoutils)
+
+######################################################################################
+### 4) Optionnal
+######################################################################################
+
+SET(FIRSTBITGA_VERSION ${GLOBAL_VERSION})
+SET_TARGET_PROPERTIES(FirstBitGA PROPERTIES VERSION "${FIRSTBITGA_VERSION}")
+
+SET(FIRSTREALGA_VERSION ${GLOBAL_VERSION})
+SET_TARGET_PROPERTIES(FirstRealGA PROPERTIES VERSION "${FIRSTREALGA_VERSION}")
+
+SET(EXERCICE13_VERSION ${GLOBAL_VERSION})
+SET_TARGET_PROPERTIES(exercise1.3 PROPERTIES VERSION "${EXERCICE13_VERSION}")
+
+######################################################################################
+### 5) Link the librairies for the targets
+######################################################################################
+
+TARGET_LINK_LIBRARIES(FirstBitGA ga eo eoutils)
+TARGET_LINK_LIBRARIES(FirstRealGA ga eo eoutils)
+TARGET_LINK_LIBRARIES(exercise1.3 ga eo eoutils)
+
+######################################################################################
+### 6) Configure project installation paths
+######################################################################################
+
+INSTALL(TARGETS FirstBitGA RUNTIME DESTINATION local/share${INSTALL_SUB_DIR}/eo/examples/Lesson1 COMPONENT examples)
+INSTALL(TARGETS FirstRealGA RUNTIME DESTINATION local/share${INSTALL_SUB_DIR}/eo/examples/Lesson1 COMPONENT examples)
+INSTALL(TARGETS exercise1.3 RUNTIME DESTINATION local/share${INSTALL_SUB_DIR}/eo/examples/Lesson1 COMPONENT examples)
+
+######################################################################################

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;
+}

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;
+}

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 *~

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;
+}