---

individual.h

Go to the documentation of this file.

#ifndef __INDIVIDUAL_H__
#define __INDIVIDUAL_H__

#include "nhp/genetics.h"
#include <magic/mmath.h>
#include <magic/mmap.h>

//Externals
class EAEnvironment;
class SimplePopulation;
class SelectionMatrix;
class Selector;
class SelectionPrms;



//                                                                           //
//               ---           | o       o     |             |               //
//                |    _       |               |        ___  |               //
//                |  |/ \   ---| | |   | |  ---| |   |  ___| |               //
//                |  |   | (   | |  \ /  | (   | |   | (   | |               //
//               _|_ |   |  ---| |   V   |  ---|  \__!  \__| |               //
//                                                                           //

class Individual : public Comparable {
    decl_dynamic (Individual);
  public:

                            Individual      ();
    explicit                Individual      (const Individual& prototype);

    explicit                Individual      (const Genome& prototype);

    virtual                 ~Individual     ();
    
    void                    incarnate       (bool init);

    // Passthroughs to feature map
    
    void                    set             (const String& key, Object* val) {
        mFeatures.set (key, val);
    }

    void                    remove          (const String& key) {mFeatures.remove(key);}
    
    Object&                 operator[]		(const String& key) {return mFeatures[key];}

    const Object&           operator[]		(const String& key) const {return mFeatures[key];}

    Object*                 getFeature      (const String& key) {return mFeatures.getvp(key);}
    const Object*           getFeature      (const String& key) const {return mFeatures.getp(key);}

    const Map<String,Object>&   features    () const {return mFeatures;}
    
    // Evaluation of the fitness
    
    double                  evaluate        (EAEnvironment& envr, bool force=false);

    // Lets the individual to give it's preference for the given individual
    //double                    select          (const RefArray<Individual>& opop, int j) const;

    // We want to be comparable by our fitness to allow sorting
    int                     compare         (const Comparable& other) const;

    // Returns the evaluated fitness of the phenotype
    double                  getfitness      () const {return fitness;}

    // Returns the number of evaluations the calculated fitness has
    // been averaged over
    int                     averaged_over   () const {return avg_over;}

    // Joins the fitness with a (practically) identical other phenotype
    void                    joinfitness     (const Individual& other);

    // Reset fitness and it's averaging
    void                    resetFitness    () {fitness=0; avg_over=0;}
    
    // Feature shortcuts

    int                     getage          () const {return age;}

    const Selector&         selector        () const {return *mpSelector;}

    void                    setSelector     (const SelectionPrms& templ);
    
    //double                    select          (const SelectionMatrix& selmat,
    //                                       int self_i, int other_j) const;

    // Passthroughs to Genome

    bool                execute             (const GeneticMsg& msg) const {return genome.execute(msg);}
    void                init                () {genome.init();}
    bool                pointMutate         (const MutationRate& k);
    const Genstruct*    getGene             (const GeneticID& n) const {return genome.getGene(n);}
    static void         addGenesTo          (Genome& g, const StringMap& params);
    void                addking             () {genome.addking();}
    int                 getkings            () const {return genome.getkings();}
    void                recombine           (const Individual& a, const Individual& b);
    double              equality            (const Individual& other) const {
        return genome.equality (other.genome);
    }
    
    void                    print           (TextOStream& out) const;

    virtual DataOStream&    operator>>		(DataOStream& out) const;

    virtual void            check           () const;

  private:
    int                     operator==      (const Comparable& other) const {FORBIDDEN}

    void                    grow_older      ();

    Map<String,Object>      mFeatures;

    mutable double          fitness;

    mutable int             avg_over;

    int                     age;

    Selector*               mpSelector;

    Genome                  genome;

    Individual& operator= (const Individual& other) {FORBIDDEN; return *this;} // Prevent copying
};

#endif

---