diff --git a/branches/newMo/src/algo/moLocalSearch.h b/branches/newMo/src/algo/moLocalSearch.h index 460b5c822..3704944d1 100644 --- a/branches/newMo/src/algo/moLocalSearch.h +++ b/branches/newMo/src/algo/moLocalSearch.h @@ -63,7 +63,7 @@ public: virtual bool operator() (EOT & _solution) { if(_solution.invalid()) - fullEval(_solution); + fullEval(_solution); // initialization of the parameter of the search (for example fill empty the tabu list) searchExplorer.initParam(_solution); @@ -94,7 +94,6 @@ public: continuator.lastCall(_solution); - //A CHANGER return true; }; diff --git a/branches/newMo/src/explorer/moTSExplorer.h b/branches/newMo/src/explorer/moTSExplorer.h index ec92ac635..321a9c071 100644 --- a/branches/newMo/src/explorer/moTSExplorer.h +++ b/branches/newMo/src/explorer/moTSExplorer.h @@ -100,6 +100,7 @@ public: intensification.init(_solution); diversification.init(_solution); aspiration.init(_solution); + bestSoFar=_solution; }; @@ -114,7 +115,8 @@ public: tabuList.add(_solution, *best); intensification.add(_solution, *best); diversification.add(_solution, *best); - //bestSoFar = ???; + if(_solution.fitness() > bestSoFar.fitness()) + bestSoFar = _solution; } tabuList.update(_solution, *best); intensification.update(_solution, *best); @@ -126,9 +128,9 @@ public: /** * terminate : NOTHING TO DO */ - virtual void terminate(EOT & solution) + virtual void terminate(EOT & _solution) { - //solution = bestSoFar; + _solution= bestSoFar; }; @@ -175,7 +177,7 @@ public: //eval eval(_solution, (*current)); //check if the current is better than the best and is not tabu or if it is aspirat (by the aspiration criteria of course) - if ( (!tabuList.check(_solution, *current) && neighborComparator((*best),(*current))) || aspiration(_solution, *current) ){ + if ( (!tabuList.check(_solution, *current) || aspiration(_solution, (*current))) && neighborComparator((*best),(*current))){ // set best (*best)=(*current); } @@ -239,9 +241,13 @@ protected: moDiversification & diversification; moAspiration & aspiration; + //Current and best neighbor Neighbor* best; Neighbor* current; + //Best so far Solution + EOT bestSoFar; + // true if the move is accepted bool isAccept ; diff --git a/branches/newMo/src/memory/moAspiration.h b/branches/newMo/src/memory/moAspiration.h index 96f529326..f8746a1d8 100644 --- a/branches/newMo/src/memory/moAspiration.h +++ b/branches/newMo/src/memory/moAspiration.h @@ -1,6 +1,8 @@ #ifndef _moAspiration_h #define _moAspiration_h +#include + /** * Abstract class for Aspiration Criteria */ diff --git a/branches/newMo/src/memory/moBestImprAspiration.h b/branches/newMo/src/memory/moBestImprAspiration.h index 57441e066..6e0d1dc7a 100644 --- a/branches/newMo/src/memory/moBestImprAspiration.h +++ b/branches/newMo/src/memory/moBestImprAspiration.h @@ -32,13 +32,22 @@ public: } /** - * test if a solution is better than the "bestFoundSoFar" + * Test the tabu feature of the neighbor: + * test if the neighbor's fitness is better than the "bestFoundSoFar" fitness * @param _sol a solution * @param _neighbor a neighbor - * @return true if _sol is better than the "bestFoundSoFar" + * @return true if _neighbor fitness is better than the "bestFoundSoFar" */ bool operator()(EOT & _sol, Neighbor & _neighbor){ - return (bestFoundSoFar.fitness() < _sol.fitness()); + return (bestFoundSoFar.fitness() < _neighbor.fitness()); + } + + /** + * Getter + * @return a reference on the best found so far solution + */ + EOT& getBest(){ + return bestFoundSoFar; } private: diff --git a/branches/newMo/src/memory/moSolVectorTabuList.h b/branches/newMo/src/memory/moSolVectorTabuList.h index ddc9f59d1..59a710ac1 100644 --- a/branches/newMo/src/memory/moSolVectorTabuList.h +++ b/branches/newMo/src/memory/moSolVectorTabuList.h @@ -3,6 +3,7 @@ #include #include +#include /** * Tabu List of solution stocked in a vector @@ -36,15 +37,14 @@ public: * @param _sol the current solution * @param _neighbor the current neighbor (unused) */ - virtual void add(EOT & _sol, Neighbor & _neighbor) - { + virtual void add(EOT & _sol, Neighbor & _neighbor){ if(tabuList.size() < maxSize) tabuList.push_back(_sol); else{ tabuList[index%maxSize] = _sol; index++; } - } + } /** * update the tabulist: NOTHING TO DO @@ -60,8 +60,10 @@ public: * @return true if tabuList contains _sol */ virtual bool check(EOT & _sol, Neighbor & _neighbor){ + EOT tmp=_sol; + _neighbor.move(tmp); for(unsigned int i=0; i +Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2010 + +Sébastien Verel, Arnaud Liefooghe, Jérémie Humeau + +This software is governed by the CeCILL license under French law and +abiding by the rules of distribution of free software. You can ue, +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". + +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 +*/ +#include +#include "moTestClass.h" + +#include +#include +#include + +int main(){ + + std::cout << "[t-moBestImprAspiration] => START" << std::endl; + + moBestImprAspiration test; + eoBit sol1(4); + eoBit sol2(4); + eoBit sol3(4); + eoBit sol4(4); + bitNeighbor n1; + bitNeighbor n2; + bitNeighbor n3; + bitNeighbor n4; + + sol3[0]=true; + sol4[3]=true; + + sol1.fitness(4); + sol2.fitness(5); + sol3.fitness(3); + sol4.fitness(3); + n1.fitness(4); + n2.fitness(5); + n3.fitness(3); + n4.fitness(3); + + test.init(sol1); + assert(test.getBest()==sol1); + assert(!test(sol2,n2)); + assert(test(sol3,n3)); + test.update(sol3,n3); + assert(test.getBest()==sol3); + assert(!test(sol4,n4)); + test.update(sol4,n4); + assert(test.getBest()==sol3); + + std::cout << "[t-moBestImprAspiration] => OK" << std::endl; + + return EXIT_SUCCESS; +} + diff --git a/branches/newMo/test/t-moSolVectorTabuList.cpp b/branches/newMo/test/t-moSolVectorTabuList.cpp index fbb068e38..e62f5803c 100644 --- a/branches/newMo/test/t-moSolVectorTabuList.cpp +++ b/branches/newMo/test/t-moSolVectorTabuList.cpp @@ -38,39 +38,55 @@ int main(){ std::cout << "[t-moSolVectorTabuList] => START" << std::endl; - moSolVectorTabuList test(3); - bitNeighbor n; + moSolVectorTabuList test(2); + bitNeighbor n1; + bitNeighbor n2; + bitNeighbor n3; + bitNeighbor n4; + n1.index(0); + n2.index(1); + n3.index(2); + n4.index(3); - eoBit sol1(4); - eoBit sol2(4); - eoBit sol3(4); - eoBit sol4(4); + eoBit sol1(4, true); + eoBit sol2(4, true); + eoBit sol3(4, true); + eoBit sol4(4, true); - sol2[0]=true; - sol3[1]=true; - sol4[2]=true; + sol2[0]=false; + sol3[1]=false; + sol4[0]=false; + sol4[1]=false; test.init(sol1); - test.add(sol1,n); - test.add(sol2,n); - test.add(sol3,n); - assert(test.check(sol1,n)); - assert(test.check(sol2,n)); - assert(test.check(sol3,n)); - test.add(sol4,n); - assert(!test.check(sol1,n)); - assert(test.check(sol2,n)); - assert(test.check(sol3,n)); - assert(test.check(sol4,n)); + test.add(sol1,n1); + assert(test.check(sol2,n1)); + assert(!test.check(sol2,n2)); + assert(!test.check(sol2,n3)); + assert(!test.check(sol2,n4)); + + assert(!test.check(sol3,n1)); + assert(test.check(sol3,n2)); + assert(!test.check(sol3,n3)); + assert(!test.check(sol3,n4)); + + assert(!test.check(sol4,n1)); + assert(!test.check(sol4,n2)); + assert(!test.check(sol4,n3)); + assert(!test.check(sol4,n4)); test.init(sol1); - assert(!test.check(sol1,n)); - assert(!test.check(sol2,n)); - assert(!test.check(sol3,n)); - assert(!test.check(sol4,n)); + assert(!test.check(sol2,n1)); + assert(!test.check(sol3,n2)); - test.update(sol1,n); + test.update(sol1,n1); + test.add(sol1,n1); + test.add(sol2,n1); + assert(test.check(sol2,n1)); + test.add(sol4,n1); + assert(!test.check(sol2,n1)); + assert(test.check(sol2,n2)); std::cout << "[t-moSolVectorTabuList] => OK" << std::endl; diff --git a/branches/newMo/test/t-moTSExplorer.cpp b/branches/newMo/test/t-moTSExplorer.cpp new file mode 100644 index 000000000..30acd75be --- /dev/null +++ b/branches/newMo/test/t-moTSExplorer.cpp @@ -0,0 +1,163 @@ +/* + +Copyright (C) DOLPHIN Project-Team, INRIA Lille - Nord Europe, 2006-2010 + +Sébastien Verel, Arnaud Liefooghe, Jérémie Humeau + +This software is governed by the CeCILL license under French law and +abiding by the rules of distribution of free software. You can ue, +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". + +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 +*/ + +#include +#include +#include +#include +#include +#include "moTestClass.h" + +#include +#include +#include + +int main(){ + + std::cout << "[t-moTSExplorer] => START" << std::endl; + + eoBit sol(4, true); + sol.fitness(4); + bitNeighborhood nh(4); + bitNeighborhood emptyNH(0); + evalOneMax eval(4); + moNeighborComparator ncomp; + moSolNeighborComparator sncomp; + moDummyIntensification intens; + moDummyDiversification diver; + moSolVectorTabuList tabuList(4); + moBestImprAspiration aspir; + + moTSExplorer test(nh, eval, ncomp, sncomp, tabuList, intens, diver, aspir); + moTSExplorer test2(emptyNH, eval, ncomp, sncomp, tabuList, intens, diver, aspir); + + //test d'un voisinage vide + test2.initParam(sol); + test2(sol); + assert(!test2.accept(sol)); + + //test le comportement classique de la taboo + test.initParam(sol); + assert(aspir.getBest()==sol); + + test(sol); + test.updateParam(sol); + assert(aspir.getBest()==sol); + + //on ameliore et on stock une sol tabou 0111 + test(sol); + test.move(sol); + test.moveApplied(true); + test.updateParam(sol); + assert(aspir.getBest()==sol); + + //on ameliore et on stock une autre sol tabou 0011 + test(sol); + test.move(sol); + test.moveApplied(true); + test.updateParam(sol); + assert(aspir.getBest()==sol); + + //pareil on stock 0001 met pdt la recherche on se rend compte que 0111 est tabou + test(sol); + test.move(sol); + test.moveApplied(true); + test.updateParam(sol); + assert(aspir.getBest()==sol); + + //on modifie la sol en 1001(fitness 2) pour que la 1er sol exploré(0001) soit tabou + //De plus on change la solution mais elle est pas meilleure que la best so Far + sol[0]=true; + std::cout << sol << std::endl; + sol.fitness(2); + test(sol); + test.move(sol); + test.moveApplied(true); + test.updateParam(sol); + assert( sol[0] && !sol[1] && !sol[2] && !sol[3]); + sol[0]=false; + sol[3]=true; + assert(aspir.getBest()==sol); + + //test du isContinue + assert(test.isContinue(sol)); + + //test du terminate + test.initParam(sol); + sol[0]=true; + sol[1]=true; + sol[2]=true; + sol[3]=true; + sol.fitness(4); + test(sol); + test.move(sol); + test.moveApplied(true); + test.updateParam(sol); + assert( !sol[0] && sol[1] && sol[2] && sol[3]); + test.terminate(sol); + assert( !sol[0] && !sol[1] && !sol[2] && sol[3]); + + //test pour avoir que des mouvement taboo + eoBit sol2(2, true); + sol2.fitness(2); + bitNeighborhood nh2(2); + evalOneMax eval2(2); + + moTSExplorer test3(nh2, eval2, ncomp, sncomp, tabuList, intens, diver, aspir); + + test3.initParam(sol2); + test3(sol2); + test3.move(sol2); + test3.moveApplied(true); + test3.updateParam(sol2); + + test3(sol2); + test3.move(sol2); + test3.moveApplied(true); + test3.updateParam(sol2); + + test3(sol2); + test3.move(sol2); + test3.moveApplied(true); + test3.updateParam(sol2); + + test3(sol2); + test3.move(sol2); + test3.moveApplied(true); + test3.updateParam(sol2); + + test3(sol2); + assert(!test3.accept(sol2)); + + + std::cout << "[t-moTSExplorer] => OK" << std::endl; + + return EXIT_SUCCESS; +} +