From ef252cf7de046c5d47b0ede07f12b3d46fe055e4 Mon Sep 17 00:00:00 2001 From: tlegrand Date: Tue, 8 Jan 2008 15:13:32 +0000 Subject: [PATCH] corrected PSO dummy errors and completed documentation --- eo/src/eoEasyPSO.h | 20 ++++-- eo/src/eoInitializer.h | 82 +++++++++++------------- eo/src/eoSyncEasyPSO.h | 139 +++++++++++++++++++++-------------------- 3 files changed, 124 insertions(+), 117 deletions(-) diff --git a/eo/src/eoEasyPSO.h b/eo/src/eoEasyPSO.h index 931194c1..a6805491 100644 --- a/eo/src/eoEasyPSO.h +++ b/eo/src/eoEasyPSO.h @@ -47,6 +47,7 @@ template < class POT > class eoEasyPSO:public eoPSO < POT > public: /** Full constructor + * @param _init - An eoInitializer that initializes the topology, velocity, best particle(s) * @param _continuator - An eoContinue that manages the stopping criterion and the checkpointing system * @param _eval - An eoEvalFunc: the evaluation performer * @param _velocity - An eoVelocity that defines how to compute the velocities @@ -54,37 +55,44 @@ public: * to modify the positions according to the velocities */ eoEasyPSO ( + eoInitializer &_init, eoContinue < POT > &_continuator, eoEvalFunc < POT > &_eval, eoVelocity < POT > &_velocity, eoFlight < POT > &_flight): + init(_init), continuator (_continuator), eval (_eval), velocity (_velocity), - flight (_flight){} + flight (_flight) + {} /** Constructor without eoFlight. For special cases when the flight is performed withing the velocity. + * @param _init - An eoInitializer that initializes the topology, velocity, best particle(s) * @param _continuator - An eoContinue that manages the stopping criterion and the checkpointing system * @param _eval - An eoEvalFunc: the evaluation performer * @param _velocity - An eoVelocity that defines how to compute the velocities */ eoEasyPSO ( + eoInitializer &_init, eoContinue < POT > &_continuator, eoEvalFunc < POT > &_eval, eoVelocity < POT > &_velocity): + init(_init), continuator (_continuator), eval (_eval), velocity (_velocity), - flight (dummyFlight){} - - + flight (dummyFlight) + {} /// Apply a few iteration of flight to the population (=swarm). virtual void operator () (eoPop < POT > &_pop) { try { + // initializes the topology, velocity, best particle(s) + init(); do { // loop over all the particles for the current iteration @@ -103,7 +111,8 @@ public: velocity.updateNeighborhood(_pop[idx],idx); } - }while (continuator (_pop)); + } + while (continuator (_pop)); } catch (std::exception & e) @@ -116,6 +125,7 @@ public: } private: + eoInitializer &init; eoContinue < POT > &continuator; eoEvalFunc < POT > &eval; eoVelocity < POT > &velocity; diff --git a/eo/src/eoInitializer.h b/eo/src/eoInitializer.h index f0c905de..70315536 100644 --- a/eo/src/eoInitializer.h +++ b/eo/src/eoInitializer.h @@ -38,15 +38,15 @@ * Abstract class for initialization of algorithm PSO */ template class eoInitializerBase : public eoFunctorBase - { - public : +{ +public : virtual ~eoInitializerBase() {} virtual void operator()() {}; - }; +}; /** Base (name) class for Initialization of algorithm PSO @@ -54,8 +54,8 @@ template class eoInitializerBase : public eoFunctorBase @see eoInitializerBase eoUF apply */ template class eoInitializer : public eoInitializerBase - { - public: +{ +public: //! Constructor //! @param _proc Evaluation function @@ -63,18 +63,13 @@ template class eoInitializer : public eoInitializerBase //! @param _initBest Initialization of the best //! @param _pop Population eoInitializer( - eoUF& _proc, - eoVelocityInit < POT > &_initVelo, - eoParticleBestInit &_initBest, - eoTopology &_topology, - eoPop < POT > &_pop + eoUF& _proc, + eoVelocityInit < POT > &_initVelo, + eoParticleBestInit &_initBest, + eoTopology &_topology, + eoPop < POT > &_pop ) : proc(_proc), procPara(dummyEval), initVelo(_initVelo), initBest(_initBest), topology(_topology), pop(_pop) - { - /* apply(proc, _pop); - apply < POT > (initVelo, _pop); - apply < POT > (initBest, _pop); - topology.setup(_pop);*/ - } + {} //! Constructor for parallel evaluation //! @param _proc Evaluation function @@ -82,11 +77,11 @@ template class eoInitializer : public eoInitializerBase //! @param _initBest Initialization of the best //! @param _pop Population eoInitializer( - eoPopEvalFunc & _proc, - eoVelocityInit < POT > &_initVelo, - eoParticleBestInit &_initBest, - eoTopology &_topology, - eoPop < POT > &_pop + eoPopEvalFunc & _proc, + eoVelocityInit < POT > &_initVelo, + eoParticleBestInit &_initBest, + eoTopology &_topology, + eoPop < POT > &_pop ) : proc(dummy), procPara(_proc), initVelo(_initVelo), initBest(_initBest), topology(_topology), pop(_pop) {} @@ -94,29 +89,28 @@ template class eoInitializer : public eoInitializerBase //! Give the name of the class //! @return The name of the class virtual std::string className (void) const - { - return "eoInitializer"; - } - - - - virtual void operator () (/*eoPop < POT > &_pop*/) { - eoPop empty_pop; - apply(proc, pop); - procPara(empty_pop, pop); - apply < POT > (initVelo, pop); - apply < POT > (initBest, pop); - topology.setup(pop); + return "eoInitializer"; } - private : + + + virtual void operator() () + { + eoPop empty_pop; + apply(proc, pop); + procPara(empty_pop, pop); + apply < POT > (initVelo, pop); + apply < POT > (initBest, pop); + topology.setup(pop); + } + +private : /* @param proc First evaluation @param initVelo Initialization of the velocity - @param initBest Initialization of the best - + @param initBest Initialization of the best */ eoPop < POT > & pop; eoUF& proc; @@ -124,22 +118,22 @@ template class eoInitializer : public eoInitializerBase eoVelocityInit < POT > & initVelo; eoParticleBestInit & initBest; eoTopology & topology; - class eoDummyEval : public eoPopEvalFunc +class eoDummyEval : public eoPopEvalFunc { - public: + public: void operator()(eoPop &,eoPop &_pop) {} } dummyEval; - class eoDummy : public eoUF +class eoDummy : public eoUF { - public: + public: void operator()(POT &) {} - + } - dummy; - }; + dummy; +}; #endif diff --git a/eo/src/eoSyncEasyPSO.h b/eo/src/eoSyncEasyPSO.h index c474fdf9..ef2338b3 100644 --- a/eo/src/eoSyncEasyPSO.h +++ b/eo/src/eoSyncEasyPSO.h @@ -44,10 +44,11 @@ * -- update the neighborhoods */ template < class POT > class eoSyncEasyPSO:public eoPSO < POT > - { - public: +{ +public: /** Full constructor + * @param _init - An eoInitializer that initializes the topology, velocity, best particle(s) * @param _continuator - An eoContinue that manages the stopping criterion and the checkpointing system * @param _eval - An eoEvalFunc: the evaluation performer * @param _velocity - An eoVelocity that defines how to compute the velocities @@ -55,102 +56,104 @@ template < class POT > class eoSyncEasyPSO:public eoPSO < POT > * to modify the positions according to the velocities */ eoSyncEasyPSO ( - eoInitializer &_init, - eoContinue < POT > &_continuator, - eoEvalFunc < POT > &_eval, - eoVelocity < POT > &_velocity, - eoFlight < POT > &_flight): - init(_init), - continuator (_continuator), - eval (_eval), - loopEval(_eval), - popEval(loopEval), - velocity (_velocity), - flight (_flight) + eoInitializer &_init, + eoContinue < POT > &_continuator, + eoEvalFunc < POT > &_eval, + eoVelocity < POT > &_velocity, + eoFlight < POT > &_flight): + init(_init), + continuator (_continuator), + eval (_eval), + loopEval(_eval), + popEval(loopEval), + velocity (_velocity), + flight (_flight) {} /** Constructor without eoFlight. For special cases when the flight is performed withing the velocity. + * @param _init - An eoInitializer that initializes the topology, velocity, best particle(s) * @param _continuator - An eoContinue that manages the stopping criterion and the checkpointing system * @param _eval - An eoEvalFunc: the evaluation performer * @param _velocity - An eoVelocity that defines how to compute the velocities */ eoSyncEasyPSO ( - eoInitializer &_init, - eoContinue < POT > &_continuator, - eoEvalFunc < POT > &_eval, - eoVelocity < POT > &_velocity): - init(_init), - continuator (_continuator), - eval (_eval), - loopEval(_eval), - popEval(loopEval), - velocity (_velocity), - flight (dummyFlight) - {} - + eoInitializer &_init, + eoContinue < POT > &_continuator, + eoEvalFunc < POT > &_eval, + eoVelocity < POT > &_velocity): + init(_init), + continuator (_continuator), + eval (_eval), + loopEval(_eval), + popEval(loopEval), + velocity (_velocity), + flight (dummyFlight) + {} + /** Full constructor - Can be used in parallel + * @param _init - An eoInitializer that initializes the topology, velocity, best particle(s) * @param _continuator - An eoContinue that manages the stopping criterion and the checkpointing system * @param _eval - An eoPopEvalFunc * @param _velocity - An eoVelocity that defines how to compute the velocities * @param _flight - An eoFlight */ eoSyncEasyPSO ( - eoInitializer &_init, - eoContinue < POT > &_continuator, - eoPopEvalFunc < POT > &_eval, - eoVelocity < POT > &_velocity, - eoFlight &_flight): - init(_init), - continuator (_continuator), - eval (dummyEval), - loopEval(dummyEval), - popEval(_eval), - velocity (_velocity), - flight (_flight) - {} + eoInitializer &_init, + eoContinue < POT > &_continuator, + eoPopEvalFunc < POT > &_eval, + eoVelocity < POT > &_velocity, + eoFlight &_flight): + init(_init), + continuator (_continuator), + eval (dummyEval), + loopEval(dummyEval), + popEval(_eval), + velocity (_velocity), + flight (_flight) + {} /// Apply a few iteration of flight to the population (=swarm). virtual void operator () (eoPop < POT > &_pop) { - try + try { - init(); - // just to use a loop eval - eoPop empty_pop; + // initializes the topology, velocity, best particle(s) + init(); + // just to use a loop eval + eoPop empty_pop; - do + do { + // perform velocity evaluation + velocity.apply (_pop); - // perform velocity evaluation - velocity.apply (_pop); + // apply the flight + flight.apply (_pop); - // apply the flight - flight.apply (_pop); + // evaluate the position (with a loop eval, empty_swarm IS USELESS) + popEval(empty_pop,_pop); - // evaluate the position (with a loop eval, empty_swarm IS USELESS) - popEval(empty_pop,_pop); - - // update the topology (particle and local/global best(s)) - velocity.updateNeighborhood(_pop); + // update the topology (particle and local/global best(s)) + velocity.updateNeighborhood(_pop); } - while (continuator (_pop)); + while (continuator (_pop)); } - catch (std::exception & e) + catch (std::exception & e) { - std::string s = e.what (); - s.append (" in eoSyncEasyPSO"); - throw std::runtime_error (s); + std::string s = e.what (); + s.append (" in eoSyncEasyPSO"); + throw std::runtime_error (s); } } - private: - +private: + eoInitializer &init; eoContinue < POT > &continuator; @@ -163,17 +166,17 @@ template < class POT > class eoSyncEasyPSO:public eoPSO < POT > // if the flight does not need to be used, use the dummy flight instance eoDummyFlight dummyFlight; - + // if the eval does not need to be used, use the dummy eval instance - class eoDummyEval : public eoEvalFunc - { - public: +class eoDummyEval : public eoEvalFunc + { + public: void operator()(POT &) {} - } + } dummyEval; - - }; + +}; #endif /*_EOSYNCEASYPSO_H*/