nojhan/paradiseo
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Test for SingleObjectivization algorithms added

Browse source 
git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@1625 331e1502-861f-0410-8da2-ba01fb791d7f
This commit is contained in:
jhumeau 2009-12-14 15:11:28 +00:00
commit 2c229f811b
8 changed files with 1694 additions and 27 deletions
Download patch file Download diff file Expand all files Collapse all files

8
trunk/paradiseo-moeo/test/CMakeLists.txt
View file

@ -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})

297
trunk/paradiseo-moeo/test/t-moeoHC.cpp Normal file
View file

@ -0,0 +1,297 @@
/*
* <t-moILS_HC.cpp>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2008
*
* S<-61><-87>bastien Cahon, Jean-Charles Boisson (Jean-Charles.Boisson@lifl.fr)
*
* This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use,
* modify and/ or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info".
*
* As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited liability.
*
* In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
* The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms.
*
* ParadisEO WebSite : http://paradiseo.gforge.inria.fr
* Contact: paradiseo-help@lists.gforge.inria.fr
*
*/
//-----------------------------------------------------------------------------
// t-moILS_HC.cpp
//-----------------------------------------------------------------------------
#include <eo> // EO
#include <mo> // MO
#include <moeo>
using std::cout;
using std::endl;
//-----------------------------------------------------------------------------
class ObjectiveVectorTraits : public moeoObjectiveVectorTraits
{
public:
static bool minimizing (int i)
{
return true;
}
static bool maximizing (int i)
{
return false;
}
static unsigned int nObjectives ()
{
return 2;
}
};
typedef moeoRealObjectiveVector < ObjectiveVectorTraits > ObjectiveVector;
class Solution : public moeoRealVector < ObjectiveVector, double, double >
{
public:
Solution() : moeoRealVector < ObjectiveVector, double, double > (2) {}
};
class solutionEval : public moeoEvalFunc < Solution >
{
public:
void operator () (Solution & _sol)
{
ObjectiveVector objVec;
objVec[0] = _sol[0];
objVec[1] = _sol[1];
_sol.objectiveVector(objVec);
}
};
class testMove : public moMove <Solution>
{
public :
void operator () (Solution & _solution)
{
Solution sol=_solution;
}
} ;
class testMoveInit : public moMoveInit <testMove>
{
public :
void operator () (testMove & _move, const Solution & _solution)
{
testMove move=_move;
const Solution sol(_solution);
}
} ;
class testMoveNext : public moNextMove <testMove>
{
public :
bool operator () (testMove & _move, const Solution & _solution)
{
testMove move=_move;
const Solution sol(_solution);
return false;
}
} ;
class testMoveIncrEval : public moMoveIncrEval <testMove,ObjectiveVector>
{
public :
ObjectiveVector operator () (const testMove & _move, const Solution & _solution)
{
const testMove move(_move);
const Solution solution(_solution);
return _solution.objectiveVector();
}
} ;
class testTabuList : public moTabuList<testMove>
{
public:
bool operator() (const testMove & _move, const Solution & _solution)
{
const testMove move(_move);
const Solution sol(_solution);
return false;
}
void add(const testMove & _move, const Solution & _solution)
{
const testMove move(_move);
const Solution sol(_solution);
}
void update()
{}
void init()
{}
};
class testAspirCrit : public moAspirCrit<testMove>
{
public:
bool operator() (const testMove & _move, const double & _fitness)
{
double fitness;
const testMove move(_move);
fitness=_fitness;
return false;
}
void init()
{}
};
class solutionContinue : public moSolContinue<Solution>
{
public :
solutionContinue(): counter(0)
{}
bool operator () (const Solution & _solution)
{
const Solution sol(_solution);
if(counter==0)
{
counter++;
return true;
}
return false;
}
void init()
{}
private :
unsigned int counter;
} ;
class solutionComparator : public moComparator<Solution>
{
public :
bool operator () (const Solution & _solution1 , const Solution & _solution2)
{
const Solution sol1(_solution1);
const Solution sol2(_solution2);
return sol1.fitness()>sol2.fitness();
}
} ;
class solutionPerturbation : public eoMonOp<Solution>
{
public :
bool operator () (Solution & _solution)
{
ObjectiveVector objVec;
objVec[0] = 1;
objVec[1] = 1;
_solution[1]=1;
_solution[0]=1;
_solution.objectiveVector(objVec);
_solution.fitness(2);
return true;
}
} ;
class solutionSingler : public moeoSingleObjectivization<Solution>
{
void operator () (Solution & _solution){
ObjectiveVector objVec;
objVec[0] = _solution[0];
objVec[1] = _solution[1];
_solution.objectiveVector(objVec);
_solution.fitness(_solution.objectiveVector()[0]+_solution.objectiveVector()[1]);
}
void operator()(eoPop<Solution> &_pop){
}
double operator() (const ObjectiveVector &_obj){
return _obj[0]+_obj[1];
}
void updateByDeleting(eoPop<Solution>& pop, ObjectiveVector& obj){}
} ;
class selectMove: public moMoveSelect<testMove>
{
public:
void init(const double &d){
max_fit=d;
}
bool update(const testMove &move,const double &fitness){
if (fitness>max_fit){
max_fit=fitness;
best_move=move;
return false;
}else
return true;
}
void operator()(testMove &move,double &fitness){
move=best_move;
fitness=max_fit;
}
private:
double max_fit;
testMove best_move;
};
//-----------------------------------------------------------------------------
int main()
{
std::string test_result;
int return_value;
Solution solution;
testMoveInit init;
testMoveNext next;
testMoveIncrEval incrEval;
testTabuList tabuList;
testAspirCrit aspirCrit;
solutionEval eval;
solutionContinue continu;
solutionContinue continu_2;
solutionComparator comparator;
solutionPerturbation perturbation;
solutionSingler singler;
selectMove select;
moeoHC<testMove> hc(init, next, incrEval, select, singler);
cout << "[ moeoHC ] ==> ";
hc(solution);
cout << "OK" << endl;
return EXIT_SUCCESS;
}
//-----------------------------------------------------------------------------

52
trunk/paradiseo-moeo/test/t-moeoHyperVolumeDifferenceMetric.cpp
View file

@ -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;
}

300
trunk/paradiseo-moeo/test/t-moeoILS_HC.cpp Normal file
View file

@ -0,0 +1,300 @@
/*
* <t-moILS_HC.cpp>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2008
*
* S<-61><-87>bastien Cahon, Jean-Charles Boisson (Jean-Charles.Boisson@lifl.fr)
*
* This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use,
* modify and/ or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info".
*
* As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited liability.
*
* In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
* The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms.
*
* ParadisEO WebSite : http://paradiseo.gforge.inria.fr
* Contact: paradiseo-help@lists.gforge.inria.fr
*
*/
//-----------------------------------------------------------------------------
// t-moILS_HC.cpp
//-----------------------------------------------------------------------------
#include <eo> // EO
#include <mo> // MO
#include <moeo>
using std::cout;
using std::endl;
//-----------------------------------------------------------------------------
class ObjectiveVectorTraits : public moeoObjectiveVectorTraits
{
public:
static bool minimizing (int i)
{
return true;
}
static bool maximizing (int i)
{
return false;
}
static unsigned int nObjectives ()
{
return 2;
}
};
typedef moeoRealObjectiveVector < ObjectiveVectorTraits > ObjectiveVector;
class Solution : public moeoRealVector < ObjectiveVector, double, double >
{
public:
Solution() : moeoRealVector < ObjectiveVector, double, double > (2) {}
};
class solutionEval : public moeoEvalFunc < Solution >
{
public:
void operator () (Solution & _sol)
{
ObjectiveVector objVec;
objVec[0] = _sol[0];
objVec[1] = _sol[1];
_sol.objectiveVector(objVec);
}
};
class testMove : public moMove <Solution>
{
public :
void operator () (Solution & _solution)
{
Solution sol=_solution;
}
} ;
class testMoveInit : public moMoveInit <testMove>
{
public :
void operator () (testMove & _move, const Solution & _solution)
{
testMove move=_move;
const Solution sol(_solution);
}
} ;
class testMoveNext : public moNextMove <testMove>
{
public :
bool operator () (testMove & _move, const Solution & _solution)
{
testMove move=_move;
const Solution sol(_solution);
return false;
}
} ;
class testMoveIncrEval : public moMoveIncrEval <testMove,ObjectiveVector>
{
public :
ObjectiveVector operator () (const testMove & _move, const Solution & _solution)
{
const testMove move(_move);
const Solution solution(_solution);
return _solution.objectiveVector();
}
} ;
class testTabuList : public moTabuList<testMove>
{
public:
bool operator() (const testMove & _move, const Solution & _solution)
{
const testMove move(_move);
const Solution sol(_solution);
return false;
}
void add(const testMove & _move, const Solution & _solution)
{
const testMove move(_move);
const Solution sol(_solution);
}
void update()
{}
void init()
{}
};
class testAspirCrit : public moAspirCrit<testMove>
{
public:
bool operator() (const testMove & _move, const double & _fitness)
{
double fitness;
const testMove move(_move);
fitness=_fitness;
return false;
}
void init()
{}
};
class solutionContinue : public moSolContinue<Solution>
{
public :
solutionContinue(): counter(0)
{}
bool operator () (const Solution & _solution)
{
const Solution sol(_solution);
if(counter==0)
{
counter++;
return true;
}
return false;
}
void init()
{}
private :
unsigned int counter;
} ;
class solutionComparator : public moComparator<Solution>
{
public :
bool operator () (const Solution & _solution1 , const Solution & _solution2)
{
const Solution sol1(_solution1);
const Solution sol2(_solution2);
return sol1.fitness()>sol2.fitness();
}
} ;
class solutionPerturbation : public eoMonOp<Solution>
{
public :
bool operator () (Solution & _solution)
{
ObjectiveVector objVec;
objVec[0] = 1;
objVec[1] = 1;
_solution[1]=1;
_solution[0]=1;
_solution.objectiveVector(objVec);
_solution.fitness(2);
return true;
}
} ;
class solutionSingler : public moeoSingleObjectivization<Solution>
{
void operator () (Solution & _solution){
ObjectiveVector objVec;
objVec[0] = _solution[0];
objVec[1] = _solution[1];
_solution.objectiveVector(objVec);
_solution.fitness(_solution.objectiveVector()[0]+_solution.objectiveVector()[1]);
}
void operator()(eoPop<Solution> &_pop){
}
double operator() (const ObjectiveVector &_obj){
return _obj[0]+_obj[1];
}
void updateByDeleting(eoPop<Solution>& pop, ObjectiveVector& obj){}
} ;
class selectMove: public moMoveSelect<testMove>
{
public:
void init(const double &d){
max_fit=d;
}
bool update(const testMove &move,const double &fitness){
if (fitness>max_fit){
max_fit=fitness;
best_move=move;
return false;
}else
return true;
}
void operator()(testMove &move,double &fitness){
move=best_move;
fitness=max_fit;
}
private:
double max_fit;
testMove best_move;
};
//-----------------------------------------------------------------------------
int main()
{
std::string test_result;
int return_value;
Solution solution;
testMoveInit init;
testMoveNext next;
testMoveIncrEval incrEval;
testTabuList tabuList;
testAspirCrit aspirCrit;
solutionEval eval;
solutionContinue continu;
solutionContinue continu_2;
solutionComparator comparator;
solutionPerturbation perturbation;
solutionSingler singler;
selectMove select;
moeoILS<testMove> ils(init, next, incrEval, singler, select, continu, comparator, perturbation);
cout << "[ moILS_HC ] ==> ";
ils(solution);
test_result=((solution.fitness()!=2)?"KO":"OK");
return_value=((test_result.compare("KO")==0)?EXIT_FAILURE:EXIT_SUCCESS);
cout << test_result << endl;
return return_value;
}
//-----------------------------------------------------------------------------

325
trunk/paradiseo-moeo/test/t-moeoILS_SA.cpp Normal file
View file

@ -0,0 +1,325 @@
/*
* <t-moILS_HC.cpp>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2008
*
* S<-61><-87>bastien Cahon, Jean-Charles Boisson (Jean-Charles.Boisson@lifl.fr)
* Legillon François
*
* This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use,
* modify and/ or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info".
*
* As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited liability.
*
* In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
* The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms.
*
* ParadisEO WebSite : http://paradiseo.gforge.inria.fr
* Contact: paradiseo-help@lists.gforge.inria.fr
*
*/
//-----------------------------------------------------------------------------
// t-moILS_HC.cpp
//-----------------------------------------------------------------------------
#include <eo> // EO
#include <mo> // MO
#include <moeo>
using std::cout;
using std::endl;
//-----------------------------------------------------------------------------
class ObjectiveVectorTraits : public moeoObjectiveVectorTraits
{
public:
static bool minimizing (int i)
{
return true;
}
static bool maximizing (int i)
{
return false;
}
static unsigned int nObjectives ()
{
return 2;
}
};
typedef moeoRealObjectiveVector < ObjectiveVectorTraits > ObjectiveVector;
class Solution : public moeoRealVector < ObjectiveVector, double, double >
{
public:
Solution() : moeoRealVector < ObjectiveVector, double, double > (2) {}
};
class solutionEval : public moeoEvalFunc < Solution >
{
public:
void operator () (Solution & _sol)
{
ObjectiveVector objVec;
objVec[0] = _sol[0];
objVec[1] = _sol[1];
_sol.objectiveVector(objVec);
}
};
class testMove : public moMove <Solution>
{
public :
void operator () (Solution & _solution)
{
Solution sol=_solution;
}
} ;
class testMoveInit : public moMoveInit <testMove>
{
public :
void operator () (testMove & _move, const Solution & _solution)
{
testMove move=_move;
const Solution sol(_solution);
}
} ;
class testMoveNext : public moNextMove <testMove>
{
public :
bool operator () (testMove & _move, const Solution & _solution)
{
testMove move=_move;
const Solution sol(_solution);
return false;
}
} ;
class testMoveIncrEval : public moMoveIncrEval <testMove,ObjectiveVector>
{
public :
ObjectiveVector operator () (const testMove & _move, const Solution & _solution)
{
const testMove move(_move);
const Solution solution(_solution);
return _solution.objectiveVector();
}
} ;
class testTabuList : public moTabuList<testMove>
{
public:
bool operator() (const testMove & _move, const Solution & _solution)
{
const testMove move(_move);
const Solution sol(_solution);
return false;
}
void add(const testMove & _move, const Solution & _solution)
{
const testMove move(_move);
const Solution sol(_solution);
}
void update()
{}
void init()
{}
};
class testAspirCrit : public moAspirCrit<testMove>
{
public:
bool operator() (const testMove & _move, const double & _fitness)
{
double fitness;
const testMove move(_move);
fitness=_fitness;
return false;
}
void init()
{}
};
class solutionContinue : public moSolContinue<Solution>
{
public :
solutionContinue(): counter(0)
{}
bool operator () (const Solution & _solution)
{
const Solution sol(_solution);
if(counter==0)
{
counter++;
return true;
}
return false;
}
void init()
{}
private :
unsigned int counter;
} ;
class solutionComparator : public moComparator<Solution>
{
public :
bool operator () (const Solution & _solution1 , const Solution & _solution2)
{
const Solution sol1(_solution1);
const Solution sol2(_solution2);
return sol1.fitness()>sol2.fitness();
}
} ;
class solutionPerturbation : public eoMonOp<Solution>
{
public :
bool operator () (Solution & _solution)
{
ObjectiveVector objVec;
objVec[0] = 1;
objVec[1] = 1;
_solution[1]=1;
_solution[0]=1;
_solution.objectiveVector(objVec);
_solution.fitness(2);
return true;
}
} ;
class solutionSingler : public moeoSingleObjectivization<Solution>
{
void operator () (Solution & _solution){
ObjectiveVector objVec;
objVec[0] = _solution[0];
objVec[1] = _solution[1];
_solution.objectiveVector(objVec);
_solution.fitness(_solution.objectiveVector()[0]+_solution.objectiveVector()[1]);
}
void operator()(eoPop<Solution> &_pop){
}
double operator() (const ObjectiveVector &_obj){
return _obj[0]+_obj[1];
}
void updateByDeleting(eoPop<Solution>& pop, ObjectiveVector& obj){}
} ;
class selectMove: public moMoveSelect<testMove>
{
public:
void init(const double &d){
max_fit=d;
}
bool update(const testMove &move,const double &fitness){
if (fitness>max_fit){
max_fit=fitness;
best_move=move;
return false;
}else
return true;
}
void operator()(testMove &move,double &fitness){
move=best_move;
fitness=max_fit;
}
private:
double max_fit;
testMove best_move;
};
class testCooling : public moCoolingSchedule
{
public :
bool operator () (double & _temperature)
{
double temperature;
temperature=_temperature;
return false;
}
};
class testRandMove : public moRandMove<testMove>
{
public :
void operator () (testMove & _move)
{
_move=_move;
}
};
//-----------------------------------------------------------------------------
int main()
{
std::string test_result;
int return_value;
Solution solution;
testMoveInit init;
testMoveNext next;
testMoveIncrEval incrEval;
testTabuList tabuList;
testAspirCrit aspirCrit;
solutionEval eval;
solutionContinue continu;
solutionContinue continu_2;
solutionComparator comparator;
solutionPerturbation perturbation;
solutionSingler singler;
selectMove select;
testRandMove rand;
testCooling cooling;
// moeoILS<testMove> ils(init, next, incrEval, singler, select, continu, comparator, perturbation, eval);
moeoILS<testMove> ils(rand, incrEval,singler, continu, 10.0, cooling, continu_2, comparator, perturbation);
cout << "[ moILS_HC ] ==> ";
ils(solution);
test_result=((solution.fitness()!=2)?"KO":"OK");
return_value=((test_result.compare("KO")==0)?EXIT_FAILURE:EXIT_SUCCESS);
cout << test_result << endl;
return return_value;
}
//-----------------------------------------------------------------------------

277
trunk/paradiseo-moeo/test/t-moeoILS_TS.cpp Executable file
View file

@ -0,0 +1,277 @@
/*
* <t-moILS_TS.cpp>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2008
*
* Sébastien Cahon, Jean-Charles Boisson (Jean-Charles.Boisson@lifl.fr)
*
* This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use,
* modify and/ or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info".
*
* As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited liability.
*
* In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
* The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms.
*
* ParadisEO WebSite : http://paradiseo.gforge.inria.fr
* Contact: paradiseo-help@lists.gforge.inria.fr
*
*/
//-----------------------------------------------------------------------------
// t-moILS_TS.cpp
//-----------------------------------------------------------------------------
#include <eo> // EO
#include <mo> // MO
#include <moeo>
using std::cout;
using std::endl;
//-----------------------------------------------------------------------------
class ObjectiveVectorTraits : public moeoObjectiveVectorTraits
{
public:
static bool minimizing (int i)
{
return true;
}
static bool maximizing (int i)
{
return false;
}
static unsigned int nObjectives ()
{
return 2;
}
};
typedef moeoRealObjectiveVector < ObjectiveVectorTraits > ObjectiveVector;
class Solution : public moeoRealVector < ObjectiveVector, double, double >
{
public:
Solution() : moeoRealVector < ObjectiveVector, double, double > (2) {}
};
class solutionEval : public moeoEvalFunc < Solution >
{
public:
void operator () (Solution & _sol)
{
ObjectiveVector objVec;
objVec[0] = _sol[0];
objVec[1] = _sol[1];
_sol.objectiveVector(objVec);
// _sol.fitness(_sol[1]+_sol[2]);
}
};
class testMove : public moMove <Solution>
{
public :
void operator () (Solution & _solution)
{
Solution sol=_solution;
}
} ;
class testMoveInit : public moMoveInit <testMove>
{
public :
void operator () (testMove & _move, const Solution & _solution)
{
testMove move=_move;
const Solution sol(_solution);
}
} ;
class testMoveNext : public moNextMove <testMove>
{
public :
bool operator () (testMove & _move, const Solution & _solution)
{
testMove move=_move;
const Solution sol(_solution);
return false;
}
} ;
class testMoveIncrEval : public moMoveIncrEval <testMove,ObjectiveVector>
{
public :
ObjectiveVector operator () (const testMove & _move, const Solution & _solution)
{
const testMove move(_move);
const Solution solution(_solution);
return _solution.objectiveVector();
}
} ;
class testTabuList : public moTabuList<testMove>
{
public:
bool operator() (const testMove & _move, const Solution & _solution)
{
const testMove move(_move);
const Solution sol(_solution);
return false;
}
void add(const testMove & _move, const Solution & _solution)
{
const testMove move(_move);
const Solution sol(_solution);
}
void update()
{}
void init()
{}
};
class testAspirCrit : public moAspirCrit<testMove>
{
public:
bool operator() (const testMove & _move, const double & _fitness)
{
double fitness;
const testMove move(_move);
fitness=_fitness;
return false;
}
void init()
{}
};
class solutionContinue : public moSolContinue<Solution>
{
public :
solutionContinue(): counter(0)
{}
bool operator () (const Solution & _solution)
{
const Solution sol(_solution);
if(counter==0)
{
counter++;
return true;
}
return false;
}
void init()
{}
private :
unsigned int counter;
} ;
class solutionComparator : public moComparator<Solution>
{
public :
bool operator () (const Solution & _solution1 , const Solution & _solution2)
{
const Solution sol1(_solution1);
const Solution sol2(_solution2);
return sol1.fitness()>sol2.fitness();
}
} ;
class solutionPerturbation : public eoMonOp<Solution>
{
public :
bool operator () (Solution & _solution)
{
ObjectiveVector objVec;
objVec[0] = 1;
objVec[1] = 1;
_solution[1]=1;
_solution[0]=1;
_solution.objectiveVector(objVec);
_solution.fitness(2);
_solution.invalidate();
return true;
}
} ;
class solutionSingler : public moeoSingleObjectivization<Solution>
{
void operator () (Solution & _solution){
ObjectiveVector objVec;
objVec[0] = _solution[0];
objVec[1] = _solution[1];
_solution.objectiveVector(objVec);
_solution.fitness(_solution.objectiveVector()[0]+_solution.objectiveVector()[1]);
}
void operator()(eoPop<Solution> &_pop){
}
double operator() (const ObjectiveVector &_obj){
return _obj[0]+_obj[1];
}
void updateByDeleting(eoPop<Solution>& pop, ObjectiveVector& obj){}
} ;
//-----------------------------------------------------------------------------
int main()
{
std::string test_result;
int return_value;
Solution solution;
testMoveInit init;
testMoveNext next;
testMoveIncrEval incrEval;
testTabuList tabuList;
testAspirCrit aspirCrit;
solutionEval eval;
solutionContinue continu;
solutionContinue continu_2;
solutionComparator comparator;
solutionPerturbation perturbation;
solutionSingler singler;
moeoILS<testMove> ils(init, next, incrEval, singler, tabuList, aspirCrit, continu, continu_2, comparator, perturbation);
cout << "[ moILS_TS ] ==> ";
ils(solution);
test_result=((solution.fitness()!=2)?"KO":"OK");
return_value=((test_result.compare("KO")==0)?EXIT_FAILURE:EXIT_SUCCESS);
cout << test_result << endl;
return return_value;
}
//-----------------------------------------------------------------------------

275
trunk/paradiseo-moeo/test/t-moeoTS.cpp Normal file
View file

@ -0,0 +1,275 @@
/*
* <t-moeoTS.cpp>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2006-2007
* (C) OPAC Team, LIFL, 2002-2008
*
* Sébastien Cahon, Jean-Charles Boisson (Jean-Charles.Boisson@lifl.fr)
*
* This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use,
* modify and/ or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info".
*
* As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited liability.
*
* In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
* The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms.
*
* ParadisEO WebSite : http://paradiseo.gforge.inria.fr
* Contact: paradiseo-help@lists.gforge.inria.fr
*
*/
//-----------------------------------------------------------------------------
// t-moILS_TS.cpp
//-----------------------------------------------------------------------------
#include <eo> // EO
#include <mo> // MO
#include <moeo>
using std::cout;
using std::endl;
//-----------------------------------------------------------------------------
class ObjectiveVectorTraits : public moeoObjectiveVectorTraits
{
public:
static bool minimizing (int i)
{
return true;
}
static bool maximizing (int i)
{
return false;
}
static unsigned int nObjectives ()
{
return 2;
}
};
typedef moeoRealObjectiveVector < ObjectiveVectorTraits > ObjectiveVector;
class Solution : public moeoRealVector < ObjectiveVector, double, double >
{
public:
Solution() : moeoRealVector < ObjectiveVector, double, double > (2) {}
};
class solutionEval : public moeoEvalFunc < Solution >
{
public:
void operator () (Solution & _sol)
{
ObjectiveVector objVec;
objVec[0] = _sol[0];
objVec[1] = _sol[1];
_sol.objectiveVector(objVec);
// _sol.fitness(_sol[1]+_sol[2]);
}
};
class testMove : public moMove <Solution>
{
public :
void operator () (Solution & _solution)
{
Solution sol=_solution;
}
} ;
class testMoveInit : public moMoveInit <testMove>
{
public :
void operator () (testMove & _move, const Solution & _solution)
{
testMove move=_move;
const Solution sol(_solution);
}
} ;
class testMoveNext : public moNextMove <testMove>
{
public :
bool operator () (testMove & _move, const Solution & _solution)
{
testMove move=_move;
const Solution sol(_solution);
return false;
}
} ;
class testMoveIncrEval : public moMoveIncrEval <testMove,ObjectiveVector>
{
public :
ObjectiveVector operator () (const testMove & _move, const Solution & _solution)
{
const testMove move(_move);
const Solution solution(_solution);
return _solution.objectiveVector();
}
} ;
class testTabuList : public moTabuList<testMove>
{
public:
bool operator() (const testMove & _move, const Solution & _solution)
{
const testMove move(_move);
const Solution sol(_solution);
return false;
}
void add(const testMove & _move, const Solution & _solution)
{
const testMove move(_move);
const Solution sol(_solution);
}
void update()
{}
void init()
{}
};
class testAspirCrit : public moAspirCrit<testMove>
{
public:
bool operator() (const testMove & _move, const double & _fitness)
{
double fitness;
const testMove move(_move);
fitness=_fitness;
return false;
}
void init()
{}
};
class solutionContinue : public moSolContinue<Solution>
{
public :
solutionContinue(): counter(0)
{}
bool operator () (const Solution & _solution)
{
const Solution sol(_solution);
if(counter==0)
{
counter++;
return true;
}
return false;
}
void init()
{}
private :
unsigned int counter;
} ;
class solutionComparator : public moComparator<Solution>
{
public :
bool operator () (const Solution & _solution1 , const Solution & _solution2)
{
const Solution sol1(_solution1);
const Solution sol2(_solution2);
return sol1.fitness()>sol2.fitness();
}
} ;
class solutionPerturbation : public eoMonOp<Solution>
{
public :
bool operator () (Solution & _solution)
{
ObjectiveVector objVec;
objVec[0] = 1;
objVec[1] = 1;
_solution[1]=1;
_solution[0]=1;
_solution.objectiveVector(objVec);
_solution.fitness(2);
_solution.invalidate();
return true;
}
} ;
class solutionSingler : public moeoSingleObjectivization<Solution>
{
void operator () (Solution & _solution){
ObjectiveVector objVec;
objVec[0] = _solution[0];
objVec[1] = _solution[1];
_solution.objectiveVector(objVec);
_solution.fitness(_solution.objectiveVector()[0]+_solution.objectiveVector()[1]);
}
void operator()(eoPop<Solution> &_pop){
}
double operator() (const ObjectiveVector &_obj){
return _obj[0]+_obj[1];
}
void updateByDeleting(eoPop<Solution>& pop, ObjectiveVector& obj){}
} ;
//-----------------------------------------------------------------------------
int main()
{
std::string test_result;
int return_value;
Solution solution;
testMoveInit init;
testMoveNext next;
testMoveIncrEval incrEval;
testTabuList tabuList;
testAspirCrit aspirCrit;
solutionEval eval;
solutionContinue continu;
solutionContinue continu_2;
solutionComparator comparator;
solutionPerturbation perturbation;
solutionSingler singler;
moeoIncrEvalSingleObjectivizer<Solution,testMove> sincrEval(singler,incrEval);
moeoTSMoveLoopExpl<testMove> expl(init,next,sincrEval,tabuList,aspirCrit);
moeoTS<testMove> ts(init,next,incrEval,tabuList,aspirCrit,continu,singler);
cout << "[ moeoTS ] ==> ";
ts(solution);
cout << "OK" << endl;
return EXIT_SUCCESS;
}
//-----------------------------------------------------------------------------

187
trunk/paradiseo-moeo/test/t-moeoVNS.cpp Executable file
View file

@ -0,0 +1,187 @@
/*
* <t-moVNS.cpp>
* Copyright (C) DOLPHIN Project-Team, INRIA Futurs, 2007-2008
* (C) OPAC Team, LIFL, 2002-2008
*
* Salma Mesmoudi (salma.mesmoudi@inria.fr), Jean-Charles Boisson (Jean-Charles.Boisson@lifl.fr)
* Jeremie Humeau (jeremie.humeau@inria.fr)
*
* This software is governed by the CeCILL license under French law and
* abiding by the rules of distribution of free software. You can use,
* modify and/ or redistribute the software under the terms of the CeCILL
* license as circulated by CEA, CNRS and INRIA at the following URL
* "http://www.cecill.info".
*
* As a counterpart to the access to the source code and rights to copy,
* modify and redistribute granted by the license, users are provided only
* with a limited warranty and the software's author, the holder of the
* economic rights, and the successive licensors have only limited liability.
*
* In this respect, the user's attention is drawn to the risks associated
* with loading, using, modifying and/or developing or reproducing the
* software by the user in light of its specific status of free software,
* that may mean that it is complicated to manipulate, and that also
* therefore means that it is reserved for developers and experienced
* professionals having in-depth computer knowledge. Users are therefore
* encouraged to load and test the software's suitability as regards their
* requirements in conditions enabling the security of their systems and/or
* data to be ensured and, more generally, to use and operate it in the
* same conditions as regards security.
* The fact that you are presently reading this means that you have had
* knowledge of the CeCILL license and that you accept its terms.
*
* ParadisEO WebSite : http://paradiseo.gforge.inria.fr
* Contact: paradiseo-help@lists.gforge.inria.fr
*
*/
//-----------------------------------------------------------------------------
// t-moVNS.cpp
//-----------------------------------------------------------------------------
#include <eo> // EO
#include <mo> // MO
#include <moeo>
#include <cassert>
using std::cout;
using std::endl;
//-----------------------------------------------------------------------------
class ObjectiveVectorTraits : public moeoObjectiveVectorTraits
{
public:
static bool minimizing (int i)
{
return true;
}
static bool maximizing (int i)
{
return false;
}
static unsigned int nObjectives ()
{
return 2;
}
};
typedef EO<unsigned int> solution;
typedef moeoRealObjectiveVector<ObjectiveVectorTraits> ObjectiveVector;
typedef eoScalarFitness< float, std::greater<float> > tspFitness ;
typedef moeoRealVector <ObjectiveVector, unsigned int> Route ;
int cpt=0;
int tableau[8]={1.0, 2.0, 8.0, 8.0, 11.0, 11.0, 11.0,30.0};
class testMove : public moMove <solution>
{
public :
void operator () (solution & _solution)
{
solution sol=_solution;
}
} ;
class solutionAlgo : public moAlgo <solution>
{
public :
bool operator () (solution & _solution)
{
solution solution(_solution);
return true;
}
} ;
class Voisinage : public eoMonOp<Route>
{
public :
bool operator () (Route & _solution)
{
_solution.invalidate();
//_solution.fitness();
return true;
}
} ;
class Explorer : public moExpl<Route>
{
public:
Explorer(eoMonOp<Route> & expl): moExpl<Route>( expl)
{
}
};
class solutionEval : public eoEvalFunc <Route>
{
public :
void operator () (Route & _solution)
{
ObjectiveVector obj;
obj[0]=(tableau[0]);
obj[1]=(tableau[cpt]);
_solution.objectiveVector(obj);
_solution.fitness(obj[0]+obj[1]);
cpt++;
}
};
class solutionSingler : public moeoSingleObjectivization<Route>
{
public:
solutionSingler(solutionEval &_eval):eval(_eval){}
void operator () (Route & _solution){
eval(_solution);
_solution.fitness(_solution.objectiveVector()[0]+_solution.objectiveVector()[1]);
}
void operator()(eoPop<Route> &_pop){
}
Route::Fitness operator() (const ObjectiveVector &_obj){
return _obj[0]+_obj[1];
}
void updateByDeleting(eoPop<Route>& pop, ObjectiveVector& obj){}
solutionEval &eval;
} ;
//-----------------------------------------------------------------------------
int
main()
{
std::string test_result;
//solution solution;
Route so ;
Voisinage sol1;
Voisinage sol2;
Explorer explorer(sol1);
explorer.addExplorer(sol2);
solutionEval eval;
std::vector<double> poids;
poids.push_back(1);
poids.push_back(1);
solutionSingler singler(eval);
moeoVNS<Route> vns(explorer, singler);
cout << "[moeoVNS] ==> ";
so.fitness(5.0);
vns(so);
assert(so.fitness()==12.0);
cout << "OK" << endl;
return EXIT_SUCCESS;
}
//-----------------------------------------------------------------------------