moeoIteratedIBMOLS.h

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

//-----------------------------------------------------------------------------
// moeoIteratedIBMOLS.h
// (c) OPAC Team (LIFL), Dolphin Project (INRIA), 2007
/*
    This library...

    Contact: paradiseo-help@lists.gforge.inria.fr, http://paradiseo.gforge.inria.fr
 */
//-----------------------------------------------------------------------------

#ifndef MOEOITERATEDIBMOLS_H_
#define MOEOITERATEDIBMOLS_H_

#include <eoContinue.h>
#include <eoEvalFunc.h>
#include <eoOp.h>
#include <eoPop.h>
#include <utils/rnd_generators.h>
#include <moMove.h>
#include <moMoveInit.h>
#include <moNextMove.h>
#include <algo/moeoIBMOLS.h>
#include <algo/moeoLS.h>
#include <archive/moeoArchive.h>
#include <fitness/moeoBinaryIndicatorBasedFitnessAssignment.h>
#include <move/moeoMoveIncrEval.h>



//#include <rsCrossQuad.h>



template < class MOEOT, class Move >
class moeoIteratedIBMOLS : public moeoLS < MOEOT, eoPop < MOEOT > & >
{
public:

    typedef typename MOEOT::ObjectiveVector ObjectiveVector;


    moeoIteratedIBMOLS(
        moMoveInit < Move > & _moveInit,
        moNextMove < Move > & _nextMove,
        eoEvalFunc < MOEOT > & _eval,
        moeoMoveIncrEval < Move > & _moveIncrEval,
        moeoBinaryIndicatorBasedFitnessAssignment < MOEOT > & _fitnessAssignment,
        eoContinue < MOEOT > & _continuator,
        eoMonOp < MOEOT > & _monOp,
        eoMonOp < MOEOT > & _randomMonOp,
        unsigned int _nNoiseIterations=1
    ) :
            ibmols(_moveInit, _nextMove, _eval, _moveIncrEval, _fitnessAssignment, _continuator),
            eval(_eval),
            continuator(_continuator),
            monOp(_monOp),
            randomMonOp(_randomMonOp),
            nNoiseIterations(_nNoiseIterations)
    {}


    void operator() (eoPop < MOEOT > & _pop, moeoArchive < MOEOT > & _arch)
    {
        _arch.update(_pop);
        ibmols(_pop, _arch);
        while (continuator(_arch))
        {
            // generate new solutions from the archive
            generateNewSolutions(_pop, _arch);
            // apply the local search (the global archive is updated in the sub-function)
            ibmols(_pop, _arch);
        }
    }


private:

    moeoIBMOLS < MOEOT, Move > ibmols;
    eoEvalFunc < MOEOT > & eval;
    eoContinue < MOEOT > & continuator;
    eoMonOp < MOEOT > & monOp;
    eoMonOp < MOEOT > & randomMonOp;
    unsigned int nNoiseIterations;


    void generateNewSolutions(eoPop < MOEOT > & _pop, const moeoArchive < MOEOT > & _arch)
    {
        // shuffle vector for the random selection of individuals
        vector<unsigned int> shuffle;
        shuffle.resize(std::max(_pop.size(), _arch.size()));
        // init shuffle
        for (unsigned int i=0; i<shuffle.size(); i++)
        {
            shuffle[i] = i;
        }
        // randomize shuffle
        UF_random_generator <unsigned int> gen;
        std::random_shuffle(shuffle.begin(), shuffle.end(), gen);
        // start the creation of new solutions
        for (unsigned int i=0; i<_pop.size(); i++)
        {
            if (shuffle[i] < _arch.size()) // the given archive contains the individual i
            {
                // add it to the resulting pop
                _pop[i] = _arch[shuffle[i]];
                // apply noise
                for (unsigned int j=0; j<nNoiseIterations; j++)
                {
                    monOp(_pop[i]);
                }
            }
            else // a random solution needs to be added
            {
                // random initialization
                randomMonOp(_pop[i]);
            }
            // evaluation of the new individual
            _pop[i].invalidate();
            eval(_pop[i]);
        }
    }





// A DEVELOPPER RAPIDEMENT POUR TESTER AVEC CROSSOVER //
    /*
        void generateNewSolutions2(eoPop < MOEOT > & _pop, const moeoArchive < MOEOT > & _arch)
        {
                // here, we must have a QuadOp !
                //eoQuadOp < MOEOT > quadOp;
                rsCrossQuad quadOp;
                // shuffle vector for the random selection of individuals
                vector<unsigned int> shuffle;
                shuffle.resize(_arch.size());
                // init shuffle
                for (unsigned int i=0; i<shuffle.size(); i++)
                {
                        shuffle[i] = i;
                }
                // randomize shuffle
                UF_random_generator <unsigned int int> gen;
                std::random_shuffle(shuffle.begin(), shuffle.end(), gen);
                // start the creation of new solutions
                unsigned int i=0;
                while ((i<_pop.size()-1) && (i<_arch.size()-1))
                {
                        _pop[i] = _arch[shuffle[i]];
                        _pop[i+1] = _arch[shuffle[i+1]];
                        // then, apply the operator nIterationsNoise times
                        for (unsigned int j=0; j<nNoiseIterations; j++)
                        {
                                quadOp(_pop[i], _pop[i+1]);
                        }
                        eval(_pop[i]);
                        eval(_pop[i+1]);
                        i=i+2;
                }
                // do we have to add some random solutions ?
                while (i<_pop.size())
                {
                        randomMonOp(_pop[i]);
                        eval(_pop[i]);
                        i++;
                }
        }
        */





};

#endif /*MOEOITERATEDIBMOLS_H_*/

---