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

Timestamp:

05/18/23 03:43:42 (11 months ago)

Author:

Maciej Komosinski

Message:

No longer sort modifiers and cancel out antagonistic modifiers in f1 and f4; simplifying modifier sequences is now much less intrusive to allow for 2^{N distinct values of properties instead of only 2*N that resulted from earlier forced ordering (N is the number of same-letter upper- and lower-case characters in a modifier sequence)}

File:

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

cpp/frams/genetics/genooperators.cpp

@@ -473 +473 @@
 
 //#include <cassert>
-string GenoOperators::simplifiedModifiers(const char *str_of_char_pairs, vector<int> &char_counts)
+string GenoOperators::simplifiedModifiersFixedOrder(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)
+        const int MAX_NUMBER_SAME_TYPE = 8; // max. number of modifiers of each type (case-sensitive) - mainly for rR, even though for rR, 4 would be sufficient if we assume lower or upper can be chosen as required for minimal length, e.g. rrrrr==RRR, RRRRRR==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.
+        //#define CLUMP_IDENTICAL_MODIFIERS //not good because with the exception of rR 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 (with the exception of rR) 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++)
@@ -507 +507 @@
         return simplified;
 }
+
+string GenoOperators::simplifiedModifiers(const string & original)
+{
+        const int MAX_NUMBER_SAME_TYPE = 6; // max. number of modifiers of each type (case-insensitive). rR could be treated separately in simplification because their influence follows different (i.e., simple additive) logic - so the simplifiedModifiersFixedOrder() logic with cancelling out is appropriate for rR. However in this function, making no exception to rR does not cause any harm to these modifiers either - the only consequence is that we will not remove antagonistic letters and will not simplify sequences of rR longer than 4, while they could be simplified (e.g. rrrrr==RRR, RRRRRR==rr).
+        int counter[256] = {}; //initialize with zeros; 256 is unnecessarily too big and redundant, but enables very fast access (indexed directly by the ascii code)
+        string simplified = "";
+        for (int i = original.size() - 1; i >= 0; i--) //iterate from end to begin - easier to remove "oldest" = first modifiers
+        {
+                unsigned char c = original[i];
+                if (!std::isalpha(c))
+                        continue;
+                unsigned char lower = std::tolower(c);
+                counter[lower]++;
+                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
+                        simplified += c;
+        }
+        std::reverse(simplified.begin(), simplified.end()); //"simplified" was built in reverse order, so need to restore the order that corresponds to "original"
+        return simplified;
+}