diff --git a/trunk/paradiseo-moeo/src/distance/moeoAchievementScalarizingFunctionDistance.h b/trunk/paradiseo-moeo/src/distance/moeoAchievementScalarizingFunctionDistance.h new file mode 100644 index 000000000..192feae33 --- /dev/null +++ b/trunk/paradiseo-moeo/src/distance/moeoAchievementScalarizingFunctionDistance.h @@ -0,0 +1,109 @@ +/* + * + * Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007 + * (C) OPAC Team, LIFL, 2002-2007 + * + * Jeremie Humeau + * Arnaud Liefooghe + * François Legillon + * + * This software is governed by the CeCILL license under French law and + * abiding by the rules of distribution of free software. You can use, + * modify and/ or redistribute the software under the terms of the CeCILL + * license as circulated by CEA, CNRS and INRIA at the following URL + * "http://www.cecill.info". + * + * As a counterpart to the access to the source code and rights to copy, + * modify and redistribute granted by the license, users are provided only + * with a limited warranty and the software's author, the holder of the + * economic rights, and the successive licensors have only limited liability. + * + * In this respect, the user's attention is drawn to the risks associated + * with loading, using, modifying and/or developing or reproducing the + * software by the user in light of its specific status of free software, + * that may mean that it is complicated to manipulate, and that also + * therefore means that it is reserved for developers and experienced + * professionals having in-depth computer knowledge. Users are therefore + * encouraged to load and test the software's suitability as regards their + * requirements in conditions enabling the security of their systems and/or + * data to be ensured and, more generally, to use and operate it in the + * same conditions as regards security. + * The fact that you are presently reading this means that you have had + * knowledge of the CeCILL license and that you accept its terms. + * + * ParadisEO WebSite : http://paradiseo.gforge.inria.fr + * Contact: paradiseo-help@lists.gforge.inria.fr + * + */ +//----------------------------------------------------------------------------- +#ifndef MOEOASFADIST_H_ +#define MOEOASFADIST_H_ + +#include + +/** + Achievment scalarizing function aproach to calculate a distance + */ +template < class MOEOT> +class moeoAchievementScalarizingFunctionDistance : public moeoObjSpaceDistance< MOEOT > +{ + public: + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + typedef typename MOEOT::Fitness Fitness; + + /** + constructor with a normalizer + @param _rho + @param _weight the weight to apply to each dimension + @param _normalizer the normalizer + */ + moeoAchievementScalarizingFunctionDistance(unsigned int _rho, const ObjectiveVector& _weight, moeoObjectiveVectorNormalizer& _normalizer): normalizer(_normalizer), weight(_weight), rho(_rho){} + + /** + constructor without a normalizer + @param _rho + @param _weight the weight to apply to each dimension + */ + moeoAchievementScalarizingFunctionDistance(unsigned int _rho, const ObjectiveVector& _weight): normalizer(defaultNormalizer), weight(_weight), rho(_rho){} + + /** + fonction which calculate the distance + @param _obj the point to evaluate + @param _reference the reference to calculate the distance from + @return the fitness conrresponding to the distance + */ + const Fitness operator()(const ObjectiveVector& _reference, const ObjectiveVector& _obj){ + unsigned int dim=_obj.size(); + ObjectiveVector tmp1(_reference); + ObjectiveVector tmp2(_obj); + Fitness max=iteration(tmp2,tmp1,0,_obj.minimizing(0)); + Fitness res=max; + for (unsigned i=0;i defaultNormalizer; + moeoObjectiveVectorNormalizer &normalizer; + const ObjectiveVector &weight; + double rho; + + Fitness iteration(const ObjectiveVector &obj, const ObjectiveVector& reference, int dim, bool mini){ + ObjectiveVector obj_norm=normalizer(obj); + ObjectiveVector ref_norm=normalizer(reference); + Fitness res; + if (mini){ + res=(obj_norm[dim]-ref_norm[dim]); + }else{ + res=(ref_norm[dim]-obj_norm[dim]); + } + res=weight[dim]*res; + return res; + } +}; +#endif diff --git a/trunk/paradiseo-moeo/src/distance/moeoAugmentedAchievementScalarizingFunctionDistance.h b/trunk/paradiseo-moeo/src/distance/moeoAugmentedAchievementScalarizingFunctionDistance.h new file mode 100644 index 000000000..62120071a --- /dev/null +++ b/trunk/paradiseo-moeo/src/distance/moeoAugmentedAchievementScalarizingFunctionDistance.h @@ -0,0 +1,111 @@ +/* + * + * Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007 + * (C) OPAC Team, LIFL, 2002-2007 + * + * Jeremie Humeau + * Arnaud Liefooghe + * Legillon François + * + * This software is governed by the CeCILL license under French law and + * abiding by the rules of distribution of free software. You can use, + * modify and/ or redistribute the software under the terms of the CeCILL + * license as circulated by CEA, CNRS and INRIA at the following URL + * "http://www.cecill.info". + * + * As a counterpart to the access to the source code and rights to copy, + * modify and redistribute granted by the license, users are provided only + * with a limited warranty and the software's author, the holder of the + * economic rights, and the successive licensors have only limited liability. + * + * In this respect, the user's attention is drawn to the risks associated + * with loading, using, modifying and/or developing or reproducing the + * software by the user in light of its specific status of free software, + * that may mean that it is complicated to manipulate, and that also + * therefore means that it is reserved for developers and experienced + * professionals having in-depth computer knowledge. Users are therefore + * encouraged to load and test the software's suitability as regards their + * requirements in conditions enabling the security of their systems and/or + * data to be ensured and, more generally, to use and operate it in the + * same conditions as regards security. + * The fact that you are presently reading this means that you have had + * knowledge of the CeCILL license and that you accept its terms. + * + * ParadisEO WebSite : http://paradiseo.gforge.inria.fr + * Contact: paradiseo-help@lists.gforge.inria.fr + * + */ +//----------------------------------------------------------------------------- +#ifndef MOEOASFAORDIST_H_ +#define MOEOASFAORDIST_H_ + + +#include +#include +#include + +/** + Order representing Achievment scalarizing function aproach to calculate a metric + */ +template < class MOEOT> +class moeoAugmentedAchievementScalarizingFunctionDistance : public moeoObjSpaceDistance< MOEOT > +{ + public: + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + typedef typename MOEOT::Fitness Fitness; + /** + constructor with a normalizer + @param _rho + @param _weight the weight to apply to each dimansion + @param _normalizer the normalizer + */ + moeoAugmentedAchievementScalarizingFunctionDistance(unsigned int _rho,const ObjectiveVector &_weight,moeoObjectiveVectorNormalizer &_normalizer): normalizer(_normalizer),weight(_weight),rho(_rho) + {} + /** + constructor without a normalizer + @param _rho + @param _weight the weight to apply to each dimansion + */ + moeoAugmentedAchievementScalarizingFunctionDistance(unsigned int _rho,const ObjectiveVector &_weight): normalizer(defaultNormalizer),weight(_weight),rho(_rho) + {} + + + /** + fonction which apply the metric to calculate a fitness + @param _reference the reference point to calculate the distance + @param _obj the point to evaluate + @return the fitness conrresponding to the distance + */ + const Fitness operator()(const ObjectiveVector &_reference,const ObjectiveVector &_obj){ + unsigned int dim=_obj.size(); + Fitness res=0; + Fitness max=iteration(_obj,_reference,0,_obj.minimizing(0)); + for (unsigned i=0;i defaultNormalizer; + moeoObjectiveVectorNormalizer &normalizer; + const ObjectiveVector &weight; + double rho; + Fitness iteration(const ObjectiveVector &obj,const ObjectiveVector &reference,int dim,bool mini){ + ObjectiveVector obj_norm=normalizer(obj); + ObjectiveVector ref_norm=normalizer(reference); + Fitness res; + if (mini){ + res=obj_norm[dim]-ref_norm[dim]; + }else{ + + res=ref_norm[dim]-obj_norm[dim]; + } + res=weight[dim]*res; + return res; + } +}; +#endif diff --git a/trunk/paradiseo-moeo/src/distance/moeoAugmentedWeightedChebychevDistance.h b/trunk/paradiseo-moeo/src/distance/moeoAugmentedWeightedChebychevDistance.h new file mode 100644 index 000000000..098b3c817 --- /dev/null +++ b/trunk/paradiseo-moeo/src/distance/moeoAugmentedWeightedChebychevDistance.h @@ -0,0 +1,102 @@ +/* + * + * Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007 + * (C) OPAC Team, LIFL, 2002-2007 + * + * François Legillon + * Jeremie Humeau + * Arnaud Liefooghe + * + * This software is governed by the CeCILL license under French law and + * abiding by the rules of distribution of free software. You can use, + * modify and/ or redistribute the software under the terms of the CeCILL + * license as circulated by CEA, CNRS and INRIA at the following URL + * "http://www.cecill.info". + * + * As a counterpart to the access to the source code and rights to copy, + * modify and redistribute granted by the license, users are provided only + * with a limited warranty and the software's author, the holder of the + * economic rights, and the successive licensors have only limited liability. + * + * In this respect, the user's attention is drawn to the risks associated + * with loading, using, modifying and/or developing or reproducing the + * software by the user in light of its specific status of free software, + * that may mean that it is complicated to manipulate, and that also + * therefore means that it is reserved for developers and experienced + * professionals having in-depth computer knowledge. Users are therefore + * encouraged to load and test the software's suitability as regards their + * requirements in conditions enabling the security of their systems and/or + * data to be ensured and, more generally, to use and operate it in the + * same conditions as regards security. + * The fact that you are presently reading this means that you have had + * knowledge of the CeCILL license and that you accept its terms. + * + * ParadisEO WebSite : http://paradiseo.gforge.inria.fr + * Contact: paradiseo-help@lists.gforge.inria.fr + * + */ +//----------------------------------------------------------------------------- +#ifndef MOEOCHEBYCHEVORDIST_H_ +#define MOEOCHEBYCHEVORDIST_H_ + +#include + +/** + order representing chebychev distance + */ +template < class MOEOT> +class moeoAugmentedWeightedChebychevDistance : public moeoObjSpaceDistance < MOEOT > +{ + public: + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + typedef typename MOEOT::Fitness Fitness; + + /** + constructor with a normalizer + @param _rho + @param _weight the weight to apply to each dimension + @param _normalizer the normalizer + */ + moeoAugmentedWeightedChebychevDistance(unsigned int _rho, const ObjectiveVector& _weight, moeoObjectiveVectorNormalizer& _normalizer): normalizer(_normalizer), weight(_weight), rho(_rho){} + + /** + constructor with a dummy normalizer + @param _rho + @param _weight the weight to apply to each dimension + */ + moeoAugmentedWeightedChebychevDistance(unsigned int _rho, const ObjectiveVector& _weight): normalizer(defaultNormalizer), weight(_weight), rho(_rho){} + + /** + fonction which calculate a fitness + @param _reference the reference to calculate the distance from + @param _obj the point to evaluate + @return the fitness conrresponding to the distance + */ + const Fitness operator()(const ObjectiveVector& _reference, const ObjectiveVector& _obj){ + unsigned int dim=_obj.size(); + Fitness res=iteration(_obj,_reference,0); + Fitness max=res*weight[0]; + for (unsigned i=1;imax) + max=tmp*weight[i]; + res+=tmp; + } + res=res*rho+max; + return res; + } + + private: + moeoObjectiveVectorNormalizer &normalizer; + moeoObjectiveVectorNormalizer defaultNormalizer; + const ObjectiveVector &weight; + double rho; + + Fitness iteration(const ObjectiveVector &obj,const ObjectiveVector &reference,int dim){ + ObjectiveVector obj_norm=normalizer(obj); + ObjectiveVector ref_norm=normalizer(reference); + Fitness res=abs(obj_norm[dim]-ref_norm[dim]); + return res; + } +}; +#endif diff --git a/trunk/paradiseo-moeo/src/distance/moeoEuclideanDistance.h b/trunk/paradiseo-moeo/src/distance/moeoEuclideanDistance.h index 2c949a464..5c43c7599 100644 --- a/trunk/paradiseo-moeo/src/distance/moeoEuclideanDistance.h +++ b/trunk/paradiseo-moeo/src/distance/moeoEuclideanDistance.h @@ -4,6 +4,7 @@ * (C) OPAC Team, LIFL, 2002-2007 * * Arnaud Liefooghe +* François Legillon * * This software is governed by the CeCILL license under French law and * abiding by the rules of distribution of free software. You can use, @@ -39,52 +40,48 @@ #define MOEOEUCLIDEANDISTANCE_H_ #include -#include +#include +#include /** * A class allowing to compute an euclidian distance between two solutions in the objective space with normalized objective values (i.e. between 0 and 1). * A distance value then lies between 0 and sqrt(nObjectives). */ template < class MOEOT > -class moeoEuclideanDistance : public moeoNormalizedDistance < MOEOT > +class moeoEuclideanDistance : public moeoObjSpaceDistance < MOEOT > { public: /** the objective vector type of the solutions */ typedef typename MOEOT::ObjectiveVector ObjectiveVector; - + /** the fitness type of the solutions */ + typedef typename MOEOT::Fitness Fitness; /** - * Returns the euclidian distance between _moeo1 and _moeo2 in the objective space - * @param _moeo1 the first solution - * @param _moeo2 the second solution - */ - const double operator()(const MOEOT & _moeo1, const MOEOT & _moeo2) - { - double result = 0.0; - double tmp1, tmp2; - for (unsigned int i=0; i _normalizer):normalizer(_normalizer) + {} + /** + default ctr + */ + moeoEuclideanDistance ():normalizer(defaultNormalizer) + {} /** - * Returns the euclidian distance between _obj1 and _obj2 + * Returns the euclidian distance between _obj1 and _obj2 in the objective space * @param _obj1 the first objective vector * @param _obj2 the second objective vector */ - const double operator()(const ObjectiveVector & _obj1, const ObjectiveVector & _obj2) +const Fitness operator()(const ObjectiveVector & _obj1, const ObjectiveVector & _obj2) { - double result = 0.0; - double tmp1, tmp2; + Fitness result = 0.0; + Fitness tmp1, tmp2; for (unsigned int i=0; i private: - /** the bounds for every objective */ - using moeoNormalizedDistance < MOEOT > :: bounds; + moeoObjectiveVectorNormalizer defaultNormalizer; + moeoObjectiveVectorNormalizer &normalizer; }; diff --git a/trunk/paradiseo-moeo/src/distance/moeoManhattanDistance.h b/trunk/paradiseo-moeo/src/distance/moeoManhattanDistance.h index 91eea6f3d..da359c12b 100644 --- a/trunk/paradiseo-moeo/src/distance/moeoManhattanDistance.h +++ b/trunk/paradiseo-moeo/src/distance/moeoManhattanDistance.h @@ -4,6 +4,7 @@ * (C) OPAC Team, LIFL, 2002-2007 * * Arnaud Liefooghe +* Francçois Legillon * * This software is governed by the CeCILL license under French law and * abiding by the rules of distribution of free software. You can use, @@ -39,34 +40,48 @@ #define MOEOMANHATTANDISTANCE_H_ #include -#include +#include +#include /** * A class allowing to compute the Manhattan distance between two solutions in the objective space normalized objective values (i.e. between 0 and 1). * A distance value then lies between 0 and nObjectives. */ template < class MOEOT > -class moeoManhattanDistance : public moeoNormalizedDistance < MOEOT > +class moeoManhattanDistance : public moeoObjSpaceDistance < MOEOT > { public: /** the objective vector type of the solutions */ typedef typename MOEOT::ObjectiveVector ObjectiveVector; - + /** the fitness type of the solutions */ + typedef typename MOEOT::Fitness Fitness; /** - * Returns the Manhattan distance between _moeo1 and _moeo2 in the objective space - * @param _moeo1 the first solution - * @param _moeo2 the second solution + ctr with a normalizer + @param _normalizer the normalizer used for every ObjectiveVector + */ + moeoManhattanDistance (moeoObjectiveVectorNormalizer &_normalizer):normalizer(_normalizer) + {} + /** + default ctr + */ + moeoManhattanDistance ():normalizer(defaultNormalizer) + {} + + /** + * Returns the Manhattan distance between _obj1 and _obj2 in the objective space + * @param _obj1 the first objective vector + * @param _obj2 the second objective vector */ - const double operator()(const MOEOT & _moeo1, const MOEOT & _moeo2) + const double operator()(const ObjectiveVector & _obj1, const ObjectiveVector & _obj2) { double result = 0.0; double tmp1, tmp2; for (unsigned int i=0; i private: - /** the bounds for every objective */ - using moeoNormalizedDistance < MOEOT > :: bounds; + moeoObjectiveVectorNormalizer defaultNormalizer; + moeoObjectiveVectorNormalizer &normalizer; }; diff --git a/trunk/paradiseo-moeo/src/distance/moeoObjSpaceDistance.h b/trunk/paradiseo-moeo/src/distance/moeoObjSpaceDistance.h new file mode 100644 index 000000000..2158a7934 --- /dev/null +++ b/trunk/paradiseo-moeo/src/distance/moeoObjSpaceDistance.h @@ -0,0 +1,63 @@ +/* + * + * Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007 + * (C) OPAC Team, LIFL, 2002-2007 + * + * Jeremie Humeau + * Arnaud Liefooghe + * François Legillon + * + * This software is governed by the CeCILL license under French law and + * abiding by the rules of distribution of free software. You can use, + * modify and/ or redistribute the software under the terms of the CeCILL + * license as circulated by CEA, CNRS and INRIA at the following URL + * "http://www.cecill.info". + * + * As a counterpart to the access to the source code and rights to copy, + * modify and redistribute granted by the license, users are provided only + * with a limited warranty and the software's author, the holder of the + * economic rights, and the successive licensors have only limited liability. + * + * In this respect, the user's attention is drawn to the risks associated + * with loading, using, modifying and/or developing or reproducing the + * software by the user in light of its specific status of free software, + * that may mean that it is complicated to manipulate, and that also + * therefore means that it is reserved for developers and experienced + * professionals having in-depth computer knowledge. Users are therefore + * encouraged to load and test the software's suitability as regards their + * requirements in conditions enabling the security of their systems and/or + * data to be ensured and, more generally, to use and operate it in the + * same conditions as regards security. + * The fact that you are presently reading this means that you have had + * knowledge of the CeCILL license and that you accept its terms. + * + * ParadisEO WebSite : http://paradiseo.gforge.inria.fr + * Contact: paradiseo-help@lists.gforge.inria.fr + * + */ +//----------------------------------------------------------------------------- +#ifndef MOEOOBJDIST_H_ +#define MOEOOBJDIST_H_ + + +#include +#include +#include + +/** + Distances using Objective vectors to evaluate + */ +template < class MOEOT> +class moeoObjSpaceDistance : public moeoDistance < MOEOT, typename MOEOT::Fitness >, public eoBF +{ + public: + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + typedef typename MOEOT::Fitness Fitness; + + virtual const Fitness operator()(const MOEOT &_moeot1,const MOEOT &_moeot2){ + return operator()(_moeot1.objectiveVector(),_moeot2.objectiveVector()); + } + + virtual const Fitness operator()(const ObjectiveVector &_obj1, const ObjectiveVector &_obj2)=0; +}; +#endif diff --git a/trunk/paradiseo-moeo/src/distance/moeoWeightedChebychevDistance.h b/trunk/paradiseo-moeo/src/distance/moeoWeightedChebychevDistance.h new file mode 100644 index 000000000..c25c86987 --- /dev/null +++ b/trunk/paradiseo-moeo/src/distance/moeoWeightedChebychevDistance.h @@ -0,0 +1,101 @@ +/* + * + * Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007 + * (C) OPAC Team, LIFL, 2002-2007 + * + * Jeremie Humeau + * Arnaud Liefooghe + * François Legillon + * + * This software is governed by the CeCILL license under French law and + * abiding by the rules of distribution of free software. You can use, + * modify and/ or redistribute the software under the terms of the CeCILL + * license as circulated by CEA, CNRS and INRIA at the following URL + * "http://www.cecill.info". + * + * As a counterpart to the access to the source code and rights to copy, + * modify and redistribute granted by the license, users are provided only + * with a limited warranty and the software's author, the holder of the + * economic rights, and the successive licensors have only limited liability. + * + * In this respect, the user's attention is drawn to the risks associated + * with loading, using, modifying and/or developing or reproducing the + * software by the user in light of its specific status of free software, + * that may mean that it is complicated to manipulate, and that also + * therefore means that it is reserved for developers and experienced + * professionals having in-depth computer knowledge. Users are therefore + * encouraged to load and test the software's suitability as regards their + * requirements in conditions enabling the security of their systems and/or + * data to be ensured and, more generally, to use and operate it in the + * same conditions as regards security. + * The fact that you are presently reading this means that you have had + * knowledge of the CeCILL license and that you accept its terms. + * + * ParadisEO WebSite : http://paradiseo.gforge.inria.fr + * Contact: paradiseo-help@lists.gforge.inria.fr + * + */ +//----------------------------------------------------------------------------- +#ifndef MOEOCHEBYCHEVDIST_H_ +#define MOEOCHEBYCHEVDIST_H_ + + +#include +#include +#include +/** + * weighted chebychev distance + */ +template < class MOEOT> +class moeoWeightedChebychevDistance : public moeoObjSpaceDistance < MOEOT > +{ + public: + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + typedef typename MOEOT::Fitness Fitness; + + /** + * constructor with a normalizer + * @param _rho + * @param _weight the weight to apply to each dimansion + * @param _normalizer the normalizer + */ + moeoWeightedChebychevDistance(unsigned int _rho, const ObjectiveVector& _weight, moeoObjectiveVectorNormalizer& _normalizer): normalizer(_normalizer), weight(_weight), rho(_rho){} + + /** + * constructor with a normalizer + * @param _rho + * @param _weight the weight to apply to each dimansion + */ + moeoWeightedChebychevDistance(unsigned int _rho, const ObjectiveVector& _weight): normalizer(defaultNormalizer), weight(_weight), rho(_rho){} + + /** + * fonction which apply the metric to calculate a fitness + * @param _obj the point to evaluate + * @param _reference the reference to calculate the distance from + * @return the fitness conrresponding to the distance + */ + const Fitness operator()(const ObjectiveVector& _reference, const ObjectiveVector& _obj){ + unsigned int dim=_obj.size(); + Fitness res=0; + ObjectiveVector obj_norm=normalizer(_obj); + ObjectiveVector ref_norm=normalizer(_reference); + for (unsigned i=0;i &normalizer; + moeoObjectiveVectorNormalizer defaultNormalizer; + const ObjectiveVector &weight; + double rho; + + Fitness iteration(const ObjectiveVector &obj,const ObjectiveVector &reference,int dim){ + Fitness res=abs(obj[dim]-reference[dim]); + res=weight[dim]*pow(res,rho); + res=pow(res,1/rho); + return res; + } +}; +#endif diff --git a/trunk/paradiseo-moeo/src/fitness/moeoAchievementScalarizingFunctionMetricFitnessAssignment.h b/trunk/paradiseo-moeo/src/fitness/moeoAchievementScalarizingFunctionMetricFitnessAssignment.h new file mode 100644 index 000000000..17382fa77 --- /dev/null +++ b/trunk/paradiseo-moeo/src/fitness/moeoAchievementScalarizingFunctionMetricFitnessAssignment.h @@ -0,0 +1,146 @@ +/* + * + * Copyright (C) DOLPHIN Project-Team, INRIA Lille-Nord Europe, 2006-2008 + * (C) OPAC Team, LIFL, 2002-2008 + * + * François Legillon + * + * This software is governed by the CeCILL license under French law and + * abiding by the rules of distribution of free software. You can use, + * modify and/ or redistribute the software under the terms of the CeCILL + * license as circulated by CEA, CNRS and INRIA at the following URL + * "http://www.cecill.info". + * + * As a counterpart to the access to the source code and rights to copy, + * modify and redistribute granted by the license, users are provided only + * with a limited warranty and the software's author, the holder of the + * economic rights, and the successive licensors have only limited liability. + * + * In this respect, the user's attention is drawn to the risks associated + * with loading, using, modifying and/or developing or reproducing the + * software by the user in light of its specific status of free software, + * that may mean that it is complicated to manipulate, and that also + * therefore means that it is reserved for developers and experienced + * professionals having in-depth computer knowledge. Users are therefore + * encouraged to load and test the software's suitability as regards their + * requirements in conditions enabling the security of their systems and/or + * data to be ensured and, more generally, to use and operate it in the + * same conditions as regards security. + * The fact that you are presently reading this means that you have had + * knowledge of the CeCILL license and that you accept its terms. + * + * ParadisEO WebSite : http://paradiseo.gforge.inria.fr + * Contact: paradiseo-help@lists.gforge.inria.fr + * + */ +//----------------------------------------------------------------------------- +// moeoScalarizationFunctionMetricFitnessAssignment.h +//----------------------------------------------------------------------------- +#ifndef MOEOASFAFITNESSASSIGNMENT_H_ +#define MOEOASFAFITNESSASSIGNMENT_H_ + +#include +#include +#include +#include +#include + +/* + * Fitness assignment scheme which use a metric + */ +template < class MOEOT> +class moeoAchievementScalarizingFunctionMetricFitnessAssignment : public moeoSingleObjectivization < MOEOT > +{ + public: + + /** the objective vector type of the solutions */ + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + typedef typename MOEOT::Fitness Fitness; + typedef typename ObjectiveVector::Type Type; + + /** + * ctor with normalizer + * @param _rho + * @param _reference the reference point + * @param _weight the weights applied to the objectives + * @param _normalizer the normalizer to apply to objectiveVectors + */ + moeoAchievementScalarizingFunctionMetricFitnessAssignment(unsigned int _rho, const ObjectiveVector& _reference, const ObjectiveVector& _weight, moeoObjectiveVectorNormalizer& _normalizer) : normalizer(_normalizer), eval(defaultEval), distance(_rho, _weight), metric( distance, _reference, defaultNormalizer){} + + /** + * ctor with an evaluing fonction, applied if give moeot is invalid + * @param _rho + * @param _reference the reference point + * @param _weight the weights applied to the objectives + * @param _eval a evalFunc to regenerate the objectiveVector if needed + */ + moeoAchievementScalarizingFunctionMetricFitnessAssignment(unsigned int _rho, ObjectiveVector& _reference, const ObjectiveVector& _weight, eoEvalFunc& _eval): eval(_eval), normalizer(defaultNormalizer), distance(_rho, _weight), metric( distance, _reference, defaultNormalizer){} + + /** + * ctor with an evaluing fonction, applied if give moeot is invalid, and a noramlizer, applied to ObjectiveVectors + * @param _rho + * @param _reference the reference point + * @param _weight the weights applied to the objectives + * @param _normalizer the normalizer to apply to objectiveVectors + * @param _eval a evalFunc to regenerate the objectiveVector if needed + */ + moeoAchievementScalarizingFunctionMetricFitnessAssignment(unsigned int _rho, const ObjectiveVector& _reference, const ObjectiveVector& _weight, moeoObjectiveVectorNormalizer& _normalizer, eoEvalFunc& _eval) : normalizer(_normalizer), eval(_eval), distance(_rho, _weight), metric(distance, _reference, _normalizer){} + + /** + default constructor + * @param _rho + * @param _reference the reference point + * @param _weight the weights applied to the objectives + */ + moeoAchievementScalarizingFunctionMetricFitnessAssignment(unsigned int _rho, const ObjectiveVector& _reference, const ObjectiveVector& _weight) : eval(defaultEval), normalizer(defaultNormalizer), distance(_rho, _weight), metric(distance, _reference, defaultNormalizer){} + + /** + * Sets the fitness values for a moeot + * @param _mo the MOEOT + */ + void operator()(MOEOT & _mo){ + if (_mo.invalidObjectiveVector()) + eval(_mo); + _mo.fitness(operator()(_mo.objectiveVector())); + } + + /** + return the fitness of a valid objectiveVector + @param _mo the objectiveVector + @return the fitness value of _mo + */ + typename MOEOT::Fitness operator()(const typename MOEOT::ObjectiveVector& _mo){ + return -metric(_mo); + } + + /** + * Sets the fitness values for every solution contained in the populing _pop (and in the archive) + * @param _pop the populing + */ + void operator()(eoPop < MOEOT > & _pop) + { + for (unsigned int k=0; k < _pop.size(); k++) + operator()(_pop[k]); + } + + /** + * @param _pop the populing + * @param _objVec the objective vector + */ + void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec){} + + private: + + moeoObjectiveVectorNormalizer defaultNormalizer; + moeoAchievementScalarizingFunctionDistance distance; + moeoDistanceMetric metric; + eoEvalFunc &eval; + moeoObjectiveVectorNormalizer &normalizer; + + class DummyEval: public eoEvalFunc{ + void operator()(MOEOT &moeo){ + } + } defaultEval; +}; + +#endif /*moeoAugmentedScalarizingFunctionMetricFitnessASSIGNMENT_H_*/ diff --git a/trunk/paradiseo-moeo/src/fitness/moeoAggregationFitnessAssignment.h b/trunk/paradiseo-moeo/src/fitness/moeoAggregationFitnessAssignment.h new file mode 100644 index 000000000..e351ddca7 --- /dev/null +++ b/trunk/paradiseo-moeo/src/fitness/moeoAggregationFitnessAssignment.h @@ -0,0 +1,129 @@ +/* + * + * Copyright (C) DOLPHIN Project-Team, INRIA Lille-Nord Europe, 2006-2008 + * (C) OPAC Team, LIFL, 2002-2008 + * + * François Legillon + * + * This software is governed by the CeCILL license under French law and + * abiding by the rules of distribution of free software. You can use, + * modify and/ or redistribute the software under the terms of the CeCILL + * license as circulated by CEA, CNRS and INRIA at the following URL + * "http://www.cecill.info". + * + * As a counterpart to the access to the source code and rights to copy, + * modify and redistribute granted by the license, users are provided only + * with a limited warranty and the software's author, the holder of the + * economic rights, and the successive licensors have only limited liability. + * + * In this respect, the user's attention is drawn to the risks associated + * with loading, using, modifying and/or developing or reproducing the + * software by the user in light of its specific status of free software, + * that may mean that it is complicated to manipulate, and that also + * therefore means that it is reserved for developers and experienced + * professionals having in-depth computer knowledge. Users are therefore + * encouraged to load and test the software's suitability as regards their + * requirements in conditions enabling the security of their systems and/or + * data to be ensured and, more generally, to use and operate it in the + * same conditions as regards security. + * The fact that you are presently reading this means that you have had + * knowledge of the CeCILL license and that you accept its terms. + * + * ParadisEO WebSite : http://paradiseo.gforge.inria.fr + * Contact: paradiseo-help@lists.gforge.inria.fr + * + */ +//----------------------------------------------------------------------------- +// moeoAggregationFitnessAssignment.h +//----------------------------------------------------------------------------- +#ifndef MOEOAGGREGATIONFITNESSASSIGNMENT_H_ +#define MOEOAGGREGATIONFITNESSASSIGNMENT_H_ + +#include +#include +#include + +/* + * Fitness assignment scheme which use weight foreach objectives + */ +template < class MOEOT > +class moeoAggregationFitnessAssignment : public moeoSingleObjectivization < MOEOT > +{ + public: + + /** the objective vector type of the solutions */ + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + typedef typename MOEOT::Fitness Fitness; + + /** + * Default ctor + * @param _weight vectors contains all weights. + * @param _eval a eval function, to revalidate the objectiveVector if needed + */ + moeoAggregationFitnessAssignment(std::vector & _weight,eoEvalFunc &_eval) : weight(_weight),eval(_eval){} + + /** + * Ctor with a dummy evaluation function + * @param _weight vectors contains all weights. + */ + moeoAggregationFitnessAssignment(std::vector & _weight) : weight(_weight),eval(defaultEval){} + + /** + * Sets the fitness values for _moeot + * @param _moeot the MOEOT + */ + virtual void operator()(MOEOT & _moeot){ + if (_moeot.invalidObjectiveVector()) + eval(_moeot); + _moeot.fitness(operator()(_moeot.objectiveVector())); + } + + /** + * function which calculate the fitness from an objectiveVector (which has troi be valid.) + * @param _mo an valid objectiveVector + * @return the fitness value of _mo + */ + virtual Fitness operator()(const typename MOEOT::ObjectiveVector & _mo){ + unsigned int dim=_mo.nObjectives(); + Fitness res=0; + if (dim>weight.size()){ + std::cout<<"moeoAggregationFitnessAssignmentFitness: Error -> given weight dimension is smaller than MOEOTs"< & _pop){ + for (unsigned int k=0; k < _pop.size(); k++) + operator()(_pop[k]); + } + + /** + * Warning: no yet implemented: 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){} + + private: + + class DummyEval: public eoEvalFunc{ + void operator()(MOEOT &moeo){} + }defaultEval; + + //the vector of weight + std::vector& weight; + eoEvalFunc& eval; + +}; +#endif /*MOEOAGGREGATIONFITNESSASSIGNMENT_H_*/ diff --git a/trunk/paradiseo-moeo/src/fitness/moeoAugmentedAchievementScalarizingFunctionMetricFitnessAssignment.h b/trunk/paradiseo-moeo/src/fitness/moeoAugmentedAchievementScalarizingFunctionMetricFitnessAssignment.h new file mode 100644 index 000000000..9775c7592 --- /dev/null +++ b/trunk/paradiseo-moeo/src/fitness/moeoAugmentedAchievementScalarizingFunctionMetricFitnessAssignment.h @@ -0,0 +1,160 @@ +/* + * + * Copyright (C) DOLPHIN Project-Team, INRIA Lille-Nord Europe, 2006-2008 + * (C) OPAC Team, LIFL, 2002-2008 + * + * François Legillon + * + * This software is governed by the CeCILL license under French law and + * abiding by the rules of distribution of free software. You can use, + * modify and/ or redistribute the software under the terms of the CeCILL + * license as circulated by CEA, CNRS and INRIA at the following URL + * "http://www.cecill.info". + * + * As a counterpart to the access to the source code and rights to copy, + * modify and redistribute granted by the license, users are provided only + * with a limited warranty and the software's author, the holder of the + * economic rights, and the successive licensors have only limited liability. + * + * In this respect, the user's attention is drawn to the risks associated + * with loading, using, modifying and/or developing or reproducing the + * software by the user in light of its specific status of free software, + * that may mean that it is complicated to manipulate, and that also + * therefore means that it is reserved for developers and experienced + * professionals having in-depth computer knowledge. Users are therefore + * encouraged to load and test the software's suitability as regards their + * requirements in conditions enabling the security of their systems and/or + * data to be ensured and, more generally, to use and operate it in the + * same conditions as regards security. + * The fact that you are presently reading this means that you have had + * knowledge of the CeCILL license and that you accept its terms. + * + * ParadisEO WebSite : http://paradiseo.gforge.inria.fr + * Contact: paradiseo-help@lists.gforge.inria.fr + * + */ +//----------------------------------------------------------------------------- +// moeoAugmentedScalarizingFunctionMetricFitnessAssignment.h +//----------------------------------------------------------------------------- +#ifndef MOEOAUGASFAFITNESSASSIGNMENT_H_ +#define MOEOAUGASFAFITNESSASSIGNMENT_H_ + +#include +#include +#include +#include +#include +#include +#include + +/* + * Fitness assignment scheme which use a metric + */ +template < class MOEOT> +class moeoAugmentedAchievementScalarizingFunctionMetricFitnessAssignment : public moeoSingleObjectivization < MOEOT > +{ + public: + + + /** the objective vector type of the solutions */ + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + typedef typename MOEOT::Fitness Fitness; + typedef typename ObjectiveVector::Type Type; + + + /** + * ctor with normalizer + * @param _normalizer the normalizer to apply to objectiveVectors + * @param _rho + * @param _reference the reference point + * @param _weight the weights applied to the objectives + */ + moeoAugmentedAchievementScalarizingFunctionMetricFitnessAssignment(unsigned int _rho,const ObjectiveVector &_reference,const ObjectiveVector &_weight,moeoObjectiveVectorNormalizer &_normalizer) : normalizer(_normalizer),eval(defaultEval), distance(_rho,_weight), metric(distance,_reference,normalizer) + {} + /** + * ctor with an evaluing fonction, applied if give moeot is invalid + * @param _eval a evalFunc to regenerate the objectiveVector if needed + * @param _rho + * @param _reference the reference point + * @param _weight the weights applied to the objectives + */ + moeoAugmentedAchievementScalarizingFunctionMetricFitnessAssignment(unsigned int _rho, const ObjectiveVector &_reference,const ObjectiveVector &_weight,eoEvalFunc &_eval) : eval(_eval),normalizer(defaultNormalizer), distance(_rho,_weight), metric(distance,_reference,normalizer) + {} + /** + * ctor with an evaluing fonction, applied if give moeot is invalid, and a noramlizer, applied to ObjectiveVectors + * @param _eval a evalFunc to regenerate the objectiveVector if needed + * @param _normalizer the normalizer to apply to objectiveVectors + * @param _rho + * @param _reference the reference point + * @param _weight the weights applied to the objectives + */ + moeoAugmentedAchievementScalarizingFunctionMetricFitnessAssignment(unsigned int _rho, const ObjectiveVector &_reference,const ObjectiveVector &_weight,moeoObjectiveVectorNormalizer &_normalizer,eoEvalFunc &_eval) :normalizer(_normalizer),eval(_eval), distance(_rho,_weight), metric(distance,_reference,normalizer) + {} + /** + default constructor + * @param _rho + * @param _reference the reference point + * @param _weight the weights applied to the objectives + */ + moeoAugmentedAchievementScalarizingFunctionMetricFitnessAssignment(unsigned int _rho, const ObjectiveVector &_reference,const ObjectiveVector &_weight) : eval(defaultEval),normalizer(defaultNormalizer), distance(_rho,_weight), metric(distance,_reference,normalizer) + {} + + /** + * Sets the fitness values for a moeot + * @param _mo the MOEOT + */ + void operator()(MOEOT & _mo){ + if (_mo.invalidObjectiveVector()) eval(_mo); + _mo.fitness(operator()(_mo.objectiveVector())); + + } + + /** + return the fitness of a valid objectiveVector + @param _mo the objectiveVector + @return the fitness value of _mo + */ + typename MOEOT::Fitness operator()(const typename MOEOT::ObjectiveVector & _mo){ + return -metric(_mo); + } + + + /** + * Sets the fitness values for every solution contained in the populing _pop (and in the archive) + * @param _pop the populing + */ + void operator()(eoPop < MOEOT > & _pop) + { + unsigned int pop_size= _pop.size(); + for (unsigned int k=0; k & _pop, ObjectiveVector & _objVec) + { + } + + + private: + + moeoObjectiveVectorNormalizer defaultNormalizer; + moeoAugmentedAchievementScalarizingFunctionDistance distance; + moeoObjectiveVectorNormalizer &normalizer; + moeoDistanceMetric metric; + eoEvalFunc &eval; + class DummyEval: public eoEvalFunc{ + void operator()(MOEOT &moeo){ + } + } defaultEval; + +}; + +#endif /*moeoAugmentedScalarizingFunctionMetricFitnessASSIGNMENT_H_*/ diff --git a/trunk/paradiseo-moeo/src/fitness/moeoAugmentedWeightedChebychevMetricFitnessAssignment.h b/trunk/paradiseo-moeo/src/fitness/moeoAugmentedWeightedChebychevMetricFitnessAssignment.h new file mode 100644 index 000000000..37748a4b4 --- /dev/null +++ b/trunk/paradiseo-moeo/src/fitness/moeoAugmentedWeightedChebychevMetricFitnessAssignment.h @@ -0,0 +1,144 @@ +/* + * + * Copyright (C) DOLPHIN Project-Team, INRIA Lille-Nord Europe, 2006-2008 + * (C) OPAC Team, LIFL, 2002-2008 + * + * François Legillon + * + * This software is governed by the CeCILL license under French law and + * abiding by the rules of distribution of free software. You can use, + * modify and/ or redistribute the software under the terms of the CeCILL + * license as circulated by CEA, CNRS and INRIA at the following URL + * "http://www.cecill.info". + * + * As a counterpart to the access to the source code and rights to copy, + * modify and redistribute granted by the license, users are provided only + * with a limited warranty and the software's author, the holder of the + * economic rights, and the successive licensors have only limited liability. + * + * In this respect, the user's attention is drawn to the risks associated + * with loading, using, modifying and/or developing or reproducing the + * software by the user in light of its specific status of free software, + * that may mean that it is complicated to manipulate, and that also + * therefore means that it is reserved for developers and experienced + * professionals having in-depth computer knowledge. Users are therefore + * encouraged to load and test the software's suitability as regards their + * requirements in conditions enabling the security of their systems and/or + * data to be ensured and, more generally, to use and operate it in the + * same conditions as regards security. + * The fact that you are presently reading this means that you have had + * knowledge of the CeCILL license and that you accept its terms. + * + * ParadisEO WebSite : http://paradiseo.gforge.inria.fr + * Contact: paradiseo-help@lists.gforge.inria.fr + * + */ +//----------------------------------------------------------------------------- +// moeoAugmentedWeightedChebychevMetricFitnessAssignment.h +//----------------------------------------------------------------------------- +#ifndef MOEOAUGCHEVMETRICFITNESSASSIGNMENT_H_ +#define MOEOAUGCHEVMETRICFITNESSASSIGNMENT_H_ + +#include +#include +#include + +/* + * Fitness assignment scheme which use a metric + */ +template < class MOEOT> +class moeoAugmentedWeightedChebychevMetricFitnessAssignment : public moeoSingleObjectivization < MOEOT > +{ + public: + + /** the objective vector type of the solutions */ + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + typedef typename MOEOT::Fitness Fitness; + typedef typename ObjectiveVector::Type Type; + + /** + * ctor with normalizer + * @param _rho + * @param _reference the reference point + * @param _weight the weights applied to the objectives + * @param _normalizer the normalizer to apply to objectiveVectors + */ + moeoAugmentedWeightedChebychevMetricFitnessAssignment(unsigned int _rho, const ObjectiveVector& _reference, const ObjectiveVector& _weight, moeoObjectiveVectorNormalizer& _normalizer) : normalizer(_normalizer), eval(defaultEval), distance(_rho, _weight), metric(distance, _reference, normalizer){} + + /** + * ctor with an evaluation fonction, applied if give moeot is invalid + * @param _rho + * @param _reference the reference point + * @param _weight the weights applied to the objectives + * @param _eval a evalFunc to regenerate the objectiveVector if needed + */ + moeoAugmentedWeightedChebychevMetricFitnessAssignment(unsigned int _rho, const ObjectiveVector& _reference, const ObjectiveVector& _weight, eoEvalFunc& _eval) : eval(_eval), normalizer(defaultNormalizer), distance(_rho, _weight), metric(distance, _reference, normalizer){} + + /** + * ctor with an evaluation fonction, applied if give moeot is invalid, and a noramlizer, applied to ObjectiveVectors + * @param _rho + * @param _reference the reference point + * @param _weight the weights applied to the objectives + * @param _normalizer the normalizer to apply to objectiveVectors + * @param _eval a evalFunc to regenerate the objectiveVector if needed + */ + moeoAugmentedWeightedChebychevMetricFitnessAssignment(unsigned int _rho, const ObjectiveVector& _reference, const ObjectiveVector& _weight, moeoObjectiveVectorNormalizer& _normalizer, eoEvalFunc& _eval) : normalizer(_normalizer), eval(_eval), distance(_rho, _weight), metric(distance, _reference, normalizer){} + + /** + default constructor + * @param _rho + * @param _reference the reference point + * @param _weight the weights applied to the objectives + */ + moeoAugmentedWeightedChebychevMetricFitnessAssignment(unsigned int _rho, const ObjectiveVector& _reference, const ObjectiveVector& _weight) : eval(defaultEval), normalizer(defaultNormalizer), distance(_rho, _weight), metric(distance, _reference, normalizer){} + + /** + * Sets the fitness values for a moeot + * @param _mo the MOEOT + */ + void operator()(MOEOT & _mo){ + if (_mo.invalidObjectiveVector()) + eval(_mo); + _mo.fitness(operator()(_mo.objectiveVector())); + } + + /** + return the fitness of a valid objectiveVector + @param _mo the objectiveVector + @return the fitness value of _mo + */ + typename MOEOT::Fitness operator()(const typename MOEOT::ObjectiveVector & _mo){ + return -metric(_mo); + } + + /** + * Sets the fitness values for every solution contained in the population _pop (and in the archive) + * @param _pop the population + */ + void operator()(eoPop < MOEOT > & _pop){ + for (unsigned int k=0; k<_pop.size(); k++) + operator()(_pop[k]); + } + + /** + * @param _pop the population + * @param _objVec the objective vector + */ + void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec){} + + private: + + class DummyEval: public eoEvalFunc{ + void operator()(MOEOT &moeo){ + } + } defaultEval; + + moeoAugmentedWeightedChebychevDistance distance; + moeoObjectiveVectorNormalizer defaultNormalizer; + moeoObjectiveVectorNormalizer &normalizer; + moeoDistanceMetric metric; + eoEvalFunc &eval; + +}; + +#endif /*moeoAugmentedWeightedChebychevMetricFitnessASSIGNMENT_H_*/ diff --git a/trunk/paradiseo-moeo/src/fitness/moeoConstraintFitnessAssignment.h b/trunk/paradiseo-moeo/src/fitness/moeoConstraintFitnessAssignment.h new file mode 100644 index 000000000..c48eee9d9 --- /dev/null +++ b/trunk/paradiseo-moeo/src/fitness/moeoConstraintFitnessAssignment.h @@ -0,0 +1,171 @@ +/* + * + * Copyright (C) DOLPHIN Project-Team, INRIA Lille-Nord Europe, 2006-2008 + * (C) OPAC Team, LIFL, 2002-2008 + * + * François Legillon + * + * This software is governed by the CeCILL license under French law and + * abiding by the rules of distribution of free software. You can use, + * modify and/ or redistribute the software under the terms of the CeCILL + * license as circulated by CEA, CNRS and INRIA at the following URL + * "http://www.cecill.info". + * + * As a counterpart to the access to the source code and rights to copy, + * modify and redistribute granted by the license, users are provided only + * with a limited warranty and the software's author, the holder of the + * economic rights, and the successive licensors have only limited liability. + * + * In this respect, the user's attention is drawn to the risks associated + * with loading, using, modifying and/or developing or reproducing the + * software by the user in light of its specific status of free software, + * that may mean that it is complicated to manipulate, and that also + * therefore means that it is reserved for developers and experienced + * professionals having in-depth computer knowledge. Users are therefore + * encouraged to load and test the software's suitability as regards their + * requirements in conditions enabling the security of their systems and/or + * data to be ensured and, more generally, to use and operate it in the + * same conditions as regards security. + * The fact that you are presently reading this means that you have had + * knowledge of the CeCILL license and that you accept its terms. + * + * ParadisEO WebSite : http://paradiseo.gforge.inria.fr + * Contact: paradiseo-help@lists.gforge.inria.fr + * + */ +//----------------------------------------------------------------------------- +// moeoConstraintFitnessAssignment.h +//----------------------------------------------------------------------------- +#ifndef MOEOCONSTRAINTFITNESSASSIGNMENT_H_ +#define MOEOCONSTRAINTFITNESSASSIGNMENT_H_ + +#include +#include +#include + +/* + * Fitness assignment scheme which give a penalty if MOEOT does not respect constraints + */ +template < class MOEOT > +class moeoConstraintFitnessAssignment : public moeoSingleObjectivization < MOEOT > +{ + public: + + /** the objective vector type of the solutions */ + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + /** the fitness type of the solutions */ + typedef typename MOEOT::Fitness Fitness; + /** the type of the solutions */ + typedef typename ObjectiveVector::Type Type; + + /** + * Default ctor + * @param _weight vectors contains all weights to apply for not respecting the contraint in each dimension. + * @param _constraint vector containing the constraints, normalizer is applied to it + * @param _to_optimize dimension in which we ignore the constraint + * @param _normalizer normalizer to apply to each objective + */ + moeoConstraintFitnessAssignment(std::vector & _weight, ObjectiveVector &_constraint, int _to_optimize, moeoObjectiveVectorNormalizer &_normalizer, eoEvalFunc &_eval) : weight(_weight),constraint(_constraint),to_optimize(_to_optimize),normalizer(_normalizer),eval(_eval),to_eval(true){} + + /** + * Ctor with a dummy eval + * @param _weight vectors contains all weights to apply for not respecting the contraint in each dimension. + * @param _constraint vector containing the constraints, normalizer is applied to it + * @param _to_optimize dimension in which we ignore the constraint + * @param _normalizer normalizer to apply to each objective + */ + moeoConstraintFitnessAssignment(std::vector & _weight, ObjectiveVector &_constraint, int _to_optimize, moeoObjectiveVectorNormalizer &_normalizer) : weight(_weight), constraint(_constraint), to_optimize(_to_optimize), normalizer(_normalizer), eval(defaultEval), to_eval(false){} + + /** + * Sets the fitness values for every solution contained in the population _pop (and in the archive) + * @param _mo the MOEOT + */ + void operator()(MOEOT & _mo){ + if (to_eval && _mo.invalidObjectiveVector()) + eval(_mo); + _mo.fitness(operator()(_mo.objectiveVector())); + } + + /** + * Calculate a fitness from a valid objectiveVector + * @param _mo a valid objectiveVector + * @return the fitness of _mo + */ + Fitness operator()(const typename MOEOT::ObjectiveVector & _mo){ + unsigned int dim=_mo.nObjectives(); + Fitness res=0; + if (dim>weight.size()){ + std::cout<<"moeoAggregationFitnessAssignmentFitness: ouch, given weight dimension is smaller than MOEOTs"<normalizer(constraint)[l]) + res-=(normalizer(_mo)[l]-normalizer(constraint)[l])*weight[l]; + } + else{ + if (normalizer(_mo)[l] & _pop) + { + for(unsigned int k=0; k<_pop.size(); k++) + operator()(_pop[k]); + } + + /** + * Warning: no yet implemented: 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) + { + //std::cout << "WARNING : updateByDeleting not implemented in moeoAssignmentFitnessAssignment" << std::endl; + } + + private: + + //dummy evaluation function + class DummyEval: public eoEvalFunc{ + void operator()(MOEOT &moeo){ + } + } defaultEval; + + //the vector of weight + std::vector weight; + + //the vector of constraints + ObjectiveVector constraint; + + //index of the objective to optimize + int to_optimize; + + //the normalizer + moeoObjectiveVectorNormalizer& normalizer; + + //the evaluation function + eoEvalFunc &eval; + + //true if the evaluation has to be done + bool to_eval; + +}; + +#endif /*MOEOAGGREGATIONFITNESSASSIGNMENT_H_*/ diff --git a/trunk/paradiseo-moeo/src/fitness/moeoMetricFitnessAssignment.h b/trunk/paradiseo-moeo/src/fitness/moeoMetricFitnessAssignment.h new file mode 100644 index 000000000..f5c3e5549 --- /dev/null +++ b/trunk/paradiseo-moeo/src/fitness/moeoMetricFitnessAssignment.h @@ -0,0 +1,140 @@ +/* + * + * Copyright (C) DOLPHIN Project-Team, INRIA Lille-Nord Europe, 2006-2008 + * (C) OPAC Team, LIFL, 2002-2008 + * + * François Legillon + * + * This software is governed by the CeCILL license under French law and + * abiding by the rules of distribution of free software. You can use, + * modify and/ or redistribute the software under the terms of the CeCILL + * license as circulated by CEA, CNRS and INRIA at the following URL + * "http://www.cecill.info". + * + * As a counterpart to the access to the source code and rights to copy, + * modify and redistribute granted by the license, users are provided only + * with a limited warranty and the software's author, the holder of the + * economic rights, and the successive licensors have only limited liability. + * + * In this respect, the user's attention is drawn to the risks associated + * with loading, using, modifying and/or developing or reproducing the + * software by the user in light of its specific status of free software, + * that may mean that it is complicated to manipulate, and that also + * therefore means that it is reserved for developers and experienced + * professionals having in-depth computer knowledge. Users are therefore + * encouraged to load and test the software's suitability as regards their + * requirements in conditions enabling the security of their systems and/or + * data to be ensured and, more generally, to use and operate it in the + * same conditions as regards security. + * The fact that you are presently reading this means that you have had + * knowledge of the CeCILL license and that you accept its terms. + * + * ParadisEO WebSite : http://paradiseo.gforge.inria.fr + * Contact: paradiseo-help@lists.gforge.inria.fr + * + */ +//----------------------------------------------------------------------------- +// moeoMetrucFitnessAssignment.h +//----------------------------------------------------------------------------- +#ifndef MOEOMETRICFITNESSASSIGNMENT_H_ +#define MOEOMETRICFITNESSASSIGNMENT_H_ + +#include +#include +#include +#include +#include +#include + +/* + * Fitness assignment scheme which use a metric + */ +template < class MOEOT> +class moeoMetricFitnessAssignment : public moeoSingleObjectivization < MOEOT > +{ + public: + + + /** the objective vector type of the solutions */ + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + typedef typename MOEOT::Fitness Fitness; + typedef typename ObjectiveVector::Type Type; + + + /** + * Default ctor + * @param _metric a metric function to calculate fitness + * @param _negate true if fitness should be maxed + */ + moeoMetricFitnessAssignment(moeoUnaryMetric &_metric, bool _negate=true) : metric(_metric),eval(defaultEval),negate(_negate) + {} + /** + * ctor with an evaluation fonction, applied if give moeot is invalid + * @param _eval a evalFunc to regenerate the objectiveVector if needed + * @param _metric a metric function to calculate fitness + * @param _negate true if fitness should be maxed + */ + moeoMetricFitnessAssignment(moeoUnaryMetric &_metric,eoEvalFunc &_eval, bool _negate=false) : metric(_metric),eval(_eval),negate(_negate) + {} + + /** + * Sets the fitness values for a moeot + * @param _mo the MOEOT + */ + void operator()(MOEOT & _mo){ + if (_mo.invalidObjectiveVector()) eval(_mo); + _mo.fitness(operator()(_mo.objectiveVector())); + + } + + /** + return the fitness of a valid objectiveVector + @param _mo the objectiveVector + @return the fitness value of _mo + */ + typename MOEOT::Fitness operator()(const typename MOEOT::ObjectiveVector & _mo){ + if (negate) + return 1/metric(_mo); + else return metric(_mo); + } + + + /** + * Sets the fitness values for every solution contained in the population _pop (and in the archive) + * @param _pop the population + */ + void operator()(eoPop < MOEOT > & _pop) + { + unsigned int pop_size= _pop.size(); + for (unsigned int k=0; k & _pop, ObjectiveVector & _objVec) + { + //std::cout << "WARNING : updateByDeleting not implemented in moeoAssignmentFitnessAssignment" << std::endl; + } + + + private: + + moeoUnaryMetric &metric; + eoEvalFunc &eval; + bool negate; + class DummyEval: public eoEvalFunc{ + void operator()(MOEOT &moeo){ + } + } defaultEval; + +}; + +#endif /*MOEOMETRICFITNESSASSIGNMENT_H_*/ diff --git a/trunk/paradiseo-moeo/src/fitness/moeoSingleObjectivization.h b/trunk/paradiseo-moeo/src/fitness/moeoSingleObjectivization.h new file mode 100644 index 000000000..f3ecbba06 --- /dev/null +++ b/trunk/paradiseo-moeo/src/fitness/moeoSingleObjectivization.h @@ -0,0 +1,67 @@ +/* +* +* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2009 +* (C) OPAC Team, LIFL, 2002-2007 +* +* François Legillon +* +* This software is governed by the CeCILL license under French law and +* abiding by the rules of distribution of free software. You can use, +* modify and/ or redistribute the software under the terms of the CeCILL +* license as circulated by CEA, CNRS and INRIA at the following URL +* "http://www.cecill.info". +* +* As a counterpart to the access to the source code and rights to copy, +* modify and redistribute granted by the license, users are provided only +* with a limited warranty and the software's author, the holder of the +* economic rights, and the successive licensors have only limited liability. +* +* In this respect, the user's attention is drawn to the risks associated +* with loading, using, modifying and/or developing or reproducing the +* software by the user in light of its specific status of free software, +* that may mean that it is complicated to manipulate, and that also +* therefore means that it is reserved for developers and experienced +* professionals having in-depth computer knowledge. Users are therefore +* encouraged to load and test the software's suitability as regards their +* requirements in conditions enabling the security of their systems and/or +* data to be ensured and, more generally, to use and operate it in the +* same conditions as regards security. +* The fact that you are presently reading this means that you have had +* knowledge of the CeCILL license and that you accept its terms. +* +* ParadisEO WebSite : http://paradiseo.gforge.inria.fr +* Contact: paradiseo-help@lists.gforge.inria.fr +* +*/ +//----------------------------------------------------------------------------- + +#ifndef MOEOSINGLEOBJECTIVIZATION_H_ +#define MOEOSINGLEOBJECTIVIZATION_H_ + +#include +#include +/** + * Class to adapt multiobjective problems to single objective algorithms + */ +template < class MOEOT > +class moeoSingleObjectivization : public moeoFitnessAssignment < MOEOT > , public eoEvalFunc < MOEOT > + { + public: + + /** + * herited from moeoFitnessAssignment + * @param _pop the population + */ + virtual void operator () (eoPop < MOEOT > & _pop)=0; + + /** + herited from eoEvalFunc + @param _moeot + */ + virtual void operator() (MOEOT & _moeot)=0; + + virtual typename MOEOT::Fitness operator() (const typename MOEOT::ObjectiveVector & _obj)=0; + + }; + +#endif /*MOEOSINGLEOBJECTIVIZATION_H_*/ diff --git a/trunk/paradiseo-moeo/src/fitness/moeoWeightedChebychevMetricFitnessAssignment.h b/trunk/paradiseo-moeo/src/fitness/moeoWeightedChebychevMetricFitnessAssignment.h new file mode 100644 index 000000000..68de7e748 --- /dev/null +++ b/trunk/paradiseo-moeo/src/fitness/moeoWeightedChebychevMetricFitnessAssignment.h @@ -0,0 +1,149 @@ +/* + * + * Copyright (C) DOLPHIN Project-Team, INRIA Lille-Nord Europe, 2006-2008 + * (C) OPAC Team, LIFL, 2002-2008 + * + * François Legillon + * + * This software is governed by the CeCILL license under French law and + * abiding by the rules of distribution of free software. You can use, + * modify and/ or redistribute the software under the terms of the CeCILL + * license as circulated by CEA, CNRS and INRIA at the following URL + * "http://www.cecill.info". + * + * As a counterpart to the access to the source code and rights to copy, + * modify and redistribute granted by the license, users are provided only + * with a limited warranty and the software's author, the holder of the + * economic rights, and the successive licensors have only limited liability. + * + * In this respect, the user's attention is drawn to the risks associated + * with loading, using, modifying and/or developing or reproducing the + * software by the user in light of its specific status of free software, + * that may mean that it is complicated to manipulate, and that also + * therefore means that it is reserved for developers and experienced + * professionals having in-depth computer knowledge. Users are therefore + * encouraged to load and test the software's suitability as regards their + * requirements in conditions enabling the security of their systems and/or + * data to be ensured and, more generally, to use and operate it in the + * same conditions as regards security. + * The fact that you are presently reading this means that you have had + * knowledge of the CeCILL license and that you accept its terms. + * + * ParadisEO WebSite : http://paradiseo.gforge.inria.fr + * Contact: paradiseo-help@lists.gforge.inria.fr + * + */ +//----------------------------------------------------------------------------- +// moeoWeightedChebychevMetricFitnessAssignment.h +//----------------------------------------------------------------------------- +#ifndef MOEOCHEVMETRICFITNESSASSIGNMENT_H_ +#define MOEOCHEVMETRICFITNESSASSIGNMENT_H_ + +#include +#include +#include +#include +#include +#include +#include + +/* + * Fitness assignment scheme which use a metric + */ +template < class MOEOT> +class moeoWeightedChebychevMetricFitnessAssignment : public moeoSingleObjectivization < MOEOT > +{ + public: + + /** the objective vector type of the solutions */ + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + typedef typename MOEOT::Fitness Fitness; + typedef typename ObjectiveVector::Type Type; + + /** + * ctor with normalizer + * @param _rho + * @param _reference the reference point + * @param _weight the weights applied to the objectives + * @param _normalizer the normalizer to apply to objectiveVectors + */ + moeoWeightedChebychevMetricFitnessAssignment(unsigned int _rho, const ObjectiveVector& _reference, const ObjectiveVector& _weight, moeoObjectiveVectorNormalizer& _normalizer) : normalizer(_normalizer), eval(defaultEval), distance(_rho, _weight), metric(distance, _reference, _normalizer){} + + /** + * ctor with an evaluation fonction, applied if give moeot is invalid + * @param _rho + * @param _reference the reference point + * @param _weight the weights applied to the objectives + * @param _eval a evalFunc to regenerate the objectiveVector if needed + */ + moeoWeightedChebychevMetricFitnessAssignment(unsigned int _rho, const ObjectiveVector& _reference, const ObjectiveVector& _weight, eoEvalFunc& _eval) : eval(_eval), normalizer(defaultNormalizer), distance(_rho, _weight), metric(distance, _reference, normalizer){} + + /** + * ctor with an evaluation fonction, applied if give moeot is invalid, and a noramlizer, applied to ObjectiveVectors + * @param _rho + * @param _reference the reference point + * @param _weight the weights applied to the objectives + * @param _normalizer the normalizer to apply to objectiveVectors + * @param _eval a evalFunc to regenerate the objectiveVector if needed + */ + moeoWeightedChebychevMetricFitnessAssignment(unsigned int _rho, const ObjectiveVector& _reference, const ObjectiveVector& _weight, moeoObjectiveVectorNormalizer& _normalizer, eoEvalFunc& _eval) : normalizer(_normalizer), eval(_eval), distance(_rho, _weight), metric(distance, _reference, normalizer){} + + /** + default constructor + * @param _rho + * @param _reference the reference point + * @param _weight the weights applied to the objectives + */ + moeoWeightedChebychevMetricFitnessAssignment(unsigned int _rho, const ObjectiveVector& _reference, const ObjectiveVector& _weight) : eval(defaultEval), normalizer(defaultNormalizer), distance(_rho, _weight), metric(distance, _reference, normalizer){} + + /** + * Sets the fitness values for a moeot + * @param _mo the MOEOT + */ + void operator()(MOEOT & _mo){ + if (_mo.invalidObjectiveVector()) + eval(_mo); + _mo.fitness(operator()(_mo.objectiveVector())); + } + + /** + return the fitness of a valid objectiveVector + @param _mo the objectiveVector + @return the fitness value of _mo + */ + typename MOEOT::Fitness operator()(const typename MOEOT::ObjectiveVector & _mo){ + return -metric(_mo); + } + + /** + * Sets the fitness values for every solution contained in the population _pop (and in the archive) + * @param _pop the population + */ + void operator()(eoPop < MOEOT > & _pop) + { + for (unsigned int k=0; k < _pop.size(); k++) + operator()(_pop[k]); + } + + /** + * @param _pop the population + * @param _objVec the objective vector + */ + void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec){} + + private: + + moeoWeightedChebychevDistance distance; + moeoObjectiveVectorNormalizer defaultNormalizer; + moeoObjectiveVectorNormalizer& normalizer; + moeoDistanceMetric metric; + eoEvalFunc &eval; + + class DummyEval: public eoEvalFunc{ + void operator()(MOEOT &moeo){ + } + } defaultEval; + +}; + +#endif /*moeoWeightedChebychevMetricFitnessASSIGNMENT_H_*/ diff --git a/trunk/paradiseo-moeo/src/metric/moeoDistanceMetric.h b/trunk/paradiseo-moeo/src/metric/moeoDistanceMetric.h new file mode 100644 index 000000000..fc5626982 --- /dev/null +++ b/trunk/paradiseo-moeo/src/metric/moeoDistanceMetric.h @@ -0,0 +1,86 @@ +/* + * + * Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007 + * (C) OPAC Team, LIFL, 2002-2007 + * + * Jeremie Humeau + * Arnaud Liefooghe + * François Legillon + * + * This software is governed by the CeCILL license under French law and + * abiding by the rules of distribution of free software. You can use, + * modify and/ or redistribute the software under the terms of the CeCILL + * license as circulated by CEA, CNRS and INRIA at the following URL + * "http://www.cecill.info". + * + * As a counterpart to the access to the source code and rights to copy, + * modify and redistribute granted by the license, users are provided only + * with a limited warranty and the software's author, the holder of the + * economic rights, and the successive licensors have only limited liability. + * + * In this respect, the user's attention is drawn to the risks associated + * with loading, using, modifying and/or developing or reproducing the + * software by the user in light of its specific status of free software, + * that may mean that it is complicated to manipulate, and that also + * therefore means that it is reserved for developers and experienced + * professionals having in-depth computer knowledge. Users are therefore + * encouraged to load and test the software's suitability as regards their + * requirements in conditions enabling the security of their systems and/or + * data to be ensured and, more generally, to use and operate it in the + * same conditions as regards security. + * The fact that you are presently reading this means that you have had + * knowledge of the CeCILL license and that you accept its terms. + * + * ParadisEO WebSite : http://paradiseo.gforge.inria.fr + * Contact: paradiseo-help@lists.gforge.inria.fr + * + */ +//----------------------------------------------------------------------------- +#ifndef MOEODISTANCEMETRIC_H_ +#define MOEODISTANCEMETRIC_H_ + +#include +#include + +/** + Adapter to use Distances as a metric + */ +template < class MOEOT> +class moeoDistanceMetric : public moeoUnaryMetric < typename MOEOT::ObjectiveVector , typename MOEOT::Fitness > +{ + public: + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + typedef typename MOEOT::Fitness Fitness; + + /** + constructor with a normalizer + @param _distance the distance + @param _referencePoint the point from which we evaluate the distance + @param _normalizer the normalizer + */ + moeoDistanceMetric(moeoObjSpaceDistance &_distance, const ObjectiveVector &_referencePoint,moeoObjectiveVectorNormalizer& _normalizer): distance(_distance), reference(_referencePoint),normalizer(_normalizer){} + + /** + constructor with a dummy normalizer + @param _distance the distance + @param _referencePoint the point from which we evaluate the distance + */ + moeoDistanceMetric(moeoObjSpaceDistance &_distance, const ObjectiveVector &_referencePoint): distance(_distance), reference(_referencePoint),normalizer(defaultNormalizer){} + + /** + fonction which apply the metric to calculate a fitness + @param _obj the point to evaluate + @return the fitness conrresponding to the distance + */ + Fitness operator()(ObjectiveVector _obj){ + return distance(normalizer(reference), normalizer(_obj)); + } + + private: + moeoObjectiveVectorNormalizer defaultNormalizer; + moeoObjectiveVectorNormalizer& normalizer; + moeoObjSpaceDistance& distance; + const ObjectiveVector& reference; + +}; +#endif diff --git a/trunk/paradiseo-moeo/src/moeo b/trunk/paradiseo-moeo/src/moeo index bb78197dd..51ed42f81 100644 --- a/trunk/paradiseo-moeo/src/moeo +++ b/trunk/paradiseo-moeo/src/moeo @@ -61,7 +61,7 @@ #include #include #include -#include +//#include #include @@ -91,9 +91,14 @@ #include #include +#include #include #include #include +#include +#include +#include +#include #include #include @@ -104,8 +109,10 @@ #include #include +#include #include #include +#include #include #include #include @@ -117,7 +124,13 @@ #include #include #include +#include #include +#include +#include +#include +#include + #include #include @@ -130,6 +143,7 @@ #include #include #include +#include #include #include diff --git a/trunk/paradiseo-moeo/src/utils/moeoObjectiveVectorNormalizer.h b/trunk/paradiseo-moeo/src/utils/moeoObjectiveVectorNormalizer.h index b56611e5a..742102ef1 100644 --- a/trunk/paradiseo-moeo/src/utils/moeoObjectiveVectorNormalizer.h +++ b/trunk/paradiseo-moeo/src/utils/moeoObjectiveVectorNormalizer.h @@ -55,9 +55,10 @@ class moeoObjectiveVectorNormalizer /** constructor with a supplied scale, usefull if you tweak your scale - @param scale the scale for noramlzation + @param _scale the scale for noramlzation + @param max_param the returned values will be between 0 and max */ - moeoObjectiveVectorNormalizer(Scale &_scale,Type max_param=100):scale(_scale),max(max_param) + moeoObjectiveVectorNormalizer(Scale _scale=make_dummy_scale(),Type max_param=100):scale(_scale),max(max_param) {} /** constructor to create a normalizer from a given population @@ -68,15 +69,17 @@ class moeoObjectiveVectorNormalizer {} /** constructor to create a normalizer with given boundaries - @param boundaries the supplied vectors should have their values between thos boundaries + @param _boundaries the supplied vectors should have their values between thos boundaries + @param max_param the returned values will be between 0 and max **/ moeoObjectiveVectorNormalizer(std::vector &_boundaries, Type max_param=100):scale(make_scale_from_bounds(_boundaries,max_param)), max(max_param) {} /** constructor to create a normalizer from bounds - @param bounds the supplied vectors should have their value in those bounds + @param _bounds the supplied vectors should have their value in those bounds + @param max_param the returned values will be between 0 and max **/ - moeoObjectiveVectorNormalizer(Bounds &_bounds, Type max_param=100 ):scale(make_scale_from_bounds(_bounds,ObjectiveVector::nObjectives(),max_param)), max(max_param) + moeoObjectiveVectorNormalizer(Bounds &_bounds, Type max_param=100 ):scale(make_scale_from_bounds(_bounds,max_param)), max(max_param) {} /** constructor to create a normalizer from a worst vector and a best vector @@ -141,11 +144,11 @@ class moeoObjectiveVectorNormalizer /** create a scale from bounds - @param boundaries the boundaries + @param _boundaries the boundaries @param max the maximum for returned values @return a scale */ - static Scale make_scale_from_bounds(std::vector &_boundaries,Type max=100){ + static Scale make_scale_from_bounds(const std::vector &_boundaries,Type max=100){ Scale res; for (unsigned i=0;i<_boundaries.size();i++){ std::vector coeff; @@ -162,8 +165,9 @@ class moeoObjectiveVectorNormalizer @param max the maximum for returned values @return a scale */ - static Scale make_scale_from_bounds(Bounds &bounds,int dim,Type max=100){ + static Scale make_scale_from_bounds(const Bounds &bounds,Type max=100){ Scale res; + unsigned int dim=MOEOT::ObjectiveVector::nObjectives(); for (unsigned i=0;i coeff; coeff.push_back(max/(bounds.maximum()-bounds.minimum())); @@ -190,6 +194,22 @@ class moeoObjectiveVectorNormalizer } return res; } + + /** + create a default scale that does nothing when applied + @return a dummy scale + */ + static Scale make_dummy_scale(){ + unsigned int dim=MOEOT::ObjectiveVector::nObjectives(); + Scale res; + for (unsigned int i=0;i coeff; + coeff.push_back(1); + coeff.push_back(0); + res.push_back(coeff); + } + return res; + } /** * main fonction, normalize a vector. All objective returned vectors will be between 0 and max previously * supplied, be carefull about a possible rounding error. @@ -221,6 +241,7 @@ class moeoObjectiveVectorNormalizer /** fast(to use, not in complexity) function to normalize a population @param pop the population to normalize + @param max the returned values will be between 0 and max @return a vector of normalized Objective vectors < max */ static std::vector normalize(const eoPop &pop, Type &max){ @@ -231,20 +252,33 @@ class moeoObjectiveVectorNormalizer /** Change the scale according to a new pop. Should be called everytime pop is updated @param pop population to analyse - @param max_param the worst vector is is set to max_param */ void update_by_pop(eoPop pop){ scale=make_scale_from_pop(pop,max); } /** change the scale with the worst point and the best point - @param max the worst point - @param min the best point + @param _max the worst point + @param _min the best point */ void update_by_min_max(const ObjectiveVector &_min,const ObjectiveVector &_max){ scale=make_scale_from_minmax(_min,_max,max); } + /** change the scale according to given boundaries + @param boundaries a vector of bounds corresponding to the bounds in each dimension + */ + void update_by_bounds(const std::vector &boundaries){ + scale=make_scale_from_bounds(boundaries); + } + /** change the scale according to bounds,them same is used in each dimension + @param bounds bounds corresponding to the bounds in each dimension + */ + void update_by_bounds(const Bounds &bounds){ + scale=make_scale_from_bounds(bounds); + } + + /** updates the scale @param _scale the new scale @@ -265,10 +299,7 @@ class moeoObjectiveVectorNormalizer } max=_max; } - protected: - moeoObjectiveVectorNormalizer() - { - } + private: Scale scale; Type max; diff --git a/trunk/paradiseo-moeo/src/utils/moeoQuadTree.h b/trunk/paradiseo-moeo/src/utils/moeoQuadTree.h index ba66cb345..e3244be0e 100644 --- a/trunk/paradiseo-moeo/src/utils/moeoQuadTree.h +++ b/trunk/paradiseo-moeo/src/utils/moeoQuadTree.h @@ -74,7 +74,7 @@ public: } private: - ObjectiveVector& objVec; + ObjectiveVector objVec; std::map*> subTree; }; @@ -119,10 +119,13 @@ public: if(!(root->getSubTree().empty())){ QuadTreeIterator it=root->getSubTree().begin(); while(!stop && (it != root->getSubTree().end())){ - std::cout << "hop" << std::endl; - if( ((*it).first < succ) && (((succ ^ bound) & ((*it).first ^ bound))== succ) ){ + if((*it).second != NULL){ + std::cout << "hop"<getSubTree().begin(); while(it != root->getSubTree().end()){ - if( (succ < (*it).first) && ((succ & (*it).first) == succ)){ - test2(tmp, (*it).second, root, (*it).first); + if((*it).second != NULL){ + if( (succ < (*it).first) && ((succ & (*it).first) == succ)){ + test2(tmp, (*it).second, root, (*it).first); + } } it++; } @@ -141,6 +146,7 @@ public: QuadTreeNode* tmp = new QuadTreeNode(_obj); // std::cout << "insert case new son: " << root->getVec() << std::endl; if(root->setChild(succ, tmp)){ + std::cout << "\n\nthe root changed\n\n"; root=root->getSubTree()[succ]; } else{ @@ -154,6 +160,7 @@ public: stop=true; } } + std::cout << "realroot: " << realroot->getVec() << std::endl; root=realroot; } return res; @@ -165,6 +172,7 @@ public: * @param _objVec2 */ unsigned int k_succ(const ObjectiveVector& _objVec1, const ObjectiveVector& _objVec2){ + std::cout << "enter k_succ" << std::endl; unsigned int res=0; for(int i=0; i < ObjectiveVector::nObjectives(); i++){ if( (ObjectiveVector::minimizing(i) && ((_objVec1[i] - _objVec2[i]) >= (-1.0 * 1e-6 ))) || @@ -172,6 +180,7 @@ public: res+=pow(2,ObjectiveVector::nObjectives()-i-1); } } + std::cout << "quit k_succ" << std::endl; return res; } @@ -184,32 +193,39 @@ public: //create the new root QuadTreeNode* newroot = new QuadTreeNode(_newroot); //reconsider each son of the old root - if(!(root->getSubTree().empty())){ + if(!(root->getSubTree().empty())){ QuadTreeIterator it; for(it=(root->getSubTree()).begin(); it != (root->getSubTree()).end(); it++){ - std::cout << "replace: " << (*it).second->getVec() << std::endl; - reconsider(newroot, (*it).second); + std::cout << "on passe ici" << std::endl; + if((*it).second!=NULL){ + std::cout << "replace: " << (*it).second->getVec() << std::endl; + reconsider(newroot, (*it).second); + std::cout << "end replacement" << std::endl; + } } } + std::cout << "replace after reconsider" << std::endl; //replace the old root by the new one delete(root); root = newroot; std::cout << root << " -> "<< root->getVec() << std::endl; - + std::cout << "replace after change the root" << std::endl; + std::cout << "quit replace: " << std::endl; } void reconsider(QuadTreeNode* _newroot, QuadTreeNode* _child){ std::cout << "enter reconsider: " << std::endl; unsigned int succ; if(!(_child->getSubTree().empty())){ - std::cout << "enter reconsider" << std::endl; QuadTreeIterator it; for(it=(_child->getSubTree()).begin(); it != (_child->getSubTree()).end(); it++){ - std::cout << "reconsider: " << (*it).second->getVec() << std::endl; - QuadTreeNode* tmp=(*it).second; - _child->getSubTree()[(*it).first]=NULL; + if((*it).second != NULL){ + std::cout << "reconsider: " << (*it).second->getVec() << std::endl; + QuadTreeNode* tmp=(*it).second; + _child->getSubTree()[(*it).first]=NULL; - reconsider(_newroot, tmp); + reconsider(_newroot, tmp); + } } } else{ @@ -221,27 +237,30 @@ public: if(succ==bound) delete(_child); else if(_newroot->getSubTree()[succ] != NULL){ - std::cout << "hohoho" << std::endl; +// std::cout << "hohoho" << std::endl; reinsert(_newroot->getSubTree()[succ],_child); } else{ - std::cout << "houhouhou" << std::endl; +// std::cout << "houhouhou" << std::endl; _newroot->setChild(succ, _child); } + std::cout << "quit reconsider: " << std::endl; } void reinsert(QuadTreeNode* _node1, QuadTreeNode* _node2){ + std::cout << "enter reinsert: " << std::endl; if(_node1 != _node2){ - std::cout << "enter reinsert" << std::endl; std::cout << "node1: " << _node1->getVec() << ", node2: " << _node2->getVec() << std::endl; unsigned int succ; if(!(_node1->getSubTree().empty())){ QuadTreeIterator it; for(it=(_node1->getSubTree()).begin(); it != (_node1->getSubTree()).end(); it++){ - std::cout << "reinsert: " << (*it).second->getVec() << std::endl; - QuadTreeNode* tmp=(*it).second; - _node1->getSubTree().erase(it); - reinsert(_node1, tmp); + if((*it).second != NULL){ + std::cout << "reinsert: " << (*it).second->getVec() << std::endl; + QuadTreeNode* tmp=(*it).second; + _node1->getSubTree().erase(it); + reinsert(_node1, tmp); + } } } succ=k_succ(_node2->getVec(),_node1->getVec()); @@ -252,10 +271,12 @@ public: _node1->setChild(succ, _node2); } } + std::cout << "quit reinsert: " << std::endl; } void remove(QuadTreeNode* _node, QuadTreeNode* _parent, unsigned int _succ){ - std::cout << "enter remove" << std::endl; + std::cout << "enter remove -> " << _node->getVec() << std::endl; + printTree(); unsigned int k=1; QuadTreeNode* tmp=NULL; _parent->getSubTree()[_succ]=NULL; @@ -274,6 +295,8 @@ public: k++; } delete(_node); + std::cout << "quit remove: " << std::endl; + printTree(); } bool test1(QuadTreeNode* _node1, QuadTreeNode* _node2){ @@ -287,12 +310,15 @@ public: else{ QuadTreeIterator it=_node2->getSubTree().begin(); while(!res && (it != _node2->getSubTree().end())){ - if( ((succ ^ bound) & ((*it).first ^ bound)) == succ){ - res = res || test1(_node1, (*it).second); + if((*it).second!=NULL){ + if( ((succ ^ bound) & ((*it).first ^ bound)) == (succ^bound)){ + res = res || test1(_node1, (*it).second); + } } it++; } } + std::cout << "quit test1" << std::endl; return res; } @@ -302,6 +328,7 @@ public: unsigned int succ; succ=k_succ(_node1->getVec(), _node2->getVec()); if(succ==0){ +// std::cout << "\n\n\nPEUT ETRE ICI\n\n\n"; remove(_node2, _parent, _succ); if(_parent->getSubTree()[_succ]!=NULL) test2(_node1, _parent->getSubTree()[_succ], _parent, _succ); @@ -309,12 +336,15 @@ public: else{ QuadTreeIterator it=_node2->getSubTree().begin(); while(it != _node2->getSubTree().end()){ - if( (succ & (*it).first) == succ){ - test2(_node1, (*it).second, _node2, (*it).first); + if((*it).second!=NULL){ + if( (succ & (*it).first) == succ){ + test2(_node1, (*it).second, _node2, (*it).first); + } } it++; } } + std::cout << "quit test2" << std::endl; }