tests added

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

branches/newMo/src/algo/moLocalSearch.h

@@ -94,7 +94,6 @@ public:
       
       continuator.lastCall(_solution);
       
-      //A CHANGER
       return true;
     };
 

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<Neighbor> & diversification;
 	moAspiration<Neighbor> & aspiration;
 
+	//Current and best neighbor
 	Neighbor* best;
     Neighbor* current;
 
+    //Best so far Solution
+    EOT bestSoFar;
+
     // true if the move is accepted
     bool isAccept ;
 

branches/newMo/src/memory/moAspiration.h

@@ -1,6 +1,8 @@
 #ifndef _moAspiration_h
 #define _moAspiration_h
 
+#include <eoFunctor.h>
+
 /**
  * Abstract class for Aspiration Criteria
  */

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:

branches/newMo/src/memory/moSolVectorTabuList.h

@@ -3,6 +3,7 @@
 
 #include <memory/moTabuList.h>
 #include <vector>
+#include <iostream>
 
 /**
  * Tabu List of solution stocked in a vector
@@ -36,8 +37,7 @@ 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{
@@ -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<tabuList.size(); i++){
-			if (tabuList[i] == _sol)
+			if (tabuList[i] == tmp)
 				return true;
 		}
 		return false;

branches/newMo/test/CMakeLists.txt

@@ -48,6 +48,8 @@ SET (TEST_LIST
 		t-moSolutionStat
 		t-moCheckpoint
 		t-moDummyMemory
+		t-moSolVectorTabuList
+		t-moBestImprAspiration
 		t-moSimpleHCexplorer
 		t-moSimpleHCneutralExplorer
 		t-moHCneutralExplorer
@@ -55,8 +57,7 @@ SET (TEST_LIST
 		t-moRandomWalkExplorer
 		t-moMetropolisHastingExplorer
 		t-moRandomNeutralWalkExplorer
-		t-moSolVectorTabuList
+		t-moTSExplorer
-		
 		)
 				
 FOREACH (test ${TEST_LIST})

branches/newMo/test/t-moBestImprAspiration.cpp

@@ -0,0 +1,76 @@
+/*
+<t-moBestImprAspiration.cpp>
+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 <memory/moBestImprAspiration.h>
+#include "moTestClass.h"
+
+#include <iostream>
+#include <cstdlib>
+#include <cassert>
+
+int main(){
+
+	std::cout << "[t-moBestImprAspiration] => START" << std::endl;
+
+	moBestImprAspiration<bitNeighbor> test;
+	eoBit<eoMinimizingFitness> sol1(4);
+	eoBit<eoMinimizingFitness> sol2(4);
+	eoBit<eoMinimizingFitness> sol3(4);
+	eoBit<eoMinimizingFitness> 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;
+}
+

branches/newMo/test/t-moSolVectorTabuList.cpp

@@ -38,39 +38,55 @@ int main(){
 
 	std::cout << "[t-moSolVectorTabuList] => START" << std::endl;
 
-	moSolVectorTabuList<bitNeighbor> test(3);
+	moSolVectorTabuList<bitNeighbor> test(2);
-	bitNeighbor n;
+	bitNeighbor n1;
+	bitNeighbor n2;
+	bitNeighbor n3;
+	bitNeighbor n4;
+	n1.index(0);
+	n2.index(1);
+	n3.index(2);
+	n4.index(3);
 
-	eoBit<eoMinimizingFitness> sol1(4);
+	eoBit<eoMinimizingFitness> sol1(4, true);
-	eoBit<eoMinimizingFitness> sol2(4);
+	eoBit<eoMinimizingFitness> sol2(4, true);
-	eoBit<eoMinimizingFitness> sol3(4);
+	eoBit<eoMinimizingFitness> sol3(4, true);
-	eoBit<eoMinimizingFitness> sol4(4);
+	eoBit<eoMinimizingFitness> sol4(4, true);
 
-	sol2[0]=true;
+	sol2[0]=false;
-	sol3[1]=true;
+	sol3[1]=false;
-	sol4[2]=true;
+	sol4[0]=false;
+	sol4[1]=false;
 
 	test.init(sol1);
-	test.add(sol1,n);
+	test.add(sol1,n1);
-	test.add(sol2,n);
+	assert(test.check(sol2,n1));
-	test.add(sol3,n);
+	assert(!test.check(sol2,n2));
-	assert(test.check(sol1,n));
+	assert(!test.check(sol2,n3));
-	assert(test.check(sol2,n));
+	assert(!test.check(sol2,n4));
-	assert(test.check(sol3,n));
+
-	test.add(sol4,n);
+	assert(!test.check(sol3,n1));
-	assert(!test.check(sol1,n));
+	assert(test.check(sol3,n2));
-	assert(test.check(sol2,n));
+	assert(!test.check(sol3,n3));
-	assert(test.check(sol3,n));
+	assert(!test.check(sol3,n4));
-	assert(test.check(sol4,n));
+
+	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,n1));
-	assert(!test.check(sol2,n));
+	assert(!test.check(sol3,n2));
-	assert(!test.check(sol3,n));
-	assert(!test.check(sol4,n));
 
-	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;
 

branches/newMo/test/t-moTSExplorer.cpp

@@ -0,0 +1,163 @@
+/*
+<t-moTSExplorer.cpp>
+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 <memory/moSolVectorTabuList.h>
+#include <memory/moDummyIntensification.h>
+#include <memory/moDummyDiversification.h>
+#include <memory/moBestImprAspiration.h>
+#include <explorer/moTSExplorer.h>
+#include "moTestClass.h"
+
+#include <iostream>
+#include <cstdlib>
+#include <cassert>
+
+int main(){
+
+	std::cout << "[t-moTSExplorer] => START" << std::endl;
+
+	eoBit<eoMinimizingFitness> sol(4, true);
+	sol.fitness(4);
+	bitNeighborhood nh(4);
+	bitNeighborhood emptyNH(0);
+	evalOneMax eval(4);
+	moNeighborComparator<bitNeighbor> ncomp;
+	moSolNeighborComparator<bitNeighbor> sncomp;
+	moDummyIntensification<bitNeighbor> intens;
+	moDummyDiversification<bitNeighbor> diver;
+	moSolVectorTabuList<bitNeighbor> tabuList(4);
+	moBestImprAspiration<bitNeighbor> aspir;
+
+	moTSExplorer<bitNeighborhood> test(nh, eval, ncomp, sncomp, tabuList, intens, diver, aspir);
+	moTSExplorer<bitNeighborhood> 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<eoMinimizingFitness> sol2(2, true);
+	sol2.fitness(2);
+	bitNeighborhood nh2(2);
+	evalOneMax eval2(2);
+
+	moTSExplorer<bitNeighborhood> 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;
+}
+