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

EO: added overloaded printing of fitness (for vectors and pairs)

Browse source 
Various bugs and ommissions in eoPerf2Worth and eoSelectFromWorth
This commit is contained in:
maartenkeijzer 2001-03-12 16:00:58 +00:00
commit 4222e64829
4 changed files with 144 additions and 46 deletions
Download patch file Download diff file Expand all files Collapse all files

104
eo/src/EO.h
View file

@ -31,56 +31,104 @@
#include <eoObject.h> // eoObject
#include <eoPersistent.h> // eoPersistent
template <class T>
ostream& print_fitness(ostream& _os, const std::vector<T>& vec)
{
_os << vec.size() << ' ';
std::copy(vec.begin(), vec.end(), ostream_iterator<T>(_os));
return _os;
}
template <class T, class U>
ostream& print_fitness(ostream& _os, const std::pair<T, U>& pair)
{
return _os << pair.first << ' ' << pair.second;
}
template <class T>
ostream& print_fitness(ostream& _os, const T& t)
{ // general, try operator<<
return _os << t;
}
template <class T>
istream& read_fitness(istream& _is, vector<T>& vec)
{
unsigned sz;
_is >> sz;
vec.resize(sz);
for (unsigned i = 0; i < vec.size(); ++i)
{
_is >> vec[i];
}
return _is;
}
template <class T, class U>
istream& read_fitness(istream& _is, pair<T, U>& pair)
{
_is >> pair.first;
_is >> pair.second;
return _is;
}
template <class T>
istream& read_fitness(istream& _is, T& t)
{
_is >> t;
return _is;
}
//-----------------------------------------------------------------------------
/** EO is a base class for evolvable objects, that is, the subjects of
/** EO is a base class for evolvable objects, that is, the subjects of
evolution. EOs have only got a fitness, which at the same time needs to be
only an object with the operation less than (<) defined. Fitness says how
good is the object; evolution or change of these objects is left to the
genetic operators. A fitness less than another means a worse fitness, in
whatever the context; thus, fitness is always maximized; although it can
be minimized with a proper definition of the < operator. The fitness
only an object with the operation less than (<) defined. Fitness says how
good is the object; evolution or change of these objects is left to the
genetic operators. A fitness less than another means a worse fitness, in
whatever the context; thus, fitness is always maximized; although it can
be minimized with a proper definition of the < operator. The fitness
object must have, besides an void ctor, a copy ctor.
*/
template<class F> class EO: public eoObject, public eoPersistent
{
public:
typedef F Fitness;
/** Default constructor.
Fitness must have a ctor which takes 0 as a value; we can not use void
ctors here since default types like float have no void initializer.
Fitness must have a ctor which takes 0 as a value; we can not use void
ctors here since default types like float have no void initializer.
VC++ allows it, but gcc does not
*/
EO(): repFitness(Fitness()), invalidFitness(true) {}
/// Virtual dtor
virtual ~EO() {};
/// Return fitness value.
Fitness fitness() const {
if (invalid())
throw runtime_error("invalid fitness");
return repFitness;
}
// Set fitness as invalid.
void invalidate() { invalidFitness = true; }
/** Set fitness. At the same time, validates it.
* @param _fitness New fitness value.
*/
void fitness(const Fitness& _fitness)
{
{
repFitness = _fitness;
invalidFitness = false;
}
/** Return true If fitness value is invalid, false otherwise.
* @return true If fitness is invalid.
*/
bool invalid() const { return invalidFitness; }
/** Returns true if
/** Returns true if
@return true if the fitness is higher
*/
bool operator<(const EO& _eo2) const { return fitness() < _eo2.fitness(); }
@ -88,28 +136,28 @@ public:
/// Methods inherited from eoObject
//@{
/** Return the class id.
/** Return the class id.
* @return the class name as a string
*/
virtual string className() const { return "EO"; }
/**
* Read object.\\
* Calls base class, just in case that one had something to do.
* The read and print methods should be compatible and have the same format.
* Calls base class, just in case that one had something to do.
* The read and print methods should be compatible and have the same format.
* In principle, format is "plain": they just print a number
* @param _is a istream.
* @throw runtime_exception If a valid object can't be read.
*/
virtual void readFrom(istream& _is) {
_is >> repFitness;
virtual void readFrom(istream& _is) {
read_fitness(_is, repFitness);
if (_is)
invalidFitness = false;
else
throw runtime_error("EO(istream&): can't read valid eo from istream");
}
/**
* Write object. Called printOn since it prints the object _on_ a stream.
* @param _os A ostream.
@ -118,11 +166,11 @@ public:
if (invalid())
_os << "INVALID ";
else
_os << repFitness << ' '; // trailing space to make reading in that much easier
print_fitness(_os, repFitness) << ' '; // trailing space to make reading in that much easier
}
//@}
private:
Fitness repFitness; // value of fitness for this chromosome
bool invalidFitness; // true if the value of fitness is invalid

5
eo/src/eo
View file

@ -81,7 +81,7 @@
#include <eoSteadyFitContinue.h>
#include <eoFitContinue.h>
// Selection
// Selection
// the eoSelectOne's
#include <eoRandomSelect.h> // also contains the eoSequentialSelect
#include <eoDetTournamentSelect.h>
@ -113,6 +113,9 @@
// a simple transformer
#include <eoSGATransform.h>
// Perf2Worth
#include <eoParetoRanking.h>
// Algorithms
#include <eoEasyEA.h>
#include <eoSGA.h>

4
eo/src/eoPerf2Worth.h
View file

@ -41,8 +41,8 @@ template <class EOT, class WorthT = typename EOT::Fitness>
class eoPerf2Worth : public eoStat<EOT, vector<WorthT> >
{
public:
eoPerf2Worth():eoStat<EOT, vector<WorthT> >(vector<WorthT>(0),
"Worths") {}
eoPerf2Worth(std::string _description = "Worths"):eoStat<EOT, vector<WorthT> >(vector<WorthT>(0),
_description) {}
};
#endif

77
eo/src/eoSelectFromWorth.h
View file

@ -57,13 +57,35 @@ public:
perf2Worth(_perf2Worth) {}
/* setup the worthes */
virtual void setup(const eoPop<EOT>& _pop)
virtual void setup(const eoPop<EOT>& _pop)
{
perf2Worth(_pop);
#ifndef NDEBUG
fitness.resize(_pop.size());
for (unsigned i = 0; i < _pop.size(); ++i)
{
fitness[i] = _pop[i].fitness();
}
#endif
}
protected:
eoPerf2Worth<EOT, WorthType> & perf2Worth;
#ifndef NDEBUG
vector<typename EOT::Fitness> fitness; // for debugging purposes, to check that the perf2worth and pop are in sync
void check_sync(unsigned index, const EOT& _eo)
{
if (fitness[index] != _eo.fitness())
{
throw runtime_error("eoSelectFromWorth: fitnesses are not in sync");
}
}
#endif
};
@ -82,16 +104,24 @@ public:
unsigned _tSize) :
eoSelectFromWorth<EOT, WorthT>(_perf2Worth), tSize(_tSize) {}
/* Perform deterministic tournament on worthes
by calling the appropriate fn
/* Perform deterministic tournament on worthes
by calling the appropriate fn
see selectors.h
*/
virtual const EOT& operator()(const eoPop<EOT>& _pop)
virtual const EOT& operator()(const eoPop<EOT>& _pop)
{
worthIterator it = deterministic_tournament(
perf2Worth.value().begin(),
perf2Worth.value().end(), tSize);
return _pop[it-perf2Worth.value().begin()];
unsigned index = it - perf2Worth.value().begin();
#ifndef NDEBUG
// check whether the stuff is still in sync
check_sync(index, _pop[index]);
#endif
return _pop[index];
}
private:
@ -99,7 +129,7 @@ private:
};
/** An instance of eoSelectPerf2Worth that does selection from the Worthes
* using a ... determinisitic tournament, yes!
* using a ... stochastic tournament, yes!
*/
template <class EOT, class WorthT = double>
class eoStochTournamentWorthSelect : public eoSelectFromWorth<EOT, WorthT>
@ -113,15 +143,23 @@ public:
double _tRate) :
eoSelectFromWorth<EOT, WorthT>(_perf2Worth), tRate(_tRate) {}
/* Perform stochastic tournament on worthes
/* Perform stochastic tournament on worthes
by calling the appropriate fn in selectors.h
*/
virtual const EOT& operator()(const eoPop<EOT>& _pop)
virtual const EOT& operator()(const eoPop<EOT>& _pop)
{
worthIterator it = deterministic_tournament(
worthIterator it = stochastic_tournament(
perf2Worth.value().begin(),
perf2Worth.value().end(), tRate);
return _pop[it-perf2Worth.value().begin()];
unsigned index = it - perf2Worth.value().begin();
#ifndef NDEBUG
// check whether the stuff is still in sync
check_sync(index, _pop[index]);
#endif
return _pop[index];
}
private:
@ -145,25 +183,34 @@ public:
/* We have to override the default behavior to compute the total
* only once!
*/
virtual void setup(const eoPop<EOT>& _pop)
virtual void setup(const eoPop<EOT>& _pop)
{
perf2Worth(_pop);
eoSelectFromWorth<EOT, WorthT>::setup(_pop);
total = 0.0;
for (worthIterator it = perf2Worth.value().begin();
it<perf2Worth.value().end(); ++it)
total += (*it);
}
/* Perform deterministic tournament on worthes
by calling the appropriate fn
/* Perform deterministic tournament on worthes
by calling the appropriate fn
see selectors.h
*/
virtual const EOT& operator()(const eoPop<EOT>& _pop)
virtual const EOT& operator()(const eoPop<EOT>& _pop)
{
worthIterator it = roulette_wheel(
perf2Worth.value().begin(),
perf2Worth.value().end(),
total);
unsigned index = it - perf2Worth.value().begin();
#ifndef NDEBUG
// check whether the stuff is still in sync
check_sync(index, _pop[index]);
#endif
return _pop[index];
return _pop[it-perf2Worth.value().begin()];
}