Changeset 1233 for cpp/frams/genetics/genooperators.cpp

Timestamp:

05/04/23 00:57:57 (12 months ago)

Author:

Maciej Komosinski

Message:

Added a function that simplifies a sequence of modifier genes (useful in f1 and f4 encodings) by removing antagonistic modifier genes and limiting the number of genes of the same kind

File:

• cpp/frams/genetics/genooperators.cpp (modified) (5 diffs)

cpp/frams/genetics/genooperators.cpp

@@ -8 +8 @@
 #include <common/nonstd_math.h>
 #include <frams/util/rndutil.h>
+#include <algorithm> // std::min, std::max
 
 //
@@ -355 +356 @@
 }
 
-int GenoOperators::getRandomChar(const char *choices, const char *excluded)
-{
-        int allowed_count = 0;
-        for (size_t i = 0; i < strlen(choices); i++) if (!strchrn0(excluded, choices[i])) allowed_count++;
-        if (allowed_count == 0) return -1; //no char is allowed
-        int rnd_index = rndUint(allowed_count) + 1;
-        allowed_count = 0;
-        for (size_t i = 0; i < strlen(choices); i++)
-        {
-                if (!strchrn0(excluded, choices[i])) allowed_count++;
-                if (allowed_count == rnd_index) return int(i);
-        }
-        return -1; //never happens
-}
-
-NeuroClass *GenoOperators::parseNeuroClass(char *&s, ModelEnum::ShapeType supported_shapetype)
+NeuroClass *GenoOperators::parseNeuroClass(char *&s, ModelEnum::ShapeType for_shape_type)
 {
         int maxlen = (int)strlen(s);
@@ -378 +364 @@
         {
                 NeuroClass *nci = Neuro::getClass(i);
-                if (!nci->isShapeTypeSupported(supported_shapetype))
+                if (!nci->isShapeTypeSupported(for_shape_type))
                         continue;
                 const char *nciname = nci->name.c_str();
@@ -434 +420 @@
 }
 
+bool GenoOperators::canStartNeuroClassName(const char firstchar)
+{
+        return isupper(firstchar) || firstchar == '|' || firstchar == '@' || firstchar == '*';
+}
+
 bool GenoOperators::isWS(const char c)
 {
@@ -466 +457 @@
 }
 
-bool GenoOperators::canStartNeuroClassName(const char firstchar)
-{
-        return isupper(firstchar) || firstchar == '|' || firstchar == '@' || firstchar == '*';
-}
+int GenoOperators::getRandomChar(const char *choices, const char *excluded)
+{
+        int allowed_count = 0;
+        for (size_t i = 0; i < strlen(choices); i++) if (!strchrn0(excluded, choices[i])) allowed_count++;
+        if (allowed_count == 0) return -1; //no char is allowed
+        int rnd_index = rndUint(allowed_count) + 1;
+        allowed_count = 0;
+        for (size_t i = 0; i < strlen(choices); i++)
+        {
+                if (!strchrn0(excluded, choices[i])) allowed_count++;
+                if (allowed_count == rnd_index) return int(i);
+        }
+        return -1; //never happens
+}
+
+//#include <cassert>
+string GenoOperators::simplifiedModifiers(const char *str_of_char_pairs, vector<int> &char_counts)
+{
+//      assert(strlen(str_of_char_pairs) == char_counts.size());
+//      assert(char_counts.size() % 2 == 0);
+        const int MAX_NUMBER_SAME_TYPE = 8; // max. number of modifiers of each type = 8 (mainly for Rr)
+        string simplified;
+        //#define CLUMP_IDENTICAL_MODIFIERS //not good because properties are calculated incrementally, non-linearly, and their values are updated after each modifier character, so these values may for example saturate after a large number of identical modifier symbols. The order of modifiers is in general relevant and extreme values of properties increase this relevance, so better keep the modifiers dispersed.
+#ifdef CLUMP_IDENTICAL_MODIFIERS
+        for (size_t i = 0; i < strlen(str_of_char_pairs); i++)
+                if ((i % 2) == 0) //only even index "i" in str_of_char_pairs
+                        for (int j = 0; j < std::min(MAX_NUMBER_SAME_TYPE, abs(char_counts[i] - char_counts[i + 1])); j++) //assume that an even-index char and the following odd-index char have the opposite influence, so they cancel out.
+                                simplified += str_of_char_pairs[i + (char_counts[i + 1] > char_counts[i])]; //inner loop adds a sequence of same chars such as rrrrr or QQQ
+#else
+        for (size_t i = 0; i < strlen(str_of_char_pairs); i++)
+                if ((i % 2) == 0) //only even index "i" in str_of_char_pairs
+                {
+                        char_counts[i] -= char_counts[i + 1]; //from now on, even items in the vector store the difference between antagonistic modifier symbols; odd items are not needed
+                        char_counts[i] = std::min(std::max(char_counts[i], -MAX_NUMBER_SAME_TYPE), MAX_NUMBER_SAME_TYPE);
+                }
+        int remaining;
+        do {
+                remaining = 0;
+                for (size_t i = 0; i < strlen(str_of_char_pairs); i++)
+                        if ((i % 2) == 0) //only even index "i" in str_of_char_pairs
+                                if (char_counts[i] != 0)
+                                {
+                                        simplified += str_of_char_pairs[i + (char_counts[i] < 0)];
+                                        char_counts[i] += char_counts[i] > 0 ? -1 : +1; //decrease the difference towards zero
+                                        remaining += abs(char_counts[i]);
+                                }
+        } while (remaining > 0);
+#endif
+        return simplified;
+}