Changeset 1313 for cpp


Ignore:
Timestamp:
07/11/24 17:15:51 (4 months ago)
Author:
Maciej Komosinski
Message:

Color mutations in f1 and f4, and a new syntax for "allowed modifiers" (opposite to previous "excluded modifiers") with optional probabilities for each modifier

Location:
cpp/frams/genetics
Files:
7 edited

Legend:

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

    r1274 r1313  
    11// This file is a part of Framsticks SDK.  http://www.framsticks.com/
    2 // Copyright (C) 1999-2023  Maciej Komosinski and Szymon Ulatowski.
     2// Copyright (C) 1999-2024  Maciej Komosinski and Szymon Ulatowski.
    33// See LICENSE.txt for details.
    44
     
    189189        }
    190190
    191         char tmpLine[100];
     191        char tmpLine[256];
    192192        MultiRange range = C->genoRange;
    193193
     
    200200                        // new part object for firstend
    201201                        // coordinates are left to be computed by Model
    202                         sprintf(tmpLine, "fr=%g,ing=%g,as=%g",
    203                                 /*1.0/C->P.mass,*/ C->P.friction, C->P.ingestion, C->P.assimilation
     202                        sprintf(tmpLine, "fr=%g,ing=%g,as=%g,vr=%g,vg=%g,vb=%g",
     203                                /*1.0/C->P.mass,*/ C->P.friction, C->P.ingestion, C->P.assimilation, C->P.cred, C->P.cgreen, C->P.cblue
    204204                                //C->firstend.x, C->firstend.y, C->firstend.z
    205205                        );
     
    216216                }
    217217                // new part object for lastend
    218                 sprintf(tmpLine, "fr=%g,ing=%g,as=%g",
     218                sprintf(tmpLine, "fr=%g,ing=%g,as=%g,vr=%g,vg=%g,vb=%g",
    219219                        //C->lastend.x, C->lastend.y, C->lastend.z
    220                         /*"vol=" 1.0/C->P.mass,*/ C->P.friction, C->P.ingestion, C->P.assimilation
     220                        /*"vol=" 1.0/C->P.mass,*/ C->P.friction, C->P.ingestion, C->P.assimilation, C->P.cred, C->P.cgreen, C->P.cblue
    221221                );
    222222                C->p2_refno = addFromString(PartType, tmpLine, &range);
     
    241241                C->joint_refno = addFromString(JointType, tmpLine, &range);
    242242                if (C->joint_refno < 0) return -13;
     243                getJoint(C->joint_refno)->vcolor = (getPart(jj_p1_refno)->vcolor + getPart(jj_p2_refno)->vcolor) / 2; //joint gets the average color of both connected parts
    243244                this->checkpoint();
    244245        }
  • cpp/frams/genetics/f4/f4_general.cpp

    r1259 r1313  
    11// This file is a part of Framsticks SDK.  http://www.framsticks.com/
    2 // Copyright (C) 1999-2023  Maciej Komosinski and Szymon Ulatowski.
     2// Copyright (C) 1999-2024  Maciej Komosinski and Szymon Ulatowski.
    33// See LICENSE.txt for details.
    44
     
    14141414                        char *ptr = (char*)(genot + pos_inout);
    14151415                        string original = "";
    1416                         while (GenoOperators::strchrn0(all_modifiers_no_comma, *ptr)) //only processes a section of chars known in all_modifiers_no_comma, other characters will exit the loop
     1416                        while (GenoOperators::strchr_no0(all_modifiers_no_comma, *ptr)) //only processes a section of chars known in all_modifiers_no_comma, other characters will exit the loop
    14171417                        {
    14181418                                original += *ptr;
     
    14221422                        if (advanced > 0) //found modifiers
    14231423                        {
    1424                                 string simplified = GenoOperators::simplifiedModifiers(original);
     1424                                string simplified = GenoOperators::simplifiedModifiers(original, F14_MODIFIERS_COLOR);
    14251425                                // add a node for each char in "simplified"
    14261426                                for (size_t i = 0; i < simplified.length(); i++)
    14271427                                {
    1428                                         int pos = GenoOperators::strchrn0(genot + pos_inout, simplified[i]) - genot; //unnecessarily finding the same char, if it occurrs multiple times in simplified
     1428                                        int pos = GenoOperators::strchr_no0(genot + pos_inout, simplified[i]) - genot; //unnecessarily finding the same char, if it occurrs multiple times in simplified
    14291429                                        f4_Node *node = new f4_Node(simplified[i], par, pos); //location is approximate. In the simplification process we don't trace where the origin(s) of the simplified[i] gene were. We provide 'pos' as the first occurrence of simplified[i] (for example, all 'L' will have the same location assigned, but at least this is where 'L' occurred in the genotype, so in case of any modification of a node (repair, removal, whatever... even mapping of genes) the indicated gene will be one of the responsible ones)
    14301430                                        par = node;
  • cpp/frams/genetics/f4/f4_oper.cpp

    r1298 r1313  
    11// This file is a part of Framsticks SDK.  http://www.framsticks.com/
    2 // Copyright (C) 1999-2023  Maciej Komosinski and Szymon Ulatowski.
     2// Copyright (C) 1999-2024  Maciej Komosinski and Szymon Ulatowski.
    33// See LICENSE.txt for details.
    44
     
    1717// TODO add mapping genotype character ranges for neural [connections]
    1818// TODO The f0 genotypes for /*4*/<<RX>X>X> and RX(X,X) are identical, but if you replace R with C or Q, there are small differences (they were present both before and after the change in C,Q effects in the f1 converter in 2023-06, see conv_f1_f0_cq_influence) - check why (modifiers affecting cells=sticks are applied differently or skip some initial sticks?) and perhaps unify with f1?
    19 // TODO F4_SIMPLIFY_MODIFIERS in f4_general.cpp: currently it works while parsing (which is a bit "cheating": we get a phenotype that is a processed version of the genotype, thus some changes in modifiers in the genotype have no effect on its phenotype). Another (likely better) option, instead of simplifying while parsing, would be during mutations (like it is done in f1): when mutations add/modify/remove a modifier node, they could "clean" the tree by simplifying modifiers on the same subpath just as GenoOperators::simplifiedModifiers() does. This way, simplifying would be only performed when we actually modify a part of a genotype, not each time we interpret it, and there would be no hidden mechanism: all visible genes would have an expected effect on the phenotype.
     19// TODO F4_SIMPLIFY_MODIFIERS in f4_general.cpp: currently it works while parsing (which is a bit "cheating": we get a phenotype that is a processed version of the genotype, thus some changes in modifiers in the genotype have no effect on its phenotype). This is especially noticeable with color modifiers, where simplification only accepts MAX_NUMBER_SAME_TYPE_COLOR. Another (likely better) option, instead of simplifying while parsing, would be during mutations (like it is done in f1): when mutations add/modify/remove a modifier node, they could "clean" the tree by simplifying modifiers on the same subpath just as GenoOperators::simplifiedModifiers() does. This way, simplifying would be only performed when we actually modify a part of a genotype, not each time we interpret it, and there would be no hidden mechanism: all visible genes would have an expected effect on the phenotype. In other words, if a genotype happened to have more modifiers of the same type than allowed by GenoOperators::simplifiedModifiers(), they would all be effective (like in f1) and not silently ignored when interpreting that genotype. For example in /*4*/GGGgGX> due to simplifying modifiers (removing the oldest), only the last G remains effective when MAX_NUMBER_SAME_TYPE_COLOR=1, and it is impossible to adjust colors precisely even by manually editing the genotype - like it is in f1, even though the same simplifying function is used, just in a different moment.
    2020// TODO improve the way modifiers are handled in the f4->f1 approximate converter (used extremely rarely just for illustration)
    2121
     
    3232
    3333
    34 const char *Geno_f4::all_modifiers = F14_MODIFIERS ","; //comma in f4 is handled the same way (simple node, F4_ADD_SIMP) as modifiers. See also all_modifiers_no_comma in f4_general.cpp.
    3534
    3635// codes that can be changed (apart from being added/deleted)
     
    5655
    5756        { "f4_mut_max_rep", 1, 0, "Maximum number for '#' repetitions", "d 2 20 6", FIELD(mut_max_rep), "Maximum allowed number of repetitions for the '#' repetition gene", },
    58         { "f4_mut_exmod", 1, 0, "Excluded modifiers", "s 0 30", FIELD(excluded_modifiers), "Modifiers that will not be added nor deleted during mutation\n(all: " F14_MODIFIERS ")", },
     57        { "f4_mut_modifiers", 1, 0, "Allowed modifiers", "s 0 100", FIELD(allowed_modifiers), "Modifier symbols that will be added or deleted during mutation\n(from the full set: " F14_MODIFIERS ").\n\nYou may use the extended syntax: after every allowed symbol, you may include its probability value in parentheses.\nWithout parentheses, all allowed symbols behave as if they had (1.0) appended.\nIf you include (0.0) after a symbol, this bans that symbol as if it was not present in this string.", },
    5958        { 0, },
    6059};
     
    8483void Geno_f4::setDefaults()
    8584{
    86         excluded_modifiers = F14_MODIFIERS_RARE F14_MODIFIERS_VISUAL;
     85        allowed_modifiers = F14_MODIFIERS_BASIC F14_MODIFIERS_COLOR_SPORADIC;
    8786}
    8887
     
    183182                        f4_Node *node_new = NULL; //stick or neuron or neural connection
    184183                        if (rndDouble(1) < STICK_OR_NEURON)
     184                        {
    185185                                node_new = new f4_Node('X', node_new_div, node_new_div->pos);
     186                                //now add one color modifier before this new X, just as in f1's Geno_f1::addMutationColoredX()
     187                                if (prob[F4_ADD] > 0 && probadd[F4_ADD_SIMP] > 0) //user wants modifier mutations, so we are allowed to prepend a random color modifier to "X"
     188                                {
     189                                        char color_mod = GenoOperators::getRandomColorModifier(allowed_modifiers.c_str(), F14_MODIFIERS_COLOR); //may return 0 if no color modifiers available
     190                                        if (color_mod != 0)
     191                                        {
     192                                                //adding a new color modifier node just as in the F4_ADD_SIMP case later below.
     193                                                node_new->parent->removeChild(node_new);
     194                                                f4_Node *n2 = new f4_Node(color_mod, node_new->parent, node_new->parent->pos);
     195                                                n2->addChild(node_new);
     196                                                node_new->parent = n2;
     197                                        }
     198                                }
     199                        }
    186200                        else
    187201                        {
     
    220234                                }
    221235                        }
    222                         new f4_Node('>', node_new, node_new->pos); //adds to node_new
     236                        new f4_Node('>', node_new, node_new->pos); //adds '>' to node_new
    223237                        node_mutated->parent = node_new_div;
    224238                        // now, swap children with 50% chance
     
    294308                {
    295309                        // add simple node
    296                         int modifier_index = GenoOperators::getRandomChar(all_modifiers, excluded_modifiers.c_str());
    297                         if (modifier_index < 0)
     310                        SString allowed_modifiers_and_comma = allowed_modifiers + ","; // traditionally, in f4, comma was treated here equally with modifiers
     311                        char modifier = GenoOperators::getRandomModifier(allowed_modifiers_and_comma.c_str());
     312                        if (modifier == 0)
    298313                                return GENOPER_OPFAIL;
    299314                        node_mutated->parent->removeChild(node_mutated);
    300315                        // old source: choose a simple node from ADD_SIMPLE_CODES
    301316                        //f4_Node *n2 = new f4_Node(ADD_SIMPLE_CODES[rndUint(strlen(ADD_SIMPLE_CODES))], node_mutated->parent, node_mutated->parent->pos);
    302                         f4_Node *n2 = new f4_Node(all_modifiers[modifier_index], node_mutated->parent, node_mutated->parent->pos);
     317                        f4_Node *n2 = new f4_Node(modifier, node_mutated->parent, node_mutated->parent->pos);
    303318                        n2->addChild(node_mutated);
    304319                        node_mutated->parent = n2;
     
    722737        else if (strchr(">", ch))                style = GENSTYLE_RGBS(0, 0, 100, GENSTYLE_NONE);
    723738        else if (strchr(STYL4CAT_DIGIT, ch))     style = GENSTYLE_CS(GENCOLOR_NUMBER, GENSTYLE_NONE);
    724         else if (strchr(STYL4CAT_MODIFIC, ch))   style = GENSTYLE_RGBS(100, 100, 100, GENSTYLE_NONE);
     739        else if (strchr(STYL4CAT_MODIFIC, ch))
     740        {
     741                if (strchr(F14_MODIFIERS_COLOR, ch)) //color modifier - less important so less visible on white
     742                        style = GENSTYLE_RGBS(200, 200, 200, GENSTYLE_NONE);
     743                else //non-color modifier
     744                        style = GENSTYLE_RGBS(100, 100, 100, GENSTYLE_NONE);
     745        }
    725746        else if (strchr(STYL4CAT_NEUMOD, ch))    style = GENSTYLE_RGBS(0, 150, 0, GENSTYLE_NONE);
    726747        if (isalpha(ch))
  • cpp/frams/genetics/f4/f4_oper.h

    r1234 r1313  
    11// This file is a part of Framsticks SDK.  http://www.framsticks.com/
    2 // Copyright (C) 1999-2023  Maciej Komosinski and Szymon Ulatowski.
     2// Copyright (C) 1999-2024  Maciej Komosinski and Szymon Ulatowski.
    33// See LICENSE.txt for details.
    44
     
    5959        paInt mut_max_rep;                ///maximum allowed number of repetitions for the '#' repetition gene
    6060
    61         SString excluded_modifiers;       ///<Modifiers that are excluded in mutation process
    62         static const char *all_modifiers;
     61        SString allowed_modifiers;        //to be used in mutations
    6362
    6463private:
  • cpp/frams/genetics/geneprops.h

    r1305 r1313  
    11// This file is a part of Framsticks SDK.  http://www.framsticks.com/
    2 // Copyright (C) 1999-2023  Maciej Komosinski and Szymon Ulatowski.
     2// Copyright (C) 1999-2024  Maciej Komosinski and Szymon Ulatowski.
    33// See LICENSE.txt for details.
    44
     
    1313
    1414
    15 #define F14_MODIFIERS_VISUAL "DdGgBb"
     15#define F14_MODIFIERS_BASIC "LlRrCcQqFfMm"
    1616#define F14_MODIFIERS_RARE "EeWwSsAaIi" //An expdef would need to handle many of these properly/specifically to ensure reasonable behavior, and hardly any expdef does. Modifying initial energy of a creature as a result of its genes (Ee) is in general not a good idea, but may make sense in some specific competitive biological simulations. Weight (Ww) works only in water, and in water sinking/going up should usually be caused by real "intentional" activity of a creature, not by its inherited weight. Stamina (Ss) is no longer needed as destructive collisions are not supported, and even if they were, some expdef would need to impose reasonable restrictions on the value of this parameter (e.g. similar to normalizeBiol4()) so there is some cost associated with it, and the specific consequences of destructions should be defined as needed. For assimilation (Aa), there is a dedicated parameter in CreaturesGroup. Ingestion (Ii) influences how fast energy is transferred to Parts of a creature, and optimizing this property may make sense in experiments where energy is present in the environment and can be ingested - if needed, this modifier should be enabled for mutation.
    17 #define F14_MODIFIERS "LlRrCcQqFfMm" F14_MODIFIERS_RARE F14_MODIFIERS_VISUAL
     17#define F14_MODIFIERS_COLOR "DdGgBb"
     18#define F14_MODIFIERS_COLOR_SPORADIC "D(0.01)d(0.01)G(0.01)g(0.01)B(0.01)b(0.01)" //add a small chance so that color mutations can rarely occur. Functionally they are neutral so we do not want to waste computational resources on creating and evaluating such duplicate individuals, but it is nice to have visually distinct "lineages" by allowing propagated color genes to be extremely rarely modified. Also, if these color modifiers have positive probability, all newly created sticks are assigned a random color immediately on creation.
     19
     20#define F14_MODIFIERS     F14_MODIFIERS_BASIC  F14_MODIFIERS_RARE  F14_MODIFIERS_COLOR
    1821
    1922
  • cpp/frams/genetics/genooperators.cpp

    r1287 r1313  
    11// This file is a part of Framsticks SDK.  http://www.framsticks.com/
    2 // Copyright (C) 1999-2023  Maciej Komosinski and Szymon Ulatowski.
     2// Copyright (C) 1999-2024  Maciej Komosinski and Szymon Ulatowski.
    33// See LICENSE.txt for details.
    44
     
    5656        for (sum = 0, i = 0; i < count; i++) { sum += probtab[i]; if (sel < sum) return i; }
    5757        return -1;
     58}
     59
     60int GenoOperators::roulette(const vector<double> &probtab)
     61{
     62        return roulette(probtab.data(), (int)probtab.size());
    5863}
    5964
     
    461466}
    462467
    463 char *GenoOperators::strchrn0(const char *str, char ch)
     468char *GenoOperators::strchr_no0(const char *str, char ch)
    464469{
    465470        return ch == 0 ? NULL : strchr((char *)str, ch);
    466471}
    467472
    468 int GenoOperators::getRandomChar(const char *choices, const char *excluded)
    469 {
    470         int allowed_count = 0;
    471         for (size_t i = 0; i < strlen(choices); i++) if (!strchrn0(excluded, choices[i])) allowed_count++;
    472         if (allowed_count == 0) return -1; //no char is allowed
    473         int rnd_index = rndUint(allowed_count) + 1;
    474         allowed_count = 0;
    475         for (size_t i = 0; i < strlen(choices); i++)
    476         {
    477                 if (!strchrn0(excluded, choices[i])) allowed_count++;
    478                 if (allowed_count == rnd_index) return int(i);
    479         }
    480         return -1; //never happens
     473double GenoOperators::probOfModifier(const char* mod_def)
     474{
     475        if (*(mod_def + 1) == '(') //the special syntax with the appended probability value in (...)
     476                return std::atof(mod_def + 2); //0.0 when no valid number
     477        return 1.0;
     478}
     479
     480char GenoOperators::getRandomModifier(const char *choices)
     481{
     482        static const char* EXTRA_CHARS = "().0123456789";
     483        // this function assumes that EXTRA_CHARS are only used for the special probabilities syntax in "choices", not as valid choice characters.
     484        vector<char> allowed; //this could be determined only once for a given "choices", as long as the effect of "choices" is deterministic (i.e., "choices" does not include probabilities)
     485        size_t choices_len = strlen(choices);
     486        allowed.reserve(choices_len); //max size, avoid reallocations later
     487        for (size_t i = 0; i < choices_len; i++)
     488        {
     489                if (strchr(EXTRA_CHARS, choices[i])) continue; //skip parentheses and numbers
     490                double prob = probOfModifier(&choices[i]);
     491                if (prob == 1.0 || rndDouble(1) < prob)
     492                        allowed.push_back(choices[i]);
     493        }
     494        if (allowed.size() == 0) return 0; //no char is allowed
     495        return allowed[rndUint(allowed.size())];
     496}
     497
     498char GenoOperators::getRandomColorModifier(const char *choices, const char *color_modifiers)
     499{
     500        vector<char> allowed_colors;
     501        vector<double> allowed_probs;
     502        size_t colors_len = strlen(color_modifiers);
     503        allowed_colors.reserve(colors_len); //max size, avoid reallocations later
     504        allowed_probs.reserve(colors_len); //max size, avoid reallocations later
     505        for (size_t i = 0; i < colors_len; i++) //for all known color modifiers...
     506        {
     507                const char *pos = strchr(choices, color_modifiers[i]); //...search in "choices" - i.e., in currently set active modifiers. Note that "choices" may use an extended syntax with numbers and parentheses, such as qM(0.1)Dm(0.1)dG(0.2)C
     508                if (pos) //found the color modifier in choices
     509                {
     510                        allowed_colors.push_back(*pos);
     511                        allowed_probs.push_back(probOfModifier(pos));
     512                }
     513        }
     514        // the above "parsing" part could be done only once "choices" changes, not every time we want to get a random color modifier...
     515        int idx = roulette(allowed_probs);
     516        return idx < 0 ? 0 : allowed_colors[idx];
    481517}
    482518
     
    544580}
    545581
    546 string GenoOperators::simplifiedModifiers(const string & original)
     582string GenoOperators::simplifiedModifiers(const string & original, const char* colorgenes)
    547583{
    548584        const int MAX_NUMBER_SAME_TYPE = 5; // max. number of modifiers of each type (case-insensitive). The more characters, the closer we can get to min and max values of a given property at the expense of the length of evolved genotypes. 5 is "close enough", but how close we get to the extreme also depends on the initial value of a given property, which is not always exactly in the middle of min and max. rR is treated separately in simplification because their influence follows different (i.e., simple additive) logic - so the simplifiedModifiersFixedOrder() logic with cancelling out antagonistic modifiers would be appropriate for rR.
     585        const int MAX_NUMBER_SAME_TYPE_COLOR = 1; //color does not affect fitness and is used purely for aesthetics, so allow at most 1 char for each r,g,b channel - we get very low resolution of colors (only 3*3*3 combinations), but we spare the genotype length and limit bloat
    549586        int counter[256] = {}; //initialize with zeros; 256 is unnecessarily too big and redundant, but enables very fast access (indexed directly by the ascii code)
    550587        string simplified = "";
     
    556593                unsigned char lower = std::tolower(c);
    557594                counter[lower]++;
    558                 if (counter[lower] <= MAX_NUMBER_SAME_TYPE) //get rid of modifiers that are too numerous, but get rid of the first ones in the string (="oldest", the last ones looking from the end), because their influence on the parameter value is the smallest
     595                int MAX_NUMBER = strchr(colorgenes, c) != NULL ? MAX_NUMBER_SAME_TYPE_COLOR : MAX_NUMBER_SAME_TYPE;
     596                if (counter[lower] <= MAX_NUMBER) //get rid of modifiers that are too numerous - get rid of the first ones in the string (="oldest", the last ones looking from the end), because their influence on the parameter value is the smallest
    559597                        simplified += c;
    560598        }
  • cpp/frams/genetics/genooperators.h

    r1273 r1313  
    11// This file is a part of Framsticks SDK.  http://www.framsticks.com/
    2 // Copyright (C) 1999-2023  Maciej Komosinski and Szymon Ulatowski.
     2// Copyright (C) 1999-2024  Maciej Komosinski and Szymon Ulatowski.
    33// See LICENSE.txt for details.
    44
     
    144144        virtual int mutate(char *&geno, float& chg, int &method) { method = -1; chg = -1; return GENOPER_NOOPER; }
    145145
    146         /**Crosses over two genotypes. It is sufficient to return only one child (in \a g1) and set \a chg1 only, then \a g2 must equal "".
     146        /**Crosses over two genotypes. It is sufficient to return only one child (in \a g1) and set \a chg1 only, then \a g2 must be "".
    147147
    148148        Avoid unnecessary calls in your code. Every genotype argument passed to this
     
    183183        static const int NEUROCLASS_PROP_OFFSET = 100; //a NeuroClass property is identified by some functions below as a single-value integer index, yet a property is either "standard" or "extra" (two separate lists), hence this offset to tell one case from the other.
    184184
    185         static int roulette(const double *probtab, const int count);    ///<returns random index according to probabilities in the \a probtab table or -1 if all probs are zero. \a count is the number of elements in \a probtab.
     185        static int roulette(const double *probtab, const int count); ///<returns a random index according to probabilities in the \a probtab table or -1 if all probs are zero. \a count is the number of elements in \a probtab.
     186        static int roulette(const vector<double> &probtab); ///<returns a random index according to probabilities in the \a probtab table or -1 if all probs are zero.
    186187        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).
    187188        static bool mutateRandomNeuroClassProperty(Neuro* n); ///<high-level neuron mutation function, will select and mutate a random property of Neuron's NeuroClass. Returns true if successful and some property was actually mutated. Could return false when the NeuroClass of the Neuron have no properties, or when a randomly selected property was not suitable for mutation (for example a string or another non-number type).
     
    215216        static void skipWS(char *&s); ///<advances pointer \a s skipping whitespaces.
    216217        static bool areAlike(char*, char*); ///<compares two text strings skipping whitespaces. Returns 1 when equal, 0 when different.
    217         static char* strchrn0(const char *str, char ch); ///<like strchr, but does not find ascii=0 char in \a str.
    218 
    219         static int getRandomChar(const char *choices, const char *excluded); ///<returns index of a random character from \a choices excluding \a excluded, or -1 when everything is excluded or \a choices is empty.
     218        static char* strchr_no0(const char *str, char ch); ///<like strchr, but does not find ascii=0 char in \a str.
     219
     220        static double probOfModifier(const char* mod_def); //returns a probability of a modifier: either 1.0 (default) or parsed value if the probability is given in the appended parentheses (...). For example, "G(0.3)" will return 0.3, and "G" will return 1.0.
     221        static char getRandomModifier(const char *choices); ///<returns a random character from \a choices (note that the special syntax with probabilities in parentheses is supported), or 0 when \a choices is empty or probabilities were insufficient for a random chance to choose some character.
     222        static char getRandomColorModifier(const char *choices, const char *color_modifiers); //finds all color_modifiers in choices and returns a color modifier drawn randomly proportionally to the optional probabilities defined in choices. Returns 0 when \a choices does not have any color modifier with a positive probability.
    220223        static string simplifiedModifiers_rR(const string& str); ///<finds all 'r' and 'R' in \a str and returns the shortest sequence of 'r' and 'R that is equivalent to all these found in \a str.
    221224        static string simplifiedModifiersFixedOrder(const char *str_of_char_pairs, vector<int> &char_counts); ///<returns a sequence of chars from \a str_of_char_pairs based on how many times each char occurred in \a char_counts. Assume that an even-index char and the following odd-index char have the opposite influence, so they cancel out. We don't use this function, because a fixed order imposed by this function means that the number of different parameter values produced by a sequence of modifiers is lowered (N same-letter upper- and lower-case chars yield only 2*N different values). Due to how modifiers work, the effect of aaA, aAa, Aaa etc. is different (N same-letter upper- and lower-case chars yield 2^N different values), so simplifying modifiers should not impose any order, should not interfere with their original order, and should not cancel out antagonistic modifiers - see \a simplifiedModifiers() and geneprops_test.cpp.
    222225        //@}
    223         static string simplifiedModifiers(const string &original); ///<from the \a original sequence removes modifiers that are too numerous (exceeding a defined threshold number), starting the removal from the least-significant, leftmost (="oldest" when interpreting the sequence from left to right) ones. Contrary to \a simplifiedModifiersFixedOrder(), this kind of simplification preserves 2^N different sequences for each upper/lower-case modifier and thus 2^N different values of a given property (see geneprops.cpp), but the values resulting from these sequences constitute a landscape not as easy for optimization as in the case of 2*N, where the effect of each mutation could be independent and additive (no epistasis). So for a given sequence length, the 2^N case allows for a higher resolution at the cost of a more rugged fitness landscape than the 2*N case.
     226        static string simplifiedModifiers(const string &original, const char* colorgenes); ///<from the \a original sequence removes modifiers that are too numerous (exceeding a defined threshold number), starting the removal from the least-significant, leftmost (="oldest" when interpreting the sequence from left to right) ones. Contrary to \a simplifiedModifiersFixedOrder(), this kind of simplification preserves 2^N different sequences for each upper/lower-case modifier and thus 2^N different values of a given property (see geneprops.cpp), but the values resulting from these sequences constitute a landscape not as easy for optimization as in the case of 2*N, where the effect of each mutation could be independent and additive (no epistasis). So for a given sequence length, the 2^N case allows for a higher resolution at the cost of a more rugged fitness landscape than the 2*N case.
    224227};
    225228
Note: See TracChangeset for help on using the changeset viewer.