---

genetics.h

Go to the documentation of this file.

/*
  Neljänneksi tulee Tuulen kirja. Tämä kirja ei ole yhteydessä minun
  Ichi-kouluuni vaan muihin strategian kouluihin. Tuulella tarkoitan
  strategian vanhoja perinteitä, tämän päivän perinteitä ja
  perhetraditioita. Siten voi selkeästi selittää maailman
  strategiat. Tämä on perinne. On vaikeaa tuntea itseäsi jos et tunne
  muita. Kaikilla Teillä on sivupolkuja. Jos opiskelet Tietä
  päivittäin ja henkesi joutuu harhaan, voit luulla noudattavasi hyvää
  Tietä vaikka objektiivisesti se ei ole oikea Tie. Jos seuraat oikeaa
  Tietä mutta harhaannut hieman, tulee siitä myöhemmin suuri
  poikkeama. Sinun täytyy tajuta tämä. Muut strategiat ovat tulleet
  otettaviksi pelkkänä miekkailuna, eikä se ole väärin että näin
  olisi. Minun strategiani hyöty, vaikkakin se sisältää miekkailun,
  sijaitsee erillisessä periaatteessa. Olen selittänyt mitä
  tavallisesti tarkoitetaan strategialla muissa kouluissa Perinteen
  (Tuulen) kirjassa.  */

#ifndef __GENETICS_H__
#define __GENETICS_H__

#include <magic/mobject.h>
#include <magic/mstring.h>
#include <magic/mmap.h>

using namespace MagiC;

// Externals
class MagiC::DataOStream;
class MagiC::OStream;
class Individual;
class Gene;

// Internals
class Genstruct;
class Gentainer;

enum printflags {PRINT_CLASSNAMES=0, PRINT_NAMES, PRINT_HIDDEN};

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

typedef String GeneticID;

class GeneticMsg {
  public:

    GeneticMsg  (const GeneticID& rcvr, Individual& ind) : receiver (rcvr), host (ind) {
        previous = NULL;
    }

    virtual void    pushCaller  (Genstruct* clr) {previous = clr;}

    Genstruct*  getCaller   () const {return previous;}

    const GeneticID&    receiver;

    Individual&         host;

  private:
    Genstruct*  previous;

    GeneticMsg (const GeneticMsg& orig) :
            receiver (*(GeneticID*)NULL), host (*(Individual*)NULL) {FORBIDDEN}

    GeneticMsg& operator= (const GeneticMsg& orig) {FORBIDDEN; return *this;}
};


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

class MutationRate {
    double          mBinaryRate;
    double          mIntRate;
    double          mFloatRate;
    double          mFloatVariance;
    bool            mOneBitMutation;
    bool            mAutoAdaptation;
    //FloatMutator* mFloatMutator;
  public:
                        MutationRate    () {
                            mBinaryRate=mIntRate=mFloatRate=mFloatVariance=0.0;
                            mOneBitMutation=false;
                            mAutoAdaptation=false;
                        }

                        MutationRate    (const MutationRate& o) {
                            // Do copying quickly
                            memcpy (this, &o, sizeof (MutationRate));
                        }

                        MutationRate    (const MutationRate& o, const MutationRate& m) {
                            mBinaryRate = o.mBinaryRate * m.mBinaryRate;
                            mIntRate = o.mIntRate * m.mIntRate;
                            mFloatRate = o.mFloatRate * m.mFloatRate;
                            mFloatVariance = o.mFloatVariance * m.mFloatVariance;
                            mOneBitMutation = o.mOneBitMutation || m.mOneBitMutation;
                            mAutoAdaptation = o.mAutoAdaptation || m.mAutoAdaptation;
                        }
    
                        MutationRate    (const Gentainer& g);
    
    static void         addGenesTo      (Gentainer& g, const StringMap& params);

    double              binaryRate      () const {return mBinaryRate;}
    double              intRate         () const {return mIntRate;}
    double              doubleRate      () const {return mFloatRate;}
    double              doubleVariance  () const {return mFloatVariance;}

    void                binaryRate      (double x) {mBinaryRate=x;}
    void                intRate         (double x) {mIntRate=x;}
    void                doubleRate      (double x) {mFloatRate=x;}
    void                doubleVariance  (double x) {mFloatVariance=x;}

    void                oneBitMutation  (bool mt) {mOneBitMutation = mt;}

    bool                oneBitMutation  () const {return mOneBitMutation;}

    void                autoAdaptation  (bool aa) {mAutoAdaptation=aa;}

    bool                autoAdaptation  () const {return mAutoAdaptation;}

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



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

EXCEPTIONCLASS (invalid_gene_name);

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

                                Genstruct   (const GeneticID& name=NULL);
                                Genstruct   (const Genstruct& other);


    const Genstruct&            operator[]	(const GeneticID& name) const {
        return *getGene (name);
    }

    Genstruct&                  operator[]	(const GeneticID& name) {
        return const_cast<Genstruct&>(const_cast<const Genstruct*>(this)->operator[] (name));
    }

    const GeneticID&            getID       () const {return id;}

    int                         length      () const;

    // Virtual functions
    
    virtual void                init        () {MUST_OVERLOAD}

    virtual const Genstruct*    getGene     (const GeneticID& name) const {MUST_OVERLOAD; return NULL;}

    virtual bool                execute     (const GeneticMsg& msg) const {return false;}

    virtual void                addPrivateGenes (Gentainer& g) {MUST_OVERLOAD}
    virtual void                addPrivateGenes (Gentainer& g, const StringMap& params) {MUST_OVERLOAD}
    
    virtual bool                pointMutate (const MutationRate& r) {MUST_OVERLOAD; return false;}
    
    virtual void                recombine   (const Genstruct& a, const Genstruct& b) {copy(a);}

    virtual double              equality    (const Genstruct& other) const {MUST_OVERLOAD; return 0.0;}

    virtual Genstruct*          replicate   () const {MUST_OVERLOAD; return NULL;}

    virtual void                copy        (const Genstruct& other) {MUST_OVERLOAD}

    virtual void                print       (TextOStream& out) const;

    // The world has become so virtual that it's a wonder we any more
    // know what is real. For example, this class is abstract.

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

    Genstruct&                  hide        (bool h=true) {mHidden=h; return *this;}

    bool                        isHidden    () const {return mHidden;}

    virtual int                 calc_len    () const {MUST_OVERLOAD; return 0;}

    // Implementations

    virtual void                check       () const;
    
  protected:

    void                        copyGenstr  (const Genstruct& other) {
        id = other.id;
        size = other.size;
        mHidden = other.mHidden;
    }

    GeneticID                   id;

  private:  
    mutable int                 size;

    bool                        mHidden;

    Genstruct operator= (const Genstruct& orig) {FORBIDDEN; return *this;}

    friend class Gentainer;
};



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

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

                        Gentainer   (const GeneticID& name = NULL);

                        Gentainer   (const Gentainer& orig);

    void                add         (Genstruct* newstruct);
    
    const Genstruct&    operator[]	(const GeneticID& name) const {
        return *getGene (name);
    }
    Genstruct&          operator[]	(const GeneticID& name) {
        return const_cast<Genstruct&>(const_cast<const Gentainer*>(this)->operator[](name));
    }

    const Genstruct&    operator[]	(int i) const {return substructs[i];}
    Genstruct&          operator[]	(int i) {return substructs[i];}

    int                 size        () const {return substructs.size();}

    void                selfadjust  (bool val=true) {self_adjust=val;}

    void                recombRate  (double rate) {mRecombRate=rate;}

    // Implementations

    virtual void                init        ();
    virtual void                addPrivateGenes (Gentainer& g, const StringMap& params);
    virtual const Genstruct*    getGene     (const GeneticID& name) const;
    virtual bool                pointMutate (const MutationRate& k);
    virtual void                recombine   (const Genstruct& a, const Genstruct& b);
    virtual double              equality    (const Genstruct& other) const;
    virtual Genstruct*          replicate   () const;
    virtual void                copy        (const Genstruct& other);
    virtual void                print       (TextOStream& out) const;
    virtual bool                execute     (const GeneticMsg& msg) const;

    virtual DataOStream&        operator>>	(DataOStream& out) const;
    virtual void                check       () const;
    
  protected:
    virtual int         calc_len    () const;

    Array<Genstruct>    substructs;

    bool                self_adjust;

    double              mRecombRate;

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

//
// I CALL AND I CALL!
// But in vain -
// no genstruct hears,
// no genstruct cares.
//
// So vast is the genome,
// so full of abstract gentainers
// that my messages are lost,
// in unoverridden virtual methods.
//


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

class Genome : public Gentainer {
    decl_dynamic (Genome);
  protected:
    int kings;

  public:   

                                Genome      ();
                                Genome      (const Genome& other);
    
    void                        addking     () {kings++;}

    int                         getkings    () const {return kings;}

    // Implementations

    virtual void                init        ();
    //virtual void              recombine   (const Genstruct& a, const Genstruct& b);
    virtual void                print       (TextOStream& out) const;
    virtual void                addPrivateGenes (Gentainer& g, const StringMap& pars);

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

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




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

class MonoploidGenome : public Genome {
  public:

                MonoploidGenome     ();
};



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

class DiploidGenome : public Genome {
    MonoploidGenome genome_a, genome_b;
    
  public:

                                DiploidGenome   ();

    // Implementations

    virtual void        init        ();
    virtual void        addPrivateGenes (Gentainer& g, const StringMap& params);
    virtual int         length      () const;
    virtual const Gene& operator[]	(const char* name) const  throw (invalid_gene_name);
    virtual bool        pointMutate (const MutationRate& k);
    virtual void        recombine   (const Genstruct& a, const Genstruct& b);
    virtual double      equality    (const Genstruct& other) const;
    virtual Genstruct*  replicate   () const;
    virtual void        copy        (const Genstruct& other);
    virtual void        print       (TextOStream& out) const;
  protected:
    virtual int         calc_len    () const;

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



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

/*
class TransGentainer {
  public:
  private:
    Gentainer*  gentainer;
};
*/

// And Void became to exist, together with the Light,
// The Mother Ocean was born, together with her Brother,
// filled with the primal froths of the holy Union,
// their little children, the eternal existance.


#endif

---