test for VFAS and weight strategies added

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

trunk/paradiseo-moeo/test/CMakeLists.txt

@@ -84,6 +84,13 @@ SET (TEST_LIST
 		t-moeoILS_TS
 		t-moeoTS
 		t-moeoVNS
+		t-moeoVFAS
+		t-moeoAnytimeWeightStrategy
+		t-moeoQexploreWeightStrategy
+		t-moeoAugmentedQexploreWeightStrategy
+		t-moeoFixedTimeOneDirectionWeightStrategy
+		t-moeoFixedTimeBothDirectionWeightStrategy
+		t-moeoDichoWeightStrategy
 )
 
 FOREACH (test ${TEST_LIST})

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

@@ -0,0 +1,301 @@
+/*
+ * <t-moeoAnytimeWeightStrategy.cpp>
+ * Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
+ * (C) OPAC Team, LIFL, 2002-2008
+ *
+ * Fraéncç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
+ *
+ */
+//-----------------------------------------------------------------------------
+// t-moeoAnytimeWeightStrategy.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 eoEvalFunc < 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 eoContinue<Solution>
+{
+	public :
+		solutionContinue(): counter(0)
+	{}
+
+		bool operator () (const eoPop<Solution> & _solution)
+		{
+			if(counter==0)
+			{
+				counter++;
+				return true;
+			}
+			return false;
+		}
+
+
+		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 moeoComparator<Solution>
+{
+	public :
+		const 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()
+{
+	Solution solution;
+	moeoAnytimeWeightStrategy<Solution> strat;
+	std::vector<double> weight;
+	weight.resize(2);
+
+	cout << "[ moeoAnytimeWeightStrategy                     ] ==> ";
+	strat(weight,solution);
+	assert(weight[0]==0 && weight[1]==1);
+	strat(weight,solution);
+	assert(weight[0]==1 && weight[1]==0);
+	strat(weight,solution);
+	assert(weight[0]==0.5 && weight[1]==0.5);
+	strat(weight,solution);
+	assert(weight[0]==0.25 && weight[1]==0.75);
+	strat(weight,solution);
+	assert(weight[0]==0.75 && weight[1]==0.25);
+
+	std::cout<<"OK"<<std::endl;
+	return EXIT_SUCCESS;
+}
+
+//-----------------------------------------------------------------------------
+

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

@@ -0,0 +1,300 @@
+/*
+ * <t-moeoAugmentedQexploreWeightStrategy.cpp>
+ * Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
+ * (C) OPAC Team, LIFL, 2002-2008
+ *
+ * Fraéncç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
+ *
+ */
+//-----------------------------------------------------------------------------
+// t-moeoAugmentedQexploreWeightStrategy.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 3;
+		}
+};
+
+typedef moeoRealObjectiveVector < ObjectiveVectorTraits > ObjectiveVector;
+
+class Solution : public moeoRealVector < ObjectiveVector, double, double >
+{
+	public:
+		Solution() : moeoRealVector < ObjectiveVector, double, double > (3) {}
+};
+
+class solutionEval : public eoEvalFunc < Solution >
+{
+	public:
+		void operator () (Solution & _sol)
+		{
+			ObjectiveVector objVec;
+			objVec[0] = _sol[0];
+			objVec[1] = _sol[1];
+			objVec[2] = _sol[2];
+			_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 eoContinue<Solution>
+{
+	public :
+		solutionContinue(): counter(0)
+	{}
+
+		bool operator () (const eoPop<Solution> & _solution)
+		{
+			if(counter==0)
+			{
+				counter++;
+				return true;
+			}
+			return false;
+		}
+
+
+		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 moeoComparator<Solution>
+{
+	public :
+		const 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;
+			objVec[2] = 1;
+			_solution[1]=1;
+			_solution[0]=1;
+			_solution[2]=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];
+			objVec[2] = _solution[2];
+			_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()
+{
+	Solution solution;
+	solutionEval eval;
+	std::vector<double> weight;
+	weight.resize(3);
+	cout << "[moeoAugmentedQexploreWeightStrategy] ==> ";
+	moeoAugmentedQexploreWeightStrategy<Solution> strat;
+	for (unsigned int i=0;i<6000;i++){
+		eval(solution);
+		strat(weight,solution);
+	//	std::cout<<weight[0]<<" "<<weight[1]<<" "<<weight[2]<<" "/*<<weight[3]*/<<std::endl;
+	}
+
+	std::cout<<"OK"<<std::endl;
+	return EXIT_SUCCESS;
+}
+
+//-----------------------------------------------------------------------------
+

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

@@ -0,0 +1,305 @@
+/*
+ * <t-moeoDichoWeightStrategy.cpp>
+ * Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
+ * (C) OPAC Team, LIFL, 2002-2008
+ *
+ * François Legillon
+ *
+ * This software is governed by the CeCILL license under French law and
+ * abiding by the rules of distribution of free software.  You can  use,
+ * modify and/ or redistribute the software under the terms of the CeCILL
+ * license as circulated by CEA, CNRS and INRIA at the following URL
+ * "http://www.cecill.info".
+ *
+ * As a counterpart to the access to the source code and  rights to copy,
+ * modify and redistribute granted by the license, users are provided only
+ * with a limited warranty  and the software's author,  the holder of the
+ * economic rights,  and the successive licensors  have only  limited liability.
+ *
+ * In this respect, the user's attention is drawn to the risks associated
+ * with loading,  using,  modifying and/or developing or reproducing the
+ * software by the user in light of its specific status of free software,
+ * that may mean  that it is complicated to manipulate,  and  that  also
+ * therefore means  that it is reserved for developers  and  experienced
+ * professionals having in-depth computer knowledge. Users are therefore
+ * encouraged to load and test the software's suitability as regards their
+ * requirements in conditions enabling the security of their systems and/or
+ * data to be ensured and,  more generally, to use and operate it in the
+ * same conditions as regards security.
+ * The fact that you are presently reading this means that you have had
+ * knowledge of the CeCILL license and that you accept its terms.
+ *
+ * ParadisEO WebSite : http://paradiseo.gforge.inria.fr
+ * Contact: paradiseo-help@lists.gforge.inria.fr
+ *
+ */
+//-----------------------------------------------------------------------------
+// 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 eoEvalFunc < 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 eoContinue<Solution>
+{
+	public :
+		solutionContinue(): counter(0)
+	{}
+
+		bool operator () (const eoPop<Solution> & _solution)
+		{
+			if(counter==0)
+			{
+				counter++;
+				return true;
+			}
+			return false;
+		}
+
+
+		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 moeoComparator<Solution>
+{
+	public :
+		const 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()
+{
+	Solution solution;
+	moeoDichoWeightStrategy<Solution> strat;
+	solutionEval eval;
+	std::vector<double> weight;
+	cout << "[moeoDichoWeightStrategy] ==> ";
+	weight.resize(2);
+	ObjectiveVector obj;
+	obj[0]=1;
+	obj[1]=0;
+	solution.objectiveVector(obj);
+	strat(weight,solution);
+	assert(weight[0]==0 && weight[1]==1);
+	obj[0]=0;
+	obj[1]=1;
+	solution.objectiveVector(obj);
+	strat(weight,solution);
+	assert(weight[0]==1 && weight[1]==0);
+	strat(weight,solution);
+	assert(weight[0]==0.5 && weight[1]==0.5);
+
+
+	std::cout<<"OK"<<std::endl;
+	return EXIT_SUCCESS;
+}
+
+//-----------------------------------------------------------------------------
+

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

@@ -0,0 +1,295 @@
+/*
+ * <t-moeoFixedTimeBothDirectionWeightStrategy.cpp>
+ * Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
+ * (C) OPAC Team, LIFL, 2002-2008
+ *
+ * Fraéncç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
+ *
+ */
+//-----------------------------------------------------------------------------
+// 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 eoEvalFunc < 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 eoContinue<Solution>
+{
+	public :
+		solutionContinue(): counter(0)
+	{}
+
+		bool operator () (const eoPop<Solution> & _solution)
+		{
+			if(counter==0)
+			{
+				counter++;
+				return true;
+			}
+			return false;
+		}
+
+
+		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 moeoComparator<Solution>
+{
+	public :
+		const 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()
+{
+	Solution solution;
+	moeoFixedTimeBothDirectionWeightStrategy<Solution> strat(0.1);
+	std::vector<double> weight;
+	weight.resize(2);
+	for (unsigned int i=0;i<20;i++){
+		strat(weight,solution);
+		std::cout<<weight[0]<<" "<<weight[1]<<std::endl;
+	}
+
+
+	cout << "[ moeo_weight2direction                 ] ==> ";
+	std::cout<<"OK"<<std::endl;
+	return EXIT_SUCCESS;
+}
+
+//-----------------------------------------------------------------------------
+

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

@@ -0,0 +1,295 @@
+/*
+ * <t-moeoFixedTimeOneDirectionWeightStrategy.cpp>
+ * Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
+ * (C) OPAC Team, LIFL, 2002-2008
+ *
+ * Fraéncç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
+ *
+ */
+//-----------------------------------------------------------------------------
+// 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 eoEvalFunc < 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 eoContinue<Solution>
+{
+	public :
+		solutionContinue(): counter(0)
+	{}
+
+		bool operator () (const eoPop<Solution> & _solution)
+		{
+			if(counter==0)
+			{
+				counter++;
+				return true;
+			}
+			return false;
+		}
+
+
+		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 moeoComparator<Solution>
+{
+	public :
+		const 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()
+{
+	Solution solution;
+	moeoFixedTimeOneDirectionWeightStrategy<Solution> strat(0.1);
+	std::vector<double> weight;
+	weight.resize(2);
+	for (unsigned int i=0;i<20;i++){
+		strat(weight,solution);
+		std::cout<<weight[0]<<" "<<weight[1]<<std::endl;
+	}
+
+
+	cout << "[ moeo_weight1direction                 ] ==> ";
+	std::cout<<"OK"<<std::endl;
+	return EXIT_SUCCESS;
+}
+
+//-----------------------------------------------------------------------------
+

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

@@ -0,0 +1,306 @@
+/*
+ * <t-moeoQexploreWeightStrategy.cpp>
+ * Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
+ * (C) OPAC Team, LIFL, 2002-2008
+ *
+ * Fraéncç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
+ *
+ */
+//-----------------------------------------------------------------------------
+// t-moeoQexploreWeightStrategy.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 eoEvalFunc < 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 eoContinue<Solution>
+{
+	public :
+		solutionContinue(): counter(0)
+	{}
+
+		bool operator () (const eoPop<Solution> & _solution)
+		{
+			if(counter==0)
+			{
+				counter++;
+				return true;
+			}
+			return false;
+		}
+
+
+		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 moeoComparator<Solution>
+{
+	public :
+		const 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()
+{
+	Solution solution;
+	moeoQexploreWeightStrategy<Solution> strat;
+	cout << "[ moeoQexploreWeightStrategy ] ==> ";
+	std::vector<double> weight;
+	weight.resize(2);
+	strat(weight,solution);
+	assert(weight[0]==0 && weight[1]==1);
+	strat(weight,solution);
+	assert(weight[0]==1 && weight[1]==0);
+	strat(weight,solution);
+	assert(weight[0]==0.5 && weight[1]==0.5);
+	strat(weight,solution);
+	assert(weight[0]==1.0/3.0 && weight[1]==2.0/3.0);
+	strat(weight,solution);
+	assert(weight[0]==2.0/3.0 && weight[1]==1.0/3.0);
+	strat(weight,solution);
+	assert(weight[0]==1.0/4.0 && weight[1]==3.0/4.0);
+	strat(weight,solution);
+	assert(weight[0]==3.0/4.0 && weight[1]==1.0/4.0);
+
+
+
+	std::cout<<"OK"<<std::endl;
+	return EXIT_SUCCESS;
+}
+
+//-----------------------------------------------------------------------------
+

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

@@ -0,0 +1,315 @@
+/*
+ * <t-moVFAS.cpp>
+ * Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
+ * (C) OPAC Team, LIFL, 2002-2008
+ *
+ * Fraéncç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
+ *
+ */
+//-----------------------------------------------------------------------------
+// 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 eoEvalFunc < 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 eoContinue<Solution>
+{
+	public :
+		solutionContinue(): counter(0)
+	{}
+
+		bool operator () (const eoPop<Solution> & _solution)
+		{
+			if(counter==0)
+			{
+				counter++;
+				return true;
+			}
+			return false;
+		}
+
+
+		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 moeoComparator<Solution>
+{
+	public :
+		const 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;
+	moeoDetTournamentSelect<Solution> selectOne(comparator);
+	eoPop<Solution> pop;
+	pop.push_back(solution);
+	moeoRandWeightStrategy<Solution> strat;
+	std::vector<double> weights;
+	weights.push_back(0);
+	weights.push_back(1);
+
+	moeoHC<testMove> hc(init,next,incrEval,select,singler);
+	moeoVFAS<testMove> vfas(hc,continu,selectOne,eval,strat);
+	moeoVFAS<testMove> vfas1(hc,continu,selectOne,weights,eval,strat);
+
+	cout << "[ moeo_VFAS                     ] ==> ";
+	vfas(pop);
+	std::cout<<"OK"<<std::endl;
+	return EXIT_SUCCESS;
+}
+
+//-----------------------------------------------------------------------------
+