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

cleaning the indentation and formating of eoPop.h, added the authors

Browse source
This commit is contained in:
nojhan 2012-04-01 12:09:17 +02:00
commit ca8948486f
1 changed files with 279 additions and 246 deletions
Download patch file Download diff file Expand all files Collapse all files

487
eo/src/eoPop.h
View file

@ -4,26 +4,35 @@
// eoPop.h // eoPop.h
// (c) GeNeura Team, 1998 // (c) GeNeura Team, 1998
/* /*
This library is free software; you can redistribute it and/or This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version. version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful, This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details. Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Contact: todos@geneura.ugr.es, http://geneura.ugr.es Authors:
*/ todos@geneura.ugr.es, http://geneura.ugr.es
jmerelo
gustavoromero
mac
maartenkeijzer
kuepper
okoenig
evomarc
Johann Dréo <johann.dreo@thalesgroup.com>
*/
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
#ifndef _EOPOP_H #ifndef _EOPOP_H_
#define _EOPOP_H #define _EOPOP_H_
#include <algorithm> #include <algorithm>
#include <iostream> #include <iostream>
@ -54,18 +63,18 @@
template<class EOT> template<class EOT>
class eoPop: public std::vector<EOT>, public eoObject, public eoPersistent class eoPop: public std::vector<EOT>, public eoObject, public eoPersistent
{ {
public: public:
using std::vector<EOT>::size; using std::vector<EOT>::size;
using std::vector<EOT>::resize; using std::vector<EOT>::resize;
using std::vector<EOT>::operator[]; using std::vector<EOT>::operator[];
using std::vector<EOT>::begin; using std::vector<EOT>::begin;
using std::vector<EOT>::end; using std::vector<EOT>::end;
typedef typename EOT::Fitness Fitness; typedef typename EOT::Fitness Fitness;
#if defined(__CUDACC__) #if defined(__CUDACC__)
typedef typename std::vector<EOT>::iterator iterator; typedef typename std::vector<EOT>::iterator iterator;
typedef typename std::vector<EOT>::const_iterator const_iterator; typedef typename std::vector<EOT>::const_iterator const_iterator;
#endif #endif
/** Default ctor. Creates empty pop /** Default ctor. Creates empty pop
@ -74,272 +83,296 @@ public:
/** Ctor for the initialization of chromosomes /** Ctor for the initialization of chromosomes
@param _popSize total population size @param _popSize total population size
@param _chromInit Initialization routine, produces EO's, needs to be an eoInit @param _chromInit Initialization routine, produces EO's, needs to be an eoInit
*/ */
eoPop( unsigned _popSize, eoInit<EOT>& _chromInit ) eoPop( unsigned _popSize, eoInit<EOT>& _chromInit )
:std::vector<EOT>() : std::vector<EOT>()
{ {
resize(_popSize); resize(_popSize);
for ( unsigned i = 0; i < _popSize; i++ ) for ( unsigned i = 0; i < _popSize; i++ )
{ {
_chromInit(operator[](i)); _chromInit(operator[](i));
} }
}; }
/** appends random guys at end of pop. /** appends random guys at end of pop.
Can be used to initialize it pop is empty Can be used to initialize it pop is empty
@param _newPopSize total population size @param _newPopSize total population size
@param _chromInit Initialization routine, produces EO's, needs to be an eoInit @param _chromInit Initialization routine, produces EO's, needs to be an eoInit
*/ */
void append( unsigned _newPopSize, eoInit<EOT>& _chromInit ) void append( unsigned _newPopSize, eoInit<EOT>& _chromInit )
{
unsigned oldSize = size();
if (_newPopSize < oldSize)
{ {
throw std::runtime_error("New size smaller than old size in pop.append"); unsigned oldSize = size();
return; if (_newPopSize < oldSize)
{
throw std::runtime_error("New size smaller than old size in pop.append");
return;
}
if (_newPopSize == oldSize)
return;
resize(_newPopSize); // adjust the size
for ( unsigned i = oldSize; i < _newPopSize; i++ )
{
_chromInit(operator[](i));
}
} }
if (_newPopSize == oldSize)
return;
resize(_newPopSize); // adjust the size /** Ctor from an std::istream; reads the population from a stream,
for ( unsigned i = oldSize; i < _newPopSize; i++ ) each element should be in different lines
@param _is the stream
*/
eoPop( std::istream& _is ) :std::vector<EOT>()
{ {
_chromInit(operator[](i)); readFrom( _is );
} }
};
/** Ctor from an std::istream; reads the population from a stream, /** Empty Dtor */
each element should be in different lines
@param _is the stream
*/
eoPop( std::istream& _is ) :std::vector<EOT>() {
readFrom( _is );
}
/** Empty Dtor */
virtual ~eoPop() {} virtual ~eoPop() {}
/// helper struct for getting a pointer /// helper struct for getting a pointer
struct Ref { const EOT* operator()(const EOT& eot) { return &eot;}}; struct Ref { const EOT* operator()(const EOT& eot) { return &eot;}};
/// helper struct for comparing on pointers
struct Cmp { /// helper struct for comparing on pointers
bool operator()(const EOT* a, const EOT* b) const struct Cmp {
bool operator()(const EOT* a, const EOT* b) const
{ return b->operator<(*a); } { return b->operator<(*a); }
}; };
/// helper struct for comparing (EA or PSO)
struct Cmp2 /// helper struct for comparing (EA or PSO)
{ struct Cmp2
bool operator()(const EOT & a,const EOT & b) const
{ {
bool operator()(const EOT & a,const EOT & b) const
{
return b.operator<(a); return b.operator<(a);
}
};
/**
sort the population. Use this member to sort in order
of descending Fitness, so the first individual is the best!
*/
void sort(void)
{
std::sort(begin(), end(), Cmp2());
} }
};
/** creates a std::vector<EOT*> pointing to the individuals in descending order */
void sort(std::vector<const EOT*>& result) const
{
result.resize(size());
/** std::transform(begin(), end(), result.begin(), Ref());
sort the population. Use this member to sort in order
of descending Fitness, so the first individual is the best!
*/
void sort(void)
{
std::sort(begin(), end(), Cmp2());
}
/** creates a std::vector<EOT*> pointing to the individuals in descending order */ std::sort(result.begin(), result.end(), Cmp());
void sort(std::vector<const EOT*>& result) const }
{
result.resize(size());
std::transform(begin(), end(), result.begin(), Ref());
std::sort(result.begin(), result.end(), Cmp()); /**
} shuffle the population. Use this member to put the population
in random order
*/
void shuffle(void)
{
UF_random_generator<unsigned int> gen;
std::random_shuffle(begin(), end(), gen);
}
/**
shuffle the population. Use this member to put the population
in random order
*/
void shuffle(void)
{
UF_random_generator<unsigned int> gen;
std::random_shuffle(begin(), end(), gen);
}
/** creates a std::vector<EOT*> pointing to the individuals in random order */ /** creates a std::vector<EOT*> pointing to the individuals in random order */
void shuffle(std::vector<const EOT*>& result) const void shuffle(std::vector<const EOT*>& result) const
{ {
result.resize(size()); result.resize(size());
std::transform(begin(), end(), result.begin(), Ref()); std::transform(begin(), end(), result.begin(), Ref());
UF_random_generator<unsigned int> gen; UF_random_generator<unsigned int> gen;
std::random_shuffle(result.begin(), result.end(), gen); std::random_shuffle(result.begin(), result.end(), gen);
} }
/** returns an iterator to the best individual DOES NOT MOVE ANYBODY */
/** returns an iterator to the best individual DOES NOT MOVE ANYBODY */
#if defined(__CUDACC__) #if defined(__CUDACC__)
eoPop<EOT>::iterator it_best_element() eoPop<EOT>::iterator it_best_element()
{ {
eoPop<EOT>:: iterator it = std::max_element(begin(), end()); eoPop<EOT>:: iterator it = std::max_element(begin(), end());
#else #else
typename eoPop<EOT>::iterator it_best_element() typename eoPop<EOT>::iterator it_best_element()
{ {
assert( this->size() > 0 ); assert( this->size() > 0 );
typename eoPop<EOT>::iterator it = std::max_element(begin(), end()); typename eoPop<EOT>::iterator it = std::max_element(begin(), end());
#endif #endif
return it; return it;
} }
/** returns an iterator to the best individual DOES NOT MOVE ANYBODY */
const EOT & best_element() const /** returns an iterator to the best individual DOES NOT MOVE ANYBODY */
{ const EOT & best_element() const
{
#if defined(__CUDACC__) #if defined(__CUDACC__)
eoPop<EOT>::const_iterator it = std::max_element(begin(), end()); eoPop<EOT>::const_iterator it = std::max_element(begin(), end());
#else #else
typename eoPop<EOT>::const_iterator it = std::max_element(begin(), end()); typename eoPop<EOT>::const_iterator it = std::max_element(begin(), end());
#endif #endif
return (*it); return (*it);
} }
/** returns a const reference to the worse individual DOES NOT MOVE ANYBODY */
const EOT & worse_element() const /** returns a const reference to the worse individual DOES NOT MOVE ANYBODY */
{ const EOT & worse_element() const
{
#if defined(__CUDACC__) #if defined(__CUDACC__)
eoPop<EOT>::const_iterator it = std::min_element(begin(), end()); eoPop<EOT>::const_iterator it = std::min_element(begin(), end());
#else #else
assert( this->size() > 0 ); assert( this->size() > 0 );
typename eoPop<EOT>::const_iterator it = std::min_element(begin(), end()); typename eoPop<EOT>::const_iterator it = std::min_element(begin(), end());
#endif #endif
return (*it); return (*it);
} }
/** returns an iterator to the worse individual DOES NOT MOVE ANYBODY */
/** returns an iterator to the worse individual DOES NOT MOVE ANYBODY */
#if defined(__CUDACC__) #if defined(__CUDACC__)
eoPop<EOT>::iterator it_worse_element() eoPop<EOT>::iterator it_worse_element()
{ {
eoPop<EOT>::iterator it = std::min_element(begin(), end()); eoPop<EOT>::iterator it = std::min_element(begin(), end());
#else #else
typename eoPop<EOT>::iterator it_worse_element() typename eoPop<EOT>::iterator it_worse_element()
{ {
assert( this->size() > 0 ); assert( this->size() > 0 );
typename eoPop<EOT>::iterator it = std::min_element(begin(), end()); typename eoPop<EOT>::iterator it = std::min_element(begin(), end());
#endif #endif
return it; return it;
} }
/**
slightly faster algorithm than sort to find all individuals that are better /**
than the nth individual. INDIVIDUALS ARE MOVED AROUND in the pop. slightly faster algorithm than sort to find all individuals that are better
*/ than the nth individual. INDIVIDUALS ARE MOVED AROUND in the pop.
*/
#if defined(__CUDACC__) #if defined(__CUDACC__)
eoPop<EOT>::iterator nth_element(int nth) eoPop<EOT>::iterator nth_element(int nth)
{ {
eoPop<EOT>::iterator it = begin() + nth; eoPop<EOT>::iterator it = begin() + nth;
#else #else
typename eoPop<EOT>::iterator nth_element(int nth) typename eoPop<EOT>::iterator nth_element(int nth)
{ {
assert( this->size() > 0 ); assert( this->size() > 0 );
typename eoPop<EOT>::iterator it = begin() + nth; typename eoPop<EOT>::iterator it = begin() + nth;
#endif #endif
std::nth_element(begin(), it, end(), std::greater<EOT>()); std::nth_element(begin(), it, end(), std::greater<EOT>());
return it; return it;
} }
struct GetFitness { Fitness operator()(const EOT& _eo) const { return _eo.fitness(); } };
/** returns the fitness of the nth element */ struct GetFitness { Fitness operator()(const EOT& _eo) const { return _eo.fitness(); } };
Fitness nth_element_fitness(int which) const
{ // probably not the fastest way to do this, but what the heck
std::vector<Fitness> fitness(size());
std::transform(begin(), end(), fitness.begin(), GetFitness());
typename std::vector<Fitness>::iterator it = fitness.begin() + which; /** returns the fitness of the nth element */
std::nth_element(fitness.begin(), it, fitness.end(), std::greater<Fitness>()); Fitness nth_element_fitness(int which) const
return *it; { // probably not the fastest way to do this, but what the heck
}
/** const nth_element function, returns pointers to sorted individuals std::vector<Fitness> fitness(size());
* up the the nth std::transform(begin(), end(), fitness.begin(), GetFitness());
*/
void nth_element(int which, std::vector<const EOT*>& result) const
{
assert( this->size() > 0 ); typename std::vector<Fitness>::iterator it = fitness.begin() + which;
result.resize(size()); std::nth_element(fitness.begin(), it, fitness.end(), std::greater<Fitness>());
std::transform(begin(), end(), result.begin(), Ref()); return *it;
}
typename std::vector<const EOT*>::iterator it = result.begin() + which;
std::nth_element(result.begin(), it, result.end(), Cmp()); /** const nth_element function, returns pointers to sorted individuals
} * up the the nth
*/
void nth_element(int which, std::vector<const EOT*>& result) const
{
/** does STL swap with other pop */ assert( this->size() > 0 );
void swap(eoPop<EOT>& other) result.resize(size());
{ std::transform(begin(), end(), result.begin(), Ref());
std::swap(static_cast<std::vector<EOT>& >(*this), static_cast<std::vector<EOT>& >(other));
}
/** typename std::vector<const EOT*>::iterator it = result.begin() + which;
* Prints sorted pop but does NOT modify it!
*
* @param _os A std::ostream.
*/
virtual void sortedPrintOn(std::ostream& _os) const
{
std::vector<const EOT*> result;
sort(result);
_os << size() << '\n';
for (unsigned i = 0; i < size(); ++i)
{
_os << *result[i] << std::endl;
}
}
/** std::nth_element(result.begin(), it, result.end(), Cmp());
* Write object. It's called printOn since it prints the object _on_ a stream. }
* @param _os A std::ostream.
*/
virtual void printOn(std::ostream& _os) const
{
_os << size() << '\n';
std::copy( begin(), end(), std::ostream_iterator<EOT>( _os, "\n") );
}
/** @name Methods from eoObject */
//@{
/**
* Read object. The EOT class must have a ctor from a stream;
* @param _is A std::istream.
*/
virtual void readFrom(std::istream& _is)
{
size_t sz;
_is >> sz;
resize(sz); /** does STL swap with other pop */
void swap(eoPop<EOT>& other)
{
std::swap(static_cast<std::vector<EOT>& >(*this), static_cast<std::vector<EOT>& >(other));
}
for (size_t i = 0; i < sz; ++i) {
operator[](i).readFrom( _is );
}
}
/** Inherited from eoObject. Returns the class name. /**
@see eoObject * Prints sorted pop but does NOT modify it!
*/ *
virtual std::string className() const {return "eoPop";}; * @param _os A std::ostream.
//@} */
virtual void sortedPrintOn(std::ostream& _os) const
{
std::vector<const EOT*> result;
sort(result);
_os << size() << '\n';
for (unsigned i = 0; i < size(); ++i)
{
_os << *result[i] << std::endl;
}
}
virtual void invalidate()
{
for (unsigned i=0; i<size(); i++)
this->operator[](i).invalidate();
}
};
#endif /**
* Write object. It's called printOn since it prints the object _on_ a stream.
* @param _os A std::ostream.
*/
virtual void printOn(std::ostream& _os) const
{
_os << size() << '\n';
std::copy( begin(), end(), std::ostream_iterator<EOT>( _os, "\n") );
}
/** @name Methods from eoObject */
//@{
/**
* Read object. The EOT class must have a ctor from a stream;
* @param _is A std::istream.
*/
virtual void readFrom(std::istream& _is)
{
size_t sz;
_is >> sz;
resize(sz);
for (size_t i = 0; i < sz; ++i) {
operator[](i).readFrom( _is );
}
}
/** Inherited from eoObject. Returns the class name.
@see eoObject
*/
virtual std::string className() const {return "eoPop";};
//@}
/** Invalidate the whole population
*/
virtual void invalidate()
{
for (unsigned i=0; i<size(); i++)
this->operator[](i).invalidate();
}
}; // class eoPop
#endif // _EOPOP_H_