Context Navigation

source: cpp/frams/genetics/fL/fL_oper.cpp @ 1095

Last change on this file since 1095 was 1075, checked in by Maciej Komosinski, 4 years ago
Fixed dangerous size_t-1
File size: 26.1 KB

Rev	Line
[797]	1	// This file is a part of Framsticks SDK. http://www.framsticks.com/
[935]	2	// Copyright (C) 1999-2020 Maciej Komosinski and Szymon Ulatowski.
[797]	3	// See LICENSE.txt for details.
	4
[780]	5	#include "fL_oper.h"
[797]	6	#include <common/loggers/loggers.h>
	7	#include "../fH/fH_oper.h"
	8	#include <algorithm>
[780]	9
[797]	10	#define FIELDSTRUCT Geno_fL
[974]	11	static ParamEntry geno_fL_paramtab[] =
[797]	12	{
	13	{"Genetics: fL", 3, FL_OPCOUNT + FL_MUTGROUPSCOUNT + FL_CHG_COUNT + 2 + FL_ADD_COUNT, },
	14	{"Genetics: fL: Probabilities of mutating axiom and rules", },
	15	{"Genetics: fL: Probabilities of mutation types", },
	16	{"fL_maxdefinedwords", 0, 0, "Maximum number of defined words", "d 0 100 10", FIELD(maxdefinedwords), "Maximum number of words that can be defined in L-System", },
	17
	18	{"fL_axm_mut_prob", 1, 0, "Axiom mutation", "f 0 1 0.2", FIELD(groupprobabilities[FL_AXM_WORD_MUT_PROB]), "Probability of performing mutation operations on axiom", },
	19	{"fL_rul_mut_prob", 1, 0, "Rule's successor mutation", "f 0 1 0.8", FIELD(groupprobabilities[FL_RUL_WORD_MUT_PROB]), "Probability of performing mutation operations on the successor of random rule", },
	20
	21	{"fL_mut_addition", 2, 0, "Addition of word to sequence", "f 0 1 0.2", FIELD(operations[FL_ADD_WORD]), "Probability of adding random existing word to the axiom or one of successors", },
	22
	23	{"fL_mut_add_stick", 2, 0, " - addition of stick", "f 0 1 0.2", FIELD(addtypes[FL_ADD_STICK]), "Probability of adding stick", },
	24	{"fL_mut_add_neuro", 2, 0, " - addition of neuron", "f 0 1 0.2", FIELD(addtypes[FL_ADD_NEURO]), "Probability of adding neuron", },
	25	{"fL_mut_add_conn", 2, 0, " - addition of neuron connection", "f 0 1 0.2", FIELD(addtypes[FL_ADD_CONN]), "Probability of adding connection", },
	26	{"fL_mut_add_rot", 2, 0, " - addition of rotation words", "f 0 1 0.2", FIELD(addtypes[FL_ADD_ROT]), "Probability of adding one of rotation words", },
	27	{"fL_mut_add_branch", 2, 0, " - addition of branched stick", "f 0 1 0.2", FIELD(addtypes[FL_ADD_BRANCH]), "Probability of adding branch with rotation and stick", },
	28	{"fL_mut_add_other", 2, 0, " - addition of defined words", "f 0 1 0.4", FIELD(addtypes[FL_ADD_OTHER]), "Probability of adding other word, defined in genotype", },
	29
	30	{"fL_mut_worddefaddition", 2, 0, "Addition of new word definition", "f 0 1 0.05", FIELD(operations[FL_ADD_WDEF]), "Probability of adding new word definition to the genotype", },
	31	{"fL_mut_ruleaddition", 2, 0, "Addition of new rule definition", "f 0 1 0.1", FIELD(operations[FL_ADD_RULE]), "Probability of adding new rule definition for existing word", },
	32	{"fL_mut_rulecond", 2, 0, "Modification of rule condition", "f 0 1 0.1", FIELD(operations[FL_CHG_COND]), "Probability of modifying random rule condition", },
	33
	34	{"fL_mut_changeword", 2, 0, "Change of random word", "f 0 1 0.3", FIELD(operations[FL_CHG_WORD]), "Probability of changing word name or formula of a random word from axiom or one of successors", },
	35	{"fL_mut_changeword_formula", 2, 0, " - change of formula", "f 0 1 0.7", FIELD(chgoperations[FL_CHG_WORD_FORMULA]), "Probability of changing formula in word", },
	36	{"fL_mut_changeword_name", 2, 0, " - change of name", "f 0 1 0.3", FIELD(chgoperations[FL_CHG_WORD_NAME]), "Probability of changing name in word", },
	37
	38	{"fL_mut_changeiter", 2, 0, "Change of L-System iteration", "f 0 1 0.3", FIELD(operations[FL_CHG_ITER]), "Probability of changing number of iterations of L-Systems", },
	39	{"fL_mut_changeiter_step", 2, 0, "Step of iteration changing", "f 0 1 1.0", FIELD(iterchangestep), "Minimal step that should be used for changing iterations in L-Systems", },
	40	{"fL_mut_deletion", 2, 0, "Deletion of random word", "f 0 1 0.2", FIELD(operations[FL_DEL_WORD]), "Probability of deleting random word from axiom or random successor (also deletes rule if there is only one word in successor)", },
	41	{ 0, },
	42	};
	43	#undef FIELDSTRUCT
	44
[780]	45	Geno_fL::Geno_fL()
	46	{
[974]	47	par.setParamTab(geno_fL_paramtab);
[797]	48	par.select(this);
	49	par.setDefault();
	50	supported_format = 'L';
	51	iterchangestep = 1.0;
	52	maxdefinedwords = 10;
[780]	53	}
[797]	54
	55	int Geno_fL::checkValidity(const char geno, const char genoname)
	56	{
	57	LoggerToMemory eh(LoggerBase::Enable \| LoggerToMemory::StoreAllMessages, LOG_WARN);
	58	fL_Builder builder(false, false);
	59
	60	int err = builder.parseGenotype(geno);
	61	if (err != 0)
	62	{
	63	return err;
	64	}
	65
[821]	66	if (builder.countSticksInSequence(&builder.genotype) == 0)
[797]	67	{
	68	return GENOPER_OPFAIL;
	69	}
	70	double neededtime = 0;
	71	Model *m = builder.developModel(neededtime);
	72	if (!m)
	73	{
	74	return GENOPER_OPFAIL;
	75	}
	76	if (!m->isValid())
	77	{
	78	delete m;
	79	return GENOPER_OPFAIL;
	80	}
	81	delete m;
	82
	83
	84	return GENOPER_OK;
	85	}
	86
	87	int Geno_fL::validate(char &geno, const char genoname)
	88	{
	89	LoggerToMemory eh(LoggerBase::Enable \| LoggerToMemory::StoreAllMessages, LOG_WARN);
	90	fL_Builder builder(false, false);
	91
	92	int err = builder.parseGenotype(geno);
	93	if (err != 0)
	94	{
	95	return err;
	96	}
	97	double neededtime = 0;
	98	Model *m = builder.developModel(neededtime);
	99	if (!m->isValid())
	100	{
	101	delete m;
	102	return GENOPER_OPFAIL;
	103	}
	104	if (neededtime != builder.time)
	105	{
	106	builder.time = neededtime;
	107	free(geno);
	108	geno = strdup(builder.toString().c_str());
	109	delete m;
	110	return GENOPER_OK;
	111	}
	112	delete m;
	113	return GENOPER_OK;
	114	}
	115
	116	bool Geno_fL::addWord(std::list<fL_Word > list, fL_Word definition, std::list<fL_Word >::iterator it)
	117	{
	118	fL_Word *newword = new fL_Word();
	119	newword = definition;
	120
	121	// if word has parameters
	122	if (newword->npar > 0)
	123	{
	124	// create ParamObject that will hold parameter data
	125	newword->data = ParamObject::makeObject(newword->tab);
	126	Param par(newword->tab);
	127	par.select(newword->data);
	128	par.setDefault();
	129	for (int i = 0; i < par.getPropCount(); i++)
	130	{
	131	newword->parevals.push_back(NULL);
	132	}
	133	if (newword->name.startsWith("rot"))
	134	{
[896]	135	double rot = rndDouble(2);
[797]	136	MathEvaluation *eval = new MathEvaluation(0);
	137	eval->convertString(SString::valueOf(rot).c_str());
	138	newword->parevals[0] = eval;
	139	}
	140	else if (newword->name == "N")
	141	{
	142	SString det;
[999]	143	NeuroClass *cls = getRandomNeuroClass(Model::SHAPETYPE_BALL_AND_STICK);
[797]	144	det = cls->getName();
	145	Geno_fH::mutateNeuronProperties(det);
	146	par.setStringById(FL_PE_NEURO_DET, det);
	147	}
	148	else if (newword->name == "C")
	149	{
	150	MathEvaluation *eval = new MathEvaluation(0);
[896]	151	eval->convertString(SString::valueOf(rndDouble(2) - 1).c_str());
[797]	152	newword->parevals[0] = eval;
	153	}
	154	}
	155
	156	list->insert(it, newword);
	157	return true;
	158	}
	159
	160	std::list<fL_Word > Geno_fL::selectRandomSequence(fL_Builder *creature, int &numparams, int &ruleid)
	161	{
	162	std::list<fL_Word > list = NULL;
	163	int axiomorrules = roulette(groupprobabilities, FL_MUTGROUPSCOUNT);
	164	bool axiomused = axiomorrules == FL_AXM_WORD_MUT_PROB \|\| creature->rules.size() == 0;
	165	if (axiomused)
	166	{
	167	list = &creature->genotype;
	168	numparams = 0;
	169	ruleid = -1;
	170	}
	171	else
	172	{
[896]	173	int rid = rndUint(creature->rules.size());
[797]	174	list = &creature->rules[rid]->objsucc;
	175	numparams = creature->rules[rid]->objpred->npar;
	176	ruleid = rid;
	177	}
	178	return list;
	179	}
	180
	181	fL_Word* Geno_fL::randomWordDefinition(fL_Builder *creature, int method)
	182	{
	183	if (method == FL_ADD_OTHER && creature->builtincount < (int)creature->words.size())
	184	{
[896]	185	return creature->words[creature->wordnames[creature->builtincount + rndUint((int)creature->words.size() - creature->builtincount)]];
[797]	186	}
	187	else
	188	{
	189	if (method == FL_ADD_OTHER) // we should be able to select stick, neuro or conn
	190	{
	191	double alttypes[FL_ADD_COUNT - 2];
	192	alttypes[FL_ADD_STICK] = addtypes[FL_ADD_STICK];
	193	alttypes[FL_ADD_NEURO] = addtypes[FL_ADD_NEURO];
	194	alttypes[FL_ADD_CONN] = addtypes[FL_ADD_CONN];
	195	alttypes[FL_ADD_ROT] = addtypes[FL_ADD_ROT];
	196	method = roulette(alttypes, FL_ADD_COUNT - 2);
	197	}
	198	switch (method)
	199	{
	200	case FL_ADD_STICK:
	201	return creature->words["S"];
	202	case FL_ADD_NEURO:
[999]	203	if (getActiveNeuroClassCount(Model::SHAPETYPE_BALL_AND_STICK) == 0)
[803]	204	return creature->words["S"];
	205	else
	206	return creature->words["N"];
[797]	207	case FL_ADD_CONN:
	208	return creature->words["C"];
	209	case FL_ADD_ROT:
	210	{
[896]	211	int rottype = rndUint(3);
[797]	212	switch (rottype)
	213	{
	214	case 0:
	215	return creature->words["rotX"];
	216	case 1:
	217	return creature->words["rotY"];
	218	case 2:
	219	return creature->words["rotZ"];
	220	}
	221	break;
	222	}
	223	case FL_ADD_BRANCH:
	224	// return NULL
	225	break;
	226	}
	227	}
	228	return NULL;
	229	}
	230
	231	void Geno_fL::deleteBranch(std::list<fL_Word > list, std::list<fL_Word *>::iterator openbranchposition)
	232	{
	233	fL_Branch branch = (fL_Branch )(*openbranchposition);
	234	if (branch->btype == fL_Branch::BranchType::OPEN)
	235	{
	236	int bcount = 1;
	237	delete (*openbranchposition);
	238	openbranchposition = list->erase(openbranchposition);
	239	for (; openbranchposition != list->end(); openbranchposition++)
	240	{
	241	if ((*openbranchposition)->type == fLElementType::BRANCH)
	242	{
	243	branch = (fL_Branch )(openbranchposition);
	244	if (branch->btype == fL_Branch::BranchType::OPEN)
	245	{
	246	bcount++;
	247	}
	248	else
	249	{
	250	bcount--;
	251	if (bcount == 0)
	252	{
	253	delete branch;
	254	list->erase(openbranchposition);
	255	break;
	256	}
	257	}
	258	}
	259	}
	260	}
	261	else
	262	{
	263	openbranchposition++;
	264	if (openbranchposition != list->end())
	265	{
	266	delete (*openbranchposition);
	267	list->erase(openbranchposition);
	268	}
	269	}
	270	}
	271
	272	int Geno_fL::mutate(char *&geno, float& chg, int &method)
	273	{
	274	fL_Builder *creature = new fL_Builder(false, false);
	275
	276	if (creature->parseGenotype(geno) != 0)
	277	{
	278	delete creature;
	279	return GENOPER_OPFAIL;
	280	}
	281
	282	int before = creature->countWordsInLSystem();
	283
	284	method = roulette(operations, FL_OPCOUNT);
	285	switch (method)
	286	{
[973]	287	case FL_CHG_ITER:
	288	{
	289	if (rndUint(2) == 0)
[797]	290	{
[973]	291	creature->time = creature->time + iterchangestep <= ExtValue::getDouble(FL_MAXITER) ?
	292	creature->time + iterchangestep : creature->time - iterchangestep;
[797]	293	}
[973]	294	else
[797]	295	{
[973]	296	creature->time = creature->time - iterchangestep >= 0 ?
	297	creature->time - iterchangestep : creature->time + iterchangestep;
	298	}
	299	break;
	300	}
	301	case FL_CHG_COND:
	302	{
	303	if (creature->rules.size() > 0)
	304	{
	305	int ruleid = rndUint(creature->rules.size());
	306	if (!creature->rules[ruleid]->condeval)
[797]	307	{
[973]	308	creature->rules[ruleid]->condeval = new MathEvaluation(creature->rules[ruleid]->objpred->npar);
[797]	309	}
[973]	310	creature->rules[ruleid]->condeval->mutateConditional();
	311	break;
[797]	312	}
[973]	313	// if there are no rules - create one
	314	}
	315	[[fallthrough]];
	316	case FL_ADD_RULE:
	317	{
	318	std::unordered_map<std::string, fL_Word *>::iterator pred = creature->words.begin();
	319	std::vector<fL_Word *> wordswithnorules;
	320	for (; pred != creature->words.end(); pred++)
[797]	321	{
[973]	322	if (!pred->second->builtin)
[797]	323	{
[973]	324	bool norules = true;
	325	for (fL_Rule * r : creature->rules)
[797]	326	{
[973]	327	if (pred->second->name == r->objpred->name &&
	328	pred->second->npar == r->objpred->npar)
[797]	329	{
[973]	330	norules = false;
	331	break;
[797]	332	}
	333	}
[973]	334	if (norules)
	335	{
	336	wordswithnorules.push_back(pred->second);
	337	}
[797]	338	}
[973]	339	}
	340	if (wordswithnorules.size() > 0)
	341	{
	342	int predid = rndUint(wordswithnorules.size());
	343	fL_Rule *newrule = new fL_Rule(0, 0);
	344	fL_Word *pred = new fL_Word();
	345	pred = wordswithnorules[predid];
	346	newrule->objpred = pred;
	347	fL_Word *initdef = randomWordDefinition(creature, roulette(addtypes, FL_ADD_COUNT - 1)); // -1 to avoid branching
	348	addWord(&newrule->objsucc, initdef, newrule->objsucc.begin());
	349	creature->rules.push_back(newrule);
	350	break;
	351	}
	352	else if (creature->rules.size() > 0)
	353	{
	354	int ruleid = rndUint(creature->rules.size());
	355	fL_Rule *newrule = new fL_Rule(0, 0);
	356	fL_Word *pred = new fL_Word();
	357	pred = creature->rules[ruleid]->objpred;
	358	newrule->objpred = pred;
	359	if (creature->rules[ruleid]->condeval)
[797]	360	{
[973]	361	std::string formula = "";
	362	creature->rules[ruleid]->condeval->RPNToInfix(formula);
	363	if (formula.find("1.0-(") != 0)
[797]	364	{
[973]	365	std::string res = "1.0-(";
	366	res += formula;
	367	res += ")";
	368	newrule->condeval = new MathEvaluation(pred->npar);
	369	newrule->condeval->convertString(res);
[797]	370	}
	371	else
	372	{
	373	newrule->condeval = new MathEvaluation(pred->npar);
	374	newrule->condeval->mutateConditional();
	375	}
	376	}
[973]	377	else
	378	{
	379	newrule->condeval = new MathEvaluation(pred->npar);
	380	newrule->condeval->mutateConditional();
	381	}
	382	fL_Word *worddef = randomWordDefinition(creature, roulette(addtypes, FL_ADD_COUNT - 1));
	383	addWord(&newrule->objsucc, worddef, newrule->objsucc.begin());
	384	creature->rules.push_back(newrule);
	385	break;
[797]	386	}
[973]	387	// if there are no words, from which rules can be formed, then add one
	388	}
	389	[[fallthrough]];
	390	case FL_ADD_WDEF:
	391	{
	392	if (creature->countDefinedWords() <= maxdefinedwords)
[797]	393	{
[973]	394	int npar = rndUint(ExtValue::getInt(FL_MAXPARAMS, false));
	395	for (int i = 0; i < maxdefinedwords; i++)
[797]	396	{
[973]	397	std::string name = "w";
	398	name += std::to_string(i);
	399	if (creature->words.find(name) == creature->words.end())
[797]	400	{
[973]	401	fL_Word *word = new fL_Word(false, 0, 0);
	402	word->npar = npar;
	403	word->name = name.c_str();
	404	word->processDefinition(creature);
	405	break;
[797]	406	}
	407	}
[973]	408	break;
[797]	409	}
[973]	410	//no break at the end of case - if there is too many words, then
	411	// deletion should be performed
	412	}
	413	[[fallthrough]];
	414	case FL_DEL_WORD:
	415	{
	416	int numpars = 0;
	417	int ruleid = 0;
	418	std::list<fL_Word > list = selectRandomSequence(creature, numpars, ruleid);
	419	if (ruleid == -1 && creature->countSticksInSequence(list) == 1)
[797]	420	{
[973]	421	if (list->size() > 1)
[797]	422	{
[1075]	423	int rndid = rndUint(int(list->size()) - 1);
[973]	424	int j = 0;
	425	std::list<fL_Word *>::iterator it = list->begin();
	426	if ((*it)->name == "S")
[797]	427	{
[973]	428	it++;
	429	}
	430	while (it != list->end() && j < rndid && ((*it)->name == "S"))
	431	{
	432	if ((*it)->name != "S")
[797]	433	{
[973]	434	j++;
[797]	435	}
[973]	436	it++;
	437	}
	438	if (it != list->end())
	439	{
	440	if ((*it)->type == fLElementType::BRANCH)
[797]	441	{
[973]	442	deleteBranch(list, it);
[797]	443	}
[973]	444	else
[797]	445	{
[973]	446	delete (*it);
	447	list->erase(it);
[797]	448	}
[973]	449	break;
[797]	450	}
	451	// else add word
	452	}
[973]	453	// else add word
[797]	454	}
[973]	455	else
[797]	456	{
[896]	457	int rndid = rndUint(list->size());
[797]	458	std::list<fL_Word *>::iterator it = list->begin();
	459	std::advance(it, rndid);
[973]	460	if ((*it)->type == fLElementType::BRANCH)
[797]	461	{
[973]	462	deleteBranch(list, it);
[797]	463	}
	464	else
	465	{
[973]	466	delete (*it);
	467	list->erase(it);
	468	}
	469	if (ruleid > -1 && creature->rules[ruleid]->objsucc.size() == 0)
	470	{
	471	delete creature->rules[ruleid];
	472	creature->rules.erase(creature->rules.begin() + ruleid);
	473	}
	474	break;
	475	}
	476	// if no words available, then add word
	477	}
	478	[[fallthrough]];
	479	case FL_ADD_WORD:
	480	{
	481	int numpars = 0;
	482	int tmp = 0;
	483	std::list<fL_Word > list = selectRandomSequence(creature, numpars, tmp);
	484	int rndid = rndUint(list->size());
	485	std::list<fL_Word *>::iterator it = list->begin();
	486	std::advance(it, rndid);
	487	int meth = roulette(addtypes, FL_ADD_COUNT);
	488	if (tmp == -1)
	489	{ // if sequence is axiom and it does not have non-builtin words
	490	bool hasdefined = false;
	491	for (std::list<fL_Word *>::iterator elem = list->begin(); elem != list->end(); elem++)
	492	{
	493	if (!(*elem)->builtin)
[797]	494	{
[973]	495	hasdefined = true;
	496	break;
[797]	497	}
	498	}
[973]	499	if (!hasdefined)
	500	{
	501	meth = FL_ADD_OTHER;
	502	}
	503
	504	}
	505	if (meth != FL_ADD_BRANCH)
	506	{
	507	fL_Word *worddef = randomWordDefinition(creature, meth);
	508	addWord(list, worddef, it);
	509	}
	510	else
	511	{
	512	fL_Branch *start = new fL_Branch(fL_Branch::BranchType::OPEN, 0, 0);
	513	list->insert(it, start);
	514	int rottype = rndUint(2);
	515	switch (rottype)
	516	{
	517	case 0:
	518	addWord(list, creature->words["rotY"], it);
	519	case 1:
	520	addWord(list, creature->words["rotZ"], it);
	521	}
	522	addWord(list, creature->words["S"], it);
	523	fL_Branch *end = new fL_Branch(fL_Branch::BranchType::CLOSE, 0, 0);
	524	list->insert(it, end);
	525	}
	526	break;
	527	}
	528	case FL_CHG_WORD:
	529	{
	530	int numpars = 0;
	531	int tmp = 0;
	532	std::list<fL_Word > list = selectRandomSequence(creature, numpars, tmp);
	533	int rndid = rndUint(list->size());
	534	std::list<fL_Word *>::iterator selectedword = list->begin();
	535	std::advance(selectedword, rndid);
	536	if ((*selectedword)->type == fLElementType::BRANCH)
	537	{
[797]	538	break;
	539	}
[973]	540	int chgtype = roulette(chgoperations, FL_CHG_COUNT);
	541	if (creature->countSticksInSequence(list) == 1 && tmp == -1) // if sequence is axiom
[797]	542	{
[973]	543	fL_Word *worddef = randomWordDefinition(creature, roulette(addtypes, FL_ADD_COUNT - 1));
	544
[797]	545	int numpars = 0;
	546	std::list<fL_Word > list = selectRandomSequence(creature, numpars, tmp);
[896]	547	int rndid = rndUint(list->size());
[973]	548	std::list<fL_Word *>::iterator it = list->begin();
	549	std::advance(it, rndid);
	550
	551	addWord(list, worddef, it);
	552
	553	break;
	554	}
	555	else if (chgtype == FL_CHG_WORD_NAME)
	556	{
	557	if ((*selectedword)->builtin)
[797]	558	{
[973]	559	delete (*selectedword);
	560	selectedword = list->erase(selectedword);
[797]	561	fL_Word *worddef = randomWordDefinition(creature, roulette(addtypes, FL_ADD_COUNT - 1));
[973]	562	addWord(list, worddef, selectedword);
[797]	563	}
[973]	564	else
[797]	565	{
[973]	566	std::vector<fL_Word *> available;
	567	for (std::unordered_map<std::string, fL_Word *>::iterator wit = creature->words.begin();
	568	wit != creature->words.end(); wit++)
[797]	569	{
[973]	570	if ((*selectedword)->npar == wit->second->npar &&
	571	(*selectedword)->name != wit->second->name &&
	572	!wit->second->builtin)
	573	{
	574	available.push_back(wit->second);
	575	}
	576	}
	577	if (available.size() > 0)
	578	{
	579	int newnameid = rndUint(available.size());
	580	(*selectedword)->name = available[newnameid]->name;
	581	}
	582	else
	583	{
[797]	584	delete (*selectedword);
	585	selectedword = list->erase(selectedword);
	586	fL_Word *worddef = randomWordDefinition(creature, roulette(addtypes, FL_ADD_COUNT - 1));
	587	addWord(list, worddef, selectedword);
	588	}
[973]	589	}
	590	}
	591	else
	592	{
	593	if ((*selectedword)->npar > 0)
	594	{
	595	int randeval = rndUint((*selectedword)->npar);
	596	Param par((selectedword)->tab, (selectedword)->data);
	597	if ((selectedword)->builtin && (selectedword)->name == "N"
	598	&& strcmp(par.id(randeval), FL_PE_NEURO_DET) == 0)
[797]	599	{
[973]	600	SString res = par.getStringById(FL_PE_NEURO_DET);
	601	Geno_fH::mutateNeuronProperties(res);
	602	par.setStringById(FL_PE_NEURO_DET, res);
	603	}
	604	else if ((*selectedword)->builtin &&
	605	(*selectedword)->name == "C" &&
	606	strcmp(par.id(randeval), FL_PE_CONN_ATTR) == 0)
	607	{
	608	SString strattractor = par.getStringById(FL_PE_CONN_ATTR);
	609	if (strattractor.length() > 0)
[797]	610	{
[973]	611	fL_Word *w = NULL;
	612	creature->createWord(strattractor, w, numpars, 0, 0);
	613	// mutate attractor parameter
	614	if (w->npar > 0)
[797]	615	{
[973]	616	int rndattr = rndUint(w->npar);
	617	if (!w->parevals[rndattr])
	618	{
	619	w->parevals[rndattr] = new MathEvaluation(numpars);
	620	}
	621	w->parevals[rndattr]->mutate(false, false);
[797]	622	}
[973]	623	strattractor = w->stringify(true);
	624	par.setStringById(FL_PE_CONN_ATTR, strattractor);
	625	delete w;
[797]	626	}
	627	else
	628	{
[973]	629	if (creature->builtincount < (int)creature->words.size())
[797]	630	{
[973]	631	fL_Word *wdef = randomWordDefinition(creature, FL_ADD_OTHER);
	632	fL_Word *w = new fL_Word();
	633	w = wdef;
	634	w->data = ParamObject::makeObject(w->tab);
	635	Param apar(w->tab);
	636	apar.select(w->data);
	637	apar.setDefault();
[797]	638	if (w->npar > 0)
	639	{
[896]	640	int rndattr = rndUint(w->npar);
[973]	641	for (int i = 0; i < w->npar; i++)
[797]	642	{
[973]	643	if (i == rndattr)
	644	{
	645	MathEvaluation *ev = new MathEvaluation(numpars);
	646	ev->mutate(false, false);
	647	w->parevals.push_back(ev);
	648	}
	649	else
	650	{
	651	w->parevals.push_back(NULL);
	652	}
[797]	653	}
[973]	654
[797]	655	}
[973]	656	strattractor = w->stringify(false);
[797]	657	par.setStringById(FL_PE_CONN_ATTR, strattractor);
	658	delete w;
	659	}
	660	}
[973]	661	}
	662	else
	663	{
	664	if (!(*selectedword)->parevals[randeval])
[797]	665	{
[973]	666	(*selectedword)->parevals[randeval] = new MathEvaluation(numpars);
[797]	667	}
[973]	668	(*selectedword)->parevals[randeval]->mutate(false, iterchangestep != 1.0);
[797]	669	}
	670	}
	671	}
[973]	672	break;
[797]	673	}
[973]	674	}
[797]	675
	676	free(geno);
	677	geno = strdup(creature->toString().c_str());
	678	chg = (double)abs(before - creature->countWordsInLSystem()) / before;
	679	delete creature;
	680
	681	return GENOPER_OK;
	682	}
	683
	684	fL_Word* Geno_fL::getAppropriateWord(fL_Builder from, fL_Builder to, fL_Word *fromword, std::unordered_map<std::string, std::string> &map)
	685	{
	686	if (fromword->name == "[" \|\| fromword->name == "]") // if words are branching words
	687	{
	688	fL_Branch *newword = new fL_Branch(fromword->name == "[" ? fL_Branch::BranchType::OPEN : fL_Branch::BranchType::CLOSE, 0, 0);
	689	return newword;
	690	}
	691	if (fromword->builtin)
	692	{
	693	fL_Word *newword = new fL_Word();
	694	(newword) = (to->words[fromword->name.c_str()]);
	695	return newword;
	696	}
	697	if (map.find(fromword->name.c_str()) != map.end()) // if word is already mapped
	698	{
	699	fL_Word *newword = new fL_Word();
	700	(newword) = (to->words[map[fromword->name.c_str()]]);
	701	return newword;
	702	}
	703	else if (to->words.find(fromword->name.c_str()) != to->words.end() &&
[973]	704	to->words[fromword->name.c_str()]->npar == fromword->npar) // if there is already same word with same number of parameters
[797]	705	{
	706	fL_Word *newword = new fL_Word();
	707	map[fromword->name.c_str()] = fromword->name.c_str();
	708	(newword) = (to->words[map[fromword->name.c_str()]]);
	709	return newword;
	710	}
	711	for (std::unordered_map<std::string, fL_Word *>::iterator it = to->words.begin();
[973]	712	it != to->words.end(); it++)
[797]	713	{ // find word with same number of parameters
	714	if (fromword->npar == it->second->npar && map.find(fromword->name.c_str()) == map.end() && !it->second->builtin)
	715	{ // if there is a word with same number of parameters
	716	map[fromword->name.c_str()] = it->second->name.c_str();
	717	fL_Word *newword = new fL_Word();
	718	(newword) = (it->second);
	719	return newword;
	720	}
	721	}
	722	fL_Word *newworddef = new fL_Word();
	723	(newworddef) = (fromword);
	724	newworddef->parevals.clear();
	725	if (to->words.find(newworddef->name.c_str()) != to->words.end())
	726	{
	727	int i = 0;
	728	while (true)
	729	{
	730	std::string name = "w";
	731	name += std::to_string(i);
	732	if (to->words.find(name) == to->words.end())
	733	{
	734	newworddef->name = name.c_str();
	735	break;
	736	}
	737	i++;
	738	}
	739	}
	740	newworddef->processDefinition(to);
	741	map[fromword->name.c_str()] = newworddef->name.c_str();
	742	fL_Word *newword = new fL_Word();
	743	(newword) = (to->words[map[fromword->name.c_str()]]);
	744	return newword;
	745	}
	746
	747	void Geno_fL::migrateRandomRules(fL_Builder from, fL_Builder to, int numselrules)
	748	{
	749	std::unordered_map<std::string, std::string> map;
	750	if (from->rules.size() > 0)
	751	{
	752	for (int i = 0; i < numselrules; i++)
	753	{
[896]	754	int rulid = rndUint(from->rules.size());
[797]	755	fL_Rule *rul = from->rules[rulid];
	756	fL_Rule *newrule = new fL_Rule(0, 0);
	757	newrule->objpred = getAppropriateWord(from, to, rul->objpred, map);
	758	for (fL_Word *w : rul->objsucc)
	759	{
	760	fL_Word *el = getAppropriateWord(from, to, w, map);
	761	if (el->type == fLElementType::BRANCH)
	762	{
	763	newrule->objsucc.push_back(el);
	764	continue;
	765	}
	766	Param origpar(w->tab);
	767	origpar.select(w->data);
	768	el->data = ParamObject::makeObject(el->tab);
	769	Param par(el->tab);
	770	par.select(el->data);
	771	par.setDefault();
	772	for (int i = 0; i < el->npar; i++)
	773	{
	774	std::string form;
	775	if (w->builtin && w->name == "N"
[973]	776	&& strcmp(par.id(i), FL_PE_NEURO_DET) == 0)
[797]	777	{
	778	SString res = origpar.getStringById(FL_PE_NEURO_DET);
	779	par.setStringById(FL_PE_NEURO_DET, res);
	780	el->parevals.push_back(NULL);
	781	}
	782	else if (w->builtin && w->name == "C"
[973]	783	&& strcmp(par.id(i), FL_PE_CONN_ATTR) == 0)
[797]	784	{
	785	SString strattractor = origpar.getStringById(FL_PE_CONN_ATTR);
[973]	786	if (strattractor.length() > 0)
[797]	787	{
	788	fL_Word *tmp = NULL;
	789	from->createWord(strattractor, tmp, newrule->objpred->npar, 0, 0);
	790	fL_Word *newsuccword = getAppropriateWord(from, to, tmp, map);
	791	newsuccword->data = ParamObject::makeObject(el->tab);
	792	newsuccword->parevals = tmp->parevals;
	793	tmp->parevals.clear();
	794	strattractor = newsuccword->stringify(true);
	795	par.setStringById(FL_PE_CONN_ATTR, strattractor);
	796	delete newsuccword;
	797	delete tmp;
	798	}
	799	par.setStringById(FL_PE_CONN_ATTR, strattractor);
	800	el->parevals.push_back(NULL);
	801	}
	802	else if (w->parevals[i])
	803	{
	804	MathEvaluation *eval = new MathEvaluation(newrule->objpred->npar);
	805	w->parevals[i]->RPNToInfix(form);
	806	eval->convertString(form);
	807	el->parevals.push_back(eval);
	808	}
	809	else
	810	{
	811	el->parevals.push_back(NULL);
	812	}
	813	}
	814	newrule->objsucc.push_back(el);
	815	}
	816	to->rules.push_back(newrule);
	817	}
	818	}
	819	}
	820
	821	int Geno_fL::crossOver(char &g1, char &g2, float& chg1, float& chg2)
	822	{
	823	fL_Builder *creature1 = new fL_Builder(false, false);
	824	fL_Builder *creature1template = new fL_Builder(false, false);
	825	fL_Builder *creature2 = new fL_Builder(false, false);
	826	fL_Builder *creature2template = new fL_Builder(false, false);
	827
	828	int count1 = creature1->countWordsInLSystem();
	829	int count2 = creature2->countWordsInLSystem();
	830
	831	if (creature1->parseGenotype(g1) != 0 \|\| creature2->parseGenotype(g2) != 0)
	832	{
	833	delete creature1;
	834	delete creature2;
	835	delete creature1template;
	836	delete creature2template;
	837	return GENOPER_OPFAIL;
	838	}
	839
	840	creature1template->parseGenotype(g1);
	841	creature2template->parseGenotype(g2);
	842
[896]	843	int numselrules = 1 + rndUint(XOVER_MAX_MIGRATED_RULES);
[797]	844	numselrules = numselrules < (int)creature1->rules.size() ? numselrules : (int)creature1->rules.size();
	845
	846	migrateRandomRules(creature1template, creature2, numselrules);
	847
[896]	848	numselrules = 1 + rndUint(XOVER_MAX_MIGRATED_RULES);
[797]	849	numselrules = numselrules < (int)creature1->rules.size() ? numselrules : (int)creature1->rules.size();
	850
	851	migrateRandomRules(creature2template, creature1, numselrules);
	852
	853	free(g1);
	854	free(g2);
	855
	856	g1 = strdup(creature1->toString().c_str());
	857	g2 = strdup(creature2->toString().c_str());
	858
	859	chg1 = (double)count1 / creature1->countWordsInLSystem();
	860	chg1 = (double)count2 / creature2->countWordsInLSystem();
	861
	862	delete creature1;
	863	delete creature2;
	864	delete creature1template;
	865	delete creature2template;
	866
	867	return GENOPER_OK;
	868	}
	869
	870	uint32_t Geno_fL::style(const char *geno, int pos)
	871	{
	872	char ch = geno[pos];
	873	uint32_t style = GENSTYLE_CS(0, GENSTYLE_STRIKEOUT);
	874	if (pos == 0 \|\| geno[pos - 1] == '\n' \|\| ch == ':') // single-character line definition
	875	{
	876	style = GENSTYLE_CS(GENCOLOR_TEXT, GENSTYLE_BOLD);
	877	}
	878	else if (strchr("()", ch) != NULL)
	879	{
	880	style = GENSTYLE_RGBS(50, 50, 50, GENSTYLE_BOLD);
	881	}
	882	else if (isalpha(ch)) // properties name
	883	{
	884	style = GENSTYLE_RGBS(0, 200, 0, GENSTYLE_BOLD);
	885	}
	886	else if (isdigit(ch) \|\| strchr(",.=", ch)) // properties values
	887	{
	888	style = GENSTYLE_CS(GENCOLOR_TEXT, GENSTYLE_NONE);
	889	}
	890	else if (ch == '\"')
	891	{
	892	style = GENSTYLE_RGBS(200, 0, 0, GENSTYLE_BOLD);
	893	}
[1029]	894	else if (strchr("<>$[]&\\ @\|*", ch) != NULL) // other allowed symbols and special neuron symbols
	895	{
	896	style = GENSTYLE_CS(GENCOLOR_TEXT, ch=='[' \|\| ch==']' ? GENSTYLE_BOLD : GENSTYLE_NONE);
	897	}
[797]	898	return style;
	899	}

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

Download in other formats: