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

Make sure uint32_t is defined correctly in eoRNG.h and use it where

Browse source 
appropriate.
This commit is contained in:
kuepper 2005-09-26 10:18:15 +00:00
commit 6e0c4a7264
13 changed files with 238 additions and 220 deletions
Download patch file Download diff file Expand all files Collapse all files

3
eo/configure.in
View file

@ -30,6 +30,7 @@ AC_CHECK_PROG(DOXYGEN, doxygen, doxygen, true)
dnl Checks for header files.
AC_HEADER_STDC
AC_CHECK_HEADERS(inttypes.h)
AC_CHECK_HEADERS(limits.h)
AC_CHECK_HEADERS(values.h)
AC_CXX_HAVE_NUMERIC_LIMITS
@ -39,6 +40,8 @@ AC_CXX_NAMESPACES
dnl Checks for typedefs, structures, and compiler characteristics.
AC_C_CONST
AC_C_INLINE
AC_CHECK_SIZEOF([unsigned long])
AC_CHECK_TYPES(uint32_t)
AC_TYPE_SIZE_T
dnl Checks for libraries.

12
eo/src/do/make_pop.h
View file

@ -3,7 +3,7 @@
//-----------------------------------------------------------------------------
// make_pop.h
// (c) Maarten Keijzer, Marc Schoenauer and GeNeura Team, 2001
/*
/*
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
@ -49,7 +49,7 @@ template <class EOT>
eoPop<EOT>& do_make_pop(eoParser & _parser, eoState& _state, eoInit<EOT> & _init)
{
// random seed
eoValueParam<uint32>& seedParam = _parser.createParam(uint32(0), "seed", "Random number seed", 'S');
eoValueParam<uint32_t>& seedParam = _parser.createParam(uint32_t(0), "seed", "Random number seed", 'S');
if (seedParam.value() == 0)
seedParam.value() = time(0);
eoValueParam<unsigned>& popSize = _parser.createParam(unsigned(20), "popSize", "Population Size", 'P', "Evolution Engine");
@ -57,10 +57,10 @@ eoPop<EOT>& do_make_pop(eoParser & _parser, eoState& _state, eoInit<EOT> & _ini
// Either load or initialize
// create an empty pop and let the state handle the memory
eoPop<EOT>& pop = _state.takeOwnership(eoPop<EOT>());
eoValueParam<std::string>& loadNameParam = _parser.createParam(std::string(""), "Load","A save file to restart from",'L', "Persistence" );
eoValueParam<bool> & recomputeFitnessParam = _parser.createParam(false, "recomputeFitness", "Recompute the fitness after re-loading the pop.?", 'r', "Persistence" );
if (loadNameParam.value() != "") // something to load
{
// create another state for reading
@ -71,7 +71,7 @@ eoPop<EOT>& do_make_pop(eoParser & _parser, eoState& _state, eoInit<EOT> & _ini
inState.registerObject(pop);
inState.registerObject(rng);
inState.load(loadNameParam.value()); // load the pop and the rng
// the fitness is read in the file:
// the fitness is read in the file:
// do only evaluate the pop if the fitness has changed
if (recomputeFitnessParam.value())
{
@ -92,7 +92,7 @@ eoPop<EOT>& do_make_pop(eoParser & _parser, eoState& _state, eoInit<EOT> & _ini
}
if (pop.size() < popSize.value()) // missing some guys
{
{
// Init pop from the randomizer: need to use the append function
pop.append(popSize.value(), _init);
}

16
eo/src/ga/make_PBILdistrib.h
View file

@ -3,7 +3,7 @@
//-----------------------------------------------------------------------------
// make_PBILdistrib.h
// (c) Marc Schoenauer, Maarten Keijzer, 2001
/*
/*
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
@ -49,15 +49,15 @@ template <class EOT>
eoPBILDistrib<EOT> & do_make_PBILdistrib(eoParser & _parser, eoState& _state, EOT)
{
// First the random seed
eoValueParam<uint32>& seedParam = _parser.createParam(uint32(0), "seed", "Random number seed", 'S');
eoValueParam<uint32_t>& seedParam = _parser.createParam(uint32_t(0), "seed", "Random number seed", 'S');
if (seedParam.value() == 0)
seedParam.value() = time(0);
// chromosome size:
// chromosome size:
unsigned theSize;
// but it might have been already read in the definition fo the performance
eoParam* ptParam = _parser.getParamWithLongName(std::string("chromSize"));
eoParam* ptParam = _parser.getParamWithLongName(std::string("chromSize"));
if (!ptParam) // not already defined: read it here
{
theSize = _parser.createParam(unsigned(10), "chromSize", "The length of the bitstrings", 'n',"Problem").value();
@ -67,17 +67,17 @@ eoPBILDistrib<EOT> & do_make_PBILdistrib(eoParser & _parser, eoState& _state, E
eoValueParam<unsigned>* ptChromSize = dynamic_cast<eoValueParam<unsigned>*>(ptParam);
theSize = ptChromSize->value();
}
eoPBILDistrib<EOT> * ptDistrib = new eoPBILDistrib<EOT>(theSize);
_state.storeFunctor(ptDistrib);
// now the initialization: read a previously saved distribution, or random
eoValueParam<std::string>& loadNameParam = _parser.createParam(std::string(""), "Load","A save file to restart from",'L', "Persistence" );
eoValueParam<std::string>& loadNameParam = _parser.createParam(std::string(""), "Load","A save file to restart from",'L', "Persistence" );
if (loadNameParam.value() != "") // something to load
{
// create another state for reading
eoState inState; // a state for loading - WITHOUT the parser
// register the rng and the distribution in the state,
// register the rng and the distribution in the state,
// so they can be loaded,
// and the present run will be the exact continuation of the saved run
// eventually with different parameters

101
eo/src/utils/eoRNG.h
View file

@ -1,6 +1,6 @@
/*
* Random number generator adapted from (see comments below)
*
*
* The random number generator is modified into a class
* by Maarten Keijzer (mak@dhi.dk). Also added the Box-Muller
* transformation to generate normal deviates.
@ -70,7 +70,7 @@
//
//
// uint32 must be an unsigned integer type capable of holding at least 32
// uint32_t must be an unsigned integer type capable of holding at least 32
// bits; exactly 32 should be fastest, but 64 is better on an Alpha with
// GCC at -O3 optimization so try your options and see what's best for you
//
@ -81,6 +81,12 @@
#ifndef EO_RANDOM_NUMBER_GENERATOR
#define EO_RANDOM_NUMBER_GENERATOR
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#ifdef HAVE_INTTYPES_H
#include <inttypes.h>
#endif
#include "../eoPersistent.h"
#include "../eoObject.h"
@ -89,7 +95,14 @@
// Unfortunately MSVC's preprocessor does not comprehend sizeof()
// so neat preprocessing tricks will not work
typedef unsigned long uint32; // Compiler and platform dependent!
#if(! (defined HAVE_UINT32_T))
#if(SIZEOF_UNSIGNED_LONG == 4)
typedef unsigned long uint32_t;
#else
#error Need to provide a type for uint32_t in eoRNG.h.
#endif
#endif
//-----------------------------------------------------------------------------
// eoRng
@ -101,7 +114,7 @@ for generating random numbers. The various member functions implement useful fun
for evolutionary algorithms. Included are: rand(), random(), flip() and normal().
Note for people porting EO to other platforms: please make sure that the typedef
uint32 in the file eoRng.h is exactly 32 bits long. It may be longer, but not
uint32_t in the file eoRng.h is exactly 32 bits long. It may be longer, but not
shorter. If it is longer, file compatibility between EO on different platforms
may be broken.
*/
@ -113,8 +126,8 @@ public :
@see reseed to see why the parameter to initialize is doubled
*/
eoRng(uint32 s) : state(0), next(0), left(-1), cached(false), N(624), M(397), K(0x9908B0DFU) {
state = new uint32[N+1];
eoRng(uint32_t s) : state(0), next(0), left(-1), cached(false), N(624), M(397), K(0x9908B0DFU) {
state = new uint32_t[N+1];
initialize(2*s);
}
@ -130,10 +143,10 @@ public :
* the argument to reseed is now doubled before being passed on.
*
* Manually divide the seed by 2 if you want to re-run old runs
*
*
* MS. 5 Oct. 2001
*/
void reseed(uint32 s)
void reseed(uint32_t s)
{
initialize(2*s);
}
@ -141,7 +154,7 @@ public :
/**
Re-initializes the Random Number Generator - old version
*/
void oldReseed(uint32 s)
void oldReseed(uint32_t s)
{
initialize(s);
}
@ -153,37 +166,37 @@ public :
{ // random number between [0, m]
return m * double(rand()) / double(1.0 + rand_max());
}
/**
random() returns a random integer in the range [0, m)
*/
uint32 random(uint32 m)
uint32_t random(uint32_t m)
{
return uint32(uniform() * double(m));
return uint32_t(uniform() * double(m));
}
/**
flip() tosses a biased coin such that flip(x/100.0) will
flip() tosses a biased coin such that flip(x/100.0) will
returns true x% of the time
*/
bool flip(float bias=0.5)
{
return uniform() < bias;
}
/**
normal() zero mean gaussian deviate with standard deviation of 1
*/
double normal(void); // gaussian mutation, stdev 1
double normal(void); // gaussian mutation, stdev 1
/**
normal(stdev) zero mean gaussian deviate with user defined standard deviation
*/
double normal(double stdev)
double normal(double stdev)
{
return stdev * normal();
}
/**
normal(mean, stdev) user defined mean gaussian deviate with user defined standard deviation
*/
@ -203,13 +216,13 @@ public :
/**
rand() returns a random number in the range [0, rand_max)
*/
uint32 rand();
uint32_t rand();
/**
rand_max() the maximum returned by rand()
*/
uint32 rand_max(void) const { return (uint32) 0xffffffff; }
uint32_t rand_max(void) const { return (uint32_t) 0xffffffff; }
/**
roulette_wheel(vec, total = 0) does a roulette wheel selection
on the input std::vector vec. If the total is not supplied, it is
@ -219,11 +232,11 @@ public :
int roulette_wheel(const std::vector<T>& vec, T total = 0)
{
if (total == 0)
{ // count
{ // count
for (unsigned i = 0; i < vec.size(); ++i)
total += vec[i];
}
double fortune = uniform() * total;
int i = 0;
@ -231,19 +244,19 @@ public :
{
fortune -= vec[i++];
}
return --i;
}
/**
/**
* choice(vec), returns a uniformly chosen element from the vector
*/
template <class T>
const T& choice(const std::vector<T>& vec) { return vec[rng.random(vec.size())]; }
template <class T>
T& choice(std::vector<T>& vec) { return vec[rng.random(vec.size())]; }
///
void printOn(std::ostream& _os) const
{
@ -275,11 +288,11 @@ public :
std::string className(void) const { return "Mersenne-Twister"; }
private :
uint32 restart(void);
void initialize(uint32 seed);
uint32_t restart(void);
void initialize(uint32_t seed);
uint32* state; // the array for the state
uint32* next;
uint32_t* state; // the array for the state
uint32_t* next;
int left;
// for normal distribution
@ -288,7 +301,7 @@ private :
const int N;
const int M;
const uint32 K; // a magic constant
const uint32_t K; // a magic constant
/**
@ -319,7 +332,7 @@ using eo::rng;
#define loBits(u) ((u) & 0x7FFFFFFFU) // mask the highest bit of u
#define mixBits(u, v) (hiBit(u)|loBits(v)) // move hi bit of u to hi bit of v
inline void eoRng::initialize(uint32 seed)
inline void eoRng::initialize(uint32_t seed)
{
//
// We initialize state[0..(N-1)] via the generator
@ -369,7 +382,7 @@ inline void eoRng::initialize(uint32 seed)
left = -1;
register uint32 x = (seed | 1U) & 0xFFFFFFFFU, *s = state;
register uint32_t x = (seed | 1U) & 0xFFFFFFFFU, *s = state;
register int j;
for(left=0, *s++=x, j=N; --j;
@ -377,9 +390,9 @@ inline void eoRng::initialize(uint32 seed)
}
inline uint32 eoRng::restart(void)
inline uint32_t eoRng::restart(void)
{
register uint32 *p0=state, *p2=state+2, *pM=state+M, s0, s1;
register uint32_t *p0=state, *p2=state+2, *pM=state+M, s0, s1;
register int j;
left=N-1, next=state+1;
@ -397,10 +410,10 @@ inline uint32 eoRng::restart(void)
return(s1 ^ (s1 >> 18));
}
inline uint32 eoRng::rand(void)
inline uint32_t eoRng::rand(void)
{
uint32 y;
uint32_t y;
if(--left < 0)
return(restart());
@ -428,20 +441,20 @@ inline double eoRng::normal(void)
var2 = 2.0 * uniform() - 1.0;
rSquare = var1 * var1 + var2 * var2;
}
}
while (rSquare >= 1.0 || rSquare == 0.0);
factor = sqrt(-2.0 * log(rSquare) / rSquare);
cacheValue = var1 * factor;
cached = true;
return (var2 * factor);
}
namespace eo {
// a few convenience functions for generating numbers
/**
* Templatized random function, works with most basic types such as:
* char
@ -453,7 +466,7 @@ namespace eo {
template <typename T>
inline
T random(const T& mx) { return static_cast<T>(rng.uniform() * mx); }
/** Normal distribution */
inline double normal() { return rng.normal(); }
}

62
eo/src/utils/rnd_generators.h
View file

@ -8,7 +8,7 @@
normal_generator : normally distributed floats or doubles
(c) Maarten Keijzer (mak@dhi.dk) and GeNeura Team, 1999, 2000
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
@ -36,26 +36,26 @@
/**
The class uniform_generator can be used in the STL generate function
to easily generate random floats and doubles
either in [0, _max) if only 1 value (_max) is given
to easily generate random floats and doubles
either in [0, _max) if only 1 value (_max) is given
(or none, as _max defaults to 1.0)
or in [_min,_max) if 2 values are given (_min, _max)
*/
template <class T = double> class uniform_generator
{
// added new ctor with 2 params, and modified the data to minim and range
// added new ctor with 2 params, and modified the data to minim and range
// (was maxim only). MS 3/11/2000
public :
uniform_generator(T _max = T(1.0), eoRng& _rng = rng) :
uniform_generator(T _max = T(1.0), eoRng& _rng = rng) :
minim(T(0.0)), range(_max), uniform(_rng) {}
uniform_generator(T _min, T _max, eoRng& _rng = rng) :
minim(_min), range(_max-_min), uniform(_rng)
uniform_generator(T _min, T _max, eoRng& _rng = rng) :
minim(_min), range(_max-_min), uniform(_rng)
{
if (_min>_max)
throw std::logic_error("Min is greater than Max in uniform_generator");
throw std::logic_error("Min is greater than Max in uniform_generator");
}
T operator()(void) { return minim+static_cast<T>(uniform.uniform(range)); }
T operator()(void) { return minim+static_cast<T>(uniform.uniform(range)); }
private :
T minim;
@ -71,8 +71,8 @@ class boolean_generator
{
public :
boolean_generator(float _bias = 0.5, eoRng& _rng = rng) : bias(_bias), gen(_rng) {}
bool operator()(void) { return gen.flip(bias); }
bool operator()(void) { return gen.flip(bias); }
private :
float bias;
eoRng& gen;
@ -80,26 +80,26 @@ class boolean_generator
/**
The class random_generator can be used in the STL generate function
to easily generate random ints
to easily generate random ints
either between [0, _max) if only one value (_max) is given to the ctor
or in [_min,_max) if 2 values are given (_min, _max)
*/
template <class T = uint32> class random_generator
template <class T = uint32_t> class random_generator
{
public :
// added new ctor with 2 params, and modified the data to minim and range
// added new ctor with 2 params, and modified the data to minim and range
// (was maxim only). MS 3/11/2000
random_generator(T _max, eoRng& _rng = rng) :
random_generator(T _max, eoRng& _rng = rng) :
minim(T(0.0)), range(_max), random(_rng) {}
random_generator(T _min, T _max, eoRng& _rng = rng) :
minim(_min), range(_max-_min), random(_rng)
random_generator(T _min, T _max, eoRng& _rng = rng) :
minim(_min), range(_max-_min), random(_rng)
{
if (_min>_max)
throw std::logic_error("Min is greater than Max in random_generator");
throw std::logic_error("Min is greater than Max in random_generator");
}
T operator()(void) { return (T) (minim + random.random(range)); }
private :
T minim;
T range;
@ -114,18 +114,18 @@ inline bool random_generator<bool>::operator()(void)
}
/**
Another class random_generator that can be used in the STL random_shuffle
function (see eoPop::shuffle): its operator() takes an unsigned argument m
Another class random_generator that can be used in the STL random_shuffle
function (see eoPop::shuffle): its operator() takes an unsigned argument m
and must return an unsigned uniformly distributed in [0,m}
*/
template <class T = uint32> class UF_random_generator
template <class T = uint32_t> class UF_random_generator
{
public :
UF_random_generator(eoRng& _rng = rng) :
UF_random_generator(eoRng& _rng = rng) :
random(_rng) {}
T operator()(T _t) { return (T) (random.random(_t)); }
private :
eoRng& random;
};
@ -140,9 +140,9 @@ template <class T = double> class normal_generator
{
public :
normal_generator(T _stdev = T(1.0), eoRng& _rng = rng) : stdev(_stdev), normal(_rng) {}
T operator()(void) { return (T) normal.normal(stdev); }
private :
T stdev;
eoRng& normal;
@ -157,9 +157,9 @@ template <class T = double> class negexp_generator
{
public :
negexp_generator(T _mean = 1.0, eoRng& _rng = rng) : mean(_mean), negexp(_rng) {}
T operator()(void) { return (T) negexp.negexp(mean); }
private :
T mean;
eoRng& negexp;

40
eo/test/t-eoCheckpointing.cpp
View file

@ -5,10 +5,10 @@
#pragma warning(disable:4786)
#endif
#include <stdexcept> // runtime_error
#include <stdexcept> // runtime_error
//-----------------------------------------------------------------------------
// tt.cpp:
// tt.cpp:
//
//-----------------------------------------------------------------------------
@ -40,18 +40,18 @@ public :
int the_main(int argc, char **argv)
{ // ok, we have a command line parser and a state
typedef eoBit<float> Chrom;
eoParser parser(argc, argv);
// Define Parameters
eoValueParam<double> rate(0.01, "mutationRatePerBit", "Initial value for mutation rate per bit");
eoValueParam<double> rate(0.01, "mutationRatePerBit", "Initial value for mutation rate per bit");
eoValueParam<double> factor(0.99, "mutationFactor", "Decrease factor for mutation rate");
eoValueParam<uint32> seed(time(0), "seed", "Random number seed");
eoValueParam<uint32_t> seed(time(0), "seed", "Random number seed");
eoValueParam<std::string> load_name("", "Load","Load",'L');
eoValueParam<std::string> save_name("", "Save","Save",'S');
// Register them
parser.processParam(rate, "Genetic Operators");
parser.processParam(factor, "Genetic Operators");
@ -61,27 +61,27 @@ int the_main(int argc, char **argv)
eoState state;
state.registerObject(parser);
if (load_name.value() != "")
{ // load the parser. This is only neccessary when the user wants to
{ // load the parser. This is only neccessary when the user wants to
// be able to change the parameters in the state file by hand.
state.load(load_name.value()); // load the parser
}
// Create the algorithm here
typedef Dummy EoType;
eoDummyPop pop;
eoGenContinue<EoType> genTerm(5); // run for 5 generations
eoCheckPoint<EoType> checkpoint(genTerm);
eoCheckPoint<EoType> checkpoint(genTerm);
// The algorithm will now quit after five generations
// Create a counter parameter
eoValueParam<unsigned> generationCounter(0, "Generation");
// Create an incrementor (wich is an eoUpdater). Note that the
// Create an incrementor (wich is an eoUpdater). Note that the
// Parameter's value is passed by reference, so every time the incrementer increments,
// the data in generationCounter will change.
eoIncrementor<unsigned> increment(generationCounter.value());
@ -91,7 +91,7 @@ int the_main(int argc, char **argv)
// The file monitor will print parameters to a comma seperated file
eoFileMonitor monitor("monitor.csv");
// the checkpoint mechanism can handle multiple monitors
checkpoint.add(monitor);
@ -108,9 +108,9 @@ int the_main(int argc, char **argv)
monitor.add(stats);
// save state every third generation
eoCountedStateSaver stateSaver1(3, state, "generation");
// save state every 2 seconds
eoTimedStateSaver stateSaver2(2, state, "time");
eoCountedStateSaver stateSaver1(3, state, "generation");
// save state every 2 seconds
eoTimedStateSaver stateSaver2(2, state, "time");
// And add the two savers to the checkpoint
checkpoint.add(stateSaver1);
@ -138,7 +138,7 @@ int the_main(int argc, char **argv)
// initialize rng and population
rng.reseed(seed.value());
pop.resize(2);
pop[0].fitness(1);
@ -148,7 +148,7 @@ int the_main(int argc, char **argv)
while(checkpoint(pop))
{
pop[0].fitness(pop[0].fitness() + 1);
time_t now = time(0);
while (time(0) == now) {} // wait a second to test timed saver

33
eo/test/t-eoESFull.cpp
View file

@ -2,7 +2,7 @@
#ifdef _MSC_VER
#pragma warning(disable:4786)
#endif
#endif
#include <algorithm>
#include <string>
@ -20,20 +20,21 @@ using namespace std;
#include "real_value.h" // the sphere fitness
// Now the main
///////////////
// Now the main
///////////////
typedef eoMinimizingFitness FitT;
template <class EOT>
void runAlgorithm(EOT, eoParser& _parser, eoState& _state, eoRealVectorBounds& _bounds, eoValueParam<string> _load_name);
int main_function(int argc, char *argv[])
int main_function(int argc, char *argv[])
{
// Create the command-line parser
eoParser parser( argc, argv, "Basic EA for vector<float> with adaptive mutations");
// Define Parameters and load them
eoValueParam<uint32>& seed = parser.createParam(static_cast<uint32>(time(0)), "seed", "Random number seed");
eoValueParam<uint32_t>& seed = parser.createParam(static_cast<uint32_t>(time(0)),
"seed", "Random number seed");
eoValueParam<string>& load_name = parser.createParam(string(), "Load","Load a state file",'L');
eoValueParam<string>& save_name = parser.createParam(string(), "Save","Saves a state file",'S');
eoValueParam<bool>& stdevs = parser.createParam(false, "Stdev", "Use adaptive mutation rates", 's');
@ -47,7 +48,7 @@ int main_function(int argc, char *argv[])
rng.reseed(seed.value());
if (!load_name.value().empty())
{ // load the parser. This is only neccessary when the user wants to
{ // load the parser. This is only neccessary when the user wants to
// be able to change the parameters in the state file by hand
// Note that only parameters inserted in the parser at this point
// will be loaded!.
@ -57,7 +58,7 @@ int main_function(int argc, char *argv[])
state.registerObject(rng);
eoRealVectorBounds bounds(chromSize.value(), minimum.value(), maximum.value());
// Run the appropriate algorithm
if (stdevs.value() == false && corr.value() == false)
{
@ -67,7 +68,7 @@ int main_function(int argc, char *argv[])
{
runAlgorithm(eoEsFull<FitT>(),parser, state, bounds, load_name);
}
else
else
{
runAlgorithm(eoEsStdev<FitT>(), parser, state, bounds, load_name);
}
@ -80,11 +81,11 @@ int main_function(int argc, char *argv[])
state.save(file_name);
}
return 0;
return 0;
}
// A main that catches the exceptions
int main(int argc, char **argv)
{
#ifdef _MSC_VER
@ -94,7 +95,7 @@ int main(int argc, char **argv)
_CrtSetDbgFlag(flag);
// _CrtSetBreakAlloc(100);
#endif
try
{
main_function(argc, argv);
@ -103,7 +104,7 @@ int main(int argc, char **argv)
{
std::cout << "Exception: " << e.what() << '\n';
}
return 1;
}
@ -124,7 +125,7 @@ void runAlgorithm(EOT, eoParser& _parser, eoState& _state, eoRealVectorBounds& _
// Initialization
eoEsChromInit<EOT> init(_bounds);
// State takes ownership of pop because it needs to save it in caller
eoPop<EOT>& pop = _state.takeOwnership(eoPop<EOT>(mu.value(), init));
@ -158,8 +159,8 @@ void runAlgorithm(EOT, eoParser& _parser, eoState& _state, eoRealVectorBounds& _
checkpoint.add(average);
// only mutation (== with rate 1.0)
eoMonGenOp<EOT> op(mutate);
eoMonGenOp<EOT> op(mutate);
// the selection: sequential selection
eoSequentialSelect<EOT> select;
// the general breeder (lambda is a rate -> true)

10
eo/test/t-eoGenOp.cpp
View file

@ -3,7 +3,7 @@
//-----------------------------------------------------------------------------
// eoGenOp.cpp
// (c) Maarten Keijzer and Marc Schoenauer, 2001
/*
/*
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
@ -126,7 +126,7 @@ class one2threeOp : public eoGenOp<EOT> // :-)
class two2oneOp : public eoGenOp<EOT> // :-)
{
public:
public:
unsigned max_production(void) { return 1; }
void apply(eoPopulator<EOT>& _plop)
@ -141,7 +141,7 @@ class two2oneOp : public eoGenOp<EOT> // :-)
class three2threeOp : public eoGenOp<EOT> // :-)
{
public:
public:
unsigned max_production(void) { return 3; }
void apply(eoPopulator<EOT>& _plop)
@ -182,7 +182,7 @@ void init(eoPop<Dummy> & _pop, unsigned _pSize)
char s[255];
std::ostrstream os(s, 254);
#endif
os << i << std::ends;
_pop[i] = Dummy(os.str());
_pop[i].fitness(i);
@ -197,7 +197,7 @@ int the_main(int argc, char **argv)
eoValueParam<unsigned int> parentSizeParam = parser.createParam(unsigned(10), "parentSize", "Parent size",'P');
pSize = parentSizeParam.value(); // global variable
eoValueParam<uint32> seedParam(time(0), "seed", "Random number seed", 'S');
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam );
eo::rng.reseed(seedParam.value());

13
eo/test/t-eoSelect.cpp
View file

@ -5,7 +5,7 @@
#pragma warning(disable:4786)
#endif
#include <stdexcept> // runtime_error
#include <stdexcept> // runtime_error
// general
#include <eo>
@ -52,7 +52,7 @@ void testSelectMany(eoSelect<EOT> & _select, std::string _name)
{
unsigned i;
std::cout << "\n\n" << fitnessType + _name << std::endl;
std::cout << "===============\n";
std::cout << "===============\n";
eoDummyPop parents(parentsOrg);
eoDummyPop offspring(0);
@ -93,7 +93,7 @@ void testSelectOne(eoSelectOne<EOT> & _select, eoHowMany & _offspringRate,
//-----------------------------------------------------------------------------
int the_main(int argc, char **argv)
{
{
eoParser parser(argc, argv);
eoValueParam<unsigned> parentSizeParam = parser.createParam(unsigned(10), "parentSize", "Parent size",'P');
pSize = parentSizeParam.value(); // global variable
@ -129,7 +129,7 @@ eoValueParam<unsigned> tournamentSizeParam = parser.createParam(unsigned(2), "to
// hard-coded directory name ...
system("mkdir ResSelect");
std::cout << "Testing the Selections\nParents size = " << pSize
std::cout << "Testing the Selections\nParents size = " << pSize
<< ", offspring rate = " << oRate;
std::cout << " and putting rsulting files in dir ResSelect" << std::endl;
@ -150,13 +150,14 @@ eoValueParam<unsigned> tournamentSizeParam = parser.createParam(unsigned(2), "to
parentsOrg[i].fitness(i);
parentsOrg[pSize-1].fitness(10*pSize);
}
else
else
throw std::runtime_error("Invalid fitness Type"+fitnessType);
std::cout << "Initial parents (odd)\n" << parentsOrg << std::endl;
// random seed
eoValueParam<uint32>& seedParam = parser.createParam(uint32(0), "seed", "Random number seed", 'S');
eoValueParam<uint32_t>& seedParam = parser.createParam(uint32_t(0), "seed",
"Random number seed", 'S');
if (seedParam.value() == 0)
seedParam.value() = time(0);
rng.reseed(seedParam.value());

14
eo/test/t-eoSharing.cpp
View file

@ -74,7 +74,7 @@ void testSelectMany(eoSelect<EOT> & _select, std::string _name)
{
unsigned i;
std::cout << "\n\n" << fitnessType + _name << std::endl;
std::cout << "===============\n";
std::cout << "===============\n";
eoDummyPop parents(parentsOrg);
eoDummyPop offspring(0);
@ -117,11 +117,11 @@ void testSelectOne(eoSelectOne<EOT> & _select, eoHowMany & _offspringRate,
//-----------------------------------------------------------------------------
int the_main(int argc, char **argv)
{
{
eoParser parser(argc, argv);
// random seed
eoValueParam<uint32>& seedParam = parser.createParam(uint32(0), "seed", "Random number seed", 'S');
eoValueParam<uint32_t>& seedParam = parser.createParam(uint32_t(0), "seed", "Random number seed", 'S');
if (seedParam.value() == 0)
seedParam.value() = time(0);
rng.reseed(seedParam.value());
@ -158,7 +158,7 @@ int the_main(int argc, char **argv)
for (i=0; i<peakNumber; i++)
nbIndiPerPeak[i] = pSize/peakNumber;
}
else // parameters passed by user
else // parameters passed by user
if (peakParam.second.size() != peakNumber)
{
std::cerr << "ERROR, not enough nb of indis per peaks" << std::endl;
@ -174,7 +174,7 @@ int the_main(int argc, char **argv)
}
// compute exact total
sum = 0;
sum = 0;
for (i=0; i<peakNumber; i++)
sum += nbIndiPerPeak[i];
if (sum != pSize)
@ -182,8 +182,8 @@ int the_main(int argc, char **argv)
pSize = pSizeParam.value() = sum;
std::cerr << "WARNING, adjusting pSize to " << pSize << std::endl;
}
make_help(parser);
make_help(parser);
// hard-coded directory name ...
std::cout << "Testing the Sharing\n";

24
eo/test/t-eoStateAndParser.cpp
View file

@ -5,10 +5,10 @@
#pragma warning(disable:4786)
#endif
#include <stdexcept> // runtime_error
#include <stdexcept> // runtime_error
//-----------------------------------------------------------------------------
// tt.cpp:
// tt.cpp:
//
//-----------------------------------------------------------------------------
@ -36,16 +36,16 @@ struct Dummy : public EO<double>
int the_main(int argc, char **argv)
{ // ok, we have a command line parser and a state
typedef eoBit<float> Chrom;
eoParser parser(argc, argv);
// Define Parameters
eoValueParam<unsigned int> dimParam((unsigned int)(5), "dimension", "dimension");
eoValueParam<double> rate(0.01, "mutationRatePerBit", "Initial value for mutation rate per bit");
eoValueParam<unsigned int> dimParam((unsigned int)(5), "dimension", "dimension");
eoValueParam<double> rate(0.01, "mutationRatePerBit", "Initial value for mutation rate per bit");
eoValueParam<double> factor(0.99, "mutationFactor", "Decrease factor for mutation rate");
eoValueParam<uint32> seed(time(0), "seed", "Random number seed");
eoValueParam<uint32_t> seed(time(0), "seed", "Random number seed");
// test if user entered or if default value used
if (parser.isItThere(seed))
std::cout << "YES\n";
@ -55,7 +55,7 @@ int the_main(int argc, char **argv)
eoValueParam<std::string> load_name("", "Load","Load",'L');
eoValueParam<std::string> save_name("", "Save","Save",'S');
// Register them
parser.processParam(dimParam, "Genetic Operators");
parser.processParam(rate, "Genetic Operators");
@ -73,16 +73,16 @@ int the_main(int argc, char **argv)
eoState state;
state.registerObject(parser);
if (load_name.value() != "")
{ // load the parser. This is only neccessary when the user wants to
{ // load the parser. This is only neccessary when the user wants to
// be able to change the parameters in the state file by hand.
state.load(load_name.value()); // load the parser
}
// Create the algorithm here
// Register the algorithm
state.registerObject(rng);
//state.registerObject(pop);

68
eo/tutorial/Lesson3/SecondBitEA.cpp
View file

@ -13,7 +13,7 @@
// standard includes
#include <fstream>
#include <iostream> // cout
#include <stdexcept> // runtime_error
#include <stdexcept> // runtime_error
#ifdef HAVE_SSTREAM
#include <sstream>
#else
@ -42,8 +42,8 @@ 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 a parameter file (same syntax, order independent,
// # = usual comment character
// or in the environment (TODO)
// First define a parser from the command-line arguments
@ -52,7 +52,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
eoValueParam<uint32> seedParam(time(0), "seed", "Random number seed", 'S');
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam );
unsigned seed = seedParam.value();
@ -74,7 +74,7 @@ void main_function(int argc, char **argv)
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();
@ -88,7 +88,7 @@ void main_function(int argc, char **argv)
unsigned steadyGen = steadyGenParam.value();
// operators probabilities at the algorithm level
eoValueParam<double> pCrossParam(0.6, "pCross", "Probability of Crossover", 'C');
eoValueParam<double> pCrossParam(0.6, "pCross", "Probability of Crossover", 'C');
parser.processParam( pCrossParam, "Genetic Operators" );
double pCross = pCrossParam.value();
@ -117,7 +117,7 @@ void main_function(int argc, char **argv)
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();
@ -163,11 +163,11 @@ void main_function(int argc, char **argv)
// eventually with different parameters
inState.registerObject(rng);
inState.registerObject(pop);
if (loadName != "")
{
inState.load(loadName); // load the pop and the rng
// the fitness is read in the file:
// the fitness is read in the file:
// do only evaluate the pop if the fitness has changed
}
else
@ -177,14 +177,14 @@ void main_function(int argc, char **argv)
// based on boolean_generator class (see utils/rnd_generator.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)
pop.append(popSize, random);
// and evaluate pop (STL syntax)
apply<Indi>(eval, pop);
} // end of initializatio of the population
// OUTPUT
// OUTPUT
// sort pop for pretty printout
pop.sort();
// Print (sorted) intial population (raw printout)
@ -198,12 +198,12 @@ void main_function(int argc, char **argv)
// The robust tournament selection
eoDetTournamentSelect<Indi> selectOne(tSize); // tSize in [2,POPSIZE]
// is now encapsulated in a eoSelectPerc (stands for Percentage)
eoSelectPerc<Indi> select(selectOne);
eoSelectPerc<Indi> select(selectOne);
// REPLACE
// And we now have the full slection/replacement - though with
// And we now have the full slection/replacement - though with
// the same generational replacement at the moment :-)
eoGenerationalReplacement<Indi> replace;
eoGenerationalReplacement<Indi> replace;
// OPERATORS
//////////////////////////////////////
@ -225,7 +225,7 @@ void main_function(int argc, char **argv)
// standard bit-flip mutation for bitstring
eoBitMutation<Indi> mutationBitFlip(pMutPerBit);
// mutate exactly 1 bit per individual
eoDetBitFlip<Indi> mutationOneBit;
eoDetBitFlip<Indi> mutationOneBit;
// Combine them with relative rates
eoPropCombinedMonOp<Indi> mutation(mutationBitFlip, bitFlipRate);
mutation.add(mutationOneBit, oneBitRate, true);
@ -243,27 +243,27 @@ void main_function(int argc, char **argv)
eoCombinedContinue<Indi> continuator(genCont);
continuator.add(steadyCont);
continuator.add(fitCont);
// CHECKPOINT
// but now you want to make many different things every generation
// 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
// 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,
// 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,
// Add it to the checkpoint,
// so the counter is updated (here, incremented) every generation
checkpoint.add(increment);
@ -279,11 +279,11 @@ void main_function(int argc, char **argv)
// The Stdout monitor will print parameters to the screen ...
eoStdoutMonitor monitor(false);
// when called by the checkpoint (i.e. at every generation)
checkpoint.add(monitor);
// the monitor will output a series of parameters: add them
// the monitor will output a series of parameters: add them
monitor.add(generationCounter);
monitor.add(eval); // because now eval is an eoEvalFuncCounter!
monitor.add(bestStat);
@ -291,7 +291,7 @@ void main_function(int argc, char **argv)
// A file monitor: will print parameters to ... a File, yes, you got it!
eoFileMonitor fileMonitor("stats.xg", " ");
// the checkpoint mechanism can handle multiple monitors
checkpoint.add(fileMonitor);
@ -309,9 +309,9 @@ void main_function(int argc, char **argv)
// and feed the state to state savers
// save state every 100th generation
eoCountedStateSaver stateSaver1(20, outState, "generation");
// save state every 1 seconds
eoTimedStateSaver stateSaver2(1, outState, "time");
eoCountedStateSaver stateSaver1(20, outState, "generation");
// save state every 1 seconds
eoTimedStateSaver stateSaver2(1, outState, "time");
// Don't forget to add the two savers to the checkpoint
checkpoint.add(stateSaver1);
@ -323,13 +323,13 @@ void main_function(int argc, char **argv)
// the algorithm
////////////////////////////////////////
// Easy EA requires
// Easy EA requires
// stopping criterion, eval, selection, transformation, replacement
eoEasyEA<Indi> gga(checkpoint, eval, select, transform, replace);
// Apply algo to pop - that's it!
gga(pop);
// OUTPUT
// Print (sorted) intial population
pop.sort();

62
eo/tutorial/Lesson3/exercise3.1.cpp
View file

@ -13,7 +13,7 @@
// standard includes
#include <fstream>
#include <iostream> // cout
#include <stdexcept> // runtime_error
#include <stdexcept> // runtime_error
#ifdef HAVE_SSTREAM
#include <sstream>
#else
@ -42,8 +42,8 @@ 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 a parameter file (same syntax, order independent,
// # = usual comment character
// or in the environment (TODO)
// First define a parser from the command-line arguments
@ -52,7 +52,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
eoValueParam<uint32> seedParam(time(0), "seed", "Random number seed", 'S');
eoValueParam<uint32_t> seedParam(time(0), "seed", "Random number seed", 'S');
parser.processParam( seedParam );
unsigned seed = seedParam.value();
@ -88,7 +88,7 @@ void main_function(int argc, char **argv)
unsigned steadyGen = steadyGenParam.value();
// operators probabilities at the algorithm level
eoValueParam<double> pCrossParam(0.6, "pCross", "Probability of Crossover", 'C');
eoValueParam<double> pCrossParam(0.6, "pCross", "Probability of Crossover", 'C');
parser.processParam( pCrossParam, "Genetic Operators" );
double pCross = pCrossParam.value();
@ -117,7 +117,7 @@ void main_function(int argc, char **argv)
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();
@ -163,11 +163,11 @@ void main_function(int argc, char **argv)
// eventually with different parameters
inState.registerObject(rng);
inState.registerObject(pop);
if (loadName != "")
{
inState.load(loadName); // load the pop and the rng
// the fitness is read in the file:
// the fitness is read in the file:
// do only evaluate the pop if the fitness has changed
}
else
@ -177,14 +177,14 @@ void main_function(int argc, char **argv)
// based on boolean_generator class (see utils/rnd_generator.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)
pop.append(popSize, random);
// and evaluate pop (STL syntax)
apply<Indi>(eval, pop);
} // end of initializatio of the population
// OUTPUT
// OUTPUT
// sort pop for pretty printout
// pop.sort();
// Print (sorted) intial population (raw printout)
@ -202,13 +202,13 @@ void main_function(int argc, char **argv)
eoSelectPerc<Indi> select(selectOne);// by default rate==1
// REPLACE
// And we now have the full slection/replacement - though with
// And we now have the full slection/replacement - though with
// generational replacement at the moment :-)
eoGenerationalReplacement<Indi> replace;
eoGenerationalReplacement<Indi> replace;
// want to add (weak) elitism? easy!
// rename the eoGenerationalReplacement replace_main,
// then encapsulate it in the elitist replacement
// eoWeakElitistReplacement<Indi> replace(replace_main);
// eoWeakElitistReplacement<Indi> replace(replace_main);
// OPERATORS
//////////////////////////////////////
@ -230,7 +230,7 @@ void main_function(int argc, char **argv)
// standard bit-flip mutation for bitstring
eoBitMutation<Indi> mutationBitFlip(pMutPerBit);
// mutate exactly 1 bit per individual
eoDetBitFlip<Indi> mutationOneBit;
eoDetBitFlip<Indi> mutationOneBit;
// Combine them with relative rates
eoPropCombinedMonOp<Indi> mutation(mutationBitFlip, bitFlipRate);
mutation.add(mutationOneBit, oneBitRate, true);
@ -252,27 +252,27 @@ void main_function(int argc, char **argv)
#ifndef _MSC_VER
eoCtrlCContinue<Indi> ctrlC;
continuator.add(ctrlC);
#endif
#endif
// CHECKPOINT
// but now you want to make many different things every generation
// 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
// 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,
// 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,
// Add it to the checkpoint,
// so the counter is updated (here, incremented) every generation
checkpoint.add(increment);
@ -306,7 +306,7 @@ void main_function(int argc, char **argv)
monitor.add(SecondStat);
monitor.add(fdcStat);
// test de eoPopStat and/or eoSortedPopStat.
// test de eoPopStat and/or eoSortedPopStat.
// Dumps the whole pop every 10 gen.
// eoSortedPopStat<Indi> popStat(10, "Dump of whole population");
// eoPopStat<Indi> popStat(10, "Dump of whole population");
@ -365,9 +365,9 @@ void main_function(int argc, char **argv)
// 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");
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
checkpoint.add(stateSaver1);
@ -379,13 +379,13 @@ void main_function(int argc, char **argv)
// the algorithm
////////////////////////////////////////
// Easy EA requires
// Easy EA requires
// selection, transformation, eval, replacement, and stopping criterion
eoEasyEA<Indi> gga(checkpoint, eval, select, transform, replace);
// Apply algo to pop - that's it!
gga(pop);
// OUTPUT
// Print (sorted) intial population
pop.sort();