diff --git a/trunk/paradiseo-moeo/test/CMakeLists.txt b/trunk/paradiseo-moeo/test/CMakeLists.txt index a9ce4a879..492fe3f7c 100644 --- a/trunk/paradiseo-moeo/test/CMakeLists.txt +++ b/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}) diff --git a/trunk/paradiseo-moeo/test/t-moeoHC.cpp b/trunk/paradiseo-moeo/test/t-moeoHC.cpp new file mode 100644 index 000000000..484feb86a --- /dev/null +++ b/trunk/paradiseo-moeo/test/t-moeoHC.cpp @@ -0,0 +1,297 @@ +/* + * + * 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 +#include // MO +#include + +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 +{ + public : + void operator () (Solution & _solution) + { + Solution sol=_solution; + } +} ; + +class testMoveInit : public moMoveInit +{ + public : + void operator () (testMove & _move, const Solution & _solution) + { + testMove move=_move; + const Solution sol(_solution); + } +} ; + +class testMoveNext : public moNextMove +{ + public : + bool operator () (testMove & _move, const Solution & _solution) + { + testMove move=_move; + const Solution sol(_solution); + + return false; + } +} ; + +class testMoveIncrEval : public moMoveIncrEval +{ + public : + ObjectiveVector operator () (const testMove & _move, const Solution & _solution) + { + const testMove move(_move); + const Solution solution(_solution); + + + return _solution.objectiveVector(); + } +} ; + +class testTabuList : public moTabuList +{ + 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 +{ + 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 +{ + 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 +{ + 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 +{ + 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 +{ + 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 &_pop){ + } + + double operator() (const ObjectiveVector &_obj){ + return _obj[0]+_obj[1]; + } + void updateByDeleting(eoPop& pop, ObjectiveVector& obj){} + +} ; + +class selectMove: public moMoveSelect +{ + 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 hc(init, next, incrEval, select, singler); + + cout << "[ moeoHC ] ==> "; + + hc(solution); + + cout << "OK" << endl; + return EXIT_SUCCESS; +} + +//----------------------------------------------------------------------------- + diff --git a/trunk/paradiseo-moeo/test/t-moeoHyperVolumeDifferenceMetric.cpp b/trunk/paradiseo-moeo/test/t-moeoHyperVolumeDifferenceMetric.cpp index facf92f5d..003786f1d 100644 --- a/trunk/paradiseo-moeo/test/t-moeoHyperVolumeDifferenceMetric.cpp +++ b/trunk/paradiseo-moeo/test/t-moeoHyperVolumeDifferenceMetric.cpp @@ -105,7 +105,7 @@ int main() set1[2][0] = 1; set1[2][1] = 5; - + set2[0][0] = 4; set2[0][1] = 2; @@ -114,15 +114,15 @@ int main() set2[2][0] = 1; set2[2][1] = 6; - + moeoHyperVolumeDifferenceMetric < ObjectiveVector> metric(true, 2); - + std::vector < eoRealInterval > bounds; - + metric.setup(set1, set2); bounds = metric.getBounds(); - - std::cout << "\t>test normalization =>"; + + std::cout << "\t>test normalization =>"; assert(bounds[0].minimum()==1.0); assert(bounds[0].maximum()==5.0); assert(bounds[0].range()==4.0); @@ -130,43 +130,43 @@ int main() assert(bounds[1].minimum()==1.0); assert(bounds[1].maximum()==6.0); assert(bounds[1].range()==5.0); - + std::cout << " OK\n"; - + //test calculation of difference hypervolume - moeoHyperVolumeDifferenceMetric < ObjectiveVector> metric2(false, 2); - std::cout << "\t>test difference without normalization and a coefficient rho=>"; - double difference=metric2(set1,set2); + moeoHyperVolumeDifferenceMetric < ObjectiveVector> metric2(false, 2); + std::cout << "\t>test difference without normalization and a coefficient rho=>"; + double difference=metric2(set1,set2); assert(difference==5.0); std::cout << " OK\n"; - + moeoHyperVolumeDifferenceMetric < ObjectiveVector> metric3(true, 1.1); - double tolerance = 1e-10; - std::cout << "\t>test difference with normalization and coefficient rho=>"; - difference=metric3(set1,set2); + double tolerance = 1e-10; + std::cout << "\t>test difference with normalization and coefficient rho=>"; + difference=metric3(set1,set2); assert( (difference < (0.02 + tolerance)) && (difference > (0.02 - tolerance))); std::cout << " OK\n"; - + ObjectiveVector ref_point; ref_point[0]= 10; ref_point[1]= 12; - moeoHyperVolumeDifferenceMetric < ObjectiveVector> metric4(false, ref_point); - std::cout << "\t>test difference without normalization and a ref_point=>"; - difference=metric4(set1,set2); + moeoHyperVolumeDifferenceMetric < ObjectiveVector> metric4(false, ref_point); + std::cout << "\t>test difference without normalization and a ref_point=>"; + difference=metric4(set1,set2); assert(difference==5.0); std::cout << " OK\n"; - + ref_point[0]= 1.1; ref_point[1]= 1.1; moeoHyperVolumeDifferenceMetric < ObjectiveVector> metric5(true, ref_point); - std::cout << "\t>test difference with normalization and a ref_point=>"; - difference=metric5(set1,set2); + std::cout << "\t>test difference with normalization and a ref_point=>"; + difference=metric5(set1,set2); assert( (difference < (0.02 + tolerance)) && (difference > (0.02 - tolerance))); std::cout << " OK\n"; - - - - + + + + return EXIT_SUCCESS; } diff --git a/trunk/paradiseo-moeo/test/t-moeoILS_HC.cpp b/trunk/paradiseo-moeo/test/t-moeoILS_HC.cpp new file mode 100644 index 000000000..343e96c6b --- /dev/null +++ b/trunk/paradiseo-moeo/test/t-moeoILS_HC.cpp @@ -0,0 +1,300 @@ +/* + * + * 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 +#include // MO +#include + +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 +{ + public : + void operator () (Solution & _solution) + { + Solution sol=_solution; + } +} ; + +class testMoveInit : public moMoveInit +{ + public : + void operator () (testMove & _move, const Solution & _solution) + { + testMove move=_move; + const Solution sol(_solution); + } +} ; + +class testMoveNext : public moNextMove +{ + public : + bool operator () (testMove & _move, const Solution & _solution) + { + testMove move=_move; + const Solution sol(_solution); + + return false; + } +} ; + +class testMoveIncrEval : public moMoveIncrEval +{ + public : + ObjectiveVector operator () (const testMove & _move, const Solution & _solution) + { + const testMove move(_move); + const Solution solution(_solution); + + + return _solution.objectiveVector(); + } +} ; + +class testTabuList : public moTabuList +{ + 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 +{ + 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 +{ + 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 +{ + 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 +{ + 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 +{ + 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 &_pop){ + } + + double operator() (const ObjectiveVector &_obj){ + return _obj[0]+_obj[1]; + } + void updateByDeleting(eoPop& pop, ObjectiveVector& obj){} + +} ; + +class selectMove: public moMoveSelect +{ + 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 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; +} + +//----------------------------------------------------------------------------- + diff --git a/trunk/paradiseo-moeo/test/t-moeoILS_SA.cpp b/trunk/paradiseo-moeo/test/t-moeoILS_SA.cpp new file mode 100644 index 000000000..4db8f78e3 --- /dev/null +++ b/trunk/paradiseo-moeo/test/t-moeoILS_SA.cpp @@ -0,0 +1,325 @@ +/* + * + * 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 +#include // MO +#include + +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 +{ + public : + void operator () (Solution & _solution) + { + Solution sol=_solution; + } +} ; + +class testMoveInit : public moMoveInit +{ + public : + void operator () (testMove & _move, const Solution & _solution) + { + testMove move=_move; + const Solution sol(_solution); + } +} ; + +class testMoveNext : public moNextMove +{ + public : + bool operator () (testMove & _move, const Solution & _solution) + { + testMove move=_move; + const Solution sol(_solution); + + return false; + } +} ; + +class testMoveIncrEval : public moMoveIncrEval +{ + public : + ObjectiveVector operator () (const testMove & _move, const Solution & _solution) + { + const testMove move(_move); + const Solution solution(_solution); + + + return _solution.objectiveVector(); + } +} ; + +class testTabuList : public moTabuList +{ + 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 +{ + 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 +{ + 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 +{ + 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 +{ + 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 +{ + 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 &_pop){ + } + + double operator() (const ObjectiveVector &_obj){ + return _obj[0]+_obj[1]; + } + void updateByDeleting(eoPop& pop, ObjectiveVector& obj){} + +} ; + +class selectMove: public moMoveSelect +{ + 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 +{ +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 ils(init, next, incrEval, singler, select, continu, comparator, perturbation, eval); + moeoILS 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; +} + +//----------------------------------------------------------------------------- + diff --git a/trunk/paradiseo-moeo/test/t-moeoILS_TS.cpp b/trunk/paradiseo-moeo/test/t-moeoILS_TS.cpp new file mode 100755 index 000000000..135ea24f6 --- /dev/null +++ b/trunk/paradiseo-moeo/test/t-moeoILS_TS.cpp @@ -0,0 +1,277 @@ +/* +* +* 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 +#include // MO +#include + +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 +{ + public : + void operator () (Solution & _solution) + { + Solution sol=_solution; + } +} ; + +class testMoveInit : public moMoveInit +{ + public : + void operator () (testMove & _move, const Solution & _solution) + { + testMove move=_move; + const Solution sol(_solution); + } +} ; + +class testMoveNext : public moNextMove +{ + public : + bool operator () (testMove & _move, const Solution & _solution) + { + testMove move=_move; + const Solution sol(_solution); + + return false; + } +} ; + +class testMoveIncrEval : public moMoveIncrEval +{ + public : + ObjectiveVector operator () (const testMove & _move, const Solution & _solution) + { + const testMove move(_move); + const Solution solution(_solution); + + + return _solution.objectiveVector(); + } +} ; + +class testTabuList : public moTabuList +{ + 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 +{ + 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 +{ + 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 +{ + 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 +{ + 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 +{ + 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 &_pop){ + } + + double operator() (const ObjectiveVector &_obj){ + return _obj[0]+_obj[1]; + } + void updateByDeleting(eoPop& 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 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; +} + +//----------------------------------------------------------------------------- diff --git a/trunk/paradiseo-moeo/test/t-moeoTS.cpp b/trunk/paradiseo-moeo/test/t-moeoTS.cpp new file mode 100644 index 000000000..ee15d7093 --- /dev/null +++ b/trunk/paradiseo-moeo/test/t-moeoTS.cpp @@ -0,0 +1,275 @@ +/* +* +* 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 +#include // MO +#include + +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 +{ + public : + void operator () (Solution & _solution) + { + Solution sol=_solution; + } +} ; + +class testMoveInit : public moMoveInit +{ + public : + void operator () (testMove & _move, const Solution & _solution) + { + testMove move=_move; + const Solution sol(_solution); + } +} ; + +class testMoveNext : public moNextMove +{ + public : + bool operator () (testMove & _move, const Solution & _solution) + { + testMove move=_move; + const Solution sol(_solution); + + return false; + } +} ; + +class testMoveIncrEval : public moMoveIncrEval +{ + public : + ObjectiveVector operator () (const testMove & _move, const Solution & _solution) + { + const testMove move(_move); + const Solution solution(_solution); + + + return _solution.objectiveVector(); + } +} ; + +class testTabuList : public moTabuList +{ + 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 +{ + 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 +{ + 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 +{ + 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 +{ + 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 +{ + 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 &_pop){ + } + + double operator() (const ObjectiveVector &_obj){ + return _obj[0]+_obj[1]; + } + void updateByDeleting(eoPop& 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 sincrEval(singler,incrEval); + moeoTSMoveLoopExpl expl(init,next,sincrEval,tabuList,aspirCrit); + moeoTS ts(init,next,incrEval,tabuList,aspirCrit,continu,singler); + + + cout << "[ moeoTS ] ==> "; + ts(solution); + cout << "OK" << endl; + return EXIT_SUCCESS; +} + +//----------------------------------------------------------------------------- diff --git a/trunk/paradiseo-moeo/test/t-moeoVNS.cpp b/trunk/paradiseo-moeo/test/t-moeoVNS.cpp new file mode 100755 index 000000000..e95e7421d --- /dev/null +++ b/trunk/paradiseo-moeo/test/t-moeoVNS.cpp @@ -0,0 +1,187 @@ +/* +* +* 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 +#include // MO +#include +#include + +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 solution; +typedef moeoRealObjectiveVector ObjectiveVector; +typedef eoScalarFitness< float, std::greater > tspFitness ; +typedef moeoRealVector 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 +{ +public : + + void operator () (solution & _solution) + { + solution sol=_solution; + } +} ; + + +class solutionAlgo : public moAlgo +{ +public : + bool operator () (solution & _solution) + { + solution solution(_solution); + return true; + } +} ; + +class Voisinage : public eoMonOp +{ +public : + bool operator () (Route & _solution) + { + _solution.invalidate(); + //_solution.fitness(); + + return true; + } +} ; + +class Explorer : public moExpl +{ +public: + Explorer(eoMonOp & expl): moExpl( expl) + { + + } +}; + +class solutionEval : public eoEvalFunc +{ +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 +{ + public: + solutionSingler(solutionEval &_eval):eval(_eval){} + void operator () (Route & _solution){ + eval(_solution); + _solution.fitness(_solution.objectiveVector()[0]+_solution.objectiveVector()[1]); + } + void operator()(eoPop &_pop){ + } + + Route::Fitness operator() (const ObjectiveVector &_obj){ + return _obj[0]+_obj[1]; + } + void updateByDeleting(eoPop& 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 poids; + poids.push_back(1); + poids.push_back(1); + solutionSingler singler(eval); + + moeoVNS vns(explorer, singler); + + cout << "[moeoVNS] ==> "; + + so.fitness(5.0); + + vns(so); + + assert(so.fitness()==12.0); + + cout << "OK" << endl; + + return EXIT_SUCCESS; +} + +//-----------------------------------------------------------------------------