From 4f2efb1bd09ab2f69eab501e79b0296464bc37b1 Mon Sep 17 00:00:00 2001 From: jhumeau Date: Tue, 10 Mar 2009 15:15:57 +0000 Subject: [PATCH] git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@1491 331e1502-861f-0410-8da2-ba01fb791d7f --- .../branches/MOLS/src/eoTenTimeContinue.h | 98 ++++++++ .../MOLS/src/moeoAllSolAllNeighborsExpl.h | 107 ++++++++ .../MOLS/src/moeoAllSolOneNeighborExpl.h | 167 +++++++++++++ .../branches/MOLS/src/moeoNewArchive.h | 226 +++++++++++++++++ .../branches/MOLS/src/moeoNewBoundedArchive.h | 230 ++++++++++++++++++ .../MOLS/src/moeoOneSolAllNeighborsExpl.h | 104 ++++++++ .../MOLS/src/moeoOneSolOneNeighborExpl.h | 190 +++++++++++++++ contribution/branches/MOLS/src/moeoPopLS.h | 51 ++++ .../MOLS/src/moeoPopNeighborhoodExplorer.h | 52 ++++ .../branches/MOLS/src/moeoRestartLS.h | 112 +++++++++ .../MOLS/src/moeoUnifiedDominanceBasedLS.h | 114 +++++++++ 11 files changed, 1451 insertions(+) create mode 100755 contribution/branches/MOLS/src/eoTenTimeContinue.h create mode 100755 contribution/branches/MOLS/src/moeoAllSolAllNeighborsExpl.h create mode 100755 contribution/branches/MOLS/src/moeoAllSolOneNeighborExpl.h create mode 100755 contribution/branches/MOLS/src/moeoNewArchive.h create mode 100644 contribution/branches/MOLS/src/moeoNewBoundedArchive.h create mode 100755 contribution/branches/MOLS/src/moeoOneSolAllNeighborsExpl.h create mode 100755 contribution/branches/MOLS/src/moeoOneSolOneNeighborExpl.h create mode 100755 contribution/branches/MOLS/src/moeoPopLS.h create mode 100755 contribution/branches/MOLS/src/moeoPopNeighborhoodExplorer.h create mode 100755 contribution/branches/MOLS/src/moeoRestartLS.h create mode 100755 contribution/branches/MOLS/src/moeoUnifiedDominanceBasedLS.h diff --git a/contribution/branches/MOLS/src/eoTenTimeContinue.h b/contribution/branches/MOLS/src/eoTenTimeContinue.h new file mode 100755 index 000000000..f8d4e450c --- /dev/null +++ b/contribution/branches/MOLS/src/eoTenTimeContinue.h @@ -0,0 +1,98 @@ +#ifndef _eoTenTimeContinue_h +#define _eoTenTimeContinue_h + +#include +#include +#include +#include +#include + +template< class EOT> +class eoTenTimeContinue: public eoContinue +{ +public: + + eoTenTimeContinue(unsigned int _maxTime, std::string _fileName, moeoArchive & _arch) : + start(time(0)), maxTime(_maxTime), id(1), fileName(_fileName), arch(_arch) {} + + + // _pop must be an archive + virtual bool operator() (const eoPop & _pop) + { + unsigned int diff = (unsigned int) difftime(time(0), start); + if (diff >= (id * maxTime/10) ) + { + time_t begin=time(0); + save(_pop); + id++; + start= start - (time(0)-begin); + //operator()(_pop); + } + if (diff >= maxTime) + { + return false; + } + return true; + } + + + virtual std::string className(void) const + { + return "eoTenTimeContinue"; + } + + + void readFrom (std :: istream & __is) + { + + __is >> start; + } + + + void printOn (std :: ostream & __os) const + { + + __os << start << ' ' << std :: endl; + } + + +private: + + time_t start; + unsigned int maxTime; + unsigned int id; + std::string fileName; + moeoArchive & arch; + + + void save(const eoPop & _pop) + { + // update the archive + arch(_pop); + // save the archive contents in a file + std::string tmp = fileName; + std::ostringstream os; + os << id; + tmp += '.'; + tmp += os.str(); + std::ofstream outfile(tmp.c_str()); +// std::cout << "save " << tmp << " - " << difftime(time(0), start) << std::endl; + unsigned int nObj = EOT::ObjectiveVector::nObjectives(); + for (unsigned int i=0; i +* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2008 +* (C) OPAC Team, LIFL, 2002-2008 +* +* Arnaud Liefooghe +* Jérémie Humeau +* +* 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 _MOEOALLSOLALLNEIGHBORSEXPL_H +#define _MOEOALLSOLALLNEIGHBORSEXPL_H + +#include +#include +#include +#include +#include +#include + +/** + * TODO + */ +template < class Move > +class moeoAllSolAllNeighborsExpl : public moeoPopNeighborhoodExplorer < Move > +{ + typedef typename Move::EOType MOEOT; + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + +public: + + moeoAllSolAllNeighborsExpl( + moMoveInit < Move > & _moveInit, + moNextMove < Move > & _nextMove, + moMoveIncrEval < Move, ObjectiveVector > & _incrEval) + : moveInit(_moveInit), nextMove(_nextMove), incrEval(_incrEval){} + + void operator()(eoPop < MOEOT > & _src, eoPop < MOEOT > & _dest) + { + Move move; + ObjectiveVector objVec; + for (unsigned int i=0; i<_src.size(); i++) + { + if (_src[i].flag() == 0) + { + moveInit(move, _src[i]); + do + { + objVec = incrEval(move, _src[i]); + if (! comparator (objVec, _src[i].objectiveVector())) + { + if (objVec != _src[i].objectiveVector()) + { + _dest.push_back(_src[i]); + move(_dest.back()); + _dest.back().objectiveVector(objVec); + _dest.back().flag(0); + } + } + } + while (nextMove(move, _src[i])); + _src[i].flag(1); + } + } + } + +private: + /** the move initializer */ + moMoveInit < Move > & moveInit; + /** the neighborhood explorer */ + moNextMove < Move > & nextMove; + /** the incremental evaluation */ + moMoveIncrEval < Move, ObjectiveVector > & incrEval; + /** comparator */ + moeoParetoObjectiveVectorComparator comparator; + +}; + +#endif /*_MOEOALLSOLALLNEIGHBORSEXPL_H_*/ diff --git a/contribution/branches/MOLS/src/moeoAllSolOneNeighborExpl.h b/contribution/branches/MOLS/src/moeoAllSolOneNeighborExpl.h new file mode 100755 index 000000000..bc779be43 --- /dev/null +++ b/contribution/branches/MOLS/src/moeoAllSolOneNeighborExpl.h @@ -0,0 +1,167 @@ +/* +* +* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2008 +* (C) OPAC Team, LIFL, 2002-2008 +* +* Arnaud Liefooghe +* Jérémie Humeau +* +* 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 _MOEOALLSOLONENEIGHBOREXPL_H +#define _MOEOALLSOLONENEIGHBOREXPL_H + +#include +#include +#include +#include +#include +#include +#include + +/** + * TODO + */ +template < class Move > +class moeoAllSolOneNeighborExpl : public moeoPopNeighborhoodExplorer < Move > +{ + typedef typename Move::EOType MOEOT; + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + +public: + + moeoAllSolOneNeighborExpl( + moMoveInit < Move > & _moveInit, + moNextMove < Move > & _nextMove, + moMoveIncrEval < Move, ObjectiveVector > & _incrEval) + : moveInit(_moveInit), nextMove(_nextMove), incrEval(_incrEval){} + + + void operator()(eoPop < MOEOT > & _src, eoPop < MOEOT > & _dest) + { + int id=0; + for (unsigned int i=0; i<_src.size(); i++) + { + //solution without move + if (_src[i].flag() == 0 ) + { + //No move are available -> create a new Move + if (availableMove.empty()) + { + //create a new move + Move newMove; + //add it to moveVector + moveVector.push_back(newMove); + //get the moveVector size + id = moveVector.size(); + //add a flag to _src + _src[i].flag(-id); + //Init the move + moveInit(moveVector[id-1], _src[i]); + // Apply move or not + m(_src, _dest, i, moveVector[id-1]); + //If it the last move set solution as visited (flag >0) and set the move as available + if (!nextMove(moveVector[id-1], _src[i])) + { + _src[i].flag(1); + availableMove.push(id-1); + } + } + //A move is available -> get it + else + { + //get the id of an available move + id = availableMove.back(); + //remove it from available move + availableMove.pop(); + //add a flag to _src + _src[i].flag(-1 * (id+1)); + //Init the move + moveInit(moveVector[id], _src[i]); + // Apply move or not + m(_src, _dest, i, moveVector[id]); + if (!nextMove(moveVector[id], _src[i])) + { + _src[i].flag(1); + availableMove.push(id); + } + } + } + //solution which have already a move -> do next move + else if (_src[i].flag() < 0) + { + id= (_src[i].flag() + 1) * -1; + m(_src, _dest, i, moveVector[id]); + if (!nextMove(moveVector[id], _src[i])) + { + _src[i].flag(1); + availableMove.push(id); + } + } + } + } + + + void m(eoPop < MOEOT > & _src, eoPop < MOEOT > & _dest, unsigned int i, Move & move) + { + ObjectiveVector objVec = incrEval(move, _src[i]); + // add the moved sol ? + if (! comparator (objVec, _src[i].objectiveVector())) + { + if (objVec != _src[i].objectiveVector()) + { + _dest.push_back(_src[i]); + move(_dest.back()); + _dest.back().objectiveVector(objVec); + _dest.back().flag(0); + } + } + } + + +private: + + /** queue of available move */ + std::queue < unsigned int > availableMove; + /** the move vector*/ + std::vector < Move > moveVector; + /** the move initializer */ + moMoveInit < Move > & moveInit; + /** the neighborhood explorer */ + moNextMove < Move > & nextMove; + /** the incremental evaluation */ + moMoveIncrEval < Move, ObjectiveVector > & incrEval; + /** comparator */ + moeoParetoObjectiveVectorComparator comparator; + +}; + +#endif /*_MOEOALLSOLONENEIGHBOREXPL_H_*/ diff --git a/contribution/branches/MOLS/src/moeoNewArchive.h b/contribution/branches/MOLS/src/moeoNewArchive.h new file mode 100755 index 000000000..2f23331eb --- /dev/null +++ b/contribution/branches/MOLS/src/moeoNewArchive.h @@ -0,0 +1,226 @@ +/* +* +* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007 +* (C) OPAC Team, LIFL, 2002-2007 +* +* 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 MOEONEWARCHIVE_H_ +#define MOEONEWARCHIVE_H_ + +#include +#include +#include + +template < class MOEOT > +class moeoNewArchive : public moeoArchive < MOEOT > +{ +public: + + using moeoArchive < MOEOT > :: size; + using moeoArchive < MOEOT > :: operator[]; + using moeoArchive < MOEOT > :: back; + using moeoArchive < MOEOT > :: pop_back; + + + /** + * The type of an objective vector for a solution + */ + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + + + /** + * Default ctor. + * The moeoObjectiveVectorComparator used to compare solutions is based on Pareto dominance + */ + moeoNewArchive() : moeoArchive < MOEOT >(), comparator(paretoComparator) + {} + + + /** + * Ctor + * @param _comparator the moeoObjectiveVectorComparator used to compare solutions + */ + moeoNewArchive(moeoObjectiveVectorComparator < ObjectiveVector > & _comparator) : eoPop < MOEOT >(), comparator(_comparator) + {} + + + /** + * Returns true if the current archive dominates _objectiveVector according to the moeoObjectiveVectorComparator given in the constructor + * @param _objectiveVector the objective vector to compare with the current archive + */ + bool dominates (const ObjectiveVector & _objectiveVector) const + { + for (unsigned int i = 0; i & _pop) + { + bool res = false; + for (unsigned int i=0; i<_pop.size(); i++) + { + res = (*this).update(_pop[i]) || res; + } + return res; + } + + + /** + * Returns true if the current archive contains the same objective vectors than the given archive _arch + * @param _arch the given archive + */ + bool equals (const moeoArchive < MOEOT > & _arch) + { + for (unsigned int i=0; i & comparator; + /** A moeoObjectiveVectorComparator based on Pareto dominance (used as default) */ + moeoParetoObjectiveVectorComparator < ObjectiveVector > paretoComparator; + + + /** + * Updates the archive with a given individual _moeo *** NEW *** + * @param _moeo the given individual + */ + bool update(const MOEOT & _moeo) + { + // first step: removing the dominated solutions from the archive + for (unsigned int j=0; j +* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007 +* (C) OPAC Team, LIFL, 2002-2007 +* +* 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 MOEONEWBOUNDEDARCHIVE_H_ +#define MOEONEWBOUNDEDARCHIVE_H_ + +#include +#include +#include + +template < class MOEOT > +class moeoNewBoundedArchive : public moeoArchive < MOEOT > +{ +public: + + using moeoArchive < MOEOT > :: size; + using moeoArchive < MOEOT > :: operator[]; + using moeoArchive < MOEOT > :: back; + using moeoArchive < MOEOT > :: pop_back; + + + /** + * The type of an objective vector for a solution + */ + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + + + /** + * Default ctor. + * The moeoObjectiveVectorComparator used to compare solutions is based on Pareto dominance + */ + moeoNewBoundedArchive(unsigned int _maxSize=100) : moeoArchive < MOEOT >(), comparator(paretoComparator), maxSize(_maxSize) + {} + + + /** + * Ctor + * @param _comparator the moeoObjectiveVectorComparator used to compare solutions + */ + moeoNewBoundedArchive(moeoObjectiveVectorComparator < ObjectiveVector > & _comparator, unsigned int _maxSize=100) : eoPop < MOEOT >(), comparator(_comparator), maxSize(_maxSize) + {} + + + /** + * Returns true if the current archive dominates _objectiveVector according to the moeoObjectiveVectorComparator given in the constructor + * @param _objectiveVector the objective vector to compare with the current archive + */ + bool dominates (const ObjectiveVector & _objectiveVector) const + { + for (unsigned int i = 0; i & _pop) + { + bool res = false; + for (unsigned int i=0; i<_pop.size(); i++) + { + res = (*this).update(_pop[i]) || res; + } + return res; + } + + + /** + * Returns true if the current archive contains the same objective vectors than the given archive _arch + * @param _arch the given archive + */ + bool equals (const moeoArchive < MOEOT > & _arch) + { + for (unsigned int i=0; i & comparator; + /** A moeoObjectiveVectorComparator based on Pareto dominance (used as default) */ + moeoParetoObjectiveVectorComparator < ObjectiveVector > paretoComparator; + /** Max size of archive*/ + unsigned int maxSize; + + /** + * Updates the archive with a given individual _moeo *** NEW *** + * @param _moeo the given individual + */ + bool update(const MOEOT & _moeo) + { + // first step: removing the dominated solutions from the archive + for (unsigned int j=0; j +* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2008 +* (C) OPAC Team, LIFL, 2002-2008 +* +* Arnaud Liefooghe +* Jérémie Humeau +* +* 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 _MOEOONESOLALLNEIGHBORSEXPL_H +#define _MOEOONESOLALLNEIGHBORSEXPL_H + +#include +#include +#include +#include +#include +#include + +/** + * TODO + */ +template < class Move > +class moeoOneSolAllNeighborsExpl : public moeoPopNeighborhoodExplorer < Move > +{ + typedef typename Move::EOType MOEOT; + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + +public: + + moeoOneSolAllNeighborsExpl( + moMoveInit < Move > & _moveInit, + moNextMove < Move > & _nextMove, + moMoveIncrEval < Move, ObjectiveVector > & _incrEval) + : moveInit(_moveInit), nextMove(_nextMove), incrEval(_incrEval){} + + void operator()(eoPop < MOEOT > & _src, eoPop < MOEOT > & _dest) + { + Move move; + ObjectiveVector objVec; + unsigned int i = 0; + while (_src[i].flag() != 0) + i++; + moveInit(move, _src[i]); + do + { + objVec = incrEval(move, _src[i]); + if (! comparator (objVec, _src[i].objectiveVector())) + { + if (objVec != _src[i].objectiveVector()) + { + _dest.push_back(_src[i]); + move(_dest.back()); + _dest.back().objectiveVector(objVec); + _dest.back().flag(0); + } + } + } + while (nextMove(move, _src[i])); + _src[i].flag(1); + } + +private: + /** the move initializer */ + moMoveInit < Move > & moveInit; + /** the neighborhood explorer */ + moNextMove < Move > & nextMove; + /** the incremental evaluation */ + moMoveIncrEval < Move, ObjectiveVector > & incrEval; + /** comparator */ + moeoParetoObjectiveVectorComparator comparator; + +}; + +#endif /*_MOEOONESOLALLNEIGHBORSEXPL_H_*/ diff --git a/contribution/branches/MOLS/src/moeoOneSolOneNeighborExpl.h b/contribution/branches/MOLS/src/moeoOneSolOneNeighborExpl.h new file mode 100755 index 000000000..d6ae8a7c4 --- /dev/null +++ b/contribution/branches/MOLS/src/moeoOneSolOneNeighborExpl.h @@ -0,0 +1,190 @@ +/* +* +* Copyright (C) DOLPHIN project-team, LIFL, INRIA Lille, 2009 +* Arnaud Liefooghe +* Jérémie Humeau +* +* 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 _MOEOONESOLONENEIGHBOREXPL_H +#define _MOEOONESOLONENEIGHBOREXPL_H + +#include +#include +#include +#include +#include +#include + +template < class Move > +class moeoOneSolOneNeighborExpl : public moeoPopNeighborhoodExplorer < Move > +{ + typedef typename Move::EOType MOEOT; + typedef typename MOEOT::ObjectiveVector ObjectiveVector; + +public: + + moeoOneSolOneNeighborExpl( + moMoveInit < Move > & _moveInit, + moNextMove < Move > & _nextMove, + moMoveIncrEval < Move, ObjectiveVector > & _incrEval) + : moveInit(_moveInit), nextMove(_nextMove), incrEval(_incrEval) {} + + + void operator()(eoPop < MOEOT > & _src, eoPop < MOEOT > & _dest) + { + // init + Move move; + ObjectiveVector objVec; + unsigned int i = eo::rng.random(_src.size()); // "-1" ??? + moveInit(move, _src[i]); + // ttt + do + { + objVec = incrEval(move, _src[i]); + if (! comparator (objVec, _src[i].objectiveVector())) + { + if (objVec != _src[i].objectiveVector()) + { + _dest.push_back(_src[i]); + move(_dest.back()); + _dest.back().objectiveVector(objVec); + _dest.back().flag(0); + } + } + } while ( (_dest.size()==0) && nextMove(move,_src[i]) ); + // si tous les voisins sont dominés (ie "! nextMove(move,_src[i])"), mettre le flag à ZERO !!!!!!!!!!!!!!!!!!!!!!!!!!! + } + + +private: + + /** the move initializer */ + moMoveInit < Move > & moveInit; + /** the neighborhood explorer */ + moNextMove < Move > & nextMove; + /** the incremental evaluation */ + moMoveIncrEval < Move, ObjectiveVector > & incrEval; + /** comparator */ + moeoParetoObjectiveVectorComparator comparator; + + + + + + /* la même solution est utilisée iteration après iteration (qd c'est possible) */ +// void operator()(eoPop < MOEOT > & _src, eoPop < MOEOT > & _dest) +// { +// ObjectiveVector objVec; +// unsigned int i = 0; +// // setting _src[i] +// if (!start) +// { +// while (_src[i].flag() != 0) +// i++; +// moveInit(move, _src[i]); +// _src[i].flag(-1); +// } +// else +// { +// while ( (i < _src.size()) && (_src[i].flag() != -1) ) +// i++; +// if (_src[i].flag() != -1) +// { +// i=0; +// while (_src[i].flag() != 0) +// i++; +// moveInit(move, _src[i]); +// _src[i].flag(-1); +// } +// } +// // ttt +// objVec = incrEval(move, _src[i]); +// if (! comparator (objVec, _src[i].objectiveVector())) +// { +// if (objVec != _src[i].objectiveVector()) +// { +// _dest.push_back(_src[i]); +// move(_dest.back()); +// _dest.back().objectiveVector(objVec); +// _dest.back().flag(0); +// } +// } +// // preparing the next iteration +// if (nextMove(move, _src[i])) +// { +// start=true; +// } +// else +// { +// start=false; +// _src[i].flag(1); +// } +// } + + + + + + /* version 1 */ +// if(!start){ +// moveInit(move, _src[i]); +// _dest.push_back(_src[i]); +// sol = & _dest.back(); +// move(*sol); +// sol->invalidate(); +// eval(*sol); +// if(nextMove(move, _src[i])) +// start=true; +// else{ +// start=false; +// _src[i].flag(1); +// } +// } +// else{ +// _dest.push_back(_src[i]); +// sol = & _dest.back(); +// //objVec = moveIncrEval(move, *sol); +// move(*sol); +// sol->invalidate(); +// eval(*sol); +// //sol->objectiveVector(objVec); +// //if (comparator(sol, _src[i])) +// if(!nextMove(move, _src[i])){ +// start=false; +// _src[i].flag(1); +// } +// } +// } + +}; + +#endif /*_MOEOONESOLONENEIGHBOREXPL_H_*/ diff --git a/contribution/branches/MOLS/src/moeoPopLS.h b/contribution/branches/MOLS/src/moeoPopLS.h new file mode 100755 index 000000000..2cb90db32 --- /dev/null +++ b/contribution/branches/MOLS/src/moeoPopLS.h @@ -0,0 +1,51 @@ +/* +* +* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007 +* (C) OPAC Team, LIFL, 2002-2007 +* +* Arnaud Liefooghe +* Jérémie Humeau +* +* 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 MOEOPOPLS_H_ +#define MOEOPOPLS_H_ + +#include + +/** + * Abstract class for Population based multi-objective local search. + */ +template < class Move > +class moeoPopLS : public moeoPopAlgo < typename Move::EOType > + {}; + +#endif /*MOEOPOPLS_H_*/ diff --git a/contribution/branches/MOLS/src/moeoPopNeighborhoodExplorer.h b/contribution/branches/MOLS/src/moeoPopNeighborhoodExplorer.h new file mode 100755 index 000000000..1f2a867d8 --- /dev/null +++ b/contribution/branches/MOLS/src/moeoPopNeighborhoodExplorer.h @@ -0,0 +1,52 @@ +/* +* +* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2008 +* (C) OPAC Team, LIFL, 2002-2008 +* +* Arnaud Liefooghe +* Jérémie Humeau +* +* 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 _MOEOPOPNEIGHBORHOODEXPLORER_H +#define _MOEOPOPNEIGHBORHOODEXPLORER_H + +#include +#include + +/** + * TODO + */ +template < class Move > +class moeoPopNeighborhoodExplorer : public eoBF &, eoPop < typename Move::EOType > &, void> + {}; + +#endif /*MOEONEIGHBORHOODEXPLORER_H_*/ diff --git a/contribution/branches/MOLS/src/moeoRestartLS.h b/contribution/branches/MOLS/src/moeoRestartLS.h new file mode 100755 index 000000000..70beb24cc --- /dev/null +++ b/contribution/branches/MOLS/src/moeoRestartLS.h @@ -0,0 +1,112 @@ +/* +* +* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2008 +* (C) OPAC Team, LIFL, 2002-2008 +* +* Arnaud Liefooghe +* Jérémie Humeau +* +* 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 _MOEORESTARTLS_H +#define _MOEORESTARTLS_H + +#include +#include +#include +#include +#include +#include + +template < class Move > +class moeoRestartLS : public moeoPopLS < Move > +{ +public: + + typedef typename Move::EOType MOEOT; + + moeoRestartLS( + eoInit < MOEOT > & _init, + eoEvalFunc < MOEOT > & _eval, + eoContinue < MOEOT > & _continuator, + moeoPopNeighborhoodExplorer < Move > & _explorer, + moeoArchive < MOEOT > & _globalArchive, + std::string _fileName) : + init(_init), eval(_eval), continuator(_continuator), ls(continuator, _eval, internalArchive, _explorer), globalArchive(_globalArchive), fileName(_fileName), count(0) {} + + + virtual void operator()(eoPop & _pop) + { + do + { + internalArchive.resize(0); + for (unsigned int i=0; i<_pop.size(); i++) + { + init(_pop[i]); + _pop[i].invalidateObjectiveVector(); + eval(_pop[i]); + } + ls(_pop); + count++; + globalArchive(internalArchive); + } while (continuator(globalArchive)); + save(); +// std::cout << "Final archive\n"; +// globalArchive.sortedPrintOn(std::cout); +// std::cout << std::endl; + } + + +protected: + + eoInit < MOEOT > & init; + eoEvalFunc < MOEOT > & eval; + eoContinue < MOEOT > & continuator; + moeoNewArchive < MOEOT > internalArchive; + moeoUnifiedDominanceBasedLS < Move > ls; + moeoArchive < MOEOT > & globalArchive; + std::string & fileName; + unsigned int count; + + + void save() + { + // save count in a file + std::string tmp = fileName; + tmp += ".stat"; + std::ofstream outfile(tmp.c_str()); + outfile << count << std::endl; + outfile.close(); + } + +}; + +#endif /*_MOEORESTARTLS_H*/ diff --git a/contribution/branches/MOLS/src/moeoUnifiedDominanceBasedLS.h b/contribution/branches/MOLS/src/moeoUnifiedDominanceBasedLS.h new file mode 100755 index 000000000..090a49635 --- /dev/null +++ b/contribution/branches/MOLS/src/moeoUnifiedDominanceBasedLS.h @@ -0,0 +1,114 @@ +/* +* +* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2008 +* (C) OPAC Team, LIFL, 2002-2008 +* +* Arnaud Liefooghe +* Jérémie Humeau +* +* 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 _MOEOUNIFIEDDOMINANCEBASEDLS_H +#define _MOEOUNIFIEDDOMINANCEBASEDLS_H + +#include +#include +#include +#include + +template < class Move > +class moeoUnifiedDominanceBasedLS : public moeoPopLS < Move > +{ +public: + + typedef typename Move::EOType MOEOT; + + + moeoUnifiedDominanceBasedLS( + eoContinue < MOEOT > & _continuator, + eoEvalFunc < MOEOT > & _eval, + moeoArchive < MOEOT > & _archive, + moeoPopNeighborhoodExplorer < Move > & _explorer) : + continuator(_continuator), loopEval(_eval), popEval(loopEval), archive(_archive), explorer(_explorer) {} + + + /** + * Applies a few generation of evolution to the population _pop. + * @param _pop the population + */ + virtual void operator()(eoPop < MOEOT > & _pop) + { + eoPop < MOEOT > tmp_pop; + popEval(tmp_pop, _pop); + archive(_pop); + do{ + tmp_pop.resize(0); + //"perturber" la population + explorer(archive, tmp_pop); + //mise à jour de la pop ou archive + archive(tmp_pop); + } + while (continuator(archive) && naturalContinuator(archive)); +// std::cout << "Final archive\n"; +// archive.sortedPrintOn(std::cout); +// std::cout << std::endl; + } + + +protected: + + eoContinue < MOEOT > & continuator; + eoPopLoopEval < MOEOT > loopEval; + eoPopEvalFunc < MOEOT > & popEval; + moeoArchive < MOEOT > & archive; + moeoPopNeighborhoodExplorer < Move > & explorer; + +class moeoContinue : public eoUF < eoPop < MOEOT > &, bool > + { + public: + + moeoContinue(){} + + virtual bool operator()(eoPop < MOEOT > & _pop) + { + bool res = false; + unsigned int i=0; + while (!res && i < _pop.size()){ + res = (_pop[i].flag() != 1); + i++; + } + return res; + } + } naturalContinuator; + +}; + +#endif /*MOEOUNIFIEDDOMINANCEBASEDLS_H_*/