diff --git a/trunk/paradiseo-moeo/src/algo/moeoHC.h b/trunk/paradiseo-moeo/src/algo/moeoHC.h new file mode 100644 index 000000000..282f20c55 --- /dev/null +++ b/trunk/paradiseo-moeo/src/algo/moeoHC.h @@ -0,0 +1,99 @@ +/* + + Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2008 + (C) OPAC Team, LIFL, 2002-2008 + + Sébastien Cahon, Jean-Charles Boisson (Jean-Charles.Boisson@lifl.fr) + 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 __moeoHC_h +#define __moeoHC_h +#include +#include +#include +#include +#include +//! Hill Climbing (HC) +/*! + Class which describes the algorithm for a hill climbing. + Adapts the moHC for a multi-objective problem using a moeoSingleObjectivization. + M is for Move + */ +template +class moeoHC : public moeoSolAlgo < typename M::EOType > +{ + + public: + typedef typename M::EOType MOEOT; + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + typedef typename MOEOT::Fitness Fitness; + + //! Full constructor. + /*! + All the boxes are given in order the HC to use a moHCMoveLoopExpl. + + \param _move_initializer a move initialiser. + \param _next_move_generator a neighborhood explorer. + \param _incremental_evaluation a (generally) efficient evaluation function. + \param _move_selection a move selector. + \param _singler a singleObjectivizer to translate objectiveVectors into fitness + */ + moeoHC (moMoveInit < M > & _move_initializer, moNextMove < M > & _next_move_generator, + moMoveIncrEval < M,ObjectiveVector > & _incremental_evaluation, moMoveSelect < M > & _move_selection, moeoSingleObjectivization < MOEOT > & _singler) : + incrEval((new moeoIncrEvalSingleObjectivizer(_singler,_incremental_evaluation))), + moveLoop(new moeoHCMoveLoopExpl(_move_initializer,_next_move_generator,*(incrEval),_move_selection)), + algo(*(moveLoop), (_singler)) + {} + //! Function which launches the HC + /*! + The HC has to improve a current solution. + As the moSA and the mo TS, it can be used for HYBRIDATION in an evolutionnary algorithm. + + \param _solution a current solution to improve. + \return true. + */ + + bool operator()(MOEOT &_solution){ + if (_solution.invalidObjectiveVector()) { + (*incrEval)(_solution); + }else{ + } + return algo(_solution); + } + + private: + moeoIncrEvalSingleObjectivizer *incrEval; + moeoHCMoveLoopExpl *moveLoop; + //! the actual algo + moHC algo; + +}; +#endif diff --git a/trunk/paradiseo-moeo/src/algo/moeoILS.h b/trunk/paradiseo-moeo/src/algo/moeoILS.h new file mode 100644 index 000000000..6d80578c7 --- /dev/null +++ b/trunk/paradiseo-moeo/src/algo/moeoILS.h @@ -0,0 +1,156 @@ +/* + + Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2008 + (C) OPAC Team, LIFL, 2002-2008 + + Sébastien Cahon, Jean-Charles Boisson (Jean-Charles.Boisson@lifl.fr) + 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 _moeoILS_h +#define _moeoILS_h + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +//! Iterated Local Search (ILS) +/*! + Class which describes the algorithm for a iterated local search. + Adapts the moILS for a multi-objective problem using a moeoSingleObjectivization. + M is for Move + */ + +template < class M > +class moeoILS:public moeoSolAlgo < typename M::EOType > +{ + + public: + typedef typename M::EOType MOEOT; + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + typedef typename MOEOT::Fitness Fitness; + //! Generic constructor + /*! + Generic constructor using a moAlgo + + \param _algorithm The solution based heuristic to use. + \param _continue The stopping criterion. + \param _acceptance_criterion The acceptance criterion. + \param _perturbation The pertubation generator. + \param _full_evaluation The evaluation function. + */ + moeoILS (moeoSolAlgo & _algorithm, moSolContinue & _continue, moComparator & _acceptance_criterion, + eoMonOp & _perturbation, moeoSingleObjectivization & _full_evaluation): + algo(_algorithm,_continue,_acceptance_criterion,_perturbation,_full_evaluation) + {} + //! Constructor for using a moHC + /*! + \param _move_initializer The move initialisation (for the moHC). + \param _next_move_generator The move generator (for the moHC). + \param _incremental_evaluation The partial evaluation function (for the moHC). + \param _singler a singleObjectivizer to translate objectiveVectors into fitness + \param _move_selection The move selection strategy (for the moHC). + \param _continue The stopping criterion. + \param _acceptance_criterion The acceptance criterion. + \param _perturbation The pertubation generator. + */ + moeoILS (moMoveInit < M > & _move_initializer, moNextMove < M > & _next_move_generator, + moMoveIncrEval < M,ObjectiveVector > & _incremental_evaluation, moeoSingleObjectivization &_singler,moMoveSelect < M > & _move_selection, + moSolContinue & _continue, moComparator & _acceptance_criterion, + eoMonOp & _perturbation): + subAlgo(new moeoHC(_move_initializer,_next_move_generator,_incremental_evaluation,_move_selection,_singler)), + algo(*subAlgo,_continue,_acceptance_criterion,_perturbation,_singler) + {} + //! Constructor for using a moTS for the moAlgo + /*! + \param _move_initializer The move initialisation (for the moTS). + \param _next_move_generator The move generator (for the moTS). + \param _incremental_evaluation The partial evaluation function (for the moTS). + \param _singler a singleObjectivizer to translate objectiveVectors into fitness + \param _tabu_list The tabu list (for the moTS !!!!). + \param _aspiration_criterion The aspiration criterion (for the moTS). + \param _moTS_continue The stopping criterion (for the moTS). + \param _continue The stopping criterion. + \param _acceptance_criterion The acceptance criterion. + \param _perturbation The pertubation generator. + */ + + moeoILS (moMoveInit & _move_initializer, moNextMove & _next_move_generator,moMoveIncrEval & _incremental_evaluation, moeoSingleObjectivization &_singler, moTabuList & _tabu_list,moAspirCrit & _aspiration_criterion, moSolContinue & _moTS_continue,moSolContinue & _continue, moComparator & _acceptance_criterion, eoMonOp & _perturbation): + subAlgo(new moeoTS(_move_initializer,_next_move_generator,_incremental_evaluation,_tabu_list,_aspiration_criterion,_moTS_continue,_singler)), + algo((*subAlgo),_continue,_acceptance_criterion,_perturbation,_singler) + {} + //! Constructor for using a moSA for the moAlgo + /*! + \param _random_move_generator The random move generator (for the moSA). + \param _incremental_evaluation The partial evaluation function (for the moSA). + \param _singler a singleObjectivizer to translate objectiveVectors into fitness + \param _moSA_continue The stopping criterion (for the moSA). + \param _initial_temperature The initial temperature (for the moSA). + \param _cooling_schedule The cooling schedule (for the moSA). + \param _continue The stopping criterion. + \param _acceptance_criterion The acceptance criterion. + \param _perturbation The pertubation generator. + */ + moeoILS (moRandMove & _random_move_generator, moMoveIncrEval & _incremental_evaluation,moeoSingleObjectivization &_singler, moSolContinue & _moSA_continue,double _initial_temperature, moCoolingSchedule & _cooling_schedule, moSolContinue & _continue,moComparator & _acceptance_criterion, eoMonOp & _perturbation): + subAlgo(new moeoSA(_random_move_generator, _incremental_evaluation, _moSA_continue, _initial_temperature,_cooling_schedule, _singler)), + algo(*subAlgo,_continue, _acceptance_criterion, _perturbation, _singler) + {} + + + + //! Function which launches the ILS + /*! + The ILS has to improve a current solution. + + \param _solution a current solution to improve. + \return true. + */ + bool operator()(MOEOT &_solution){ +// std::cout<<"moeoILS"< *subAlgo; + //! the actual algo + moILS algo; + + +}; +#endif diff --git a/trunk/paradiseo-moeo/src/algo/moeoSA.h b/trunk/paradiseo-moeo/src/algo/moeoSA.h new file mode 100644 index 000000000..f6c6da306 --- /dev/null +++ b/trunk/paradiseo-moeo/src/algo/moeoSA.h @@ -0,0 +1,85 @@ +/* + + Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2008 + (C) OPAC Team, LIFL, 2002-2008 + + Sébastien Cahon, Jean-Charles Boisson (Jean-Charles.Boisson@lifl.fr) + 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 __moeoSA_h +#define __moeoSA_h + +#include +#include +#include +#include +#include +#include +//! Simulated annealing (SA) +/*! + Generic algorithm that describes a Simulated Annealing algorithm. + Adapts the moSA for a multi-objective problem using a moeoSingleObjectivization. + M is for Move + */ + +template < class M > +class moeoSA:public moeoSolAlgo < typename M::EOType > +{ + + public: + + typedef typename M::EOType MOEOT; + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + typedef typename MOEOT::Fitness Fitness; + moeoSA (moRandMove < M > & _random_move_generator, moMoveIncrEval < M,ObjectiveVector > & _incremental_evaluation, + moSolContinue < MOEOT > & _continue, double _initial_temperature, moCoolingSchedule & _cooling_schedule, + moeoSingleObjectivization &_singler): + incrEval(_singler,_incremental_evaluation), + algo(_random_move_generator,incrEval,_continue,_initial_temperature,_cooling_schedule, _singler) + {} + /*! + Algorithm of the SA + As a moHC, it can be used for HYBRIDATION in an evolutionary algorithm. + + \param _solution a solution to improve. + \return TRUE. + */ + bool operator()(MOEOT &_solution){ + return algo(_solution); + } + + private: + moeoIncrEvalSingleObjectivizer incrEval; + //! the actual algo + moSA algo; + +}; +#endif diff --git a/trunk/paradiseo-moeo/src/algo/moeoSolAlgo.h b/trunk/paradiseo-moeo/src/algo/moeoSolAlgo.h new file mode 100755 index 000000000..4bdafc583 --- /dev/null +++ b/trunk/paradiseo-moeo/src/algo/moeoSolAlgo.h @@ -0,0 +1,55 @@ +/* +* +* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007 +* (C) OPAC Team, LIFL, 2002-2007 +* +* Arnaud Liefooghe +* Jérémie Humeau +* 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 MOEOSOLALGO_H_ +#define MOEOSOLALGO_H_ + +#include +#include +#include + +/** + * Abstract class for Solution based multi-objective evolutionary algorithms. + */ +template < class MOEOT > +class moeoSolAlgo : public moAlgo, public moeoAlgo +{ +}; + +#endif /*MOEOSOLALGO_H_*/ diff --git a/trunk/paradiseo-moeo/src/algo/moeoTS.h b/trunk/paradiseo-moeo/src/algo/moeoTS.h new file mode 100644 index 000000000..cbbfb30b6 --- /dev/null +++ b/trunk/paradiseo-moeo/src/algo/moeoTS.h @@ -0,0 +1,102 @@ +/* + + Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2008 + (C) OPAC Team, LIFL, 2002-2008 + + Sébastien Cahon, Jean-Charles Boisson (Jean-Charles.Boisson@lifl.fr) + 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 __moeoTS_h +#define __moeoTS_h + +#include +#include +#include +#include +#include +//! Tabu Search (TS) +/*! + Generic algorithm that describes a tabu search. + Adapts the moTS for a multi-objective problem using a moeoSingleObjectivization. + M is for Move + */ + +template < class M > +class moeoTS:public moeoSolAlgo < typename M::EOType > +{ + + public: + typedef typename M::EOType MOEOT; + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + typedef typename MOEOT::Fitness Fitness; + + //! Full constructor. + /*! + All the boxes are given in order the TS to use a moTSMoveLoopExpl. + + \param _move_initializer a move initialiser. + \param _next_move_generator a neighborhood explorer. + \param _incremental_evaluation a (generally) efficient evaluation function. + \param _tabu_list The tabu list. + \param _aspiration_criterion An aspiration criterion. + \param _continue The stopping criterion. + \param _singler a singleObjectivizer to translate objectiveVectors into fitness + */ + moeoTS (moMoveInit < M > & _move_initializer, moNextMove < M > & _next_move_generator, + moMoveIncrEval < M, typename MOEOT::ObjectiveVector > & _incremental_evaluation, moTabuList < M > & _tabu_list, + moAspirCrit < M > & _aspiration_criterion, moSolContinue < MOEOT > & _continue, + moeoSingleObjectivization &_singler): + incrEval(_singler,_incremental_evaluation), + moveLoop(_move_initializer,_next_move_generator,incrEval,_tabu_list,_aspiration_criterion), + algo(moveLoop,_continue,_singler) + {} + + //! Function which launchs the Tabu Search + /*! + Algorithm of the tabu search. + As a moSA or a moHC, it can be used for HYBRIDATION in an evolutionary algorithm. + For security a lock (pthread_mutex_t) is closed during the algorithm. + + \param _solution a solution to improve. + \return TRUE. + */ + bool operator()(MOEOT &_solution){ + return algo(_solution); + } + + private: + moeoIncrEvalSingleObjectivizer incrEval; + moeoTSMoveLoopExpl moveLoop; + //! the actual algo + moTS algo; + +}; +#endif diff --git a/trunk/paradiseo-moeo/src/algo/moeoVNS.h b/trunk/paradiseo-moeo/src/algo/moeoVNS.h new file mode 100644 index 000000000..09fe2cd56 --- /dev/null +++ b/trunk/paradiseo-moeo/src/algo/moeoVNS.h @@ -0,0 +1,86 @@ +/* + + Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2008 + (C) OPAC Team, LIFL, 2002-2008 + + Sébastien Cahon, Jean-Charles Boisson (Jean-Charles.Boisson@lifl.fr) + 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 _moeoVNS_h +#define _moeoVNS_h + +#include +#include +#include +#include +#include +#include +//! Variable Neighbors Search (VNS) +/*! + Class which describes the algorithm for a Variable Neighbors Search. + Adapts the moVNS for a multi-objective problem using a moeoSingleObjectivization. + M is for Move + */ + +template < class MOEOT > +class moeoVNS:public moeoSolAlgo < MOEOT > +{ + + public: +// typedef typename M::EOType MOEOT; + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + typedef typename MOEOT::Fitness Fitness; + //! Generic constructor + /*! + Generic constructor using a moExpl + + \param _explorer Vector of Neighborhoods. + \param _full_evaluation The singleObjectivization containing a full eval. + */ + moeoVNS(moExpl< MOEOT> & _explorer, moeoSingleObjectivization < MOEOT> & _full_evaluation): algo(_explorer,_full_evaluation) {} + + //! Function which launches the VNS + /*! + The VNS has to improve a current solution. + + \param _solution a current solution to improve. + \return true. + */ + bool operator()(MOEOT &_solution){ + return algo(_solution); + } + + private: + //! the actual algo + moVNS algo; + +}; +#endif diff --git a/trunk/paradiseo-moeo/src/explorer/moeoHCMoveLoopExpl.h b/trunk/paradiseo-moeo/src/explorer/moeoHCMoveLoopExpl.h new file mode 100755 index 000000000..ae3c8f820 --- /dev/null +++ b/trunk/paradiseo-moeo/src/explorer/moeoHCMoveLoopExpl.h @@ -0,0 +1,148 @@ +/* + + Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2008 + (C) OPAC Team, LIFL, 2002-2008 + + Sébastien Cahon, Jean-Charles Boisson (Jean-Charles.Boisson@lifl.fr) + + 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 __moeoHCLoopExpl_h +#define __moeoHCLoopExpl_h + +#include +#include +#include +#include +#include +#include +#include +/** + move explorer for multiobjectives solutions + */ +template < class M > +class moeoHCMoveLoopExpl:public moMoveLoopExpl < M > +{ + //! Alias for the type. + typedef typename M::EOType EOT; + + //! Alias for the fitness. + typedef typename M::EOType::Fitness Fitness; + + typedef typename M::EOType::ObjectiveVector ObjectiveVector; + + public: + + //! Constructor. + /*! + All the boxes have to be specified. + + \param _move_initializer The move initialiser. + \param _next_move_generator The neighbourhood explorer. + \param _incremental_evaluation (generally) Efficient evaluation function. + \param _move_selection The move selector. + */ + moeoHCMoveLoopExpl (moMoveInit < M > & _move_initializer, moNextMove < M > & _next_move_generator, + moeoIncrEvalSingleObjectivizer < EOT,M > & _incremental_evaluation, moMoveSelect < M > & _move_selection) : + move_initializer (_move_initializer), next_move_generator (_next_move_generator), + incremental_evaluation (_incremental_evaluation), move_selection (_move_selection) + {} + + //! Procedure which launches the explorer. + /*! + The exploration starts from an old solution and provides a new solution. + + \param _old_solution The current solution. + \param _new_solution The new solution (result of the procedure). + */ + void operator () (const EOT & _old_solution, EOT & _new_solution) + { + M move, best_move; + Fitness best_fitness; + bool has_next_move, selection_update_is_ok; + + if( _old_solution.invalid() ) + { + throw std::runtime_error("[moHCMoveLoopExpl.h]: The current solution has not been evaluated."); + } + + /* + The two following lines are added to avoid compilation warning. + <=> current best move fitness is the current fitness. + <=> move and best move are empty for the moment. + */ + best_fitness=_old_solution.fitness(); + move=best_move; + //At the begining, the new sol is equivalent to the old one. + _new_solution=(EOT)_old_solution; + + // Restarting the exploration of the neighbourhood + move_initializer(move, _old_solution); + + move_selection.init(_old_solution.fitness ()); + + do + { + selection_update_is_ok = move_selection.update (move, incremental_evaluation(move, _old_solution) ); + has_next_move = next_move_generator (move, _old_solution); + } + while ( selection_update_is_ok && has_next_move); + //The selecter gives the value of the best move and the corresponding best fitness. + move_selection (best_move, best_fitness); + + /*std::cout<<"bonjour moeoloopexpl"< & move_initializer; + + //! Neighborhood explorer. + moNextMove < M > & next_move_generator; + + //! (generally) Efficient evaluation. + moeoIncrEvalSingleObjectivizer < EOT,M > & incremental_evaluation; + + //! Move selector. + moMoveSelect < M > & move_selection; +}; + +#endif diff --git a/trunk/paradiseo-moeo/src/explorer/moeoTSMoveLoopExpl.h b/trunk/paradiseo-moeo/src/explorer/moeoTSMoveLoopExpl.h new file mode 100755 index 000000000..9f38ad39f --- /dev/null +++ b/trunk/paradiseo-moeo/src/explorer/moeoTSMoveLoopExpl.h @@ -0,0 +1,175 @@ +/* + + Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2008 + (C) OPAC Team, LIFL, 2002-2008 + + Sébastien Cahon, Jean-Charles Boisson (Jean-Charles.Boisson@lifl.fr) + + 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 _moeoTSMoveLoopExpl_h +#define _moeoTSMoveLoopExpl_h +#include +#include +#include +#include +#include +#include +#include +#include +#include + + + +template +class moeoTSMoveLoopExpl:public moMoveLoopExpl < M > +{ + //!Alias for the type + typedef typename M::EOType EOT; + + //!Alias for the fitness + typedef typename M::EOType::Fitness Fitness; + + public: + + //!Constructor + /*! + \param _move_initializer The move initializer. + \param _next_move_generator The neighbourhood explorer. + \param _incremental_evaluation A (generally) efficient evaluation. + \param _tabu_list The tabu list. + \param _aspiration_criterion An aspiration criterion. + */ + moeoTSMoveLoopExpl (moMoveInit < M > & _move_initializer, moNextMove < M > & _next_move_generator, moeoIncrEvalSingleObjectivizer < EOT, M > & _incremental_evaluation, moTabuList < M > & _tabu_list, moAspirCrit < M > & _aspiration_criterion): + move_initializer(_move_initializer), + next_move_generator(_next_move_generator), + incremental_evaluation(_incremental_evaluation), + tabu_list(_tabu_list), + aspiration_criterion(_aspiration_criterion) + { + tabu_list.init (); + aspiration_criterion.init (); + } + //!Procedure which lauches the exploration + /*! + The exploration continues while the chosen move is not in the tabu list + or the aspiration criterion is true. If these 2 conditions are not true, the + exploration stops if the move selector update function returns false. + + \param _old_solution the initial solution + \param _new_solution the new solution + */ + void operator () (const EOT & _old_solution, EOT & _new_solution) + { + M move, best_move; + Fitness fitness, best_move_fitness; + + bool move_is_tabu, aspiration_criterion_is_verified, selection_update_is_ok, has_next_move; + + if( _old_solution.invalidFitness() || _old_solution.invalid() ) + { + throw std::runtime_error("[moTSMoveLoopExpl.h]: The current solution has not been evaluated."); + } + + //At the begining, the new solution is equivalent to the old one. + _new_solution=(EOT)_old_solution; + // EOT mem(_old_solution); + + + // Restarting the exploration of of the neighborhood ! + move_initializer (move, _old_solution); + + move_selection.init( _old_solution.fitness() ); + + selection_update_is_ok=true; +// std::cout<<"moeoTS lets go"< & move_initializer; + + //! Neighborhood explorer + moNextMove < M > & next_move_generator; + + //! Efficient evaluation + moeoIncrEvalSingleObjectivizer < EOT,M > & incremental_evaluation; + + //! Move selector + moBestImprSelect < M > move_selection; + + //! Tabu list + moTabuList < M > & tabu_list; + + //! Aspiration criterion + moAspirCrit < M > & aspiration_criterion; +}; + +#endif diff --git a/trunk/paradiseo-moeo/src/fitness/moeoIncrEvalSingleObjectivizer.h b/trunk/paradiseo-moeo/src/fitness/moeoIncrEvalSingleObjectivizer.h new file mode 100644 index 000000000..f4b894014 --- /dev/null +++ b/trunk/paradiseo-moeo/src/fitness/moeoIncrEvalSingleObjectivizer.h @@ -0,0 +1,121 @@ +/* +* +* 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 MOEOINCREVALSINGLEOBJECTIVIZER_H_ +#define MOEOINCREVALSINGLEOBJECTIVIZER_H_ + +#include +#include +#include <../../paradiseo-mo/src/moMoveIncrEval.h> +//#include +#include +#include +#include + +/** + * Class to adapt mo algorithms (moTS moVNC...) for multiobjectives + * This class play a moMoveIncrEval but can be used with multi objectives + * Use a Singleobjectivizer to set the fitness value according to each dimension + */ +template < class MOEOT , class Move > +class moeoIncrEvalSingleObjectivizer : public moeoSingleObjectivization, public moMoveIncrEval < Move, typename MOEOT::Fitness> + { + public: + + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + + + moeoIncrEvalSingleObjectivizer (){} + /** + Constructor + @param _singler a singleObjectivizer to calculte the fitness from the objectiveVector + @param _incr incremental evaluation of moeots + */ + moeoIncrEvalSingleObjectivizer ( moeoSingleObjectivization &_singler, moMoveIncrEval &_incr): + singler(_singler), incr(_incr) + {} + /** + * herited from moeoFitnessAssignment, calculate fitness for all population + * @param _pop the population + */ + virtual void operator () (eoPop < MOEOT > & _pop){ + singler(_pop); + }; + + /** + herited from eoEvalFunc, calculate fitness for a moeot + @param _moeot + */ + virtual void operator() (MOEOT & _moeot){ + singler(_moeot); + }; + + /** + calculate fitness from an objectiveVector + @param _moeot a valid ObejctiveVector + @return the fitness value for the objectiveVector + */ + virtual typename MOEOT::Fitness operator() (const typename MOEOT::ObjectiveVector & _moeot){ + return singler(_moeot); + }; + /** + evaluates incrementally the fitness for a moeo + @param _mov a movement to virtually apply to _moeo + @param _moeo the base solution + @return the fitness of _moeo with _move applied + */ + virtual typename MOEOT::Fitness operator() ( const Move &_mov, const MOEOT &_moeo ){ + return singler(incr_obj(_mov,_moeo)); + } + + /** + evaluates incrementally the objectiveVector for a moeo + @param _mov a movement to virtually apply to _moeo + @param _moeo the base solution + @return the objectiveVector of _moeo with _move applied + */ + virtual ObjectiveVector incr_obj ( const Move &_mov, const MOEOT &_moeo ){ + return incr(_mov,_moeo); + } + /** dummy method**/ + void updateByDeleting(eoPop < MOEOT > & _pop, ObjectiveVector & _objVec){} + private: + moeoSingleObjectivization &singler; + moMoveIncrEval &incr; + }; + +#endif /*MOEOINCREVALSINGLEOBJECTIVIZER_H_*/ diff --git a/trunk/paradiseo-moeo/src/moeo b/trunk/paradiseo-moeo/src/moeo index 51ed42f81..341e7a04a 100644 --- a/trunk/paradiseo-moeo/src/moeo +++ b/trunk/paradiseo-moeo/src/moeo @@ -52,6 +52,11 @@ #include #include #include +#include +#include +#include +#include +#include #include @@ -130,6 +135,7 @@ #include #include #include +#include #include @@ -169,6 +175,9 @@ #include #include +#include +#include + #endif /*MOEO_*/