---

selection.h

Go to the documentation of this file.

#ifndef __SELECTION_H__
#define __SELECTION_H__

#include <magic/mmatrix.h>
#include <magic/mrefarray.h>
#include "nhp/individual.h"

// Externals
class SimplePopulation;
class Gentainer;

class SelectionSituation;


//                                                                          //
//    ----       |                 o            |   |               o       //
//   (      ___  |  ___   ___   |           _   |\ /|  ___   |              //
//    ---  /   ) | /   ) |   \ -+- |  __  |/ \  | V |  ___| -+- |/\ | \ /   //
//       ) |---  | |---  |      |  | /  \ |   | | | | (   |  |  |   |  X    //
//   ___/   \__  |  \__   \__/   \ | \__/ |   | |   |  \__|   \ |   | / \   //
//                                                                          //

class SelectionMatrix : public Object {
  public:

    explicit    SelectionMatrix     (const SelectionSituation& situation);
                ~SelectionMatrix    () {}
    
    void    selectRandomPair        (int& a, int& b) const;
    
    TextOStream&    operator>>		(TextOStream& out) const {return mSelection >> out;}

  protected:

    void    calculateMatrix         (const SelectionSituation& situation);

  private:
    SelectionMatrix();

    Matrix  mSelection;
    
    friend class Selector;
};



//  ----       |                 o             ---- o                     o            //
// (      ___  |  ___   ___   |           _   (        |         ___   |           _   //
//  ---  /   ) | /   ) |   \ -+- |  __  |/ \   ---  | -+- |   |  ___| -+- |  __  |/ \  //
//     ) |---  | |---  |      |  | /  \ |   |     ) |  |  |   | (   |  |  | /  \ |   | //
// ___/   \__  |  \__   \__/   \ | \__/ |   | ___/  |   \  \__!  \__|   \ | \__/ |   | //

class SelectionSituation : public Object {
  public:

                            SelectionSituation      (const SimplePopulation& pop);

    const SimplePopulation& population              () const {return mrPop;}

    const Individual&       getOrdered              (int i) const {return mOrdPop[i];}
    
  private:

    const SimplePopulation& mrPop;

    RefArray<Individual> mOrdPop;
};



//      ----       |                 o            ----                      //
//     (      ___  |  ___   ___   |           _   |   )            ____     //
//      ---  /   ) | /   ) |   \ -+- |  __  |/ \  |---  |/\ |/|/| (         //
//         ) |---  | |---  |      |  | /  \ |   | |     |   | | |  \__      //
//     ___/   \__  |  \__   \__/   \ | \__/ |   | |     |   | | | ____)     //

class SelectionPrms : public Object {
  public:

    explicit                SelectionPrms   ();
    explicit                SelectionPrms   (const SelectionPrms& o) {copy(o);}
                            ~SelectionPrms  () {}

    void                    useOnlyMethod   (int m);

    void                    adaptParams     (bool mu=true, bool etaPlus=true,
                                             bool q=true);

    void                    adaptWeights    (bool v=true) {mAdaptiveWeights=v;}

    void                    setMu       (int m);
    
    void                    setMuPart   (double part);

    void                    setEtaPlus      (double etaplus);

    void                    setQ            (int q);

    int                     muFor           (int populsize) const;
    
    void                    copy            (const SelectionPrms& o);

  protected:
    double                  mMuPart;

    int                     mMu;

    bool                    mAdaptiveMu;

    double                  mEtaPlus;

    bool                    mAdaptiveEtaPlus;

    int                     mQ;

    bool                    mAdaptiveQ;

    bool                    mWeightedSelection;

    Vector                  mSelMethodW;

    bool                    mAdaptiveWeights;

    friend class Selector;
};



//                                                                          //
//                   ----       |                                           //
//                  (      ___  |  ___   ___   |                            //
//                   ---  /   ) | /   ) |   \ -+-  __  |/\                  //
//                      ) |---  | |---  |      |  /  \ |                    //
//                  ___/   \__  |  \__   \__/   \ \__/ |                    //
//                                                                          //

class Selector : public SelectionPrms {
  public:
    explicit                Selector        () : SelectionPrms () {mScore=0;}
    explicit                Selector        (const SelectionPrms& orig);
                            ~Selector       () {}
    
    static void             addGenesTo      (Gentainer& g, const StringMap& params);

    void                    read            (const Genome& g);

    double                  select          (const SelectionSituation& situation,
                                             int self_i, int other_j) const;

    int                     score           () const {return mScore;}
    
    void                    virginize       () {mScore=0;}

    enum smconsts {MULAMBDASELECTION=0, LINEARRANKING, PROPORTIONAL, TOURNAMENT,
                   number_of_methods};
    
  protected:
    virtual double  selectWithMethod    (const SelectionSituation& situation, int smno, int i, int j) const;

    double  muLambdaSelection           (const SelectionSituation& situation, int i, int j) const;

    double  linearRanking               (const SelectionSituation& situation, int i, int j) const;

    double  proportionalSelection       (const SelectionSituation& situation, int i, int j) const;

    double  tournamentSelection         (const SelectionSituation& situation, int i, int j) const;

  protected:
    int                     mScore;

    void                    operator=       (const Selector& other) {}
    void                    operator=       (const SelectionPrms& other) {}
};

/*
class SelectionMethod : public Object {
  public:
                        SelectionMethod (const String& name);

    const Array<SelectionMethod>& methods   () const {return sMethods;}
    virtual double          select          (int i, int j);
    
  private:
    static Array<SelectionMethod> sMethods;
};
*/

#endif

---