From a93ed43907db7426d72318bdca73f0096a606eed Mon Sep 17 00:00:00 2001 From: tlegrand Date: Fri, 18 Apr 2008 08:59:02 +0000 Subject: [PATCH] added eoExtendedvelocity (+doc + test) that takes both the local best and the global of a PSO topology into account. Also updated the doc tags for the other topologies and velocities --- eo/src/eoExtendedVelocity.h | 208 ++++++++++++++++++++++++++++++++++++ 1 file changed, 208 insertions(+) create mode 100644 eo/src/eoExtendedVelocity.h diff --git a/eo/src/eoExtendedVelocity.h b/eo/src/eoExtendedVelocity.h new file mode 100644 index 00000000..1a39c2ce --- /dev/null +++ b/eo/src/eoExtendedVelocity.h @@ -0,0 +1,208 @@ +// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*- + +//----------------------------------------------------------------------------- +// eoExtendedVelocity.h +// (c) INRIA Dolphin 2008 +/* + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + Contact: thomas.legrand@inria.fr + */ +//----------------------------------------------------------------------------- + +#ifndef eoExtendedVelocity_H +#define eoExtendedVelocity_H + +//----------------------------------------------------------------------------- +#include +#include +#include +#include +#include +#include +//----------------------------------------------------------------------------- + + +/** Extended velocity performer for particle swarm optimization. Derivated from abstract eoVelocity, +* At step t: v(t+1)= w * v(t) + c1 * r1 * ( xbest(t)-x(t) ) + c2 * r2 * ( lbest(t) - x(t) ) + c3 * r3 * ( gbest(t) - x(t) ) +* It includes both a "topology" best and a global best in the social knowledge. Each topology +* provides a method to retrieve the global best <=> the best of all the neighborhood the topology contains. +*/ +template < class POT > class eoExtendedVelocity:public eoVelocity < POT > +{ + +public: + + /* + * Each element for the velocity evaluation is expected to be of type VelocityType. + */ + typedef typename POT::ParticleVelocityType VelocityType; + + /** Full constructor: Bounds and bound modifier required + * @param _topology - The topology + * @param _w - The weight factor. + * @param _c1 - Learning factor used for the particle's best. Type must be POT::ParticleVelocityType + * @param _c2 - Learning factor used for the local best + * @param _c3 - Learning factor used for the global best + * @param _bounds - An eoRealBaseVectorBounds: real bounds for real velocities. + * If the velocities are not real, they won't be bounded by default. Should have a eoBounds ? + * @param _boundsModifier - An eoRealBoundModifier used to modify the bounds (for real bounds only). + * @param _gen - The eo random generator, default=rng + */ + eoExtendedVelocity (eoTopology < POT > & _topology, + const VelocityType & _w, + const VelocityType & _c1, + const VelocityType & _c2, + const VelocityType & _c3, + eoRealVectorBounds & _bounds, + eoRealBoundModifier & _bndsModifier, + eoRng & _gen = rng): + topology(_topology), + omega (_w), + c1 (_c1), + c2 (_c2), + c3 (_c3), + bounds(_bounds), + bndsModifier(_bndsModifier), + gen(_gen){} + + + /** Constructor: No bound updater required <-> fixed bounds + * @param _topology - The topology + * @param _w - The weight factor. + * @param _c1 - The second learning factor used for the particle's best. Type must be POT::ParticleVelocityType + * @param _c2 - The third learning factor used for the local best. Type must be POT::ParticleVelocityType + * @param _c3 - Learning factor used for the global best + * @param _bounds - An eoRealBaseVectorBounds: real bounds for real velocities. + * If the velocities are not real, they won't be bounded by default. Should have a eoBounds ? + * @param _gen - The eo random generator, default=rng + */ + eoExtendedVelocity (eoTopology < POT > & _topology, + const VelocityType & _w, + const VelocityType & _c1, + const VelocityType & _c2, + const VelocityType & _c3, + eoRealVectorBounds & _bounds, + eoRng & _gen = rng): + topology(_topology), + omega (_w), + c1 (_c1), + c2 (_c2), + c3 (_c3), + bounds(_bounds), + bndsModifier(dummyModifier), + gen(_gen){} + + + /** Constructor: Neither bounds nor bound updater required <-> free velocity + * @param _topology - The topology + * @param _w - The weight factor. + * @param _c1 - The second learning factor used for the particle's best. Type must be POT::ParticleVelocityType + * @param _c2 - The third learning factor used for the local best. Type must be POT::ParticleVelocityType + * @param _c3 - Learning factor used for the global best + * @param _gen - The eo random generator, default=rng + */ + eoExtendedVelocity (eoTopology < POT > & _topology, + const VelocityType & _w, + const VelocityType & _c1, + const VelocityType & _c2, + const VelocityType & _c3, + eoRng & _gen = rng): + topology(_topology), + omega (_w), + c1 (_c1), + c2 (_c2), + c3 (_c3), + bounds(*(new eoRealVectorNoBounds(0))), + bndsModifier(dummyModifier), + gen(_gen) + {} + + + /** + * Evaluate the new velocities of the given particle. Need an indice to identify the particle + * into the topology. + * @param _po - A particle + * @param _indice - The indice (into the topology) of the given particle + */ + void operator () (POT & _po,unsigned _indice) + { + VelocityType r1; + VelocityType r2; + VelocityType r3; + + VelocityType newVelocity; + + // cast the learning factors to VelocityType + r1 = (VelocityType) rng.uniform (1) * c1; + r2 = (VelocityType) rng.uniform (1) * c2; + r3 = (VelocityType) rng.uniform (1) * c3; + + // need to resize the bounds even if there are dummy because of "isBounded" call + bounds.adjust_size(_po.size()); + + // assign the new velocities + for (unsigned j = 0; j < _po.size (); j++) + { + newVelocity= omega * _po.velocities[j] + + r1 * (_po.bestPositions[j] - _po[j]) + + r2 * (topology.best (_indice)[j] - _po[j]) + + r3 * (topology.globalBest()[j] - _po[j]); + + /* check bounds */ + if (bounds.isMinBounded(j)) + newVelocity=std::max(newVelocity,bounds.minimum(j)); + if (bounds.isMaxBounded(j)) + newVelocity=std::min(newVelocity,bounds.maximum(j)); + + _po.velocities[j]=newVelocity; + } + } + + /** + * Update the neighborhood. + */ + void updateNeighborhood(POT & _po,unsigned _indice) + { + topology.updateNeighborhood(_po,_indice); + } + + //! eoTopology getTopology + //! @return topology + + eoTopology & getTopology () + { + return topology; + } + +protected: + eoTopology < POT > & topology; + const VelocityType & omega; // social/cognitive coefficient + const VelocityType & c1; + const VelocityType & c2; // social/cognitive coefficient + const VelocityType & c3; // social/cognitive coefficient + + eoRealVectorBounds bounds; // REAL bounds even if the velocity could be of another type. + eoRealBoundModifier & bndsModifier; + + eoRng & gen; // the random generator + + // If the bound modifier doesn't need to be used, use the dummy instance + eoDummyRealBoundModifier dummyModifier; +}; + + +#endif /*eoExtendedVelocity_H */ +