Context Navigation

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

Last change on this file since 1045 was 988, checked in by Maciej Komosinski, 4 years ago
Building a Model from Geno now fails when Model.shape is incompatible with Geno.format; renamed enum constants for genetic formats: xxx_FORMAT => FORMAT_xxx
Property svn:eol-style set to `native`
File size: 25.9 KB

Rev	Line
[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
[768]	14	#define GENMAN_REPEAT_FAILED 100 //how many times GenMan tries to repeat a mutation or crossover when the operator does not return 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
	78	using 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
	89	static 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
	106	static 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
	126	GenMan::GenMan() : localpar(GMparam_tab, this), localstats(GMstats_tab, this),
	127	seloperpar("GenOperators", "Genetics: Active operators"),
[319]	128	neuronsparam("Genetics: Neurons to add", "neuronsAdd", "neuadd_"),
	129	par("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
	225	GenMan::~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]	231	int 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]	239	void 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
	251	int 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
	275	int 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]	286	Geno 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]	302	Geno 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]	353	Geno 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]	419	float 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]	427	uint32_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]	438	uint32_t GenMan::getStyle(const char *g, int pos)
[138]	439	{
	440	Geno G(g);
[532]	441	return getStyle(g, &G, pos);
	442	}
	443
	444	void 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]	465	void GenMan::getFullStyle(const char g, uint32_t styletab)
	466	{
	467	Geno G(g);
	468	getFullStyle(g, &G, styletab);
	469	}
	470
[467]	471	string GenMan::HTMLize(const char *g) { return HTMLize(g, false); }
[138]	472
[467]	473	string GenMan::HTMLizeShort(const char *g) { return HTMLize(g, true); }
[138]	474
[467]	475	string GenMan::HTMLize(const char *g, bool shorten)
[138]	476	{
	477	char buf[50];
	478	int len = strlen(g);
	479	int chars = 0, lines = 0;
	480	bool shortened = false;
[247]	481	uint32_t *styletab = new uint32_t[len];
[532]	482	getFullStyle(g, styletab);
[467]	483	string html = "\n<div style=\"background:white;padding:0.2em;font-family:arial,helvetica,sans-serif;font-size:90%\">";
[247]	484	uint32_t prevstyle, prevcolor, style = 0, color = 0;
[761]	485	for (int i = 0; i < len; i++)
[138]	486	{
[761]	487	if (shorten && ((lines == 0 && chars > 160) \|\| (lines > 5 \|\| chars > 300))) { shortened = true; break; }
[138]	488	if (g[i] == '\r') continue;
	489	if (g[i] == '\n') { html += "<br>\n"; lines++; continue; }
	490	chars++;
	491	prevstyle = style;
	492	prevcolor = color;
	493	style = GENGETSTYLE(styletab[i]);
	494	color = GENGETCOLOR(styletab[i]);
	495	if ((i != 0 && (color != prevcolor))) html += "</font>";
[955]	496	if ((style & GENSTYLE_INVALID) != (prevstyle & GENSTYLE_INVALID))
[138]	497	{
[955]	498	html += "<"; if (!(style & GENSTYLE_INVALID)) html += "/"; html += "u>";
[138]	499	}
[955]	500	if ((style & GENSTYLE_BOLD) != (prevstyle & GENSTYLE_BOLD))
[138]	501	{
[955]	502	html += "<"; if (!(style & GENSTYLE_BOLD)) html += "/"; html += "b>";
[138]	503	}
[955]	504	if ((style & GENSTYLE_ITALIC) != (prevstyle & GENSTYLE_ITALIC))
[138]	505	{
[955]	506	html += "<"; if (!(style & GENSTYLE_ITALIC)) html += "/"; html += "i>";
[138]	507	}
	508	if ((i == 0 \|\| (color != prevcolor)))
	509	{
	510	sprintf(buf, "<font color=#%02x%02x%02x>", GENGET_R(color), GENGET_G(color), GENGET_B(color)); html += buf;
	511	}
	512	if (g[i] == '<') html += "<"; else if (g[i] == '>') html += ">"; else html += g[i];
	513	if ((i % 3) == 0 && g[i] == ' ') html += "\n"; //for readability, insert some newlines into html...
	514	}
	515	delete[] styletab;
	516	html += "</u></b></i></font>";
	517	if (shortened) html += " [etc...]";
	518	html += "</div>\n";
	519	return html;
	520	}
	521
	522	void GenMan::p_htmlize(ExtValue args, ExtValue ret)
	523	{
[467]	524	ret->setString(HTMLize(args->getString().c_str()).c_str());
[138]	525	}
	526
	527	void GenMan::p_htmlizeshort(ExtValue args, ExtValue ret)
	528	{
[467]	529	ret->setString(HTMLizeShort(args->getString().c_str()).c_str());
[138]	530	}
	531
[965]	532	string GenMan::LaTeXize(const char *g)
	533	{
	534	char buf[50];
	535	int len = strlen(g);
	536	int chars = 0, lines = 0; //currently not used
	537	uint32_t *styletab = new uint32_t[len];
	538	getFullStyle(g, styletab);
	539	string latex = "\\usepackage{xcolor}\n% Using \\texttt{} may be beneficial for some genetic encodings, but then you may lose bold/italic.\n\\noindent \\sloppy";
	540	uint32_t prevstyle, prevcolor, style = 0, color = 0;
	541	for (int i = 0; i < len; i++)
	542	{
	543	if (g[i] == '\r') continue;
	544	if (g[i] == '\n') { latex += "\\\\\n"; lines++; continue; }
	545	chars++;
	546	prevstyle = style;
	547	prevcolor = color;
	548	style = GENGETSTYLE(styletab[i]);
	549	color = GENGETCOLOR(styletab[i]);
	550
	551	// Unfortunately, LaTeX (as opposed to HTML) uses the same closing tags "}" for color, bold, italic, underline - so they cannot intersect.
	552	// 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).
	553	// This could be optimized by a more complex logic and tracking which color/style section starts and ends within another section.
	554
	555	if (((style & GENSTYLE_INVALID) != (prevstyle & GENSTYLE_INVALID))
	556	\|\|
	557	((style & GENSTYLE_BOLD) != (prevstyle & GENSTYLE_BOLD))
	558	\|\|
	559	((style & GENSTYLE_ITALIC) != (prevstyle & GENSTYLE_ITALIC))
	560	\|\|
	561	((i == 0 \|\| (color != prevcolor))))
	562	{
	563	if (prevstyle & GENSTYLE_INVALID) latex += "}";
	564	if (prevstyle & GENSTYLE_BOLD) latex += "}";
	565	if (prevstyle & GENSTYLE_ITALIC) latex += "}";
	566	if (i != 0) latex += "}"; //for color
	567	if (style & GENSTYLE_INVALID) latex += "\\underline{";
	568	if (style & GENSTYLE_BOLD) latex += "\\textbf{";
	569	if (style & GENSTYLE_ITALIC) latex += "\\textit{";
	570	sprintf(buf, "\\textcolor[rgb]{%.2g,%.2g,%.2g}{", GENGET_R(color) / 255.0, GENGET_G(color) / 255.0, GENGET_B(color) / 255.0); latex += buf;
	571	}
	572	if (g[i] == '<') latex += "$<$"; else if (g[i] == '>') latex += "$>$"; else
	573	if (g[i] == '-') latex += "$-$"; else if (g[i] == '\|') latex += "$\|$"; else
	574	if (g[i] == '$') latex += "\\$"; else if (g[i] == '%') latex += "\\%"; else latex += g[i];
	575	if ((i % 3) == 0 && g[i] == ' ') latex += "\n"; //for readability, insert some newlines into latex...
	576	if (i % 10 == 0) latex += "{\\hskip 0pt}"; // https://tex.stackexchange.com/questions/33526/automatic-line-breaking-of-long-lines-of-text
	577	}
	578	delete[] styletab;
	579	latex += "}"; //for color (it was used at least once)
[966]	580	if (style & GENSTYLE_INVALID) latex += "}";
[965]	581	if (style & GENSTYLE_BOLD) latex += "}";
	582	if (style & GENSTYLE_ITALIC) latex += "}";
	583	latex += "\n";
	584	return latex;
	585	}
	586
	587	void GenMan::p_latexize(ExtValue args, ExtValue ret)
	588	{
	589	ret->setString(LaTeXize(args->getString().c_str()).c_str());
	590	}
	591
[955]	592	Geno GenMan::getSimplest(const SString& format)
[138]	593	{
[145]	594	GenoOperators *gf = getOper_f(format);
[138]	595	if (!gf) return Geno();
[955]	596	string info = "The simplest genotype of format f"; info += format.c_str();
[138]	597	info += " for operators '"; info += gf->name; info += "'.";
[200]	598	return Geno(gf->getSimplest(), format, "Root", info.c_str());
[138]	599	}
	600
	601	void GenMan::p_getsimplest(ExtValue args, ExtValue ret)
	602	{
[955]	603	SString format = GenoObj::formatFromExtValue(args[0]);
[145]	604	if (!getOper_f(format))
[138]	605	ret->setEmpty();
	606	else
[532]	607	*ret = GenoObj::makeDynamicObjectAndDecRef(new Geno(getSimplest(format)));
[138]	608	}
	609
[955]	610	const char *GenMan::getOpName(const SString& format)
[138]	611	{
[145]	612	GenoOperators *gf = getOper_f(format);
[200]	613	if (!gf) return "n/a"; else return gf->name.c_str();
[138]	614	}
	615
[955]	616	GenoOperators* GenMan::getOper_f(const SString& format)
[138]	617	{
[955]	618	int ind = findOperFormatIndex(format);
[138]	619	if (ind == -1) return NULL;
[168]	620	int which_oper_of_format = seloper[ind];
[145]	621	for (unsigned int i = 0; i < oper_fx_list.size(); i++)
	622	if (oper_fx_list[i]->supported_format == format)
[168]	623	if (which_oper_of_format == 0) return oper_fx_list[i]; else which_oper_of_format--;
[138]	624	return NULL; //should never happen
	625	}
	626
[275]	627	void GenMan::saveLink(const string parent1, const string parent2, const string child, const float chg)
[138]	628	{
	629	GenoLink l;
	630	l.count = count;
[275]	631	l.parent1 = parent1;
	632	l.parent2 = parent2;
	633	l.child = child;
[138]	634	l.chg = chg;
	635	l.fit = 0; //temporarily. Will be set when the genotype dies
[375]	636	//logPrintf("GenMan","saveLink",0,"#%d: [%d] '%s' + '%s' -> '%s'",GenoLinkList.size(),count,parent1.c_str(),parent2.c_str(),child.c_str());
[138]	637	GenoLinkList.push_back(l);
	638	}
	639
[247]	640	void GenMan::onDelGen(void *obj, intptr_t n)
[138]	641	{
	642	//old code needs update:
	643	// ((SpeciesList*)obj)->przyDodaniu(i);
	644	/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
	645	GenMan gm=(GenMan)obj;
	646	Genotype gt=(Genotype)(*listaGen)(n); //there is no more "listaGen"
	647	string g=(const char*)gt->genotype.getGene();
	648	float fit=gt->getFinalFitness();
	649	for(int i=0;i<gm->GenoLinkList.size();i++) //find genotype
	650	if (gm->GenoLinkList[i].g1==g) {gm->GenoLinkList[i].fit=fit; break;}
	651	*/
	652	}
	653
	654	void GenMan::clearStats()
	655	{
	656	count = 0;
	657	valid_m = valid_xo = validated_m = validated_xo = invalid_m = invalid_xo = failed_m = failed_xo = 0;
	658	mutchg = xochg = 0;
	659	GenoLinkList.clear();
	660	}
	661
	662	void GenMan::p_clearStats(ExtValue args, ExtValue ret) { clearStats(); }
	663
	664	void GenMan::p_report(ExtValue args, ExtValue ret)
	665	{ //should be updated to handle multiple operators for a single format
	666	char g, g2;
[145]	667	float f1, f2;
	668	int m;
[375]	669	logMessage("GenMan", "Report", 0, "The following genetic operators are available:");
[145]	670	for (unsigned int i = 0; i < oper_fx_list.size(); i++)
[138]	671	{
[200]	672	string l;
[761]	673	if (oper_fx_list[i]->checkValidity("", "") != GENOPER_NOOPER) l += " checkValidity";
[145]	674	if (oper_fx_list[i]->getSimplest())
[138]	675	{
[145]	676	g = strdup(oper_fx_list[i]->getSimplest());
[138]	677	g2 = strdup(g);
[761]	678	if (oper_fx_list[i]->validate(g, "") != GENOPER_NOOPER) l += " validate";
[145]	679	if (oper_fx_list[i]->mutate(g, f1, m) != GENOPER_NOOPER) l += " mutate";
	680	if (oper_fx_list[i]->crossOver(g, g2, f1, f2) != GENOPER_NOOPER) l += " crossover";
[138]	681	l += " getSimplest";
	682	free(g); free(g2);
	683	}
[145]	684	// if (oper_fx_list[i]->similarity("","")!=GENOPER_NOOPER) l+=" similarity";
[955]	685	logPrintf("GenMan", "Report", LOG_INFO, "format f%s (%s):%s",
	686	oper_fx_list[i]->supported_format.c_str(), oper_fx_list[i]->name.c_str(), l.c_str());
[138]	687	}
	688	}
	689
	690	void GenMan::p_validate(ExtValue args, ExtValue ret)
	691	{
	692	Geno *g = GenoObj::fromObject(args[0]);
	693	if (g == NULL)
	694	ret->setEmpty();
	695	else
[532]	696	ret = GenoObj::makeDynamicObjectAndDecRef(new Geno(validate(g)));
[138]	697	}
	698
	699	void GenMan::p_mutate(ExtValue args, ExtValue ret)
	700	{
	701	Geno *g = GenoObj::fromObject(args[0]);
	702	if (g == NULL)
	703	ret->setEmpty();
	704	else
[532]	705	ret = GenoObj::makeDynamicObjectAndDecRef(new Geno(mutate(g)));
[138]	706	}
	707
	708	void GenMan::p_crossover(ExtValue args, ExtValue ret)
	709	{
	710	Geno *g1 = GenoObj::fromObject(args[1]);
	711	Geno *g2 = GenoObj::fromObject(args[0]);
	712	if (g1 == NULL \|\| g2 == NULL)
	713	ret->setEmpty();
	714	else
[532]	715	ret = GenoObj::makeDynamicObjectAndDecRef(new Geno(crossOver(g1, *g2)));
[138]	716	}
[532]	717

Note: See TracBrowser for help on using the repository browser.

Download in other formats: