source: cpp/frams/genetics/fB/fB_conv.cpp @ 1304

// This file is a part of Framsticks SDK.  http://www.framsticks.com/
// Copyright (C) 1999-2021  Maciej Komosinski and Szymon Ulatowski.
// See LICENSE.txt for details.

#include "fB_conv.h"

#include <frams/param/paramobj.h>
#include <vector>
#include <algorithm>
#include <frams/util/multimap.h>
#include "fB_general.h"

double GenoConv_fBH::convertCharacterTo01(char c)
{
        return (double)(c - 'a') / 25.0;
}

double GenoConv_fBH::convertCharacterToWeight(char c)
{
        if (c <= 'm')
        {
                return -0.001 * pow(2.0, (double)('m' - c));
        }
        else
        {
                return 0.001 * pow(2.0, (double)(c - 'n'));
        }
}

fH_Handle* GenoConv_fBH::convertCharacterToHandle(char c, int dims, int start, int end, std::vector<IRange> ranges[3])
{
        fH_Handle *handle = NULL;
        if (c >= 'a' && c <= 'i')
        {
                handle = new fH_StickHandle(dims, start, end);
                ranges[0].push_back(IRange(start, end));
        }
        else if (c >= 'j' && c <= 'p')
        {
                handle = new fH_NeuronHandle(dims, start, end);
                ranges[1].push_back(IRange(start, end));
        }
        else
        {
                handle = new fH_ConnectionHandle(dims, start, end);
                ranges[2].push_back(IRange(start, end));
        }
        return handle;
}

SString GenoConv_fBH::convert(SString &i, MultiMap *map, bool using_checkpoints)
{
        // if there is no genotype to load, then return error

        std::vector<IRange> ranges[3];

        int pos = 0;
        SString line;
        i.getNextToken(pos, line, '\n');
        int dims = 0;
        // extract dimensions
        if (!ExtValue::parseInt(line.c_str(), dims, true, false))
        {
                logMessage("f2::Builder", "parseGenotype", LOG_ERROR, "Could not parse number of dimensions");
                return "";
        }

        if (dims < 1)
        {
                logMessage("f2::Builder", "parseGenotype", LOG_ERROR, "Number of dimensions cannot be lower than 1");
                return "";
        }

        fH_Builder creature(dims, false);

        for (int q = 0; q < fB_GenoHelpers::geneCount(i); q++)
        {
                int start, end;
                SString gene = fB_GenoHelpers::getGene(q, i, start, end);
                end -= 1; // last character is included in range, so decrementation is required
                int endoffset = 0;
                if (gene.indexOf("zz", 0) != -1) endoffset = 2;
                if (gene.length() - endoffset < 3)
                {
                        fH_StickHandle *handle = new fH_StickHandle(dims, start, end);
                        ParamEntry *tab = creature.getParamTab(handle->type);
                        void *obj = ParamObject::makeObject(tab);
                        Param par(tab, NULL);
                        par.select(obj);
                        par.setDefault();
                        handle->loadProperties(par);
                        ranges[0].push_back(IRange(start, end));
                        creature.addHandle(handle);
                        continue;
                }
                int hclasspos = 2;
                if (gene[2] == '"')
                {
                        hclasspos--;
                        if (!getNextCharId(gene, hclasspos))
                        {
                                return "";
                        }
                }
                fH_Handle *handle = convertCharacterToHandle(gene[hclasspos], dims, start, end, ranges);
                ParamEntry *tab = creature.getParamTab(handle->type);
                void *obj = ParamObject::makeObject(tab);
                Param par(tab, NULL);
                par.select(obj);
                par.setDefault();

                int propindex = 0;
                int z = hclasspos;
                if (gene[z] == '"')
                {
                        z--;
                        if (!getNextCharId(gene, z))
                        {
                                delete handle;
                                ParamObject::freeObject(obj);
                                return "";
                        }
                }
                endoffset = 0;
                if (gene.indexOf("zz", 0) != -1) endoffset = 2;
                int nclassdefcount = 1;
                while (z < gene.length() - endoffset)
                {
                        if (processNextLetter(creature, handle, par, gene, propindex, z, ranges, nclassdefcount) == -1)
                        {
                                logMessage("GenoConv_fBH", "convert", LOG_ERROR, "Property of fH could not be parsed");
                                delete handle;
                                ParamObject::freeObject(obj);
                                return "";
                        }
                }
                if (handle->type == fHBodyType::NEURON && propindex < par.getPropCount())
                {
                        SString nclass;
                        if (!getNeuroClass(gene, nclass, nclassdefcount))
                        {
                                delete handle;
                                ParamObject::freeObject(obj);
                                return "";
                        }
                        par.setStringById(FH_PE_NEURO_DET, nclass);
                }
                handle->loadProperties(par);
                creature.addHandle(handle);
        }

        SString fHgenotype = creature.toString();

        if (NULL != map)
        {
                int fHpos = 0;
                SString line;
                fHgenotype.getNextToken(fHpos, line, '\n');
                int lastpos = fHpos;
                for (int t = 0; t < 3; t++)
                {
                        for (unsigned int q = 0; q < ranges[t].size(); q++)
                        {
                                fHgenotype.getNextToken(fHpos, line, '\n');
                                map->add(ranges[t][q].begin, ranges[t][q].end, lastpos, fHpos - 1);
                                lastpos = fHpos;
                        }
                }
        }

        return fHgenotype;
}

bool GenoConv_fBH::getNextCharId(const SString& genotype, int &i)
{
        i++;
        if (genotype[i] == '"')
        {
                int nextid = i + 1;
                do
                {
                        nextid = genotype.indexOf('"', nextid);
                        if (nextid == -1)
                        {
                                return false;
                        }
                        nextid++;
                } while (genotype[nextid] == '"');
                i = nextid;
        }
        return true;
}

bool GenoConv_fBH::getNeuroClass(const SString& gene, SString &def, int nclassdefcount)
{
        SString lastdef = "N";
        int nclass = 0;
        int pos = 0;
        while (nclass < nclassdefcount)
        {
                pos = gene.indexOf('\"', pos);
                if (pos == -1)
                {
                        def = lastdef;
                        return true;
                }
                pos++;
                SString currdef;
                if (gene.indexOf('\"', pos) == -1 || !gene.getNextToken(pos, currdef, '\"'))
                {
                        def = lastdef;
                        return false;
                }
                lastdef = currdef;
                nclass++;
        }
        def = lastdef;
        return true;
}

int GenoConv_fBH::processNextLetter(fH_Builder &creature, fH_Handle *&currhandle, Param &par, const SString& gene, int &propindex, int &i, std::vector<IRange> ranges[3], int &nclassdefcount)
{
        if (propindex >= par.getPropCount())
        {
                int tmpend = currhandle->end;
                currhandle->end = i - 1;
                currhandle->loadProperties(par);
                creature.addHandle(currhandle);
                currhandle = convertCharacterToHandle(gene[i], currhandle->getDimensions(), currhandle->begin + i, tmpend, ranges);
                ParamEntry *tab = creature.getParamTab(currhandle->type);
                par.setParamTab(tab);
                void *obj = ParamObject::makeObject(tab);
                par.select(obj);
                par.setDefault();
                propindex = 0;
                if (!getNextCharId(gene, i))
                        return -1;
                return 0;
        }
        else
        {
                if (*par.type(propindex) == 'f')
                {
                        if (currhandle->type == fHBodyType::CONNECTION && *par.id(propindex) == 'w')
                        {
                                par.setDouble(propindex, convertCharacterToWeight(gene[i]));
                        }
                        else
                        {
                                double val = convertCharacterTo01(gene[i]);
                                double mn, mx, def;
                                par.getMinMaxDouble(propindex, mn, mx, def);
                                par.setDouble(propindex, std::min(mx, std::max(mn, (mx - mn) * val + mn)));
                        }
                        propindex++;
                        if (!getNextCharId(gene, i))
                                return -1;
                        return 0;
                }
                else if (currhandle->type == fHBodyType::NEURON && *par.id(propindex) == 'd')
                {
                        //When 'd' property appears for i-th element in gene, the method
                        //looks for i-th neuron definition
                        SString nclass;
                        if (!getNeuroClass(gene, nclass, nclassdefcount)) return -1;
                        par.setString(propindex, nclass);
                        propindex++;
                        nclassdefcount++;
                        if (!getNextCharId(gene, i))
                                return -1;
                        return 0;
                }
                // other property types are not available in this encoding
                return -1;
        }
}