---

genes.h

Go to the documentation of this file.

#ifndef __GENES_H__
#define __GENES_H__

#include <magic/mobject.h>
#include <magic/mdatastream.h>
#include "nhp/genetics.h"

// Is it a bool? Is it a double? No! It's the SuperGene!

//                                                                           //
//                            ----                                           //
//                           |      ___    _    ___                          //
//                           | --- /   ) |/ \  /   )                         //
//                           |   \ |---  |   | |---                          //
//                           |___/  \__  |   |  \__                          //
//                                                                           //

class Gene : public Genstruct {
    decl_dynamic (Gene);
  public:

                    Gene        () {FORBIDDEN}
                    Gene        (const GeneticID& n, double mut=1);
                    Gene        (const Gene& o) : Genstruct (o) {shallowCopy (o);}

    void                        setMutability   (double val) {mutability=val;}

    double                      getMutability   () const {return mutability;}

    // Implementations
        
    virtual void                addPrivateGenes (Gentainer& g, const StringMap& params) {;}

    virtual void                copy            (const Genstruct& other);

    virtual const Genstruct*    getGene         (const GeneticID& nam) const {
        return (id==nam)? this : (const Gene*) NULL;
    }
    virtual void                check           () const {Genstruct::check ();}
    
  protected:
    double  mutability;

    virtual int                 calc_len    () const {return 1;}
    void                        shallowCopy (const Gene& o) {mutability=o.mutability;}

  private:
    Gene& operator= (const Gene& orig) {FORBIDDEN; return *this;}
};

// The Gene is your friend!

#define DefGene(gclass) \
class gclass : public Gene { \
    decl_dynamic (gclass);\
  public:\
                        gclass              (const GeneticID& name=NULL) : Gene (name) {;}\
                        gclass              (const gclass& o) : Gene (o) {;}\
    void                init                () {;}\
    bool                pointMutate         (const MutationRate& k) {return false;}\
    void                copy                (const Genstruct& o) {Gene::copy(o);}\
    Genstruct*          replicate           () const {return new gclass (id);}\
    bool                execute             (const GeneticMsg& msg) const;\
    void                addPrivateGenes     (Gentainer& g, const StringMap& params);\
};



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

class BinaryGene : public Gene {
    decl_dynamic (BinaryGene);
  public:

                            BinaryGene  () {FORBIDDEN}

                            BinaryGene  (const GeneticID& id,
                                         double mut=1.0, double initP=0.5);

                            BinaryGene  (const BinaryGene& o) : Gene (o) {shallowCopy (o);}

    // Access operators
    
    BinaryGene&             set         (bool value) {mValue = value; return *this;}

    bool                    getvalue    () const {return mValue;}

    void                    setInitP    (double initP) {mInitP=initP;}

    // Implementations

    virtual void            init        ();

    virtual bool            pointMutate (const MutationRate& k);
    virtual double          equality    (const Genstruct& other) const {
        return (mValue == static_cast<const BinaryGene&> (other).mValue)? 1.0 : 0.0;
    }
    virtual void            copy        (const Genstruct& other);
    virtual Genstruct*      replicate   () const {return new BinaryGene (*this);}
    virtual void            print       (TextOStream& out) const;
    virtual DataOStream&    operator>>	(DataOStream& out) const;

  private:
    void                    shallowCopy (const BinaryGene& o) {
        mValue=o.mValue;
        mInitP=o.mInitP;
    }
    BinaryGene& operator= (const BinaryGene& orig) {FORBIDDEN; return *this;}

    bool    mValue;
    double  mInitP;
};

// A dead binary is the best binary



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

class AnyFloatGene : public Gene {
    decl_dynamic (AnyFloatGene);
  public:
                    AnyFloatGene    () {FORBIDDEN}
    
                    AnyFloatGene    (const GeneticID& id, double min, double max, double m=1.0);
                    AnyFloatGene    (const AnyFloatGene& o) : Gene (o) {
                        shallowCopy (o);
                    }

    virtual double  getvalue    () const {MUST_OVERLOAD; return 0.0;}
    
    // Implementations

    virtual void    copy        (const Genstruct& other);

    virtual void    check       () const;
    
  protected:
    double          mMin;

    double          mMax;
    
  private:
    AnyFloatGene&   operator= (const AnyFloatGene& orig) {FORBIDDEN; return *this;}
    
    void            shallowCopy (const AnyFloatGene& o);

};



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

// External
class FloatMutator;

class FloatGene : public AnyFloatGene {
  public:

                            FloatGene   () {FORBIDDEN}

                            FloatGene   (const GeneticID& id, double min, double max,
                                         double m=1.0, double value=-999);
                            FloatGene   (const FloatGene& o) : AnyFloatGene (o) {
                                shallowCopy (o);
                            }

    FloatGene&              set         (double val) {value = val; return *this;}
    
    virtual double          getvalue    () const {return value;}
    

    FloatGene&              setCircular (bool c) {mCircular=c; return *this;}

    FloatGene&              setMutator  (FloatMutator* m) {mMutator=m; return *this;}

    // Implementations

    virtual void            init        ();

    virtual bool            pointMutate (const MutationRate& k);

    virtual double          equality    (const Genstruct& other) const;
    virtual void            copy        (const Genstruct& other);
    virtual Genstruct*      replicate   () const {return new FloatGene (*this);}
    virtual void            print       (TextOStream& out) const;
    virtual void            check       () const;
    
  protected:

    double          value;

    double          mVariance;

    bool            mCircular;

    FloatMutator*   mMutator;

  private:
    void                    shallowCopy (const FloatGene& o);
    FloatGene&              operator=   (const FloatGene& orig) {FORBIDDEN; return *this;}
    decl_dynamic (FloatGene);
};

// Gee, genes don't sink; they really do double



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

class BitFloatGene : public AnyFloatGene {
  public:
    
                            BitFloatGene    () {FORBIDDEN}

                            BitFloatGene    (const GeneticID& id, double min, double max,
                                             int bits, const StringMap& params, double m=1.0);
                            BitFloatGene    (const BitFloatGene& o) : AnyFloatGene (o) {
                                shallowCopy (o);
                            }

    virtual double          getvalue        () const;
    BitFloatGene*           setGrayCoding   (bool isg=true) {mGrayCoded=isg; return NULL;}
    
    // Implementations
        
    virtual void            init        () {mBits.init();}
    
    virtual bool            pointMutate (const MutationRate& k) {return mBits.pointMutate (k);}

    virtual double          equality    (const Genstruct& o) const {mBits.equality(o); return 0.0;}
    virtual void            copy        (const Genstruct& other);
    virtual Genstruct*      replicate   () const {return new BitFloatGene (*this);}
    virtual void            print       (TextOStream& out) const;
    virtual void            recombine   (const Genstruct& a, const Genstruct& b);
    virtual void            check       () const;

  protected:
    Gentainer       mBits;

    int             mBitCount;

    bool            mGrayCoded;
    
    virtual int             calc_len    () const {return ((const Genstruct&)mBits).calc_len();}
    
  private:
    void                    shallowCopy (const BitFloatGene& o);
    BitFloatGene&           operator=   (const BitFloatGene& orig) {FORBIDDEN; return *this;}
    decl_dynamic (BitFloatGene);
};



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

class AnyIntGene : public Gene {
    decl_dynamic (AnyIntGene);
  public:

                    AnyIntGene  () {FORBIDDEN}
    
                    AnyIntGene  (const GeneticID& id, int min, int max, double m=1.0);
    
                    AnyIntGene  (const AnyIntGene& o) : Gene (o) {
                        shallowCopy (o);
                    }

    virtual int     getvalue    () const {MUST_OVERLOAD; return 0;}
    
    // Implementations

    virtual void    copy        (const Genstruct& other);
    
    virtual void    check       () const {ASSERT(mMin<mMax); Gene::check ();}
    
  protected:
    int             mMin;

    int             mMax;

    void            shallowCopy (const AnyIntGene& o);
};


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

class IntGene : public AnyIntGene {
    decl_dynamic (IntGene);
    int     mValue;
  public:

                            IntGene     () {FORBIDDEN}
    
                            IntGene     (const GeneticID& id, int min, int max,
                                         double mut=1,int value=-9999);
                            IntGene     (const IntGene& o) : AnyIntGene (o) {shallowCopy (o);}

    virtual IntGene&        set         (int val) {mValue = val; return *this;}

    virtual int             getvalue    () const;

    // Implementations

    virtual void            init        ();

    virtual bool            pointMutate (const MutationRate& k);

    virtual double          equality    (const Genstruct& other) const;
    virtual void            copy        (const Genstruct& other);
    virtual Genstruct*      replicate   () const {return new IntGene (*this);}
    virtual void            print       (TextOStream& out) const;
    virtual void            check       () const;

  private:
    void                    shallowCopy (const IntGene& o);
    IntGene&                operator=   (const IntGene& orig) {FORBIDDEN; return *this;}
};

// IntGene? .. hmm .. Wouldn't InGen be better?


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

class BitIntGene : public AnyIntGene {
  public:
                            BitIntGene  () {FORBIDDEN}

                            BitIntGene  (const GeneticID& id, int min, int max,
                                             int bits, const StringMap& params, double m=1.0);
                            BitIntGene  (const BitIntGene& o) : AnyIntGene (o) {
                                shallowCopy (o);
                            }

    virtual int             getvalue        () const;

    BitIntGene*             setGrayCoding   (bool gray=true) {mGrayCoded=gray; return this;}
    
    // Implementations

    virtual void            init        () {mBits.init();}

    virtual bool            pointMutate (const MutationRate& k) {return mBits.pointMutate (k);}

    virtual double          equality    (const Genstruct& o) const {return mBits.equality(o);}
    virtual void            copy        (const Genstruct& other);
    virtual Genstruct*      replicate   () const {return new BitIntGene (*this);}
    virtual void            print       (TextOStream& out) const;
    virtual void            recombine   (const Genstruct& a, const Genstruct& b);
    virtual void            check       () const;

  protected:

    Gentainer   mBits;

    int         mBitCount;

    bool        mGrayCoded;
    
    virtual int             calc_len    () const {return ((const Genstruct&)mBits).calc_len();}
    
  private:
    void                    shallowCopy (const BitIntGene& o);
    BitIntGene&             operator= (const BitIntGene& orig) {FORBIDDEN; return *this;}
    decl_dynamic (BitIntGene);
};



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

class InterGene : public Gene {
    decl_dynamic (InterGene);
    GeneticID   targetGene;
  public:
                            InterGene   (const GeneticID& name=NULL, const GeneticID& trg=NULL)
                                    : Gene (name), targetGene (trg) {;}
                            InterGene   (const InterGene& o) : Gene (o) {shallowCopy (o);}

    // Implementations

    virtual void            init        () {;}
    virtual Genstruct*      replicate   () const {return new InterGene (*this);}
    virtual void            copy        (const Genstruct& other);
    virtual bool            execute     (const GeneticMsg& msg) const;
    virtual void            print       (TextOStream& out) const;
    virtual bool            pointMutate (const MutationRate& k) {return false;}

  private:
    void                    shallowCopy (const InterGene& o) {targetGene=o.targetGene;}
    InterGene&              operator=   (const InterGene& orig) {FORBIDDEN; return *this;}
};



// I don't want any f*cking genes in my food.

#endif

---