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

added initial files coming from the trunk (r=920) for the branch 2.0

Browse source 
git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@921 331e1502-861f-0410-8da2-ba01fb791d7f
This commit is contained in:
legrand 2008-02-01 13:38:51 +00:00
commit d912c44a58
1301 changed files with 145456 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

131
branches/paradiseo-ix86-2.0/paradiseo-peo/test/CMakeLists.txt Normal file
View file

@ -0,0 +1,131 @@
###############################################################################
##
## CMakeLists file for ParadisEO-PEO/test
##
###############################################################################
######################################################################################
### 1) Include the sources
######################################################################################
INCLUDE_DIRECTORIES(${EO_SRC_DIR}/src)
INCLUDE_DIRECTORIES(${MO_SRC_DIR}/src)
INCLUDE_DIRECTORIES(${MOEO_SRC_DIR}/src)
INCLUDE_DIRECTORIES(${ParadisEO-PEO_SOURCE_DIR}/src)
INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
INCLUDE(CheckLibraryExists)
SET (CMAKE_CXX_COMPILER mpicxx)
ADD_CUSTOM_TARGET(install ALL DEPENDS ${ParadisEO-PEO_SOURCE_DIR}/test/param ${ParadisEO-PEO_SOURCE_DIR}/test/schema.xml)
ADD_CUSTOM_COMMAND(
TARGET install
PRE_BUILD
COMMAND ${CMAKE_COMMAND}
ARGS -E copy_if_different
${ParadisEO-PEO_SOURCE_DIR}/test/param
${ParadisEO-PEO_BINARY_DIR}/test)
ADD_CUSTOM_COMMAND(
TARGET install
PRE_BUILD
COMMAND ${CMAKE_COMMAND}
ARGS -E copy_if_different
${ParadisEO-PEO_SOURCE_DIR}/test/schema.xml
${ParadisEO-PEO_BINARY_DIR}/test)
######################################################################################
######################################################################################
### 2) Specify where CMake can find the libraries
######################################################################################
IF(NOT WIN32 OR CYGWIN)
LINK_DIRECTORIES(${EO_BIN_DIR}/lib ${ParadisEO-PEO_BINARY_DIR}/lib )
ENDIF(NOT WIN32 OR CYGWIN)
# especially for Visual Studio
IF(WIN32 AND NOT CYGWIN)
LINK_DIRECTORIES(${EO_BIN_DIR}\\lib\\${CMAKE_BUILD_TYPE}
${ParadisEO-PEO_BINARY_DIR}\\lib\\${CMAKE_BUILD_TYPE})
ENDIF(WIN32 AND NOT CYGWIN)
######################################################################################
######################################################################################
### 3) Define your targets and link the librairies
######################################################################################
SET (TEST_RUN t-Mpdboot)
SET (TEST_LIST t-ParallelEval
t-ParallelTransform
t-MultiStart
t-PSOSelect
t-EAAsyncIsland
t-EASyncIsland
t-PSOGlobalBest
t-PSOWorstPosition
t-Mpdallexit)
SET (TEST_STOP t-Mpdallexit)
FOREACH (test ${TEST_LIST} ${TEST_RUN} ${TEST_STOP})
SET ("T_${test}_SOURCES" "${test}.cpp")
ENDFOREACH (test)
IF(ENABLE_CMAKE_TESTING)
# Add the tests
FOREACH (test ${TEST_LIST} ${TEST_RUN} ${TEST_STOP})
ADD_EXECUTABLE(${test} ${T_${test}_SOURCES})
ENDFOREACH (test)
FOREACH (test ${TEST_RUN})
ADD_TEST(${test} ${test})
ENDFOREACH (test)
FOREACH (test ${TEST_LIST})
ADD_TEST(${test} "mpiexec" "-n" "4" "${CMAKE_CURRENT_BINARY_DIR}/${test}" "@param")
ENDFOREACH (test)
FOREACH (test ${TEST_STOP})
ADD_TEST(${test} ${test})
ENDFOREACH (test)
# Link the librairies
FOREACH (test ${TEST_LIST})
TARGET_LINK_LIBRARIES(${test} peo ${XML2_LIBS} rmc_mpi ga es eoutils eo)
ENDFOREACH (test)
ENDIF(ENABLE_CMAKE_TESTING)
######################################################################################
######################################################################################
### 5) Windows advanced config - especially for Microsoft Visual Studio 8
######################################################################################
IF(CMAKE_CXX_COMPILER MATCHES cl)
IF(NOT WITH_SHARED_LIBS)
IF(CMAKE_GENERATOR STREQUAL "Visual Studio 8 2005")
SET(CMAKE_CXX_FLAGS "/nologo /W3 /Gy")
SET(CMAKE_CXX_FLAGS_DEBUG "/MTd /Z7 /Od")
SET(CMAKE_CXX_FLAGS_RELEASE "/MT /O2")
SET(CMAKE_CXX_FLAGS_MINSIZEREL "/MT /O2")
SET(CMAKE_CXX_FLAGS_RELWITHDEBINFO "/MTd /Z7 /Od")
SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /SUBSYSTEM:CONSOLE")
ENDIF(CMAKE_GENERATOR STREQUAL "Visual Studio 8 2005")
ENDIF(NOT WITH_SHARED_LIBS)
ENDIF(CMAKE_CXX_COMPILER MATCHES cl)
######################################################################################

12
branches/paradiseo-ix86-2.0/paradiseo-peo/test/param Normal file
View file

@ -0,0 +1,12 @@
## miscallenous parameters
--debug=false
## deployment schema
--schema=schema.xml
## parameters
--inst=../examples/tsp/benchs/eil101.tsp

19
branches/paradiseo-ix86-2.0/paradiseo-peo/test/schema.xml Normal file
View file

@ -0,0 +1,19 @@
<?xml version="1.0"?>
<schema>
<group scheduler="0">
<node name="0" num_workers="0">
</node>
<node name="1" num_workers="0">
<runner>1</runner>
<runner>2</runner>
</node>
<node name="2" num_workers="1">
</node>
<node name="3" num_workers="1">
</node>
</group>
</schema>

77
branches/paradiseo-ix86-2.0/paradiseo-peo/test/t-EAAsyncIsland.cpp Normal file
View file

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

81
branches/paradiseo-ix86-2.0/paradiseo-peo/test/t-EASyncIsland.cpp Normal file
View file

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

6
branches/paradiseo-ix86-2.0/paradiseo-peo/test/t-Mpdallexit.cpp Normal file
View file

@ -0,0 +1,6 @@
#include <peo.h>
int main (int __argc, char *__argv[])
{
system("mpdallexit");
}

6
branches/paradiseo-ix86-2.0/paradiseo-peo/test/t-Mpdboot.cpp Normal file
View file

@ -0,0 +1,6 @@
#include <peo.h>
int main (int __argc, char *__argv[])
{
system("mpdboot");
}

40
branches/paradiseo-ix86-2.0/paradiseo-peo/test/t-MultiStart.cpp Normal file
View file

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

85
branches/paradiseo-ix86-2.0/paradiseo-peo/test/t-PSOGlobalBest.cpp Normal file
View file

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

34
branches/paradiseo-ix86-2.0/paradiseo-peo/test/t-PSOSelect.cpp Normal file
View file

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

85
branches/paradiseo-ix86-2.0/paradiseo-peo/test/t-PSOWorstPosition.cpp Normal file
View file

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

42
branches/paradiseo-ix86-2.0/paradiseo-peo/test/t-ParallelEval.cpp Normal file
View file

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

55
branches/paradiseo-ix86-2.0/paradiseo-peo/test/t-ParallelTransform.cpp Normal file
View file

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