eoExtendedVelocity.h

// -*- 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 <eoFunctor.h>
#include <utils/eoRNG.h>
#include <eoPop.h>
#include <utils/eoRealVectorBounds.h>
#include <eoRealBoundModifier.h>
#include <eoTopology.h>
//-----------------------------------------------------------------------------


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;

    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){}


    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){}


    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)
    {}


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

    void updateNeighborhood(POT & _po,unsigned _indice)
    {
        topology.updateNeighborhood(_po,_indice);
    }


        eoTopology<POT> & 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 */