eoConstrictedVariableWeightVelocity.h

// -*- mode: c++; c-indent-level: 4; c++-member-init-indent: 8; comment-column: 35; -*-

//-----------------------------------------------------------------------------
// eoConstrictedVariableWeightVelocity.h
// (c) OPAC 2007
/*
    Contact: paradiseo-help@lists.gforge.inria.fr
 */
//-----------------------------------------------------------------------------

#ifndef EOCONSTRICTEDVARIABLEWEIGHTVELOCITY_H
#define EOCONSTRICTEDVARIABLEWEIGHTVELOCITY_H

//-----------------------------------------------------------------------------
#include <eoVelocity.h>
#include <eoTopology.h>
#include <eoWeightUpdater.h>
#include <utils/eoRealVectorBounds.h>
#include <eoRealBoundModifier.h>
//-----------------------------------------------------------------------------



template < class POT > class eoConstrictedVariableWeightVelocity:public eoVelocity < POT >
{

public:

    /*
     * Each element for the velocity evaluation is expected to be of type VelocityType.
     */
    typedef typename POT::ParticleVelocityType VelocityType;

    eoConstrictedVariableWeightVelocity (eoTopology < POT > & _topology,
                                         const VelocityType & _coeff,
                                         eoWeightUpdater<VelocityType> & _weightUpdater,
                                         const VelocityType & _c1,
                                         const VelocityType & _c2 ,
                                         eoRealVectorBounds & _bounds,
                                         eoRealBoundModifier & _bndsModifier,
                                         eoRng & _gen = rng):
            topology(_topology),
            coeff(_coeff),
            weightUpdater(_weightUpdater),
            c1 (_c1),
            c2 (_c2),
            bounds(_bounds),
            bndsModifier(_bndsModifier),
            gen(_gen){}


    eoConstrictedVariableWeightVelocity (eoTopology < POT > & _topology,
                                         const VelocityType & _coeff,
                                         eoWeightUpdater<VelocityType> & _weightUpdater,
                                         const VelocityType & _c1,
                                         const VelocityType & _c2,
                                         eoRealVectorBounds & _bounds,
                                         eoRng & _gen = rng):
            topology(_topology),
            coeff(_coeff),
            weightUpdater(_weightUpdater),
            c1 (_c1),
            c2 (_c2),
            bounds(_bounds),
            bndsModifier(dummyModifier),
            gen(_gen){}


    eoConstrictedVariableWeightVelocity (eoTopology < POT > & _topology,
                                         const VelocityType & _coeff,
                                         eoWeightUpdater<VelocityType> & _weightUpdater,
                                         const VelocityType & _c1,
                                         const VelocityType & _c2,
                                         eoRng & _gen = rng):
            topology(_topology),
            coeff(_coeff),
            weightUpdater(_weightUpdater),
            c1 (_c1),
            c2 (_c2),
            bounds(*(new eoRealVectorNoBounds(0))),
            bndsModifier(dummyModifier),
            gen(_gen)
    {}

    void operator  () (POT & _po,unsigned _indice)
    {
        VelocityType r1;
        VelocityType r2;

        VelocityType newVelocity;

        // cast the learning factors to VelocityType
        r1 = (VelocityType) rng.uniform (1) * c1;
        r2 = (VelocityType) rng.uniform (1) * c2;

        // need to resize the bounds even if there are dummy because of "isBounded" call
        bounds.adjust_size(_po.size());

        // update the inertia weight
        weightUpdater(weight);

        // assign the new velocities
        for (unsigned j = 0; j < _po.size (); j++)
        {
            newVelocity= coeff * (weight * _po.velocities[j] + r1 * (_po.bestPositions[j] - _po[j]) +  r2 * (topology.best (_indice)[j] - _po[j]));

            /* modify the bounds */
            bndsModifier(bounds,j);

            /* check bounds */
            if (bounds.isMinBounded(j))
                newVelocity=(VelocityType)std::max(newVelocity,bounds.minimum(j));
            if (bounds.isMaxBounded(j))
                newVelocity=(VelocityType)std::min(newVelocity,bounds.maximum(j));

            _po.velocities[j]=newVelocity;
        }
    }

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



protected:
    eoTopology < POT > & topology;
    
    const VelocityType & coeff;   // the fixed constriction coefficient
    eoWeightUpdater<VelocityType> & weightUpdater;      // the updater used to make the weight evoluate
 
    const VelocityType & c1;    // learning factor 1
    const VelocityType  & c2;    // learning factor 2
   
    eoRealVectorBounds & bounds; // REAL bounds even if the velocity could be of another type.
    eoRealBoundModifier & bndsModifier;
    
    VelocityType weight;
    eoRng & gen;        // the random generator
 
    // If the bound modifier doesn't need to be used, use the dummy instance
    eoDummyRealBoundModifier dummyModifier;
};

#endif /*EOCONSTRICTEDVARIABLEWEIGHTVELOCITY_H*/

---