source: cpp/frams/genetics/fB/fB_oper.cpp @ 780

#include <frams/util/sstring.h>
#include <vector>
#include <frams/param/param.h>
#include "fB_conv.h"
#include "fB_general.h"
#include "fB_oper.h"

#define FIELDSTRUCT Geno_fB

static ParamEntry GENOfBparam_tab[] =
{
        { "Genetics: fB", 3, FB_MUT_COUNT + FB_XOVER_COUNT, }, // ask about it
        { "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_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", },
        { "fB_mut_translocation", 1, 0, "Translocation", "f 0 1 0.15", FIELD(mutationprobs[FB_TRANSLOCATION]), "Probability of mutation by replacing two substrings in genotype", },
        { "fB_cross_gene_transfer", 2, 0, "Horizontal gene transfer", "f 0 1 0.8", FIELD(crossoverprobs[FB_GENE_TRANSFER]), "Probability of crossing over by transferring single genes from both parents to beginning of each other", },
        { "fB_cross_crossover", 2, 0, "Crossing over", "f 0 1 0.2", FIELD(crossoverprobs[FB_CROSSING_OVER]), "Probability of crossing over by random distribution of genes from both parents to both children", },
        { 0, },
};

#undef FIELDSTRUCT

Geno_fB::Geno_fB()
{
        par.setParamTab(GENOfBparam_tab);
        par.select(this);
        par.setDefault();
        supported_format = 'B';
}

bool Geno_fB::hasStick(SString genotype)
{
        for (int i = 0; i < fB_GenoHelpers::geneCount(genotype); i++)
        {
                int start, end;
                SString gene = fB_GenoHelpers::getGene(i, genotype, start, end);
                int endoffset = 0;
                if (gene.indexOf("zz", 0) != -1) endoffset = 2;
                if (gene.len() - endoffset < 3)
                {
                        return true; // genes with length < 3 are always sticks
                }
                else if (gene[2] >= 'a' && gene[2] <= 'i')
                {
                        return true; // gene within this range is stick
                }
        }
        return false;
}

int Geno_fB::checkValidity(const char *geno, const char *genoname)
{
        // load genotype
        SString genotype(geno);
        SString line;
        int pos = 0;
        // if there is no genotype to load, then return error
        if (!genotype.getNextToken(pos, line, '\n'))
        {
                return pos + 1;
        }
        // extract dimensions
        int dims = 0;
        if (!ExtValue::parseInt(line.c_str(), dims, true, false))
        {
                return 1;
        }
        // extract next token in order to check if next line starts with "aa"
        int genstart = genotype.indexOf("aa", 0);
        if (genstart != pos)
        {
                return pos + 1;
        }
        // check if rest of characters are lowercase
        for (int i = genstart; i < genotype.len(); i++)
        {
                if (!islower(genotype[i]))
                {
                        return i + 1;
                }
        }
        if (!hasStick(genotype))
        {
                return 1;
        }
        return GENOPER_OK;
}

int Geno_fB::validate(char *&geno, const char *genoname)
{
        // load genotype
        SString genotype(geno);
        SString strdims;
        int pos = 0;
        if (!genotype.getNextToken(pos, strdims, '\n'))
        {
                return GENOPER_OPFAIL;
        }
        // parse dimension
        int dims = 0;
        if (!ExtValue::parseInt(strdims.c_str(), dims, true, false))
        {
                return GENOPER_OPFAIL;
        }
        SString line;
        bool fix = false;
        int genstart = genotype.indexOf("aa", 0);
        // if there is no "aa" codon in the beginning of a genotype, then add it
        if (genstart != pos)
        {
                genotype = strdims + "\naa" + genotype.substr(pos);
                fix = true;
        }
        for (int i = pos; i < genotype.len(); i++)
        {
                // if character is not alphabetic - error
                if (!isalpha(genotype[i]))
                {
                        return GENOPER_OPFAIL;
                }
                // if character is uppercase, then convert it to lowercase
                if (isupper(genotype[i]))
                {
                        genotype.directWrite()[i] = tolower(genotype[i]);
                        fix = true;
                }
        }
        // if the genotype does not contain any stick - add it
        if (!hasStick(genotype))
        {
                genotype = SString("aaazz") + genotype;
        }
        // if there were any changes - save them
        if (fix)
        {
                free(geno);
                geno = strdup(genotype.c_str());
        }
        return GENOPER_OK;
}

int Geno_fB::mutate(char *&geno, float &chg, int &method)
{
        SString genotype(geno);
        SString strdims;
        int pos = 0;
        genotype.getNextToken(pos, strdims, '\n');
        SString line;
        genotype.getNextToken(pos, line, '\n');
        method = roulette(mutationprobs, FB_MUT_COUNT);
        switch (method)
        {
        case FB_SUBSTITUTION:
        {
                int rndid = randomN(line.len()); // 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;
                }
                else
                {
                        if (line[rndid] == 'z') line.directWrite()[rndid] = 'y';
                        else line.directWrite()[rndid] = line[rndid] + 1;
                }
                chg = 1.0 / line.len();
                break;
        }
        case FB_INSERTION:
        {
                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);
                }
                break;
        }
        case FB_DUPLICATION:
        {
                int rndgene = randomN(fB_GenoHelpers::geneCount(line));
                int start, end;
                SString gene = fB_GenoHelpers::getGene(rndgene, line, start, end);
                if (gene.indexOf("zz", 0) == -1) gene += "zz";
                chg = (float)gene.len() / line.len();
                line = gene + line;
                break;
        }
        case FB_TRANSLOCATION:
        {
                std::vector<int> cuts(4);
                for (int i = 0; i < 4; i++)
                {
                        cuts[i] = randomN(line.len());
                }
                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;
                chg = (float)(cuts[3] - cuts[2] + cuts[1] - cuts[0]) / line.len();
                break;
        }
        }
        SString result = strdims + "\n" + line;
        free(geno);
        geno = strdup(result.c_str());
        return GENOPER_OK;
}

int Geno_fB::crossOver(char *&g1, char *&g2, float& chg1, float& chg2)
{
        SString p1(g1);
        SString p2(g2);

        int dims1 = 0, dims2 = 0;
        int pos = 0;
        SString strdims;
        p1.getNextToken(pos, strdims, '\n');
        ExtValue::parseInt(strdims.c_str(), dims1, true, false);
        SString parent1;
        p1.getNextToken(pos, parent1, '\n');

        pos = 0;
        p2.getNextToken(pos, strdims, '\n');
        ExtValue::parseInt(strdims.c_str(), dims2, true, false);

        if (dims1 != dims2)
        {
                return GENOPER_OPFAIL;
        }

        SString parent2;
        p2.getNextToken(pos, parent2, '\n');

        SString child1 = "";
        SString child2 = "";

        switch (roulette(crossoverprobs, FB_XOVER_COUNT))
        {
        case FB_GENE_TRANSFER:
        {
                // get random gene from first parent
                int choice = randomN(fB_GenoHelpers::geneCount(parent1));
                int start, end;
                SString gene = fB_GenoHelpers::getGene(choice, parent1, start, end);
                // add this gene to the beginning of the second parent genotype
                child2 = gene + parent2;
                chg2 = (float)parent2.len() / (float)child2.len();
                // do the same for second parent
                choice = randomN(fB_GenoHelpers::geneCount(parent2));
                gene = fB_GenoHelpers::getGene(choice, parent2, start, end);
                child1 = gene + parent1;
                chg1 = (float)parent1.len() / (float)child1.len();
                break;
        }
        case FB_CROSSING_OVER:
        {
                // iterate through all genes of the first parent and assign them
                // randomly to children
                for (int i = 0; i < fB_GenoHelpers::geneCount(parent1); i++)
                {
                        int start, end;
                        SString gene = fB_GenoHelpers::getGene(i, parent1, start, end);
                        if (randomN(2) == 0)
                        {
                                child1 += gene;
                                chg1 += 1.0f;
                        }
                        else
                        {
                                child2 += gene;
                        }
                }
                chg1 /= fB_GenoHelpers::geneCount(parent1);

                // do the same with second parent
                for (int i = 0; i < fB_GenoHelpers::geneCount(parent2); i++)
                {
                        int start, end;
                        SString gene = fB_GenoHelpers::getGene(i, parent2, start, end);
                        if (randomN(2) == 0)
                        {
                                child1 += gene;
                        }
                        else
                        {
                                child2 += gene;
                                chg2 += 1.0f;
                        }
                }
                chg2 /= fB_GenoHelpers::geneCount(parent2);
                break;
        }
        }

        free(g1);
        free(g2);
        if (child1.len() > 0 && child2.len() == 0)
        {
                child1 = strdims + "\n" + child1;
                g1 = strdup(child1.c_str());
                g2 = strdup("");
        }
        else if (child2.len() > 0 && child1.len() == 0)
        {
                child2 = strdims + "\n" + child2;
                g1 = strdup(child2.c_str());
                g2 = strdup("");
        }
        else
        {
                child1 = strdims + "\n" + child1;
                child2 = strdims + "\n" + child2;
                g1 = strdup(child1.c_str());
                g2 = strdup(child2.c_str());
        }
        return GENOPER_OK;
}

uint32_t Geno_fB::style(const char *geno, int pos)
{
        char ch = geno[pos];
        if (isdigit(ch))
        {
                while (pos > 0)
                {
                        pos--;
                        if (isdigit(geno[pos]) == 0)
                        {
                                return GENSTYLE_CS(0, GENSTYLE_INVALID);
                        }
                }
                return GENSTYLE_RGBS(0, 0, 200, GENSTYLE_BOLD);
        }
        if (islower(ch) == 0)
        {
                return GENSTYLE_CS(0, GENSTYLE_INVALID);
        }
        uint32_t style = GENSTYLE_CS(GENCOLOR_TEXT, GENSTYLE_NONE);
        if (ch == 'a' && pos > 0 && (geno[pos - 1] == 'a' || geno[pos - 1] == '\n'))
        {
                style = GENSTYLE_RGBS(0, 200, 0, GENSTYLE_BOLD);
        }
        else if (ch == 'z' && pos > 0 && geno[pos - 1] == 'z')
        {
                style = GENSTYLE_RGBS(200, 0, 0, GENSTYLE_BOLD);
        }
        return style;
}