Context Navigation

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

Last change on this file since 1280 was 1273, checked in by Maciej Komosinski, 15 months ago
fH, fB, fL: improved default parameter values, syntax coloring and code logic
File size: 26.6 KB

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

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

Download in other formats: