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

doc added

Browse source 
git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@1206 331e1502-861f-0410-8da2-ba01fb791d7f
This commit is contained in:
liefooga 2008-06-26 09:13:04 +00:00
commit fc4166a40e
4 changed files with 115 additions and 83 deletions
Download patch file Download diff file Expand all files Collapse all files

7
trunk/paradiseo-moeo/src/archive/moeoArchive.h
View file

@ -43,7 +43,8 @@
#include <comparator/moeoParetoObjectiveVectorComparator.h> #include <comparator/moeoParetoObjectiveVectorComparator.h>
/** /**
* An archive is a secondary population that stores non-dominated solutions. * Abstract class for representing an archive ;
* an archive is a secondary population that stores non-dominated solutions.
*/ */
template < class MOEOT > template < class MOEOT >
class moeoArchive : public eoPop < MOEOT > class moeoArchive : public eoPop < MOEOT >
@ -53,6 +54,7 @@ public:
using eoPop < MOEOT > :: size; using eoPop < MOEOT > :: size;
using eoPop < MOEOT > :: operator[]; using eoPop < MOEOT > :: operator[];
/** /**
* The type of an objective vector for a solution * The type of an objective vector for a solution
*/ */
@ -116,12 +118,14 @@ public:
*/ */
virtual void operator()(const MOEOT & _moeo) = 0; virtual void operator()(const MOEOT & _moeo) = 0;
/** /**
* Updates the archive with a given population _pop * Updates the archive with a given population _pop
* @param _pop the given population * @param _pop the given population
*/ */
virtual void operator()(const eoPop < MOEOT > & _pop) = 0; virtual void operator()(const eoPop < MOEOT > & _pop) = 0;
/** /**
* Returns true if the current archive contains the same objective vectors than the given archive _arch * Returns true if the current archive contains the same objective vectors than the given archive _arch
* @param _arch the given archive * @param _arch the given archive
@ -145,6 +149,7 @@ public:
return true; return true;
} }
private: private:
/** The moeoObjectiveVectorComparator used to compare solutions */ /** The moeoObjectiveVectorComparator used to compare solutions */

11
trunk/paradiseo-moeo/src/archive/moeoFixedSizeArchive.h
View file

@ -42,9 +42,12 @@
#define MOEOFIXEDSIZEARCHIVE_H_ #define MOEOFIXEDSIZEARCHIVE_H_
#include <eoPop.h> #include <eoPop.h>
#include <archive/moeoArchive.h>
#include <comparator/moeoObjectiveVectorComparator.h>
/** /**
* An FixedSizeArchive is a secondary population that stores non-dominated solutions whith a fixed size. * Abstract class for representing a fixed size archive ;
* a fixed size archive is an archive containing a given number of solutions.
*/ */
template < class MOEOT > template < class MOEOT >
class moeoFixedSizeArchive : public moeoArchive < MOEOT > class moeoFixedSizeArchive : public moeoArchive < MOEOT >
@ -71,17 +74,13 @@ public:
moeoFixedSizeArchive(moeoObjectiveVectorComparator < ObjectiveVector > & _comparator) : moeoArchive < MOEOT >( _comparator) {} moeoFixedSizeArchive(moeoObjectiveVectorComparator < ObjectiveVector > & _comparator) : moeoArchive < MOEOT >( _comparator) {}
/**
* Returns true if the current archive dominates _objectiveVector according to the moeoObjectiveVectorComparator given in the constructor
* @param _objectiveVector the objective vector to compare with the current archive
*/
/** /**
* Updates the archive with a given individual _moeo * Updates the archive with a given individual _moeo
* @param _moeo the given individual * @param _moeo the given individual
*/ */
virtual void operator()(const MOEOT & _moeo)=0; virtual void operator()(const MOEOT & _moeo)=0;
/** /**
* Updates the archive with a given population _pop * Updates the archive with a given population _pop
* @param _pop the given population * @param _pop the given population

161
trunk/paradiseo-moeo/src/archive/moeoSPEA2Archive.h
View file

@ -41,40 +41,50 @@
#ifndef MOEOSPEA2ARCHIVE_H_ #ifndef MOEOSPEA2ARCHIVE_H_
#define MOEOSPEA2ARCHIVE_H_ #define MOEOSPEA2ARCHIVE_H_
#include <eoPop.h>
#include <list>
#include <moeo>
#include <limits> #include <limits>
#include <list>
#include <eoPop.h>
#include <archive/moeoFixedSizeArchive.h>
#include <comparator/moeoComparator.h>
#include <comparator/moeoFitnessThenDiversityComparator.h>
#include <comparator/moeoObjectiveVectorComparator.h>
#include <distance/moeoDistance.h>
#include <distance/moeoEuclideanDistance.h>
/** /**
* An archive is a secondary population that stores non-dominated solutions. * This class represents a bounded archive as defined in the SPEA2 algorithm.
* E. Zitzler, M. Laumanns, and L. Thiele. SPEA2: Improving the Strength Pareto Evolutionary Algorithm. Technical Report 103,
* Computer Engineering and Networks Laboratory (TIK), ETH Zurich, Zurich, Switzerland, 2001.
*/ */
template < class MOEOT > template < class MOEOT >
class moeoSPEA2Archive : public moeoFixedSizeArchive < MOEOT > class moeoSPEA2Archive : public moeoFixedSizeArchive < MOEOT >
{ {
public: public:
using eoPop < MOEOT > :: size; using moeoFixedSizeArchive < MOEOT > :: size;
using eoPop < MOEOT > :: resize; using moeoFixedSizeArchive < MOEOT > :: resize;
using eoPop < MOEOT > :: operator[]; using moeoFixedSizeArchive < MOEOT > :: operator[];
using eoPop < MOEOT > :: back; using moeoFixedSizeArchive < MOEOT > :: back;
using eoPop < MOEOT > :: pop_back; using moeoFixedSizeArchive < MOEOT > :: pop_back;
using eoPop < MOEOT > :: push_back; using moeoFixedSizeArchive < MOEOT > :: push_back;
using eoPop < MOEOT > :: begin; using moeoFixedSizeArchive < MOEOT > :: begin;
using eoPop < MOEOT > :: end; using moeoFixedSizeArchive < MOEOT > :: end;
/** /**
* The type of an objective vector for a solution * The type of an objective vector for a solution
*/ */
typedef typename MOEOT::ObjectiveVector ObjectiveVector; typedef typename MOEOT::ObjectiveVector ObjectiveVector;
/** /**
* Default ctor. * Default ctor.
* @param _maxSize the size of archive (must be smaller or egal to the population size) * @param _maxSize the size of archive (must be smaller or equal to the population size)
*/ */
moeoSPEA2Archive(unsigned int _maxSize=100): moeoFixedSizeArchive < MOEOT >(), maxSize(_maxSize), borne(0), indiComparator(defaultComparator), distance(defaultDistance) moeoSPEA2Archive(unsigned int _maxSize=100): moeoFixedSizeArchive < MOEOT >(), maxSize(_maxSize), borne(0), indiComparator(defaultComparator), distance(defaultDistance)
{} {}
/** /**
* Ctor where you can choose your own moeoDistance * Ctor where you can choose your own moeoDistance
* @param _dist the distance used * @param _dist the distance used
@ -83,6 +93,7 @@ public:
moeoSPEA2Archive(moeoDistance <MOEOT, double>& _dist, unsigned int _maxSize=100): moeoFixedSizeArchive < MOEOT >(), maxSize(_maxSize), borne(0), indiComparator(defaultComparator), distance(_dist) moeoSPEA2Archive(moeoDistance <MOEOT, double>& _dist, unsigned int _maxSize=100): moeoFixedSizeArchive < MOEOT >(), maxSize(_maxSize), borne(0), indiComparator(defaultComparator), distance(_dist)
{} {}
/** /**
* Ctor where you can choose your own moeoObjectiveVectorComparator * Ctor where you can choose your own moeoObjectiveVectorComparator
* @param _comparator the functor used to compare objective vectors * @param _comparator the functor used to compare objective vectors
@ -91,6 +102,7 @@ public:
moeoSPEA2Archive(moeoObjectiveVectorComparator < ObjectiveVector > & _comparator, unsigned int _maxSize=100): moeoFixedSizeArchive < MOEOT >(_comparator), maxSize(_maxSize), borne(0), indiComparator(defaultComparator), distance(defaultDistance) moeoSPEA2Archive(moeoObjectiveVectorComparator < ObjectiveVector > & _comparator, unsigned int _maxSize=100): moeoFixedSizeArchive < MOEOT >(_comparator), maxSize(_maxSize), borne(0), indiComparator(defaultComparator), distance(defaultDistance)
{} {}
/** /**
* Ctor where you can choose your own moeoComparator * Ctor where you can choose your own moeoComparator
* @param _indiComparator the functor used to compare MOEOT * @param _indiComparator the functor used to compare MOEOT
@ -99,6 +111,7 @@ public:
moeoSPEA2Archive(moeoComparator <MOEOT>& _indiComparator, unsigned int _maxSize=100): moeoFixedSizeArchive < MOEOT >(), maxSize(_maxSize), borne(0), indiComparator(_indiComparator), distance(defaultDistance) moeoSPEA2Archive(moeoComparator <MOEOT>& _indiComparator, unsigned int _maxSize=100): moeoFixedSizeArchive < MOEOT >(), maxSize(_maxSize), borne(0), indiComparator(_indiComparator), distance(defaultDistance)
{} {}
/** /**
* Ctor where you can choose your own moeoComparator, moeoDistance and moeoObjectiveVectorComparator * Ctor where you can choose your own moeoComparator, moeoDistance and moeoObjectiveVectorComparator
* @param _indiComparator the functor used to compare MOEOT * @param _indiComparator the functor used to compare MOEOT
@ -109,35 +122,32 @@ public:
moeoSPEA2Archive(moeoComparator <MOEOT>& _indiComparator, moeoDistance <MOEOT, double>& _dist, moeoObjectiveVectorComparator < ObjectiveVector > & _comparator, unsigned int _maxSize=100) : moeoFixedSizeArchive < MOEOT >(_comparator), maxSize(_maxSize), borne(0), indiComparator(_indiComparator), distance(_dist) moeoSPEA2Archive(moeoComparator <MOEOT>& _indiComparator, moeoDistance <MOEOT, double>& _dist, moeoObjectiveVectorComparator < ObjectiveVector > & _comparator, unsigned int _maxSize=100) : moeoFixedSizeArchive < MOEOT >(_comparator), maxSize(_maxSize), borne(0), indiComparator(_indiComparator), distance(_dist)
{} {}
/** /**
* Updates the archive with a given individual _moeo * Updates the archive with a given individual _moeo
* @param _moeo the given individual * @param _moeo the given individual
*/ */
void operator()(const MOEOT & _moeo) { void operator()(const MOEOT & _moeo)
{
eoPop < MOEOT > pop_tmp; eoPop < MOEOT > pop_tmp;
pop_tmp.push_back(_moeo); pop_tmp.push_back(_moeo);
operator()(pop_tmp); operator()(pop_tmp);
} }
/** /**
* Updates the archive with a given population _pop * Updates the archive with a given population _pop
* @param _pop the given population * @param _pop the given population
*/ */
void operator()(const eoPop < MOEOT > & _pop) { void operator()(const eoPop < MOEOT > & _pop)
{
unsigned int i=0; unsigned int i=0;
unsigned int foo=0; unsigned int foo=0;
/*std::cout << "\n\narchive avant: ";
for(unsigned k=0; k<size();k++)
std::cout << operator[](k).fitness() << " ";
std::cout << "\npop: ";
for(unsigned k=0; k<_pop.size();k++)
std::cout << _pop[k].fitness() << " ";*/
//Creation of the vector that contains minimal pop's informations //Creation of the vector that contains minimal pop's informations
std::vector<struct refpop> copy_pop(_pop.size()); std::vector<struct refpop> copy_pop(_pop.size());
for (i;i<_pop.size(); i++) { for (i;i<_pop.size(); i++)
{
copy_pop[i].index=i; copy_pop[i].index=i;
copy_pop[i].fitness=_pop[i].fitness(); copy_pop[i].fitness=_pop[i].fitness();
copy_pop[i].diversity=_pop[i].diversity(); copy_pop[i].diversity=_pop[i].diversity();
@ -147,23 +157,26 @@ public:
std::sort(copy_pop.begin(), copy_pop.end(), Cmp()); std::sort(copy_pop.begin(), copy_pop.end(), Cmp());
//If the archive is empty, put in the best elements of the pop //If the archive is empty, put in the best elements of the pop
if (borne < maxSize) { if (borne < maxSize)
{
foo= std::min(_pop.size(), maxSize-borne); foo= std::min(_pop.size(), maxSize-borne);
for (i=0; i< foo ; i++)
for (i=0; i< foo ; i++) { {
push_back(_pop[copy_pop[i].index]); push_back(_pop[copy_pop[i].index]);
borne++; borne++;
} }
} }
else { else
{
unsigned int j=0; unsigned int j=0;
//Sort the archive //Sort the archive
std::sort(begin(), end(), indiComparator); std::sort(begin(), end(), indiComparator);
i=0; i=0;
//While we have a better element in pop than the worst <= -1 in the archive, replace the worst(of archive) by the best(of pop) //While we have a better element in pop than the worst <= -1 in the archive, replace the worst(of archive) by the best(of pop)
while ( (i<borne) && ( (operator[](i).fitness()+operator[](i).diversity()) < (copy_pop[j].fitness + copy_pop[j].diversity) ) && (operator[](i).fitness()<=-1) && ( j < copy_pop.size() ) ) { while ( (i<borne) && ( (operator[](i).fitness()+operator[](i).diversity()) < (copy_pop[j].fitness + copy_pop[j].diversity) ) && (operator[](i).fitness()<=-1) && ( j < copy_pop.size() ) )
{
operator[](i)= back(); operator[](i)= back();
pop_back(); pop_back();
push_back(_pop[copy_pop[j].index]); push_back(_pop[copy_pop[j].index]);
@ -172,7 +185,8 @@ public:
} }
//If their are others goods elements in pop (fitness=0) , keep only archive's size elements between the archive's elements and the good element in the pop (k ieme smallest distance is used) //If their are others goods elements in pop (fitness=0) , keep only archive's size elements between the archive's elements and the good element in the pop (k ieme smallest distance is used)
if (copy_pop[j].fitness > -1) { if (copy_pop[j].fitness > -1)
{
unsigned int inf=j; unsigned int inf=j;
unsigned int p; unsigned int p;
unsigned int k=0; unsigned int k=0;
@ -186,14 +200,15 @@ public:
p=j-inf; p=j-inf;
//std::cout << "p: " << p << ", j: " << j << ",inf: " << inf << "\n";
std::vector< std::vector< std::pair<int,double> > > matrice(borne+p); std::vector< std::vector< std::pair<int,double> > > matrice(borne+p);
//Build the distance matrice(vector of vector) between each keeped elements //Build the distance matrice(vector of vector) between each keeped elements
if (borne+p>0) { if (borne+p>0)
for (k=0; k<borne+p-1; k++) { {
for (l=k+1; l<borne+p; l++) { for (k=0; k<borne+p-1; k++)
{
for (l=k+1; l<borne+p; l++)
{
if ( (k<borne) && (l<borne) ) if ( (k<borne) && (l<borne) )
tmp=distance(operator[](k), operator[](l)); tmp=distance(operator[](k), operator[](l));
else if ( (k<borne) && (l>=borne) ) else if ( (k<borne) && (l>=borne) )
@ -207,7 +222,8 @@ public:
} }
} }
for (k=0; k<borne+p; k++) { for (k=0; k<borne+p; k++)
{
//sort each line of the matrice //sort each line of the matrice
std::sort(matrice[k].begin(),matrice[k].end(), CmpPair()); std::sort(matrice[k].begin(),matrice[k].end(), CmpPair());
@ -225,12 +241,14 @@ public:
std::vector< std::pair<int,double> >::iterator it; std::vector< std::pair<int,double> >::iterator it;
//search elements of the archive to delete //search elements of the archive to delete
for (k=0; k<p; k++) { for (k=0; k<p; k++)
{
tmp2=(unsigned int)matrice[0].back().second; tmp2=(unsigned int)matrice[0].back().second;
if (tmp2<borne) if (tmp2<borne)
notkeeped.push_back(tmp2); notkeeped.push_back(tmp2);
matrice.erase(matrice_it); matrice.erase(matrice_it);
for (l=0; l<matrice.size(); l++) { for (l=0; l<matrice.size(); l++)
{
it=matrice[l].begin(); it=matrice[l].begin();
while ((*it).first != tmp2) while ((*it).first != tmp2)
it++; it++;
@ -241,55 +259,75 @@ public:
} }
//search elements of pop to put in archive //search elements of pop to put in archive
for (k=0; k<borne; k++) { for (k=0; k<borne; k++)
{
tmp2=(unsigned int)matrice[k].back().second; tmp2=(unsigned int)matrice[k].back().second;
if (tmp2 >= borne) if (tmp2 >= borne)
keeped.push_back(tmp2); keeped.push_back(tmp2);
} }
//replace some archive element by some pop element //replace some archive element by some pop element
for (k=0; k<keeped.size(); k++) { for (k=0; k<keeped.size(); k++)
{
push_back( _pop[ copy_pop[keeped[k]-borne+inf].index ] ); push_back( _pop[ copy_pop[keeped[k]-borne+inf].index ] );
operator[](notkeeped[k]) = back(); operator[](notkeeped[k]) = back();
pop_back(); pop_back();
} }
} }
} }
/*
std::cout << "\n\narchive aprés: ";
for(unsigned k=0; k<size();k++)
std::cout << operator[](k).fitness() << " ";*/
}//endoperator() }//endoperator()
private :
private:
/** archive max size */
unsigned int maxSize;
/** archive size */
unsigned int borne;
/** default moeoComparator*/
moeoFitnessThenDiversityComparator < MOEOT > defaultComparator;
/** distance */
moeoDistance <MOEOT, double>& distance;
/** default distance */
moeoEuclideanDistance < MOEOT > defaultDistance;
/** /**
* Structure needs to copy informations of the pop in order to sort it * Structure needs to copy informations of the pop in order to sort it
*/ */
struct refpop { struct refpop
{
unsigned index; unsigned index;
double fitness; double fitness;
double diversity; double diversity;
}; };
/** /**
* Comparator of struct refpop : compare fitness+divesity * Comparator of struct refpop : compare fitness+divesity
*/ */
struct Cmp { struct Cmp
bool operator()(const struct refpop& _a, const struct refpop& _b) { {
bool operator()(const struct refpop& _a, const struct refpop& _b)
{
return ( (_a.diversity + _a.fitness) > (_b.diversity + _b.fitness) ); return ( (_a.diversity + _a.fitness) > (_b.diversity + _b.fitness) );
} }
}; };
/** /**
* Comparator of two vector of pair * Comparator of two vector of pair
* Compare the second pair's value of the first element vector, if equals compare the next element vector... * Compare the second pair's value of the first element vector, if equals compare the next element vector...
*/ */
struct CmpVector { struct CmpVector
bool operator()( const std::vector< std::pair<int,double> >& _a, const std::vector< std::pair<int,double> >& _b) { {
bool operator()( const std::vector< std::pair<int,double> >& _a, const std::vector< std::pair<int,double> >& _b)
{
std::vector< std::pair<int,double> >::const_iterator it1= _a.begin(); std::vector< std::pair<int,double> >::const_iterator it1= _a.begin();
std::vector< std::pair<int,double> >::const_iterator it2= _b.begin(); std::vector< std::pair<int,double> >::const_iterator it2= _b.begin();
while ( (it1 != _a.end()) && (it2 != _b.end())) { while ( (it1 != _a.end()) && (it2 != _b.end()))
{
if ((*it1).second < (*it2).second) if ((*it1).second < (*it2).second)
return true; return true;
else if ((*it1).second > (*it2).second) else if ((*it1).second > (*it2).second)
@ -301,15 +339,19 @@ private :
} }
}; };
/** /**
* Comparator of two pair : compare the second pair's value * Comparator of two pair : compare the second pair's value
*/ */
struct CmpPair { struct CmpPair
bool operator()(const std::pair<int,double>& _a, const std::pair<int,double>& _b) { {
bool operator()(const std::pair<int,double>& _a, const std::pair<int,double>& _b)
{
return _a.second < _b.second; return _a.second < _b.second;
} }
}; };
/** /**
* Wrapper which allow to used an moeoComparator in std::sort * Wrapper which allow to used an moeoComparator in std::sort
* @param _comp the comparator to used * @param _comp the comparator to used
@ -321,8 +363,7 @@ private :
* Ctor. * Ctor.
* @param _comp the comparator * @param _comp the comparator
*/ */
Wrapper(moeoComparator < MOEOT > & _comp) : comp(_comp) Wrapper(moeoComparator < MOEOT > & _comp) : comp(_comp) {}
{}
/** /**
* Returns true if _moeo1 is greater than _moeo2 according to the comparator * Returns true if _moeo1 is greater than _moeo2 according to the comparator
* _moeo1 the first individual * _moeo1 the first individual
@ -338,16 +379,6 @@ private :
} }
indiComparator; indiComparator;
/** archive max size */
unsigned int maxSize;
/** archive size */
unsigned int borne;
/** default moeoComparator*/
moeoFitnessThenDiversityComparator < MOEOT > defaultComparator;
/** distance */
moeoDistance <MOEOT, double>& distance;
/** default distance */
moeoEuclideanDistance < MOEOT > defaultDistance;
}; };
#endif /*MOEOSPEA2ARCHIVE_H_*/ #endif /*MOEOSPEA2ARCHIVE_H_*/

19
trunk/paradiseo-moeo/src/archive/moeoUnboundedArchive.h
View file

@ -41,20 +41,22 @@
#define MOEOUNBOUNDEDARCHIVE_H_ #define MOEOUNBOUNDEDARCHIVE_H_
#include <eoPop.h> #include <eoPop.h>
#include <archive/moeoArchive.h>
#include <comparator/moeoObjectiveVectorComparator.h>
/** /**
* An archive is a secondary population that stores non-dominated solutions. * An unbounded archive is an archive storing an unbounded number of non-dominated solutions.
*/ */
template < class MOEOT > template < class MOEOT >
class moeoUnboundedArchive : public moeoArchive < MOEOT > class moeoUnboundedArchive : public moeoArchive < MOEOT >
{ {
public: public:
using eoPop < MOEOT > :: size; using moeoArchive < MOEOT > :: size;
using eoPop < MOEOT > :: resize; using moeoArchive < MOEOT > :: resize;
using eoPop < MOEOT > :: operator[]; using moeoArchive < MOEOT > :: operator[];
using eoPop < MOEOT > :: back; using moeoArchive < MOEOT > :: back;
using eoPop < MOEOT > :: pop_back; using moeoArchive < MOEOT > :: pop_back;
/** /**
@ -77,11 +79,6 @@ public:
moeoUnboundedArchive(moeoObjectiveVectorComparator < ObjectiveVector > & _comparator) : moeoArchive < MOEOT >(_comparator) {} moeoUnboundedArchive(moeoObjectiveVectorComparator < ObjectiveVector > & _comparator) : moeoArchive < MOEOT >(_comparator) {}
/**
* Returns true if the current archive dominates _objectiveVector according to the moeoObjectiveVectorComparator given in the constructor
* @param _objectiveVector the objective vector to compare with the current archive
*/
/** /**
* Updates the archive with a given individual _moeo * Updates the archive with a given individual _moeo
* @param _moeo the given individual * @param _moeo the given individual