Test for SingleObjectivization algorithms added

git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@1625 331e1502-861f-0410-8da2-ba01fb791d7f

trunk/paradiseo-moeo/test/CMakeLists.txt

@@ -10,6 +10,7 @@
 ######################################################################################
 
 INCLUDE_DIRECTORIES(${EO_SRC_DIR}/src)
+INCLUDE_DIRECTORIES(${MO_SRC_DIR}/src)
 INCLUDE_DIRECTORIES(${ParadisEO-MOEO_SOURCE_DIR}/src)
 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 
@@ -77,7 +78,12 @@ SET (TEST_LIST
 		t-moeoChebyshevOrientedMetric
 		t-moeoASFAMetric
 		t-moeoASFAOrMetric
-		
+		t-moeoHC
+		t-moeoILS_HC
+		t-moeoILS_SA
+		t-moeoILS_TS
+		t-moeoTS
+		t-moeoVNS
 )
 
 FOREACH (test ${TEST_LIST})

trunk/paradiseo-moeo/test/t-moeoHC.cpp

@@ -0,0 +1,297 @@
+/*
+ * <t-moILS_HC.cpp>
+ * Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
+ * (C) OPAC Team, LIFL, 2002-2008
+ *
+ * S<-61><-87>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
+ *
+ */
+//-----------------------------------------------------------------------------
+// t-moILS_HC.cpp
+//-----------------------------------------------------------------------------
+
+#include <eo>  // EO
+#include <mo>  // MO
+#include <moeo>
+
+using std::cout;
+using std::endl;
+
+//-----------------------------------------------------------------------------
+class ObjectiveVectorTraits : public moeoObjectiveVectorTraits
+{
+	public:
+		static bool minimizing (int i)
+		{
+			return true;
+		}
+		static bool maximizing (int i)
+		{
+			return false;
+		}
+		static unsigned int nObjectives ()
+		{
+			return 2;
+		}
+};
+
+typedef moeoRealObjectiveVector < ObjectiveVectorTraits > ObjectiveVector;
+
+class Solution : public moeoRealVector < ObjectiveVector, double, double >
+{
+	public:
+		Solution() : moeoRealVector < ObjectiveVector, double, double > (2) {}
+};
+
+class solutionEval : public moeoEvalFunc < Solution >
+{
+	public:
+		void operator () (Solution & _sol)
+		{
+			ObjectiveVector objVec;
+			objVec[0] = _sol[0];
+			objVec[1] = _sol[1];
+			_sol.objectiveVector(objVec);
+		}
+};
+
+
+class testMove : public moMove <Solution>
+{
+	public :
+		void operator () (Solution & _solution)
+		{
+			Solution sol=_solution;
+		}
+} ;
+
+class testMoveInit : public moMoveInit <testMove>
+{
+	public :
+		void operator () (testMove & _move, const Solution & _solution)
+		{
+			testMove move=_move;
+			const Solution sol(_solution);
+		}
+} ;
+
+class testMoveNext : public moNextMove <testMove>
+{
+	public :
+		bool operator () (testMove & _move, const Solution & _solution)
+		{
+			testMove move=_move;
+			const Solution sol(_solution);
+
+			return false;
+		}
+} ;
+
+class testMoveIncrEval : public moMoveIncrEval <testMove,ObjectiveVector>
+{
+	public :
+		ObjectiveVector operator () (const testMove & _move, const Solution & _solution)
+		{
+			const testMove move(_move);
+			const Solution solution(_solution);
+
+
+			return _solution.objectiveVector();
+		}
+} ;
+
+class testTabuList : public moTabuList<testMove>
+{
+	public:
+		bool operator() (const testMove & _move, const Solution & _solution)
+		{
+			const testMove move(_move);
+			const Solution sol(_solution);
+
+			return false;
+		}
+
+		void add(const testMove & _move, const Solution & _solution)
+		{
+			const testMove move(_move);
+			const Solution sol(_solution);
+		}
+
+		void update()
+		{}
+
+		void init()
+		{}
+};
+
+class testAspirCrit : public moAspirCrit<testMove>
+{
+	public:
+		bool operator() (const testMove & _move, const double & _fitness)
+		{
+			double fitness;
+			const testMove move(_move);
+			fitness=_fitness;
+
+			return false;
+		}
+
+		void init()
+		{}
+};
+
+class solutionContinue : public moSolContinue<Solution>
+{
+	public :
+		solutionContinue(): counter(0)
+	{}
+
+		bool operator () (const Solution & _solution)
+		{
+			const Solution sol(_solution);
+
+			if(counter==0)
+			{
+				counter++;
+				return true;
+			}
+			return false;
+		}
+
+		void init()
+		{}
+	private :
+		unsigned int counter;
+} ;
+
+class solutionComparator : public moComparator<Solution>
+{
+	public :
+		bool operator () (const Solution & _solution1 , const Solution & _solution2)
+		{
+			const Solution sol1(_solution1);
+			const Solution sol2(_solution2);
+
+			return sol1.fitness()>sol2.fitness();
+		}
+} ;
+
+class solutionPerturbation : public eoMonOp<Solution>
+{
+	public :
+		bool operator () (Solution & _solution)
+		{
+			ObjectiveVector objVec;
+			objVec[0] = 1;
+			objVec[1] = 1;
+			_solution[1]=1;
+			_solution[0]=1;
+			_solution.objectiveVector(objVec);
+			_solution.fitness(2);
+			return true;
+		}
+} ;
+
+class solutionSingler : public moeoSingleObjectivization<Solution>
+{
+	void operator () (Solution & _solution){
+			ObjectiveVector objVec;
+			objVec[0] = _solution[0];
+			objVec[1] = _solution[1];
+			_solution.objectiveVector(objVec);
+		_solution.fitness(_solution.objectiveVector()[0]+_solution.objectiveVector()[1]);
+	}
+	void operator()(eoPop<Solution> &_pop){
+	}
+
+	double operator() (const ObjectiveVector &_obj){
+		return _obj[0]+_obj[1];
+	}
+	void updateByDeleting(eoPop<Solution>& pop, ObjectiveVector& obj){}
+
+} ;
+
+class selectMove: public moMoveSelect<testMove>
+{
+	public:
+		void init(const double &d){
+			max_fit=d;
+		}
+		bool update(const testMove &move,const double &fitness){
+			if (fitness>max_fit){
+				max_fit=fitness;
+				best_move=move;
+				return false;
+			}else
+				return true;
+		}
+		void operator()(testMove &move,double &fitness){
+			move=best_move;
+			fitness=max_fit;
+		}
+	private:
+		double max_fit;
+		testMove best_move;
+};
+
+//-----------------------------------------------------------------------------
+
+int main()
+{
+	std::string test_result;
+	int return_value;
+
+	Solution solution;
+
+	testMoveInit init;
+	testMoveNext next;
+	testMoveIncrEval incrEval;
+	testTabuList tabuList;
+	testAspirCrit aspirCrit;
+	solutionEval eval;
+	solutionContinue continu;
+	solutionContinue continu_2;
+	solutionComparator comparator;
+	solutionPerturbation perturbation;
+	solutionSingler singler;
+	selectMove select;
+
+	moeoHC<testMove> hc(init, next, incrEval, select, singler);
+
+	cout << "[ moeoHC                     ] ==> ";
+
+	hc(solution);
+
+	cout << "OK" << endl;
+	return EXIT_SUCCESS;
+}
+
+//-----------------------------------------------------------------------------
+

trunk/paradiseo-moeo/test/t-moeoILS_HC.cpp

@@ -0,0 +1,300 @@
+/*
+ * <t-moILS_HC.cpp>
+ * Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
+ * (C) OPAC Team, LIFL, 2002-2008
+ *
+ * S<-61><-87>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
+ *
+ */
+//-----------------------------------------------------------------------------
+// t-moILS_HC.cpp
+//-----------------------------------------------------------------------------
+
+#include <eo>  // EO
+#include <mo>  // MO
+#include <moeo>
+
+using std::cout;
+using std::endl;
+
+//-----------------------------------------------------------------------------
+class ObjectiveVectorTraits : public moeoObjectiveVectorTraits
+{
+	public:
+		static bool minimizing (int i)
+		{
+			return true;
+		}
+		static bool maximizing (int i)
+		{
+			return false;
+		}
+		static unsigned int nObjectives ()
+		{
+			return 2;
+		}
+};
+
+typedef moeoRealObjectiveVector < ObjectiveVectorTraits > ObjectiveVector;
+
+class Solution : public moeoRealVector < ObjectiveVector, double, double >
+{
+	public:
+		Solution() : moeoRealVector < ObjectiveVector, double, double > (2) {}
+};
+
+class solutionEval : public moeoEvalFunc < Solution >
+{
+	public:
+		void operator () (Solution & _sol)
+		{
+			ObjectiveVector objVec;
+			objVec[0] = _sol[0];
+			objVec[1] = _sol[1];
+			_sol.objectiveVector(objVec);
+		}
+};
+
+
+class testMove : public moMove <Solution>
+{
+	public :
+		void operator () (Solution & _solution)
+		{
+			Solution sol=_solution;
+		}
+} ;
+
+class testMoveInit : public moMoveInit <testMove>
+{
+	public :
+		void operator () (testMove & _move, const Solution & _solution)
+		{
+			testMove move=_move;
+			const Solution sol(_solution);
+		}
+} ;
+
+class testMoveNext : public moNextMove <testMove>
+{
+	public :
+		bool operator () (testMove & _move, const Solution & _solution)
+		{
+			testMove move=_move;
+			const Solution sol(_solution);
+
+			return false;
+		}
+} ;
+
+class testMoveIncrEval : public moMoveIncrEval <testMove,ObjectiveVector>
+{
+	public :
+		ObjectiveVector operator () (const testMove & _move, const Solution & _solution)
+		{
+			const testMove move(_move);
+			const Solution solution(_solution);
+
+
+			return _solution.objectiveVector();
+		}
+} ;
+
+class testTabuList : public moTabuList<testMove>
+{
+	public:
+		bool operator() (const testMove & _move, const Solution & _solution)
+		{
+			const testMove move(_move);
+			const Solution sol(_solution);
+
+			return false;
+		}
+
+		void add(const testMove & _move, const Solution & _solution)
+		{
+			const testMove move(_move);
+			const Solution sol(_solution);
+		}
+
+		void update()
+		{}
+
+		void init()
+		{}
+};
+
+class testAspirCrit : public moAspirCrit<testMove>
+{
+	public:
+		bool operator() (const testMove & _move, const double & _fitness)
+		{
+			double fitness;
+			const testMove move(_move);
+			fitness=_fitness;
+
+			return false;
+		}
+
+		void init()
+		{}
+};
+
+class solutionContinue : public moSolContinue<Solution>
+{
+	public :
+		solutionContinue(): counter(0)
+	{}
+
+		bool operator () (const Solution & _solution)
+		{
+			const Solution sol(_solution);
+
+			if(counter==0)
+			{
+				counter++;
+				return true;
+			}
+			return false;
+		}
+
+		void init()
+		{}
+	private :
+		unsigned int counter;
+} ;
+
+class solutionComparator : public moComparator<Solution>
+{
+	public :
+		bool operator () (const Solution & _solution1 , const Solution & _solution2)
+		{
+			const Solution sol1(_solution1);
+			const Solution sol2(_solution2);
+
+			return sol1.fitness()>sol2.fitness();
+		}
+} ;
+
+class solutionPerturbation : public eoMonOp<Solution>
+{
+	public :
+		bool operator () (Solution & _solution)
+		{
+			ObjectiveVector objVec;
+			objVec[0] = 1;
+			objVec[1] = 1;
+			_solution[1]=1;
+			_solution[0]=1;
+			_solution.objectiveVector(objVec);
+			_solution.fitness(2);
+			return true;
+		}
+} ;
+
+class solutionSingler : public moeoSingleObjectivization<Solution>
+{
+	void operator () (Solution & _solution){
+			ObjectiveVector objVec;
+			objVec[0] = _solution[0];
+			objVec[1] = _solution[1];
+			_solution.objectiveVector(objVec);
+		_solution.fitness(_solution.objectiveVector()[0]+_solution.objectiveVector()[1]);
+	}
+	void operator()(eoPop<Solution> &_pop){
+	}
+
+	double operator() (const ObjectiveVector &_obj){
+		return _obj[0]+_obj[1];
+	}
+	void updateByDeleting(eoPop<Solution>& pop, ObjectiveVector& obj){}
+
+} ;
+
+class selectMove: public moMoveSelect<testMove>
+{
+	public:
+		void init(const double &d){
+			max_fit=d;
+		}
+		bool update(const testMove &move,const double &fitness){
+			if (fitness>max_fit){
+				max_fit=fitness;
+				best_move=move;
+				return false;
+			}else
+				return true;
+		}
+		void operator()(testMove &move,double &fitness){
+			move=best_move;
+			fitness=max_fit;
+		}
+	private:
+		double max_fit;
+		testMove best_move;
+};
+
+//-----------------------------------------------------------------------------
+
+int main()
+{
+	std::string test_result;
+	int return_value;
+
+	Solution solution;
+
+	testMoveInit init;
+	testMoveNext next;
+	testMoveIncrEval incrEval;
+	testTabuList tabuList;
+	testAspirCrit aspirCrit;
+	solutionEval eval;
+	solutionContinue continu;
+	solutionContinue continu_2;
+	solutionComparator comparator;
+	solutionPerturbation perturbation;
+	solutionSingler singler;
+	selectMove select;
+
+	moeoILS<testMove> ils(init, next, incrEval, singler, select, continu, comparator, perturbation);
+
+	cout << "[ moILS_HC                     ] ==> ";
+
+	ils(solution);
+
+	test_result=((solution.fitness()!=2)?"KO":"OK");
+	return_value=((test_result.compare("KO")==0)?EXIT_FAILURE:EXIT_SUCCESS);
+
+	cout << test_result << endl;
+	return return_value;
+}
+
+//-----------------------------------------------------------------------------
+

trunk/paradiseo-moeo/test/t-moeoILS_SA.cpp

@@ -0,0 +1,325 @@
+/*
+ * <t-moILS_HC.cpp>
+ * Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
+ * (C) OPAC Team, LIFL, 2002-2008
+ *
+ * S<-61><-87>bastien Cahon, Jean-Charles Boisson (Jean-Charles.Boisson@lifl.fr)
+ * 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
+ *
+ */
+//-----------------------------------------------------------------------------
+// t-moILS_HC.cpp
+//-----------------------------------------------------------------------------
+
+#include <eo>  // EO
+#include <mo>  // MO
+#include <moeo>
+
+using std::cout;
+using std::endl;
+
+//-----------------------------------------------------------------------------
+class ObjectiveVectorTraits : public moeoObjectiveVectorTraits
+{
+	public:
+		static bool minimizing (int i)
+		{
+			return true;
+		}
+		static bool maximizing (int i)
+		{
+			return false;
+		}
+		static unsigned int nObjectives ()
+		{
+			return 2;
+		}
+};
+
+typedef moeoRealObjectiveVector < ObjectiveVectorTraits > ObjectiveVector;
+
+class Solution : public moeoRealVector < ObjectiveVector, double, double >
+{
+	public:
+		Solution() : moeoRealVector < ObjectiveVector, double, double > (2) {}
+};
+
+class solutionEval : public moeoEvalFunc < Solution >
+{
+	public:
+		void operator () (Solution & _sol)
+		{
+			ObjectiveVector objVec;
+			objVec[0] = _sol[0];
+			objVec[1] = _sol[1];
+			_sol.objectiveVector(objVec);
+		}
+};
+
+
+class testMove : public moMove <Solution>
+{
+	public :
+		void operator () (Solution & _solution)
+		{
+			Solution sol=_solution;
+		}
+} ;
+
+class testMoveInit : public moMoveInit <testMove>
+{
+	public :
+		void operator () (testMove & _move, const Solution & _solution)
+		{
+			testMove move=_move;
+			const Solution sol(_solution);
+		}
+} ;
+
+class testMoveNext : public moNextMove <testMove>
+{
+	public :
+		bool operator () (testMove & _move, const Solution & _solution)
+		{
+			testMove move=_move;
+			const Solution sol(_solution);
+
+			return false;
+		}
+} ;
+
+class testMoveIncrEval : public moMoveIncrEval <testMove,ObjectiveVector>
+{
+	public :
+		ObjectiveVector operator () (const testMove & _move, const Solution & _solution)
+		{
+			const testMove move(_move);
+			const Solution solution(_solution);
+
+
+			return _solution.objectiveVector();
+		}
+} ;
+
+class testTabuList : public moTabuList<testMove>
+{
+	public:
+		bool operator() (const testMove & _move, const Solution & _solution)
+		{
+			const testMove move(_move);
+			const Solution sol(_solution);
+
+			return false;
+		}
+
+		void add(const testMove & _move, const Solution & _solution)
+		{
+			const testMove move(_move);
+			const Solution sol(_solution);
+		}
+
+		void update()
+		{}
+
+		void init()
+		{}
+};
+
+class testAspirCrit : public moAspirCrit<testMove>
+{
+	public:
+		bool operator() (const testMove & _move, const double & _fitness)
+		{
+			double fitness;
+			const testMove move(_move);
+			fitness=_fitness;
+
+			return false;
+		}
+
+		void init()
+		{}
+};
+
+class solutionContinue : public moSolContinue<Solution>
+{
+	public :
+		solutionContinue(): counter(0)
+	{}
+
+		bool operator () (const Solution & _solution)
+		{
+			const Solution sol(_solution);
+
+			if(counter==0)
+			{
+				counter++;
+				return true;
+			}
+			return false;
+		}
+
+		void init()
+		{}
+	private :
+		unsigned int counter;
+} ;
+
+class solutionComparator : public moComparator<Solution>
+{
+	public :
+		bool operator () (const Solution & _solution1 , const Solution & _solution2)
+		{
+			const Solution sol1(_solution1);
+			const Solution sol2(_solution2);
+
+			return sol1.fitness()>sol2.fitness();
+		}
+} ;
+
+class solutionPerturbation : public eoMonOp<Solution>
+{
+	public :
+		bool operator () (Solution & _solution)
+		{
+			ObjectiveVector objVec;
+			objVec[0] = 1;
+			objVec[1] = 1;
+			_solution[1]=1;
+			_solution[0]=1;
+			_solution.objectiveVector(objVec);
+			_solution.fitness(2);
+			return true;
+		}
+} ;
+
+class solutionSingler : public moeoSingleObjectivization<Solution>
+{
+	void operator () (Solution & _solution){
+		ObjectiveVector objVec;
+		objVec[0] = _solution[0];
+		objVec[1] = _solution[1];
+		_solution.objectiveVector(objVec);
+		_solution.fitness(_solution.objectiveVector()[0]+_solution.objectiveVector()[1]);
+	}
+	void operator()(eoPop<Solution> &_pop){
+	}
+
+	double operator() (const ObjectiveVector &_obj){
+		return _obj[0]+_obj[1];
+	}
+	void updateByDeleting(eoPop<Solution>& pop, ObjectiveVector& obj){}
+
+} ;
+
+class selectMove: public moMoveSelect<testMove>
+{
+	public:
+		void init(const double &d){
+			max_fit=d;
+		}
+		bool update(const testMove &move,const double &fitness){
+			if (fitness>max_fit){
+				max_fit=fitness;
+				best_move=move;
+				return false;
+			}else
+				return true;
+		}
+		void operator()(testMove &move,double &fitness){
+			move=best_move;
+			fitness=max_fit;
+		}
+	private:
+		double max_fit;
+		testMove best_move;
+};
+class testCooling : public moCoolingSchedule
+{
+public :
+  bool operator () (double & _temperature)
+  {
+    double temperature;
+    temperature=_temperature;
+
+    return false;
+  }
+};
+
+class testRandMove : public moRandMove<testMove>
+{
+public :
+  void operator () (testMove & _move)
+  {
+    _move=_move;
+  }
+};
+
+//-----------------------------------------------------------------------------
+
+int main()
+{
+	std::string test_result;
+	int return_value;
+
+	Solution solution;
+
+	testMoveInit init;
+	testMoveNext next;
+	testMoveIncrEval incrEval;
+	testTabuList tabuList;
+	testAspirCrit aspirCrit;
+	solutionEval eval;
+	solutionContinue continu;
+	solutionContinue continu_2;
+	solutionComparator comparator;
+	solutionPerturbation perturbation;
+	solutionSingler singler;
+	selectMove select;
+	
+	testRandMove rand;
+	testCooling cooling;
+
+	//	moeoILS<testMove> ils(init, next, incrEval, singler, select, continu, comparator, perturbation, eval);
+	moeoILS<testMove> ils(rand, incrEval,singler, continu, 10.0, cooling, continu_2, comparator, perturbation);
+
+	cout << "[ moILS_HC                     ] ==> ";
+
+	ils(solution);
+
+	test_result=((solution.fitness()!=2)?"KO":"OK");
+	return_value=((test_result.compare("KO")==0)?EXIT_FAILURE:EXIT_SUCCESS);
+
+	cout << test_result << endl;
+	return return_value;
+}
+
+//-----------------------------------------------------------------------------
+

trunk/paradiseo-moeo/test/t-moeoILS_TS.cpp

@@ -0,0 +1,277 @@
+/*
+* <t-moILS_TS.cpp>
+* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
+* (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
+*
+ */
+//-----------------------------------------------------------------------------
+// t-moILS_TS.cpp
+//-----------------------------------------------------------------------------
+
+#include <eo>  // EO
+#include <mo>  // MO
+#include <moeo>
+
+using std::cout;
+using std::endl;
+
+//-----------------------------------------------------------------------------
+class ObjectiveVectorTraits : public moeoObjectiveVectorTraits
+{
+	public:
+		static bool minimizing (int i)
+		{
+			return true;
+		}
+		static bool maximizing (int i)
+		{
+			return false;
+		}
+		static unsigned int nObjectives ()
+		{
+			return 2;
+		}
+};
+
+typedef moeoRealObjectiveVector < ObjectiveVectorTraits > ObjectiveVector;
+
+class Solution : public moeoRealVector < ObjectiveVector, double, double >
+{
+	public:
+		Solution() : moeoRealVector < ObjectiveVector, double, double > (2) {}
+};
+
+class solutionEval : public moeoEvalFunc < Solution >
+{
+	public:
+		void operator () (Solution & _sol)
+		{
+			ObjectiveVector objVec;
+			objVec[0] = _sol[0];
+			objVec[1] = _sol[1];
+			_sol.objectiveVector(objVec);
+//			_sol.fitness(_sol[1]+_sol[2]);
+		}
+};
+
+
+class testMove : public moMove <Solution>
+{
+	public :
+		void operator () (Solution & _solution)
+		{
+			Solution sol=_solution;
+		}
+} ;
+
+class testMoveInit : public moMoveInit <testMove>
+{
+	public :
+		void operator () (testMove & _move, const Solution & _solution)
+		{
+			testMove move=_move;
+			const Solution sol(_solution);
+		}
+} ;
+
+class testMoveNext : public moNextMove <testMove>
+{
+	public :
+		bool operator () (testMove & _move, const Solution & _solution)
+		{
+			testMove move=_move;
+			const Solution sol(_solution);
+
+			return false;
+		}
+} ;
+
+class testMoveIncrEval : public moMoveIncrEval <testMove,ObjectiveVector>
+{
+	public :
+		ObjectiveVector operator () (const testMove & _move, const Solution & _solution)
+		{
+			const testMove move(_move);
+			const Solution solution(_solution);
+
+
+			return _solution.objectiveVector();
+		}
+} ;
+
+class testTabuList : public moTabuList<testMove>
+{
+	public:
+		bool operator() (const testMove & _move, const Solution & _solution)
+		{
+			const testMove move(_move);
+			const Solution sol(_solution);
+
+			return false;
+		}
+
+		void add(const testMove & _move, const Solution & _solution)
+		{
+			const testMove move(_move);
+			const Solution sol(_solution);
+		}
+
+		void update()
+		{}
+
+		void init()
+		{}
+};
+
+class testAspirCrit : public moAspirCrit<testMove>
+{
+	public:
+		bool operator() (const testMove & _move, const double & _fitness)
+		{
+			double fitness;
+			const testMove move(_move);
+			fitness=_fitness;
+
+			return false;
+		}
+
+		void init()
+		{}
+};
+
+class solutionContinue : public moSolContinue<Solution>
+{
+	public :
+		solutionContinue(): counter(0)
+	{}
+
+		bool operator () (const Solution & _solution)
+		{
+			const Solution sol(_solution);
+
+			if(counter==0)
+			{
+				counter++;
+				return true;
+			}
+			return false;
+		}
+
+		void init()
+		{}
+	private :
+		unsigned int counter;
+} ;
+
+class solutionComparator : public moComparator<Solution>
+{
+	public :
+		bool operator () (const Solution & _solution1 , const Solution & _solution2)
+		{
+			const Solution sol1(_solution1);
+			const Solution sol2(_solution2);
+
+			return sol1.fitness()>sol2.fitness();
+		}
+} ;
+
+class solutionPerturbation : public eoMonOp<Solution>
+{
+	public :
+		bool operator () (Solution & _solution)
+		{
+			ObjectiveVector objVec;
+			objVec[0] = 1;
+			objVec[1] = 1;
+			_solution[1]=1;
+			_solution[0]=1;
+			_solution.objectiveVector(objVec);
+			_solution.fitness(2);
+			_solution.invalidate();
+			return true;
+		}
+} ;
+
+class solutionSingler : public moeoSingleObjectivization<Solution>
+{
+	void operator () (Solution & _solution){
+
+		ObjectiveVector objVec;
+		objVec[0] = _solution[0];
+		objVec[1] = _solution[1];
+		_solution.objectiveVector(objVec);
+		_solution.fitness(_solution.objectiveVector()[0]+_solution.objectiveVector()[1]);
+	}
+	void operator()(eoPop<Solution> &_pop){
+	}
+
+	double operator() (const ObjectiveVector &_obj){
+		return _obj[0]+_obj[1];
+	}
+	void updateByDeleting(eoPop<Solution>& pop, ObjectiveVector& obj){}
+
+} ;
+
+//-----------------------------------------------------------------------------
+
+int main()
+{
+	std::string test_result;
+	int return_value;
+
+	Solution solution;
+
+	testMoveInit init;
+	testMoveNext next;
+	testMoveIncrEval incrEval;
+	testTabuList tabuList;
+	testAspirCrit aspirCrit;
+	solutionEval eval;
+	solutionContinue continu;
+	solutionContinue continu_2;
+	solutionComparator comparator;
+	solutionPerturbation perturbation;
+	solutionSingler singler;
+
+	moeoILS<testMove> ils(init, next, incrEval, singler, tabuList, aspirCrit, continu, continu_2, comparator, perturbation);
+
+	cout << "[ moILS_TS                     ] ==> ";
+
+	ils(solution);
+	test_result=((solution.fitness()!=2)?"KO":"OK");
+	return_value=((test_result.compare("KO")==0)?EXIT_FAILURE:EXIT_SUCCESS);
+
+	cout << test_result << endl;
+	return return_value;
+}
+
+//-----------------------------------------------------------------------------

trunk/paradiseo-moeo/test/t-moeoTS.cpp

@@ -0,0 +1,275 @@
+/*
+* <t-moeoTS.cpp>
+* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
+* (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
+*
+ */
+//-----------------------------------------------------------------------------
+// t-moILS_TS.cpp
+//-----------------------------------------------------------------------------
+
+#include <eo>  // EO
+#include <mo>  // MO
+#include <moeo>
+
+using std::cout;
+using std::endl;
+
+//-----------------------------------------------------------------------------
+class ObjectiveVectorTraits : public moeoObjectiveVectorTraits
+{
+	public:
+		static bool minimizing (int i)
+		{
+			return true;
+		}
+		static bool maximizing (int i)
+		{
+			return false;
+		}
+		static unsigned int nObjectives ()
+		{
+			return 2;
+		}
+};
+
+typedef moeoRealObjectiveVector < ObjectiveVectorTraits > ObjectiveVector;
+
+class Solution : public moeoRealVector < ObjectiveVector, double, double >
+{
+	public:
+		Solution() : moeoRealVector < ObjectiveVector, double, double > (2) {}
+};
+
+class solutionEval : public moeoEvalFunc < Solution >
+{
+	public:
+		void operator () (Solution & _sol)
+		{
+			ObjectiveVector objVec;
+			objVec[0] = _sol[0];
+			objVec[1] = _sol[1];
+			_sol.objectiveVector(objVec);
+//			_sol.fitness(_sol[1]+_sol[2]);
+		}
+};
+
+
+class testMove : public moMove <Solution>
+{
+	public :
+		void operator () (Solution & _solution)
+		{
+			Solution sol=_solution;
+		}
+} ;
+
+class testMoveInit : public moMoveInit <testMove>
+{
+	public :
+		void operator () (testMove & _move, const Solution & _solution)
+		{
+			testMove move=_move;
+			const Solution sol(_solution);
+		}
+} ;
+
+class testMoveNext : public moNextMove <testMove>
+{
+	public :
+		bool operator () (testMove & _move, const Solution & _solution)
+		{
+			testMove move=_move;
+			const Solution sol(_solution);
+
+			return false;
+		}
+} ;
+
+class testMoveIncrEval : public moMoveIncrEval <testMove,ObjectiveVector>
+{
+	public :
+		ObjectiveVector operator () (const testMove & _move, const Solution & _solution)
+		{
+			const testMove move(_move);
+			const Solution solution(_solution);
+
+
+			return _solution.objectiveVector();
+		}
+} ;
+
+class testTabuList : public moTabuList<testMove>
+{
+	public:
+		bool operator() (const testMove & _move, const Solution & _solution)
+		{
+			const testMove move(_move);
+			const Solution sol(_solution);
+
+			return false;
+		}
+
+		void add(const testMove & _move, const Solution & _solution)
+		{
+			const testMove move(_move);
+			const Solution sol(_solution);
+		}
+
+		void update()
+		{}
+
+		void init()
+		{}
+};
+
+class testAspirCrit : public moAspirCrit<testMove>
+{
+	public:
+		bool operator() (const testMove & _move, const double & _fitness)
+		{
+			double fitness;
+			const testMove move(_move);
+			fitness=_fitness;
+
+			return false;
+		}
+
+		void init()
+		{}
+};
+
+class solutionContinue : public moSolContinue<Solution>
+{
+	public :
+		solutionContinue(): counter(0)
+	{}
+
+		bool operator () (const Solution & _solution)
+		{
+			const Solution sol(_solution);
+
+			if(counter==0)
+			{
+				counter++;
+				return true;
+			}
+			return false;
+		}
+
+		void init()
+		{}
+	private :
+		unsigned int counter;
+} ;
+
+class solutionComparator : public moComparator<Solution>
+{
+	public :
+		bool operator () (const Solution & _solution1 , const Solution & _solution2)
+		{
+			const Solution sol1(_solution1);
+			const Solution sol2(_solution2);
+
+			return sol1.fitness()>sol2.fitness();
+		}
+} ;
+
+class solutionPerturbation : public eoMonOp<Solution>
+{
+	public :
+		bool operator () (Solution & _solution)
+		{
+			ObjectiveVector objVec;
+			objVec[0] = 1;
+			objVec[1] = 1;
+			_solution[1]=1;
+			_solution[0]=1;
+			_solution.objectiveVector(objVec);
+			_solution.fitness(2);
+			_solution.invalidate();
+			return true;
+		}
+} ;
+
+class solutionSingler : public moeoSingleObjectivization<Solution>
+{
+	void operator () (Solution & _solution){
+
+		ObjectiveVector objVec;
+		objVec[0] = _solution[0];
+		objVec[1] = _solution[1];
+		_solution.objectiveVector(objVec);
+		_solution.fitness(_solution.objectiveVector()[0]+_solution.objectiveVector()[1]);
+	}
+	void operator()(eoPop<Solution> &_pop){
+	}
+
+	double operator() (const ObjectiveVector &_obj){
+		return _obj[0]+_obj[1];
+	}
+	void updateByDeleting(eoPop<Solution>& pop, ObjectiveVector& obj){}
+
+} ;
+
+//-----------------------------------------------------------------------------
+
+int main()
+{
+	std::string test_result;
+	int return_value;
+
+	Solution solution;
+
+	testMoveInit init;
+	testMoveNext next;
+	testMoveIncrEval incrEval;
+	testTabuList tabuList;
+	testAspirCrit aspirCrit;
+	solutionEval eval;
+	solutionContinue continu;
+	solutionContinue continu_2;
+	solutionComparator comparator;
+	solutionPerturbation perturbation;
+	solutionSingler singler;
+	moeoIncrEvalSingleObjectivizer<Solution,testMove> sincrEval(singler,incrEval);
+	moeoTSMoveLoopExpl<testMove> expl(init,next,sincrEval,tabuList,aspirCrit);
+	moeoTS<testMove> ts(init,next,incrEval,tabuList,aspirCrit,continu,singler);
+
+
+	cout << "[ moeoTS                     ] ==> ";
+	ts(solution);
+	cout << "OK" << endl;
+	return EXIT_SUCCESS;
+}
+
+//-----------------------------------------------------------------------------

trunk/paradiseo-moeo/test/t-moeoVNS.cpp

@@ -0,0 +1,187 @@
+/*
+* <t-moVNS.cpp>
+* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2007-2008
+* (C) OPAC Team, LIFL, 2002-2008
+*
+* Salma Mesmoudi (salma.mesmoudi@inria.fr), Jean-Charles Boisson (Jean-Charles.Boisson@lifl.fr)
+* Jeremie Humeau (jeremie.humeau@inria.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
+*
+*/
+//-----------------------------------------------------------------------------
+// t-moVNS.cpp
+//-----------------------------------------------------------------------------
+
+#include <eo>  // EO
+#include <mo>  // MO
+#include <moeo>
+#include <cassert>
+
+using std::cout;
+using std::endl;
+
+//-----------------------------------------------------------------------------
+class ObjectiveVectorTraits : public moeoObjectiveVectorTraits
+{
+	public:
+		static bool minimizing (int i)
+		{
+			return true;
+		}
+		static bool maximizing (int i)
+		{
+			return false;
+		}
+		static unsigned int nObjectives ()
+		{
+			return 2;
+		}
+};
+
+
+typedef EO<unsigned int> solution;
+typedef moeoRealObjectiveVector<ObjectiveVectorTraits> ObjectiveVector;
+typedef eoScalarFitness< float, std::greater<float> > tspFitness ;
+typedef moeoRealVector <ObjectiveVector, unsigned int> Route ;
+
+int cpt=0;
+int tableau[8]={1.0, 2.0, 8.0, 8.0, 11.0, 11.0, 11.0,30.0};
+
+class testMove : public moMove <solution>
+{
+public :
+
+  void operator () (solution & _solution)
+  {
+    solution sol=_solution;
+  }
+} ;
+
+
+class solutionAlgo : public moAlgo <solution>
+{
+public :
+  bool operator () (solution & _solution)
+  {
+    solution solution(_solution);
+    return true;
+  }
+} ;
+
+class Voisinage : public eoMonOp<Route>
+{
+public :
+  bool operator () (Route & _solution)
+  {
+	_solution.invalidate();
+    //_solution.fitness();
+
+    return true;
+  }
+} ;
+
+class Explorer : public moExpl<Route>
+{
+public:
+	Explorer(eoMonOp<Route> & expl): moExpl<Route>( expl)
+	  {
+
+	  }
+};
+
+class solutionEval : public eoEvalFunc <Route>
+{
+public :
+  void operator () (Route & _solution)
+  {
+	  ObjectiveVector obj;
+	  obj[0]=(tableau[0]);
+	  obj[1]=(tableau[cpt]);
+	  _solution.objectiveVector(obj);
+	  _solution.fitness(obj[0]+obj[1]);
+	  cpt++;
+  }
+};
+
+class solutionSingler : public moeoSingleObjectivization<Route>
+{
+	public:
+	solutionSingler(solutionEval &_eval):eval(_eval){}
+	void operator () (Route & _solution){
+		eval(_solution);
+		_solution.fitness(_solution.objectiveVector()[0]+_solution.objectiveVector()[1]);
+	}
+	void operator()(eoPop<Route> &_pop){
+	}
+
+	Route::Fitness operator() (const ObjectiveVector &_obj){
+		return _obj[0]+_obj[1];
+	}
+	void updateByDeleting(eoPop<Route>& pop, ObjectiveVector& obj){}
+	solutionEval &eval;
+
+} ;
+
+
+//-----------------------------------------------------------------------------
+
+int
+main()
+{
+  std::string test_result;
+
+  //solution solution;
+   Route so ;
+
+  Voisinage sol1;
+  Voisinage sol2;
+  Explorer explorer(sol1);
+  explorer.addExplorer(sol2);
+  solutionEval eval;
+  std::vector<double> poids;
+  poids.push_back(1);
+  poids.push_back(1);
+  solutionSingler singler(eval);
+
+  moeoVNS<Route> vns(explorer, singler);
+
+  cout << "[moeoVNS] ==> ";
+
+  so.fitness(5.0);
+
+  vns(so);
+
+  assert(so.fitness()==12.0);
+
+  cout << "OK" << endl;
+
+  return EXIT_SUCCESS;
+}
+
+//-----------------------------------------------------------------------------