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

23/02/07 modifications

Browse source 
git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@184 331e1502-861f-0410-8da2-ba01fb791d7f
This commit is contained in:
liefooga 2007-02-23 12:49:11 +00:00
commit 086b51c370
20 changed files with 772 additions and 970 deletions
Download patch file Download diff file Expand all files Collapse all files

339
branches/paradiseo-moeo-1.0/src/MOEO.h
View file

@ -31,253 +31,250 @@
* operator '<' et '>' ??? * operator '<' et '>' ???
* !!!!!!!!!!!!!!!!!!!!!!! * !!!!!!!!!!!!!!!!!!!!!!!
*/ */
template < class MOEOObjectiveVector, class MOEOFitness, class MOEODiversity > class MOEO:public EO < template < class MOEOObjectiveVector, class MOEOFitness, class MOEODiversity >
MOEOFitness class MOEO : public EO < MOEOFitness >
>
{ {
public: public:
/** the objective vector type of a solution */ /** the objective vector type of a solution */
typedef MOEOObjectiveVector ObjectiveVector; typedef MOEOObjectiveVector ObjectiveVector;
/** the fitness type of a solution */ /** the fitness type of a solution */
typedef MOEOFitness Fitness; typedef MOEOFitness Fitness;
/** the diversity type of a solution */ /** the diversity type of a solution */
typedef MOEODiversity Diversity; typedef MOEODiversity Diversity;
/** /**
* Ctor * Ctor
*/ */
MOEO () MOEO()
{ {
// default values for every parameters // default values for every parameters
objectiveVectorValue = ObjectiveVector (); objectiveVectorValue = ObjectiveVector();
fitnessValue = Fitness (); fitnessValue = Fitness();
diversityValue = Diversity (); diversityValue = Diversity();
// invalidate all // invalidate all
invalidate (); invalidate();
} }
/** /**
* Virtual dtor * Virtual dtor
*/ */
virtual ~ MOEO () virtual ~MOEO() {};
{
};
/** /**
* Returns the objective vector of the current solution * Returns the objective vector of the current solution
*/ */
ObjectiveVector objectiveVector () const ObjectiveVector objectiveVector() const
{ {
if (invalidObjectiveVector ()) if ( invalidObjectiveVector() )
{ {
throw std::runtime_error ("invalid objective vector"); throw std::runtime_error("invalid objective vector");
} }
return objectiveVectorValue; return objectiveVectorValue;
} }
/** /**
* Sets the objective vector of the current solution * Sets the objective vector of the current solution
* @param _objectiveVectorValue the new objective vector * @param _objectiveVectorValue the new objective vector
*/ */
void objectiveVector (const ObjectiveVector & _objectiveVectorValue) void objectiveVector(const ObjectiveVector & _objectiveVectorValue)
{ {
objectiveVectorValue = _objectiveVectorValue; objectiveVectorValue = _objectiveVectorValue;
invalidObjectiveVectorValue = false; invalidObjectiveVectorValue = false;
} }
/** /**
* Sets the objective vector as invalid * Sets the objective vector as invalid
*/ */
void invalidateObjectiveVector () void invalidateObjectiveVector()
{ {
invalidObjectiveVectorValue = true; invalidObjectiveVectorValue = true;
} }
/** /**
* Returns true if the objective vector is invalid, false otherwise * Returns true if the objective vector is invalid, false otherwise
*/ */
bool invalidObjectiveVector () const bool invalidObjectiveVector() const
{ {
return invalidObjectiveVectorValue; return invalidObjectiveVectorValue;
} }
/** /**
* Returns the fitness value of the current solution * Returns the fitness value of the current solution
*/ */
Fitness fitness () const Fitness fitness() const
{ {
if (invalidFitness ()) if ( invalidFitness() )
{ {
throw std::runtime_error ("invalid fitness"); throw std::runtime_error("invalid fitness");
} }
return fitnessValue; return fitnessValue;
} }
/** /**
* Sets the fitness value of the current solution * Sets the fitness value of the current solution
* @param _fitnessValue the new fitness value * @param _fitnessValue the new fitness value
*/ */
void fitness (const Fitness & _fitnessValue) void fitness(const Fitness & _fitnessValue)
{ {
fitnessValue = _fitnessValue; fitnessValue = _fitnessValue;
invalidFitnessValue = false; invalidFitnessValue = false;
} }
/** /**
* Sets the fitness value as invalid * Sets the fitness value as invalid
*/ */
void invalidateFitness () void invalidateFitness()
{ {
invalidFitnessValue = true; invalidFitnessValue = true;
} }
/** /**
* Returns true if the fitness value is invalid, false otherwise * Returns true if the fitness value is invalid, false otherwise
*/ */
bool invalidFitness () const bool invalidFitness() const
{ {
return invalidFitnessValue; return invalidFitnessValue;
} }
/** /**
* Returns the diversity value of the current solution * Returns the diversity value of the current solution
*/ */
Diversity diversity () const Diversity diversity() const
{ {
if (invalidDiversity ()) if ( invalidDiversity() )
{ {
throw std::runtime_error ("invalid diversity"); throw std::runtime_error("invalid diversity");
} }
return diversityValue; return diversityValue;
} }
/** /**
* Sets the diversity value of the current solution * Sets the diversity value of the current solution
* @param _diversityValue the new diversity value * @param _diversityValue the new diversity value
*/ */
void diversity (const Diversity & _diversityValue) void diversity(const Diversity & _diversityValue)
{ {
diversityValue = _diversityValue; diversityValue = _diversityValue;
invalidDiversityValue = false; invalidDiversityValue = false;
} }
/** /**
* Sets the diversity value as invalid * Sets the diversity value as invalid
*/ */
void invalidateDiversity () void invalidateDiversity()
{ {
invalidDiversityValue = true; invalidDiversityValue = true;
} }
/** /**
* Returns true if the diversity value is invalid, false otherwise * Returns true if the diversity value is invalid, false otherwise
*/ */
bool invalidDiversity () const bool invalidDiversity() const
{ {
return invalidDiversityValue; return invalidDiversityValue;
} }
/** /**
* Sets the objective vector, the fitness value and the diversity value as invalid * Sets the objective vector, the fitness value and the diversity value as invalid
*/ */
void invalidate () void invalidate()
{ {
invalidateObjectiveVector (); invalidateObjectiveVector();
invalidateFitness (); invalidateFitness();
invalidateDiversity (); invalidateDiversity();
} }
/** /**
* Returns true if the fitness value is invalid, false otherwise * Returns true if the fitness value is invalid, false otherwise
*/ */
bool invalid () const bool invalid() const
{ {
return invalidObjectiveVector (); return invalidObjectiveVector();
} }
/** /**
* Return the class id (the class name as a std::string) * Return the class id (the class name as a std::string)
*/ */
virtual std::string className () const virtual std::string className() const
{ {
return "MOEO"; return "MOEO";
} }
/** /**
* Writing object * Writing object
* @param _os output stream * @param _os output stream
*/ */
virtual void printOn (std::ostream & _os) const virtual void printOn(std::ostream & _os) const
{ {
if (invalidObjectiveVector ()) if ( invalidObjectiveVector() )
{ {
_os << "INVALID\t"; _os << "INVALID\t";
} }
else else
{ {
_os << objectiveVectorValue << '\t'; _os << objectiveVectorValue << '\t';
} }
} }
/** /**
* Reading object * Reading object
* @param _is input stream * @param _is input stream
*/ */
virtual void readFrom (std::istream & _is) virtual void readFrom(std::istream & _is)
{ {
std::string objectiveVector_str; std::string objectiveVector_str;
int pos = _is.tellg (); int pos = _is.tellg();
_is >> objectiveVector_str; _is >> objectiveVector_str;
if (objectiveVector_str == "INVALID") if (objectiveVector_str == "INVALID")
{ {
invalidateObjectiveVector (); invalidateObjectiveVector();
} }
else else
{ {
invalidObjectiveVectorValue = false; invalidObjectiveVectorValue = false;
_is.seekg (pos); // rewind _is.seekg(pos); // rewind
_is >> objectiveVectorValue; _is >> objectiveVectorValue;
} }
} }
private: private:
/** the objective vector of this solution */ /** the objective vector of this solution */
ObjectiveVector objectiveVectorValue; ObjectiveVector objectiveVectorValue;
/** true if the objective vector is invalid */ /** true if the objective vector is invalid */
bool invalidObjectiveVectorValue; bool invalidObjectiveVectorValue;
/** the fitness value of this solution */ /** the fitness value of this solution */
Fitness fitnessValue; Fitness fitnessValue;
/** true if the fitness value is invalid */ /** true if the fitness value is invalid */
bool invalidFitnessValue; bool invalidFitnessValue;
/** the diversity value of this solution */ /** the diversity value of this solution */
Diversity diversityValue; Diversity diversityValue;
/** true if the diversity value is invalid */ /** true if the diversity value is invalid */
bool invalidDiversityValue; bool invalidDiversityValue;
}; };
#endif /*MOEO_H_ */ #endif /*MOEO_H_*/

3
branches/paradiseo-moeo-1.0/src/moeo
View file

@ -15,9 +15,11 @@
#include <eo> #include <eo>
#include <metric/moeoAdditiveEpsilonBinaryMetric.h>
#include <metric/moeoBinaryMetricSavingUpdater.h> #include <metric/moeoBinaryMetricSavingUpdater.h>
#include <metric/moeoContributionMetric.h> #include <metric/moeoContributionMetric.h>
#include <metric/moeoEntropyMetric.h> #include <metric/moeoEntropyMetric.h>
#include <metric/moeoHypervolumeBinaryMetric.h>
#include <metric/moeoMetric.h> #include <metric/moeoMetric.h>
#include <moeoArchiveFitnessSavingUpdater.h> #include <moeoArchiveFitnessSavingUpdater.h>
#include <moeoArchiveUpdater.h> #include <moeoArchiveUpdater.h>
@ -28,6 +30,7 @@
#include <moeoEA.h> #include <moeoEA.h>
#include <moeoEvalFunc.h> #include <moeoEvalFunc.h>
#include <moeoFastNonDominatedSortingFitnessAssignment.h> #include <moeoFastNonDominatedSortingFitnessAssignment.h>
#include <moeoFitnessAssignment.h>
#include <moeoGenerationalReplacement.h> #include <moeoGenerationalReplacement.h>
#include <moeoHybridLS.h> #include <moeoHybridLS.h>
#include <moeoLS.h> #include <moeoLS.h>

203
branches/paradiseo-moeo-1.0/src/moeoArchive.h
View file

@ -14,148 +14,141 @@
#define MOEOARCHIVE_H_ #define MOEOARCHIVE_H_
#include <eoPop.h> #include <eoPop.h>
#include <moeoObjectiveVectorComparator.h>
/** /**
* An archive is a secondary population that stores non-dominated solutions * An archive is a secondary population that stores non-dominated solutions.
*/ */
template < class MOEOT > class moeoArchive:public eoPop < MOEOT > template < class MOEOT >
class moeoArchive : public eoPop < MOEOT >
{ {
public: public:
using std::vector < MOEOT >::size; using std::vector < MOEOT > :: size;
using std::vector < MOEOT >::operator[]; using std::vector < MOEOT > :: operator[];
using std::vector < MOEOT >::back; using std::vector < MOEOT > :: back;
using std::vector < MOEOT >::pop_back; using std::vector < MOEOT > :: pop_back;
/** /**
* 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.
* The moeoObjectiveVectorComparator used to compare solutions is based on Pareto dominance * The moeoObjectiveVectorComparator used to compare solutions is based on Pareto dominance
*/ */
moeoArchive ():eoPop < MOEOT > (), comparator (paretoComparator) moeoArchive() : eoPop < MOEOT >(), comparator(paretoComparator)
{ {}
}
/** /**
* Ctor * Ctor
* @param _comparator the moeoObjectiveVectorComparator used to compare solutions * @param _comparator the moeoObjectiveVectorComparator used to compare solutions
*/ */
moeoArchive (moeoObjectiveVectorComparator < ObjectiveVector > &_comparator):eoPop < MOEOT > (), moeoArchive(moeoObjectiveVectorComparator < ObjectiveVector > & _comparator) : eoPop < MOEOT >(), comparator(_comparator)
comparator {}
(_comparator)
{
}
/** /**
* Returns true if the current archive dominates _objectiveVector according to the moeoObjectiveVectorComparator given in the constructor * 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 * @param _objectiveVector the objective vector to compare with the current archive
*/ */
bool dominates (const ObjectiveVector & _objectiveVector) const bool dominates (const ObjectiveVector & _objectiveVector) const
{ {
for (unsigned i = 0; i < size (); i++) for (unsigned i = 0; i<size(); i++)
{ {
if (comparator (operator[](i).fitness (), _objectiveVector) == 1) if ( comparator(operator[](i).fitness(), _objectiveVector) )
{ {
return true; return true;
} }
} }
return false; return false;
} }
/** /**
* Returns true if the current archive already contains a solution with the same objective values than _objectiveVector * Returns true if the current archive already contains a solution with the same objective values than _objectiveVector
* @param _objectiveVector the objective vector to compare with the current archive * @param _objectiveVector the objective vector to compare with the current archive
*/ */
bool contains (const ObjectiveVector & _objectiveVector) const bool contains (const ObjectiveVector & _objectiveVector) const
{ {
for (unsigned i = 0; i < size; i++) for (unsigned i = 0; i<size(); i++)
{ {
if (operator[](i).fitness () == _objectiveVector) if (operator[](i).fitness() == _objectiveVector)
{ {
return true; return true;
} }
} }
return false; return false;
} }
/** /**
* 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 update (const MOEOT & _moeo) void update (const MOEOT & _moeo)
{ {
// first step: removing the dominated solutions from the archive // first step: removing the dominated solutions from the archive
for (unsigned j = 0; j < size ();) for (unsigned j=0; j<size();)
{ {
// if _moeo.fitness() dominates operator[](j).fitness() // if _moeo dominates the jth solution contained in the archive
//if ( comparator(_moeo.fitness(), operator[](j).fitness())==1 ) if ( comparator(_moeo.objectiveVector(), operator[](j).objectiveVector()) )
if (comparator {
(_moeo.objectiveVector (), operator[](j).objectiveVector ()) == 1) operator[](j) = back();
{ pop_back();
operator[](j) = back (); }
pop_back (); else if (_moeo.objectiveVector() == operator[](j).objectiveVector())
} {
//else if (_moeo.fitness() == operator[](j).fitness()) operator[](j) = back();
else if (_moeo.objectiveVector () == operator[](j).objectiveVector ()) pop_back();
{ }
operator[](j) = back (); else
pop_back (); {
} j++;
else }
{ }
j++; // second step: is _moeo dominated?
} bool dom = false;
} for (unsigned j=0; j<size(); j++)
// second step: is _moeo dominated? {
bool dom = false; // if the jth solution contained in the archive dominates _moeo
for (unsigned j = 0; j < size (); j++) if ( comparator(operator[](j).objectiveVector(), _moeo.objectiveVector()) )
{ {
// if operator[](j).fitness() dominates _moeo.fitness() dom = true;
//if ( comparator(operator[](j).fitness(), _moeo.fitness())==1 ) break;
if (comparator }
(operator[](j).objectiveVector (), _moeo.objectiveVector ()) == 1) }
{ if (!dom)
dom = true; {
break; push_back(_moeo);
} }
} }
if (!dom)
{
push_back (_moeo);
}
}
/** /**
* 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 update (const eoPop < MOEOT > &_pop) void update (const eoPop < MOEOT > & _pop)
{ {
for (unsigned i = 0; i < _pop.size (); i++) for (unsigned i=0; i<_pop.size(); i++)
{ {
update (_pop[i]); update(_pop[i]);
} }
} }
private: private:
/** The moeoObjectiveVectorComparator used to compare solutions */ /** The moeoObjectiveVectorComparator used to compare solutions */
moeoObjectiveVectorComparator < ObjectiveVector > &comparator; moeoObjectiveVectorComparator < ObjectiveVector > & comparator;
/** A moeoObjectiveVectorComparator based on Pareto dominance (used as default) */ /** A moeoObjectiveVectorComparator based on Pareto dominance (used as default) */
moeoParetoObjectiveVectorComparator < ObjectiveVector > paretoComparator; moeoParetoObjectiveVectorComparator < ObjectiveVector > paretoComparator;
}; };
#endif /*MOEOARCHIVE_H_ */ #endif /*MOEOARCHIVE_H_ */

31
branches/paradiseo-moeo-1.0/src/moeoArchiveFitnessSavingUpdater.h
View file

@ -24,7 +24,8 @@
/** /**
* This class allows to save the fitnesses of solutions contained in an archive into a file at each generation. * This class allows to save the fitnesses of solutions contained in an archive into a file at each generation.
*/ */
template < class EOT > class moeoArchiveFitnessSavingUpdater:public eoUpdater template <class EOT>
class moeoArchiveFitnessSavingUpdater : public eoUpdater
{ {
public: public:
@ -34,25 +35,21 @@ public:
* @param _filename target filename * @param _filename target filename
* @param _id own ID * @param _id own ID
*/ */
moeoArchiveFitnessSavingUpdater (moeoArchive < EOT > &_arch, const std::string & _filename = "Res/Arch", int _id = -1):arch (_arch), filename (_filename), id (_id), moeoArchiveFitnessSavingUpdater (moeoArchive<EOT> & _arch, const std::string & _filename = "Res/Arch", int _id = -1) : arch(_arch), filename(_filename), id(_id), counter(0)
counter {}
(0)
{
}
/** /**
* Saves the fitness of the archive's members into the file * Saves the fitness of the archive's members into the file
*/ */
void operator () () void operator()() {
{
char buff[MAX_BUFFER_SIZE]; char buff[MAX_BUFFER_SIZE];
if (id == -1) if (id == -1)
sprintf (buff, "%s.%u", filename.c_str (), counter++); sprintf (buff, "%s.%u", filename.c_str(), counter ++);
else else
sprintf (buff, "%s.%u.%u", filename.c_str (), id, counter++); sprintf (buff, "%s.%u.%u", filename.c_str(), id, counter ++);
std::ofstream f (buff); std::ofstream f(buff);
for (unsigned i = 0; i < arch.size (); i++) for (unsigned i = 0; i < arch.size (); i++)
f << arch[i].objectiveVector () << std::endl; f << arch[i].objectiveVector() << std::endl;
f.close (); f.close ();
} }
@ -60,14 +57,14 @@ moeoArchiveFitnessSavingUpdater (moeoArchive < EOT > &_arch, const std::string &
private: private:
/** local archive */ /** local archive */
moeoArchive < EOT > &arch; moeoArchive<EOT> & arch;
/** target filename */ /** target filename */
std::string filename; std::string filename;
/** own ID */ /** own ID */
int id; int id;
/** counter */ /** counter */
unsigned counter; unsigned counter;
}; };
#endif /*MOEOARCHIVEFITNESSSAVINGUPDATER_H_ */ #endif /*MOEOARCHIVEFITNESSSAVINGUPDATER_H_*/

28
branches/paradiseo-moeo-1.0/src/moeoArchiveUpdater.h
View file

@ -18,39 +18,37 @@
#include <moeoArchive.h> #include <moeoArchive.h>
/** /**
* This class allows to update the archive at each generation with newly found non-dominated solutions * This class allows to update the archive at each generation with newly found non-dominated solutions.
*/ */
template < class EOT > class moeoArchiveUpdater:public eoUpdater template < class EOT >
class moeoArchiveUpdater : public eoUpdater
{ {
public: public:
/** /**
* Ctor * Ctor
* @param _arch an archive of non-dominated solutions * @param _arch an archive of non-dominated solutions
* @param _pop the main population * @param _pop the main population
*/ */
moeoArchiveUpdater (moeoArchive < EOT > &_arch, moeoArchiveUpdater(moeoArchive <EOT> & _arch, const eoPop<EOT> & _pop) : arch(_arch), pop(_pop)
const eoPop < EOT > &_pop):arch (_arch), pop (_pop) {}
{
}
/** /**
* Updates the archive with newly found non-dominated solutions contained in the main population * Updates the archive with newly found non-dominated solutions contained in the main population
*/ */
void operator () () void operator()() {
{ arch.update(pop);
arch.update (pop);
} }
private: private:
/** the archive of non-dominated solutions */ /** the archive of non-dominated solutions */
moeoArchive < EOT > &arch; moeoArchive<EOT> & arch;
/** the main population */ /** the main population */
const eoPop < EOT > &pop; const eoPop<EOT> & pop;
}; };
#endif /*MOEOARCHIVEUPDATER_H_ */ #endif /*MOEOARCHIVEUPDATER_H_*/

52
branches/paradiseo-moeo-1.0/src/moeoCombinedLS.h
View file

@ -19,53 +19,53 @@
/** /**
* This class allows to embed a set of local searches that are sequentially applied, * This class allows to embed a set of local searches that are sequentially applied,
* and so working and updating the same archive of non-dominated solutions * and so working and updating the same archive of non-dominated solutions.
*/ */
template < class MOEOT > class moeoCombinedLS:public moeoLS < MOEOT > template < class MOEOT >
class moeoCombinedLS : public moeoLS < MOEOT >
{ {
public: public:
/** /**
* Ctor * Ctor
* @param _eval the full evaluator of a solution * @param _eval the full evaluator of a solution
* @param _first_ls the first multi-objective local search to add * @param _first_mols the first multi-objective local search to add
*/ */
moeoCombinedLS (moeoEvalFunc < MOEOT > &_eval, moeoLS < MOEOT > &_first_ls):eval moeoCombinedLS(moeoEvalFunc < MOEOT > & _eval, moeoLS < MOEOT > & _first_mols) : eval (_eval)
(_eval) {
{ combinedLS.push_back (& _first_mols);
combinedLS.push_back (&_first_ls); }
}
/** /**
* Adds a new local search to combine * Adds a new local search to combine
* @param _ls the multi-objective local search to add * @param _mols the multi-objective local search to add
*/ */
void add (moeoLS < MOEOT > &_ls) void add(moeoLS < MOEOT > & _mols)
{ {
combinedMOLS.push_back (&_ls); combinedMOLS.push_back(& _mols);
} }
/** /**
* Gives a new solution in order to explore the neigborhood. * Gives a new solution in order to explore the neigborhood.
* The new non-dominated solutions are added to the archive * The new non-dominated solutions are added to the archive
* @param _eo the solution * @param _moeo the solution
* @param _arch the archive of non-dominated solutions * @param _arch the archive of non-dominated solutions
*/ */
void operator () (const MOEOT & _eo, moeoArchive < MOEOT > &_arch) void operator () (const MOEOT & _moeo, moeoArchive < MOEOT > & _arch)
{ {
eval (const_cast < MOEOT & >(_eo)); eval(const_cast < MOEOT & > (_moeo));
for (unsigned i = 0; i < combinedLS.size (); i++) for (unsigned i=0; i<combinedLS.size(); i++)
combinedLS[i]->operator ()(_eo, _arch); combinedLS[i] -> operator()(_moeo, _arch);
} }
private: private:
/** the full evaluator of a solution */ /** the full evaluator of a solution */
moeoEvalFunc < MOEOT > &eval; moeoEvalFunc < MOEOT > & eval;
/** the vector that contains the combined LS */ /** the vector that contains the combined LS */
std::vector < moeoLS < MOEOT > *>combinedLS; std::vector< moeoLS < MOEOT > * > combinedLS;
}; };
#endif /*MOEOCOMBINEDLS_H_ */ #endif /*MOEOCOMBINEDLS_H_*/

160
branches/paradiseo-moeo-1.0/src/moeoComparator.h
View file

@ -14,24 +14,20 @@
#define MOEOCOMPARATOR_H_ #define MOEOCOMPARATOR_H_
#include <eoFunctor.h> #include <eoFunctor.h>
#include <eoPop.h>
/** /**
* Functor allowing to compare two solutions * Functor allowing to compare two solutions.
*/ */
template < class MOEOT > class moeoComparator:public eoBF < const MOEOT &, const MOEOT &, template < class MOEOT >
const bool > class moeoComparator : public eoBF < const MOEOT &, const MOEOT &, const bool >
{ {};
public:
// virtual const bool operator () (const MOEOT & _moeo1, const MOEOT & _moeo){}
};
/** /**
* Functor allowing to compare two solutions according to their first objective value, then their second, and so on * Functor allowing to compare two solutions according to their first objective value, then their second, and so on.
*/ */
template < class MOEOT > class moeoObjectiveComparator:public moeoComparator < template < class MOEOT >
MOEOT > class moeoObjectiveComparator : public moeoComparator < MOEOT >
{ {
public: public:
/** /**
@ -39,56 +35,18 @@ public:
* @param _moeo1 the first solution * @param _moeo1 the first solution
* @param _moeo2 the second solution * @param _moeo2 the second solution
*/ */
const bool operator () (const MOEOT & _moeo1, const MOEOT & _moeo2) const bool operator()(const MOEOT & _moeo1, const MOEOT & _moeo2)
{ {
return _moeo1.objectiveVector () < _moeo2.objectiveVector (); return _moeo1.objectiveVector() < _moeo2.objectiveVector();
} }
}; };
/** /**
* Functor allowing to compare two solutions according to their fitness values * Functor allowing to compare two solutions according to their fitness values, then according to their diversity values.
*/ */
//template < class MOEOT > template < class MOEOT >
//class moeoFitnessComparator : public moeoComparator < MOEOT > class moeoFitnessThenDiversityComparator : public moeoComparator < MOEOT >
//{
//public:
// /**
// * Returns true if the fitness value of _moeo1 is smaller than the fitness value of _moeo2
// * @param _moeo1 the first solution
// * @param _moeo2 the second solution
// */
// const bool operator()(const MOEOT & _moeo1, const MOEOT & _moeo2)
// {
// return _moeo1.fitness() < _moeo2.fitness();
// }
//};
//
//
///**
// * Functor allowing to compare two solutions according to their diversity values
// */
//template < class MOEOT >
//class moeoDiversityComparator : public moeoComparator < MOEOT >
//{
//public:
// /**
// * Returns true if the diversity value of _moeo1 is smaller than the diversity value of _moeo2
// * @param _moeo1 the first solution
// * @param _moeo2 the second solution
// */
// const bool operator()(const MOEOT & _moeo1, const MOEOT & _moeo2)
// {
// return _moeo1.diversity() < _moeo2.diversity();
// }
//};
/**
* Functor allowing to compare two solutions according to their fitness values, then according to their diversity values
*/
template < class MOEOT > class moeoFitnessThenDiversityComparator:public moeoComparator <
MOEOT >
{ {
public: public:
/** /**
@ -96,25 +54,25 @@ public:
* @param _moeo1 the first solution * @param _moeo1 the first solution
* @param _moeo2 the second solution * @param _moeo2 the second solution
*/ */
const bool operator () (const MOEOT & _moeo1, const MOEOT & _moeo2) const bool operator()(const MOEOT & _moeo1, const MOEOT & _moeo2)
{ {
if (_moeo1.fitness () == _moeo2.fitness ()) if (_moeo1.fitness() == _moeo2.fitness())
{ {
return _moeo1.diversity () < _moeo2.diversity (); return _moeo1.diversity() < _moeo2.diversity();
} }
else else
{ {
return _moeo1.fitness () < _moeo2.fitness (); return _moeo1.fitness() < _moeo2.fitness();
} }
} }
}; };
/** /**
* Functor allowing to compare two solutions according to their diversity values, then according to their fitness values * Functor allowing to compare two solutions according to their diversity values, then according to their fitness values.
*/ */
template < class MOEOT > class moeoDiversityThenFitnessComparator:public moeoComparator < template < class MOEOT >
MOEOT > class moeoDiversityThenFitnessComparator : public moeoComparator < MOEOT >
{ {
public: public:
/** /**
@ -122,64 +80,18 @@ public:
* @param _moeo1 the first solution * @param _moeo1 the first solution
* @param _moeo2 the second solution * @param _moeo2 the second solution
*/ */
const bool operator () (const MOEOT & _moeo1, const MOEOT & _moeo2)
{
if (_moeo1.diversity () == _moeo2.diversity ())
{
return _moeo1.fitness () < _moeo2.fitness ();
}
else
{
return _moeo1.diversity () < _moeo2.diversity ();
}
}
};
/**
* Functor allowing to compare two solutions according to Pareto dominance relation => USEFULL ???
*
template < class MOEOT >
class moeoParetoDominanceComparator : public moeoComparator < MOEOT >
{
public:
/**
* Returns true if _moeo1 is dominated by _moeo2 according to Pareto dominance relation
* @param _moeo1 the first solution
* @param _moeo2 the second solution
*
const bool operator()(const MOEOT & _moeo1, const MOEOT & _moeo2) const bool operator()(const MOEOT & _moeo1, const MOEOT & _moeo2)
{ {
bool result = false; if (_moeo1.diversity() == _moeo2.diversity())
typedef typename MOEOT::ObjectiveVector::Traits ObjectiveVectorTraits;
for (unsigned i=0; i<ObjectiveVectorTraits::nObjectives(); i++)
{ {
// first, we have to check if the 2 objective values are not equal on the ith objective return _moeo1.fitness() < _moeo2.fitness();
if ( fabs(_moeo1.objectiveVector()[i] - _moeo2.objectiveVector()[i]) > ObjectiveVectorTraits::tolerance() ) }
{ else
// if the ith objective have to be minimized... {
if (ObjectiveVectorTraits::minimizing(i)) return _moeo1.diversity() < _moeo2.diversity();
{
if (_moeo1.objectiveVector()[i] < _moeo2.objectiveVector()[i])
{
return false; // _moeo2 cannot dominate _moeo1
}
result = true;
}
// if the ith objective have to be maximized...
else if (ObjectiveVectorTraits::maximizing(i))
{
if (_moeo1.objectiveVector()[i] > _moeo2.objectiveVector()[i])
{
return false; // _moeo2 cannot dominate _moeo1
}
result = true;
}
}
} }
return result;
} }
}; };
*/
#endif /*MOEOCOMPARATOR_H_ */
#endif /*MOEOCOMPARATOR_H_*/

42
branches/paradiseo-moeo-1.0/src/moeoDiversityAssignment.h
View file

@ -17,32 +17,34 @@
#include <eoPop.h> #include <eoPop.h>
/** /**
* Functor that sets the diversity values of a whole population * Functor that sets the diversity values of a whole population.
*/ */
template < class MOEOT > class moeoDiversityAssignment:public eoUF < eoPop < MOEOT > &, template < class MOEOT >
void > class moeoDiversityAssignment : public eoUF < eoPop < MOEOT > &, void >
{ {};
};
/** /**
* moeoDummyDiversityAssignment is a moeoDiversityAssignment which gives 0 as the diversity for the whole population. * moeoDummyDiversityAssignment is a moeoDiversityAssignment that gives the value '0' as the individual's diversity for a whole population.
*/ */
template < class MOEOT > class moeoDummyDiversityAssignment:public moeoDiversityAssignment < template < class MOEOT >
MOEOT > class moeoDummyDiversityAssignment : public moeoDiversityAssignment < MOEOT >
{ {
// main operator public:
void operator () (eoPop < MOEOT > &_pop)
{
for (int idx = 0; idx < _pop.size (); idx++)
{
// set the diversity to 0
_pop[idx].diversity (0);
}
}
/**
* Sets the diversity to '0' for every individuals of the population _pop
* @param _pop the population
*/
void operator () (eoPop < MOEOT > & _pop)
{
for (unsigned idx = 0; idx<_pop.size (); idx++)
{
// set the diversity to 0
_pop[idx].diversity(0);
}
}
}; };
#endif /*MOEODIVERSITYASSIGNMENT_H_*/
#endif /*MOEODIVERSITYASSIGNMENT_H_ */

9
branches/paradiseo-moeo-1.0/src/moeoEA.h
View file

@ -16,11 +16,10 @@
#include <eoAlgo.h> #include <eoAlgo.h>
/** /**
* Abstract class for multi-objective evolutionary algorithms * Abstract class for multi-objective evolutionary algorithms.
*/ */
template < class MOEOT > class moeoEA:public eoAlgo < MOEOT > template < class MOEOT >
{ class moeoEA : public eoAlgo < MOEOT > {};
};
#endif /*MOEOEA_H_ */ #endif /*MOEOEA_H_*/

7
branches/paradiseo-moeo-1.0/src/moeoEvalFunc.h
View file

@ -18,8 +18,7 @@
/* /*
* Functor that evaluates one MOEO by setting all its objective values. * Functor that evaluates one MOEO by setting all its objective values.
*/ */
template < class MOEOT > class moeoEvalFunc:public eoEvalFunc < MOEOT > template < class MOEOT >
{ class moeoEvalFunc : public eoEvalFunc< MOEOT > {};
};
#endif /*MOEOEVALFUNC_H_ */ #endif /*MOEOEVALFUNC_H_*/

243
branches/paradiseo-moeo-1.0/src/moeoFastNonDominatedSortingFitnessAssignment.h
View file

@ -14,170 +14,159 @@
#define MOEOFASTNONDOMINATEDSORTINGFITNESSASSIGNMENT_H_ #define MOEOFASTNONDOMINATEDSORTINGFITNESSASSIGNMENT_H_
#include <eoPop.h> #include <eoPop.h>
#include <moeoFitnessAssignment.h>
#include <moeoComparator.h> #include <moeoComparator.h>
#include <moeoFitnessAssignment.h>
#include <moeoObjectiveVectorComparator.h> #include <moeoObjectiveVectorComparator.h>
/** /**
* Fitness assignment sheme based on Pareto-dominance count proposed in * Fitness assignment sheme based on Pareto-dominance count proposed in:
* N. Srinivas, K. Deb, "Multiobjective Optimization Using Nondominated Sorting in Genetic Algorithms", Evolutionary Computation vol. 2, no. 3, pp. 221-248 (1994) * N. Srinivas, K. Deb, "Multiobjective Optimization Using Nondominated Sorting in Genetic Algorithms", Evolutionary Computation vol. 2, no. 3, pp. 221-248 (1994)
* and in * and in:
* K. Deb, A. Pratap, S. Agarwal, T. Meyarivan, "A Fast and Elitist Multi-Objective Genetic Algorithm: NSGA-II", IEEE Transactions on Evolutionary Computation, vol. 6, no. 2 (2002). * K. Deb, A. Pratap, S. Agarwal, T. Meyarivan, "A Fast and Elitist Multi-Objective Genetic Algorithm: NSGA-II", IEEE Transactions on Evolutionary Computation, vol. 6, no. 2 (2002).
* This strategy is, for instance, used in NSGA and NSGA-II. * This strategy is, for instance, used in NSGA and NSGA-II.
*/ */
template < class MOEOT > class moeoFastNonDominatedSortingFitnessAssignment:public moeoParetoBasedFitnessAssignment < template < class MOEOT >
MOEOT class moeoFastNonDominatedSortingFitnessAssignment : public moeoParetoBasedFitnessAssignment < MOEOT >
>
{ {
public: public:
/** /**
* Ctor * Ctor
*/ */
moeoFastNonDominatedSortingFitnessAssignment () moeoFastNonDominatedSortingFitnessAssignment() {}
{
}
/** /**
* Computes fitness values for every solution contained in the population _pop * Computes fitness values for every solution contained in the population _pop
* @param _pop the population * @param _pop the population
*/ */
void operator () (eoPop < MOEOT > &_pop) void operator()(eoPop < MOEOT > & _pop)
{ {
// number of objectives for the problem under consideration // number of objectives for the problem under consideration
unsigned nObjectives = MOEOT::ObjectiveVector::nObjectives (); unsigned nObjectives = MOEOT::ObjectiveVector::nObjectives();
if (nObjectives == 1) if (nObjectives == 1)
{ {
// one objective // one objective
oneObjective (_pop); oneObjective(_pop);
} }
else if (nObjectives == 2) else if (nObjectives == 2)
{ {
// two objectives (the two objectives function is still to do) // two objectives (the two objectives function is still to implement)
mObjectives (_pop); mObjectives(_pop);
} }
else if (nObjectives > 2) else if (nObjectives > 2)
{ {
// more than two objectives // more than two objectives
mObjectives (_pop); mObjectives(_pop);
} }
else else
{ {
// problem with the number of objectives // problem with the number of objectives
throw std:: throw std::runtime_error("Problem with the number of objectives in moeoFastNonDominatedSortingFitnessAssignment");
runtime_error }
("Problem with the number of objectives in moeoFastNonDominatedSortingFitnessAssignment"); }
}
}
private: private:
/** the objective vector type of the solutions */ /** the objective vector type of the solutions */
typedef typename MOEOT::ObjectiveVector ObjectiveVector; typedef typename MOEOT::ObjectiveVector ObjectiveVector;
/** Functor to compare two objective vectors according to Pareto dominance relation */ /** Functor to compare two objective vectors according to Pareto dominance relation */
moeoParetoObjectiveVectorComparator < ObjectiveVector > comparator; moeoParetoObjectiveVectorComparator < ObjectiveVector > comparator;
/** Functor to compare two solutions on the first objective, then on the second, and so on */ /** Functor to compare two solutions on the first objective, then on the second, and so on */
moeoObjectiveComparator < MOEOT > objComparator; moeoObjectiveComparator < MOEOT > objComparator;
/** /**
* Sets the fitness values for mono-objective problems * Sets the fitness values for mono-objective problems
* @param _pop the population * @param _pop the population
*/ */
void oneObjective (eoPop < MOEOT > &_pop) void oneObjective (eoPop < MOEOT > & _pop)
{ {
std::sort (_pop.begin (), _pop.end (), objComparator); std::sort(_pop.begin(), _pop.end(), objComparator);
for (unsigned i = 0; i < _pop.size (); i++) for (unsigned i=0; i<_pop.size(); i++)
{ {
_pop[i].fitness (i + 1); _pop[i].fitness(i+1);
} }
} }
/** /**
* Sets the fitness values for bi-objective problems with a complexity of O(n log n), where n stands for the population size * Sets the fitness values for bi-objective problems with a complexity of O(n log n), where n stands for the population size
* @param _pop the population * @param _pop the population
*/ */
void twoObjectives (eoPop < MOEOT > &_pop) void twoObjectives (eoPop < MOEOT > & _pop)
{ {
//... TO DO ! //... TO DO !
} }
/** /**
* Sets the fitness values for problems with more than two objectives with a complexity of O(n² log n), where n stands for the population size * Sets the fitness values for problems with more than two objectives with a complexity of O(n² log n), where n stands for the population size
* @param _pop the population * @param _pop the population
*/ */
void mObjectives (eoPop < MOEOT > &_pop) void mObjectives (eoPop < MOEOT > & _pop)
{ {
// S[i] = indexes of the individuals dominated by _pop[i] // S[i] = indexes of the individuals dominated by _pop[i]
std::vector < std::vector < unsigned >>S (_pop.size ()); std::vector < std::vector<unsigned> > S(_pop.size());
// n[i] = number of individuals that dominate the individual _pop[i] // n[i] = number of individuals that dominate the individual _pop[i]
std::vector < unsigned >n (_pop.size (), 0); std::vector < unsigned > n(_pop.size(), 0);
// fronts: F[i] = indexes of the individuals contained in the ith front // fronts: F[i] = indexes of the individuals contained in the ith front
std::vector < std::vector < unsigned >>F (_pop.size () + 1); std::vector < std::vector<unsigned> > F(_pop.size()+1);
// used to store the number of the first front // used to store the number of the first front
F[1].reserve (_pop.size ()); F[1].reserve(_pop.size());
// flag to comparae solutions for (unsigned p=0; p<_pop.size(); p++)
int comparatorFlag; {
for (unsigned p = 0; p < _pop.size (); p++) for (unsigned q=0; q<_pop.size(); q++)
{ {
for (unsigned q = 0; q < _pop.size (); q++) // if p dominates q
{ if ( comparator(_pop[p].objectiveVector(), _pop[q].objectiveVector()) )
// comparison of the 2 solutions according to Pareto dominance {
comparatorFlag = // add q to the set of solutions dominated by p
comparator (_pop[p].objectiveVector (), S[p].push_back(q);
_pop[q].objectiveVector ()); }
// if p dominates q // if q dominates p
if (comparatorFlag == 1) else if ( comparator(_pop[q].objectiveVector(), _pop[p].objectiveVector()) )
{ {
// add q to the set of solutions dominated by p // increment the domination counter of p
S[p].push_back (q); n[p]++;
} }
// if q dominates p }
else if (comparatorFlag == -1) // if no individual dominates p
{ if (n[p] == 0)
// increment the domination counter of p {
n[p]++; // p belongs to the first front
} _pop[p].fitness(1);
} F[1].push_back(p);
// if no individual dominates p }
if (n[p] == 0) }
{ // front counter
// p belongs to the first front unsigned counter=1;
_pop[p].fitness (1); unsigned p,q;
F[1].push_back (p); while (! F[counter].empty())
} {
} // used to store the number of the next front
// front counter F[counter+1].reserve(_pop.size());
unsigned counter = 1; for (unsigned i=0; i<F[counter].size(); i++)
unsigned p, q; {
while (!F[counter].empty ()) p = F[counter][i];
{ for (unsigned j=0; j<S[p].size(); j++)
// used to store the number of the next front {
F[counter + 1].reserve (_pop.size ()); q = S[p][j];
for (unsigned i = 0; i < F[counter].size (); i++) n[q]--;
{ // if no individual dominates q anymore
p = F[counter][i]; if (n[q] == 0)
for (unsigned j = 0; j < S[p].size (); j++) {
{ // q belongs to the next front
q = S[p][j]; _pop[q].fitness(counter+1);
n[q]--; F[counter+1].push_back(q);
// if no individual dominates q anymore }
if (n[q] == 0) }
{ }
// q belongs to the next front counter++;
_pop[q].fitness (counter + 1); }
F[counter + 1].push_back (q); }
}
}
}
counter++;
}
}
}; };
#endif /*MOEOFASTNONDOMINATEDSORTINGFITNESSASSIGNMENT_H_ */ #endif /*MOEOFASTNONDOMINATEDSORTINGFITNESSASSIGNMENT_H_*/

45
branches/paradiseo-moeo-1.0/src/moeoFitnessAssignment.h
View file

@ -17,46 +17,35 @@
#include <eoPop.h> #include <eoPop.h>
/** /**
* Functor that sets the fitness values of a whole population * Functor that sets the fitness values of a whole population.
*/ */
template < class MOEOT > class moeoFitnessAssignment:public eoUF < eoPop < MOEOT > &, template < class MOEOT >
void > class moeoFitnessAssignment : public eoUF < eoPop < MOEOT > &, void >
{ {};
};
/** /**
* moeoScalarFitnessAssignment is a moeoFitnessAssignment for scalar strategies * moeoScalarFitnessAssignment is a moeoFitnessAssignment for scalar strategies.
*/ */
template < class MOEOT > class moeoScalarFitnessAssignment:public moeoFitnessAssignment < template < class MOEOT >
MOEOT > class moeoScalarFitnessAssignment : public moeoFitnessAssignment < MOEOT >
{ {};
};
/** /**
* moeoCriterionBasedFitnessAssignment is a moeoFitnessAssignment for criterion-based strategies * moeoCriterionBasedFitnessAssignment is a moeoFitnessAssignment for criterion-based strategies.
*/ */
template < class MOEOT > class moeoCriterionBasedFitnessAssignment:public moeoFitnessAssignment < template < class MOEOT >
MOEOT > class moeoCriterionBasedFitnessAssignment : public moeoFitnessAssignment < MOEOT >
{ {};
};
/** /**
* moeoParetoBasedFitnessAssignment is a moeoFitnessAssignment for Pareto-based strategies * moeoParetoBasedFitnessAssignment is a moeoFitnessAssignment for Pareto-based strategies.
*/ */
template < class MOEOT > class moeoParetoBasedFitnessAssignment:public moeoFitnessAssignment < template < class MOEOT >
MOEOT > class moeoParetoBasedFitnessAssignment : public moeoFitnessAssignment < MOEOT >
{ {};
void operator () (eoPop < MOEOT > &_pop)
{
// do nothing for the moment ...
}
};
#endif /*MOEOFITNESSASSIGNMENT_H_*/
#endif /*MOEOFITNESSASSIGNMENT_H_ */

11
branches/paradiseo-moeo-1.0/src/moeoGenerationalReplacement.h
View file

@ -17,12 +17,9 @@
#include <moeoGenerationalReplacement.h> #include <moeoGenerationalReplacement.h>
/** /**
* Generational replacement: only the new individuals are preserved * Generational replacement: only the new individuals are preserved.
*/ */
template < class MOEOT > class moeoGenerationalReplacement:public moeoReplacement < MOEOT >, template < class MOEOT >
public eoGenerationalReplacement < class moeoGenerationalReplacement : public moeoReplacement < MOEOT >, public eoGenerationalReplacement < MOEOT > {};
MOEOT >
{
};
#endif /*MOEOGENERATIONALREPLACEMENT_H_ */ #endif /*MOEOGENERATIONALREPLACEMENT_H_*/

50
branches/paradiseo-moeo-1.0/src/moeoHybridLS.h
View file

@ -24,7 +24,8 @@
* This class allows to apply a multi-objective local search to a number of selected individuals contained in the archive * This class allows to apply a multi-objective local search to a number of selected individuals contained in the archive
* at every generation until a stopping criteria is verified. * at every generation until a stopping criteria is verified.
*/ */
template < class MOEOT > class moeoHybridLS:public eoUpdater template < class MOEOT >
class moeoHybridLS : public eoUpdater
{ {
public: public:
@ -32,45 +33,42 @@ public:
* Ctor * Ctor
* @param _term stopping criteria * @param _term stopping criteria
* @param _select selector * @param _select selector
* @param _ls a multi-objective local search * @param _mols a multi-objective local search
* @param _arch the archive * @param _arch the archive
*/ */
eoHybridLS (eoContinue < MOEOT > &_term, eoSelect < MOEOT > &_select, moeoLS < MOEOT > &_ls, moeoArchive < MOEOT > &_arch):term (_term), select (_select), ls (_ls), eoHybridLS (eoContinue < MOEOT > & _term, eoSelect < MOEOT > & _select, moeoLS < MOEOT > & _mols, moeoArchive < MOEOT > & _arch) : term(_term), select(_select), mols(_mols), arch(_arch)
arch {}
(_arch)
{
}
/** /**
* Applies the multi-objective local search to selected individuals contained in the archive if the stopping criteria is not verified * Applies the multi-objective local search to selected individuals contained in the archive if the stopping criteria is not verified
*/ */
void operator () () void operator () ()
{ {
if (!cont (arch)) if (! cont (arch))
{ {
// selection of solutions // selection of solutions
eoPop < MOEOT > selectedSolutions; eoPop < MOEOT > selectedSolutions;
select (arch, selectedSolutions); select(arch, selectedSolutions);
// apply the local search to every selected solution // apply the local search to every selected solution
for (unsigned i = 0; i < selectedSolutions.size (); i++) for (unsigned i=0; i<selectedSolutions.size(); i++)
{ {
ls (selectedSolutions[i], arch); mols(selectedSolutions[i], arch);
} }
} }
} }
private: private:
/** stopping criteria*/ /** stopping criteria*/
eoContinue < MOEOT > &term; eoContinue < MOEOT > & term;
/** selector */ /** selector */
eoSelect < MOEOT > &select; eoSelect < MOEOT > & select;
/** multi-objective local search */ /** multi-objective local search */
moeoLS < MOEOT > &ls; moeoLS < MOEOT > & mols;
/** archive */ /** archive */
moeoArchive < MOEOT > &arch; moeoArchive < MOEOT > & arch;
}; };
#endif /*MOEOHYBRIDLS_H_ */ #endif /*MOEOHYBRIDLS_H_*/

9
branches/paradiseo-moeo-1.0/src/moeoLS.h
View file

@ -20,9 +20,8 @@
* Abstract class for local searches applied to multi-objective optimization. * Abstract class for local searches applied to multi-objective optimization.
* Starting from only one solution, it produces a set of new non-dominated solutions. * Starting from only one solution, it produces a set of new non-dominated solutions.
*/ */
template < class MOEOT > class moeoLS:public eoBF < const MOEOT &, moeoArchive < MOEOT > &, template < class MOEOT >
void > class moeoLS: public eoBF < const MOEOT &, moeoArchive < MOEOT > &, void >
{ {};
};
#endif /*MOEOLS_H_ */ #endif /*MOEOLS_H_*/

273
branches/paradiseo-moeo-1.0/src/moeoObjectiveVector.h
View file

@ -24,54 +24,52 @@
* but it can be replaced at will by any other class that implements the static functions defined therein. * but it can be replaced at will by any other class that implements the static functions defined therein.
* Some static funtions to access to the traits characteristics are re-defined in order not to write a lot of typedef's. * Some static funtions to access to the traits characteristics are re-defined in order not to write a lot of typedef's.
*/ */
template < class ObjectiveVectorTraits > class moeoObjectiveVector template < class ObjectiveVectorTraits >
class moeoObjectiveVector
{ {
public: public:
/** The traits of objective vectors */ /** The traits of objective vectors */
typedef ObjectiveVectorTraits Traits; typedef ObjectiveVectorTraits Traits;
/** /**
* Parameters setting (for the objective vector of any solution) * Parameters setting (for the objective vector of any solution)
* @param _nObjectives the number of objectives * @param _nObjectives the number of objectives
* @param _bObjectives the min/max vector (true = min / false = max) * @param _bObjectives the min/max vector (true = min / false = max)
*/ */
static void setup (unsigned _nObjectives, static void setup(unsigned _nObjectives, std::vector < bool > & _bObjectives)
std::vector < bool > &_bObjectives) {
{ ObjectiveVectorTraits::setup(_nObjectives, _bObjectives);
ObjectiveVectorTraits::setup (_nObjectives, _bObjectives); }
}
/** /**
* Returns the number of objectives * Returns the number of objectives
*/ */
static unsigned nObjectives () static unsigned nObjectives()
{ {
return ObjectiveVectorTraits::nObjectives (); return ObjectiveVectorTraits::nObjectives();
} }
/** /**
* Returns true if the _ith objective have to be minimized * Returns true if the _ith objective have to be minimized
* @param _i the index * @param _i the index
*/ */
static bool minimizing (unsigned _i) static bool minimizing(unsigned _i) {
{ return ObjectiveVectorTraits::minimizing(_i);
return ObjectiveVectorTraits::minimizing (_i); }
}
/** /**
* Returns true if the _ith objective have to be maximized * Returns true if the _ith objective have to be maximized
* @param _i the index * @param _i the index
*/ */
static bool maximizing (unsigned _i) static bool maximizing(unsigned _i) {
{ return ObjectiveVectorTraits::maximizing(_i);
return ObjectiveVectorTraits::maximizing (_i); }
}
}; };
@ -79,159 +77,122 @@ public:
* This class allows to represent a solution in the objective space (phenotypic representation) by a std::vector of doubles, * This class allows to represent a solution in the objective space (phenotypic representation) by a std::vector of doubles,
* i.e. that an objective value is represented using a double, and this for any objective. * i.e. that an objective value is represented using a double, and this for any objective.
*/ */
template < class ObjectiveVectorTraits > class moeoObjectiveVectorDouble:public moeoObjectiveVector < ObjectiveVectorTraits >, template < class ObjectiveVectorTraits >
public std::vector < class moeoObjectiveVectorDouble : public moeoObjectiveVector < ObjectiveVectorTraits >, public std::vector < double >
double >
{ {
public: public:
using using std::vector< double >::size;
std::vector < double >::size; using std::vector< double >::operator[];
using
std::vector < double >::operator[];
/** /**
* Ctor * Ctor
*/ */
moeoObjectiveVectorDouble (): moeoObjectiveVectorDouble() : std::vector < double > (ObjectiveVectorTraits::nObjectives(), 0.0) {}
std::vector < double >(ObjectiveVectorTraits::nObjectives (), 0.0)
{
}
/** /**
* Ctor from a vector of doubles * Ctor from a vector of doubles
* @param _v the std::vector < double > * @param _v the std::vector < double >
*/ */
moeoObjectiveVectorDouble (std::vector < double >&_v): moeoObjectiveVectorDouble(std::vector <double> & _v) : std::vector < double > (_v) {}
std::vector < double >(_v)
{
}
/** /**
* Returns true if the current objective vector dominates _other according to the Pareto dominance relation * Returns true if the current objective vector dominates _other according to the Pareto dominance relation
* (but it's better to use a moeoObjectiveVectorComparator object to compare solutions) * (but it's better to use a moeoObjectiveVectorComparator object to compare solutions)
* @param _other the other moeoObjectiveVectorDouble object to compare with * @param _other the other moeoObjectiveVectorDouble object to compare with
*/ */
bool bool dominates(const moeoObjectiveVectorDouble < ObjectiveVectorTraits > & _other) const
dominates (const moeoObjectiveVectorDouble < ObjectiveVectorTraits > {
&_other) const moeoParetoObjectiveVectorComparator < moeoObjectiveVectorDouble<ObjectiveVectorTraits> > comparator;
{ return comparator(*this, _other);
moeoParetoObjectiveVectorComparator < }
moeoObjectiveVectorDouble <
ObjectiveVectorTraits > >
comparator;
return
comparator (*this, _other) == 1;
}
/** /**
* Returns true if the current objective vector is equal to _other (according to a tolerance value) * Returns true if the current objective vector is equal to _other (according to a tolerance value)
* @param _other the other moeoObjectiveVectorDouble object to compare with * @param _other the other moeoObjectiveVectorDouble object to compare with
*/ */
bool bool operator==(const moeoObjectiveVectorDouble < ObjectiveVectorTraits > & _other) const
operator== (const moeoObjectiveVectorDouble < ObjectiveVectorTraits > {
&_other) const for (unsigned i=0; i < size(); i++)
{ {
for (unsigned i = 0; i < size (); i++) if ( fabs(operator[](i) - _other[i]) > ObjectiveVectorTraits::tolerance() )
{ {
if (fabs (operator[](i) - _other[i]) > return false;
ObjectiveVectorTraits::tolerance ()) }
{ }
return false; return true;
} }
}
return
true;
}
/** /**
* Returns true if the current objective vector is different than _other (according to a tolerance value) * Returns true if the current objective vector is different than _other (according to a tolerance value)
* @param _other the other moeoObjectiveVectorDouble object to compare with * @param _other the other moeoObjectiveVectorDouble object to compare with
*/ */
bool bool operator!=(const moeoObjectiveVectorDouble < ObjectiveVectorTraits > & _other) const
operator!= (const moeoObjectiveVectorDouble < ObjectiveVectorTraits > {
&_other) const return ! operator==(_other);
{ }
return !
operator== (_other);
}
/** /**
* Returns true if the current objective vector is smaller than _other on the first objective, then on the second, and so on * Returns true if the current objective vector is smaller than _other on the first objective, then on the second, and so on
* (can be usefull for sorting/printing) * (can be usefull for sorting/printing)
* @param _other the other moeoObjectiveVectorDouble object to compare with * @param _other the other moeoObjectiveVectorDouble object to compare with
*/ */
bool bool operator<(const moeoObjectiveVectorDouble < ObjectiveVectorTraits > & _other) const
operator< (const moeoObjectiveVectorDouble < ObjectiveVectorTraits > {
&_other) const for (unsigned i=0; i < size(); i++)
{ {
for (unsigned i = 0; i < size (); i++) if ( fabs(operator[](i) - _other[i]) > ObjectiveVectorTraits::tolerance() )
{ {
if (fabs (operator[](i) - _other[i]) > if (operator[](i) < _other[i])
ObjectiveVectorTraits::tolerance ()) {
{ return true;
if (operator[](i) < _other[i]) }
{ else
return true; {
} return false;
else }
{ }
}
return false; return false;
} }
}
}
return false;
}
/** /**
* Returns true if the current objective vector is greater than _other on the first objective, then on the second, and so on * Returns true if the current objective vector is greater than _other on the first objective, then on the second, and so on
* (can be usefull for sorting/printing) * (can be usefull for sorting/printing)
* @param _other the other moeoObjectiveVectorDouble object to compare with * @param _other the other moeoObjectiveVectorDouble object to compare with
*/ */
bool bool operator>(const moeoObjectiveVectorDouble < ObjectiveVectorTraits > & _other) const
operator> (const moeoObjectiveVectorDouble < ObjectiveVectorTraits > {
&_other) const return _other < *this;
{ }
return
_other < *
this;
}
/** /**
* Returns true if the current objective vector is smaller than or equal to _other on the first objective, then on the second, and so on * Returns true if the current objective vector is smaller than or equal to _other on the first objective, then on the second, and so on
* (can be usefull for sorting/printing) * (can be usefull for sorting/printing)
* @param _other the other moeoObjectiveVectorDouble object to compare with * @param _other the other moeoObjectiveVectorDouble object to compare with
*/ */
bool bool operator<=(const moeoObjectiveVectorDouble < ObjectiveVectorTraits > & _other) const
operator<= (const moeoObjectiveVectorDouble < ObjectiveVectorTraits > {
&_other) const return operator==(_other) || operator<(_other);
{ }
return
operator== (_other) ||
operator< (_other);
}
/** /**
* Returns true if the current objective vector is greater than or equal to _other on the first objective, then on the second, and so on * Returns true if the current objective vector is greater than or equal to _other on the first objective, then on the second, and so on
* (can be usefull for sorting/printing) * (can be usefull for sorting/printing)
* @param _other the other moeoObjectiveVectorDouble object to compare with * @param _other the other moeoObjectiveVectorDouble object to compare with
*/ */
bool bool operator>=(const moeoObjectiveVectorDouble < ObjectiveVectorTraits > & _other) const
operator>= (const moeoObjectiveVectorDouble < ObjectiveVectorTraits > {
&_other) const return operator==(_other) || operator>(_other);
{ }
return
operator== (_other) ||
operator> (_other);
}
}; };
@ -242,15 +203,13 @@ public:
* @param _objectiveVector the objective vector to write * @param _objectiveVector the objective vector to write
*/ */
template < class ObjectiveVectorTraits > template < class ObjectiveVectorTraits >
std::ostream & operator<< (std::ostream & _os, std::ostream & operator<<(std::ostream & _os, const moeoObjectiveVectorDouble < ObjectiveVectorTraits > & _objectiveVector)
const moeoObjectiveVectorDouble <
ObjectiveVectorTraits > &_objectiveVector)
{ {
for (unsigned i = 0; i < _objectiveVector.size (); i++) for (unsigned i=0; i<_objectiveVector.size(); i++)
{ {
_os << _objectiveVector[i] << ' '; _os << _objectiveVector[i] << ' ';
} }
return _os; return _os;
} }
/** /**
@ -259,16 +218,14 @@ template < class ObjectiveVectorTraits >
* @param _objectiveVector the objective vector to read * @param _objectiveVector the objective vector to read
*/ */
template < class ObjectiveVectorTraits > template < class ObjectiveVectorTraits >
std::istream & operator>> (std::istream & _is, std::istream & operator>>(std::istream & _is, moeoObjectiveVectorDouble < ObjectiveVectorTraits > & _objectiveVector)
moeoObjectiveVectorDouble <
ObjectiveVectorTraits > &_objectiveVector)
{ {
_objectiveVector = moeoObjectiveVectorDouble < ObjectiveVectorTraits > (); _objectiveVector = moeoObjectiveVectorDouble < ObjectiveVectorTraits > ();
for (unsigned i = 0; i < _objectiveVector.size (); i++) for (unsigned i=0; i<_objectiveVector.size(); i++)
{ {
_is >> _objectiveVector[i]; _is >> _objectiveVector[i];
} }
return _is; return _is;
} }
#endif /*MOEOOBJECTIVEVECTOR_H_ */ #endif /*MOEOOBJECTIVEVECTOR_H_*/

105
branches/paradiseo-moeo-1.0/src/moeoObjectiveVectorComparator.h
View file

@ -20,74 +20,61 @@
* Abstract class allowing to compare 2 objective vectors. * Abstract class allowing to compare 2 objective vectors.
* The template argument ObjectiveVector have to be a moeoObjectiveVector. * The template argument ObjectiveVector have to be a moeoObjectiveVector.
*/ */
template < class ObjectiveVector > class moeoObjectiveVectorComparator:public eoBF < const ObjectiveVector &, const ObjectiveVector &, template < class ObjectiveVector >
int > class moeoObjectiveVectorComparator : public eoBF < const ObjectiveVector &, const ObjectiveVector &, bool >
{ {};
};
/** /**
* This functor class allows to compare 2 objective vectors according to Pareto dominance * This functor class allows to compare 2 objective vectors according to Pareto dominance.
*/ */
template < class ObjectiveVector > class moeoParetoObjectiveVectorComparator:public moeoObjectiveVectorComparator < template < class ObjectiveVector >
ObjectiveVector class moeoParetoObjectiveVectorComparator : public moeoObjectiveVectorComparator < ObjectiveVector >
>
{ {
public: public:
/** /**
* Returns 1 if _objectiveVector1 dominates _objectiveVector2, -1 if _objectiveVector2 dominates _objectiveVector1 and 0 if no one dominates the other * Returns true if _objectiveVector1 dominates _objectiveVector2
* @param _objectiveVector1 the first objective vector * @param _objectiveVector1 the first objective vector
* @param _objectiveVector2 the second objective vector * @param _objectiveVector2 the second objective vector
*/ */
int operator () (const ObjectiveVector & _objectiveVector1, bool operator()(const ObjectiveVector & _objectiveVector1, const ObjectiveVector & _objectiveVector2)
const ObjectiveVector & _objectiveVector2) {
{ bool dom = false;
bool dom1 = false; for (unsigned i=0; i<ObjectiveVector::nObjectives(); i++)
bool dom2 = false; {
for (unsigned i = 0; i < ObjectiveVector::nObjectives (); i++) // first, we have to check if the 2 objective values are not equal for the ith objective
{ if ( fabs(_objectiveVector1[i] - _objectiveVector2[i]) > ObjectiveVector::Traits::tolerance() )
// first, we have to check if the 2 objective values are not equal for the ith objective {
if (fabs (_objectiveVector1[i] - _objectiveVector2[i]) > // if the ith objective have to be minimized...
ObjectiveVector::Traits::tolerance ()) if (ObjectiveVector::minimizing(i))
{ {
// if the ith objective have to be minimized... if (_objectiveVector1[i] < _objectiveVector2[i])
if (ObjectiveVector::minimizing (i)) {
{ dom = true; //_objectiveVector1[i] is better than _objectiveVector2[i]
if (_objectiveVector1[i] > _objectiveVector2[i]) }
{ else
dom2 = true; //_objectiveVector2[i] is better than _objectiveVector1[i] {
} return false; //_objectiveVector1 cannot dominate _objectiveVector2
else // _objectiveVector1[i] < _objectiveVector2[i] }
{ }
dom1 = true; //_objectiveVector1[i] is better than _objectiveVector2[i] // if the ith objective have to be maximized...
} else if (ObjectiveVector::maximizing(i))
} {
// if the ith objective have to be maximized... if (_objectiveVector1[i] > _objectiveVector2[i])
else if (ObjectiveVector::maximizing (i)) {
{ dom = true; //_objectiveVector1[i] is better than _objectiveVector2[i]
if (_objectiveVector1[i] > _objectiveVector2[i]) }
{ else
dom1 = true; //_objectiveVector1[i] is better than _objectiveVector2[i] {
} return false; //_objectiveVector1 cannot dominate _objectiveVector2
else // _objectiveVector1[i] < _objectiveVector2[i] }
{ }
dom2 = true; //_objectiveVector2[i] is better than _objectiveVector1[i] }
} }
} return dom;
} }
}
if (dom1 == dom2)
{
return 0; // no one dominates the other
}
if (dom1)
{
return 1; //_objectiveVector1 dominates _objectiveVector2
}
return -1; //_objectiveVector2 dominates _objectiveVector1
}
}; };
#endif /*MOEOOBJECTIVEVECTORCOMPARATOR_H_ */ #endif /*MOEOOBJECTIVEVECTORCOMPARATOR_H_*/

114
branches/paradiseo-moeo-1.0/src/moeoObjectiveVectorTraits.h
View file

@ -18,105 +18,91 @@
#include <stdexcept> #include <stdexcept>
/** /**
* A traits class for moeoObjectiveVector to specify the number of objectives and which ones have to be minimized or maximized * A traits class for moeoObjectiveVector to specify the number of objectives and which ones have to be minimized or maximized.
*/ */
class moeoObjectiveVectorTraits class moeoObjectiveVectorTraits
{ {
public: public:
/** The tolerance value (used to compare solutions) */ /** The tolerance value (used to compare solutions) */
const static double tol = 1e-6; const static double tol = 1e-6;
/** /**
* Parameters setting * Parameters setting
* @param _nObjectives the number of objectives * @param _nObjectives the number of objectives
* @param _bObjectives the min/max vector (true = min / false = max) * @param _bObjectives the min/max vector (true = min / false = max)
*/ */
static void setup (unsigned _nObjectives, static void setup(unsigned _nObjectives, std::vector < bool > & _bObjectives)
std::vector < bool > &_bObjectives) {
{ // in case the number of objectives was already set to a different value
// in case the number of objectives was already set to a different value if ( nObj && (nObj != _nObjectives) ) {
if (nObj && (nObj != _nObjectives)) std::cout << "WARNING\n";
{ std::cout << "WARNING : the number of objectives are changing\n";
std::cout << "WARNING\n"; std::cout << "WARNING : Make sure all existing objects are destroyed\n";
std::cout << "WARNING : the number of objectives are changing\n"; std::cout << "WARNING\n";
std:: }
cout << "WARNING : Make sure all existing objects are destroyed\n"; // number of objectives
std::cout << "WARNING\n"; nObj = _nObjectives;
} // min/max vector
// number of objectives bObj = _bObjectives;
nObj = _nObjectives; // in case the number of objectives and the min/max vector size don't match
// min/max vector if (nObj != bObj.size())
bObj = _bObjectives; throw std::runtime_error("Number of objectives and min/max size don't match in moeoObjectiveVectorTraits::setup");
// in case the number of objectives and the min/max vector size don't match }
if (nObj != bObj.size ())
throw std::
runtime_error
("Number of objectives and min/max size don't match in moeoObjectiveVectorTraits::setup");
}
/** /**
* Returns the number of objectives * Returns the number of objectives
*/ */
static unsigned nObjectives () static unsigned nObjectives()
{ {
// in case the number of objectives would not be assigned yet // in case the number of objectives would not be assigned yet
if (!nObj) if (! nObj)
throw std:: throw std::runtime_error("Number of objectives not assigned in moeoObjectiveVectorTraits");
runtime_error return nObj;
("Number of objectives not assigned in moeoObjectiveVectorTraits"); }
return nObj;
}
/** /**
* Returns true if the _ith objective have to be minimized * Returns true if the _ith objective have to be minimized
* @param _i the index * @param _i the index
*/ */
static bool minimizing (unsigned _i) static bool minimizing(unsigned _i)
{ {
// in case the min/max vector would not be assigned yet // in case there would be a wrong index
if (!bObj[_i]) if (_i >= bObj.size())
throw std:: throw std::runtime_error("Wrong index in moeoObjectiveVectorTraits");
runtime_error return bObj[_i];
("We don't know if the ith objective have to be minimized or maximized in moeoObjectiveVectorTraits"); }
// in case there would be a wrong index
if (_i >= bObj.size ())
throw std::runtime_error ("Wrong index in moeoObjectiveVectorTraits");
return bObj[_i];
}
/** /**
* Returns true if the _ith objective have to be maximized * Returns true if the _ith objective have to be maximized
* @param _i the index * @param _i the index
*/ */
static bool maximizing (unsigned _i) static bool maximizing(unsigned _i) {
{ return (! minimizing(_i));
return (!minimizing (_i)); }
}
/** /**
* Returns the tolerance value (to compare solutions) * Returns the tolerance value (to compare solutions)
*/ */
static double tolerance () static double tolerance()
{ {
return tol; return tol;
} }
private: private:
/** The number of objectives */ /** The number of objectives */
static unsigned nObj; static unsigned nObj;
/** The min/max vector */ /** The min/max vector */
static std::vector < bool > bObj; static std::vector < bool > bObj;
}; };
#endif /*MOEOOBJECTIVEVECTORTRAITS_H_ */ #endif /*MOEOOBJECTIVEVECTORTRAITS_H_*/
// The static variables of the moeoObjectiveVectorTraits class need to be allocated // The static variables of the moeoObjectiveVectorTraits class need to be allocated
// (maybe it would have been better to put this on a moeoObjectiveVectorTraits.cpp file) // (maybe it would have been better to put this on a moeoObjectiveVectorTraits.cpp file)
unsigned unsigned moeoObjectiveVectorTraits::nObj;
moeoObjectiveVectorTraits::nObj;
std::vector < bool > moeoObjectiveVectorTraits::bObj; std::vector < bool > moeoObjectiveVectorTraits::bObj;

9
branches/paradiseo-moeo-1.0/src/moeoReplacement.h
View file

@ -16,10 +16,9 @@
#include <eoReplacement.h> #include <eoReplacement.h>
/** /**
* Replacement strategy for multi-objective optimization * Replacement strategy for multi-objective optimization.
*/ */
template < class MOEOT > class moeoReplacement:public eoReplacement < MOEOT > template < class MOEOT >
{ class moeoReplacement : public eoReplacement < MOEOT > {};
};
#endif /*MOEOREPLACEMENT_H_ */ #endif /*MOEOREPLACEMENT_H_*/

7
branches/paradiseo-moeo-1.0/src/moeoSelectOne.h
View file

@ -16,8 +16,9 @@
#include <eoSelectOne.h> #include <eoSelectOne.h>
/** /**
* Selection strategy for multi-objective optimization that selects only one element from a whole population * Selection strategy for multi-objective optimization that selects only one element from a whole population.
*/ */
template < class MOEOT > class moeoSelectOne : public eoSelectOne < MOEOT > {}; template < class MOEOT >
class moeoSelectOne : public eoSelectOne < MOEOT > {};
#endif /*MOEOSELECTONE_H_ */ #endif /*MOEOSELECTONE_H_*/