Changeset 675 for cpp/frams/genetics


Ignore:
Timestamp:
08/19/17 02:52:26 (3 years ago)
Author:
Maciej Komosinski
Message:

Code formatting

Location:
cpp/frams/genetics
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • cpp/frams/genetics/f4/conv_f4.cpp

    r671 r675  
    157157                if (C->dadlink->type != T_STICK4)
    158158                {
    159                         C->dadlink = getStick(C->dadlink);
     159                C->dadlink = getStick(C->dadlink);
    160160                }
    161161
  • cpp/frams/genetics/oper_fx.h

    r673 r675  
    7979class GenoOperators
    8080{
    81  public:
    82    Param par;
    83    char supported_format; ///<genotype format which is supported by this class ('6' for GenoOper_f6, 'F' for GenoOper_fF, etc.). Must be initialized in constructor
    84    string name; ///<name of this set of genetic operators
    85    const char **mutation_method_names; ///<array of names for mutation methods. If initialized (by new const char*[]), must have entries for each method index returned by mutate(geno,chg,METHOD).  If initialized, it is automatically freed by this destructor.
    86    GenoOperators() : par(empty_paramtab) {supported_format='x'; name="Default"; mutation_method_names=NULL; setDefaults();}
    87 
    88 /**Used to perform initializations of Param parameters that are not handled by the Param itself
    89 (i.e. string parameters or fields that require some complex logic may be initialized here)*/
    90    virtual void setDefaults() {}
    91 
    92 /**Checks a genotype for minor mistakes and major errors.
    93 \param geno genotype to be checked
    94 \param genoname name of the genotype to be checked
    95 \retval error_position 1-based (or 1 if no exact error position known)
    96 \retval GENOPER_OK when the genotype is fully valid, and can be translated by the converter with \b no modifications nor tweaks*/
    97    virtual int checkValidity(const char *geno, const char *genoname) { return GENOPER_NOOPER; }
    98 
    99 /**Validates a genotype. The purpose of this function is to validate
    100 obvious/minor errors (range overruns, invalid links, etc.). Do not try
    101 to introduce entirely new genes in place of an error.
    102 \param geno input/output: genotype to be validated
    103 \param genoname name of the genotype to be validated
    104 \retval GENOPER_OK must be returned in any case ("did my best to validate")*/
    105    virtual int validate(char *&geno, const char *genoname) { return GENOPER_NOOPER; }
    106 
    107 /**Mutates a genotype. Mutation should always change something.
    108 
    109 Avoid unnecessary calls in your code. Every genotype argument passed to this
    110 function is first checked, and validated if checkValidity() reported an error (or
    111 if there is no checkValidity() implemented). Every resulting genotype is subject
    112 to the same procedure, unless GENOPER_OPFAIL was returned. Thus you do not have
    113 to call these functions on input and output genotypes, because they are validated
    114 if needed.
    115 \param geno input/output: genotype to be mutated
    116 \param chg output: initialize with a value (in most cases 0..1) corresponding
    117 to the amount of genotype mutated. For example, it could be the number of changed
    118 genes divided by the total number of genes before mutation.
    119 \param chg method: initialize with the ID (number) of mutation method used.
    120 \retval GENOPER_OK
    121 \retval GENOPER_OPFAIL
    122 \sa
    123 Mutation example to illustrate the exchange of pointers for \e geno.
    124 The mutation adds random letter at the beginning or removes last letter from \e geno.
    125 \code
    126 {
    127  int len=strlen(geno);
    128  if (len==0 || random(2)==0) //add
    129  {
    130     method=0;
    131     char* mutated=(char*)malloc(mutated,len+2); //allocate for mutated genotype
    132     mutated[0]='A'+random(10); //first char random
    133     strcpy(mutated+1,geno); //the rest is original
    134     free(geno); //must take care of the original allocation
    135     geno=mutated;
    136  } else
    137  {
    138     method=1;
    139     geno[len-1]=0; //simply shorten the string - remove last char
    140  }
    141  chg=1.0/max(len,1); //estimation of mutation strength, divby0-safe
    142 } \endcode
    143 */
    144    virtual int mutate(char *&geno,float& chg,int &method) {method=-1; chg=-1; return GENOPER_NOOPER;}
    145 
    146 /**Crosses over two genotypes. It is sufficient to return only one child (in \e g1) and set \e chg1 only, then \e g2 must equal "".
    147 
    148 Avoid unnecessary calls in your code. Every genotype argument passed to this
    149 function is first checked, and validated if checkValidity() reported an error (or
    150 if there is no checkValidity() implemented). Every resulting genotype is subject
    151 to the same procedure, unless GENOPER_OPFAIL was returned. Thus you do not have
    152 to call these functions on input and output genotypes, because they are validated
    153 if needed.
    154 \param g1 input/output: parent1 genotype, initialize with child1
    155 \param g2 input/output: parent2 genotype, initialize with child2 if both children are available
    156 \param chg1 output: initialize with the fraction of parent1 genes in child1 (parent2 has the rest)
    157 \param chg2 output: initialize with the fraction of parent2 genes in child2 (parent1 has the rest)
    158 \retval GENOPER_OK
    159 \retval GENOPER_OPFAIL
    160 \sa mutate() for an example*/
    161    virtual int crossOver(char *&g1,char *&g2,float& chg1,float& chg2) {chg1=chg2=-1; return GENOPER_NOOPER;}
    162 
    163 /**\return a pointer to the simplest genotype string*/
    164    virtual const char* getSimplest() {return NULL;}
    165 
    166 /**You may want to have your genotype colored. This method provides desired character styles for genes.
    167 \param geno genotype
    168 \param pos 0-based char offset
    169 \retval number-encoded visual style (and validity) of the genotype char at \e geno[pos].
    170 Assume white background.
    171 \sa GENSTYLE_* macros, like GENSTYLE_BOLD*/
    172    virtual uint32_t style(const char *geno,int pos) {return GENSTYLE_RGBS(0,0,0,GENSTYLE_NONE);}
    173 
    174 ///currently not used (similarity of two genotypes)
    175    virtual float similarity(const char*,const char*) {return GENOPER_NOOPER;}
    176    virtual ~GenoOperators() {if (mutation_method_names) {delete []mutation_method_names; mutation_method_names=NULL;}}
    177 //   virtual char getFormat() {return 255;} //returns supported genotype format, for ex. '1'
    178 //   virtual int enabled() {return 1;} // should be enabled by default
    179 
    180 /** \name Some helpful methods for you */
    181 //@{
    182    static int roulette(const double *probtab,const int count);  ///<returns random index according to probabilities in the \e probtab table or -1 if all probs are zero. \e count is the number of elements in \e probtab.
    183    static bool getMinMaxDef(ParamInterface *p,int propindex,double &mn,double &mx,double &def); ///<perhaps a more useful (higher-level) way to obtain min/max/def info for integer and double properties. Returns true if min/max/def was really available (otherwise it is just invented).
    184    static int selectRandomProperty(Neuro* n); ///<selects random property (either 0-based extraproperty of Neuro or 100-based property of its NeuroClass). -1 if Neuro has no properties.
    185    static double mutateNeuProperty(double current,Neuro *n,int propindex); ///<returns value \e current mutated for the property \e propindex of NeuroClass \e nc or for extraproperty (\e propindex - 100) of Neuro. Neuro is used as read-only. Give \e propindex == -1 to mutate connection weight (\e nc is then ignored).
    186    static bool mutatePropertyNaive(ParamInterface &p,int propindex); ///<creep-mutate selected property. Returns true when success. mutateProperty() should be used instead of this function.
    187    static bool mutateProperty(ParamInterface &p,int propindex); ///<like mutatePropertyNaive(), but uses special probability distributions for some neuron properties.
    188    static bool getMutatedProperty(ParamInterface &p,int i,double oldval,double &newval); ///<like mutateProperty(), but just returns \e newval, does not get nor set it using \e p.
    189    static double mutateCreepNoLimit(char type,double current,double mn,double mx); ///<returns \e current value creep-mutated with Gaussian distribution within [ \e mn , \e mx ] interval. Forced precision: 3 digits after comma. \e type must be either 'd' (integer) or 'f' (float/double).
    190    static double mutateCreep(char type,double current,double mn,double mx); ///<just as mutateCreepNoLimit(), but forces mutated value into the [mn,mx] range using the 'reflect' approach.
    191    static void setIntFromDoubleWithProbabilisticDithering(ParamInterface &p, int index, double value); ///<sets a double value in an integer field; when a value is non-integer, applies random "dithering" so that both lower and higher integer value have some chance to be set.
    192    static void linearMix(ParamInterface &p1, int i1, ParamInterface &p2, int i2, double proportion); ///<mixes i1'th and i2'th properties of p1 and p2; proportion should be within [0,1]; 0.5 causes both properties to become their average. For integer properties applies random "dithering" when necessary.
    193    static NeuroClass* getRandomNeuroClass(); ///<returns random neuroclass or NULL when no active classes.
    194    static int getRandomNeuroClassWithOutput(const vector<NeuroClass*>& NClist); //returns index of random neuroclass from the NClist or -1 (no neurons on the list that provide output)
    195    static int getRandomNeuroClassWithInput(const vector<NeuroClass*>& NClist); //returns index of random neuroclass from the NClist or -1 (no neurons on the list that want input(s))
    196    static int getRandomChar(const char *choices, const char *excluded); ///<returns index of a random character from 'choices' excluding 'excluded', or -1 when everything is excluded or 'choices' is empty.
    197    static NeuroClass* parseNeuroClass(char *&s); ///<returns longest matching neuroclass or NULL if the string does not begin with a valid neuroclass name. Advances \e s pointer.
    198    static Neuro* findNeuro(const Model *m,const NeuroClass *nc); ///<returns pointer to first Neuro of class \e nc, or NULL if there is no such Neuro.
    199    static int neuroClassProp(char *&s,NeuroClass *nc,bool also_v1_N_props=false); ///<returns 0-based property number for \e neuroclass, 100-based extraproperty number for Neuro, or -1 if the string does not begin with a valid property name. Advance \e s pointer if success.
    200    static bool isWS(const char c); ///<is \e c a whitespace char?
    201    static void skipWS(char *&s); ///<advances pointer \e s skipping whitespaces.
    202    static bool areAlike(char*,char*); ///<compares two text strings skipping whitespaces. Returns 1 when equal, 0 when different.
    203    static char* strchrn0(const char *str,char ch); ///<like strchr, but does not find zero char in \e str.
    204    static bool isNeuroClassName(const char firstchar); ///<determines if \e firstchar may start NeuroClass name. If not, it may start NeuroClass' (or Neuro's) property name.
    205 //@}
     81public:
     82        Param par;
     83        char supported_format; ///<genotype format which is supported by this class ('6' for GenoOper_f6, 'F' for GenoOper_fF, etc.). Must be initialized in constructor
     84        string name; ///<name of this set of genetic operators
     85        const char **mutation_method_names; ///<array of names for mutation methods. If initialized (by new const char*[]), must have entries for each method index returned by mutate(geno,chg,METHOD).  If initialized, it is automatically freed by this destructor.
     86        GenoOperators() : par(empty_paramtab) { supported_format = 'x'; name = "Default"; mutation_method_names = NULL; setDefaults(); }
     87
     88        /**Used to perform initializations of Param parameters that are not handled by the Param itself
     89        (i.e. string parameters or fields that require some complex logic may be initialized here)*/
     90        virtual void setDefaults() {}
     91
     92        /**Checks a genotype for minor mistakes and major errors.
     93        \param geno genotype to be checked
     94        \param genoname name of the genotype to be checked
     95        \retval error_position 1-based (or 1 if no exact error position known)
     96        \retval GENOPER_OK when the genotype is fully valid, and can be translated by the converter with \b no modifications nor tweaks*/
     97        virtual int checkValidity(const char *geno, const char *genoname) { return GENOPER_NOOPER; }
     98
     99        /**Validates a genotype. The purpose of this function is to validate
     100        obvious/minor errors (range overruns, invalid links, etc.). Do not try
     101        to introduce entirely new genes in place of an error.
     102        \param geno input/output: genotype to be validated
     103        \param genoname name of the genotype to be validated
     104        \retval GENOPER_OK must be returned in any case ("did my best to validate")*/
     105        virtual int validate(char *&geno, const char *genoname) { return GENOPER_NOOPER; }
     106
     107        /**Mutates a genotype. Mutation should always change something.
     108
     109        Avoid unnecessary calls in your code. Every genotype argument passed to this
     110        function is first checked, and validated if checkValidity() reported an error (or
     111        if there is no checkValidity() implemented). Every resulting genotype is subject
     112        to the same procedure, unless GENOPER_OPFAIL was returned. Thus you do not have
     113        to call these functions on input and output genotypes, because they are validated
     114        if needed.
     115        \param geno input/output: genotype to be mutated
     116        \param chg output: initialize with a value (in most cases 0..1) corresponding
     117        to the amount of genotype mutated. For example, it could be the number of changed
     118        genes divided by the total number of genes before mutation.
     119        \param chg method: initialize with the ID (number) of mutation method used.
     120        \retval GENOPER_OK
     121        \retval GENOPER_OPFAIL
     122        \sa
     123        Mutation example to illustrate the exchange of pointers for \e geno.
     124        The mutation adds random letter at the beginning or removes last letter from \e geno.
     125        \code
     126        {
     127                int len=strlen(geno);
     128                if (len==0 || random(2)==0) //add
     129                {
     130                        method=0;
     131                        char* mutated=(char*)malloc(mutated,len+2); //allocate for mutated genotype
     132                        mutated[0]='A'+random(10); //first char random
     133                        strcpy(mutated+1,geno); //the rest is original
     134                        free(geno); //must take care of the original allocation
     135                        geno=mutated;
     136                } else
     137                {
     138                        method=1;
     139                        geno[len-1]=0; //simply shorten the string - remove last char
     140                }
     141                chg=1.0/max(len,1); //estimation of mutation strength, divby0-safe
     142        } \endcode
     143        */
     144        virtual int mutate(char *&geno, float& chg, int &method) { method = -1; chg = -1; return GENOPER_NOOPER; }
     145
     146        /**Crosses over two genotypes. It is sufficient to return only one child (in \e g1) and set \e chg1 only, then \e g2 must equal "".
     147
     148        Avoid unnecessary calls in your code. Every genotype argument passed to this
     149        function is first checked, and validated if checkValidity() reported an error (or
     150        if there is no checkValidity() implemented). Every resulting genotype is subject
     151        to the same procedure, unless GENOPER_OPFAIL was returned. Thus you do not have
     152        to call these functions on input and output genotypes, because they are validated
     153        if needed.
     154        \param g1 input/output: parent1 genotype, initialize with child1
     155        \param g2 input/output: parent2 genotype, initialize with child2 if both children are available
     156        \param chg1 output: initialize with the fraction of parent1 genes in child1 (parent2 has the rest)
     157        \param chg2 output: initialize with the fraction of parent2 genes in child2 (parent1 has the rest)
     158        \retval GENOPER_OK
     159        \retval GENOPER_OPFAIL
     160        \sa mutate() for an example*/
     161        virtual int crossOver(char *&g1, char *&g2, float& chg1, float& chg2) { chg1 = chg2 = -1; return GENOPER_NOOPER; }
     162
     163        /**\return a pointer to the simplest genotype string*/
     164        virtual const char* getSimplest() { return NULL; }
     165
     166        /**You may want to have your genotype colored. This method provides desired character styles for genes.
     167        \param geno genotype
     168        \param pos 0-based char offset
     169        \retval number-encoded visual style (and validity) of the genotype char at \e geno[pos].
     170        Assume white background.
     171        \sa GENSTYLE_* macros, like GENSTYLE_BOLD*/
     172        virtual uint32_t style(const char *geno, int pos) { return GENSTYLE_RGBS(0, 0, 0, GENSTYLE_NONE); }
     173
     174        ///currently not used (similarity of two genotypes)
     175        virtual float similarity(const char*, const char*) { return GENOPER_NOOPER; }
     176        virtual ~GenoOperators() { if (mutation_method_names) { delete[]mutation_method_names; mutation_method_names = NULL; } }
     177        //   virtual char getFormat() {return 255;} //returns supported genotype format, for ex. '1'
     178        //   virtual int enabled() {return 1;} // should be enabled by default
     179
     180        /** \name Some helpful methods for you */
     181        //@{
     182        static int roulette(const double *probtab, const int count);    ///<returns random index according to probabilities in the \e probtab table or -1 if all probs are zero. \e count is the number of elements in \e probtab.
     183        static bool getMinMaxDef(ParamInterface *p, int propindex, double &mn, double &mx, double &def); ///<perhaps a more useful (higher-level) way to obtain min/max/def info for integer and double properties. Returns true if min/max/def was really available (otherwise it is just invented).
     184        static int selectRandomProperty(Neuro* n); ///<selects random property (either 0-based extraproperty of Neuro or 100-based property of its NeuroClass). -1 if Neuro has no properties.
     185        static double mutateNeuProperty(double current, Neuro *n, int propindex); ///<returns value \e current mutated for the property \e propindex of NeuroClass \e nc or for extraproperty (\e propindex - 100) of Neuro. Neuro is used as read-only. Give \e propindex == -1 to mutate connection weight (\e nc is then ignored).
     186        static bool mutatePropertyNaive(ParamInterface &p, int propindex); ///<creep-mutate selected property. Returns true when success. mutateProperty() should be used instead of this function.
     187        static bool mutateProperty(ParamInterface &p, int propindex); ///<like mutatePropertyNaive(), but uses special probability distributions for some neuron properties.
     188        static bool getMutatedProperty(ParamInterface &p, int i, double oldval, double &newval); ///<like mutateProperty(), but just returns \e newval, does not get nor set it using \e p.
     189        static double mutateCreepNoLimit(char type, double current, double mn, double mx); ///<returns \e current value creep-mutated with Gaussian distribution within [ \e mn , \e mx ] interval. Forced precision: 3 digits after comma. \e type must be either 'd' (integer) or 'f' (float/double).
     190        static double mutateCreep(char type, double current, double mn, double mx); ///<just as mutateCreepNoLimit(), but forces mutated value into the [mn,mx] range using the 'reflect' approach.
     191        static void setIntFromDoubleWithProbabilisticDithering(ParamInterface &p, int index, double value); ///<sets a double value in an integer field; when a value is non-integer, applies random "dithering" so that both lower and higher integer value have some chance to be set.
     192        static void linearMix(ParamInterface &p1, int i1, ParamInterface &p2, int i2, double proportion); ///<mixes i1'th and i2'th properties of p1 and p2; proportion should be within [0,1]; 0.5 causes both properties to become their average. For integer properties applies random "dithering" when necessary.
     193        static NeuroClass* getRandomNeuroClass(); ///<returns random neuroclass or NULL when no active classes.
     194        static int getRandomNeuroClassWithOutput(const vector<NeuroClass*>& NClist); //returns index of random neuroclass from the NClist or -1 (no neurons on the list that provide output)
     195        static int getRandomNeuroClassWithInput(const vector<NeuroClass*>& NClist); //returns index of random neuroclass from the NClist or -1 (no neurons on the list that want input(s))
     196        static int getRandomChar(const char *choices, const char *excluded); ///<returns index of a random character from 'choices' excluding 'excluded', or -1 when everything is excluded or 'choices' is empty.
     197        static NeuroClass* parseNeuroClass(char *&s); ///<returns longest matching neuroclass or NULL if the string does not begin with a valid neuroclass name. Advances \e s pointer.
     198        static Neuro* findNeuro(const Model *m, const NeuroClass *nc); ///<returns pointer to first Neuro of class \e nc, or NULL if there is no such Neuro.
     199        static int neuroClassProp(char *&s, NeuroClass *nc, bool also_v1_N_props = false); ///<returns 0-based property number for \e neuroclass, 100-based extraproperty number for Neuro, or -1 if the string does not begin with a valid property name. Advance \e s pointer if success.
     200        static bool isWS(const char c); ///<is \e c a whitespace char?
     201        static void skipWS(char *&s); ///<advances pointer \e s skipping whitespaces.
     202        static bool areAlike(char*, char*); ///<compares two text strings skipping whitespaces. Returns 1 when equal, 0 when different.
     203        static char* strchrn0(const char *str, char ch); ///<like strchr, but does not find zero char in \e str.
     204        static bool isNeuroClassName(const char firstchar); ///<determines if \e firstchar may start NeuroClass name. If not, it may start NeuroClass' (or Neuro's) property name.
     205        //@}
    206206};
    207207
Note: See TracChangeset for help on using the changeset viewer.