Test peo modified

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

trunk/paradiseo-peo/test/CMakeLists.txt

@@ -59,12 +59,23 @@ ENDIF(WIN32 AND NOT CYGWIN)
 ### 3) Define your targets and link the librairies
 ######################################################################################
 
-SET (TEST_LIST t-peo
-			    )
-			    
-SET (TEST_LIBRARY t-ParallelEval
+SET (TEST_LIST    t-ParallelEval
 				  t-ParallelTransform
 				  t-MultiStart
+				  t-PSOSelect
+				  t-EAAsyncIsland
+				  t-EASyncIsland
+				  t-PSOGlobalBest
+				  t-PSOWorstPosition
+			    )
+			    
+SET (TEST_LIBRARY t-ParallelEvalLib
+				  t-ParallelTransformLib
+				  t-MultiStartLib
+				  t-EAAsyncIslandLib
+				  t-EASyncIslandLib
+				  t-PSOGlobalBestLib
+				  t-PSOWorstPositionLib
 				)
 			    
 				

trunk/paradiseo-peo/test/t-EAAsyncIsland.cpp

@@ -0,0 +1,8 @@
+#include <peo.h>
+
+int main (int __argc, char *__argv[])
+{
+	system("mpdboot");
+	system("mpiexec -n 4 ./t-EAAsyncIslandLib @param ");
+	system("mpdallexit");
+}

trunk/paradiseo-peo/test/t-EAAsyncIslandLib.cpp

@@ -0,0 +1,77 @@
+//Test : Asynchronous island with EA
+#include <peo>
+#include <es.h>
+typedef eoReal<double> Indi;
+
+double f (const Indi & _indi)
+{
+  double sum=_indi[0]+_indi[1];
+  return (-sum);
+}
+int main (int __argc, char *__argv[])
+{
+  peo :: init( __argc, __argv );
+  if (getNodeRank()==1)
+  	std::cout<<"\n\nTest : Asynchronous island with EA\n\n";
+  rng.reseed (10);
+  RingTopology topology;
+  eoGenContinue < Indi > genContPara (10);
+  eoCombinedContinue <Indi> continuatorPara (genContPara);
+  eoCheckPoint<Indi> checkpoint(continuatorPara);
+  peoEvalFunc<Indi> mainEval( f );
+  peoPopEval <Indi> eval(mainEval);
+  eoUniformGenerator < double >uGen (-2., 2.);
+  eoInitFixedLength < Indi > random (2, uGen);
+  eoRankingSelect<Indi> selectionStrategy;
+  eoSelectNumber<Indi> select(selectionStrategy,10);
+  eoSegmentCrossover<Indi> crossover;
+  eoUniformMutation<Indi>  mutation(0.01);
+  peoTransform<Indi> transform(crossover,0.8,mutation,0.3);
+  peoPop < Indi > pop;
+  pop.append (10, random);
+  eoPlusReplacement<Indi> replace;
+  eoRandomSelect<Indi> mig_select_one;
+  eoSelector <Indi, peoPop<Indi> > mig_select (mig_select_one,2,pop);
+  eoReplace <Indi, peoPop<Indi> > mig_replace (replace,pop);
+  peoSyncIslandMig<Indi, peoPop<Indi> > mig(2,mig_select,mig_replace,topology,pop,pop);
+  checkpoint.add(mig);
+  eoEasyEA< Indi > eaAlg( checkpoint, eval, select, transform, replace );
+  peoWrapper parallelEA( eaAlg, pop);
+  eval.setOwner(parallelEA);
+  transform.setOwner(parallelEA);
+  mig.setOwner(parallelEA);
+  eoGenContinue < Indi > genContPara2 (10);
+  eoCombinedContinue <Indi> continuatorPara2 (genContPara2);
+  eoCheckPoint<Indi> checkpoint2(continuatorPara2);
+  peoEvalFunc<Indi> mainEval2( f );
+  peoPopEval <Indi> eval2(mainEval2);
+  eoUniformGenerator < double >uGen2 (-2., 2.);
+  eoInitFixedLength < Indi > random2 (2, uGen2);
+  eoRankingSelect<Indi> selectionStrategy2;
+  eoSelectNumber<Indi> select2(selectionStrategy2,10);
+  eoSegmentCrossover<Indi> crossover2;
+  eoUniformMutation<Indi>  mutation2(0.01);
+  peoTransform<Indi> transform2(crossover2,0.8,mutation2,0.3);
+  peoPop < Indi > pop2;
+  pop2.append (10, random2);
+  eoPlusReplacement<Indi> replace2;
+  eoRandomSelect<Indi> mig_select_one2;
+  eoSelector <Indi, peoPop<Indi> > mig_select2 (mig_select_one2,2,pop2);
+  eoReplace <Indi, peoPop<Indi> > mig_replace2 (replace2,pop2);
+  peoSyncIslandMig<Indi, peoPop<Indi> > mig2(2,mig_select2,mig_replace2,topology,pop2,pop2);
+  checkpoint2.add(mig2);
+  eoEasyEA< Indi > eaAlg2( checkpoint2, eval2, select2, transform2, replace2 );
+  peoWrapper parallelEA2( eaAlg2, pop2);
+  eval2.setOwner(parallelEA2);
+  transform2.setOwner(parallelEA2);
+  mig2.setOwner(parallelEA2);
+  peo :: run();
+  peo :: finalize();
+  if (getNodeRank()==1)
+    {
+      pop.sort();
+      pop2.sort();
+      std::cout << "Final population 1 :\n" << pop << std::endl;
+      std::cout << "Final population 2 :\n" << pop2 << std::endl;
+    }
+}

trunk/paradiseo-peo/test/t-EASyncIsland.cpp

@@ -0,0 +1,8 @@
+#include <peo.h>
+
+int main (int __argc, char *__argv[])
+{
+	system("mpdboot");
+	system("mpiexec -n 4 ./t-EASyncIslandLib @param ");
+	system("mpdallexit");
+}

trunk/paradiseo-peo/test/t-EASyncIslandLib.cpp

@@ -0,0 +1,81 @@
+//Test : Synchronous island with EA
+#include <peo>
+#include <es.h>
+typedef eoReal<double> Indi;
+
+double f (const Indi & _indi)
+{
+  double sum=_indi[0]+_indi[1];
+  return (-sum);
+}
+int main (int __argc, char *__argv[])
+{
+  peo :: init( __argc, __argv );
+  if (getNodeRank()==1)
+  	std::cout<<"\n\nTest : Synchronous island with EA\n\n";
+  rng.reseed (10);
+  RingTopology topology;
+  eoGenContinue < Indi > genContPara (10);
+  eoCombinedContinue <Indi> continuatorPara (genContPara);
+  eoCheckPoint<Indi> checkpoint(continuatorPara);
+  peoEvalFunc<Indi> mainEval( f );
+  peoPopEval <Indi> eval(mainEval);
+  eoUniformGenerator < double >uGen (-2., 2.);
+  eoInitFixedLength < Indi > random (2, uGen);
+  eoRankingSelect<Indi> selectionStrategy;
+  eoSelectNumber<Indi> select(selectionStrategy,10);
+  eoSegmentCrossover<Indi> crossover;
+  eoUniformMutation<Indi>  mutation(0.01);
+  peoTransform<Indi> transform(crossover,0.8,mutation,0.3);
+  peoPop < Indi > pop;
+  pop.append (10, random);
+  eoPlusReplacement<Indi> replace;
+  eoRandomSelect<Indi> mig_select_one;
+  eoSelector <Indi, peoPop<Indi> > mig_select (mig_select_one,2,pop);
+  eoReplace <Indi, peoPop<Indi> > mig_replace (replace,pop);
+  eoPeriodicContinue< Indi > mig_cont( 2 );
+  eoContinuator<Indi> cont(mig_cont, pop);
+  peoAsyncIslandMig<Indi, peoPop<Indi> > mig(cont,mig_select,mig_replace,topology,pop,pop);
+  checkpoint.add(mig);
+  eoEasyEA< Indi > eaAlg( checkpoint, eval, select, transform, replace );
+  peoWrapper parallelEA( eaAlg, pop);
+  eval.setOwner(parallelEA);
+  transform.setOwner(parallelEA);
+  mig.setOwner(parallelEA);
+  eoGenContinue < Indi > genContPara2 (10);
+  eoCombinedContinue <Indi> continuatorPara2 (genContPara2);
+  eoCheckPoint<Indi> checkpoint2(continuatorPara2);
+  peoEvalFunc<Indi> mainEval2( f );
+  peoPopEval <Indi> eval2(mainEval2);
+  eoUniformGenerator < double >uGen2 (-2., 2.);
+  eoInitFixedLength < Indi > random2 (2, uGen2);
+  eoRankingSelect<Indi> selectionStrategy2;
+  eoSelectNumber<Indi> select2(selectionStrategy2,10);
+  eoSegmentCrossover<Indi> crossover2;
+  eoUniformMutation<Indi>  mutation2(0.01);
+  peoTransform<Indi> transform2(crossover2,0.8,mutation2,0.3);
+  peoPop < Indi > pop2;
+  pop2.append (10, random2);
+  eoPlusReplacement<Indi> replace2;
+  eoRandomSelect<Indi> mig_select_one2;
+  eoSelector <Indi, peoPop<Indi> > mig_select2 (mig_select_one2,2,pop2);
+  eoReplace <Indi, peoPop<Indi> > mig_replace2 (replace2,pop2);
+  eoPeriodicContinue< Indi > mig_cont2( 2 );
+  eoContinuator<Indi> cont2(mig_cont2, pop2);
+  peoAsyncIslandMig<Indi, peoPop<Indi> > mig2(cont2,mig_select2,mig_replace2,topology,pop2,pop2);
+  checkpoint2.add(mig2);
+  eoEasyEA< Indi > eaAlg2( checkpoint2, eval2, select2, transform2, replace2 );
+  peoWrapper parallelEA2( eaAlg2, pop2);
+  eval2.setOwner(parallelEA2);
+  transform2.setOwner(parallelEA2);
+  mig2.setOwner(parallelEA2);
+  peo :: run();
+  peo :: finalize();
+  if (getNodeRank()==1)
+    {
+      pop.sort();
+      pop2.sort();
+      std::cout << "Final population 1 :\n" << pop << std::endl;
+      std::cout << "Final population 2 :\n" << pop2 << std::endl;
+    }
+}

trunk/paradiseo-peo/test/t-MultiStart.cpp

@@ -1,40 +1,8 @@
-// Test : multistart
+#include <peo.h>
 
-#include <peo>
-
-struct Algorithm 
+int main (int __argc, char *__argv[])
 {
-	void operator()(double & _d) 
-	{
-		_d = _d * _d;	
-	}
-};
-
-int main (int __argc, char * * __argv)
-{
-
-  peo :: init (__argc, __argv);
-  if (getNodeRank()==1)
-  	std::cout<<"\n\nTest : multistart\n\n";
-  std::vector < double > v;
-  if (getNodeRank()==1)
-  	std::cout<<"\n\nBefore :";
-  for(unsigned i = 0; i< 10; i++)
-  {
-  	v.push_back(i);
- 	if (getNodeRank()==1)
-  		std::cout<<"\n"<<v[i];
-  }
-  Algorithm algo;
-  peoMultiStart < double > initParallel (algo);
-  peoWrapper parallelAlgo (initParallel, v);
-  initParallel.setOwner(parallelAlgo);
-  peo :: run( );
-  peo :: finalize( );
-  if (getNodeRank()==1)
-  {
-  	std::cout<<"\n\nAfter :\n";
-  	for(unsigned i = 0; i< 10; i++)
-		std::cout<<v[i]<<"\n";
-  }
+	system("mpdboot");
+	system("mpiexec -n 4 ./t-MultiStartLib @param ");
+	system("mpdallexit");
 }

trunk/paradiseo-peo/test/t-MultiStartLib.cpp

@@ -0,0 +1,40 @@
+// Test : multistart
+
+#include <peo>
+
+struct Algorithm 
+{
+	void operator()(double & _d) 
+	{
+		_d = _d * _d;	
+	}
+};
+
+int main (int __argc, char * * __argv)
+{
+
+  peo :: init (__argc, __argv);
+  if (getNodeRank()==1)
+  	std::cout<<"\n\nTest : multistart\n\n";
+  std::vector < double > v;
+  if (getNodeRank()==1)
+  	std::cout<<"\n\nBefore :";
+  for(unsigned i = 0; i< 10; i++)
+  {
+  	v.push_back(i);
+ 	if (getNodeRank()==1)
+  		std::cout<<"\n"<<v[i];
+  }
+  Algorithm algo;
+  peoMultiStart < double > initParallel (algo);
+  peoWrapper parallelAlgo (initParallel, v);
+  initParallel.setOwner(parallelAlgo);
+  peo :: run( );
+  peo :: finalize( );
+  if (getNodeRank()==1)
+  {
+  	std::cout<<"\n\nAfter :\n";
+  	for(unsigned i = 0; i< 10; i++)
+		std::cout<<v[i]<<"\n";
+  }
+}

trunk/paradiseo-peo/test/t-PSOGlobalBest.cpp

@@ -0,0 +1,8 @@
+#include <peo.h>
+
+int main (int __argc, char *__argv[])
+{
+	system("mpdboot");
+	system("mpiexec -n 4 ./t-PSOGlobalBestLib @param ");
+	system("mpdallexit");
+}

trunk/paradiseo-peo/test/t-PSOGlobalBestLib.cpp

@@ -0,0 +1,85 @@
+// Test : PSO Global Best
+#include <peo>
+typedef eoRealParticle < double >Indi;
+double f (const Indi & _indi)
+{
+  double sum=_indi[0]+_indi[1];
+  return (sum);
+}
+int main (int __argc, char *__argv[])
+{
+  peo :: init( __argc, __argv );
+  if (getNodeRank()==1)
+  	std::cout<<"\n\nTest : PSO Global Best\n\n";
+  rng.reseed (10);
+  RingTopology topologyMig;
+  eoGenContinue < Indi > genContPara (10);
+  eoCombinedContinue <Indi> continuatorPara (genContPara);
+  eoCheckPoint<Indi> checkpoint(continuatorPara);
+  peoEvalFunc<Indi, double, const Indi& > plainEval(f);
+  peoPopEval< Indi > eval(plainEval);
+  eoUniformGenerator < double >uGen (0, 1.);
+  eoInitFixedLength < Indi > random (2, uGen);
+  eoUniformGenerator < double >sGen (-1., 1.);
+  eoVelocityInitFixedLength < Indi > veloRandom (2, sGen);
+  eoFirstIsBestInit < Indi > localInit;
+  eoRealVectorBounds bndsFlight(2,0,1.);
+  eoStandardFlight < Indi > flight(bndsFlight);
+  peoPop < Indi > pop;
+  pop.append (10, random);
+  eoLinearTopology<Indi> topology(2);
+  eoRealVectorBounds bnds(2,-1.,1.);
+  eoStandardVelocity < Indi > velocity (topology,1,0.5,2.,bnds);
+  eoInitializer <Indi> init(eval,veloRandom,localInit,topology,pop);
+  eoPeriodicContinue< Indi > mig_cont( 2 );
+  peoPSOSelect<Indi> mig_selec(topology);
+  peoGlobalBestVelocity<Indi> mig_replac (2.,velocity);
+  eoContinuator<Indi> cont(mig_cont, pop);
+  eoSelector <Indi, peoPop<Indi> > mig_select (mig_selec,1,pop);
+  eoReplace <Indi, peoPop<Indi> > mig_replace (mig_replac,pop);
+  eoGenContinue < Indi > genContPara2 (10);
+  eoCombinedContinue <Indi> continuatorPara2 (genContPara2);
+  eoCheckPoint<Indi> checkpoint2(continuatorPara2);
+  peoEvalFunc<Indi, double, const Indi& > plainEval2(f);
+  peoPopEval< Indi > eval2(plainEval2);
+  eoUniformGenerator < double >uGen2 (0, 1.);
+  eoInitFixedLength < Indi > random2 (2, uGen2);
+  eoUniformGenerator < double >sGen2 (-1., 1.);
+  eoVelocityInitFixedLength < Indi > veloRandom2 (2, sGen2);
+  eoFirstIsBestInit < Indi > localInit2;
+  eoRealVectorBounds bndsFlight2(2,0,1.);
+  eoStandardFlight < Indi > flight2(bndsFlight2);
+  peoPop < Indi > pop2;
+  pop2.append (10, random2);
+  eoLinearTopology<Indi> topology2(2);
+  eoRealVectorBounds bnds2(2,-1.,1.);
+  eoStandardVelocity < Indi > velocity2 (topology2,1,0.5,2.,bnds2);
+  eoInitializer <Indi> init2(eval2,veloRandom2,localInit2,topology2,pop2);
+  eoPeriodicContinue< Indi > mig_cont2( 2 );
+  peoPSOSelect<Indi> mig_selec2(topology2);
+  peoGlobalBestVelocity<Indi> mig_replac2 (2.,velocity2);
+  eoContinuator<Indi> cont2(mig_cont2,pop2);
+  eoSelector <Indi, peoPop<Indi> > mig_select2 (mig_selec2,1,pop2);
+  eoReplace <Indi, peoPop<Indi> > mig_replace2 (mig_replac2,pop2);
+  peoAsyncIslandMig< Indi, peoPop<Indi> > mig(cont,mig_select, mig_replace, topologyMig, pop, pop);
+  checkpoint.add( mig );
+  peoAsyncIslandMig< Indi, peoPop<Indi> > mig2(cont2,mig_select2, mig_replace2, topologyMig, pop2, pop2);
+  checkpoint2.add( mig2 );
+  eoSyncEasyPSO <Indi> psa(init,checkpoint,eval, velocity, flight);
+  peoWrapper parallelPSO( psa, pop);
+  eval.setOwner(parallelPSO);
+  mig.setOwner(parallelPSO);
+  eoSyncEasyPSO <Indi> psa2(init2,checkpoint2,eval2, velocity2, flight2);
+  peoWrapper parallelPSO2( psa2, pop2);
+  eval2.setOwner(parallelPSO2);
+  mig2.setOwner(parallelPSO2);
+  peo :: run();
+  peo :: finalize();
+  if (getNodeRank()==1)
+    {
+      pop.sort();
+      pop2.sort();
+      std::cout << "Final population :\n" << pop << std::endl;
+      std::cout << "Final population :\n" << pop2	 << std::endl;
+    }
+}

trunk/paradiseo-peo/test/t-PSOSelect.cpp

@@ -0,0 +1,34 @@
+//Test : PSO select
+#include <peo>
+typedef eoRealParticle < double >Indi;
+double f (const Indi & _indi)
+{
+  double sum=_indi[0]+_indi[1];
+  return (-sum);
+}
+
+int main (int __argc, char *__argv[])
+{
+  std::cout<<"\n\nTest : PSO select\n\n";
+  rng.reseed (10);
+  peoEvalFunc<Indi, double, const Indi& > plainEval(f);
+  eoEvalFuncCounter < Indi > firstEval(plainEval);
+  eoPopLoopEval < Indi > eval(firstEval);
+  eoUniformGenerator < double >uGen (1, 2);
+  eoInitFixedLength < Indi > random (2, uGen);
+  eoUniformGenerator < double >sGen (-1, 1);
+  eoVelocityInitFixedLength < Indi > veloRandom (2, sGen);
+  eoFirstIsBestInit < Indi > localInit;
+  eoRealVectorBounds bndsFlight(2,1,2);
+  eoStandardFlight < Indi > flight(bndsFlight);
+  eoLinearTopology<Indi> topology(6);
+  eoRealVectorBounds bnds(2,-1,1);
+  eoStandardVelocity < Indi > velocity (topology,1,0.5,2.,bnds);
+  eoPop < Indi > empty_pop,pop(20, random);
+  eoInitializer <Indi> init(eval,veloRandom,localInit,topology,pop);
+  init();
+  eval (empty_pop,pop);
+  peoPSOSelect<Indi> mig_selec(topology);
+  pop.sort();
+  std::cout<<"\nBest : "<<pop[0]<<"    =     "<<mig_selec(pop)<<"\n\n";
+}

trunk/paradiseo-peo/test/t-PSOWorstPosition.cpp

@@ -0,0 +1,8 @@
+#include <peo.h>
+
+int main (int __argc, char *__argv[])
+{
+	system("mpdboot");
+	system("mpiexec -n 4 ./t-PSOWorstPositionLib @param ");
+	system("mpdallexit");
+}

trunk/paradiseo-peo/test/t-PSOWorstPositionLib.cpp

@@ -0,0 +1,85 @@
+// Test : PSO Worst Position
+#include <peo>
+typedef eoRealParticle < double >Indi;
+double f (const Indi & _indi)
+{
+  double sum=_indi[0]+_indi[1];
+  return (sum);
+}
+int main (int __argc, char *__argv[])
+{
+  peo :: init( __argc, __argv );
+  if (getNodeRank()==1)
+  	std::cout<<"\n\nTest : PSO Worst Position\n\n";
+  rng.reseed (10);
+  RingTopology topologyMig;
+  eoGenContinue < Indi > genContPara (10);
+  eoCombinedContinue <Indi> continuatorPara (genContPara);
+  eoCheckPoint<Indi> checkpoint(continuatorPara);
+  peoEvalFunc<Indi, double, const Indi& > plainEval(f);
+  peoPopEval< Indi > eval(plainEval);
+  eoUniformGenerator < double >uGen (0, 1.);
+  eoInitFixedLength < Indi > random (2, uGen);
+  eoUniformGenerator < double >sGen (-1., 1.);
+  eoVelocityInitFixedLength < Indi > veloRandom (2, sGen);
+  eoFirstIsBestInit < Indi > localInit;
+  eoRealVectorBounds bndsFlight(2,0,1.);
+  eoStandardFlight < Indi > flight(bndsFlight);
+  peoPop < Indi > pop;
+  pop.append (10, random);
+  eoLinearTopology<Indi> topology(2);
+  eoRealVectorBounds bnds(2,-1.,1.);
+  eoStandardVelocity < Indi > velocity (topology,1,0.5,2.,bnds);
+  eoInitializer <Indi> init(eval,veloRandom,localInit,topology,pop);
+  eoPeriodicContinue< Indi > mig_cont( 2 );
+  peoPSOSelect<Indi> mig_selec(topology);
+  peoWorstPositionReplacement<Indi> mig_replac;
+  eoContinuator<Indi> cont(mig_cont, pop);
+  eoSelector <Indi, peoPop<Indi> > mig_select (mig_selec,1,pop);
+  eoReplace <Indi, peoPop<Indi> > mig_replace (mig_replac,pop);
+  eoGenContinue < Indi > genContPara2 (10);
+  eoCombinedContinue <Indi> continuatorPara2 (genContPara2);
+  eoCheckPoint<Indi> checkpoint2(continuatorPara2);
+  peoEvalFunc<Indi, double, const Indi& > plainEval2(f);
+  peoPopEval< Indi > eval2(plainEval2);
+  eoUniformGenerator < double >uGen2 (0, 1.);
+  eoInitFixedLength < Indi > random2 (2, uGen2);
+  eoUniformGenerator < double >sGen2 (-1., 1.);
+  eoVelocityInitFixedLength < Indi > veloRandom2 (2, sGen2);
+  eoFirstIsBestInit < Indi > localInit2;
+  eoRealVectorBounds bndsFlight2(2,0,1.);
+  eoStandardFlight < Indi > flight2(bndsFlight2);
+  peoPop < Indi > pop2;
+  pop2.append (10, random2);
+  eoLinearTopology<Indi> topology2(2);
+  eoRealVectorBounds bnds2(2,-1.,1.);
+  eoStandardVelocity < Indi > velocity2 (topology2,1,0.5,2.,bnds2);
+  eoInitializer <Indi> init2(eval2,veloRandom2,localInit2,topology2,pop2);
+  eoPeriodicContinue< Indi > mig_cont2( 2 );
+  peoPSOSelect<Indi> mig_selec2(topology2);
+  peoWorstPositionReplacement<Indi> mig_replac2;
+  eoContinuator<Indi> cont2(mig_cont2,pop2);
+  eoSelector <Indi, peoPop<Indi> > mig_select2 (mig_selec2,1,pop2);
+  eoReplace <Indi, peoPop<Indi> > mig_replace2 (mig_replac2,pop2);
+  peoAsyncIslandMig< Indi, peoPop<Indi> > mig(cont,mig_select, mig_replace, topologyMig, pop, pop);
+  checkpoint.add( mig );
+  peoAsyncIslandMig< Indi, peoPop<Indi> > mig2(cont2,mig_select2, mig_replace2, topologyMig, pop2, pop2);
+  checkpoint2.add( mig2 );
+  eoSyncEasyPSO <Indi> psa(init,checkpoint,eval, velocity, flight);
+  peoWrapper parallelPSO( psa, pop);
+  eval.setOwner(parallelPSO);
+  mig.setOwner(parallelPSO);
+  eoSyncEasyPSO <Indi> psa2(init2,checkpoint2,eval2, velocity2, flight2);
+  peoWrapper parallelPSO2( psa2, pop2);
+  eval2.setOwner(parallelPSO2);
+  mig2.setOwner(parallelPSO2);
+  peo :: run();
+  peo :: finalize();
+  if (getNodeRank()==1)
+    {
+      pop.sort();
+      pop2.sort();
+      std::cout << "Final population :\n" << pop << std::endl;
+      std::cout << "Final population :\n" << pop2	 << std::endl;
+    }
+}

trunk/paradiseo-peo/test/t-ParallelEval.cpp

@@ -1,42 +1,8 @@
-// Test : parallel evaluation
-#include <peo>
-#include <es.h>
-typedef eoReal<double> Indi;
-double f (const Indi & _indi)
-{
-  double sum=_indi[0]+_indi[1];
-  return (-sum);
-}
-struct Algorithm 
-{
-	Algorithm( peoPopEval < Indi > & _eval): eval( _eval ){}
-	void operator()(eoPop < Indi > & _pop) 
-	{
-		eoPop < Indi > empty_pop;
-        eval(empty_pop, _pop);	
-	}
-	peoPopEval < Indi > & eval;
-};
+#include <peo.h>
 
 int main (int __argc, char *__argv[])
 {
-  peo :: init( __argc, __argv );
-  if (getNodeRank()==1)
-  	std::cout<<"\n\nTest : parallel evaluation\n\n";
-  rng.reseed (10);
-  peoEvalFunc<Indi, double, const Indi& > plainEval(f);
-  peoPopEval< Indi > eval(plainEval);
-  eoUniformGenerator < double >uGen (0, 1);
-  eoInitFixedLength < Indi > random (2, uGen);
-  eoPop < Indi > pop(20, random);
-  Algorithm algo ( eval );
-  peoWrapper parallelAlgo( algo, pop);
-  eval.setOwner(parallelAlgo);
-  peo :: run();
-  peo :: finalize();
-  if (getNodeRank()==1)
-  {
-      pop.sort();
-      std::cout<<pop;
-  }
+	system("mpdboot");
+	system("mpiexec -n 4 ./t-ParallelEvalLib @param ");
+	system("mpdallexit");
 }

trunk/paradiseo-peo/test/t-ParallelEvalLib.cpp

@@ -0,0 +1,42 @@
+// Test : parallel evaluation
+#include <peo>
+#include <es.h>
+typedef eoReal<double> Indi;
+double f (const Indi & _indi)
+{
+  double sum=_indi[0]+_indi[1];
+  return (-sum);
+}
+struct Algorithm 
+{
+	Algorithm( peoPopEval < Indi > & _eval): eval( _eval ){}
+	void operator()(eoPop < Indi > & _pop) 
+	{
+		eoPop < Indi > empty_pop;
+        eval(empty_pop, _pop);	
+	}
+	peoPopEval < Indi > & eval;
+};
+
+int main (int __argc, char *__argv[])
+{
+  peo :: init( __argc, __argv );
+  if (getNodeRank()==1)
+  	std::cout<<"\n\nTest : parallel evaluation\n\n";
+  rng.reseed (10);
+  peoEvalFunc<Indi, double, const Indi& > plainEval(f);
+  peoPopEval< Indi > eval(plainEval);
+  eoUniformGenerator < double >uGen (0, 1);
+  eoInitFixedLength < Indi > random (2, uGen);
+  eoPop < Indi > pop(20, random);
+  Algorithm algo ( eval );
+  peoWrapper parallelAlgo( algo, pop);
+  eval.setOwner(parallelAlgo);
+  peo :: run();
+  peo :: finalize();
+  if (getNodeRank()==1)
+  {
+      pop.sort();
+      std::cout<<pop;
+  }
+}

trunk/paradiseo-peo/test/t-ParallelTransform.cpp

@@ -1,55 +1,8 @@
-// Test : parallel transform
-#include <peo>
-#include <es.h>
-typedef eoReal<double> Indi;
-double f (const Indi & _indi)
-{
-  double sum=_indi[0]+_indi[1];
-  return (-sum);
-}
-struct Algorithm 
-{
-	Algorithm( eoEvalFunc < Indi > & _eval, eoSelect < Indi > & _select, peoTransform < Indi > & _transform): 
-		loopEval(_eval),
-        eval(loopEval),
-		selectTransform( _select, _transform),
-		breed(selectTransform) {}
-		
-	void operator()(eoPop < Indi > & _pop) 
-	{
-		eoPop < Indi > offspring, empty_pop;
-        eval(empty_pop, _pop);
-        eval(empty_pop, offspring);
-        std::cout<<"\n\nBefore :\n"<<offspring;
-        breed(_pop, offspring);
-        eval(empty_pop, offspring);
-        std::cout<<"\n\nAfter :\n"<<offspring;
-	}
-	eoPopLoopEval < Indi > loopEval;
-    eoPopEvalFunc < Indi > & eval;
-	eoSelectTransform < Indi > selectTransform;
-    eoBreed < Indi > & breed;
-};
+#include <peo.h>
 
 int main (int __argc, char *__argv[])
 {
-  peo :: init( __argc, __argv );
-  if (getNodeRank()==1)
-  	std::cout<<"\n\nTest : parallel transform\n\n";
-  rng.reseed (10);
-  eoEvalFuncPtr < Indi > plainEval(f);
-  eoEvalFuncCounter < Indi > eval(plainEval);
-  eoUniformGenerator < double >uGen (0, 1);
-  eoInitFixedLength < Indi > random (2, uGen);
-  eoPop < Indi > empty_pop,pop(6, random);
-  eoRankingSelect < Indi > selectionStrategy;
-  eoSelectNumber < Indi > select(selectionStrategy,6);
-  eoSegmentCrossover < Indi > crossover;
-  eoUniformMutation < Indi >  mutation(0.01);
-  peoTransform<Indi> transform(crossover,0.8,mutation,0.3);
-  Algorithm algo ( eval, select, transform );
-  peoWrapper parallelAlgo( algo, pop);
-  transform.setOwner(parallelAlgo);
-  peo :: run();
-  peo :: finalize();
+	system("mpdboot");
+	system("mpiexec -n 4 ./t-ParallelTransformLib @param ");
+	system("mpdallexit");
 }

trunk/paradiseo-peo/test/t-ParallelTransformLib.cpp

@@ -0,0 +1,55 @@
+// Test : parallel transform
+#include <peo>
+#include <es.h>
+typedef eoReal<double> Indi;
+double f (const Indi & _indi)
+{
+  double sum=_indi[0]+_indi[1];
+  return (-sum);
+}
+struct Algorithm 
+{
+	Algorithm( eoEvalFunc < Indi > & _eval, eoSelect < Indi > & _select, peoTransform < Indi > & _transform): 
+		loopEval(_eval),
+        eval(loopEval),
+		selectTransform( _select, _transform),
+		breed(selectTransform) {}
+		
+	void operator()(eoPop < Indi > & _pop) 
+	{
+		eoPop < Indi > offspring, empty_pop;
+        eval(empty_pop, _pop);
+        eval(empty_pop, offspring);
+        std::cout<<"\n\nBefore :\n"<<offspring;
+        breed(_pop, offspring);
+        eval(empty_pop, offspring);
+        std::cout<<"\n\nAfter :\n"<<offspring;
+	}
+	eoPopLoopEval < Indi > loopEval;
+    eoPopEvalFunc < Indi > & eval;
+	eoSelectTransform < Indi > selectTransform;
+    eoBreed < Indi > & breed;
+};
+
+int main (int __argc, char *__argv[])
+{
+  peo :: init( __argc, __argv );
+  if (getNodeRank()==1)
+  	std::cout<<"\n\nTest : parallel transform\n\n";
+  rng.reseed (10);
+  eoEvalFuncPtr < Indi > plainEval(f);
+  eoEvalFuncCounter < Indi > eval(plainEval);
+  eoUniformGenerator < double >uGen (0, 1);
+  eoInitFixedLength < Indi > random (2, uGen);
+  eoPop < Indi > empty_pop,pop(6, random);
+  eoRankingSelect < Indi > selectionStrategy;
+  eoSelectNumber < Indi > select(selectionStrategy,6);
+  eoSegmentCrossover < Indi > crossover;
+  eoUniformMutation < Indi >  mutation(0.01);
+  peoTransform<Indi> transform(crossover,0.8,mutation,0.3);
+  Algorithm algo ( eval, select, transform );
+  peoWrapper parallelAlgo( algo, pop);
+  transform.setOwner(parallelAlgo);
+  peo :: run();
+  peo :: finalize();
+}

trunk/paradiseo-peo/test/t-peo.cpp

@@ -1,10 +0,0 @@
-#include <peo.h>
-
-int main (int __argc, char *__argv[])
-{
-	system("mpdboot");
-	system("mpiexec -n 4 ./t-ParallelEval @param ");
-	system("mpiexec -n 4 ./t-ParallelTransform @param ");
-	system("mpiexec -n 4 ./t-MultiStart @param ");
-	system("mpdallexit");
-}