Changeset 1273 for cpp/frams/genetics/fL/fL_oper.cpp

Timestamp:

09/09/23 15:10:49 (8 months ago)

Author:

Maciej Komosinski

Message:

fH, fB, fL: improved default parameter values, syntax coloring and code logic

File:

• cpp/frams/genetics/fL/fL_oper.cpp (modified) (16 diffs)

cpp/frams/genetics/fL/fL_oper.cpp

@@ -1 +1 @@
 // This file is a part of Framsticks SDK.  http://www.framsticks.com/
-// Copyright (C) 1999-2020  Maciej Komosinski and Szymon Ulatowski.
+// Copyright (C) 1999-2023  Maciej Komosinski and Szymon Ulatowski.
 // See LICENSE.txt for details.
 
@@ -8 +8 @@
 #include <algorithm>
 
+
+
+//TODO fix: occasionally happens (note that fL extensively uses Param parsing, see fL_word_paramtab): Param.loadSingleLine: Unknown property 'Word.w0(n1' (ignored)
+//TODO reconsider and maybe improve sensor and effector embodiment; see "MacKo 2023-07: embody" in fL_general.cpp.
+
+
+
 #define FIELDSTRUCT Geno_fL
 static ParamEntry geno_fL_paramtab[] =
@@ -14 +21 @@
         {"Genetics: fL: Probabilities of mutating axiom and rules", },
         {"Genetics: fL: Probabilities of mutation types", },
-        {"fL_maxdefinedwords", 0, 0, "Maximum number of defined words", "d 0 100 10", FIELD(maxdefinedwords), "Maximum number of words that can be defined in L-System", },
-
-        {"fL_axm_mut_prob", 1, 0, "Axiom mutation", "f 0 1 0.2", FIELD(groupprobabilities[FL_AXM_WORD_MUT_PROB]), "Probability of performing mutation operations on axiom", },
-        {"fL_rul_mut_prob", 1, 0, "Rule's successor mutation", "f 0 1 0.8", FIELD(groupprobabilities[FL_RUL_WORD_MUT_PROB]), "Probability of performing mutation operations on the successor of random rule", },
-
-        {"fL_mut_addition", 2, 0, "Addition of word to sequence", "f 0 1 0.2", FIELD(operations[FL_ADD_WORD]), "Probability of adding random existing word to the axiom or one of successors", },
-
-        {"fL_mut_add_stick", 2, 0, " - addition of stick", "f 0 1 0.2", FIELD(addtypes[FL_ADD_STICK]), "Probability of adding stick", },
-        {"fL_mut_add_neuro", 2, 0, " - addition of neuron", "f 0 1 0.2", FIELD(addtypes[FL_ADD_NEURO]), "Probability of adding neuron", },
-        {"fL_mut_add_conn", 2, 0, " - addition of neuron connection", "f 0 1 0.2", FIELD(addtypes[FL_ADD_CONN]), "Probability of adding connection", },
-        {"fL_mut_add_rot", 2, 0, " - addition of rotation words", "f 0 1 0.2", FIELD(addtypes[FL_ADD_ROT]), "Probability of adding one of rotation words", },
-        {"fL_mut_add_branch", 2, 0, " - addition of branched stick", "f 0 1 0.2", FIELD(addtypes[FL_ADD_BRANCH]), "Probability of adding branch with rotation and stick", },
-        {"fL_mut_add_other", 2, 0, " - addition of defined words", "f 0 1 0.4", FIELD(addtypes[FL_ADD_OTHER]), "Probability of adding other word, defined in genotype", },
-
-        {"fL_mut_worddefaddition", 2, 0, "Addition of new word definition", "f 0 1 0.05", FIELD(operations[FL_ADD_WDEF]), "Probability of adding new word definition to the genotype", },
-        {"fL_mut_ruleaddition", 2, 0, "Addition of new rule definition", "f 0 1 0.1", FIELD(operations[FL_ADD_RULE]), "Probability of adding new rule definition for existing word", },
-        {"fL_mut_rulecond", 2, 0, "Modification of rule condition", "f 0 1 0.1", FIELD(operations[FL_CHG_COND]), "Probability of modifying random rule condition", },
-
-        {"fL_mut_changeword", 2, 0, "Change of random word", "f 0 1 0.3", FIELD(operations[FL_CHG_WORD]), "Probability of changing word name or formula of a random word from axiom or one of successors", },
-        {"fL_mut_changeword_formula", 2, 0, " - change of formula", "f 0 1 0.7", FIELD(chgoperations[FL_CHG_WORD_FORMULA]), "Probability of changing formula in word", },
-        {"fL_mut_changeword_name", 2, 0, " - change of name", "f 0 1 0.3", FIELD(chgoperations[FL_CHG_WORD_NAME]), "Probability of changing name in word", },
-
-        {"fL_mut_changeiter", 2, 0, "Change of L-System iteration", "f 0 1 0.3", FIELD(operations[FL_CHG_ITER]), "Probability of changing number of iterations of L-Systems", },
-        {"fL_mut_changeiter_step", 2, 0, "Step of iteration changing", "f 0 1 1.0", FIELD(iterchangestep), "Minimal step that should be used for changing iterations in L-Systems", },
-        {"fL_mut_deletion", 2, 0, "Deletion of random word", "f 0 1 0.2", FIELD(operations[FL_DEL_WORD]), "Probability of deleting random word from axiom or random successor (also deletes rule if there is only one word in successor)", },
+        {"fL_maxdefinedwords", 0, 0, "Maximum number of defined words", "d 0 100 10", FIELD(maxdefinedwords), "Maximum number of words that can be defined in the L-System", },
+
+        {"fL_axm_mut_prob", 1, 0, "Axiom mutation", "f 0 100 4", FIELD(groupprobabilities[FL_AXM_WORD_MUT_PROB]), "Probability of performing mutation operations on axiom", },
+        {"fL_rul_mut_prob", 1, 0, "Rule's successor mutation", "f 0 100 1", FIELD(groupprobabilities[FL_RUL_WORD_MUT_PROB]), "Probability of performing mutation operations on the successor of a random rule", },
+
+        {"fL_mut_addition", 2, 0, "Addition of a word to a sequence", "f 0 100 4", FIELD(operations[FL_ADD_WORD]), "Probability of adding a random existing word to the axiom or to one of successors", },
+
+        {"fL_mut_add_stick", 2, 0, " - addition of a stick", "f 0 100 1", FIELD(addtypes[FL_ADD_STICK]), "Probability of adding a stick", },
+        {"fL_mut_add_neuro", 2, 0, " - addition of a neuron", "f 0 100 4", FIELD(addtypes[FL_ADD_NEURO]), "Probability of adding a neuron", },
+        {"fL_mut_add_conn", 2, 0, " - addition of a neuron connection", "f 0 100 4", FIELD(addtypes[FL_ADD_CONN]), "Probability of adding a neuron connection", },
+        {"fL_mut_add_rot", 2, 0, " - addition of rotation words", "f 0 100 2", FIELD(addtypes[FL_ADD_ROT]), "Probability of adding one of rotation words", },
+        {"fL_mut_add_branch", 2, 0, " - addition of a branched stick", "f 0 100 4", FIELD(addtypes[FL_ADD_BRANCH]), "Probability of adding a branch with a rotation and a stick", },
+        {"fL_mut_add_other", 2, 0, " - addition of defined words", "f 0 100 1", FIELD(addtypes[FL_ADD_OTHER]), "Probability of adding another word defined in the genotype", },
+
+        {"fL_mut_worddefaddition", 2, 0, "Addition of a new word definition", "f 0 100 1", FIELD(operations[FL_ADD_WDEF]), "Probability of adding a new word definition to the genotype", },
+        {"fL_mut_ruleaddition", 2, 0, "Addition of a new rule definition", "f 0 100 1", FIELD(operations[FL_ADD_RULE]), "Probability of adding a new rule definition for an existing word", },
+        {"fL_mut_rulecond", 2, 0, "Modification of a rule condition", "f 0 100 1", FIELD(operations[FL_CHG_COND]), "Probability of modifying a random rule condition", },
+
+        {"fL_mut_changeword", 2, 0, "Change a random word", "f 0 100 4", FIELD(operations[FL_CHG_WORD]), "Probability of changing a word name or a formula of a random word from an axiom or one of successors", },
+        {"fL_mut_changeword_formula", 2, 0, " - change of a formula", "f 0 100 4", FIELD(chgoperations[FL_CHG_WORD_FORMULA]), "Probability of changing a formula in a word", },
+        {"fL_mut_changeword_name", 2, 0, " - change of a name", "f 0 100 2", FIELD(chgoperations[FL_CHG_WORD_NAME]), "Probability of changing a name in a word", },
+
+        {"fL_mut_changeiter", 2, 0, "Change the number of iterations", "f 0 100 1", FIELD(operations[FL_CHG_ITER]), "Probability of changing the number of iterations of the L-System", },
+        {"fL_mut_changeiter_step", 2, 0, "Step of the iteration change", "f 0 1 1.0", FIELD(iterchangestep), "The minimal step that should be used for changing iterations in the L-System", },
+        {"fL_mut_deletion", 2, 0, "Deletion of a random word", "f 0 100 4", FIELD(operations[FL_DEL_WORD]), "Probability of deleting a random word from an axiom or a random successor (also deletes the rule if there is only one word in the successor)", },
         { 0, },
 };
@@ -66 +73 @@
         if (builder.countSticksInSequence(&builder.genotype) == 0)
         {
-                return GENOPER_OPFAIL;
+                return 1;
         }
         double neededtime = 0;
         Model *m = builder.developModel(neededtime);
-        if (!m)
-        {
-                return GENOPER_OPFAIL;
+        if (m == NULL)
+        {
+                return 1;
         }
         if (!m->isValid())
         {
                 delete m;
-                return GENOPER_OPFAIL;
+                return 1;
         }
         delete m;
-
 
         return GENOPER_OK;
@@ -93 +99 @@
         if (err != 0)
         {
-                return err;
+                return GENOPER_OK;
         }
         double neededtime = 0;
         Model *m = builder.developModel(neededtime);
+        if (m == NULL)
+        {
+                return GENOPER_OK;
+        }
         if (!m->isValid())
         {
                 delete m;
-                return GENOPER_OPFAIL;
+                return GENOPER_OK;
         }
         if (neededtime != builder.time)
@@ -171 +181 @@
         else
         {
-                int rid = rndUint(creature->rules.size());
+                int rid = rndUint((unsigned int)creature->rules.size());
                 list = &creature->rules[rid]->objsucc;
                 numparams = creature->rules[rid]->objpred->npar;
@@ -303 +313 @@
                 if (creature->rules.size() > 0)
                 {
-                        int ruleid = rndUint(creature->rules.size());
+                        int ruleid = rndUint((unsigned int)creature->rules.size());
                         if (!creature->rules[ruleid]->condeval)
                         {
@@ -340 +350 @@
                 if (wordswithnorules.size() > 0)
                 {
-                        int predid = rndUint(wordswithnorules.size());
+                        int predid = rndUint((unsigned int)wordswithnorules.size());
                         fL_Rule *newrule = new fL_Rule(0, 0);
                         fL_Word *pred = new fL_Word();
@@ -352 +362 @@
                 else if (creature->rules.size() > 0)
                 {
-                        int ruleid = rndUint(creature->rules.size());
+                        int ruleid = rndUint((unsigned int)creature->rules.size());
                         fL_Rule *newrule = new fL_Rule(0, 0);
                         fL_Word *pred = new fL_Word();
@@ -455 +465 @@
                 else
                 {
-                        int rndid = rndUint(list->size());
+                        int rndid = rndUint((unsigned int)list->size());
                         std::list<fL_Word *>::iterator it = list->begin();
                         std::advance(it, rndid);
@@ -482 +492 @@
                 int tmp = 0;
                 std::list<fL_Word *> *list = selectRandomSequence(creature, numpars, tmp);
-                int rndid = rndUint(list->size());
+                int rndid = rndUint((unsigned int)list->size());
                 std::list<fL_Word *>::iterator it = list->begin();
                 std::advance(it, rndid);
@@ -531 +541 @@
                 int tmp = 0;
                 std::list<fL_Word *> *list = selectRandomSequence(creature, numpars, tmp);
-                int rndid = rndUint(list->size());
+                int rndid = rndUint((unsigned int)list->size());
                 std::list<fL_Word *>::iterator selectedword = list->begin();
                 std::advance(selectedword, rndid);
@@ -545 +555 @@
                         int numpars = 0;
                         std::list<fL_Word *> *list = selectRandomSequence(creature, numpars, tmp);
-                        int rndid = rndUint(list->size());
+                        int rndid = rndUint((unsigned int)list->size());
                         std::list<fL_Word *>::iterator it = list->begin();
                         std::advance(it, rndid);
@@ -577 +587 @@
                                 if (available.size() > 0)
                                 {
-                                        int newnameid = rndUint(available.size());
+                                        int newnameid = rndUint((unsigned int)available.size());
                                         (*selectedword)->name = available[newnameid]->name;
                                 }
@@ -752 +762 @@
                 for (int i = 0; i < numselrules; i++)
                 {
-                        int rulid = rndUint(from->rules.size());
+                        int rulid = rndUint((unsigned int)from->rules.size());
                         fL_Rule *rul = from->rules[rulid];
                         fL_Rule *newrule = new fL_Rule(0, 0);
@@ -894 +904 @@
         else if (strchr("<>$[]&\\ @|*", ch) != NULL) // other allowed symbols and special neuron symbols
         {
-                style = GENSTYLE_CS(GENCOLOR_TEXT, ch=='[' || ch==']' ? GENSTYLE_BOLD : GENSTYLE_NONE);
+                style = GENSTYLE_CS(GENCOLOR_TEXT, ch == '[' || ch == ']' ? GENSTYLE_BOLD : GENSTYLE_NONE);
         }
         return style;