Changeset 1231 for cpp/frams/genetics/f4/f4_oper.cpp

Timestamp:

05/02/23 01:36:15 (12 months ago)

Author:

Maciej Komosinski

Message:

• Thanks to r1230, it is possible to detect (and repair=remove) junk trailing genes that are left after successful parsing (after last '>')
• The validate() function may attempt to repair a genotype where earlier it would give up
• Stricter parsing of the '#' gene

File:

• cpp/frams/genetics/f4/f4_oper.cpp (modified) (8 diffs)

cpp/frams/genetics/f4/f4_oper.cpp

@@ -11 +11 @@
 // may help, but it would be better to improve the source code to make genetic operators neutral in terms of genotype length. Adding such a penalty
 // removes "work in progress" changes in genotypes thus promoting immediate, straightforward improvements while hindering slower, multifaceted progress.
-// TODO getting rid of redundancy (having valid genotypes with a lot of "junk code") in this representation looks like a good idea.
+// TODO getting rid of redundancy (valid genotypes with a lot of "junk code") in this representation looks like a good idea; many improvements to this end have already been done in April & May 2023.
 // 
-// Note: symbols after the last > are ignored, for example /*4*/<X>N:N>blablaN:N[2:-0.5]XXXwhatever but since they are not parsed into the f4_Node tree, they will be lost after any mutation.
 //
 // TODO the behavior of neuron input indexes during mutation seems badly implemented (see also TREAT_BAD_CONNECTIONS_AS_INVALID_GENO). Are they kept properly maintained when nodes are added and removed? This could be done well because during mutation we operate on the tree structure with cross-references between nodes (so they should not be affected by local changes in the tree), and then convert the tree back to string. Yet, the f4_Node.conn_from is an integer and these fields in nodes do not seem to be maintained on tree node adding/removal... change these integer offsets to references to node objects? But actually, do the offsets that constitute relative connection references concern the f4_Node tree structure (and all these sophisticated calculations of offsets during mutation are useful) or rather they concern the f4_Cells development? verify all situations in f4_Cell::oneStep(), case '['.
@@ -87 +86 @@
 }
 
-int Geno_f4::ValidateRec(f4_Node *geno, int retrycount) const
+int Geno_f4::ValidateRecur(f4_Node *geno, int retrycount) const
 {
         // ! the genotype is geno->child (not geno) !
         // build from it with repair on
 
-        f4_Cells cells(geno->child, 1);
+        f4_Cells cells(geno->child, true);
         cells.simulate();  //we should simulate?!
 
@@ -109 +108 @@
                 int res2 = GENOPER_OK;
                 if (retrycount > 0)
-                        res2 = ValidateRec(geno, retrycount - 1);
+                        res2 = ValidateRecur(geno, retrycount - 1);
 
                 if (res2 == GENOPER_OK) return GENOPER_REPAIR;
@@ -123 +122 @@
         // convert geno to a tree, then try to validate
         f4_Node root;
-        int _ = 0;
-        if (f4_processRecur(geno, _, &root) || root.childCount() != 1) return GENOPER_OK; // cannot repair
-
+        int res = f4_process(geno, &root);
+        if (res == 0 || root.childCount() != 1) return GENOPER_OK; // either parsing says the genotype is OK or the resulting tree will not be repairable (fatal flaw; root must have exactly one child) - do not attempt repair
+
+        // here we have a genotype with res>0 (for sure has some error) and root.childCount()==1 (still something was parsed into a tree)
         const int VALIDATE_TRIALS = 20;
-        if (ValidateRec(&root, VALIDATE_TRIALS) == GENOPER_REPAIR) // if repaired, make it back to string
+        res = ValidateRecur(&root, VALIDATE_TRIALS);
+        if (res != GENOPER_OPFAIL) // if repaired (GENOPER_REPAIR) or had no errors (GENOPER_OK, e.g. the genotype had some errors that were ignored during tree creation or had junk genes appended at the end, so the tree was OK but the genotype was not), 
         {
                 geno[0] = 0;
-                root.child->sprintAdj(geno);
+                root.child->sprintAdj(geno); //make it back to string
         }
         return GENOPER_OK;
@@ -139 +140 @@
 {
         f4_Node root;
-        int _ = 0;
-        int res = f4_processRecur(geno, _, &root);
+        int res = f4_process(geno, &root);
         if (res) return res;  // errorpos, >0
-        if (root.childCount() != 1) return 1; //earlier: GENOPER_OPFAIL
-        f4_Cells cells(root.child, 0);
+        if (root.childCount() != 1) return 1; // fatal flaw; root must have exactly one child
+        f4_Cells cells(root.child, false);
         cells.simulate();
         if (cells.getErrorCode() == GENOPER_OPFAIL || cells.getErrorCode() == GENOPER_REPAIR)
         {
                 if (cells.getErrorPos() >= 0) return 1 + cells.getErrorPos();
-                else return 1; //earlier: GENOPER_OPFAIL;
+                else return 1; //error, no known position
         }
         else return GENOPER_OK;
@@ -525 +525 @@
                 }
                 // try to validate it
-                res = ValidateRec(gcopy, 10);
+                res = ValidateRecur(gcopy, 10);
                 // accept if it is OK, or was repaired
                 if (GENOPER_OK == res)
@@ -552 +552 @@
 {
         f4_Node *root = new f4_Node;
-        int _ = 0;
-        if (f4_processRecur(g, _, root) || root->childCount() != 1)
+        if (f4_process(g, root) || root->childCount() != 1)
         {
                 delete root;
@@ -677 +676 @@
 
         // convert genotype strings into tree structures
-        int _1 = 0, _2 = 0;
-        if (f4_processRecur(g1, _1, &root1) || (root1.childCount() != 1)) return GENOPER_OPFAIL;
-        if (f4_processRecur(g2, _2, &root2) || (root2.childCount() != 1)) return GENOPER_OPFAIL;
+        if (f4_process(g1, &root1) || (root1.childCount() != 1)) return GENOPER_OPFAIL;
+        if (f4_process(g2, &root2) || (root2.childCount() != 1)) return GENOPER_OPFAIL;
 
         // decide amounts of crossover, 0.1-0.9