FirstRealPSO.cpp

//--------------------------------------------------------------------------------
//      FirstRealPSO.cpp
//--------------------------------------------------------------------------------

#include <stdexcept>
#include <iostream>
#include <sstream>

#include <eo>
#include <es.h>
#include <eoScalarFitness.h>
#include <utils/eoRealVectorBounds.h>
#include <es/eoRealParticle.h>

// Use functions from namespace std
using namespace std;

// REPRESENTATION
//-----------------------------------------------------------------------------
// define your particles
typedef eoRealParticle < eoMinimizingFitness >Indi;


// EVAL
//-----------------------------------------------------------------------------
// a simple fitness function that computes the euclidian norm of a real vector
//    @param _indi A real-valued individual
double real_value (const Indi & _indi)
{
  double sum = 0;
  for (unsigned i = 0; i < _indi.size ()-1; i++)
    sum += pow(_indi[i],2);
  return (sum);
}

// GENERAL
//-----------------------------------------------------------------------------
void main_function (int __argc, char *__argv[])
{
// PARAMETRES
  // all parameters are hard-coded!
  const unsigned int VEC_SIZE = 5;      // Number of object variables in genotypes
  const unsigned int POP_SIZE = 30;     // Size of population
  const unsigned int MAX_GEN = 100;             // Maximum number of generations
  
  const double C1 = 1.3;                // Velocity learning factor 1
  const double C2 = 2;          // Velocity learning factor 2
  const double POS_MIN = -2.0;  // Minimum value for the position
  const double POS_MAX = 2.0;   // Maximum value for the position
  const double VELO_MIN = -2;   // Minimum value for the velocity
  const double VELO_MAX = 2;    // Maximum value for the velocity
  const double WEIGHT = 0.7;    // Maximum value for the velocity
  
// SEED
  // Initialize the seed with the current date.
  rng.reseed (time(0));


// EVAL
  // Fitness function
  // Evaluation: from a plain C++ fn to an EvalFunc Object
  eoEvalFuncPtr<Indi, double, const Indi& > eval(  real_value );


// POPULATION (swarm)
  eoPop < Indi > pop;

// PARTICLE ARCHIVE
  // The global best is stored in an archive
  eoSingleParticleArchive < Indi > archive; 


// INITIALIZE THE POPULATION

  // Initialize the positions
  eoUniformGenerator < double >uGen (POS_MIN, POS_MAX); 
  eoInitFixedLength < Indi > random (VEC_SIZE, uGen);
  pop.append (POP_SIZE, random);  

  // Initialize the velocities
  eoUniformGenerator < double >sGen (VELO_MIN, VELO_MAX);
  eoVelocityInitFixedLength < Indi > speedRandom (VEC_SIZE, sGen);
  apply < Indi > (speedRandom, pop);

  // FIRST EVAL REQUIRED 
  // We must have a first fitness to compute the first "bests"
  apply < Indi > (eval, pop);
  
  // Initialize the particle's best
  eoFirstIsBestInit < Indi > localInit;
  apply < Indi > (localInit, pop);

  // Initialize the global best
  eoBestOfAllInit < Indi > globalInit (archive); // initialize the global besr
  psoApply < Indi > (globalInit, pop); // apply the initialization



// OUTPUT
  // sort pop before printing it!
  pop.sort();
  // Print (sorted) intial population (raw printout)
  cout << "Initial Population" << endl;
  cout << pop;
  
  
// VELOCITY
  eoInertiaFixedWeightedVelocity < Indi > velocity (archive,WEIGHT,C1, C2);
  eoRealVectorBounds bnds(VEC_SIZE,VELO_MIN,VELO_MAX);

// FLIGHT
  eoStandardFlight < Indi > flight(bnds);


// PARTICLE BEST UPDATER
  eoUpdateIfBetter < Indi > updater;


// GLOBAL BEST UPDATER
  eoUpdateGlobalIfBetter < Indi > globalUpdater (archive);


  // STOP
// CHECKPOINT
  // termination condition
  // stop after MAX_GEN generations
  eoGenContinue<Indi> continuator(MAX_GEN);
  

// GENERATION
  // the algorithm
  // standard PSO requires
  // evaluation, velocity, particle best updater, global best updater and flight, stopping criterion
  
  eoEasyPSO < Indi > psa (continuator, eval, velocity, flight, updater, globalUpdater);
 
 
  // Apply algo to pop - that's it!
  psa(pop);

// OUTPUT
  // Print (sorted) final population
  pop.sort();
  cout << "FINAL Population\n" << pop << endl;
// GENERAL
}


// A main that catches the exceptions

int main(int argc, char **argv)
{
    try
    {
        main_function(argc, argv);
    }
    catch(exception& e)
    {
        cout << "Exception: " << e.what() << '\n';
    }

    return 1;
}

---