Changeset 797 for cpp/frams/genetics/fB/fB_oper.cpp

Timestamp:

06/06/18 01:45:18 (6 years ago)

Author:

Maciej Komosinski

Message:

A more complete implementation of fB, fH, fL

File:

• cpp/frams/genetics/fB/fB_oper.cpp (modified) (8 diffs)

cpp/frams/genetics/fB/fB_oper.cpp

@@ +1 @@
+// This file is a part of Framsticks SDK.  http://www.framsticks.com/
+// Copyright (C) 1999-2018  Maciej Komosinski and Szymon Ulatowski.
+// See LICENSE.txt for details.
+
 #include <frams/util/sstring.h>
 #include <vector>
@@ -5 +9 @@
 #include "fB_general.h"
 #include "fB_oper.h"
+#include "../fH/fH_oper.h"
 
 #define FIELDSTRUCT Geno_fB
@@ -10 +15 @@
 static ParamEntry GENOfBparam_tab[] =
 {
-        { "Genetics: fB", 3, FB_MUT_COUNT + FB_XOVER_COUNT, }, // ask about it
+        { "Genetics: fB", 3, FB_MUT_COUNT + FB_XOVER_COUNT, },
         { "Genetics: fB: Mutation", },
         { "Genetics: fB: Crossover", },
         { "fB_mut_substitution", 1, 0, "Substitution", "f 0 1 0.6", FIELD(mutationprobs[FB_SUBSTITUTION]), "Probability of mutation by changing single random letter in genotype", },
-        { "fB_mut_insertion", 1, 0, "Insertion", "f 0 1 0.1", FIELD(mutationprobs[FB_INSERTION]), "Probability of mutation by inserting characters in random place of genotype", },
+        { "fB_mut_insertion", 1, 0, "Insertion", "f 0 1 0.95", FIELD(mutationprobs[FB_INSERTION]), "Probability of mutation by inserting characters in random place of genotype", },
+        { "fB_mut_nclassins", 1, 0, "Insertion of neuron class definition", "f 0 1 0.05", FIELD(mutationprobs[FB_NCLASSINS]), "Probability of mutation by inserting neuron class definition in random place of genotype", },
         { "fB_mut_deletion", 1, 0, "Deletion", "f 0 1 0.1", FIELD(mutationprobs[FB_DELETION]), "Probability of mutation by deleting random characters in genotype", },
         { "fB_mut_duplication", 1, 0, "Duplication", "f 0 1 0.05", FIELD(mutationprobs[FB_DUPLICATION]), "Probability of mutation by copying single *gene* of genotype and appending it to the beginning of this genotype", },
@@ -81 +87 @@
                 if (!islower(genotype[i]))
                 {
-                        return i + 1;
+                        if (genotype[i] == '"')
+                        {
+                                SString neuclassdef;
+                                int nextid = i + 1;
+                                if (!genotype.getNextToken(nextid, neuclassdef, '"'))
+                                {
+                                        return i + 1;
+                                }
+                                Neuro *neu = new Neuro();
+                                neu->setDetails(neuclassdef);
+
+                                bool isclass = neu->getClass() ? true : false;
+                                delete neu;
+                                if (!isclass)
+                                {
+                                        return i + 1;
+                                }
+                                i = nextid;
+                        }
+                        else
+                        {
+                                return i + 1;
+                        }
                 }
         }
@@ -121 +149 @@
                 if (!isalpha(genotype[i]))
                 {
-                        return GENOPER_OPFAIL;
+                        if (genotype[i] == '"')
+                        {
+                                SString neuclassdef;
+                                int nextid = i + 1;
+                                if (!genotype.getNextToken(nextid, neuclassdef, '"'))
+                                {
+                                        return i + 1;
+                                }
+                                Neuro *neu = new Neuro();
+                                neu->setDetails(neuclassdef);
+
+                                bool isclass = neu->getClass() ? true : false;
+                                delete neu;
+                                if (!isclass)
+                                {
+                                        return i + 1;
+                                }
+                                i = nextid;
+                        }
+                        else
+                        {
+                                return GENOPER_OPFAIL;
+                        }
                 }
                 // if character is uppercase, then convert it to lowercase
-                if (isupper(genotype[i]))
+                else if (isupper(genotype[i]))
                 {
                         genotype.directWrite()[i] = tolower(genotype[i]);
@@ -142 +192 @@
         }
         return GENOPER_OK;
+}
+
+SString Geno_fB::detokenizeSequence(std::list<SString> tokenlist)
+{
+        SString res = "";
+        for (std::list<SString>::iterator it = tokenlist.begin(); it != tokenlist.end(); it++)
+        {
+                res += (*it);
+        }
+        return res;
+}
+
+std::list<SString> Geno_fB::tokenizeSequence(SString genotype)
+{
+        std::list<SString> res;
+        int i = 0;
+        while (i < genotype.len())
+        {
+                // if character is not alphabetic - error
+                if (isalpha(genotype[i]))
+                {
+                        SString el = "";
+                        el += genotype[i];
+                        res.push_back(el);
+                        i++;
+                }
+                else
+                {
+                        SString neuclassdef;
+                        i++;
+                        genotype.getNextToken(i, neuclassdef, '"');
+                        SString ndef = "\"";
+                        ndef += neuclassdef;
+                        ndef += "\"";
+                        res.push_back(ndef);
+                }
+        }
+        return res;
 }
 
@@ -157 +245 @@
         case FB_SUBSTITUTION:
         {
-                int rndid = randomN(line.len()); // select random letter from genotype
+                std::list<SString> tokenized = tokenizeSequence(line);
+                int rndid = randomN(tokenized.size()); // select random letter from genotype
                 // increment/decrement character - when overflow happens, this method
                 // uses reflect method
-                if (randomN(2) == 0)
-                {
-                        if (line[rndid] == 'a') line.directWrite()[rndid] = 'b';
-                        else line.directWrite()[rndid] = line[rndid] - 1;
+                std::list<SString>::iterator it = tokenized.begin();
+                std::advance(it, rndid);
+                SString t = (*it);
+                if ((*it).len() == 1)
+                {
+                        if (randomN(2) == 0)
+                        {
+                                if ((*it)[0] == 'a') (*it).directWrite()[0] = 'b';
+                                else (*it).directWrite()[0] = (*it)[0] - 1;
+                        }
+                        else
+                        {
+                                if ((*it)[0] == 'z') (*it).directWrite()[0] = 'y';
+                                else (*it).directWrite()[0] = (*it)[0] + 1;
+                        }
+                        chg = 1.0 / line.len();
                 }
                 else
                 {
-                        if (line[rndid] == 'z') line.directWrite()[rndid] = 'y';
-                        else line.directWrite()[rndid] = line[rndid] + 1;
-                }
+                        // first method needs to extract quotes
+                        SString def = (*it);
+                        def = def.substr(1, def.len() - 2);
+                        Geno_fH::mutateNeuronProperties(def);
+                        SString res = "\"";
+                        res += def;
+                        res += "\"";
+                        (*it) = res;
+                        chg = (double)def.len() / line.len();
+                }
+                line = detokenizeSequence(tokenized);
+                break;
+        }
+        case FB_INSERTION:
+        {
                 chg = 1.0 / line.len();
-                break;
-        }
-        case FB_INSERTION:
+                std::list<SString> tokenized = tokenizeSequence(line);
+                int rndid = randomN(tokenized.size()); // select random insertion point
+                std::list<SString>::iterator it = tokenized.begin();
+                std::advance(it, rndid);
+                SString letter = "a";
+                letter.directWrite()[0] = 'a' + randomN(26);
+                tokenized.insert(it, letter);
+                line = detokenizeSequence(tokenized);
+                break;
+        }
+        case FB_NCLASSINS:
+        {
+                std::list<SString> tokenized = tokenizeSequence(line);
+                std::list<SString>::iterator it = tokenized.begin();
+                int rndid = randomN(tokenized.size()); // select random insertion point
+                std::advance(it, rndid);
+                NeuroClass *cls = getRandomNeuroClass();
+                SString classdef = cls->getName();
+                Geno_fH::mutateNeuronProperties(classdef);
+                SString res = "\"";
+                res += classdef;
+                res += "\"";
+                tokenized.insert(it, res);
+                chg = (double)classdef.len() / line.len();
+                line = detokenizeSequence(tokenized);
+                break;
+        }
+        case FB_DELETION:
         {
                 chg = 1.0 / line.len();
-                int rndid = randomN(genotype.len()); // select random insertion point
-                char letter = 'a' + randomN(26);
-                SString result = line.substr(0, rndid);
-                result += letter;
-                result += line.substr(rndid);
-                line = result;
-                break;
-        }
-        case FB_DELETION:
-        {
-                chg = 1.0 / line.len();
-                int rndid = randomN(line.len()); // select random insertion point
-                if (rndid == line.len() - 1)
-                {
-                        line = line.substr(0, line.len() - 1);
-                }
-                else
-                {
-                        line = line.substr(0, rndid) + line.substr(rndid + 1);
-                }
+                std::list<SString> tokenized = tokenizeSequence(line);
+                std::list<SString>::iterator it = tokenized.begin();
+                int rndid = randomN(tokenized.size()); // select random deletion point
+                std::advance(it, rndid);
+                tokenized.erase(it);
+                line = detokenizeSequence(tokenized);
                 break;
         }
@@ -210 +334 @@
         case FB_TRANSLOCATION:
         {
-                std::vector<int> cuts(4);
+                std::list<SString> tokenized = tokenizeSequence(line);
+                std::vector<unsigned int> cuts(4);
                 for (int i = 0; i < 4; i++)
                 {
-                        cuts[i] = randomN(line.len());
+                        cuts[i] = randomN(tokenized.size());
                 }
                 std::sort(cuts.begin(), cuts.end());
-                SString first = line.substr(cuts[0], cuts[1] - cuts[0]);
-                SString second = line.substr(cuts[2], cuts[3] - cuts[2]);
-                SString result = line.substr(0, cuts[0]) + second +
-                        line.substr(cuts[1], cuts[2] - cuts[1]) + first + line.substr(cuts[3]);
-                line = result;
+                std::vector<std::list<SString>::iterator> iters(4);
+                for (int i = 0; i < 4; i++)
+                {
+                        iters[i] = tokenized.begin();
+                        std::advance(iters[i], cuts[i]);
+                }
+
+                std::list<SString> res;
+                res.insert(res.end(), tokenized.begin(), iters[0]);
+                res.insert(res.end(), iters[2], iters[3]);
+                res.insert(res.end(), iters[1], iters[2]);
+                res.insert(res.end(), iters[0], iters[1]);
+                res.insert(res.end(), iters[3], tokenized.end());
+
+//              SString first = line.substr(cuts[0], cuts[1] - cuts[0]);
+//              SString second = line.substr(cuts[2], cuts[3] - cuts[2]);
+//              SString result = line.substr(0, cuts[0]) + second +
+//                      line.substr(cuts[1], cuts[2] - cuts[1]) + first + line.substr(cuts[3]);
+                line = detokenizeSequence(res);
                 chg = (float)(cuts[3] - cuts[2] + cuts[1] - cuts[0]) / line.len();
                 break;