eoVelocity.h

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

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

#ifndef EOVELOCITY_H
#define EOVELOCITY_H

//-----------------------------------------------------------------------------
#include <eoFunctor.h>
#include <utils/eoRNG.h>
#include <eoPop.h>
#include <utils/eoRealVectorBounds.h>
#include <eoParticleArchive.h>
//-----------------------------------------------------------------------------

template < class POT > class eoVelocity:public eoUF < POT &, void >
{
public:

    virtual void apply (eoPop < POT > &_pop)
    {
        for (unsigned i = 0; i < _pop.size (); i++)
        {
            operator  ()(_pop[i]);
        }

    }
};

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

public:

    eoStandardVelocity (eoSingleParticleArchive < POT > &_archive, eoRealVectorBounds & _bounds, const double _c1 = 0.5, const double _c2 = 0.9, eoRng & _gen = rng):c1 (_c1), c2 (_c2),bounds(_bounds), archive (_archive),gen(_gen){}

    eoStandardVelocity (eoSingleParticleArchive < POT > &_archive, const double _c1 = 0.5, const double _c2 = 0.9, eoRng & _gen = rng):c1 (_c1), c2 (_c2),bounds(eoDummyVectorNoBounds), archive (_archive),gen(_gen){}

    void operator  () (POT & _po)
    {
        double delta1;
        double delta2;
        double newVelocity;

        delta1 = rng.uniform (1) * c1;
        delta2 = rng.uniform (1) * c2;

        // set the standard velocities
        for (unsigned j = 0; j < _po.size (); j++)
        {
            newVelocity = _po.velocities[j] + delta1 * (_po.bestPositions[j] - _po[j]) +  delta2 * (archive.best ()[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;
        }
    }


protected:
    const double c1;
    const double c2;
    eoRealVectorBounds & bounds;
    eoRng & gen;
    eoParticleArchive < POT > &archive;
};



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

public:

    eoInertiaFixedWeightedVelocity (eoSingleParticleArchive < POT > &_archive,eoRealVectorBounds & _bounds, const double _weight=1,const double _c1 = 0.5, const double _c2 = 0.9, eoRng & _gen = rng):c1 (_c1), c2 (_c2),bounds(_bounds),weight(_weight), archive (_archive), gen(_gen){}


    eoInertiaFixedWeightedVelocity (eoSingleParticleArchive < POT > &_archive, const double _weight=1,const double _c1 = 0.5, const double _c2 = 0.9, eoRng & _gen = rng):c1 (_c1), c2 (_c2),weight(_weight),bounds(eoDummyVectorNoBounds),archive (_archive), gen(_gen){}


    void operator  () (POT & _po)
    {
        double delta1;
        double delta2;
        double newVelocity;

        delta1 = rng.uniform (1) * c1;
        delta2 = rng.uniform (1) * c2;

        for (unsigned j = 0; j < _po.size (); j++)
        {
            newVelocity = weight*_po.velocities[j] + delta1 * (_po.bestPositions[j] - _po[j]) +  delta2 * (archive.best ()[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;
        }
    }


protected:
    const double c1;
    const double c2;
    const double weight;
    eoRealVectorBounds & bounds;
    eoParticleArchive < POT > &archive;
    eoRng & gen;

};



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

public:

    eoVariableInertiaWeightedVelocity (eoSingleParticleArchive < POT > &_archive,eoRealVectorBounds & _bounds,eoValueParam<unsigned> &  _genCounter,const unsigned _maxGen,const double _c1 = 0.5, const double _c2 = 0.9, eoRng & _gen = rng):c1 (_c1), c2 (_c2),bounds(_bounds),genCounter(_genCounter), maxGen(_maxGen),archive (_archive), gen(_gen){}


    eoVariableInertiaWeightedVelocity (const double _c1,const double _c2,eoValueParam<unsigned> &  _genCounter,const unsigned _maxGen, eoSingleParticleArchive < POT > &_archive, eoRng & _gen = rng):c1 (_c1), c2 (_c2),genCounter(_genCounter), maxGen(_maxGen),archive (_archive), gen(_gen),bounds(eoDummyVectorNoBounds){}

    void operator  () (POT & _po)
    {
        double delta1;
        double delta2;
        double weight;
        double newVelocity;

        delta1 = rng.uniform (1) * c1;
        delta2 = rng.uniform (1) * c2;

        weight=(maxGen-genCounter.value())/maxGen;

        for (unsigned j = 0; j < _po.size (); j++)
        {
            newVelocity = weight*_po.velocities[j] + delta1 * (_po.bestPositions[j] - _po[j]) +  delta2 * (archive.best ()[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;
        }
    }


protected:
    const double c1;
    const double c2;    
    eoValueParam<unsigned>  & genCounter ;
    const unsigned maxGen ;     
    eoParticleArchive < POT > &archive;
    eoRng & gen;
    eoRealVectorBounds & bounds;
};


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

public:

    eoConstrictedVelocity (eoSingleParticleArchive < POT > &_archive,eoRealVectorBounds & _bounds, const double _K=1,const double _c1 = 0.5, const double _c2 = 0.9, eoRng & _gen = rng):c1 (_c1), c2 (_c2),K(_K), archive (_archive),
            gen
            (_gen)
    {
    }

    eoConstrictedVelocity (eoSingleParticleArchive < POT > &_archive,eoRealVectorBounds & _bounds, const double _K=1,const double _c1 = 0.5, const double _c2 = 0.9, eoRng & _gen = rng):c1 (_c1), c2 (_c2),K(_K), archive (_archive),bounds(eoDummyVectorNoBounds),gen(_gen)
    {
    }


    void operator  () (POT & _po)
    {
        double delta1;
        double delta2;
        double newVelocity;

        delta1 = rng.uniform (1) * c1;
        delta2 = rng.uniform (1) * c2;

        for (unsigned j = 0; j < _po.size (); j++)
        {
            newVelocity = K*(_po.velocities[j] + delta1 * (_po.bestPositions[j] - _po[j]) +  delta2 * (archive.best ()[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;
        }
    }


protected:

    const double c1;
    const double c2;
    const double K;
    eoRealVectorBounds & bounds;
    eoRng & gen;
    eoParticleArchive < POT > &archive;
};

#endif /*EOVELOCITY_H_H */

---