diff --git a/branches/paradiseo-moeo-1.0/src/MOEO.h b/branches/paradiseo-moeo-1.0/src/MOEO.h deleted file mode 100644 index 78c4de739..000000000 --- a/branches/paradiseo-moeo-1.0/src/MOEO.h +++ /dev/null @@ -1,291 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// MOEO.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEO_H_ -#define MOEO_H_ - -#include -#include -#include -#include - -/** - * Base class allowing to represent a solution (an individual) for multi-objective optimization. - * The template argument MOEOObjectiveVector allows to represent the solution in the objective space (it can be a moeoObjectiveVector object). - * The template argument MOEOFitness is an object reflecting the quality of the solution in term of convergence (the fitness of a solution is always to be maximized). - * The template argument MOEODiversity is an object reflecting the quality of the solution in term of diversity (the diversity of a solution is always to be maximized). - * All template arguments must have a void and a copy constructor. - * Using some specific representations, you will have to define a copy constructor if the default one is not what you want. - * In the same cases, you will also have to define the affectation operator (operator=). - * Then, you will explicitly have to call the parent copy constructor and the parent affectation operator at the beginning of the corresponding implementation. - * Besides, note that, contrary to the mono-objective case (and to EO) where the fitness value of a solution is confused with its objective value, - * the fitness value differs of the objectives values in the multi-objective case. - */ -template < class MOEOObjectiveVector, class MOEOFitness, class MOEODiversity > -class MOEO : public EO < MOEOObjectiveVector > -{ -public: - - /** the objective vector type of a solution */ - typedef MOEOObjectiveVector ObjectiveVector; - - /** the fitness type of a solution */ - typedef MOEOFitness Fitness; - - /** the diversity type of a solution */ - typedef MOEODiversity Diversity; - - - /** - * Ctor - */ - MOEO() - { - // default values for every parameters - objectiveVectorValue = ObjectiveVector(); - fitnessValue = Fitness(); - diversityValue = Diversity(); - // invalidate all - invalidate(); - } - - - /** - * Virtual dtor - */ - virtual ~MOEO() {}; - - - /** - * Returns the objective vector of the current solution - */ - ObjectiveVector objectiveVector() const - { - if ( invalidObjectiveVector() ) - { - throw std::runtime_error("invalid objective vector"); - } - return objectiveVectorValue; - } - - - /** - * Sets the objective vector of the current solution - * @param _objectiveVectorValue the new objective vector - */ - void objectiveVector(const ObjectiveVector & _objectiveVectorValue) - { - objectiveVectorValue = _objectiveVectorValue; - invalidObjectiveVectorValue = false; - } - - - /** - * Sets the objective vector as invalid - */ - void invalidateObjectiveVector() - { - invalidObjectiveVectorValue = true; - } - - - /** - * Returns true if the objective vector is invalid, false otherwise - */ - bool invalidObjectiveVector() const - { - return invalidObjectiveVectorValue; - } - - - /** - * Returns the fitness value of the current solution - */ - Fitness fitness() const - { - if ( invalidFitness() ) - { - throw std::runtime_error("invalid fitness (MOEO)"); - } - return fitnessValue; - } - - - /** - * Sets the fitness value of the current solution - * @param _fitnessValue the new fitness value - */ - void fitness(const Fitness & _fitnessValue) - { - fitnessValue = _fitnessValue; - invalidFitnessValue = false; - } - - - /** - * Sets the fitness value as invalid - */ - void invalidateFitness() - { - invalidFitnessValue = true; - } - - - /** - * Returns true if the fitness value is invalid, false otherwise - */ - bool invalidFitness() const - { - return invalidFitnessValue; - } - - - /** - * Returns the diversity value of the current solution - */ - Diversity diversity() const - { - if ( invalidDiversity() ) - { - throw std::runtime_error("invalid diversity"); - } - return diversityValue; - } - - - /** - * Sets the diversity value of the current solution - * @param _diversityValue the new diversity value - */ - void diversity(const Diversity & _diversityValue) - { - diversityValue = _diversityValue; - invalidDiversityValue = false; - } - - - /** - * Sets the diversity value as invalid - */ - void invalidateDiversity() - { - invalidDiversityValue = true; - } - - - /** - * Returns true if the diversity value is invalid, false otherwise - */ - bool invalidDiversity() const - { - return invalidDiversityValue; - } - - - /** - * Sets the objective vector, the fitness value and the diversity value as invalid - */ - void invalidate() - { - invalidateObjectiveVector(); - invalidateFitness(); - invalidateDiversity(); - } - - - /** - * Returns true if the fitness value is invalid, false otherwise - */ - bool invalid() const - { - return invalidObjectiveVector(); - } - - - /** - * Returns true if the objective vector of the current solution is smaller than the objective vector of _other on the first objective, - * then on the second, and so on (can be usefull for sorting/printing). - * You should implement another function in the sub-class of MOEO to have another sorting mecanism. - * @param _other the other MOEO object to compare with - */ - bool operator<(const MOEO & _other) const - { - return objectiveVector() < _other.objectiveVector(); - } - - - /** - * Return the class id (the class name as a std::string) - */ - virtual std::string className() const - { - return "MOEO"; - } - - - /** - * Writing object - * @param _os output stream - */ - virtual void printOn(std::ostream & _os) const - { - if ( invalidObjectiveVector() ) - { - _os << "INVALID\t"; - } - else - { - _os << objectiveVectorValue << '\t'; - } - } - - - /** - * Reading object - * @param _is input stream - */ - virtual void readFrom(std::istream & _is) - { - std::string objectiveVector_str; - int pos = _is.tellg(); - _is >> objectiveVector_str; - if (objectiveVector_str == "INVALID") - { - invalidateObjectiveVector(); - } - else - { - invalidObjectiveVectorValue = false; - _is.seekg(pos); // rewind - _is >> objectiveVectorValue; - } - } - - -private: - - /** the objective vector of this solution */ - ObjectiveVector objectiveVectorValue; - /** true if the objective vector is invalid */ - bool invalidObjectiveVectorValue; - /** the fitness value of this solution */ - Fitness fitnessValue; - /** true if the fitness value is invalid */ - bool invalidFitnessValue; - /** the diversity value of this solution */ - Diversity diversityValue; - /** true if the diversity value is invalid */ - bool invalidDiversityValue; - -}; - -#endif /*MOEO_H_*/ diff --git a/branches/paradiseo-moeo-1.0/src/moeoAchievementFitnessAssignment.h b/branches/paradiseo-moeo-1.0/src/moeoAchievementFitnessAssignment.h deleted file mode 100644 index ae3a0567a..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoAchievementFitnessAssignment.h +++ /dev/null @@ -1,144 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoAchievementFitnessAssignment.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEOACHIEVEMENTFITNESSASSIGNMENT_H_ -#define MOEOACHIEVEMENTFITNESSASSIGNMENT_H_ - -#include -#include - -/** - * Fitness assignment sheme based on the achievement scalarizing function propozed by Wiersbicki (1980). - */ -template < class MOEOT > -class moeoAchievementFitnessAssignment : public moeoScalarFitnessAssignment < MOEOT > -{ -public: - - /** the objective vector type of the solutions */ - typedef typename MOEOT::ObjectiveVector ObjectiveVector; - - - /** - * Default ctor - * @param _reference reference point vector - * @param _lambdas weighted coefficients vector - * @param _spn arbitrary small positive number (0 < _spn << 1) - */ - moeoAchievementFitnessAssignment(ObjectiveVector & _reference, vector < double > & _lambdas, double _spn=0.0001) : reference(_reference), lambdas(_lambdas), spn(_spn) - { - // consistency check - if ((spn < 0.0) || (spn > 1.0)) - { - std::cout << "Warning, the arbitrary small positive number should be > 0 and <<1, adjusted to 0.0001\n"; - spn = 0.0001; - } - } - - - /** - * Ctor with default values for lambdas (1/nObjectives) - * @param _reference reference point vector - * @param _spn arbitrary small positive number (0 < _spn << 1) - */ - moeoAchievementFitnessAssignment(ObjectiveVector & _reference, double _spn=0.0001) : reference(_reference), spn(_spn) - { - // compute the default values for lambdas - lambdas = vector < double > (ObjectiveVector::nObjectives()); - for (unsigned i=0 ; i 1.0)) - { - std::cout << "Warning, the arbitrary small positive number should be > 0 and <<1, adjusted to 0.0001\n"; - spn = 0.0001; - } - } - - - /** - * Sets the fitness values for every solution contained in the population _pop - * @param _pop the population - */ - virtual void operator()(eoPop < MOEOT > & _pop) - { - for (unsigned i=0; i<_pop.size() ; i++) - { - compute(_pop[i]); - } - } - - - /** - * Updates the fitness values of the whole population _pop by taking the deletion of the objective vector _objVec into account (nothing to do). - * @param _pop the population - * @param _objVec the objective vector - */ - void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec) - { - // nothing to do ;-) - } - - - /** - * Sets the reference point - * @param _reference the new reference point - */ - void setReference(const ObjectiveVector & _reference) - { - reference = _reference; - } - - -private: - - /** the reference point */ - ObjectiveVector reference; - /** the weighted coefficients vector */ - vector < double > lambdas; - /** an arbitrary small positive number (0 < _spn << 1) */ - double spn; - - - /** - * Returns a big value (regarded as infinite) - */ - double inf() const - { - return std::numeric_limits::max(); - } - - - /** - * Computes the fitness value for a solution - * @param _moeo the solution - */ - void compute(MOEOT & _moeo) - { - unsigned nobj = MOEOT::ObjectiveVector::nObjectives(); - double temp; - double min = inf(); - double sum = 0; - for (unsigned obj=0; obj -#include - -/** - * An archive is a secondary population that stores non-dominated solutions. - */ -template < class MOEOT > -class moeoArchive : public eoPop < MOEOT > -{ -public: - - using std::vector < MOEOT > :: size; - using std::vector < MOEOT > :: operator[]; - using std::vector < MOEOT > :: back; - using std::vector < MOEOT > :: pop_back; - - - /** - * The type of an objective vector for a solution - */ - typedef typename MOEOT::ObjectiveVector ObjectiveVector; - - - /** - * Default ctor. - * The moeoObjectiveVectorComparator used to compare solutions is based on Pareto dominance - */ - moeoArchive() : eoPop < MOEOT >(), comparator(paretoComparator) - {} - - - /** - * Ctor - * @param _comparator the moeoObjectiveVectorComparator used to compare solutions - */ - moeoArchive(moeoObjectiveVectorComparator < ObjectiveVector > & _comparator) : eoPop < MOEOT >(), comparator(_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 - */ - bool dominates (const ObjectiveVector & _objectiveVector) const - { - for (unsigned i = 0; i & _pop) - { - for (unsigned i=0; i<_pop.size(); i++) - { - update(_pop[i]); - } - } - - - /** - * Returns true if the current archive contains the same objective vectors - * than the given archive _arch - * @param _arch the given archive - */ - bool equals (const moeoArchive < MOEOT > & _arch) - { - for (unsigned i=0; i & comparator; - /** A moeoObjectiveVectorComparator based on Pareto dominance (used as default) */ - moeoParetoObjectiveVectorComparator < ObjectiveVector > paretoComparator; - -}; - -#endif /*MOEOARCHIVE_H_ */ diff --git a/branches/paradiseo-moeo-1.0/src/moeoArchiveObjectiveVectorSavingUpdater.h b/branches/paradiseo-moeo-1.0/src/moeoArchiveObjectiveVectorSavingUpdater.h deleted file mode 100644 index ba2413bac..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoArchiveObjectiveVectorSavingUpdater.h +++ /dev/null @@ -1,93 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoArchiveObjectiveVectorSavingUpdater.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEOARCHIVEOBJECTIVEVECTORSAVINGUPDATER_H_ -#define MOEOARCHIVEOBJECTIVEVECTORSAVINGUPDATER_H_ - -#include -#include -#include -#include -#include - -#define MAX_BUFFER_SIZE 1000 - -/** - * This class allows to save the objective vectors of the solutions contained in an archive into a file at each generation. - */ -template < class MOEOT > -class moeoArchiveObjectiveVectorSavingUpdater : public eoUpdater -{ -public: - - /** - * Ctor - * @param _arch local archive - * @param _filename target filename - * @param _count put this variable to true if you want a new file to be created each time () is called and to false if you only want the file to be updated - * @param _id own ID - */ - moeoArchiveObjectiveVectorSavingUpdater (moeoArchive & _arch, const std::string & _filename, bool _count = false, int _id = -1) : - arch(_arch), filename(_filename), count(_count), counter(0), id(_id) - {} - - /** - * Saves the fitness of the archive's members into the file - */ - void operator()() { - char buff[MAX_BUFFER_SIZE]; - if (count) - { - if (id == -1) - { - sprintf (buff, "%s.%u", filename.c_str(), counter ++); - } - else - { - sprintf (buff, "%s.%u.%u", filename.c_str(), id, counter ++); - } - } - else - { - if (id == -1) - { - sprintf (buff, "%s", filename.c_str()); - } - else - { - sprintf (buff, "%s.%u", filename.c_str(), id); - } - counter ++; - } - std::ofstream f(buff); - for (unsigned i = 0; i < arch.size (); i++) - f << arch[i].objectiveVector() << std::endl; - f.close (); - } - - -private: - - /** local archive */ - moeoArchive & arch; - /** target filename */ - std::string filename; - /** this variable is set to true if a new file have to be created each time () is called and to false if the file only HAVE to be updated */ - bool count; - /** counter */ - unsigned counter; - /** own ID */ - int id; - -}; - -#endif /*MOEOARCHIVEOBJECTIVEVECTORSAVINGUPDATER_H_*/ diff --git a/branches/paradiseo-moeo-1.0/src/moeoArchiveUpdater.h b/branches/paradiseo-moeo-1.0/src/moeoArchiveUpdater.h deleted file mode 100644 index 73fbdc687..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoArchiveUpdater.h +++ /dev/null @@ -1,54 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoArchiveUpdater.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEOARCHIVEUPDATER_H_ -#define MOEOARCHIVEUPDATER_H_ - -#include -#include -#include - -/** - * This class allows to update the archive at each generation with newly found non-dominated solutions. - */ -template < class MOEOT > -class moeoArchiveUpdater : public eoUpdater -{ -public: - - /** - * Ctor - * @param _arch an archive of non-dominated solutions - * @param _pop the main population - */ - moeoArchiveUpdater(moeoArchive < MOEOT > & _arch, const eoPop < MOEOT > & _pop) : arch(_arch), pop(_pop) - {} - - - /** - * Updates the archive with newly found non-dominated solutions contained in the main population - */ - void operator()() { - arch.update(pop); - } - - -private: - - /** the archive of non-dominated solutions */ - moeoArchive < MOEOT > & arch; - /** the main population */ - const eoPop < MOEOT > & pop; - -}; - -#endif /*MOEOARCHIVEUPDATER_H_*/ diff --git a/branches/paradiseo-moeo-1.0/src/moeoCombinedLS.h b/branches/paradiseo-moeo-1.0/src/moeoCombinedLS.h deleted file mode 100644 index 98727f700..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoCombinedLS.h +++ /dev/null @@ -1,66 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoCombinedLS.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEOCOMBINEDLS_H_ -#define MOEOCOMBINEDLS_H_ - -#include -#include - -/** - * 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. - */ -template < class MOEOT, class Type > -class moeoCombinedLS : public moeoLS < MOEOT, Type > -{ -public: - - /** - * Ctor - * @param _first_mols the first multi-objective local search to add - */ - moeoCombinedLS(moeoLS < MOEOT, Type > & _first_mols) - { - combinedLS.push_back (& _first_mols); - } - - /** - * Adds a new local search to combine - * @param _mols the multi-objective local search to add - */ - void add(moeoLS < MOEOT, Type > & _mols) - { - combinedLS.push_back(& _mols); - } - - /** - * Gives a new solution in order to explore the neigborhood. - * The new non-dominated solutions are added to the archive - * @param _type the object to apply the local search to - * @param _arch the archive of non-dominated solutions - */ - void operator () (Type _type, moeoArchive < MOEOT > & _arch) - { - for (unsigned i=0; i operator()(_type, _arch); - } - - -private: - - /** the vector that contains the combined LS */ - std::vector< moeoLS < MOEOT, Type > * > combinedLS; - -}; - -#endif /*MOEOCOMBINEDLS_H_*/ diff --git a/branches/paradiseo-moeo-1.0/src/moeoComparator.h b/branches/paradiseo-moeo-1.0/src/moeoComparator.h deleted file mode 100644 index 75b777062..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoComparator.h +++ /dev/null @@ -1,182 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoComparator.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEOCOMPARATOR_H_ -#define MOEOCOMPARATOR_H_ - -#include - -/** - * Functor allowing to compare two solutions. - */ -template < class MOEOT > -class moeoComparator : public eoBF < const MOEOT &, const MOEOT &, const bool > - {}; - - -/** - * 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 < MOEOT > -{ -public: - - /** - * Returns true if _moeo1 < _moeo2 on the first objective, then on the second, and so on - * @param _moeo1 the first solution - * @param _moeo2 the second solution - */ - const bool operator()(const MOEOT & _moeo1, const MOEOT & _moeo2) - { - return cmp(_moeo1.objectiveVector(), _moeo2.objectiveVector()); - } - -private: - - /** the objective vector type of the solutions */ - typedef typename MOEOT::ObjectiveVector ObjectiveVector; - /** the corresponding comparator for objective vectors */ - moeoObjectiveObjectiveVectorComparator < ObjectiveVector > cmp; - -}; - - -/** - * Functor allowing to compare two solutions according to one objective. - */ -template < class MOEOT > -class moeoOneObjectiveComparator : public moeoComparator < MOEOT > -{ -public: - - /** - * Ctor. - * @param _obj the index of objective - */ - moeoOneObjectiveComparator(unsigned _obj) : obj(_obj) - { - if (obj > MOEOT::ObjectiveVector::nObjectives()) - { - throw std::runtime_error("Problem with the index of objective in moeoOneObjectiveComparator"); - } - } - - /** - * Returns true if _moeo1 < _moeo2 on the obj objective - * @param _moeo1 the first solution - * @param _moeo2 the second solution - */ - const bool operator()(const MOEOT & _moeo1, const MOEOT & _moeo2) - { - return _moeo1.objectiveVector()[obj] < _moeo2.objectiveVector()[obj]; - } - -private: - /** the index of objective */ - unsigned obj; - -}; - - -/** - * 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: - - /** - * Returns true if _moeo1 < _moeo2 according to their fitness values, then according to their diversity values - * @param _moeo1 the first solution - * @param _moeo2 the second solution - */ - const bool operator()(const MOEOT & _moeo1, const MOEOT & _moeo2) - { - if (_moeo1.fitness() == _moeo2.fitness()) - { - return _moeo1.diversity() < _moeo2.diversity(); - } - else - { - return _moeo1.fitness() < _moeo2.fitness(); - } - } - -}; - - -/** - * Functor allowing to compare two solutions according to their diversity values, then according to their fitness values. - */ -template < class MOEOT > -class moeoDiversityThenFitnessComparator : public moeoComparator < MOEOT > -{ -public: - - /** - * Returns true if _moeo1 < _moeo2 according to their diversity values, then according to their fitness values - * @param _moeo1 the first 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 their fitness and diversity values, each according to its aggregative value. - */ -template < class MOEOT > -class moeoAggregativeComparator : public moeoComparator < MOEOT > -{ -public: - - /** - * Ctor. - * @param _weightFitness the weight for fitness - * @param _weightDiversity the weight for diversity - */ - moeoAggregativeComparator(double _weightFitness = 1.0, double _weightDiversity = 1.0) : weightFitness(_weightFitness), weightDiversity(_weightDiversity) - {} - - /** - * Returns true if _moeo1 < _moeo2 according to the aggregation of their fitness and diversity values - * @param _moeo1 the first solution - * @param _moeo2 the second solution - */ - const bool operator()(const MOEOT & _moeo1, const MOEOT & _moeo2) - { - return ( weightFitness * _moeo1.fitness() + weightDiversity * _moeo1.diversity() ) < ( weightFitness * _moeo2.fitness() + weightDiversity * _moeo2.diversity() ); - } - -private: - /** the weight for fitness */ - double weightFitness; - /** the weight for diversity */ - double weightDiversity; - -}; - - -#endif /*MOEOCOMPARATOR_H_*/ diff --git a/branches/paradiseo-moeo-1.0/src/moeoConvertPopToObjectiveVectors.h b/branches/paradiseo-moeo-1.0/src/moeoConvertPopToObjectiveVectors.h deleted file mode 100644 index 8afca7a7b..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoConvertPopToObjectiveVectors.h +++ /dev/null @@ -1,42 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoConvertPopToObjectiveVectors.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEOPOPTOOBJECTIVEVECTORS_H_ -#define MOEOPOPTOOBJECTIVEVECTORS_H_ - -#include - -/** - * Functor allowing to get a vector of objective vectors from a population - */ -template < class MOEOT, class ObjectiveVector = typename MOEOT::ObjectiveVector > -class moeoConvertPopToObjectiveVectors : public eoUF < const eoPop < MOEOT >, const std::vector < ObjectiveVector > > -{ -public: - - /** - * Returns a vector of the objective vectors from the population _pop - * @param _pop the population - */ - const std::vector < ObjectiveVector > operator()(const eoPop < MOEOT > _pop) - { - std::vector < ObjectiveVector > result; - result.resize(_pop.size()); - for (unsigned i=0; i<_pop.size(); i++) - { - result.push_back(_pop[i].objectiveVector()); - } - return result; - } -}; - -#endif /*MOEOPOPTOOBJECTIVEVECTORS_H_*/ diff --git a/branches/paradiseo-moeo-1.0/src/moeoCrowdingDistanceDiversityAssignment.h b/branches/paradiseo-moeo-1.0/src/moeoCrowdingDistanceDiversityAssignment.h deleted file mode 100755 index 493c4fe6e..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoCrowdingDistanceDiversityAssignment.h +++ /dev/null @@ -1,238 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoCrowdingDistanceDiversityAssignment.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEOCROWDINGDISTANCEDIVERSITYASSIGNMENT_H_ -#define MOEOCROWDINGDISTANCEDIVERSITYASSIGNMENT_H_ - -#include -#include -#include - -/** - * Diversity assignment sheme based on crowding distance proposed 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). - */ -template < class MOEOT > -class moeoCrowdingDistanceDiversityAssignment : public moeoDiversityAssignment < MOEOT > -{ -public: - - /** the objective vector type of the solutions */ - typedef typename MOEOT::ObjectiveVector ObjectiveVector; - - - /** - * Returns a big value (regarded as infinite) - */ - double inf() const - { - return std::numeric_limits::max(); - } - - - /** - * Returns a very small value that can be used to avoid extreme cases (where the min bound == the max bound) - */ - double tiny() const - { - return 1e-6; - } - - - /** - * Computes diversity values for every solution contained in the population _pop - * @param _pop the population - */ - void operator()(eoPop < MOEOT > & _pop) - { - if (_pop.size() <= 2) - { - for (unsigned i=0; i<_pop.size(); i++) - { - _pop[i].diversity(inf()); - } - } - else - { - setDistances(_pop); - } - } - - - /** - * @warning NOT IMPLEMENTED, DO NOTHING ! - * Updates the diversity values of the whole population _pop by taking the deletion of the objective vector _objVec into account. - * @param _pop the population - * @param _objVec the objective vector - * @warning NOT IMPLEMENTED, DO NOTHING ! - */ - void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec) - { - cout << "WARNING : updateByDeleting not implemented in moeoCrowdingDiversityAssignment" << endl; - } - - -protected: - - /** - * Sets the distance values - * @param _pop the population - */ - virtual void setDistances (eoPop < MOEOT > & _pop) - { - double min, max, distance; - unsigned nObjectives = MOEOT::ObjectiveVector::nObjectives(); - // set diversity to 0 - for (unsigned i=0; i<_pop.size(); i++) - { - _pop[i].diversity(0); - } - // for each objective - for (unsigned obj=0; obj comp(obj); - // sort - std::sort(_pop.begin(), _pop.end(), comp); - // min & max - min = _pop[0].objectiveVector()[obj]; - max = _pop[_pop.size()-1].objectiveVector()[obj]; - // set the diversity value to infiny for min and max - _pop[0].diversity(inf()); - _pop[_pop.size()-1].diversity(inf()); - for (unsigned i=1; i<_pop.size()-1; i++) - { - distance = (_pop[i+1].objectiveVector()[obj] - _pop[i-1].objectiveVector()[obj]) / (max-min); - _pop[i].diversity(_pop[i].diversity() + distance); - } - } - } - -}; - - -/** - * Diversity assignment sheme based on crowding distance proposed 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). - * Tis strategy assigns diversity values FRONT BY FRONT. It is, for instance, used in NSGA-II. - */ -template < class MOEOT > -class moeoFrontByFrontCrowdingDistanceDiversityAssignment : public moeoCrowdingDistanceDiversityAssignment < MOEOT > -{ -public: - - /** the objective vector type of the solutions */ - typedef typename MOEOT::ObjectiveVector ObjectiveVector; - - - /** - * @warning NOT IMPLEMENTED, DO NOTHING ! - * Updates the diversity values of the whole population _pop by taking the deletion of the objective vector _objVec into account. - * @param _pop the population - * @param _objVec the objective vector - * @warning NOT IMPLEMENTED, DO NOTHING ! - */ - void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec) - { - cout << "WARNING : updateByDeleting not implemented in moeoFrontByFrontCrowdingDistanceDiversityAssignment" << endl; - } - - -private: - - using moeoCrowdingDistanceDiversityAssignment < MOEOT >::inf; - using moeoCrowdingDistanceDiversityAssignment < MOEOT >::tiny; - - - /** - * Sets the distance values - * @param _pop the population - */ - void setDistances (eoPop < MOEOT > & _pop) - { - unsigned a,b; - double min, max, distance; - unsigned nObjectives = MOEOT::ObjectiveVector::nObjectives(); - // set diversity to 0 for every individual - for (unsigned i=0; i<_pop.size(); i++) - { - _pop[i].diversity(0.0); - } - // sort the whole pop according to fitness values - moeoFitnessThenDiversityComparator < MOEOT > fitnessComparator; - std::sort(_pop.begin(), _pop.end(), fitnessComparator); - // compute the crowding distance values for every individual "front" by "front" (front : from a to b) - a = 0; // the front starts at a - while (a < _pop.size()) - { - b = lastIndex(_pop,a); // the front ends at b - // if there is less than 2 individuals in the front... - if ((b-a) < 2) - { - for (unsigned i=a; i<=b; i++) - { - _pop[i].diversity(inf()); - } - } - // else... - else - { - // for each objective - for (unsigned obj=0; obj objComp(obj); - std::sort(_pop.begin()+a, _pop.begin()+b+1, objComp); - // min & max - min = _pop[b].objectiveVector()[obj]; - max = _pop[a].objectiveVector()[obj]; - // avoid extreme case - if (min == max) - { - min -= tiny(); - max += tiny(); - } - // set the diversity value to infiny for min and max - _pop[a].diversity(inf()); - _pop[b].diversity(inf()); - // set the diversity values for the other individuals - for (unsigned i=a+1; i & _pop, unsigned _start) - { - unsigned i=_start; - while ( (i<_pop.size()-1) && (_pop[i].fitness()==_pop[i+1].fitness()) ) - { - i++; - } - return i; - } - -}; - -#endif /*MOEOCROWDINGDISTANCEDIVERSITYASSIGNMENT_H_*/ diff --git a/branches/paradiseo-moeo-1.0/src/moeoDetTournamentSelect.h b/branches/paradiseo-moeo-1.0/src/moeoDetTournamentSelect.h deleted file mode 100644 index 6c9266b6f..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoDetTournamentSelect.h +++ /dev/null @@ -1,82 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoDetTournamentSelect.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEODETTOURNAMENTSELECT_H_ -#define MOEODETTOURNAMENTSELECT_H_ - -#include -#include -#include - -/** - * Selection strategy that selects ONE individual by deterministic tournament. - */ -template < class MOEOT > class moeoDetTournamentSelect:public moeoSelectOne < MOEOT > -{ -public: - - /** - * Full Ctor. - * @param _comparator the comparator (used to compare 2 individuals) - * @param _tSize the number of individuals in the tournament (default: 2) - */ - moeoDetTournamentSelect (moeoComparator < MOEOT > & _comparator, unsigned _tSize = 2) : comparator (_comparator), tSize (_tSize) - { - // consistency check - if (tSize < 2) - { - std:: - cout << "Warning, Tournament size should be >= 2\nAdjusted to 2\n"; - tSize = 2; - } - } - - - /** - * Ctor without comparator. A moeoFitnessThenDiversityComparator is used as default. - * @param _tSize the number of individuals in the tournament (default: 2) - */ - moeoDetTournamentSelect (unsigned _tSize = 2) : comparator (defaultComparator), tSize (_tSize) - { - // consistency check - if (tSize < 2) - { - std:: - cout << "Warning, Tournament size should be >= 2\nAdjusted to 2\n"; - tSize = 2; - } - } - - - /** - * Apply the tournament to the given population - * @param _pop the population - */ - const MOEOT & operator() (const eoPop < MOEOT > &_pop) - { - // use the selector - return mo_deterministic_tournament (_pop, tSize, comparator); - } - - -protected: - - /** the comparator (used to compare 2 individuals) */ - moeoComparator < MOEOT > & comparator; - /** a fitness then diversity comparator can be used as default */ - moeoFitnessThenDiversityComparator < MOEOT > defaultComparator; - /** the number of individuals in the tournament */ - unsigned tSize; - -}; - -#endif /*MOEODETTOURNAMENTSELECT_H_ */ diff --git a/branches/paradiseo-moeo-1.0/src/moeoDiversityAssignment.h b/branches/paradiseo-moeo-1.0/src/moeoDiversityAssignment.h deleted file mode 100644 index 66e50dd38..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoDiversityAssignment.h +++ /dev/null @@ -1,93 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoDiversityAssignment.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEODIVERSITYASSIGNMENT_H_ -#define MOEODIVERSITYASSIGNMENT_H_ - -#include -#include - -/** - * Functor that sets the diversity values of a whole population. - */ -template < class MOEOT > -class moeoDiversityAssignment : public eoUF < eoPop < MOEOT > &, void > -{ -public: - - /** The type for objective vector */ - typedef typename MOEOT::ObjectiveVector ObjectiveVector; - - - /** - * Updates the diversity values of the whole population _pop by taking the deletion of the objective vector _objVec into account. - * @param _pop the population - * @param _objVec the objective vector - */ - virtual void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec) = 0; - - - /** - * Updates the diversity values of the whole population _pop by taking the deletion of the individual _moeo into account. - * @param _pop the population - * @param _moeo the individual - */ - void updateByDeleting(eoPop < MOEOT > & _pop, MOEOT & _moeo) - { - updateByDeleting(_pop, _moeo.objectiveVector()); - } - -}; - - -/** - * moeoDummyDiversityAssignment is a moeoDiversityAssignment that gives the value '0' as the individual's diversity for a whole population if it is invalid. - */ -template < class MOEOT > -class moeoDummyDiversityAssignment : public moeoDiversityAssignment < MOEOT > -{ -public: - - /** The type for objective vector */ - typedef typename MOEOT::ObjectiveVector ObjectiveVector; - - - /** - * Sets the diversity to '0' for every individuals of the population _pop if it is invalid - * @param _pop the population - */ - void operator () (eoPop < MOEOT > & _pop) - { - for (unsigned idx = 0; idx<_pop.size (); idx++) - { - if (_pop[idx].invalidDiversity()) - { - // set the diversity to 0 - _pop[idx].diversity(0.0); - } - } - } - - - /** - * Updates the diversity values of the whole population _pop by taking the deletion of the objective vector _objVec into account. - * @param _pop the population - * @param _objVec the objective vector - */ - void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec) - { - // nothing to do... ;-) - } - -}; - -#endif /*MOEODIVERSITYASSIGNMENT_H_*/ diff --git a/branches/paradiseo-moeo-1.0/src/moeoEA.h b/branches/paradiseo-moeo-1.0/src/moeoEA.h deleted file mode 100644 index 36d115ead..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoEA.h +++ /dev/null @@ -1,26 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoEA.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEOEA_H_ -#define MOEOEA_H_ - -#include -#include - -/** - * Abstract class for multi-objective evolutionary algorithms. - */ -template < class MOEOT > -class moeoEA : public moeoAlgo, public eoAlgo < MOEOT > {}; - - -#endif /*MOEOEA_H_*/ diff --git a/branches/paradiseo-moeo-1.0/src/moeoEasyEA.h b/branches/paradiseo-moeo-1.0/src/moeoEasyEA.h deleted file mode 100755 index 35fea9598..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoEasyEA.h +++ /dev/null @@ -1,218 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoEasyEA.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef _MOEOEASYEA_H -#define _MOEOEASYEA_H - -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include - -/** - * An easy class to design multi-objective evolutionary algorithms. - */ -template < class MOEOT > -class moeoEasyEA: public moeoEA < MOEOT > -{ -public: - - /** - * Ctor taking a breed and merge. - * @param _continuator the stopping criteria - * @param _eval the evaluation functions - * @param _breed the breeder - * @param _replace the replacement strategy - * @param _fitnessEval the fitness evaluation scheme - * @param _diversityEval the diversity evaluation scheme - * @param _evalFitAndDivBeforeSelection put this parameter to 'true' if you want to re-evalue the fitness and the diversity of the population before the selection process - */ - moeoEasyEA(eoContinue < MOEOT > & _continuator, eoEvalFunc < MOEOT > & _eval, eoBreed < MOEOT > & _breed, moeoReplacement < MOEOT > & _replace, - moeoFitnessAssignment < MOEOT > & _fitnessEval, moeoDiversityAssignment < MOEOT > & _diversityEval, bool _evalFitAndDivBeforeSelection = false) - : - continuator(_continuator), eval (_eval), loopEval(_eval), popEval(loopEval), selectTransform(dummySelect, dummyTransform), breed(_breed), mergeReduce(dummyMerge, dummyReduce), replace(_replace), - fitnessEval(_fitnessEval), diversityEval(_diversityEval), evalFitAndDivBeforeSelection(_evalFitAndDivBeforeSelection) - {} - - - /** - * Ctor taking a breed, a merge and a eoPopEval. - * @param _continuator the stopping criteria - * @param _popEval the evaluation functions for the whole population - * @param _breed the breeder - * @param _replace the replacement strategy - * @param _fitnessEval the fitness evaluation scheme - * @param _diversityEval the diversity evaluation scheme - * @param _evalFitAndDivBeforeSelection put this parameter to 'true' if you want to re-evalue the fitness and the diversity of the population before the selection process - */ - moeoEasyEA(eoContinue < MOEOT > & _continuator, eoPopEvalFunc < MOEOT > & _popEval, eoBreed < MOEOT > & _breed, moeoReplacement < MOEOT > & _replace, - moeoFitnessAssignment < MOEOT > & _fitnessEval, moeoDiversityAssignment < MOEOT > & _diversityEval, bool _evalFitAndDivBeforeSelection = false) - : - continuator(_continuator), eval (dummyEval), loopEval(dummyEval), popEval(_popEval), selectTransform(dummySelect, dummyTransform), breed(_breed), mergeReduce(dummyMerge, dummyReduce), replace(_replace), - fitnessEval(_fitnessEval), diversityEval(_diversityEval), evalFitAndDivBeforeSelection(_evalFitAndDivBeforeSelection) - {} - - - /** - * Ctor taking a breed, a merge and a reduce. - * @param _continuator the stopping criteria - * @param _eval the evaluation functions - * @param _breed the breeder - * @param _merge the merge scheme - * @param _reduce the reduce scheme - * @param _fitnessEval the fitness evaluation scheme - * @param _diversityEval the diversity evaluation scheme - * @param _evalFitAndDivBeforeSelection put this parameter to 'true' if you want to re-evalue the fitness and the diversity of the population before the selection process - */ - moeoEasyEA(eoContinue < MOEOT > & _continuator, eoEvalFunc < MOEOT > & _eval, eoBreed < MOEOT > & _breed, eoMerge < MOEOT > & _merge, eoReduce< MOEOT > & _reduce, - moeoFitnessAssignment < MOEOT > & _fitnessEval, moeoDiversityAssignment < MOEOT > & _diversityEval, bool _evalFitAndDivBeforeSelection = false) - : - continuator(_continuator), eval(_eval), loopEval(_eval), popEval(loopEval), selectTransform(dummySelect, dummyTransform), breed(_breed), mergeReduce(_merge,_reduce), replace(mergeReduce), - fitnessEval(_fitnessEval), diversityEval(_diversityEval), evalFitAndDivBeforeSelection(_evalFitAndDivBeforeSelection) - {} - - - /** - * Ctor taking a select, a transform and a replacement. - * @param _continuator the stopping criteria - * @param _eval the evaluation functions - * @param _select the selection scheme - * @param _transform the tranformation scheme - * @param _replace the replacement strategy - * @param _fitnessEval the fitness evaluation scheme - * @param _diversityEval the diversity evaluation scheme - * @param _evalFitAndDivBeforeSelection put this parameter to 'true' if you want to re-evalue the fitness and the diversity of the population before the selection process - */ - moeoEasyEA(eoContinue < MOEOT > & _continuator, eoEvalFunc < MOEOT > & _eval, eoSelect < MOEOT > & _select, eoTransform < MOEOT > & _transform, moeoReplacement < MOEOT > & _replace, - moeoFitnessAssignment < MOEOT > & _fitnessEval, moeoDiversityAssignment < MOEOT > & _diversityEval, bool _evalFitAndDivBeforeSelection = false) - : - continuator(_continuator), eval(_eval), loopEval(_eval), popEval(loopEval), selectTransform(_select, _transform), breed(selectTransform), mergeReduce(dummyMerge, dummyReduce), replace(_replace), - fitnessEval(_fitnessEval), diversityEval(_diversityEval), evalFitAndDivBeforeSelection(_evalFitAndDivBeforeSelection) - {} - - - /** - * Ctor taking a select, a transform, a merge and a reduce. - * @param _continuator the stopping criteria - * @param _eval the evaluation functions - * @param _select the selection scheme - * @param _transform the tranformation scheme - * @param _merge the merge scheme - * @param _reduce the reduce scheme - * @param _fitnessEval the fitness evaluation scheme - * @param _diversityEval the diversity evaluation scheme - * @param _evalFitAndDivBeforeSelection put this parameter to 'true' if you want to re-evalue the fitness and the diversity of the population before the selection process - */ - moeoEasyEA(eoContinue < MOEOT > & _continuator, eoEvalFunc < MOEOT > & _eval, eoSelect < MOEOT > & _select, eoTransform < MOEOT > & _transform, eoMerge < MOEOT > & _merge, eoReduce< MOEOT > & _reduce, - moeoFitnessAssignment < MOEOT > & _fitnessEval, moeoDiversityAssignment < MOEOT > & _diversityEval, bool _evalFitAndDivBeforeSelection = false) - : - continuator(_continuator), eval(_eval), loopEval(_eval), popEval(loopEval), selectTransform(_select, _transform), breed(selectTransform), mergeReduce(_merge,_reduce), replace(mergeReduce), - fitnessEval(_fitnessEval), diversityEval(_diversityEval), evalFitAndDivBeforeSelection(_evalFitAndDivBeforeSelection) - {} - - - /** - * Applies a few generation of evolution to the population _pop. - * @param _pop the population - */ - virtual void operator()(eoPop < MOEOT > & _pop) - { - eoPop < MOEOT > offspring, empty_pop; - popEval(empty_pop, _pop); // A first eval of pop. - bool firstTime = true; - do - { - try - { - unsigned pSize = _pop.size(); - offspring.clear(); // new offspring - // fitness and diversity assignment (if you want to or if it is the first generation) - if (evalFitAndDivBeforeSelection || firstTime) - { - firstTime = false; - fitnessEval(_pop); - diversityEval(_pop); - } - breed(_pop, offspring); - popEval(_pop, offspring); // eval of parents + offspring if necessary - replace(_pop, offspring); // after replace, the new pop. is in _pop - if (pSize > _pop.size()) - { - throw std::runtime_error("Population shrinking!"); - } - else if (pSize < _pop.size()) - { - throw std::runtime_error("Population growing!"); - } - } - catch (std::exception& e) - { - std::string s = e.what(); - s.append( " in moeoEasyEA"); - throw std::runtime_error( s ); - } - } while (continuator(_pop)); - } - - -protected: - - /** the stopping criteria */ - eoContinue < MOEOT > & continuator; - /** the evaluation functions */ - eoEvalFunc < MOEOT > & eval; - /** to evaluate the whole population */ - eoPopLoopEval < MOEOT > loopEval; - /** to evaluate the whole population */ - eoPopEvalFunc < MOEOT > & popEval; - /** breed: a select followed by a transform */ - eoSelectTransform < MOEOT > selectTransform; - /** the breeder */ - eoBreed < MOEOT > & breed; - /** replacement: a merge followed by a reduce */ - eoMergeReduce < MOEOT > mergeReduce; - /** the replacment strategy */ - moeoReplacement < MOEOT > & replace; - /** the fitness assignment strategy */ - moeoFitnessAssignment < MOEOT > & fitnessEval; - /** the diversity assignment strategy */ - moeoDiversityAssignment < MOEOT > & diversityEval; - /** if this parameter is set to 'true', the fitness and the diversity of the whole population will be re-evaluated before the selection process */ - bool evalFitAndDivBeforeSelection; - /** a dummy eval */ -class eoDummyEval : public eoEvalFunc < MOEOT > -{ public: /** the dummy functor */ - void operator()(MOEOT &) {}} dummyEval; - /** a dummy select */ -class eoDummySelect : public eoSelect < MOEOT > -{ public: /** the dummy functor */ - void operator()(const eoPop < MOEOT > &, eoPop < MOEOT > &) {} } dummySelect; - /** a dummy transform */ -class eoDummyTransform : public eoTransform < MOEOT > -{ public: /** the dummy functor */ - void operator()(eoPop < MOEOT > &) {} } dummyTransform; - /** a dummy merge */ - eoNoElitism < MOEOT > dummyMerge; - /** a dummy reduce */ - eoTruncate < MOEOT > dummyReduce; - -}; - -#endif /*MOEOEASYEA_H_*/ diff --git a/branches/paradiseo-moeo-1.0/src/moeoElitistReplacement.h b/branches/paradiseo-moeo-1.0/src/moeoElitistReplacement.h deleted file mode 100644 index cf6e406c7..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoElitistReplacement.h +++ /dev/null @@ -1,128 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoElitistReplacement.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEOELITISTREPLACEMENT_H_ -#define MOEOELITISTREPLACEMENT_H_ - -#include -#include -#include -#include - -/** - * Elitist replacement strategy that consists in keeping the N best individuals. - */ -template < class MOEOT > class moeoElitistReplacement:public moeoReplacement < MOEOT > -{ -public: - - /** - * Full constructor. - * @param _fitnessAssignment the fitness assignment strategy - * @param _diversityAssignment the diversity assignment strategy - * @param _comparator the comparator (used to compare 2 individuals) - */ - moeoElitistReplacement (moeoFitnessAssignment < MOEOT > & _fitnessAssignment, moeoDiversityAssignment < MOEOT > & _diversityAssignment, moeoComparator < MOEOT > & _comparator) : - fitnessAssignment (_fitnessAssignment), diversityAssignment (_diversityAssignment), comparator (_comparator) - {} - - - /** - * Constructor without comparator. A moeoFitThenDivComparator is used as default. - * @param _fitnessAssignment the fitness assignment strategy - * @param _diversityAssignment the diversity assignment strategy - */ - moeoElitistReplacement (moeoFitnessAssignment < MOEOT > & _fitnessAssignment, moeoDiversityAssignment < MOEOT > & _diversityAssignment) : - fitnessAssignment (_fitnessAssignment), diversityAssignment (_diversityAssignment), comparator (defaultComparator) - {} - - - /** - * Constructor without moeoDiversityAssignement. A dummy diversity is used as default. - * @param _fitnessAssignment the fitness assignment strategy - * @param _comparator the comparator (used to compare 2 individuals) - */ - moeoElitistReplacement (moeoFitnessAssignment < MOEOT > & _fitnessAssignment, moeoComparator < MOEOT > & _comparator) : - fitnessAssignment (_fitnessAssignment), diversityAssignment (defaultDiversity), comparator (_comparator) - {} - - - /** - * Constructor without moeoDiversityAssignement nor moeoComparator. - * A moeoFitThenDivComparator and a dummy diversity are used as default. - * @param _fitnessAssignment the fitness assignment strategy - */ - moeoElitistReplacement (moeoFitnessAssignment < MOEOT > & _fitnessAssignment) : - fitnessAssignment (_fitnessAssignment), diversityAssignment (defaultDiversity), comparator (defaultComparator) - {} - - - /** - * Replaces the first population by adding the individuals of the second one, sorting with a moeoComparator and resizing the whole population obtained. - * @param _parents the population composed of the parents (the population you want to replace) - * @param _offspring the offspring population - */ - void operator () (eoPop < MOEOT > &_parents, eoPop < MOEOT > &_offspring) - { - unsigned sz = _parents.size (); - // merges offspring and parents into a global population - _parents.reserve (_parents.size () + _offspring.size ()); - copy (_offspring.begin (), _offspring.end (), back_inserter (_parents)); - // evaluates the fitness and the diversity of this global population - fitnessAssignment (_parents); - diversityAssignment (_parents); - // sorts the whole population according to the comparator - std::sort(_parents.begin(), _parents.end(), comparator); - // finally, resize this global population - _parents.resize (sz); - // and clear the offspring population - _offspring.clear (); - } - - -protected: - - /** the fitness assignment strategy */ - moeoFitnessAssignment < MOEOT > & fitnessAssignment; - /** the diversity assignment strategy */ - moeoDiversityAssignment < MOEOT > & diversityAssignment; - /** a dummy diversity assignment can be used as default */ - moeoDummyDiversityAssignment < MOEOT > defaultDiversity; - /** a fitness then diversity comparator can be used as default */ - moeoFitnessThenDiversityComparator < MOEOT > defaultComparator; - /** this object is used to compare solutions in order to sort the population */ - class Cmp - { - public: - /** - * Ctor. - * @param _comparator the comparator - */ - Cmp(moeoComparator < MOEOT > & _comp) : comp(_comp) - {} - /** - * Returns true if _moeo1 is greater than _moeo2 according to the comparator - * _moeo1 the first individual - * _moeo2 the first individual - */ - bool operator()(const MOEOT & _moeo1, const MOEOT & _moeo2) - { - return comp(_moeo2,_moeo1); - } - private: - /** the comparator */ - moeoComparator < MOEOT > & comp; - } comparator; - -}; - -#endif /*MOEOELITISTREPLACEMENT_H_ */ diff --git a/branches/paradiseo-moeo-1.0/src/moeoEnvironmentalReplacement.h b/branches/paradiseo-moeo-1.0/src/moeoEnvironmentalReplacement.h deleted file mode 100755 index 78ee0b1fc..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoEnvironmentalReplacement.h +++ /dev/null @@ -1,145 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoEnvironmentalReplacement.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEOENVIRONMENTALREPLACEMENT_H_ -#define MOEOENVIRONMENTALREPLACEMENT_H_ - -#include -#include -#include -#include - -/** - * Environmental replacement strategy that consists in keeping the N best individuals by deleting individuals 1 by 1 - * and by updating the fitness and diversity values after each deletion. - */ -template < class MOEOT > class moeoEnvironmentalReplacement:public moeoReplacement < MOEOT > -{ -public: - - /** The type for objective vector */ - typedef typename MOEOT::ObjectiveVector ObjectiveVector; - - - /** - * Full constructor. - * @param _fitnessAssignment the fitness assignment strategy - * @param _diversityAssignment the diversity assignment strategy - * @param _comparator the comparator (used to compare 2 individuals) - */ - moeoEnvironmentalReplacement (moeoFitnessAssignment < MOEOT > & _fitnessAssignment, moeoDiversityAssignment < MOEOT > & _diversityAssignment, moeoComparator < MOEOT > & _comparator) : - fitnessAssignment (_fitnessAssignment), diversityAssignment (_diversityAssignment), comparator (_comparator) - {} - - - /** - * Constructor without comparator. A moeoFitThenDivComparator is used as default. - * @param _fitnessAssignment the fitness assignment strategy - * @param _diversityAssignment the diversity assignment strategy - */ - moeoEnvironmentalReplacement (moeoFitnessAssignment < MOEOT > & _fitnessAssignment, moeoDiversityAssignment < MOEOT > & _diversityAssignment) : - fitnessAssignment (_fitnessAssignment), diversityAssignment (_diversityAssignment), comparator (defaultComparator) - {} - - - /** - * Constructor without moeoDiversityAssignement. A dummy diversity is used as default. - * @param _fitnessAssignment the fitness assignment strategy - * @param _comparator the comparator (used to compare 2 individuals) - */ - moeoEnvironmentalReplacement (moeoFitnessAssignment < MOEOT > & _fitnessAssignment, moeoComparator < MOEOT > & _comparator) : - fitnessAssignment (_fitnessAssignment), diversityAssignment (defaultDiversity), comparator (_comparator) - {} - - - /** - * Constructor without moeoDiversityAssignement nor moeoComparator. - * A moeoFitThenDivComparator and a dummy diversity are used as default. - * @param _fitnessAssignment the fitness assignment strategy - */ - moeoEnvironmentalReplacement (moeoFitnessAssignment < MOEOT > & _fitnessAssignment) : - fitnessAssignment (_fitnessAssignment), diversityAssignment (defaultDiversity), comparator (defaultComparator) - {} - - - /** - * Replaces the first population by adding the individuals of the second one, sorting with a moeoComparator and resizing the whole population obtained. - * @param _parents the population composed of the parents (the population you want to replace) - * @param _offspring the offspring population - */ - void operator () (eoPop < MOEOT > &_parents, eoPop < MOEOT > &_offspring) - { - unsigned sz = _parents.size(); - // merges offspring and parents into a global population - _parents.reserve (_parents.size() + _offspring.size()); - copy (_offspring.begin(), _offspring.end(), back_inserter(_parents)); - // evaluates the fitness and the diversity of this global population - fitnessAssignment (_parents); - diversityAssignment (_parents); - // remove individuals 1 by 1 and update the fitness values - unsigned worstIdx; - ObjectiveVector worstObjVec; - while (_parents.size() > sz) - { - // the individual to delete - worstIdx = std::min_element(_parents.begin(), _parents.end(), comparator) - _parents.begin(); - worstObjVec = _parents[worstIdx].objectiveVector(); - // remove the woorst individual - _parents[worstIdx] = _parents.back(); - _parents.pop_back(); - // update of the fitness and diversity values - fitnessAssignment.updateByDeleting(_parents, worstObjVec); - diversityAssignment.updateByDeleting(_parents, worstObjVec); - - } - // clear the offspring population - _offspring.clear (); - } - - -protected: - - /** the fitness assignment strategy */ - moeoFitnessAssignment < MOEOT > & fitnessAssignment; - /** the diversity assignment strategy */ - moeoDiversityAssignment < MOEOT > & diversityAssignment; - /** a dummy diversity assignment can be used as default */ - moeoDummyDiversityAssignment < MOEOT > defaultDiversity; - /** a fitness then diversity comparator can be used as default */ - moeoFitnessThenDiversityComparator < MOEOT > defaultComparator; - /** this object is used to compare solutions in order to sort the population */ - class Cmp - { - public: - /** - * Ctor. - * @param _comparator the comparator - */ - Cmp(moeoComparator < MOEOT > & _comp) : comp(_comp) - {} - /** - * Returns true if _moeo1 is greater than _moeo2 according to the comparator - * _moeo1 the first individual - * _moeo2 the first individual - */ - bool operator()(const MOEOT & _moeo1, const MOEOT & _moeo2) - { - return comp(_moeo1,_moeo2); - } - private: - /** the comparator */ - moeoComparator < MOEOT > & comp; - } comparator; - -}; - -#endif /*MOEOENVIRONMENTALREPLACEMENT_H_ */ diff --git a/branches/paradiseo-moeo-1.0/src/moeoEvalFunc.h b/branches/paradiseo-moeo-1.0/src/moeoEvalFunc.h deleted file mode 100644 index 1f6b7544d..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoEvalFunc.h +++ /dev/null @@ -1,24 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoEvalFunc.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEOEVALFUNC_H_ -#define MOEOEVALFUNC_H_ - -#include - -/* - * Functor that evaluates one MOEO by setting all its objective values. - */ -template < class MOEOT > -class moeoEvalFunc : public eoEvalFunc< MOEOT > {}; - -#endif /*MOEOEVALFUNC_H_*/ diff --git a/branches/paradiseo-moeo-1.0/src/moeoFastNonDominatedSortingFitnessAssignment.h b/branches/paradiseo-moeo-1.0/src/moeoFastNonDominatedSortingFitnessAssignment.h deleted file mode 100644 index 61556537e..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoFastNonDominatedSortingFitnessAssignment.h +++ /dev/null @@ -1,223 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoFastNonDominatedSortingFitnessAssignment.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEOFASTNONDOMINATEDSORTINGFITNESSASSIGNMENT_H_ -#define MOEOFASTNONDOMINATEDSORTINGFITNESSASSIGNMENT_H_ - -#include -#include -#include -#include - -/** - * 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) - * 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). - * This strategy is, for instance, used in NSGA and NSGA-II. - */ -template < class MOEOT > -class moeoFastNonDominatedSortingFitnessAssignment : public moeoParetoBasedFitnessAssignment < MOEOT > -{ -public: - - /** the objective vector type of the solutions */ - typedef typename MOEOT::ObjectiveVector ObjectiveVector; - - - /** - * Default ctor - */ - moeoFastNonDominatedSortingFitnessAssignment() : comparator(paretoComparator) - {} - - - /** - * Ctor where you can choose your own way to compare objective vectors - * @param _comparator the functor used to compare objective vectors - */ - moeoFastNonDominatedSortingFitnessAssignment(moeoObjectiveVectorComparator < ObjectiveVector > & _comparator) : comparator(_comparator) - {} - - - /** - * Sets the fitness values for every solution contained in the population _pop - * @param _pop the population - */ - void operator()(eoPop < MOEOT > & _pop) - { - // number of objectives for the problem under consideration - unsigned nObjectives = MOEOT::ObjectiveVector::nObjectives(); - if (nObjectives == 1) - { - // one objective - oneObjective(_pop); - } - else if (nObjectives == 2) - { - // two objectives (the two objectives function is still to implement) - mObjectives(_pop); - } - else if (nObjectives > 2) - { - // more than two objectives - mObjectives(_pop); - } - else - { - // problem with the number of objectives - throw std::runtime_error("Problem with the number of objectives in moeoNonDominatedSortingFitnessAssignment"); - } - // a higher fitness is better, so the values need to be inverted - double max = _pop[0].fitness(); - for (unsigned i=1 ; i<_pop.size() ; i++) - { - max = std::max(max, _pop[i].fitness()); - } - for (unsigned i=0 ; i<_pop.size() ; i++) - { - _pop[i].fitness(max - _pop[i].fitness()); - } - } - - - /** - * Updates the fitness values of the whole population _pop by taking the deletion of the objective vector _objVec into account. - * @param _pop the population - * @param _objVec the objective vector - */ - void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec) - { - for (unsigned i=0; i<_pop.size(); i++) - { - // if _pop[i] is dominated by _objVec - if ( comparator(_pop[i].objectiveVector(), _objVec) ) - { - _pop[i].fitness(_pop[i].fitness()+1); - } - } - } - - -private: - - /** Functor to compare two objective vectors */ - moeoObjectiveVectorComparator < ObjectiveVector > & comparator; - /** Functor to compare two objective vectors according to Pareto dominance relation */ - moeoParetoObjectiveVectorComparator < ObjectiveVector > paretoComparator; - - - - - /** - * Sets the fitness values for mono-objective problems - * @param _pop the population - */ - void oneObjective (eoPop < MOEOT > & _pop) - { - // Functor to compare two solutions on the first objective, then on the second, and so on - moeoObjectiveComparator < MOEOT > objComparator; - // sorts the population in the ascending order - std::sort(_pop.begin(), _pop.end(), objComparator); - // assign fitness values - unsigned rank = 1; - _pop[_pop.size()-1].fitness(rank); - for (unsigned i=_pop.size()-2; i>=0; i--) - { - if (_pop[i].objectiveVector() != _pop[i+1].objectiveVector()) - { - rank++; - } - _pop[i].fitness(rank); - } - } - - - /** - * 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 - */ - void twoObjectives (eoPop < MOEOT > & _pop) - { - //... 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 - * @param _pop the population - */ - void mObjectives (eoPop < MOEOT > & _pop) - { - // S[i] = indexes of the individuals dominated by _pop[i] - std::vector < std::vector > S(_pop.size()); - // n[i] = number of individuals that dominate the individual _pop[i] - std::vector < unsigned > n(_pop.size(), 0); - // fronts: F[i] = indexes of the individuals contained in the ith front - std::vector < std::vector > F(_pop.size()+2); - // used to store the number of the first front - F[1].reserve(_pop.size()); - for (unsigned p=0; p<_pop.size(); p++) - { - for (unsigned q=0; q<_pop.size(); q++) - { - // if q is dominated by p - if ( comparator(_pop[q].objectiveVector(), _pop[p].objectiveVector()) ) - { - // add q to the set of solutions dominated by p - S[p].push_back(q); - } - // if p is dominated by q - else if ( comparator(_pop[p].objectiveVector(), _pop[q].objectiveVector()) ) - { - // increment the domination counter of p - n[p]++; - } - } - // if no individual dominates p - if (n[p] == 0) - { - // p belongs to the first front - _pop[p].fitness(1); - F[1].push_back(p); - } - } - // front counter - unsigned counter=1; - unsigned p,q; - while (! F[counter].empty()) - { - // used to store the number of the next front - F[counter+1].reserve(_pop.size()); - for (unsigned i=0; i -#include - -/** - * Functor that sets the fitness values of a whole population. - */ -template < class MOEOT > -class moeoFitnessAssignment : public eoUF < eoPop < MOEOT > &, void > -{ -public: - - /** The type for objective vector */ - typedef typename MOEOT::ObjectiveVector ObjectiveVector; - - - /** - * Updates the fitness values of the whole population _pop by taking the deletion of the objective vector _objVec into account. - * @param _pop the population - * @param _objVec the objective vector - */ - virtual void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec) = 0; - - - /** - * Updates the fitness values of the whole population _pop by taking the deletion of the individual _moeo into account. - * @param _pop the population - * @param _moeo the individual - */ - void updateByDeleting(eoPop < MOEOT > & _pop, MOEOT & _moeo) - { - updateByDeleting(_pop, _moeo.objectiveVector()); - } - -}; - - -/** - * moeoDummyFitnessAssignment is a moeoFitnessAssignment that gives the value '0' as the individual's fitness for a whole population if it is invalid. - */ -template < class MOEOT > -class moeoDummyFitnessAssignment : public moeoFitnessAssignment < MOEOT > -{ -public: - - /** The type for objective vector */ - typedef typename MOEOT::ObjectiveVector ObjectiveVector; - - - /** - * Sets the fitness to '0' for every individuals of the population _pop if it is invalid - * @param _pop the population - */ - void operator () (eoPop < MOEOT > & _pop) - { - for (unsigned idx = 0; idx<_pop.size (); idx++) - { - if (_pop[idx].invalidFitness()) - { - // set the diversity to 0 - _pop[idx].fitness(0.0); - } - } - } - - - /** - * Updates the fitness values of the whole population _pop by taking the deletion of the objective vector _objVec into account. - * @param _pop the population - * @param _objVec the objective vector - */ - void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec) - { - // nothing to do... ;-) - } - -}; - - -/** - * moeoScalarFitnessAssignment is a moeoFitnessAssignment for scalar strategies. - */ -template < class MOEOT > -class moeoScalarFitnessAssignment : public moeoFitnessAssignment < MOEOT > - {}; - - -/** - * moeoCriterionBasedFitnessAssignment is a moeoFitnessAssignment for criterion-based strategies. - */ -template < class MOEOT > -class moeoCriterionBasedFitnessAssignment : public moeoFitnessAssignment < MOEOT > - {}; - - -/** - * moeoParetoBasedFitnessAssignment is a moeoFitnessAssignment for Pareto-based strategies. - */ -template < class MOEOT > -class moeoParetoBasedFitnessAssignment : public moeoFitnessAssignment < MOEOT > - {}; - - -#endif /*MOEOFITNESSASSIGNMENT_H_*/ diff --git a/branches/paradiseo-moeo-1.0/src/moeoGenerationalReplacement.h b/branches/paradiseo-moeo-1.0/src/moeoGenerationalReplacement.h deleted file mode 100644 index b7b800625..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoGenerationalReplacement.h +++ /dev/null @@ -1,39 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoGenerationalReplacement.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEOGENERATIONALREPLACEMENT_H_ -#define MOEOGENERATIONALREPLACEMENT_H_ - -#include -#include - -/** - * Generational replacement: only the new individuals are preserved. - */ -template < class MOEOT > -class moeoGenerationalReplacement : public moeoReplacement < MOEOT >, public eoGenerationalReplacement < MOEOT > -{ -public: - - /** - * Swaps _parents and _offspring - * @param _parents the parents population - * @param _offspring the offspring population - */ - void operator()(eoPop < MOEOT > & _parents, eoPop < MOEOT > & _offspring) - { - eoGenerationalReplacement < MOEOT >::operator ()(_parents, _offspring); - } - -}; - -#endif /*MOEOGENERATIONALREPLACEMENT_H_*/ diff --git a/branches/paradiseo-moeo-1.0/src/moeoHybridLS.h b/branches/paradiseo-moeo-1.0/src/moeoHybridLS.h deleted file mode 100644 index 95aad42e0..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoHybridLS.h +++ /dev/null @@ -1,76 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoHybridLS.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEOHYBRIDLS_H_ -#define MOEOHYBRIDLS_H_ - -#include -#include -#include -#include -#include -#include - -/** - * 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. - */ -template < class MOEOT > -class moeoHybridLS : public eoUpdater -{ -public: - - /** - * Ctor - * @param _term stopping criteria - * @param _select selector - * @param _mols a multi-objective local search - * @param _arch the archive - */ - moeoHybridLS (eoContinue < MOEOT > & _term, eoSelect < MOEOT > & _select, moeoLS < MOEOT, MOEOT > & _mols, moeoArchive < MOEOT > & _arch) : - term(_term), select(_select), mols(_mols), arch(_arch) - {} - - - /** - * Applies the multi-objective local search to selected individuals contained in the archive if the stopping criteria is not verified - */ - void operator () () - { - if (! term (arch)) - { - // selection of solutions - eoPop < MOEOT > selectedSolutions; - select(arch, selectedSolutions); - // apply the local search to every selected solution - for (unsigned i=0; i & term; - /** selector */ - eoSelect < MOEOT > & select; - /** multi-objective local search */ - moeoLS < MOEOT, MOEOT > & mols; - /** archive */ - moeoArchive < MOEOT > & arch; - -}; - -#endif /*MOEOHYBRIDLS_H_*/ diff --git a/branches/paradiseo-moeo-1.0/src/moeoIBEA.h b/branches/paradiseo-moeo-1.0/src/moeoIBEA.h deleted file mode 100644 index ca3076c6b..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoIBEA.h +++ /dev/null @@ -1,156 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoIBEA.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEOIBEA_H_ -#define MOEOIBEA_H_ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -/** - * IBEA (Indicator-Based Evolutionary Algorithm) as described in: - * E. Zitzler, S. Künzli, "Indicator-Based Selection in Multiobjective Search", Proc. 8th International Conference on Parallel Problem Solving from Nature (PPSN VIII), pp. 832-842, Birmingham, UK (2004). - * This class builds the IBEA algorithm only by using the fine-grained components of the ParadisEO-MOEO framework. - */ -template < class MOEOT > -class moeoIBEA : public moeoEA < MOEOT > -{ -public: - - /** The type of objective vector */ - typedef typename MOEOT::ObjectiveVector ObjectiveVector; - - - /** - * Simple ctor with a eoGenOp. - * @param _maxGen number of generations before stopping - * @param _eval evaluation function - * @param _op variation operator - */ - moeoIBEA (unsigned _maxGen, eoEvalFunc < MOEOT > & _eval, eoGenOp < MOEOT > & _op, moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > & _metric, const double _kappa=0.05) : - defaultGenContinuator(_maxGen), continuator(defaultGenContinuator), popEval(_eval), select(2), - fitnessAssignment(_metric, _kappa), replace(fitnessAssignment, dummyDiversityAssignment), genBreed(select, _op), breed(genBreed) - {} - - - /** - * Simple ctor with a eoTransform. - * @param _maxGen number of generations before stopping - * @param _eval evaluation function - * @param _op variation operator - */ - moeoIBEA (unsigned _maxGen, eoEvalFunc < MOEOT > & _eval, eoTransform < MOEOT > & _op, moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > & _metric, const double _kappa=0.05) : - defaultGenContinuator(_maxGen), continuator(defaultGenContinuator), popEval(_eval), select(2), - fitnessAssignment(_metric, _kappa), replace(fitnessAssignment, dummyDiversityAssignment), genBreed(select, _op), breed(genBreed) - {} - - - /** - * Ctor with a crossover, a mutation and their corresponding rates. - * @param _maxGen number of generations before stopping - * @param _eval evaluation function - * @param _crossover crossover - * @param _pCross crossover probability - * @param _mutation mutation - * @param _pMut mutation probability - */ - moeoIBEA (unsigned _maxGen, eoEvalFunc < MOEOT > & _eval, eoQuadOp < MOEOT > & _crossover, double _pCross, eoMonOp < MOEOT > & _mutation, double _pMut, moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > & _metric, const double _kappa=0.05) : - defaultGenContinuator(_maxGen), continuator(defaultGenContinuator), popEval(_eval), select (2), - fitnessAssignment(_metric, _kappa), replace (fitnessAssignment, dummyDiversityAssignment), defaultSGAGenOp(_crossover, _pCross, _mutation, _pMut), - genBreed (select, defaultSGAGenOp), breed (genBreed) - {} - - - /** - * Ctor with a continuator (instead of _maxGen) and a eoGenOp. - * @param _continuator stopping criteria - * @param _eval evaluation function - * @param _op variation operator - */ - moeoIBEA (eoContinue < MOEOT > & _continuator, eoEvalFunc < MOEOT > & _eval, eoGenOp < MOEOT > & _op, moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > & _metric, const double _kappa=0.05) : - continuator(_continuator), popEval(_eval), select(2), - fitnessAssignment(_metric, _kappa), replace(fitnessAssignment, dummyDiversityAssignment), genBreed(select, _op), breed(genBreed) - {} - - - /** - * Ctor with a continuator (instead of _maxGen) and a eoTransform. - * @param _continuator stopping criteria - * @param _eval evaluation function - * @param _op variation operator - */ - moeoIBEA (eoContinue < MOEOT > & _continuator, eoEvalFunc < MOEOT > & _eval, eoTransform < MOEOT > & _op, moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > & _metric, const double _kappa=0.05) : - continuator(_continuator), popEval(_eval), select(2), - fitnessAssignment(_metric, _kappa), replace(fitnessAssignment, dummyDiversityAssignment), genBreed(select, _op), breed(genBreed) - {} - - - /** - * Apply a few generation of evolution to the population _pop until the stopping criteria is verified. - * @param _pop the population - */ - virtual void operator () (eoPop < MOEOT > &_pop) - { - eoPop < MOEOT > offspring, empty_pop; - popEval (empty_pop, _pop); // a first eval of _pop - // evaluate fitness and diversity - fitnessAssignment(_pop); - dummyDiversityAssignment(_pop); - do - { - // generate offspring, worths are recalculated if necessary - breed (_pop, offspring); - // eval of offspring - popEval (_pop, offspring); - // after replace, the new pop is in _pop. Worths are recalculated if necessary - replace (_pop, offspring); - } while (continuator (_pop)); - } - - -protected: - - /** a continuator based on the number of generations (used as default) */ - eoGenContinue < MOEOT > defaultGenContinuator; - /** stopping criteria */ - eoContinue < MOEOT > & continuator; - /** evaluation function used to evaluate the whole population */ - eoPopLoopEval < MOEOT > popEval; - /** binary tournament selection */ - moeoDetTournamentSelect < MOEOT > select; - /** fitness assignment used in IBEA */ - moeoIndicatorBasedFitnessAssignment < MOEOT > fitnessAssignment; - /** dummy diversity assignment */ - moeoDummyDiversityAssignment < MOEOT > dummyDiversityAssignment; - /** elitist replacement */ - moeoEnvironmentalReplacement < MOEOT > replace; - /** an object for genetic operators (used as default) */ - eoSGAGenOp < MOEOT > defaultSGAGenOp; - /** general breeder */ - eoGeneralBreeder < MOEOT > genBreed; - /** breeder */ - eoBreed < MOEOT > & breed; - -}; - -#endif /*MOEOIBEA_H_*/ diff --git a/branches/paradiseo-moeo-1.0/src/moeoIndicatorBasedFitnessAssignment.h b/branches/paradiseo-moeo-1.0/src/moeoIndicatorBasedFitnessAssignment.h deleted file mode 100644 index bed309c24..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoIndicatorBasedFitnessAssignment.h +++ /dev/null @@ -1,201 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoIndicatorBasedFitnessAssignment.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEOINDICATORBASEDFITNESSASSIGNMENT_H_ -#define MOEOINDICATORBASEDFITNESSASSIGNMENT_H_ - -#include -#include -#include -#include -#include - -/** - * Fitness assignment sheme based an Indicator proposed in: - * E. Zitzler, S. Künzli, "Indicator-Based Selection in Multiobjective Search", Proc. 8th International Conference on Parallel Problem Solving from Nature (PPSN VIII), pp. 832-842, Birmingham, UK (2004). - * This strategy is, for instance, used in IBEA. - */ -template < class MOEOT > -class moeoIndicatorBasedFitnessAssignment : public moeoParetoBasedFitnessAssignment < MOEOT > -{ -public: - - /** The type of objective vector */ - typedef typename MOEOT::ObjectiveVector ObjectiveVector; - - - /** - * Ctor. - * @param _metric the quality indicator - * @param _kappa the scaling factor - */ - moeoIndicatorBasedFitnessAssignment(moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > & _metric, const double _kappa = 0.05) : metric(_metric), kappa(_kappa) - {} - - - /** - * Sets the fitness values for every solution contained in the population _pop - * @param _pop the population - */ - void operator()(eoPop < MOEOT > & _pop) - { - // 1 - setting of the bounds - setup(_pop); - // 2 - computing every indicator values - computeValues(_pop); - // 3 - setting fitnesses - setFitnesses(_pop); - } - - - /** - * Updates the fitness values of the whole population _pop by taking the deletion of the objective vector _objVec into account. - * @param _pop the population - * @param _objVec the objective vector - */ - void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec) - { - vector < double > v; - v.resize(_pop.size()); - for (unsigned i=0; i<_pop.size(); i++) - { - v[i] = metric(_objVec, _pop[i].objectiveVector()); - } - for (unsigned i=0; i<_pop.size(); i++) - { - _pop[i].fitness( _pop[i].fitness() + exp(-v[i]/kappa) ); - } - } - - - /** - * Updates the fitness values of the whole population _pop by taking the adding of the objective vector _objVec into account - * and returns the fitness value of _objVec. - * @param _pop the population - * @param _objVec the objective vector - */ - double updateByAdding(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec) - { - vector < double > v; - // update every fitness values to take the new individual into account - v.resize(_pop.size()); - for (unsigned i=0; i<_pop.size(); i++) - { - v[i] = metric(_objVec, _pop[i].objectiveVector()); - } - for (unsigned i=0; i<_pop.size(); i++) - { - _pop[i].fitness( _pop[i].fitness() - exp(-v[i]/kappa) ); - } - // compute the fitness of the new individual - v.clear(); - v.resize(_pop.size()); - for (unsigned i=0; i<_pop.size(); i++) - { - v[i] = metric(_pop[i].objectiveVector(), _objVec); - } - double result = 0; - for (unsigned i=0; i & metric; - /** the scaling factor */ - double kappa; - /** the computed indicator values */ - std::vector < std::vector > values; - - - /** - * Sets the bounds for every objective using the min and the max value for every objective vector of _pop - * @param _pop the population - */ - void setup(const eoPop < MOEOT > & _pop) - { - double min, max; - for (unsigned i=0; i & _pop) - { - values.clear(); - values.resize(_pop.size()); - for (unsigned i=0; i<_pop.size(); i++) - { - values[i].resize(_pop.size()); - for (unsigned j=0; j<_pop.size(); j++) - { - if (i != j) - { - values[i][j] = metric(_pop[i].objectiveVector(), _pop[j].objectiveVector()); - } - } - } - } - - - /** - * Sets the fitness value of the whple population - * @param _pop the population - */ - void setFitnesses(eoPop < MOEOT > & _pop) - { - for (unsigned i=0; i<_pop.size(); i++) - { - _pop[i].fitness(computeFitness(i)); - } - } - - - /** - * Returns the fitness value of the _idx th individual of the population - * @param _idx the index - */ - double computeFitness(const unsigned _idx) - { - double result = 0; - for (unsigned i=0; i -#include -#include -#include -#include -#include -#include -#include -#include -#include - -/** - * Indicator-Based Multi-Objective Local Search (IBMOLS) as described in - * Basseur M., Burke K. : "Indicator-Based Multi-Objective Local Search" (2007). - */ -template < class MOEOT, class Move > -class moeoIndicatorBasedLS : public moeoLS < MOEOT, eoPop < MOEOT > & > -{ -public: - - /** The type of objective vector */ - typedef typename MOEOT::ObjectiveVector ObjectiveVector; - - - /** - * Ctor. - * @param _moveInit the move initializer - * @param _nextMove the neighborhood explorer - * @param _eval the full evaluation - * @param _moveIncrEval the incremental evaluation - * @param _fitnessAssignment the fitness assignment strategy - * @param _continuator the stopping criteria - */ - moeoIndicatorBasedLS( - moMoveInit < Move > & _moveInit, - moNextMove < Move > & _nextMove, - eoEvalFunc < MOEOT > & _eval, - moeoMoveIncrEval < Move > & _moveIncrEval, - moeoIndicatorBasedFitnessAssignment < MOEOT > & _fitnessAssignment, - eoContinue < MOEOT > & _continuator - ) : - moveInit(_moveInit), - nextMove(_nextMove), - eval(_eval), - moveIncrEval(_moveIncrEval), - fitnessAssignment (_fitnessAssignment), - continuator (_continuator) - {} - - - /** - * Apply the local search until a local archive does not change or - * another stopping criteria is met and update the archive _arch with new non-dominated solutions. - * @param _pop the initial population - * @param _arch the (updated) archive - */ - void operator() (eoPop < MOEOT > & _pop, moeoArchive < MOEOT > & _arch) - { - // evaluation of the objective values - /* - for (unsigned i=0; i<_pop.size(); i++) - { - eval(_pop[i]); - } - */ - // fitness assignment for the whole population - fitnessAssignment(_pop); - // creation of a local archive - moeoArchive < MOEOT > archive; - // creation of another local archive (for the stopping criteria) - moeoArchive < MOEOT > previousArchive; - // update the archive with the initial population - archive.update(_pop); - do - { - previousArchive.update(archive); - oneStep(_pop); - archive.update(_pop); - } while ( (! archive.equals(previousArchive)) && (continuator(_arch)) ); - _arch.update(archive); - } - - -private: - - /** the move initializer */ - moMoveInit < Move > & moveInit; - /** the neighborhood explorer */ - moNextMove < Move > & nextMove; - /** the full evaluation */ - eoEvalFunc < MOEOT > & eval; - /** the incremental evaluation */ - moeoMoveIncrEval < Move > & moveIncrEval; - /** the fitness assignment strategy */ - moeoIndicatorBasedFitnessAssignment < MOEOT > & fitnessAssignment; - /** the stopping criteria */ - eoContinue < MOEOT > & continuator; - - - /** - * Apply one step of the local search to the population _pop - * @param _pop the population - */ - void oneStep (eoPop < MOEOT > & _pop) - { -//////////////////////////////////////////// - int ext_0_idx, ext_1_idx; - ObjectiveVector ext_0_objVec, ext_1_objVec; -/////////////////////////////////////////// - // the move - Move move; - // the objective vector and the fitness of the current solution - ObjectiveVector x_objVec; - double x_fitness; - // the index, the objective vector and the fitness of the worst solution in the population (-1 implies that the worst is the newly created one) - int worst_idx; - ObjectiveVector worst_objVec; - double worst_fitness; - // the index current of the current solution to be explored - unsigned i=0; - // initilization of the move for the first individual - moveInit(move, _pop[i]); - while (i<_pop.size() && continuator(_pop)) - { - // x = one neigbour of pop[i] - // evaluate x in the objective space - x_objVec = moveIncrEval(move, _pop[i]); - // update every fitness values to take x into account and compute the fitness of x - x_fitness = fitnessAssignment.updateByAdding(_pop, x_objVec); - -//////////////////////////////////////////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////////////////////////////////////// -// qui sont les extremes ? (=> min only !!!) - ext_0_idx = -1; - ext_0_objVec = x_objVec; - ext_1_idx = -1; - ext_1_objVec = x_objVec; - for (unsigned k=0; k<_pop.size(); k++) - { - // ext_0 - if (_pop[k].objectiveVector()[0] < ext_0_objVec[0]) - { - ext_0_idx = k; - ext_0_objVec = _pop[k].objectiveVector(); - } - else if ( (_pop[k].objectiveVector()[0] == ext_0_objVec[0]) && (_pop[k].objectiveVector()[1] < ext_0_objVec[1]) ) - { - ext_0_idx = k; - ext_0_objVec = _pop[k].objectiveVector(); - } - // ext_1 - else if (_pop[k].objectiveVector()[1] < ext_1_objVec[1]) - { - ext_1_idx = k; - ext_1_objVec = _pop[k].objectiveVector(); - } - else if ( (_pop[k].objectiveVector()[1] == ext_1_objVec[1]) && (_pop[k].objectiveVector()[0] < ext_1_objVec[0]) ) - { - ext_1_idx = k; - ext_1_objVec = _pop[k].objectiveVector(); - } - } -// worst init - if (ext_0_idx == -1) - { - unsigned ind = 0; - while (ind == ext_1_idx) - { - ind++; - } - worst_idx = ind; - worst_objVec = _pop[ind].objectiveVector(); - worst_fitness = _pop[ind].fitness(); - } - else if (ext_1_idx == -1) - { - unsigned ind = 0; - while (ind == ext_0_idx) - { - ind++; - } - worst_idx = ind; - worst_objVec = _pop[ind].objectiveVector(); - worst_fitness = _pop[ind].fitness(); - } - else - { - worst_idx = -1; - worst_objVec = x_objVec; - worst_fitness = x_fitness; - } -//////////////////////////////////////////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////////////////////////////////////// -//////////////////////////////////////////////////////////////////////////////////////////////////////////// - - // who is the worst ? - for (unsigned j=0; j<_pop.size(); j++) - { - if ( (j!=ext_0_idx) && (j!=ext_1_idx) ) - { - if (_pop[j].fitness() < worst_fitness) - { - worst_idx = j; - worst_objVec = _pop[j].objectiveVector(); - worst_fitness = _pop[j].fitness(); - } - } - } - // if the worst solution is the new one - if (worst_idx == -1) - { - // if all its neighbours have been explored, - // let's explore the neighborhoud of the next individual - if (! nextMove(move, _pop[i])) - { - i++; - if (i<_pop.size()) - { - // initilization of the move for the next individual - moveInit(move, _pop[i]); - } - } - } - // if the worst solution is located before _pop[i] - else if (worst_idx <= i) - { - // the new solution takes place insteed of _pop[worst_idx] - _pop[worst_idx] = _pop[i]; - move(_pop[worst_idx]); - _pop[worst_idx].objectiveVector(x_objVec); - _pop[worst_idx].fitness(x_fitness); - // let's explore the neighborhoud of the next individual - i++; - if (i<_pop.size()) - { - // initilization of the move for the next individual - moveInit(move, _pop[i]); - } - } - // if the worst solution is located after _pop[i] - else if (worst_idx > i) - { - // the new solution takes place insteed of _pop[i+1] and _pop[worst_idx] is deleted - _pop[worst_idx] = _pop[i+1]; - _pop[i+1] = _pop[i]; - move(_pop[i+1]); - _pop[i+1].objectiveVector(x_objVec); - _pop[i+1].fitness(x_fitness); - // let's explore the neighborhoud of the individual _pop[i+2] - i += 2; - if (i<_pop.size()) - { - // initilization of the move for the next individual - moveInit(move, _pop[i]); - } - } - // update fitness values - fitnessAssignment.updateByDeleting(_pop, worst_objVec); - } - } - -}; - -#endif /*MOEOINDICATORBASEDLS_H_*/ diff --git a/branches/paradiseo-moeo-1.0/src/moeoIteratedIBMOLS.h b/branches/paradiseo-moeo-1.0/src/moeoIteratedIBMOLS.h deleted file mode 100755 index 780787ac1..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoIteratedIBMOLS.h +++ /dev/null @@ -1,215 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoIteratedIBMOLS.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEOITERATEDIBMOLS_H_ -#define MOEOITERATEDIBMOLS_H_ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - - - -//#include - - - -/** - * Iterated version of IBMOLS as described in - * Basseur M., Burke K. : "Indicator-Based Multi-Objective Local Search" (2007). - */ -template < class MOEOT, class Move > -class moeoIteratedIBMOLS : public moeoLS < MOEOT, eoPop < MOEOT > & > -{ -public: - - /** The type of objective vector */ - typedef typename MOEOT::ObjectiveVector ObjectiveVector; - - - /** - * Ctor. - * @param _moveInit the move initializer - * @param _nextMove the neighborhood explorer - * @param _eval the full evaluation - * @param _moveIncrEval the incremental evaluation - * @param _fitnessAssignment the fitness assignment strategy - * @param _continuator the stopping criteria - * @param _monOp the monary operator - * @param _randomMonOp the random monary operator (or random initializer) - * @param _nNoiseIterations the number of iterations to apply the random noise - */ - moeoIteratedIBMOLS( - moMoveInit < Move > & _moveInit, - moNextMove < Move > & _nextMove, - eoEvalFunc < MOEOT > & _eval, - moeoMoveIncrEval < Move > & _moveIncrEval, - moeoIndicatorBasedFitnessAssignment < MOEOT > & _fitnessAssignment, - eoContinue < MOEOT > & _continuator, - eoMonOp < MOEOT > & _monOp, - eoMonOp < MOEOT > & _randomMonOp, - unsigned _nNoiseIterations=1 - ) : - ibmols(_moveInit, _nextMove, _eval, _moveIncrEval, _fitnessAssignment, _continuator), - eval(_eval), - continuator(_continuator), - monOp(_monOp), - randomMonOp(_randomMonOp), - nNoiseIterations(_nNoiseIterations) - {} - - - /** - * Apply the local search iteratively until the stopping criteria is met. - * @param _pop the initial population - * @param _arch the (updated) archive - */ - void operator() (eoPop < MOEOT > & _pop, moeoArchive < MOEOT > & _arch) - { - _arch.update(_pop); - ibmols(_pop, _arch); - while (continuator(_arch)) - { - // generate new solutions from the archive - generateNewSolutions(_pop, _arch); - // apply the local search (the global archive is updated in the sub-function) - ibmols(_pop, _arch); - } - } - - -private: - - /** the local search to iterate */ - moeoIndicatorBasedLS < MOEOT, Move > ibmols; - /** the full evaluation */ - eoEvalFunc < MOEOT > & eval; - /** the stopping criteria */ - eoContinue < MOEOT > & continuator; - /** the monary operator */ - eoMonOp < MOEOT > & monOp; - /** the random monary operator (or random initializer) */ - eoMonOp < MOEOT > & randomMonOp; - /** the number of iterations to apply the random noise */ - unsigned nNoiseIterations; - - - /** - * Creates new population randomly initialized and/or initialized from the archive _arch. - * @param _pop the output population - * @param _arch the archive - */ - void generateNewSolutions(eoPop < MOEOT > & _pop, const moeoArchive < MOEOT > & _arch) - { - // shuffle vector for the random selection of individuals - vector shuffle; - shuffle.resize(std::max(_pop.size(), _arch.size())); - // init shuffle - for (unsigned i=0; i gen; - std::random_shuffle(shuffle.begin(), shuffle.end(), gen); - // start the creation of new solutions - for (unsigned i=0; i<_pop.size(); i++) - { - if (shuffle[i] < _arch.size()) - // the given archive contains the individual i - { - // add it to the resulting pop - _pop[i] = _arch[shuffle[i]]; - // then, apply the operator nIterationsNoise times - for (unsigned j=0; j & _pop, const moeoArchive < MOEOT > & _arch) - { - // here, we must have a QuadOp ! - //eoQuadOp < MOEOT > quadOp; - rsCrossQuad quadOp; - // shuffle vector for the random selection of individuals - vector shuffle; - shuffle.resize(_arch.size()); - // init shuffle - for (unsigned i=0; i gen; - std::random_shuffle(shuffle.begin(), shuffle.end(), gen); - // start the creation of new solutions - unsigned i=0; - while ((i<_pop.size()-1) && (i<_arch.size()-1)) - { - _pop[i] = _arch[shuffle[i]]; - _pop[i+1] = _arch[shuffle[i+1]]; - // then, apply the operator nIterationsNoise times - for (unsigned j=0; j -#include -#include - -/** - * Abstract class for local searches applied to multi-objective optimization. - * Starting from a Type (i.e.: an individual, a pop, an archive...), it produces a set of new non-dominated solutions. - */ -template < class MOEOT, class Type > -class moeoLS: public moeoAlgo, public eoBF < Type, moeoArchive < MOEOT > &, void > - {}; - -#endif /*MOEOLS_H_*/ diff --git a/branches/paradiseo-moeo-1.0/src/moeoMoveIncrEval.h b/branches/paradiseo-moeo-1.0/src/moeoMoveIncrEval.h deleted file mode 100644 index 0170a959b..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoMoveIncrEval.h +++ /dev/null @@ -1,12 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -#ifndef _MOEOMOVEINCREVAL_H -#define _MOEOMOVEINCREVAL_H - -#include - -template < class Move > -class moeoMoveIncrEval : public eoBF < const Move &, const typename Move::EOType &, typename Move::EOType::ObjectiveVector > - {}; - -#endif diff --git a/branches/paradiseo-moeo-1.0/src/moeoNSGA.h b/branches/paradiseo-moeo-1.0/src/moeoNSGA.h deleted file mode 100644 index 5d18f1c59..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoNSGA.h +++ /dev/null @@ -1,152 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoNSGA.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEONSGA_H_ -#define MOEONSGA_H_ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -/** - * NSGA (Non-dominated Sorting Genetic Algorithm) as described in: - * N. Srinivas, K. Deb, "Multiobjective Optimization Using Nondominated Sorting in Genetic Algorithms". - * Evolutionary Computation, Vol. 2(3), No 2, pp. 221-248 (1994). - * This class builds the NSGA algorithm only by using the fine-grained components of the ParadisEO-MOEO framework. - */ -template < class MOEOT > -class moeoNSGA: public moeoEA < MOEOT > -{ -public: - - /** - * Simple ctor with a eoGenOp. - * @param _maxGen number of generations before stopping - * @param _eval evaluation function - * @param _op variation operator - */ - moeoNSGA (unsigned _maxGen, eoEvalFunc < MOEOT > & _eval, eoGenOp < MOEOT > & _op, double _nicheSize = 0.5) : - defaultGenContinuator(_maxGen), continuator(defaultGenContinuator), popEval(_eval), select(2), - diversityAssignment(_nicheSize), replace(fitnessAssignment, diversityAssignment), genBreed(select, _op), breed(genBreed) - {} - - - /** - * Simple ctor with a eoTransform. - * @param _maxGen number of generations before stopping - * @param _eval evaluation function - * @param _op variation operator - */ - moeoNSGA (unsigned _maxGen, eoEvalFunc < MOEOT > & _eval, eoTransform < MOEOT > & _op, double _nicheSize = 0.5) : - defaultGenContinuator(_maxGen), continuator(defaultGenContinuator), popEval(_eval), select(2), - diversityAssignment(_nicheSize), replace(fitnessAssignment, diversityAssignment), genBreed(select, _op), breed(genBreed) - {} - - - /** - * Ctor with a crossover, a mutation and their corresponding rates. - * @param _maxGen number of generations before stopping - * @param _eval evaluation function - * @param _crossover crossover - * @param _pCross crossover probability - * @param _mutation mutation - * @param _pMut mutation probability - */ - moeoNSGA (unsigned _maxGen, eoEvalFunc < MOEOT > & _eval, eoQuadOp < MOEOT > & _crossover, double _pCross, eoMonOp < MOEOT > & _mutation, double _pMut, double _nicheSize = 0.5) : - defaultGenContinuator(_maxGen), continuator(defaultGenContinuator), popEval(_eval), select (2), - diversityAssignment(_nicheSize), replace (fitnessAssignment, diversityAssignment), - defaultSGAGenOp(_crossover, _pCross, _mutation, _pMut), genBreed (select, defaultSGAGenOp), breed (genBreed) - {} - - - /** - * Ctor with a continuator (instead of _maxGen) and a eoGenOp. - * @param _continuator stopping criteria - * @param _eval evaluation function - * @param _op variation operator - */ - moeoNSGA (eoContinue < MOEOT > & _continuator, eoEvalFunc < MOEOT > & _eval, eoGenOp < MOEOT > & _op, double _nicheSize = 0.5) : - continuator(_continuator), popEval(_eval), select(2), - diversityAssignment(_nicheSize), replace(fitnessAssignment, diversityAssignment), genBreed(select, _op), breed(genBreed) - {} - - - /** - * Ctor with a continuator (instead of _maxGen) and a eoTransform. - * @param _continuator stopping criteria - * @param _eval evaluation function - * @param _op variation operator - */ - moeoNSGA (eoContinue < MOEOT > & _continuator, eoEvalFunc < MOEOT > & _eval, eoTransform < MOEOT > & _op, double _nicheSize = 0.5) : - continuator(_continuator), popEval(_eval), select(2), - diversityAssignment(_nicheSize), replace(fitnessAssignment, diversityAssignment), genBreed(select, _op), breed(genBreed) - {} - - - /** - * Apply a few generation of evolution to the population _pop until the stopping criteria is verified. - * @param _pop the population - */ - virtual void operator () (eoPop < MOEOT > &_pop) - { - eoPop < MOEOT > offspring, empty_pop; - popEval (empty_pop, _pop); // a first eval of _pop - // evaluate fitness and diversity - fitnessAssignment(_pop); - diversityAssignment(_pop); - do - { - // generate offspring, worths are recalculated if necessary - breed (_pop, offspring); - // eval of offspring - popEval (_pop, offspring); - // after replace, the new pop is in _pop. Worths are recalculated if necessary - replace (_pop, offspring); - } while (continuator (_pop)); - } - - -protected: - - /** a continuator based on the number of generations (used as default) */ - eoGenContinue < MOEOT > defaultGenContinuator; - /** stopping criteria */ - eoContinue < MOEOT > & continuator; - /** evaluation function used to evaluate the whole population */ - eoPopLoopEval < MOEOT > popEval; - /** binary tournament selection */ - moeoDetTournamentSelect < MOEOT > select; - /** fitness assignment used in NSGA-II */ - moeoFastNonDominatedSortingFitnessAssignment < MOEOT > fitnessAssignment; - /** diversity assignment used in NSGA-II */ - moeoFrontByFrontSharingDiversityAssignment < MOEOT > diversityAssignment; - /** elitist replacement */ - moeoElitistReplacement < MOEOT > replace; - /** an object for genetic operators (used as default) */ - eoSGAGenOp < MOEOT > defaultSGAGenOp; - /** general breeder */ - eoGeneralBreeder < MOEOT > genBreed; - /** breeder */ - eoBreed < MOEOT > & breed; - -}; - -#endif /*MOEONSGAII_H_*/ diff --git a/branches/paradiseo-moeo-1.0/src/moeoNSGAII.h b/branches/paradiseo-moeo-1.0/src/moeoNSGAII.h deleted file mode 100644 index ae3ac073f..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoNSGAII.h +++ /dev/null @@ -1,152 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoNSGAII.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEONSGAII_H_ -#define MOEONSGAII_H_ - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -/** - * NSGA-II (Non-dominated Sorting Genetic Algorithm II) as described in: - * Deb, K., S. Agrawal, A. Pratap, and T. Meyarivan : "A fast elitist non-dominated sorting genetic algorithm for multi-objective optimization: NSGA-II". - * In IEEE Transactions on Evolutionary Computation, Vol. 6, No 2, pp 182-197 (April 2002). - * This class builds the NSGA-II algorithm only by using the fine-grained components of the ParadisEO-MOEO framework. - */ -template < class MOEOT > -class moeoNSGAII: public moeoEA < MOEOT > -{ -public: - - /** - * Simple ctor with a eoGenOp. - * @param _maxGen number of generations before stopping - * @param _eval evaluation function - * @param _op variation operator - */ - moeoNSGAII (unsigned _maxGen, eoEvalFunc < MOEOT > & _eval, eoGenOp < MOEOT > & _op) : - defaultGenContinuator(_maxGen), continuator(defaultGenContinuator), popEval(_eval), select(2), - replace(fitnessAssignment, diversityAssignment), genBreed(select, _op), breed(genBreed) - {} - - - /** - * Simple ctor with a eoTransform. - * @param _maxGen number of generations before stopping - * @param _eval evaluation function - * @param _op variation operator - */ - moeoNSGAII (unsigned _maxGen, eoEvalFunc < MOEOT > & _eval, eoTransform < MOEOT > & _op) : - defaultGenContinuator(_maxGen), continuator(defaultGenContinuator), popEval(_eval), select(2), - replace(fitnessAssignment, diversityAssignment), genBreed(select, _op), breed(genBreed) - {} - - - /** - * Ctor with a crossover, a mutation and their corresponding rates. - * @param _maxGen number of generations before stopping - * @param _eval evaluation function - * @param _crossover crossover - * @param _pCross crossover probability - * @param _mutation mutation - * @param _pMut mutation probability - */ - moeoNSGAII (unsigned _maxGen, eoEvalFunc < MOEOT > & _eval, eoQuadOp < MOEOT > & _crossover, double _pCross, eoMonOp < MOEOT > & _mutation, double _pMut) : - defaultGenContinuator(_maxGen), continuator(defaultGenContinuator), popEval(_eval), select (2), - replace (fitnessAssignment, diversityAssignment), defaultSGAGenOp(_crossover, _pCross, _mutation, _pMut), - genBreed (select, defaultSGAGenOp), breed (genBreed) - {} - - - /** - * Ctor with a continuator (instead of _maxGen) and a eoGenOp. - * @param _continuator stopping criteria - * @param _eval evaluation function - * @param _op variation operator - */ - moeoNSGAII (eoContinue < MOEOT > & _continuator, eoEvalFunc < MOEOT > & _eval, eoGenOp < MOEOT > & _op) : - continuator(_continuator), popEval(_eval), select(2), - replace(fitnessAssignment, diversityAssignment), genBreed(select, _op), breed(genBreed) - {} - - - /** - * Ctor with a continuator (instead of _maxGen) and a eoTransform. - * @param _continuator stopping criteria - * @param _eval evaluation function - * @param _op variation operator - */ - moeoNSGAII (eoContinue < MOEOT > & _continuator, eoEvalFunc < MOEOT > & _eval, eoTransform < MOEOT > & _op) : - continuator(_continuator), popEval(_eval), select(2), - replace(fitnessAssignment, diversityAssignment), genBreed(select, _op), breed(genBreed) - {} - - - /** - * Apply a few generation of evolution to the population _pop until the stopping criteria is verified. - * @param _pop the population - */ - virtual void operator () (eoPop < MOEOT > &_pop) - { - eoPop < MOEOT > offspring, empty_pop; - popEval (empty_pop, _pop); // a first eval of _pop - // evaluate fitness and diversity - fitnessAssignment(_pop); - diversityAssignment(_pop); - do - { - // generate offspring, worths are recalculated if necessary - breed (_pop, offspring); - // eval of offspring - popEval (_pop, offspring); - // after replace, the new pop is in _pop. Worths are recalculated if necessary - replace (_pop, offspring); - } while (continuator (_pop)); - } - - -protected: - - /** a continuator based on the number of generations (used as default) */ - eoGenContinue < MOEOT > defaultGenContinuator; - /** stopping criteria */ - eoContinue < MOEOT > & continuator; - /** evaluation function used to evaluate the whole population */ - eoPopLoopEval < MOEOT > popEval; - /** binary tournament selection */ - moeoDetTournamentSelect < MOEOT > select; - /** fitness assignment used in NSGA-II */ - moeoFastNonDominatedSortingFitnessAssignment < MOEOT > fitnessAssignment; - /** diversity assignment used in NSGA-II */ - moeoFrontByFrontCrowdingDistanceDiversityAssignment < MOEOT > diversityAssignment; - /** elitist replacement */ - moeoElitistReplacement < MOEOT > replace; - /** an object for genetic operators (used as default) */ - eoSGAGenOp < MOEOT > defaultSGAGenOp; - /** general breeder */ - eoGeneralBreeder < MOEOT > genBreed; - /** breeder */ - eoBreed < MOEOT > & breed; - -}; - -#endif /*MOEONSGAII_H_*/ diff --git a/branches/paradiseo-moeo-1.0/src/moeoObjectiveVector.h b/branches/paradiseo-moeo-1.0/src/moeoObjectiveVector.h deleted file mode 100644 index d6876c364..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoObjectiveVector.h +++ /dev/null @@ -1,237 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoObjectiveVector.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEOOBJECTIVEVECTOR_H_ -#define MOEOOBJECTIVEVECTOR_H_ - -#include -#include -#include -#include - -/** - * Abstract class allowing to represent a solution in the objective space (phenotypic representation). - * The template argument ObjectiveVectorTraits defaults to moeoObjectiveVectorTraits, - * 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. - */ -template < class ObjectiveVectorTraits, class ObjectiveVectorType > -class moeoObjectiveVector : public std::vector < ObjectiveVectorType > -{ -public: - - /** The traits of objective vectors */ - typedef ObjectiveVectorTraits Traits; - /** The type of an objective value */ - typedef ObjectiveVectorType Type; - - - /** - * Ctor - */ - moeoObjectiveVector(Type _value = Type()) : std::vector < Type > (ObjectiveVectorTraits::nObjectives(), _value) - {} - - - /** - * Ctor from a vector of Type - * @param _v the std::vector < Type > - */ - moeoObjectiveVector(std::vector < Type > & _v) : std::vector < Type > (_v) - {} - - - /** - * Parameters setting (for the objective vector of any solution) - * @param _nObjectives the number of objectives - * @param _bObjectives the min/max vector (true = min / false = max) - */ - static void setup(unsigned _nObjectives, std::vector < bool > & _bObjectives) - { - ObjectiveVectorTraits::setup(_nObjectives, _bObjectives); - } - - - /** - * Returns the number of objectives - */ - static unsigned nObjectives() - { - return ObjectiveVectorTraits::nObjectives(); - } - - - /** - * Returns true if the _ith objective have to be minimized - * @param _i the index - */ - static bool minimizing(unsigned _i) { - return ObjectiveVectorTraits::minimizing(_i); - } - - - /** - * Returns true if the _ith objective have to be maximized - * @param _i the index - */ - static bool maximizing(unsigned _i) { - return ObjectiveVectorTraits::maximizing(_i); - } - -}; - - -/** - * 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. - */ -template < class ObjectiveVectorTraits > -class moeoObjectiveVectorDouble : public moeoObjectiveVector < ObjectiveVectorTraits, double > -{ -public: - - using moeoObjectiveVector < ObjectiveVectorTraits, double >::size; - using moeoObjectiveVector < ObjectiveVectorTraits, double >::operator[]; - - /** - * Ctor - */ - moeoObjectiveVectorDouble(double _value = 0.0) : moeoObjectiveVector < ObjectiveVectorTraits, double > (_value) - {} - - - /** - * Ctor from a vector of doubles - * @param _v the std::vector < double > - */ - moeoObjectiveVectorDouble(std::vector < double > & _v) : moeoObjectiveVector < ObjectiveVectorTraits, double > (_v) - {} - - - /** - * 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) - * @param _other the other moeoObjectiveVectorDouble object to compare with - */ - bool dominates(const moeoObjectiveVectorDouble < ObjectiveVectorTraits > & _other) const - { - moeoParetoObjectiveVectorComparator < moeoObjectiveVectorDouble > comparator; - return comparator(_other, *this); - } - - - /** - * 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 - */ - bool operator==(const moeoObjectiveVectorDouble < ObjectiveVectorTraits > & _other) const - { - for (unsigned i=0; i < size(); i++) - { - if ( fabs(operator[](i) - _other[i]) > ObjectiveVectorTraits::tolerance() ) - { - return false; - } - } - return true; - } - - - /** - * 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 - */ - bool operator!=(const moeoObjectiveVectorDouble < ObjectiveVectorTraits > & _other) const - { - 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 - * (can be usefull for sorting/printing) - * @param _other the other moeoObjectiveVectorDouble object to compare with - */ - bool operator<(const moeoObjectiveVectorDouble < ObjectiveVectorTraits > & _other) const - { - moeoObjectiveObjectiveVectorComparator < moeoObjectiveVectorDouble < ObjectiveVectorTraits > > cmp; - return cmp(*this, _other); - } - - - /** - * 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) - * @param _other the other moeoObjectiveVectorDouble object to compare with - */ - bool operator>(const moeoObjectiveVectorDouble < ObjectiveVectorTraits > & _other) const - { - 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 - * (can be usefull for sorting/printing) - * @param _other the other moeoObjectiveVectorDouble object to compare with - */ - bool operator<=(const moeoObjectiveVectorDouble < ObjectiveVectorTraits > & _other) const - { - 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 - * (can be usefull for sorting/printing) - * @param _other the other moeoObjectiveVectorDouble object to compare with - */ - bool operator>=(const moeoObjectiveVectorDouble < ObjectiveVectorTraits > & _other) const - { - return operator==(_other) || operator>(_other); - } - -}; - - -/** - * Output for a moeoObjectiveVectorDouble object - * @param _os output stream - * @param _objectiveVector the objective vector to write - */ -template < class ObjectiveVectorTraits > -std::ostream & operator<<(std::ostream & _os, const moeoObjectiveVectorDouble < ObjectiveVectorTraits > & _objectiveVector) -{ - for (unsigned i=0; i<_objectiveVector.size(); i++) - { - _os << _objectiveVector[i] << '\t'; - } - return _os; -} - -/** - * Input for a moeoObjectiveVectorDouble object - * @param _is input stream - * @param _objectiveVector the objective vector to read - */ -template < class ObjectiveVectorTraits > -std::istream & operator>>(std::istream & _is, moeoObjectiveVectorDouble < ObjectiveVectorTraits > & _objectiveVector) -{ - _objectiveVector = moeoObjectiveVectorDouble < ObjectiveVectorTraits > (); - for (unsigned i=0; i<_objectiveVector.size(); i++) - { - _is >> _objectiveVector[i]; - } - return _is; -} - -#endif /*MOEOOBJECTIVEVECTOR_H_*/ diff --git a/branches/paradiseo-moeo-1.0/src/moeoObjectiveVectorComparator.h b/branches/paradiseo-moeo-1.0/src/moeoObjectiveVectorComparator.h deleted file mode 100644 index 18dcc3108..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoObjectiveVectorComparator.h +++ /dev/null @@ -1,200 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoObjectiveVectorComparator.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEOOBJECTIVEVECTORCOMPARATOR_H_ -#define MOEOOBJECTIVEVECTORCOMPARATOR_H_ - -#include -#include - -/** - * Abstract class allowing to compare 2 objective vectors. - * The template argument ObjectiveVector have to be a moeoObjectiveVector. - */ -template < class ObjectiveVector > -class moeoObjectiveVectorComparator : public eoBF < const ObjectiveVector &, const ObjectiveVector &, const bool > - {}; - - -/** - * Functor allowing to compare two objective vectors according to their first objective value, then their second, and so on. - */ -template < class ObjectiveVector > -class moeoObjectiveObjectiveVectorComparator : public moeoObjectiveVectorComparator < ObjectiveVector > -{ -public: - - /** - * Returns true if _objectiveVector1 < _objectiveVector2 on the first objective, then on the second, and so on - * @param _objectiveVector1 the first objective vector - * @param _objectiveVector2 the second objective vector - */ - const bool operator()(const ObjectiveVector & _objectiveVector1, const ObjectiveVector & _objectiveVector2) - { - for (unsigned i=0; i ObjectiveVector::Traits::tolerance() ) - { - if (_objectiveVector1[i] < _objectiveVector2[i]) - { - return true; - } - else - { - return false; - } - } - } - return false; - } - -}; - - -/** - * This functor class allows to compare 2 objective vectors according to Pareto dominance. - */ -template < class ObjectiveVector > -class moeoParetoObjectiveVectorComparator : public moeoObjectiveVectorComparator < ObjectiveVector > -{ -public: - - /** - * Returns true if _objectiveVector1 is dominated by _objectiveVector2 - * @param _objectiveVector1 the first objective vector - * @param _objectiveVector2 the second objective vector - */ - const bool operator()(const ObjectiveVector & _objectiveVector1, const ObjectiveVector & _objectiveVector2) - { - bool dom = false; - for (unsigned i=0; i ObjectiveVector::Traits::tolerance() ) - { - // if the ith objective have to be minimized... - if (ObjectiveVector::minimizing(i)) - { - if (_objectiveVector1[i] > _objectiveVector2[i]) - { - dom = true; //_objectiveVector1[i] is not better than _objectiveVector2[i] - } - else - { - return false; //_objectiveVector2 cannot dominate _objectiveVector1 - } - } - // if the ith objective have to be maximized... - else if (ObjectiveVector::maximizing(i)) - { - if (_objectiveVector1[i] > _objectiveVector2[i]) - { - dom = true; //_objectiveVector1[i] is not better than _objectiveVector2[i] - } - else - { - return false; //_objectiveVector2 cannot dominate _objectiveVector1 - } - } - } - } - return dom; - } - -}; - - -/** - * This functor class allows to compare 2 objective vectors according to g-dominance. - * The concept of g-dominance as been introduced in: - * J. Molina, L. V. Santana, A. G. Hernandez-Diaz, C. A. Coello Coello, R. Caballero, - * "g-dominance: Reference point based dominance" (2007) - */ -template < class ObjectiveVector > -class moeoGDominanceObjectiveVectorComparator : public moeoObjectiveVectorComparator < ObjectiveVector > -{ -public: - - /** - * Ctor. - * @param _ref the reference point - */ - moeoGDominanceObjectiveVectorComparator(ObjectiveVector & _ref) : ref(_ref) - {} - - - /** - * Returns true if _objectiveVector1 is g-dominated by _objectiveVector2. - * @param _objectiveVector1 the first objective vector - * @param _objectiveVector2 the second objective vector - */ - const bool operator()(const ObjectiveVector & _objectiveVector1, const ObjectiveVector & _objectiveVector2) - { - unsigned flag1 = flag(_objectiveVector1); - unsigned flag2 = flag(_objectiveVector2); - if (flag2==0) - { - // cannot dominate - return false; - } - else if ( (flag2==1) && (flag1==0) ) - { - // is dominated - return true; - } - else // (flag1==1) && (flag2==1) - { - // both are on the good region, so let's use the classical Pareto dominance - return paretoComparator(_objectiveVector1, _objectiveVector2); - } - } - - -private: - - /** the reference point */ - ObjectiveVector & ref; - /** Pareto comparator */ - moeoParetoObjectiveVectorComparator < ObjectiveVector > paretoComparator; - - - /** - * Returns the flag of _objectiveVector according to the reference point - * @param _objectiveVector the first objective vector - */ - unsigned flag(const ObjectiveVector & _objectiveVector) - { - unsigned result=1; - for (unsigned i=0; i ref[i]) - { - result=0; - } - } - if (result==0) - { - result=1; - for (unsigned i=0; i -#include -#include - -/** - * A traits class for moeoObjectiveVector to specify the number of objectives and which ones have to be minimized or maximized. - */ -class moeoObjectiveVectorTraits -{ -public: - - /** - * Parameters setting - * @param _nObjectives the number of objectives - * @param _bObjectives the min/max vector (true = min / false = max) - */ - static void setup(unsigned _nObjectives, std::vector < bool > & _bObjectives) - { - // in case the number of objectives was already set to a different value - if ( nObj && (nObj != _nObjectives) ) { - std::cout << "WARNING\n"; - std::cout << "WARNING : the number of objectives are changing\n"; - std::cout << "WARNING : Make sure all existing objects are destroyed\n"; - std::cout << "WARNING\n"; - } - // number of objectives - nObj = _nObjectives; - // min/max vector - bObj = _bObjectives; - // 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 - */ - static unsigned nObjectives() - { - // in case the number of objectives would not be assigned yet - if (! nObj) - throw std::runtime_error("Number of objectives not assigned in moeoObjectiveVectorTraits"); - return nObj; - } - - /** - * Returns true if the _ith objective have to be minimized - * @param _i the index - */ - static bool minimizing(unsigned _i) - { - // 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 - * @param _i the index - */ - static bool maximizing(unsigned _i) { - return (! minimizing(_i)); - } - - /** - * Returns the tolerance value (to compare solutions) - */ - static double tolerance() - { - return 1e-6; - } - - -private: - - /** The number of objectives */ - static unsigned nObj; - /** The min/max vector */ - static std::vector < bool > bObj; - -}; - - -// The static variables of the moeoObjectiveVectorTraits class need to be allocated -unsigned moeoObjectiveVectorTraits::nObj; -std::vector < bool > moeoObjectiveVectorTraits::bObj; - - -#endif /*MOEOOBJECTIVEVECTORTRAITS_H_*/ diff --git a/branches/paradiseo-moeo-1.0/src/moeoRandomSelect.h b/branches/paradiseo-moeo-1.0/src/moeoRandomSelect.h deleted file mode 100644 index 04d7cfcc0..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoRandomSelect.h +++ /dev/null @@ -1,42 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoRandomSelect.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEORANDOMSELECT_H_ -#define MOEORANDOMSELECT_H_ - -#include -#include - -/** - * Selection strategy that selects only one element randomly from a whole population. - */ -template < class MOEOT > class moeoRandomSelect:public moeoSelectOne < MOEOT >, public eoRandomSelect -{ -public: - - /** - * Ctor. - */ - moeoRandomSelect(){} - - - /** - * Return one individual at random by using an eoRandomSelect. - */ - const MOEOT & operator () (const eoPop < MOEOT > &_pop) - { - return eoRandomSelect < MOEOT >::operator ()(_pop); - } - -}; - -#endif /*MOEORANDOMSELECT_H_ */ diff --git a/branches/paradiseo-moeo-1.0/src/moeoReferencePointIndicatorBasedFitnessAssignment.h b/branches/paradiseo-moeo-1.0/src/moeoReferencePointIndicatorBasedFitnessAssignment.h deleted file mode 100755 index f000b844c..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoReferencePointIndicatorBasedFitnessAssignment.h +++ /dev/null @@ -1,109 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoReferencePointIndicatorBasedFitnessAssignment.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEOREFERENCEPOINTINDICATORBASEDFITNESSASSIGNMENT_H_ -#define MOEOREFERENCEPOINTINDICATORBASEDFITNESSASSIGNMENT_H_ - -#include -#include -#include -#include - -/** - * Fitness assignment sheme based a Reference Point and a Quality Indicator. - */ -template < class MOEOT > -class moeoReferencePointIndicatorBasedFitnessAssignment : public moeoFitnessAssignment < MOEOT > -{ -public: - - /** The type of objective vector */ - typedef typename MOEOT::ObjectiveVector ObjectiveVector; - - /** - * Ctor - * @param _refPoint the reference point - * @param _metric the quality indicator - */ - moeoReferencePointIndicatorBasedFitnessAssignment (ObjectiveVector & _refPoint, moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > & _metric) : - refPoint(_refPoint), metric(_metric) - {} - - - /** - * Sets the fitness values for every solution contained in the population _pop - * @param _pop the population - */ - void operator()(eoPop < MOEOT > & _pop) - { - // 1 - setting of the bounds - setup(_pop); - // 2 - setting fitnesses - setFitnesses(_pop); - } - - - /** - * Updates the fitness values of the whole population _pop by taking the deletion of the objective vector _objVec into account. - * @param _pop the population - * @param _objVec the objective vector - */ - void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec) - { - // nothing to do ;-) - } - - -protected: - - /** the reference point */ - ObjectiveVector & refPoint; - /** the quality indicator */ - moeoNormalizedSolutionVsSolutionBinaryMetric < ObjectiveVector, double > & metric; - - - /** - * Sets the bounds for every objective using the min and the max value for every objective vector of _pop (and the reference point) - * @param _pop the population - */ - void setup(const eoPop < MOEOT > & _pop) - { - double min, max; - for (unsigned i=0; i & _pop) - { - for (unsigned i=0; i<_pop.size(); i++) - { - _pop[i].fitness(- metric(_pop[i].objectiveVector(), refPoint) ); - } - } - -}; - -#endif /*MOEOREFERENCEPOINTINDICATORBASEDFITNESSASSIGNMENT_H_*/ diff --git a/branches/paradiseo-moeo-1.0/src/moeoReplacement.h b/branches/paradiseo-moeo-1.0/src/moeoReplacement.h deleted file mode 100644 index 708529db0..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoReplacement.h +++ /dev/null @@ -1,25 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoReplacement.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEOREPLACEMENT_H_ -#define MOEOREPLACEMENT_H_ - -#include - -/** - * Replacement strategy for multi-objective optimization. - */ -template < class MOEOT > -class moeoReplacement : public eoReplacement < MOEOT > - {}; - -#endif /*MOEOREPLACEMENT_H_*/ diff --git a/branches/paradiseo-moeo-1.0/src/moeoRouletteSelect.h b/branches/paradiseo-moeo-1.0/src/moeoRouletteSelect.h deleted file mode 100644 index 58b6a25d5..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoRouletteSelect.h +++ /dev/null @@ -1,62 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoRouletteSelect.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEOROULETTESELECT_H_ -#define MOEOROULETTESELECT_H_ - -#include -#include - -/** - * Selection strategy that selects ONE individual by using roulette wheel process. - * @WARNING This selection only uses fitness values (and not diversity values). - */ -template < class MOEOT > -class moeoRouletteSelect:public moeoSelectOne < MOEOT > -{ -public: - - /** - * Ctor. - * @param _tSize the number of individuals in the tournament (default: 2) - */ - moeoRouletteSelect (unsigned _tSize = 2) : tSize (_tSize) - { - // consistency check - if (tSize < 2) - { - std:: - cout << "Warning, Tournament size should be >= 2\nAdjusted to 2\n"; - tSize = 2; - } - } - - - /** - * Apply the tournament to the given population - * @param _pop the population - */ - const MOEOT & operator () (const eoPop < MOEOT > & _pop) - { - // use the selector - return mo_roulette_wheel(_pop,tSize); - } - - -protected: - - /** size */ - double & tSize; - -}; - -#endif /*MOEOROULETTESELECT_H_ */ diff --git a/branches/paradiseo-moeo-1.0/src/moeoSelectFromPopAndArch.h b/branches/paradiseo-moeo-1.0/src/moeoSelectFromPopAndArch.h deleted file mode 100644 index ad2d0482d..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoSelectFromPopAndArch.h +++ /dev/null @@ -1,89 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoSelectFormPopAndArch.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEOSELECTONEFROMPOPANDARCH_H_ -#define MOEOSELECTONEFROMPOPANDARCH_H_ - -#include -#include -#include -#include -#include - -/** - * Elitist selection process that consists in choosing individuals in the archive as well as in the current population. - */ -template < class MOEOT > -class moeoSelectFromPopAndArch : public moeoSelectOne < MOEOT > -{ -public: - - /** - * Ctor - * @param _popSelectOne the population's selection operator - * @param _archSelectOne the archive's selection operator - * @param _arch the archive - * @param _ratioFromPop the ratio of selected individuals from the population - */ - moeoSelectFromPopAndArch (moeoSelectOne < MOEOT > & _popSelectOne, moeoSelectOne < MOEOT > _archSelectOne, moeoArchive < MOEOT > & _arch, double _ratioFromPop=0.5) - : popSelectOne(_popSelectOne), archSelectOne(_archSelectOne), arch(_arch), ratioFromPop(_ratioFromPop) - {} - - /** - * Defaulr ctor - the archive's selection operator is a random selector - * @param _popSelectOne the population's selection operator - * @param _arch the archive - * @param _ratioFromPop the ratio of selected individuals from the population - */ - moeoSelectFromPopAndArch (moeoSelectOne < MOEOT > & _popSelectOne, moeoArchive < MOEOT > & _arch, double _ratioFromPop=0.5) - : popSelectOne(_popSelectOne), archSelectOne(randomSelectOne), arch(_arch), ratioFromPop(_ratioFromPop) - {} - - /** - * The selection process - */ - virtual const MOEOT & operator () (const eoPop < MOEOT > & pop) - { - if (arch.size() > 0) - if (rng.flip(ratioFromPop)) - return popSelectOne(pop); - else - return archSelectOne(arch); - else - return popSelectOne(pop); - } - - /** - * Setups some population stats - */ - virtual void setup (const eoPop < MOEOT > & _pop) - { - popSelectOne.setup(_pop); - } - - -private: - - /** The population's selection operator */ - moeoSelectOne < MOEOT > & popSelectOne; - /** The archive's selection operator */ - moeoSelectOne < MOEOT > & archSelectOne; - /** The archive */ - moeoArchive < MOEOT > & arch; - /** The ratio of selected individuals from the population*/ - double ratioFromPop; - /** A random selection operator (used as default for archSelectOne) */ - moeoRandomSelect < MOEOT > randomSelectOne; - -}; - -#endif /*MOEOSELECTONEFROMPOPANDARCH_H_*/ diff --git a/branches/paradiseo-moeo-1.0/src/moeoSelectOne.h b/branches/paradiseo-moeo-1.0/src/moeoSelectOne.h deleted file mode 100644 index 7f4129b99..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoSelectOne.h +++ /dev/null @@ -1,24 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoSelectOne.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEOSELECTONE_H_ -#define MOEOSELECTONE_H_ - -#include - -/** - * Selection strategy for multi-objective optimization that selects only one element from a whole population. - */ -template < class MOEOT > -class moeoSelectOne : public eoSelectOne < MOEOT > {}; - -#endif /*MOEOSELECTONE_H_*/ diff --git a/branches/paradiseo-moeo-1.0/src/moeoSelectors.h b/branches/paradiseo-moeo-1.0/src/moeoSelectors.h deleted file mode 100644 index b6d61641a..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoSelectors.h +++ /dev/null @@ -1,154 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoSelectors.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEOSELECTORS_H_ -#define MOEOSELECTORS_H_ - -#include - - -template -It mo_deterministic_tournament(It _begin, It _end, unsigned _t_size,moeoComparator& _comparator ,eoRng& _gen = rng) -{ - It best = _begin + _gen.random(_end - _begin); - - for (unsigned i = 0; i < _t_size - 1; ++i) - { - It competitor = _begin + _gen.random(_end - _begin); - // compare the two individuals by using the comparator - if (_comparator(*best, *competitor)) - // best "better" than competitor - best=competitor; - } - return best; -} - - -template -const MOEOT& mo_deterministic_tournament(const eoPop& _pop, unsigned _t_size,moeoComparator& _comparator, eoRng& _gen = rng) -{ - return *mo_deterministic_tournament(_pop.begin(), _pop.end(),_t_size,_comparator, _gen); -} - -template -MOEOT& mo_deterministic_tournament(eoPop& _pop, unsigned _t_size,moeoComparator& _comparator,eoRng& _gen = rng) -{ - return *mo_deterministic_tournament(_pop.begin(), _pop.end(), _t_size,_comparator, _gen); -} - - - -template -It mo_stochastic_tournament(It _begin, It _end, double _t_rate,moeoComparator& _comparator ,eoRng& _gen = rng) -{ - It i1 = _begin + _gen.random(_end - _begin); - It i2 = _begin + _gen.random(_end - _begin); - - bool return_better = _gen.flip(_t_rate); - - if (_comparator(*i1, *i2)) - { - if (return_better) return i2; - // else - - return i1; - } - else - { - if (return_better) return i1; - // else - } - // else - - return i2; -} - -template -const MOEOT& mo_stochastic_tournament(const eoPop& _pop, double _t_rate,moeoComparator& _comparator, eoRng& _gen = rng) -{ - return *mo_stochastic_tournament(_pop.begin(), _pop.end(), _t_rate,_comparator, _gen); -} - -template -MOEOT& mo_stochastic_tournament(eoPop& _pop, double _t_rate, eoRng& _gen = rng) -{ - return *mo_stochastic_tournament(_pop.begin(), _pop.end(), _t_rate, _gen); -} - - - -template -It mo_roulette_wheel(It _begin, It _end, double total, eoRng& _gen = rng) -{ - - float roulette = _gen.uniform(total); - - if (roulette == 0.0) // covers the case where total==0.0 - return _begin + _gen.random(_end - _begin); // uniform choice - - It i = _begin; - - while (roulette > 0.0) - { - roulette -= static_cast(*(i++)); - } - - return --i; -} - -template -const MOEOT& mo_roulette_wheel(const eoPop& _pop, double total, eoRng& _gen = rng) -{ - float roulette = _gen.uniform(total); - - if (roulette == 0.0) // covers the case where total==0.0 - return _pop[_gen.random(_pop.size())]; // uniform choice - - typename eoPop::const_iterator i = _pop.begin(); - - while (roulette > 0.0) - { - roulette -= static_cast((i++)->fitness()); - } - - return *--i; -} - -template -MOEOT& mo_roulette_wheel(eoPop& _pop, double total, eoRng& _gen = rng) -{ - float roulette = _gen.uniform(total); - - if (roulette == 0.0) // covers the case where total==0.0 - return _pop[_gen.random(_pop.size())]; // uniform choice - - typename eoPop::iterator i = _pop.begin(); - - while (roulette > 0.0) - { - // fitness only - roulette -= static_cast((i++)->fitness()); - } - - return *--i; -} - -#endif /*MOEOSELECTORS_H_*/ - - - - - - - - - diff --git a/branches/paradiseo-moeo-1.0/src/moeoSharingDiversityAssignment.h b/branches/paradiseo-moeo-1.0/src/moeoSharingDiversityAssignment.h deleted file mode 100644 index eaed81b96..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoSharingDiversityAssignment.h +++ /dev/null @@ -1,229 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoSharingDiversityAssignment.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEOSHARINGDIVERSITYASSIGNMENT_H_ -#define MOEOSHARINGDIVERSITYASSIGNMENT_H_ - -#include -#include -#include -#include -#include - -/** - * Sharing assignment scheme originally porposed by: - * D. E. Goldberg, "Genetic Algorithms in Search, Optimization and Machine Learning", Addision-Wesley, MA, USA (1989). - */ -template < class MOEOT > -class moeoSharingDiversityAssignment : public moeoDiversityAssignment < MOEOT > -{ -public: - - /** the objective vector type of the solutions */ - typedef typename MOEOT::ObjectiveVector ObjectiveVector; - - - /** - * Ctor - * @param _distance the distance used to compute the neighborhood of solutions (can be related to the decision space or the objective space) - * @param _nicheSize neighborhood size in terms of radius distance (closely related to the way the distances are computed) - * @param _alpha parameter used to regulate the shape of the sharing function - */ - moeoSharingDiversityAssignment(moeoDistance & _distance, double _nicheSize = 0.5, double _alpha = 1.0) : distance(_distance), nicheSize(_nicheSize), alpha(_alpha) - {} - - - /** - * Ctor with an euclidean distance (with normalized objective values) in the objective space is used as default - * @param _nicheSize neighborhood size in terms of radius distance (closely related to the way the distances are computed) - * @param _alpha parameter used to regulate the shape of the sharing function - */ - moeoSharingDiversityAssignment(double _nicheSize = 0.5, double _alpha = 1.0) : distance(defaultDistance), nicheSize(_nicheSize), alpha(_alpha) - {} - - - /** - * Sets diversity values for every solution contained in the population _pop - * @param _pop the population - */ - void operator()(eoPop < MOEOT > & _pop) - { - // 1 - set simuilarities - setSimilarities(_pop); - // 2 - a higher diversity is better, so the values need to be inverted - moeoDiversityThenFitnessComparator < MOEOT > divComparator; - double max = std::max_element(_pop.begin(), _pop.end(), divComparator)->diversity(); - for (unsigned i=0 ; i<_pop.size() ; i++) - { - _pop[i].diversity(max - _pop[i].diversity()); - } - } - - - /** - * @warning NOT IMPLEMENTED, DO NOTHING ! - * Updates the diversity values of the whole population _pop by taking the deletion of the objective vector _objVec into account. - * @param _pop the population - * @param _objVec the objective vector - * @warning NOT IMPLEMENTED, DO NOTHING ! - */ - void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec) - { - cout << "WARNING : updateByDeleting not implemented in moeoSharingDiversityAssignment" << endl; - } - - -protected: - - /** the distance used to compute the neighborhood of solutions */ - moeoDistance < MOEOT , double > & distance; - /** euclidean distancein the objective space (can be used as default) */ - moeoEuclideanDistance < MOEOT > defaultDistance; - /** neighborhood size in terms of radius distance */ - double nicheSize; - /** parameter used to regulate the shape of the sharing function */ - double alpha; - - - /** - * Sets similarities for every solution contained in the population _pop - * @param _pop the population - */ - virtual void setSimilarities(eoPop < MOEOT > & _pop) - { - // compute distances between every individuals - moeoDistanceMatrix < MOEOT , double > dMatrix (_pop.size(), distance); - dMatrix(_pop); - // compute similarities - double sum; - for (unsigned i=0; i<_pop.size(); i++) - { - sum = 0.0; - for (unsigned j=0; j<_pop.size(); j++) - { - sum += sh(dMatrix[i][j]); - } - _pop[i].diversity(sum); - } - } - - - /** - * Sharing function - * @param _dist the distance value - */ - double sh(double _dist) - { - double result; - if (_dist < nicheSize) - { - result = 1.0 - pow(_dist / nicheSize, alpha); - } - else - { - result = 0.0; - } - return result; - } - -}; - - -/** - * Sharing assignment scheme on the way it is used in NSGA. - */ -template < class MOEOT > -class moeoFrontByFrontSharingDiversityAssignment : public moeoSharingDiversityAssignment < MOEOT > -{ -public: - - /** the objective vector type of the solutions */ - typedef typename MOEOT::ObjectiveVector ObjectiveVector; - - - /** - * Ctor - * @param _distance the distance used to compute the neighborhood of solutions (can be related to the decision space or the objective space) - * @param _nicheSize neighborhood size in terms of radius distance (closely related to the way the distances are computed) - * @param _alpha parameter used to regulate the shape of the sharing function - */ - moeoFrontByFrontSharingDiversityAssignment(moeoDistance & _distance, double _nicheSize = 0.5, double _alpha = 2.0) : moeoSharingDiversityAssignment < MOEOT >(_distance, _nicheSize, _alpha) - {} - - - /** - * Ctor with an euclidean distance (with normalized objective values) in the objective space is used as default - * @param _nicheSize neighborhood size in terms of radius distance (closely related to the way the distances are computed) - * @param _alpha parameter used to regulate the shape of the sharing function - */ - moeoFrontByFrontSharingDiversityAssignment(double _nicheSize = 0.5, double _alpha = 2.0) : moeoSharingDiversityAssignment < MOEOT >(_nicheSize, _alpha) - {} - - - /** - * @warning NOT IMPLEMENTED, DO NOTHING ! - * Updates the diversity values of the whole population _pop by taking the deletion of the objective vector _objVec into account. - * @param _pop the population - * @param _objVec the objective vector - * @warning NOT IMPLEMENTED, DO NOTHING ! - */ - void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec) - { - cout << "WARNING : updateByDeleting not implemented in moeoSharingDiversityAssignment" << endl; - } - - -private: - - using moeoSharingDiversityAssignment < MOEOT >::distance; - using moeoSharingDiversityAssignment < MOEOT >::nicheSize; - using moeoSharingDiversityAssignment < MOEOT >::sh; - using moeoSharingDiversityAssignment < MOEOT >::operator(); - - - /** - * Sets similarities FRONT BY FRONT for every solution contained in the population _pop - * @param _pop the population - */ - void setSimilarities(eoPop < MOEOT > & _pop) - { - // compute distances between every individuals - moeoDistanceMatrix < MOEOT , double > dMatrix (_pop.size(), distance); - dMatrix(_pop); - // sets the distance to bigger than the niche size for every couple of solutions that do not belong to the same front - for (unsigned i=0; i<_pop.size(); i++) - { - for (unsigned j=0; j -#include - -/** - * Selection strategy that selects ONE individual by stochastic tournament. - */ -template < class MOEOT > class moeoStochTournamentSelect:public moeoSelectOne -{ -public: - - /** - * Full Ctor - * @param _comparator the comparator (used to compare 2 individuals) - * @param _tRate the tournament rate - */ - moeoStochTournamentSelect (moeoComparator < MOEOT > & _comparator, double _tRate = 1.0) : comparator (_comparator), tRate (_tRate) - { - // consistency checks - if (tRate < 0.5) - { - std::cerr << "Warning, Tournament rate should be > 0.5\nAdjusted to 0.55\n"; - tRate = 0.55; - } - if (tRate > 1) - { - std::cerr << "Warning, Tournament rate should be < 1\nAdjusted to 1\n"; - tRate = 1; - } - } - - /** - * Ctor without comparator. A moeoFitnessThenDiversityComparator is used as default. - * @param _tRate the tournament rate - */ - moeoStochTournamentSelect (double _tRate = 1.0) : comparator (defaultComparator), tRate (_tRate) - { - // consistency checks - if (tRate < 0.5) - { - std::cerr << "Warning, Tournament rate should be > 0.5\nAdjusted to 0.55\n"; - tRate = 0.55; - } - if (tRate > 1) - { - std::cerr << "Warning, Tournament rate should be < 1\nAdjusted to 1\n"; - tRate = 1; - } - } - - - /** - * Apply the tournament to the given population - * @param _pop the population - */ - const MOEOT & operator() (const eoPop < MOEOT > &_pop) - { - // use the selector - return mo_stochastic_tournament(_pop,tRate,comparator); - } - - -protected: - - /** the comparator (used to compare 2 individuals) */ - moeoComparator < MOEOT > & comparator; - /** a fitness then diversity comparator can be used as default */ - moeoFitnessThenDiversityComparator < MOEOT > defaultComparator; - /** the tournament rate */ - double tRate; - -}; - -#endif /*MOEOSTOCHTOURNAMENTSELECT_H_ */ diff --git a/branches/paradiseo-moeo-1.0/src/moeoVector.h b/branches/paradiseo-moeo-1.0/src/moeoVector.h deleted file mode 100644 index 404a54ad3..000000000 --- a/branches/paradiseo-moeo-1.0/src/moeoVector.h +++ /dev/null @@ -1,216 +0,0 @@ -// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- - -//----------------------------------------------------------------------------- -// moeoVector.h -// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007 -/* - This library... - - Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr - */ -//----------------------------------------------------------------------------- - -#ifndef MOEOVECTOR_H_ -#define MOEOVECTOR_H_ - -#include -#include -#include - -/** - * Base class for fixed length chromosomes, just derives from MOEO and std::vector and redirects the smaller than operator to MOEO (objective vector based comparison). - * GeneType must have the following methods: void ctor (needed for the std::vector<>), copy ctor. - */ -template < class MOEOObjectiveVector, class MOEOFitness, class MOEODiversity, class GeneType > -class moeoVector : public MOEO < MOEOObjectiveVector, MOEOFitness, MOEODiversity >, public std::vector < GeneType > -{ -public: - - using MOEO < MOEOObjectiveVector, MOEOFitness, MOEODiversity > :: invalidate; - using std::vector < GeneType > :: operator[]; - using std::vector < GeneType > :: begin; - using std::vector < GeneType > :: end; - using std::vector < GeneType > :: resize; - using std::vector < GeneType > :: size; - - /** the atomic type */ - typedef GeneType AtomType; - /** the container type */ - typedef std::vector < GeneType > ContainerType; - - - /** - * Default ctor. - * @param _size Length of vector (default is 0) - * @param _value Initial value of all elements (default is default value of type GeneType) - */ - moeoVector(unsigned _size = 0, GeneType _value = GeneType()) : - MOEO < MOEOObjectiveVector, MOEOFitness, MOEODiversity >(), std::vector(_size, _value) - {} - - - /** - * We can't have a Ctor from a std::vector as it would create ambiguity with the copy Ctor. - * @param _v a vector of GeneType - */ - void value(const std::vector < GeneType > & _v) - { - if (_v.size() != size()) // safety check - { - if (size()) // NOT an initial empty std::vector - { - std::cout << "Warning: Changing size in moeoVector assignation"<::operator< - * @param _moeo the object to compare with - */ - bool operator<(const moeoVector< MOEOObjectiveVector, MOEOFitness, MOEODiversity, GeneType> & _moeo) const - { - return MOEO < MOEOObjectiveVector, MOEOFitness, MOEODiversity >::operator<(_moeo); - } - - - /** - * Writing object - * @param _os output stream - */ - virtual void printOn(std::ostream & _os) const - { - MOEO < MOEOObjectiveVector, MOEOFitness, MOEODiversity >::printOn(_os); - _os << ' '; - _os << size() << ' '; - std::copy(begin(), end(), std::ostream_iterator(_os, " ")); - } - - - /** - * Reading object - * @param _is input stream - */ - virtual void readFrom(std::istream & _is) - { - MOEO < MOEOObjectiveVector, MOEOFitness, MOEODiversity >::readFrom(_is); - unsigned sz; - _is >> sz; - resize(sz); - unsigned i; - for (i = 0; i < sz; ++i) - { - AtomType atom; - _is >> atom; - operator[](i) = atom; - } - } - -}; - - -/** - * To avoid conflicts between MOEO::operator< and std::vector::operator< - * @param _moeo1 the first object to compare - * @param _moeo2 the second object to compare - */ -template < class MOEOObjectiveVector, class MOEOFitness, class MOEODiversity, class GeneType > -bool operator<(const moeoVector< MOEOObjectiveVector, MOEOFitness, MOEODiversity, GeneType> & _moeo1, const moeoVector< MOEOObjectiveVector, MOEOFitness, MOEODiversity, GeneType> & _moeo2) -{ - return _moeo1.operator<(_moeo2); -} - - -/** - * To avoid conflicts between MOEO::operator> and std::vector::operator> - * @param _moeo1 the first object to compare - * @param _moeo2 the second object to compare - */ -template < class MOEOObjectiveVector, class MOEOFitness, class MOEODiversity, class GeneType > -bool operator>(const moeoVector< MOEOObjectiveVector, MOEOFitness, MOEODiversity, GeneType> & _moeo1, const moeoVector< MOEOObjectiveVector, MOEOFitness, MOEODiversity, GeneType> & _moeo2) -{ - return _moeo1.operator>(_moeo2); -} - - -/** - * This class is an implementationeo of a simple double-valued moeoVector. - */ -template < class MOEOObjectiveVector, class MOEOFitness, class MOEODiversity > -class moeoRealVector : public moeoVector < MOEOObjectiveVector, MOEOFitness, MOEODiversity, double > -{ -public: - - /** - * Ctor - * @param _size Length of vector (default is 0) - * @param _value Initial value of all elements (default is default value of type GeneType) - */ - moeoRealVector(unsigned _size = 0, double _value = 0.0) : moeoVector< MOEOObjectiveVector, MOEOFitness, MOEODiversity, double >(_size, _value) - {} - -}; - - -/** - * This class is an implementationeo of a simple bit-valued moeoVector. - */ -template < class MOEOObjectiveVector, class MOEOFitness, class MOEODiversity > -class moeoBitVector : public moeoVector < MOEOObjectiveVector, MOEOFitness, MOEODiversity, bool > -{ -public: - - using moeoVector < MOEOObjectiveVector, MOEOFitness, MOEODiversity, bool > :: begin; - using moeoVector < MOEOObjectiveVector, MOEOFitness, MOEODiversity, bool > :: end; - using moeoVector < MOEOObjectiveVector, MOEOFitness, MOEODiversity, bool > :: resize; - using moeoVector < MOEOObjectiveVector, MOEOFitness, MOEODiversity, bool > :: size; - - - /** - * Ctor - * @param _size Length of vector (default is 0) - * @param _value Initial value of all elements (default is default value of type GeneType) - */ - moeoBitVector(unsigned _size = 0, bool _value = false) : moeoVector< MOEOObjectiveVector, MOEOFitness, MOEODiversity, bool >(_size, _value) - {} - - - /** - * Writing object - * @param _os output stream - */ - virtual void printOn(std::ostream & _os) const - { - MOEO < MOEOObjectiveVector, MOEOFitness, MOEODiversity >::printOn(_os); - _os << ' '; - _os << size() << ' '; - std::copy(begin(), end(), std::ostream_iterator(_os)); - } - - - /** - * Reading object - * @param _is input stream - */ - virtual void readFrom(std::istream & _is) - { - MOEO < MOEOObjectiveVector, MOEOFitness, MOEODiversity >::readFrom(_is); - unsigned s; - _is >> s; - std::string bits; - _is >> bits; - if (_is) - { - resize(bits.size()); - std::transform(bits.begin(), bits.end(), begin(), std::bind2nd(std::equal_to(), '1')); - } - } - -}; - - -#endif /*MOEOVECTOR_H_*/