Changeset 1234 for cpp/frams/genetics/f4/f4_general.cpp

Timestamp:

05/04/23 01:45:37 (12 months ago)

Author:

Maciej Komosinski

Message:

Simplify sequences of modifier genes, cancelling out antagonistic ones and limiting the number of identical genes

File:

• cpp/frams/genetics/f4/f4_general.cpp (modified) (13 diffs)

cpp/frams/genetics/f4/f4_general.cpp

@@ -7 +7 @@
 
 #include "f4_general.h"
-#include "../genooperators.h" //for GENOPER_ constants
+#include "../genooperators.h" // for GENOPER_ constants
 #include <common/nonstd_stl.h>
 #include <common/log.h>
@@ -306 +306 @@
                                 break;
                         }
-                        case 'r':  case 'R':
+                        case 'r':
+                        case 'R':
                         {
                                 // error: if neuron
@@ -340 +341 @@
                                 // error: if neuron
                                 if (type == CELL_NEURON) //some neurons have the same single-letter names as modifiers (for example G,S,D), but they are supposed to have is_neuroclass==true so they should indeed not be handled here
-                                {//however, what we see here is actually modifiers such as IdqEbWL (so not valid neuroclasses) that occurred within an already differentiated cell type==CELL_NEURON.
+                                {//however, what we see here is actually modifiers such as IdqEbWL (so not valid neuroclasses) that occurred within an already differentiated cell of type==CELL_NEURON.
                                         //printf("Handled as a modifier, but type==CELL_NEURON: '%c'\n", name);
                                         // fix: delete it
@@ -691 +692 @@
 int f4_Cells::simulate()
 {
-        constexpr bool print_debugging = false; //print the state of cells during development
+        const bool PRINT_CELLS_DEVELOPMENT = false; //print the state of cells
         errorcode = GENOPER_OK;
 
         for (int i = 0; i < cell_count; i++)  C[i]->active = true;
 
-        if (print_debugging) f4_Node::print_tree(C[0]->genot, 0);
-        if (print_debugging) print_cells("Initialization");
+        if (PRINT_CELLS_DEVELOPMENT) f4_Node::print_tree(C[0]->genot, 0);
+        if (PRINT_CELLS_DEVELOPMENT) print_cells("Initialization");
 
         // execute oneStep() in a cycle
-        while (oneStep()) if (print_debugging) print_cells("Development step");
-        if (print_debugging) print_cells("After last development step");
+        while (oneStep()) if (PRINT_CELLS_DEVELOPMENT) print_cells("Development step");
+        if (PRINT_CELLS_DEVELOPMENT) print_cells("After last development step");
 
 #ifdef EXTRA_STEP_CELL_DEVELOPMENT
         if (errorcode == GENOPER_OK)
         {
-                oneStep(); if (print_debugging) print_cells("After extra step"); //for these "halted" (yielding) cells (they have active==false) that wait for other cells to develop. Without this step, the last, recently halted one(s) may miss the "retrying" step if all active==true cells became active==false in the last step.
+                oneStep(); if (PRINT_CELLS_DEVELOPMENT) print_cells("After extra step"); //for these "halted" (yielding) cells (they have active==false) that wait for other cells to develop. Without this step, the last, recently halted one(s) may miss the "retrying" step if all active==true cells became active==false in the last step.
         }
 #endif
@@ -745 +746 @@
         //DB( printf("Cell simulation done, %d cells. \n", nc); )
 
-        if (print_debugging) print_cells("Final");
+        if (PRINT_CELLS_DEVELOPMENT) print_cells("Final");
 
         return errorcode;
@@ -1058 +1059 @@
 {
         for (int i = 0; i < indent; i++) printf(" ");
-        printf("%s (%d)", root->name.c_str(), root->count());
+        printf("%s%s%s (%d)", root->neuclass != NULL ? "N:" : "", root->name.c_str(), root->name == "#" ? std::to_string(root->reps).c_str() : "", root->count() - 1);
         if (root->name == "[")
                 printf("     from=%-3d  weight=%g", root->conn_from, root->conn_weight);
@@ -1253 +1254 @@
 }
 
-// scan genotype string and build tree
+// scan genotype string and build a tree
 // return >1 for error (errorpos)
-int f4_processRecur(const char* genot, int &pos_inout, f4_Node *parent)
-{
+int f4_processRecur(const char* genot, const int genot_len, int &pos_inout, f4_Node *parent)
+{
+        static const char *all_modifiers_no_comma = F14_MODIFIERS; //I did experiments with added comma (see all_modifiers_for_simplify below) which had the advantage of commas not breaking sequences of modifiers, thus longer sequences of modifiers (including commas) could be simplified and genetic bloat was further reduced. But since we impose a limit on the number of modifier chars in GenoOperators::simplifiedModifiers(), it would also influence commas (e.g. no more than 8 commas per sequence), so in order to leave commas entirely unlimited let's exclude them from simplification. Note that currently 'X' or any other non-F14_MODIFIERS char also separates the sequence to be simplified, so if we wanted a really intensive simplification, it should occur during development, when we know precisely which genes influence each f4_Cell.
+        //const char *Geno_f4::all_modifiers_for_simplify = F14_MODIFIERS ",\1"; //'\1' added to keep the number of chars even, avoid exceptions in logic and save the simple rule that the sequence is made of pairs (gene,contradictory gene), where a comma has no contradictory gene and \1 is unlikely to occur in the f4 genotype (and not allowed), so no risk it will cancel out a comma during simplification.
+
+
         f4_Node *par = parent;
 
-        if (pos_inout >= (int)strlen(genot))
-                return (int)strlen(genot) + 1;
-
-        while (pos_inout < (int)strlen(genot))
-        {
-//#define PRINT_PARSING_LOCATION
-#ifdef PRINT_PARSING_LOCATION
-                printf("%s\n", genot);
-                for (int i = 0; i < pos_inout; i++) printf(" ");
-                printf("^\n");
-#endif
+        if (pos_inout >= genot_len)
+                return genot_len + 1;
+
+        while (pos_inout < genot_len)
+        {
+                const bool PRINT_PARSING_LOCATION = false;
+                if (PRINT_PARSING_LOCATION)
+                {
+                        printf("%s\n", genot);
+                        for (int i = 0; i < pos_inout; i++) printf(" ");
+                        printf("^\n");
+                }
                 switch (genot[pos_inout])
                 {
@@ -1277 +1283 @@
                         par = node;
                         pos_inout++; //move after '<'
-                        int res = f4_processRecur(genot, pos_inout, par);
+                        int res = f4_processRecur(genot, genot_len, pos_inout, par);
                         if (res) return res;
-                        if (pos_inout < (int)strlen(genot))
-                        {
-                                res = f4_processRecur(genot, pos_inout, par);
+                        if (pos_inout < genot_len)
+                        {
+                                res = f4_processRecur(genot, genot_len, pos_inout, par);
                                 if (res) return res;
                         }
@@ -1287 +1293 @@
                         {
                                 //MacKo 2023-04, more strict behavior: instead of silent repair (no visible effect to the user, genotype stays invalid but is interpreted and reported as valid), we now point out where the error is. For example <X> or <X><X or <X><N:N>
-                                return (int)strlen(genot) + 1;
+                                return genot_len + 1;
                                 //old silent repair:
-                                //node = new f4_Node(">", par, int(strlen(genot)) - 1);
+                                //node = new f4_Node(">", par, genot_len - 1);
                         }
                         return 0;  // OK
@@ -1310 +1316 @@
                         // skip number
                         pos_inout += end - (genot + pos_inout);
-                        int res = f4_processRecur(genot, pos_inout, node);
+                        int res = f4_processRecur(genot, genot_len, pos_inout, node);
                         if (res) return res;
-                        if (pos_inout < (int)strlen(genot))
-                        {
-                                res = f4_processRecur(genot, pos_inout, node);
+                        if (pos_inout < genot_len)
+                        {
+                                res = f4_processRecur(genot, genot_len, pos_inout, node);
                                 if (res) return res;
                         }
                         else // ran out
                         {
-                                return (int)strlen(genot) + 1; //MacKo 2023-04: report an error, better to be more strict instead of a silent repair (genotype stays invalid but is interpreted and reported as valid) with non-obvious consequences?
+                                return genot_len + 1; //MacKo 2023-04: report an error, better to be more strict instead of a silent repair (genotype stays invalid but is interpreted and reported as valid) with non-obvious consequences?
                                 //earlier apporach - silently treating this problem (we don't ever see where the error is because it gets corrected in some way here, while parsing the genotype, and error location in the genotype is never reported):
-                                //node = new f4_Node(">", par, int(strlen(genot)) - 1); // check if needed and if this is really the best repair operation; seemed to happen too many times in succession for some genotypes even though they were only a result of f4 operators, not manually created... and the operators should not generate invalid genotypes, right? Or maybe crossover does? Seems like too many #N's for closing >'s; removing #N or adding > helped. Operators somehow don't do it properly sometimes? But F4_ADD_REP adds '>'... (TODO)
+                                //node = new f4_Node(">", par, genot_len - 1); // check if needed and if this is really the best repair operation; seemed to happen too many times in succession for some genotypes even though they were only a result of f4 operators, not manually created... and the operators should not generate invalid genotypes, right? Or maybe crossover does? Seems like too many #N's for closing >'s; removing #N or adding > helped. Operators somehow don't do it properly sometimes? But F4_ADD_REP adds '>'... (TODO)
                         }
                         return 0;  // OK
@@ -1391 +1397 @@
                         break;
                 }
-                default: // 'X' and ',' and all modifiers and also invalid symbols - add a node, for invalid symbols build will give the error or repair
+                default: // 'X' and ',' and all modifiers and also invalid symbols - add a node. For symbols that are not valid in f4, the cell development process will give the error or repair
                 {
                         //printf("any regular character '%c'\n", genot[pos_inout]);
-                        //TODO here: read a continuous sequence of modifiers, sort and optimize ("collapse") it like in f1, then add to tree
+#define F4_SIMPLIFY_MODIFIERS //avoid long sequences like ...<X>llmlIilImmimiimmimifmfl<fifmmimilimmmiimiliffmfliIfififlliflimfliffififmiffmflllfflimlififfiiffifIr<r<... - another option, instead of simplifying while parsing here, would be mutations: when they add/modify/remove a modifier node, they could "clean" the tree by removing nodes when they encounter contradictory modifiers on the same subpath, and also limit the number of modifiers just as GenoOperators::simplifiedModifiers() does.
+#ifdef F4_SIMPLIFY_MODIFIERS
+                        char *ptr = (char*)(genot + pos_inout);
+
+#ifdef __BORLANDC__ // "[bcc32c Error] cannot compile this non-trivial TLS destruction yet" (C++B 10.4u2)
+                        static
+#else
+                        thread_local 
+#endif
+                                vector<int> modifs_counts(strlen(all_modifiers_no_comma)); ///<an array with a known constant size storing counters of each modifier symbol from all_modifiers_no_comma, created once to avoid reallocation every time when modifier genes are simplified during parsing. Initialization of required size; it will never be resized.
+                        std::fill(modifs_counts.begin(), modifs_counts.end(), 0); //zeroing only needed if we encountered a char from all_modifiers_no_comma and enter the 'while' loop below
+
+                        while (char *m = 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
+                        {
+                                modifs_counts[m - all_modifiers_no_comma]++;
+                                GenoOperators::skipWS(++ptr); //advance and ignore whitespace
+                        }
+                        int advanced = ptr - (genot + pos_inout);
+                        if (advanced > 0) //found modifiers
+                        {
+                                string simplified = GenoOperators::simplifiedModifiers(all_modifiers_no_comma, modifs_counts);
+                                // add a node for each char in "simplified"
+                                for (size_t i = 0; i < simplified.length(); i++)
+                                {
+                                        int pos = GenoOperators::strchrn0(genot + pos_inout, simplified[i]) - genot; //unnecessarily finding the same char, if it occurrs multiple times in simplified
+                                        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)
+                                        par = node;
+                                }
+                                pos_inout += advanced;
+                        }
+                        else // genot[pos_inout] is a character not present in all_modifiers_no_comma, so treat it as a regular individual char just as it would be without simplification
+                        {
+                                f4_Node *node = new f4_Node(genot[pos_inout], par, pos_inout);
+                                par = node;
+                                pos_inout++;
+                        }
+#else
                         f4_Node *node = new f4_Node(genot[pos_inout], par, pos_inout);
                         par = node;
                         pos_inout++;
+#endif // F4_SIMPLIFY_MODIFIERS
                         break;
                 }
@@ -1406 +1449 @@
         if (par && par->name != ">")
         {
-                //happens when pos_inout == strlen(genot)
+                //happens when pos_inout == genot_len
                 //return pos_inout; //MacKo 2023-04: could report an error instead of silent repair, but repair operators only work in Cells (i.e., after the f4_Node tree has been parsed without errors and Cells can start developing) so we don't want to make a fatal error because of missing '>' here. Also after conversions from Cells to text, trailing '>' is deliberately removed... and also the simplest genotype is officially X, not X>.
-                new f4_Node('>', par, int(strlen(genot)) - 1);
+                new f4_Node('>', par, genot_len - 1);
         }
 
@@ -1417 +1460 @@
 {
         int pos = 0;
-        int res = f4_processRecur(genot, pos, root);
+        int res = f4_processRecur(genot, (int)strlen(genot), pos, root);
         if (res > 0)
                 return res; //parsing error