source: cpp/frams/genetics/genman.cpp @ 1288

Last change on this file since 1288 was 1273, checked in by Maciej Komosinski, 15 months ago

fH, fB, fL: improved default parameter values, syntax coloring and code logic
  • Property svn:eol-style set to native
File size: 26.0 KB
RevLine 
[286]1// This file is a part of Framsticks SDK.  http://www.framsticks.com/
[955]2// Copyright (C) 1999-2020  Maciej Komosinski and Szymon Ulatowski.
[286]3// See LICENSE.txt for details.
[138]4
5#include "genman.h"
6#include <frams/vm/classes/genoobj.h>
7#include GEN_CONFIG_FILE //configuration of active genetic operators
[375]8#include "common/log.h"
[138]9#include "common/nonstd_math.h"
[841]10#include "common/util-string.h"
[391]11#include <common/loggers/loggers.h>
[138]12
13
[1273]14#define GENMAN_REPEAT_FAILED 100 //how many times GenMan tries to repeat a mutation or crossover when the operator does not return an acceptable genotype
[761]15#define STRINGIFY_1(x) #x
16#define STRINGIFY(x) STRINGIFY_1(x) //this second-level macro allows the parameter to be a macro itself and to stringify its value, not its name
17#define GENMAN_REPEAT_FAILED_STR STRINGIFY(GENMAN_REPEAT_FAILED)
18
19
[139]20#ifdef USE_GENMAN_f0
[779]21#include "f0/f0_oper.h"
[138]22#endif
[977]23#ifdef USE_GENMAN_f0s
24#include "f0s/f0s_oper.h"
25#endif
[139]26#ifdef USE_GENMAN_f0FUZZY
[779]27#include "f0/f0Fuzzy_oper.h"
[138]28#endif
[139]29#ifdef USE_GENMAN_f1
[779]30#include "f1/f1_oper.h"
[138]31#endif
[139]32#ifdef USE_GENMAN_f2
[779]33#include "f2/f2_oper.h"
[138]34#endif
[139]35#ifdef USE_GENMAN_f2
[779]36#include "f3/f3_oper.h"
[138]37#endif
[139]38#ifdef USE_GENMAN_f4
[779]39#include "f4/f4_oper.h"
[138]40#endif
[139]41#ifdef USE_GENMAN_f5
[779]42#include "f5/f5_oper.h"
[138]43#endif
[139]44#ifdef USE_GENMAN_f6
[779]45#include "f6/f6_oper.h"
[138]46#endif
[139]47#ifdef USE_GENMAN_f7
[779]48#include "f7/f7_oper.h"
[138]49#endif
[139]50#ifdef USE_GENMAN_f8
[779]51#include "f8/f8_oper.h"
[138]52#endif
[139]53#ifdef USE_GENMAN_f9
[779]54#include "f9/f9_oper.h"
[138]55#endif
[139]56#ifdef USE_GENMAN_fF
[779]57#include "fF/fF_oper.h"
[139]58#endif
[748]59#ifdef USE_GENMAN_fn
[779]60#include "fn/fn_oper.h"
[748]61#endif
[194]62#ifdef USE_GENMAN_fT
[779]63#include "fT/fTest_oper.h"
[194]64#endif
[780]65#ifdef USE_GENMAN_fB
66#include "fB/fB_oper.h"
67#endif
68#ifdef USE_GENMAN_fH
69#include "fH/fH_oper.h"
70#endif
71#ifdef USE_GENMAN_fL
72#include "fL/fL_oper.h"
73#endif
[955]74#ifdef USE_GENMAN_fS
75#include "fS/fS_oper.h"
76#endif
[138]77
78using namespace std; //string, vector
79
80//old code needs update:
81//#include "gengroups.h"
82//extern GenGroup *listaGen;
83//   GENGROUP(0)->l_del.add(sim->GM.onDelGen,&sim->GM); //before delete
84//   GENGROUP(0)->l_del.remove(sim->GM.onDelGen,&sim->GM); //before delete
85
86
87#define FIELDSTRUCT GenMan
88
89static ParamEntry GMparam_tab[] =
90{
[965]91        { "Genetics", 1, 11, "GenMan", },
[138]92        { "gen_hist", 0, PARAM_DONTSAVE, "Remember history of genetic operations", "d 0 1 0", FIELD(history), "Required for phylogenetic analysis", },
93        { "gen_hilite", 0, 0, "Use syntax highlighting", "d 0 1 1", FIELD(hilite), "Use colors for genes?\n(slows down viewing/editing of huge genotypes)", },
94        { "gen_extmutinfo", 0, 0, "Extended mutation info", "d 0 2 0 ~Off~Method ID~Method description", FIELD(extmutinfo), "If active, information about employed mutation method will be stored in the 'info' field of each mutated genotype.", },
95        { "operReport", 0, PARAM_DONTSAVE, "Operators report", "p()", PROCEDURE(p_report), "Show available genetic operators", },
96        { "toHTML", 0, PARAM_DONTSAVE, "HTMLize a genotype", "p s(s)", PROCEDURE(p_htmlize), "returns genotype expressed as colored HTML", },
[965]97        { "toHTMLshort", 0, PARAM_DONTSAVE, "HTMLize a genotype, shorten if needed", "p s(s)", PROCEDURE(p_htmlizeshort), "returns genotype (abbreviated if needed) in colored HTML format", },
98        { "toLaTeX", 0, PARAM_DONTSAVE, "LaTeXize a genotype", "p s(s)", PROCEDURE(p_latexize), "returns genotype in colored LaTeX format", },
[240]99        { "validate", 0, PARAM_DONTSAVE | PARAM_USERHIDDEN, "Validate", "p oGeno(oGeno)", PROCEDURE(p_validate), "returns validated (if possible) Geno object from supplied Geno", },
100        { "mutate", 0, PARAM_DONTSAVE | PARAM_USERHIDDEN, "Mutate", "p oGeno(oGeno)", PROCEDURE(p_mutate), "returns mutated Geno object from supplied Geno", },
101        { "crossOver", 0, PARAM_DONTSAVE | PARAM_USERHIDDEN, "Crossover", "p oGeno(oGeno,oGeno)", PROCEDURE(p_crossover), "returns crossed over genotype", },
[668]102        { "getSimplest", 0, PARAM_DONTSAVE | PARAM_USERHIDDEN, "Get simplest genotype", "p oGeno(s format)", PROCEDURE(p_getsimplest), "returns the simplest genotype for a given encoding (format). \"0\" means f0, \"4\" means f4, etc.", },
[138]103        { 0, },
104};
105
106static ParamEntry GMstats_tab[] =
107{
108        { "Genetics", 1, 12, "GenManStats", "Statistics for genetic operations." },
109        { "gen_count", 0, PARAM_READONLY, "Number of genetic operations so far", "d", FIELD(count), "", },
110        { "gen_mvalid", 0, PARAM_READONLY, "Mutations valid", "d", FIELD(valid_m), "", },
111        { "gen_mvalidated", 0, PARAM_READONLY, "Mutations validated", "d", FIELD(validated_m), "", },
112        { "gen_minvalid", 0, PARAM_READONLY, "Mutations invalid", "d", FIELD(invalid_m), "couldn't be repaired", },
113        { "gen_mfailed", 0, PARAM_READONLY, "Mutations failed", "d", FIELD(failed_m), "couldn't be performed", },
114        { "gen_xovalid", 0, PARAM_READONLY, "Crossovers valid", "d", FIELD(valid_xo), "", },
115        { "gen_xovalidated", 0, PARAM_READONLY, "Crossovers validated", "d", FIELD(validated_xo), "", },
116        { "gen_xoinvalid", 0, PARAM_READONLY, "Crossovers invalid", "d", FIELD(invalid_xo), "couldn't be repaired", },
117        { "gen_xofailed", 0, PARAM_READONLY, "Crossovers failed", "d", FIELD(failed_xo), "couldn't be performed", },
118        { "gen_mutimpr", 0, PARAM_READONLY, "Mutations total effect", "f", FIELD(mutchg), "total cumulative mutation change", },
119        { "gen_xoimpr", 0, PARAM_READONLY, "Crossovers total effect", "f", FIELD(xochg), "total cumulative crossover change", },
120        { "clrstats", 0, PARAM_DONTSAVE, "Clear stats and history", "p()", PROCEDURE(p_clearStats), "", },
121        { 0, },
122};
123
124#undef FIELDSTRUCT
125
126GenMan::GenMan() : localpar(GMparam_tab, this), localstats(GMstats_tab, this),
127seloperpar("GenOperators", "Genetics: Active operators"),
[319]128neuronsparam("Genetics: Neurons to add", "neuronsAdd", "neuadd_"),
129par("GenMan", "Manages various genetic operations, using appropriate operators for the argument genotype format.")
[138]130{
131        history = 0;
132        hilite = 1;
133        clearStats();
134
[139]135#ifdef USE_GENMAN_f0
[145]136        oper_fx_list.push_back(new Geno_f0);
[138]137#endif
[977]138#ifdef USE_GENMAN_f0s
139        oper_fx_list.push_back(new Geno_f0s);
140#endif
[139]141#ifdef USE_GENMAN_f0FUZZY
[145]142        oper_fx_list.push_back(new Geno_f0Fuzzy);
[138]143#endif
[139]144#ifdef USE_GENMAN_f1
[145]145        oper_fx_list.push_back(new Geno_f1);
[138]146#endif
[139]147#ifdef USE_GENMAN_f2
[145]148        oper_fx_list.push_back(new Geno_f2);
[138]149#endif
[139]150#ifdef USE_GENMAN_f3
[145]151        oper_fx_list.push_back(new Geno_f3);
[138]152#endif
[139]153#ifdef USE_GENMAN_f4
[145]154        oper_fx_list.push_back(new Geno_f4);
[138]155#endif
[139]156#ifdef USE_GENMAN_f5
[145]157        oper_fx_list.push_back(new Geno_f5);
[138]158#endif
[139]159#ifdef USE_GENMAN_f6
[145]160        oper_fx_list.push_back(new Geno_f6);
[138]161#endif
[139]162#ifdef USE_GENMAN_f7
[145]163        oper_fx_list.push_back(new Geno_f7);
[138]164#endif
[139]165#ifdef USE_GENMAN_f8
[145]166        oper_fx_list.push_back(new Geno_f8);
[138]167#endif
[139]168#ifdef USE_GENMAN_f9
[145]169        oper_fx_list.push_back(new GenoOper_f9);
[138]170#endif
[139]171#ifdef USE_GENMAN_fF
[145]172        oper_fx_list.push_back(new GenoOper_fF);
[139]173#endif
[748]174#ifdef USE_GENMAN_fn
175        oper_fx_list.push_back(new GenoOper_fn);
176#endif
[194]177#ifdef USE_GENMAN_fT
178        oper_fx_list.push_back(new GenoOper_fTest);
179#endif
[780]180#ifdef USE_GENMAN_fB
181        oper_fx_list.push_back(new Geno_fB);
182#endif
183#ifdef USE_GENMAN_fH
184        oper_fx_list.push_back(new Geno_fH);
185#endif
186#ifdef USE_GENMAN_fL
187        oper_fx_list.push_back(new Geno_fL);
188#endif
[955]189#ifdef USE_GENMAN_fS
190        oper_fx_list.push_back(new GenoOper_fS);
191#endif
[138]192
[145]193        seloper = new int[oper_fx_list.size()]; //may result in a little overhead if some of the operators on the oper_fx_list concern the same genetic format
[138]194        int selopercount = 0;
[145]195        for (unsigned int i = 0; i < oper_fx_list.size(); i++)
[138]196        {
[955]197                if (findOperFormatIndex(oper_fx_list[i]->supported_format) != -1) continue;
[200]198                string type = string("~") + oper_fx_list[i]->name;
[138]199                int dup = 0;
[145]200                for (unsigned int j = i + 1; j < oper_fx_list.size(); j++)
201                        if (oper_fx_list[i]->supported_format == oper_fx_list[j]->supported_format)
[138]202                        {
[955]203                                type += "~";
204                                type += oper_fx_list[j]->name;
205                                dup++;
[138]206                        }
[200]207                type = ssprintf("d 0 %d ", dup) + type;
[955]208                string id = ssprintf("genoper_f%s", oper_fx_list[i]->supported_format.c_str());
209                string name = ssprintf("Operators for f%s", oper_fx_list[i]->supported_format.c_str());
[138]210                seloper[selopercount] = 0;
[955]211                operformats += &oper_fx_list[i]->supported_format;
[138]212                //printf("%x %s %s %s\n",&seloper[selopercount],(const char*)id,(const char*)type,(const char*)name);
[955]213                seloperpar.addProperty(&seloper[selopercount++], id.c_str(), type.c_str(), name.c_str(), "", PARAM_READONLY * (dup == 0));
[138]214        }
215
216        par += &localpar;
217        par += &seloperpar;
218        par += &neuronsparam;
[145]219        for (unsigned int i = 0; i < oper_fx_list.size(); i++)
220                if (oper_fx_list[i]->par.getParamTab()) par += &oper_fx_list[i]->par;
[715]221
222        setDefaults(); //use Param to initialize all values of fields in the paramtab of this object and genetic operators on oper_fx_list
[138]223}
224
225GenMan::~GenMan()
226{
[145]227        for (unsigned int i = 0; i < oper_fx_list.size(); i++) delete oper_fx_list[i];
[138]228        delete[] seloper;
229}
230
[955]231int GenMan::findOperFormatIndex(const SString& format)
232{
233        for (int i = 0; i < operformats.size(); i++)
234                if (*operformats(i) == format)
235                        return i;
236        return -1;
237}
238
[138]239void GenMan::setDefaults()
240{
[145]241        for (unsigned int i = 0; i < oper_fx_list.size(); i++)
[138]242        {
[145]243                oper_fx_list[i]->par.setDefault();
244                oper_fx_list[i]->setDefaults();
[138]245        }
246        localpar.setDefault();
247        //...and we do not reset others that are linked to 'par',
248        //because there quite a few of them, and not every of them defines defaults for each of its parameters.
249}
250
251int GenMan::testValidity(Geno &g, bool &canvalidate)
252{
[761]253        SString ggs = g.getGenes();
[348]254        const char *gg = ggs.c_str();
[145]255        GenoOperators *gf = getOper_f(g.getFormat());
[138]256        int check1;
257        if (!gf) { canvalidate = false; return GENOPER_NOOPER; }
[761]258        else check1 = gf->checkValidity(gg, g.getName().c_str());
[138]259        if (!canvalidate) return check1; //just checking
260        if (check1 == GENOPER_OK) { canvalidate = false; return check1; }
261        char *g2 = strdup(gg);
[761]262        if (gf->validate(g2, g.getName().c_str()) == GENOPER_NOOPER) { free(g2); canvalidate = false; return check1; }
[138]263        if (check1 == GENOPER_NOOPER) //disaster: cannot check because there is no check operator
264        {
[534]265                g.setGenesAssumingSameFormat(g2); free(g2); canvalidate = false; return GENOPER_NOOPER;
[138]266        }
[513]267        int check2 = gf->checkValidity(g2, "validated");
[534]268        if (check2 == GENOPER_OK) g.setGenesAssumingSameFormat(g2);
[138]269        free(g2);
270        if (check2 == GENOPER_OK) return check1;
271        canvalidate = false;
272        return check1; //could not validate.
273}
274
275int GenMan::testGenoValidity(Geno& g)
276{
277        bool fix = false;
278        switch (testValidity(g, fix))
279        {
280        case GENOPER_OK: return 1;
281        case GENOPER_NOOPER: return -1;
282        default: return 0;
283        }
284}
285
[532]286Geno GenMan::validate(const Geno& geny)
[138]287{
[955]288        SString format = geny.getFormat();
[168]289        GenoOperators *gf = getOper_f(format);
290        if (gf == NULL)
[988]291                return Geno("", Geno::FORMAT_INVALID, "", SString::sprintf("GENOPER_NOOPER: Validate(): don't know how to handle genetic format %s", format.c_str()));
[534]292        char *g2 = strdup(geny.getGenes().c_str()); //copy for validation
[513]293        int res = gf->validate(g2, geny.getName().c_str());
[168]294        SString sg2 = g2;
[138]295        free(g2);
[168]296        if (res == GENOPER_OK)
297                return Geno(sg2, format, geny.getName(), geny.getComment());
[138]298        else
[988]299                return Geno("", Geno::FORMAT_INVALID, "", SString::sprintf("GENOPER_NOOPER: validate() for format %s returned invalid value", format.c_str()));
[138]300}
301
[532]302Geno GenMan::mutate(const Geno& g)
[138]303{
304        float chg; //how many changes
305        int method; //mutation method
[955]306        SString format = g.getFormat();
[168]307        GenoOperators *gf = getOper_f(format);
308        if (gf == NULL)
[988]309                return Geno("", Geno::FORMAT_INVALID, "", SString::sprintf("GENOPER_NOOPER: Mutate(): don't know how to handle genetic format %s", format.c_str()));
[168]310        Geno gv = g;
311        bool canvalidate = true;
312        if (testValidity(gv, canvalidate) > 0 && canvalidate == false)
[988]313                return Geno("", Geno::FORMAT_INVALID, "", "GENOPER_OPFAIL: Mutate(): cannot validate invalid source genotype");
[168]314        bool ok = false;
315        int pcount = count;
[138]316        while (!ok)
317        {
[534]318                char *gn = strdup(gv.getGenes().c_str()); //copy for mutation
[168]319                chg = 0;
320                if (gf->mutate(gn, chg, method) == GENOPER_OK)
[138]321                {
[375]322                        LoggerToMemory eh(LoggerBase::Enable | LoggerToMemory::StoreFirstMessage); //mute testValidity()
[168]323                        Geno G(gn, gv.getFormat(), "", "");
324                        canvalidate = true;
325                        int res = testValidity(G, canvalidate);
326                        if (res == GENOPER_OK && canvalidate == false) { valid_m++; ok = true; }
327                        else
328                                if (res > 0 && canvalidate == false) invalid_m++; else
329                                {
[955]330                                        validated_m++; ok = true;
[168]331                                }
332                        if (ok) gv = G;
333                }
334                else failed_m++;
[138]335                free(gn);
336                count++;
[761]337                if (!ok && (count - pcount > GENMAN_REPEAT_FAILED))
[138]338                {
[955]339                        logPrintf("GenMan", "Mutate", LOG_WARN, "Tried " GENMAN_REPEAT_FAILED_STR "x and failed: %s", g.getGenes().c_str());
[761]340                        return Geno("", -1, "", "GENOPER_OPFAIL: Mutate() tried " GENMAN_REPEAT_FAILED_STR "x and failed");
[138]341                }
342        }
[168]343        mutchg += chg;
[534]344        if (history) saveLink(g.getGenes().c_str(), "", gv.getGenes().c_str(), chg);
[138]345        SString mutinfo;
[348]346        if (extmutinfo == 0) mutinfo = SString::sprintf("%.2f%% mutation of '%s'", 100 * chg, g.getName().c_str()); else
347                if (extmutinfo == 1) mutinfo = SString::sprintf("%.2f%% mutation(%d) of '%s'", 100 * chg, method, g.getName().c_str()); else
348                        mutinfo = SString::sprintf("%.2f%% mutation(%s) of '%s'", 100 * chg, gf->mutation_method_names ? gf->mutation_method_names[method] : "unspecified method name", g.getName().c_str());
[138]349        gv.setComment(mutinfo);
350        return gv;
351}
352
[532]353Geno GenMan::crossOver(const Geno& g1, const Geno& g2)
[138]354{
[955]355        SString format = g1.getFormat();
[988]356        if (format != g2.getFormat()) return Geno("", Geno::FORMAT_INVALID, "", SString::sprintf("GENOPER_NOOPER: CrossOver(): does not work for parents with differing genetic formats (%s and %s)", format.c_str(), g2.getFormat().c_str()));
[145]357        GenoOperators *gf = getOper_f(format);
[138]358        if (gf == NULL)
[988]359                return Geno("", Geno::FORMAT_INVALID, "", SString::sprintf("GENOPER_NOOPER: CrossOver(): no operators found for genetic format %s", format.c_str()));
[138]360        Geno g1v = g1, g2v = g2;
361
362        {
[375]363                LoggerToMemory eh(LoggerBase::Enable | LoggerToMemory::StoreFirstMessage); //mute testValidity()
[138]364                bool canvalidate = true;
365                if (testValidity(g1v, canvalidate) > 0 && canvalidate == false)
[988]366                        return Geno("", Geno::FORMAT_INVALID, "", "GENOPER_OPFAIL: CrossOver(): cannot validate invalid source genotype #1");
[138]367                canvalidate = true;
368                if (testValidity(g2v, canvalidate) > 0 && canvalidate == false)
[988]369                        return Geno("", Geno::FORMAT_INVALID, "", "GENOPER_OPFAIL: CrossOver(): cannot validate invalid source genotype #2");
[138]370        }
371
372        float chg;
373        bool ok = false;
374        int pcount = count;
375
376        while (!ok)
377        {
378                float chg1, chg2;
[534]379                char *g1n = strdup(g1.getGenes().c_str()); //copy for crossover
380                char *g2n = strdup(g2.getGenes().c_str()); //copy for crossover
[138]381                chg1 = chg2 = 0;
382                if (gf->crossOver(g1n, g2n, chg1, chg2) == GENOPER_OK)
383                {
384                        char *gn;
[896]385                        if (g1n[0] && g2n[0]) if (rndUint(2) == 0) g1n[0] = 0; else g2n[0] = 0; //both provided? we want only one
[138]386                        if (g1n[0]) { gn = g1n; chg = chg1; }
387                        else { gn = g2n; chg = chg2; }
[375]388                        LoggerToMemory eh(LoggerBase::Enable | LoggerToMemory::StoreFirstMessage); //mute testValidity()
[138]389                        Geno G(gn, g1v.getFormat(), "", "");
390                        bool canvalidate = true;
391                        int res = testValidity(G, canvalidate);
392                        if (res == GENOPER_OK && canvalidate == false) { valid_xo++; ok = true; }
393                        else
394                                if (res > 0 && canvalidate == false) invalid_xo++; else
395                                {
[955]396                                        validated_xo++; ok = true;
[138]397                                }
398                        if (ok) g1v = G;
399                }
400                else failed_xo++;
401                free(g1n);
402                free(g2n);
403                count++;
[761]404                if (!ok && (count - pcount > GENMAN_REPEAT_FAILED))
[138]405                {
[955]406                        logPrintf("GenMan", "CrossOver", LOG_WARN, "Tried " GENMAN_REPEAT_FAILED_STR "x and failed: %s and %s", g1.getGenes().c_str(), g2.getGenes().c_str());
[988]407                        return Geno("", Geno::FORMAT_INVALID, "", "GENOPER_OPFAIL: CrossOver() tried " GENMAN_REPEAT_FAILED_STR "x and failed");
[138]408                }
409        }
410        // result in g1v
411        xochg += chg;
[534]412        if (history) saveLink(g1.getGenes().c_str(), g2.getGenes().c_str(), g1v.getGenes().c_str(), chg);
[138]413        SString xoinfo = SString::sprintf("Crossing over of '%s' (%.2f%%) and '%s' (%.2f%%)",
[348]414                g1.getName().c_str(), 100 * chg, g2.getName().c_str(), 100 * (1 - chg));
[138]415        g1v.setComment(xoinfo);
416        return g1v;
417}
418
[532]419float GenMan::similarity(const Geno& g1, const Geno& g2)
[138]420{
[955]421        SString format = g1.getFormat();
[138]422        if (format != g2.getFormat()) return GENOPER_NOOPER;
[145]423        GenoOperators *gf = getOper_f(format);
[534]424        if (!gf) return GENOPER_NOOPER; else return gf->similarity(g1.getGenes().c_str(), g2.getGenes().c_str());
[138]425}
426
[532]427uint32_t GenMan::getStyle(const char *g, const Geno *G, int pos)
[138]428{
[955]429        SString format = G->getFormat();
[988]430        if (format == Geno::FORMAT_INVALID)
[532]431                return GENSTYLE_RGBS(64, 64, 64, 0); // gray & "valid" (unknown format so we don't know what is valid and what is not)
432        if ((pos = G->mapStringToGen(pos)) == -1) return GENSTYLE_COMMENT;
433        GenoOperators *gf = getOper_f(format);
[138]434        if (!gf) return GENSTYLE_CS(0, 0); //black & valid
[534]435        else return gf->style(G->getGenes().c_str(), pos);
[138]436}
437
[532]438uint32_t GenMan::getStyle(const char *g, int pos)
[138]439{
440        Geno G(g);
[532]441        return getStyle(g, &G, pos);
442}
443
444void GenMan::getFullStyle(const char *g, const Geno *G, uint32_t *styletab)
445{
[955]446        SString format = G->getFormat();
[988]447        if (format == Geno::FORMAT_INVALID)
[532]448        {
449                for (unsigned int pos = 0; pos < strlen(g); pos++)
450                        styletab[pos] = GENSTYLE_RGBS(64, 64, 64, 0); // gray & "valid" (unknown format so we don't know what is valid and what is not)
451                return;
452        }
453        GenoOperators *gf = getOper_f(format);
[761]454        SString geny = G->getGenes();
[138]455        for (unsigned int pos = 0; pos < strlen(g); pos++)
456        {
[532]457                int posmapped = G->mapStringToGen(pos);
[138]458                if (posmapped == -1) styletab[pos] = GENSTYLE_COMMENT;
459                else if (!gf) styletab[pos] = GENSTYLE_CS(0, 0); //black & valid
[348]460                else styletab[pos] = gf->style(geny.c_str(), posmapped);
[955]461                //logPrintf("GenMan", "getFullStyle", LOG_INFO, "%d  char='%c' (%d)  format=0x%08x", pos, g[pos], g[pos], styletab[pos]);
[138]462        }
463}
464
[532]465void GenMan::getFullStyle(const char *g, uint32_t *styletab)
466{
467        Geno G(g);
468        getFullStyle(g, &G, styletab);
469}
470
[467]471string GenMan::HTMLize(const char *g) { return HTMLize(g, false); }
[138]472
[467]473string GenMan::HTMLizeShort(const char *g) { return HTMLize(g, true); }
[138]474
[467]475string GenMan::HTMLize(const char *g, bool shorten)
[138]476{
477        char buf[50];
[1238]478        int len = int(strlen(g));
[138]479        int chars = 0, lines = 0;
480        bool shortened = false;
[247]481        uint32_t *styletab = new uint32_t[len];
[532]482        getFullStyle(g, styletab);
[1238]483        string html = "<style>"
484                "span.geno{background:white; padding:0.2em; font-family:arial,helvetica,sans-serif}"
485                "</style>\n\n";
486        html += "<span class=\"geno\">";
[247]487        uint32_t prevstyle, prevcolor, style = 0, color = 0;
[761]488        for (int i = 0; i < len; i++)
[138]489        {
[761]490                if (shorten && ((lines == 0 && chars > 160) || (lines > 5 || chars > 300))) { shortened = true; break; }
[138]491                if (g[i] == '\r') continue;
492                if (g[i] == '\n') { html += "<br>\n"; lines++; continue; }
493                chars++;
494                prevstyle = style;
495                prevcolor = color;
496                style = GENGETSTYLE(styletab[i]);
497                color = GENGETCOLOR(styletab[i]);
498                if ((i != 0 && (color != prevcolor))) html += "</font>";
[955]499                if ((style & GENSTYLE_INVALID) != (prevstyle & GENSTYLE_INVALID))
[138]500                {
[955]501                        html += "<"; if (!(style & GENSTYLE_INVALID)) html += "/"; html += "u>";
[138]502                }
[955]503                if ((style & GENSTYLE_BOLD) != (prevstyle & GENSTYLE_BOLD))
[138]504                {
[955]505                        html += "<"; if (!(style & GENSTYLE_BOLD)) html += "/"; html += "b>";
[138]506                }
[955]507                if ((style & GENSTYLE_ITALIC) != (prevstyle & GENSTYLE_ITALIC))
[138]508                {
[955]509                        html += "<"; if (!(style & GENSTYLE_ITALIC)) html += "/"; html += "i>";
[138]510                }
511                if ((i == 0 || (color != prevcolor)))
512                {
513                        sprintf(buf, "<font color=#%02x%02x%02x>", GENGET_R(color), GENGET_G(color), GENGET_B(color)); html += buf;
514                }
515                if (g[i] == '<') html += "&lt;"; else if (g[i] == '>') html += "&gt;"; else html += g[i];
516                if ((i % 3) == 0 && g[i] == ' ') html += "\n"; //for readability, insert some newlines into html...
517        }
518        delete[] styletab;
519        html += "</u></b></i></font>";
520        if (shortened) html += " [etc...]";
[1238]521        html += "</span>\n";
[138]522        return html;
523}
524
525void GenMan::p_htmlize(ExtValue *args, ExtValue *ret)
526{
[467]527        ret->setString(HTMLize(args->getString().c_str()).c_str());
[138]528}
529
530void GenMan::p_htmlizeshort(ExtValue *args, ExtValue *ret)
531{
[467]532        ret->setString(HTMLizeShort(args->getString().c_str()).c_str());
[138]533}
534
[965]535string GenMan::LaTeXize(const char *g)
536{
537        char buf[50];
[1238]538        int len = int(strlen(g));
[965]539        int chars = 0, lines = 0; //currently not used
540        uint32_t *styletab = new uint32_t[len];
541        getFullStyle(g, styletab);
542        string latex = "\\usepackage{xcolor}\n% Using \\texttt{} may be beneficial for some genetic encodings, but then you may lose bold/italic.\n\\noindent \\sloppy";
543        uint32_t prevstyle, prevcolor, style = 0, color = 0;
544        for (int i = 0; i < len; i++)
545        {
546                if (g[i] == '\r') continue;
547                if (g[i] == '\n') { latex += "\\\\\n"; lines++; continue; }
548                chars++;
549                prevstyle = style;
550                prevcolor = color;
551                style = GENGETSTYLE(styletab[i]);
552                color = GENGETCOLOR(styletab[i]);
553
554                // Unfortunately, LaTeX (as opposed to HTML) uses the same closing tags "}" for color, bold, italic, underline - so they cannot intersect.
555                // Therefore we have to "turn off" everything on every change of style or color, and then "turn on" (to avoid problems with e.g. red-bold-blue-unbold or bold-italic-unbold-unitalic).
556                // This could be optimized by a more complex logic and tracking which color/style section starts and ends within another section.
557
558                if (((style & GENSTYLE_INVALID) != (prevstyle & GENSTYLE_INVALID))
559                        ||
560                        ((style & GENSTYLE_BOLD) != (prevstyle & GENSTYLE_BOLD))
561                        ||
562                        ((style & GENSTYLE_ITALIC) != (prevstyle & GENSTYLE_ITALIC))
563                        ||
564                        ((i == 0 || (color != prevcolor))))
565                {
566                        if (prevstyle & GENSTYLE_INVALID) latex += "}";
567                        if (prevstyle & GENSTYLE_BOLD) latex += "}";
568                        if (prevstyle & GENSTYLE_ITALIC) latex += "}";
569                        if (i != 0) latex += "}"; //for color
570                        if (style & GENSTYLE_INVALID) latex += "\\underline{";
571                        if (style & GENSTYLE_BOLD) latex += "\\textbf{";
572                        if (style & GENSTYLE_ITALIC) latex += "\\textit{";
573                        sprintf(buf, "\\textcolor[rgb]{%.2g,%.2g,%.2g}{", GENGET_R(color) / 255.0, GENGET_G(color) / 255.0, GENGET_B(color) / 255.0); latex += buf;
574                }
575                if (g[i] == '<') latex += "$<$"; else if (g[i] == '>') latex += "$>$"; else
576                        if (g[i] == '-') latex += "$-$"; else if (g[i] == '|') latex += "$|$"; else
[1273]577                                if (g[i] == '$') latex += "\\$"; else if (g[i] == '%') latex += "\\%"; else
578                                        if (g[i] == '#') latex += "\\#"; else latex += g[i];
[965]579                if ((i % 3) == 0 && g[i] == ' ') latex += "\n"; //for readability, insert some newlines into latex...
580                if (i % 10 == 0) latex += "{\\hskip 0pt}"; // https://tex.stackexchange.com/questions/33526/automatic-line-breaking-of-long-lines-of-text
581        }
582        delete[] styletab;
583        latex += "}"; //for color (it was used at least once)
[966]584        if (style & GENSTYLE_INVALID) latex += "}";
[965]585        if (style & GENSTYLE_BOLD) latex += "}";
586        if (style & GENSTYLE_ITALIC) latex += "}";
587        latex += "\n";
588        return latex;
589}
590
591void GenMan::p_latexize(ExtValue *args, ExtValue *ret)
592{
593        ret->setString(LaTeXize(args->getString().c_str()).c_str());
594}
595
[955]596Geno GenMan::getSimplest(const SString& format)
[138]597{
[145]598        GenoOperators *gf = getOper_f(format);
[138]599        if (!gf) return Geno();
[955]600        string info = "The simplest genotype of format f"; info += format.c_str();
[138]601        info += " for operators '"; info += gf->name; info += "'.";
[200]602        return Geno(gf->getSimplest(), format, "Root", info.c_str());
[138]603}
604
605void GenMan::p_getsimplest(ExtValue *args, ExtValue *ret)
606{
[955]607        SString format = GenoObj::formatFromExtValue(args[0]);
[145]608        if (!getOper_f(format))
[138]609                ret->setEmpty();
610        else
[532]611                *ret = GenoObj::makeDynamicObjectAndDecRef(new Geno(getSimplest(format)));
[138]612}
613
[955]614const char *GenMan::getOpName(const SString& format)
[138]615{
[145]616        GenoOperators *gf = getOper_f(format);
[200]617        if (!gf) return "n/a"; else return gf->name.c_str();
[138]618}
619
[955]620GenoOperators* GenMan::getOper_f(const SString& format)
[138]621{
[955]622        int ind = findOperFormatIndex(format);
[138]623        if (ind == -1) return NULL;
[168]624        int which_oper_of_format = seloper[ind];
[145]625        for (unsigned int i = 0; i < oper_fx_list.size(); i++)
626                if (oper_fx_list[i]->supported_format == format)
[168]627                        if (which_oper_of_format == 0) return oper_fx_list[i]; else which_oper_of_format--;
[138]628        return NULL; //should never happen
629}
630
[275]631void GenMan::saveLink(const string parent1, const string parent2, const string child, const float chg)
[138]632{
633        GenoLink l;
634        l.count = count;
[275]635        l.parent1 = parent1;
636        l.parent2 = parent2;
637        l.child = child;
[138]638        l.chg = chg;
639        l.fit = 0; //temporarily. Will be set when the genotype dies
[375]640        //logPrintf("GenMan","saveLink",0,"#%d: [%d] '%s' + '%s' -> '%s'",GenoLinkList.size(),count,parent1.c_str(),parent2.c_str(),child.c_str());
[138]641        GenoLinkList.push_back(l);
642}
643
[247]644void GenMan::onDelGen(void *obj, intptr_t n)
[138]645{
646        //old code needs update:
647        //   ((SpeciesList*)obj)->przyDodaniu(i);
648        /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
649           GenMan *gm=(GenMan*)obj;
650           Genotype *gt=(Genotype*)(*listaGen)(n); //there is no more "listaGen"
651           string g=(const char*)gt->genotype.getGene();
652           float fit=gt->getFinalFitness();
653           for(int i=0;i<gm->GenoLinkList.size();i++) //find genotype
654           if (gm->GenoLinkList[i].g1==g) {gm->GenoLinkList[i].fit=fit; break;}
655           */
656}
657
658void GenMan::clearStats()
659{
660        count = 0;
661        valid_m = valid_xo = validated_m = validated_xo = invalid_m = invalid_xo = failed_m = failed_xo = 0;
662        mutchg = xochg = 0;
663        GenoLinkList.clear();
664}
665
666void GenMan::p_clearStats(ExtValue *args, ExtValue *ret) { clearStats(); }
667
668void GenMan::p_report(ExtValue *args, ExtValue *ret)
669{                      //should be updated to handle multiple operators for a single format
670        char *g, *g2;
[145]671        float f1, f2;
672        int m;
[375]673        logMessage("GenMan", "Report", 0, "The following genetic operators are available:");
[145]674        for (unsigned int i = 0; i < oper_fx_list.size(); i++)
[138]675        {
[200]676                string l;
[761]677                if (oper_fx_list[i]->checkValidity("", "") != GENOPER_NOOPER) l += " checkValidity";
[145]678                if (oper_fx_list[i]->getSimplest())
[138]679                {
[145]680                        g = strdup(oper_fx_list[i]->getSimplest());
[138]681                        g2 = strdup(g);
[761]682                        if (oper_fx_list[i]->validate(g, "") != GENOPER_NOOPER) l += " validate";
[145]683                        if (oper_fx_list[i]->mutate(g, f1, m) != GENOPER_NOOPER) l += " mutate";
684                        if (oper_fx_list[i]->crossOver(g, g2, f1, f2) != GENOPER_NOOPER) l += " crossover";
[138]685                        l += " getSimplest";
686                        free(g); free(g2);
687                }
[145]688                //      if (oper_fx_list[i]->similarity("","")!=GENOPER_NOOPER) l+=" similarity";
[955]689                logPrintf("GenMan", "Report", LOG_INFO, "format f%s (%s):%s",
690                        oper_fx_list[i]->supported_format.c_str(), oper_fx_list[i]->name.c_str(), l.c_str());
[138]691        }
692}
693
694void GenMan::p_validate(ExtValue *args, ExtValue *ret)
695{
696        Geno *g = GenoObj::fromObject(args[0]);
697        if (g == NULL)
698                ret->setEmpty();
699        else
[532]700                *ret = GenoObj::makeDynamicObjectAndDecRef(new Geno(validate(*g)));
[138]701}
702
703void GenMan::p_mutate(ExtValue *args, ExtValue *ret)
704{
705        Geno *g = GenoObj::fromObject(args[0]);
706        if (g == NULL)
707                ret->setEmpty();
708        else
[532]709                *ret = GenoObj::makeDynamicObjectAndDecRef(new Geno(mutate(*g)));
[138]710}
711
712void GenMan::p_crossover(ExtValue *args, ExtValue *ret)
713{
714        Geno *g1 = GenoObj::fromObject(args[1]);
715        Geno *g2 = GenoObj::fromObject(args[0]);
716        if (g1 == NULL || g2 == NULL)
717                ret->setEmpty();
718        else
[532]719                *ret = GenoObj::makeDynamicObjectAndDecRef(new Geno(crossOver(*g1, *g2)));
[138]720}
[532]721
Note: See TracBrowser for help on using the repository browser.