1 | /* |
---|
2 | * geno_f8.cpp |
---|
3 | * L-systemToF1 |
---|
4 | * |
---|
5 | * Created by Maciej Wajcht on 08-06-07. |
---|
6 | * Copyright 2008 __MyCompanyName__. All rights reserved. |
---|
7 | * |
---|
8 | */ |
---|
9 | |
---|
10 | #include "geno_f8.h" |
---|
11 | #include <cstdlib> |
---|
12 | //#include <sys/time.h> |
---|
13 | #include "conv_f8tof1.h" |
---|
14 | #include "multimap.h" |
---|
15 | #include <iostream> |
---|
16 | #include <string> |
---|
17 | #include "sstringutils.h" |
---|
18 | #include "conv_f8_utils.h" |
---|
19 | |
---|
20 | #define GENO_F8_DEBUG 1 //0 - off, 1 - on |
---|
21 | |
---|
22 | #define FIELDSTRUCT Geno_f8 |
---|
23 | |
---|
24 | static ParamEntry GENO8param_tab[]= |
---|
25 | { |
---|
26 | {"Genetics: f8",1,F8_OPERATION_COUNT,}, |
---|
27 | {"f8_mut_chg_begin_arg", 0, 0, "Change beginning argument", "f 0 100 8", FIELD(operation[F8_CHANGE_BEGINNING_ARG]),"mutation: probability of changing a beginning argument", }, |
---|
28 | {"f8_mut_chg_arg", 0, 0, "Change argument", "f 0 100 8", FIELD(operation[F8_CHANGE_ARG]),"mutation: probability of changing a production's argument", }, |
---|
29 | {"f8_mut_del_comm", 0, 0, "Delete command", "f 0 100 8", FIELD(operation[F8_DELETE_COMMAND]),"mutation: probability of deleting a command", }, |
---|
30 | {"f8_mut_insert_comm", 0, 0, "Insert commands", "f 0 100 9", FIELD(operation[F8_INSERT_COMMANDS]),"mutation: probability of inserting commands", }, |
---|
31 | {"f8_mut_enc", 0, 0, "Encapsulate commands", "f 0 100 10",FIELD(operation[F8_ENCAPSULATE]),"mutation: probability of encapsulating commands", }, |
---|
32 | {"f8_mut_chg_cond_sign", 0, 0, "Change condition sign", "f 0 100 8",FIELD(operation[F8_CHANGE_CONDITION_SIGN]),"mutation: probability of changing a condition sign", }, |
---|
33 | {"f8_mut_add_param", 0, 0, "Add parameter", "f 0 100 9", FIELD(operation[F8_ADD_PARAMETER]),"mutation: probability of adding a parameter to the production", }, |
---|
34 | {"f8_mut_add_cond", 0, 0, "Add condition", "f 0 100 8", FIELD(operation[F8_ADD_CONDITION]),"mutation: probability of ading a condition to the subproduction", }, |
---|
35 | {"f8_mut_add_subprod", 0, 0, "Add subproduction", "f 0 100 8", FIELD(operation[F8_ADD_SUBPRODUCTION]),"mutation: probability of adding a subproduction", }, |
---|
36 | {"f8_mut_chg_iter_number", 0, 0, "Change iteration number", "f 0 100 8", FIELD(operation[F8_CHANGE_ITERATIONS_NUMBER]),"mutation: probability of changing an iterations number", }, |
---|
37 | {"f8_mut_del_param", 0, 0, "Delete parameter", "f 0 100 8", FIELD(operation[F8_DELETE_PARAMETER]),"mutation: probability of deleting a parameter", }, |
---|
38 | {"f8_mut_del_cond", 0, 0, "Delete condition", "f 0 100 8", FIELD(operation[F8_DELETE_CONDITION]),"mutation: probability of deleting a condition", }, |
---|
39 | {"f8_mut_add_loop", 0, 0, "Add loop", "f 0 100 0", FIELD(operation[F8_ADD_LOOP]),"mutation: probability of ading a loop", }, |
---|
40 | {"f8_mut_del_loop", 0, 0, "Delete loop", "f 0 100 0", FIELD(operation[F8_DELETE_LOOP]),"mutation: probability of deleting a loop", }, |
---|
41 | {0,}, |
---|
42 | }; |
---|
43 | |
---|
44 | #undef FIELDSTRUCT |
---|
45 | |
---|
46 | ProductionInfo::ProductionInfo(SString name, int paramCount) { |
---|
47 | this->name = name; |
---|
48 | this->paramCount = paramCount; |
---|
49 | } |
---|
50 | |
---|
51 | Geno_f8::Geno_f8() { |
---|
52 | supported_format = '8'; |
---|
53 | this->simpleCommandLetters.push_back('X'); |
---|
54 | this->simpleCommandLetters.push_back('R'); |
---|
55 | this->simpleCommandLetters.push_back('r'); |
---|
56 | this->simpleCommandLetters.push_back('C'); |
---|
57 | this->simpleCommandLetters.push_back('c'); |
---|
58 | this->simpleCommandLetters.push_back('Q'); |
---|
59 | this->simpleCommandLetters.push_back('q'); |
---|
60 | this->simpleCommandLetters.push_back('['); |
---|
61 | this->simpleCommandLetters.push_back(']'); |
---|
62 | this->simpleCommandLetters.push_back('^'); |
---|
63 | this->converter = new GenoConv_F8ToF1(); |
---|
64 | |
---|
65 | par.setParamTab(GENO8param_tab); |
---|
66 | par.select(this); |
---|
67 | par.setDefault(); |
---|
68 | |
---|
69 | /*mutation_method_names = new char*[F8_OPERATION_COUNT - 1]; |
---|
70 | int index = 0; |
---|
71 | mutation_method_names[index++]="changed beginning argument"; |
---|
72 | mutation_method_names[index++]="changed argument"; |
---|
73 | mutation_method_names[index++]="deleted command"; |
---|
74 | mutation_method_names[index++]="inserted command"; |
---|
75 | mutation_method_names[index++]="encapsulated command"; |
---|
76 | mutation_method_names[index++]="changed condition sign"; |
---|
77 | mutation_method_names[index++]="added parameter"; |
---|
78 | mutation_method_names[index++]="added condition"; |
---|
79 | mutation_method_names[index++]="added subproduction"; |
---|
80 | mutation_method_names[index++]="changed iterations number"; |
---|
81 | mutation_method_names[index++]="deleted parameter"; |
---|
82 | mutation_method_names[index++]="deleted condition"; |
---|
83 | mutation_method_names[index++]="added loop"; |
---|
84 | mutation_method_names[index++]="deleted loop"; |
---|
85 | */ |
---|
86 | |
---|
87 | #ifdef GENO_F8_DEBUG > 0 |
---|
88 | for (int i = 0; i < F8_OPERATION_COUNT; i++) { |
---|
89 | this->operation[i] = 1.0 / (double)F8_OPERATION_COUNT; |
---|
90 | } |
---|
91 | #endif |
---|
92 | } |
---|
93 | |
---|
94 | Geno_f8::~Geno_f8() { |
---|
95 | delete this->converter; |
---|
96 | } |
---|
97 | |
---|
98 | int Geno_f8::checkValidity(const char * geno) { |
---|
99 | SString ssgeno = SString(geno); |
---|
100 | SString f1ssgeno = this->converter->convert(ssgeno, NULL); |
---|
101 | const char* f1genosrc = f1ssgeno; |
---|
102 | Geno f1geno(f1genosrc); |
---|
103 | if (this->converter->checkSyntax(geno) && f1geno.isValid()) { |
---|
104 | return GENOPER_OK; |
---|
105 | } else { |
---|
106 | return 1; |
---|
107 | } |
---|
108 | } |
---|
109 | |
---|
110 | int Geno_f8::validate(char *& geno) { |
---|
111 | SString in = geno; |
---|
112 | SString validated = ""; |
---|
113 | SString line; |
---|
114 | int pos = 0; |
---|
115 | bool firstLine = true; |
---|
116 | bool beforeDelim = true; |
---|
117 | bool justAfterDelim = false; |
---|
118 | while (in.getNextToken(pos, line, '\n')) { |
---|
119 | if (firstLine) { |
---|
120 | firstLine = false; |
---|
121 | const char* str = geno; |
---|
122 | std::istringstream i(str); |
---|
123 | double x; |
---|
124 | if (i >> x) { |
---|
125 | validated += line + "\n"; |
---|
126 | } else { |
---|
127 | validated += "10\n"; |
---|
128 | } |
---|
129 | } else if (beforeDelim) { |
---|
130 | if (line[0] == 'P' && line.indexOf('(') != -1 && line.indexOf(')') != -1 && line.indexOf(':') != -1) { |
---|
131 | validated += "---\n"; |
---|
132 | validated += line + "\n"; |
---|
133 | beforeDelim = false; |
---|
134 | } |
---|
135 | int eqSignPos = line.indexOf('='); |
---|
136 | if (line[0] == 'n' && eqSignPos != -1) { |
---|
137 | validated += line + "\n"; |
---|
138 | } else if (line == SString("---")) { |
---|
139 | validated += line + "\n"; |
---|
140 | beforeDelim = false; |
---|
141 | justAfterDelim = true; |
---|
142 | } |
---|
143 | } else if (justAfterDelim && line[0] == 'P') { |
---|
144 | const char* digits = "0123456789"; |
---|
145 | SString s = line.substr(1); |
---|
146 | bool ok = true; |
---|
147 | for (int i = 0; i < s.len(); i++) { |
---|
148 | if (!strContainsOneOf(s(i), digits)) { |
---|
149 | ok = false; |
---|
150 | break; |
---|
151 | } |
---|
152 | } |
---|
153 | if (ok) { |
---|
154 | validated += line +"\n"; |
---|
155 | } |
---|
156 | justAfterDelim = false; |
---|
157 | } else if (line[0] == 'P' && line.indexOf('(') != -1 && line.indexOf(')') != -1 && line.indexOf(':') != -1) { |
---|
158 | validated += line + "\n"; |
---|
159 | } |
---|
160 | } |
---|
161 | free(geno); //must take care of the original allocation |
---|
162 | char* validatedTmp = (char*)malloc(strlen(validated) + 1); //allocate for mutated genotype |
---|
163 | strcpy(validatedTmp, validated); //the rest is originalg = mutated; |
---|
164 | geno = validatedTmp; |
---|
165 | |
---|
166 | return GENOPER_OK; |
---|
167 | } |
---|
168 | |
---|
169 | int Geno_f8::getProductionsCount(const SString &in) { |
---|
170 | int pos = 0; |
---|
171 | SString line; |
---|
172 | int counter = 0; |
---|
173 | bool beforeDelim = true; |
---|
174 | while (in.getNextToken(pos, line, '\n')) { |
---|
175 | if (line.startsWith("---")) { |
---|
176 | beforeDelim = false; |
---|
177 | //also skip the start production |
---|
178 | in.getNextToken(pos, line, '\n'); |
---|
179 | continue; |
---|
180 | } else if (beforeDelim) { |
---|
181 | continue; |
---|
182 | } else { |
---|
183 | counter++; |
---|
184 | } |
---|
185 | } |
---|
186 | return counter; |
---|
187 | } |
---|
188 | |
---|
189 | vector<ProductionInfo> Geno_f8::getProductionsInfo(const SString &in) { |
---|
190 | vector<ProductionInfo> productions; |
---|
191 | SString line; |
---|
192 | int pos = 0; |
---|
193 | bool beforeFirstProd = true; |
---|
194 | SString firstProdName; |
---|
195 | while (in.getNextToken(pos, line, '\n')) { |
---|
196 | if (line.startsWith("P") && line.indexOf('(', 0) == -1) { |
---|
197 | firstProdName = line; |
---|
198 | beforeFirstProd = false; |
---|
199 | continue; |
---|
200 | } |
---|
201 | if (beforeFirstProd) { |
---|
202 | continue; |
---|
203 | } |
---|
204 | int lParenIndex = line.indexOf('(', 0); |
---|
205 | int rParenIndex = line.indexOf(')', 0); |
---|
206 | if (line[0] == 'P' && lParenIndex != -1 && rParenIndex != -1) { |
---|
207 | ProductionInfo info; |
---|
208 | SString prodName = line.substr(0, lParenIndex); |
---|
209 | info.name = prodName; |
---|
210 | info.paramCount = 0; |
---|
211 | //if (line[lParenIndex + 1] == 'n') { |
---|
212 | SString strParams = line.substr(lParenIndex + 1, rParenIndex - lParenIndex - 1); |
---|
213 | int pos2 = 0; |
---|
214 | SString tok; |
---|
215 | while (strParams.getNextToken(pos2, tok, ',')) { |
---|
216 | info.paramCount++; |
---|
217 | info.paramNames.push_back(tok); |
---|
218 | } |
---|
219 | //} |
---|
220 | info.isFirstProduction = (prodName == firstProdName) ? true : false; |
---|
221 | productions.push_back(info); |
---|
222 | } |
---|
223 | } |
---|
224 | return productions; |
---|
225 | } |
---|
226 | |
---|
227 | SString Geno_f8::mutateChangeBeginningArg(SString &in, float& chg) { |
---|
228 | SString mutated, line, before, mid, after, tmp; |
---|
229 | int counter = 0; |
---|
230 | int pos = 0; |
---|
231 | bool afterDelim = false; |
---|
232 | bool firstLine = true; |
---|
233 | while (in.getNextToken(pos, line, '\n')) { |
---|
234 | if (firstLine) { |
---|
235 | firstLine = false; |
---|
236 | before += line + "\n"; |
---|
237 | continue; |
---|
238 | } |
---|
239 | if (afterDelim) { |
---|
240 | after += line + "\n"; |
---|
241 | continue; |
---|
242 | } |
---|
243 | if (line.startsWith("---")) { |
---|
244 | afterDelim = true; |
---|
245 | after += line + "\n"; |
---|
246 | } else { |
---|
247 | mid += line + "\n"; |
---|
248 | counter++; |
---|
249 | } |
---|
250 | } |
---|
251 | if (counter == 0) { |
---|
252 | chg = 0.0; |
---|
253 | mutated = in; |
---|
254 | } else { |
---|
255 | int randNbr = randomN(counter); |
---|
256 | pos = 0; |
---|
257 | counter = 0; |
---|
258 | while (mid.getNextToken(pos, line, '\n')) { |
---|
259 | if (counter++ == randNbr) { |
---|
260 | int pos2 = 0; |
---|
261 | SString tok; |
---|
262 | line.getNextToken(pos2, tok, '='); |
---|
263 | tmp += tok + "="; |
---|
264 | line.getNextToken(pos2, tok, '='); |
---|
265 | double arg = parseDouble(tok); |
---|
266 | arg += (double) (randomN(11) - 5); //-5..5 |
---|
267 | tmp += SString::valueOf(arg) + "\n"; |
---|
268 | chg = (float) (SString::valueOf(arg).len()) / (float) in.len(); |
---|
269 | } else { |
---|
270 | tmp += line + "\n"; |
---|
271 | } |
---|
272 | } |
---|
273 | mid = tmp; |
---|
274 | mutated += before; |
---|
275 | mutated += mid; |
---|
276 | mutated += after; |
---|
277 | } |
---|
278 | return mutated; |
---|
279 | } |
---|
280 | |
---|
281 | SString Geno_f8::mutateChangeArg(SString &in, float& chg) { |
---|
282 | SString mutated; |
---|
283 | |
---|
284 | Lsystem *newLsystem = this->converter->createLsystem(in); |
---|
285 | if (newLsystem == NULL) { |
---|
286 | mutated += in; |
---|
287 | chg = -1.0; |
---|
288 | return mutated; |
---|
289 | } |
---|
290 | |
---|
291 | vector<Production*> interestingProductions; |
---|
292 | |
---|
293 | for (map<string, Production*>::iterator prodIter = newLsystem->productions.begin(); |
---|
294 | prodIter != newLsystem->productions.end(); prodIter++) { |
---|
295 | if (prodIter->second->parameters.size() > 0) { |
---|
296 | interestingProductions.push_back(prodIter->second); |
---|
297 | } |
---|
298 | } |
---|
299 | |
---|
300 | if (interestingProductions.size() > 0) { |
---|
301 | int rnd = randomN(interestingProductions.size()); |
---|
302 | |
---|
303 | Production *randomProduction = interestingProductions[rnd]; |
---|
304 | SString prodName = randomProduction->name; |
---|
305 | |
---|
306 | int paramIndex = randomN(randomProduction->parameters.size()); |
---|
307 | |
---|
308 | for (map<string, Production*>::iterator prodIter = newLsystem->productions.begin(); |
---|
309 | prodIter != newLsystem->productions.end(); prodIter++) { |
---|
310 | vector<SubProduction> *subproductions = &(prodIter->second->subproductions); |
---|
311 | for (vector<SubProduction>::iterator subProdIter = subproductions->begin(); |
---|
312 | subProdIter != subproductions->end(); subProdIter++) { |
---|
313 | SubProduction *sp = &(*subProdIter); |
---|
314 | for (vector<ActionStrP>::iterator actionIter = sp->actions.begin(); |
---|
315 | actionIter != sp->actions.end(); actionIter++) { |
---|
316 | if ((*actionIter).action != NULL && (*actionIter).action->name == prodName && (*actionIter).params.size() > paramIndex) { |
---|
317 | SString param = (*actionIter).params[paramIndex]; |
---|
318 | int counter = 0; |
---|
319 | int pos = 0; |
---|
320 | SString tok; |
---|
321 | while (in.getNextToken(pos, tok, ',')) { |
---|
322 | counter++; |
---|
323 | } |
---|
324 | int rnd = randomN(counter); |
---|
325 | pos = 0; |
---|
326 | counter = 0; |
---|
327 | SString newParam = ""; |
---|
328 | if (randomN(2) == 0 || prodIter->second->parameters.size() == 0) { |
---|
329 | int rnd2 = randomN(5) + 1; |
---|
330 | newParam += param + SString::valueOf(rnd2) + ";"; |
---|
331 | } else { |
---|
332 | SString paramName = prodIter->second->parameters.getParameterName(randomN(prodIter->second->parameters.size())+1); |
---|
333 | newParam += param + paramName + ";"; |
---|
334 | } |
---|
335 | newParam += (rnd == 0) ? SString("+;") : SString("-;"); |
---|
336 | (*actionIter).params[paramIndex] = newParam; |
---|
337 | goto label; |
---|
338 | } |
---|
339 | } |
---|
340 | } |
---|
341 | } |
---|
342 | label: |
---|
343 | chg = 2.0 / (float) in.len(); |
---|
344 | } |
---|
345 | |
---|
346 | mutated = newLsystem->toString(); |
---|
347 | |
---|
348 | delete newLsystem; |
---|
349 | |
---|
350 | return mutated; |
---|
351 | } |
---|
352 | |
---|
353 | SString Geno_f8::mutateDeleteCommand(SString &in, float& chg) { |
---|
354 | SString mutated; |
---|
355 | |
---|
356 | Lsystem *lsystem = this->converter->createLsystem(in); |
---|
357 | if (lsystem == NULL) { |
---|
358 | mutated += in; |
---|
359 | chg = -1.0; |
---|
360 | return mutated; |
---|
361 | } |
---|
362 | |
---|
363 | map<string, Production*>::iterator prodIter = lsystem->productions.begin(); |
---|
364 | for (int i = 0; i < randomN(lsystem->productions.size()); i++) { |
---|
365 | if (i != 0) { |
---|
366 | prodIter++; |
---|
367 | } |
---|
368 | } |
---|
369 | |
---|
370 | Production *randomProduction = prodIter->second; |
---|
371 | if (randomProduction->subproductions.size() > 0) { |
---|
372 | vector<ActionStrP> *actions = &(randomProduction->subproductions.at(randomN(randomProduction->subproductions.size())).actions); |
---|
373 | int rnd = randomN(actions->size()); |
---|
374 | if (actions->size() > 0) { |
---|
375 | Action *a = actions->at(rnd).action; |
---|
376 | if (a != NULL) { |
---|
377 | chg = (float) (a->getF8Representation().len()) / (float) in.len(); |
---|
378 | actions->erase(actions->begin() + rnd); |
---|
379 | } |
---|
380 | } |
---|
381 | } |
---|
382 | |
---|
383 | mutated = lsystem->toString(); |
---|
384 | |
---|
385 | delete lsystem; |
---|
386 | |
---|
387 | return mutated; |
---|
388 | } |
---|
389 | |
---|
390 | SString Geno_f8::mutateInsertCommands(SString &in, float& chg) { |
---|
391 | SString mutated; |
---|
392 | |
---|
393 | //cout << "insertCommands 1" << endl; |
---|
394 | Lsystem *lsystem = this->converter->createLsystem(in); |
---|
395 | if (lsystem == NULL) { |
---|
396 | mutated += in; |
---|
397 | chg = -1.0; |
---|
398 | return mutated; |
---|
399 | } |
---|
400 | |
---|
401 | //cout << "insertCommands 2" << endl; |
---|
402 | vector<Action*> actions = lsystem->getAllActions(true, true, false, false); |
---|
403 | //cout << "insertCommands 3" << endl; |
---|
404 | |
---|
405 | int random1 = randomN(lsystem->productions.size()); |
---|
406 | |
---|
407 | map<string, Production*>::iterator prodIter = lsystem->productions.begin(); |
---|
408 | for (int counter = 0; counter < random1; counter++) { |
---|
409 | prodIter++; |
---|
410 | } |
---|
411 | //cout << "insertCommands 4" << endl; |
---|
412 | |
---|
413 | Production *p = prodIter->second; |
---|
414 | SubProduction *sp; |
---|
415 | if (p->subproductions.size() > 0) { |
---|
416 | sp = &(p->subproductions.at(randomN(p->subproductions.size()))); |
---|
417 | } else { |
---|
418 | mutated += in; |
---|
419 | chg = -1.0; |
---|
420 | return mutated; |
---|
421 | } |
---|
422 | |
---|
423 | int commandsToInsert = /*randomN(3) +*/ 1; |
---|
424 | int insertLen = 0; |
---|
425 | for (int i = 0; i < commandsToInsert; i++) { |
---|
426 | ActionStrP a; |
---|
427 | if (actions.size() > 0) { |
---|
428 | a.action = actions.at(randomN(actions.size())); |
---|
429 | } else { |
---|
430 | mutated += in; |
---|
431 | chg = -1.0; |
---|
432 | return mutated; |
---|
433 | } |
---|
434 | insertLen += a.action->getF8Representation().len(); |
---|
435 | if (a.action->ignoreParams == false && a.action->name[0] == 'P') { |
---|
436 | Production *p = (Production*) a.action; |
---|
437 | insertLen += 2; |
---|
438 | for (int j = 0; j < p->parameters.size(); j++) { |
---|
439 | int rnd = randomN(p->parameters.size() + 1); |
---|
440 | if (rnd == 0) { |
---|
441 | a.params.push_back(SString("0;")); |
---|
442 | insertLen += 1; |
---|
443 | } else { |
---|
444 | SString s = p->parameters.getParameterName(randomN(p->parameters.size()) + 1); |
---|
445 | a.params.push_back(s + ";"); |
---|
446 | insertLen += s.len(); |
---|
447 | } |
---|
448 | } |
---|
449 | } |
---|
450 | sp->actions.push_back(a); |
---|
451 | } |
---|
452 | //cout << "insertCommands 5" << endl; |
---|
453 | |
---|
454 | mutated = lsystem->toString(); |
---|
455 | //cout << "insertCommands 6" << endl; |
---|
456 | chg = (float) insertLen / (float) in.len(); |
---|
457 | |
---|
458 | delete lsystem; |
---|
459 | //cout << "insertCommands 7" << endl; |
---|
460 | |
---|
461 | return mutated; |
---|
462 | } |
---|
463 | |
---|
464 | SString Geno_f8::mutateEncapsulate(SString &in, float& chg) { |
---|
465 | SString mutated; |
---|
466 | |
---|
467 | Lsystem *lsystem = this->converter->createLsystem(in); |
---|
468 | if (lsystem == NULL || lsystem->productions.size() == 0) { |
---|
469 | mutated += in; |
---|
470 | chg = -1.0; |
---|
471 | return mutated; |
---|
472 | } |
---|
473 | |
---|
474 | int counter = 0; |
---|
475 | int rnd = randomN(lsystem->productions.size()); |
---|
476 | int len = 0; |
---|
477 | |
---|
478 | Production *p = new Production(); |
---|
479 | p->subproductions.push_back(SubProduction()); |
---|
480 | SubProduction *newSubProd = &(p->subproductions.back()); |
---|
481 | |
---|
482 | for (map<string, Production*>::iterator prodIter = lsystem->productions.begin(); |
---|
483 | prodIter != lsystem->productions.end(); prodIter++) { |
---|
484 | if (counter++ == rnd) { |
---|
485 | ParameterCollection *params = &(prodIter->second->parameters); |
---|
486 | //copy parameters to the encapsulated production |
---|
487 | for (int i = 1; i <= params->size(); i++) { |
---|
488 | p->parameters.addParameter(params->getParameterName(i)); |
---|
489 | } |
---|
490 | |
---|
491 | SubProduction *subproduction; |
---|
492 | if (prodIter->second->subproductions.size() > 0) { |
---|
493 | subproduction = &(prodIter->second->subproductions[randomN(prodIter->second->subproductions.size())]); |
---|
494 | } else { |
---|
495 | mutated += in; |
---|
496 | chg = -1.0; |
---|
497 | return mutated; |
---|
498 | } |
---|
499 | int firstActionIdx; |
---|
500 | if (subproduction->actions.size() > 0) { |
---|
501 | firstActionIdx = randomN(subproduction->actions.size()); |
---|
502 | } else { |
---|
503 | mutated += in; |
---|
504 | chg = -1.0; |
---|
505 | return mutated; |
---|
506 | } |
---|
507 | int i; |
---|
508 | vector<ActionStrP> newActions; |
---|
509 | for (i = 0; i < firstActionIdx; i++) { |
---|
510 | newActions.push_back(subproduction->actions[i]); |
---|
511 | } |
---|
512 | for (i = firstActionIdx; i <= firstActionIdx + randomN(4) + 1 |
---|
513 | && i < subproduction->actions.size(); i++) { //1..4 actions |
---|
514 | newSubProd->actions.push_back(subproduction->actions[i]); |
---|
515 | if (subproduction->actions[i].action != NULL) { |
---|
516 | len += subproduction->actions[i].action->getF8Representation().len(); |
---|
517 | } |
---|
518 | } |
---|
519 | ActionStrP a; |
---|
520 | a.action = p; |
---|
521 | a.params = vector<SString>(); |
---|
522 | for (int j = 0; j < params->size(); j++) { |
---|
523 | //a.params.push_back(SString("0;")); |
---|
524 | a.params.push_back(params->getParameterName(j + 1)); |
---|
525 | } |
---|
526 | newActions.push_back(a); |
---|
527 | while (i < subproduction->actions.size()) { |
---|
528 | if (subproduction->actions[i].action != NULL) { |
---|
529 | newActions.push_back(subproduction->actions[i]); |
---|
530 | } |
---|
531 | i++; |
---|
532 | } |
---|
533 | subproduction->actions = newActions; |
---|
534 | break; |
---|
535 | } |
---|
536 | } |
---|
537 | |
---|
538 | SString newName; |
---|
539 | for (int i = 0; i < 100000; i++) { |
---|
540 | newName = "P"; |
---|
541 | newName += SString::valueOf(i); |
---|
542 | if (lsystem->productions[sstringToString(newName)] == NULL) { |
---|
543 | break; |
---|
544 | } |
---|
545 | } |
---|
546 | p->name = newName; |
---|
547 | lsystem->productions[sstringToString(newName)] = p; |
---|
548 | |
---|
549 | mutated = lsystem->toString(); |
---|
550 | |
---|
551 | delete lsystem; |
---|
552 | |
---|
553 | chg = (float) len / (float) in.len(); |
---|
554 | return mutated; |
---|
555 | } |
---|
556 | |
---|
557 | SString Geno_f8::mutateChangeConditionSign(SString &in, float& chg) { |
---|
558 | SString mutated; |
---|
559 | |
---|
560 | Lsystem *newLsystem = this->converter->createLsystem(in); |
---|
561 | if (newLsystem == NULL) { |
---|
562 | mutated += in; |
---|
563 | chg = -1.0; |
---|
564 | return mutated; |
---|
565 | } |
---|
566 | |
---|
567 | map<int, SubProduction*> interestingSubproductions; |
---|
568 | int counter = 0; |
---|
569 | |
---|
570 | for (map<string, Production*>::iterator prodIter = newLsystem->productions.begin(); |
---|
571 | prodIter != newLsystem->productions.end(); prodIter++) { |
---|
572 | for (vector<SubProduction>::iterator subprodIter = prodIter->second->subproductions.begin(); |
---|
573 | subprodIter != prodIter->second->subproductions.end(); subprodIter++) { |
---|
574 | SubProduction *sp = &(*subprodIter); |
---|
575 | if (sp->conditions.size() > 0) { |
---|
576 | interestingSubproductions[counter++] = sp; |
---|
577 | } |
---|
578 | } |
---|
579 | } |
---|
580 | |
---|
581 | if (interestingSubproductions.size() > 0) { |
---|
582 | int random1 = randomN(interestingSubproductions.size()); |
---|
583 | SubProduction *randomSubproduction = interestingSubproductions[random1]; |
---|
584 | int random2 = randomN(randomSubproduction->conditions.size()); //all interesting conditions have conditions.size() > 0 |
---|
585 | Condition *c = &(randomSubproduction->conditions.at(random2)); |
---|
586 | c->relation = this->getDifferentCondition(c->relation); |
---|
587 | chg = 2.0 / (float) in.len(); |
---|
588 | } |
---|
589 | |
---|
590 | mutated = newLsystem->toString(); |
---|
591 | |
---|
592 | delete newLsystem; |
---|
593 | |
---|
594 | return mutated; |
---|
595 | } |
---|
596 | |
---|
597 | SString Geno_f8::mutateAddParameter(SString &in, float& chg) { |
---|
598 | SString mutated; |
---|
599 | |
---|
600 | Lsystem *lsystem = this->converter->createLsystem(in); |
---|
601 | if (lsystem == NULL || lsystem->productions.size() == 0) { |
---|
602 | mutated += in; |
---|
603 | chg = -1.0; |
---|
604 | return mutated; |
---|
605 | } |
---|
606 | |
---|
607 | //cout << "addParameter 1" << endl; |
---|
608 | int rnd = randomN(lsystem->productions.size()); |
---|
609 | int chglen = 0; |
---|
610 | |
---|
611 | SString prodName = ""; |
---|
612 | |
---|
613 | int counter = 0; |
---|
614 | for (map<string, Production*>::iterator prodIter = lsystem->productions.begin(); |
---|
615 | prodIter != lsystem->productions.end(); prodIter++) { |
---|
616 | if (counter++ == rnd) { |
---|
617 | prodName = prodIter->second->name; |
---|
618 | SString newParam; |
---|
619 | for (int i = 0; i < 10000; i++) { |
---|
620 | newParam = "n"; |
---|
621 | newParam += SString::valueOf(i); |
---|
622 | if (!prodIter->second->parameters.paramExist(newParam)) { |
---|
623 | prodIter->second->parameters.addParameter(newParam); |
---|
624 | chglen += newParam.len(); |
---|
625 | break; |
---|
626 | } |
---|
627 | } |
---|
628 | |
---|
629 | if (prodName == stringToSString(lsystem->firstProductionName)) { |
---|
630 | lsystem->startParams[sstringToString(newParam)] = 0.0; |
---|
631 | } |
---|
632 | break; |
---|
633 | } |
---|
634 | } |
---|
635 | //cout << "addParameter 2" << endl; |
---|
636 | for (map<string, Production*>::iterator prodIter = lsystem->productions.begin(); |
---|
637 | prodIter != lsystem->productions.end(); prodIter++) { |
---|
638 | for (vector<SubProduction>::iterator subprodIter = prodIter->second->subproductions.begin(); |
---|
639 | subprodIter != prodIter->second->subproductions.end(); subprodIter++) { |
---|
640 | for (vector<ActionStrP>::iterator actionIter = (*subprodIter).actions.begin(); |
---|
641 | actionIter != (*subprodIter).actions.end(); actionIter++) { |
---|
642 | if ((*actionIter).action != NULL && (*actionIter).action->name != NULL) { |
---|
643 | if ((*actionIter).action->name == prodName) { |
---|
644 | int randParamVal = randomN(prodIter->second->parameters.size() + 1); |
---|
645 | SString paramVal = NULL; |
---|
646 | if (randParamVal == 0) { |
---|
647 | paramVal = "0;"; |
---|
648 | } else { |
---|
649 | paramVal = prodIter->second->parameters.getParameterName(randParamVal) + ";"; |
---|
650 | } |
---|
651 | //(*actionIter).params.push_back(paramVal); |
---|
652 | chglen += 2; |
---|
653 | } |
---|
654 | } |
---|
655 | } |
---|
656 | } |
---|
657 | } |
---|
658 | //cout << "addParameter 3" << endl; |
---|
659 | |
---|
660 | mutated = lsystem->toString(); |
---|
661 | //cout << "addParameter 4" << endl; |
---|
662 | |
---|
663 | delete lsystem; |
---|
664 | |
---|
665 | chg = (float) chglen / (float) in.len(); |
---|
666 | return mutated; |
---|
667 | } |
---|
668 | |
---|
669 | SString Geno_f8::mutateAddCondition(SString &in, float& chg) { |
---|
670 | SString mutated, before, mid, after, line; |
---|
671 | vector<ProductionInfo> prodInfo = this->getProductionsInfo(in); |
---|
672 | vector<int> interestingProductions; |
---|
673 | for (int i = 0; i < prodInfo.size(); i++) { |
---|
674 | if (prodInfo[i].paramNames.size() > 0) { |
---|
675 | interestingProductions.push_back(i); |
---|
676 | } |
---|
677 | } |
---|
678 | if (interestingProductions.size() == 0) { |
---|
679 | chg = -1.0; |
---|
680 | mutated = in; |
---|
681 | return mutated; |
---|
682 | } |
---|
683 | int rndProd = interestingProductions[randomN(interestingProductions.size())]; |
---|
684 | int pos = 0; |
---|
685 | mutated = ""; |
---|
686 | while (in.getNextToken(pos, line, '\n')) { |
---|
687 | if (line.startsWith(prodInfo[rndProd].name) && line.len() > prodInfo[rndProd].name.len()) { |
---|
688 | int subproductionsCount = -1; |
---|
689 | SString tok; |
---|
690 | int pos2 = 0; |
---|
691 | while (line.getNextToken(pos2, tok, ':')) { |
---|
692 | subproductionsCount++; |
---|
693 | } |
---|
694 | if (subproductionsCount == 0) { |
---|
695 | chg = -1.0; |
---|
696 | mutated = in; |
---|
697 | return mutated; |
---|
698 | } |
---|
699 | int rnd = randomN(subproductionsCount); |
---|
700 | int counter = 0; |
---|
701 | int colonIdx = line.indexOf(':', 0); |
---|
702 | pos2 = colonIdx; |
---|
703 | while (counter != rnd) { |
---|
704 | colonIdx = line.indexOf(':', pos2 + 1); |
---|
705 | counter++; |
---|
706 | } |
---|
707 | |
---|
708 | int nextColonIdx = line.indexOf(':', colonIdx + 1); |
---|
709 | if (nextColonIdx == -1) { |
---|
710 | nextColonIdx = 2147483646; |
---|
711 | } |
---|
712 | int pipeIdx = line.indexOf('|', colonIdx + 1); |
---|
713 | mid = ""; |
---|
714 | if (pipeIdx < nextColonIdx && pipeIdx != -1) { |
---|
715 | //before += line.substr(colonIdx + 1, pipeIdx - colonIdx - 1); |
---|
716 | before = line.substr(0, pipeIdx); |
---|
717 | mid += ","; |
---|
718 | after = line.substr(pipeIdx); |
---|
719 | } else { |
---|
720 | before = line.substr(0, colonIdx + 1); |
---|
721 | after = SString("|") + line.substr(colonIdx + 1); |
---|
722 | } |
---|
723 | int paramIdx = (int) randomN(prodInfo[rndProd].paramNames.size()); |
---|
724 | mid += prodInfo[rndProd].paramNames[paramIdx]; |
---|
725 | mid += (randomN(2) == 0) ? ">" : "<"; |
---|
726 | mid += SString::valueOf((int) randomN(21) - 10); |
---|
727 | |
---|
728 | mutated += before + mid + after + "\n"; |
---|
729 | chg = (float) mid.len() / (float)in.len(); |
---|
730 | } else { |
---|
731 | mutated += line + "\n"; |
---|
732 | } |
---|
733 | } |
---|
734 | return mutated; |
---|
735 | } |
---|
736 | |
---|
737 | SString Geno_f8::mutateDeleteParameter(SString &in, float& chg) { |
---|
738 | SString mutated; |
---|
739 | |
---|
740 | Lsystem *newLsystem = this->converter->createLsystem(in); |
---|
741 | if (newLsystem == NULL) { |
---|
742 | mutated += in; |
---|
743 | chg = -1.0; |
---|
744 | return mutated; |
---|
745 | } |
---|
746 | |
---|
747 | map<int, Production*> interestingProductions; |
---|
748 | int counter = 0; |
---|
749 | |
---|
750 | for (map<string, Production*>::iterator prodIter = newLsystem->productions.begin(); |
---|
751 | prodIter != newLsystem->productions.end(); prodIter++) { |
---|
752 | if (prodIter->second->parameters.size() > 0) { |
---|
753 | interestingProductions[counter++] = prodIter->second; |
---|
754 | } |
---|
755 | } |
---|
756 | |
---|
757 | if (interestingProductions.size() > 0) { |
---|
758 | int rnd = randomN(interestingProductions.size()); |
---|
759 | |
---|
760 | Production *randomProduction = interestingProductions[rnd]; |
---|
761 | SString prodName = randomProduction->name; |
---|
762 | |
---|
763 | int paramIndex = randomN(randomProduction->parameters.size()) + 1; |
---|
764 | SString paramName = randomProduction->parameters.getParameterName(paramIndex); |
---|
765 | string sparamName = sstringToString(paramName); |
---|
766 | int change = paramName.len(); |
---|
767 | |
---|
768 | randomProduction->parameters.removeParameter(paramName); |
---|
769 | |
---|
770 | if (prodName == stringToSString(newLsystem->firstProductionName)) { |
---|
771 | newLsystem->startParams.erase(sstringToString(paramName)); |
---|
772 | } |
---|
773 | |
---|
774 | for (vector<SubProduction>::iterator subProdIter = randomProduction->subproductions.begin(); |
---|
775 | subProdIter != randomProduction->subproductions.end(); subProdIter++) { |
---|
776 | for (int condIter = 0; condIter < (*subProdIter).conditions.size(); condIter++) { |
---|
777 | Condition c = (*subProdIter).conditions[condIter]; |
---|
778 | if (c.parameter == paramName) { |
---|
779 | (*subProdIter).conditions.erase((*subProdIter).conditions.begin() + condIter); |
---|
780 | } |
---|
781 | } |
---|
782 | for (vector<ActionStrP>::iterator actionIter = (*subProdIter).actions.begin(); |
---|
783 | actionIter != (*subProdIter).actions.end(); actionIter++) { |
---|
784 | for (vector<SString>::iterator paramIter = (*actionIter).params.begin(); |
---|
785 | paramIter != (*actionIter).params.end(); paramIter++) { |
---|
786 | string s = sstringToString(*paramIter); |
---|
787 | if (s.find(sparamName, 0) != string::npos) { |
---|
788 | *paramIter = SString("0;"); |
---|
789 | } |
---|
790 | } |
---|
791 | } |
---|
792 | } |
---|
793 | |
---|
794 | for (map<string, Production*>::iterator prodIter = newLsystem->productions.begin(); |
---|
795 | prodIter != newLsystem->productions.end(); prodIter++) { |
---|
796 | vector<SubProduction> *subproductions = &(prodIter->second->subproductions); |
---|
797 | for (vector<SubProduction>::iterator subProdIter = subproductions->begin(); |
---|
798 | subProdIter != subproductions->end(); subProdIter++) { |
---|
799 | SubProduction *sp = &(*subProdIter); |
---|
800 | for (int actionIter = 0; actionIter < sp->actions.size(); actionIter++) { |
---|
801 | ActionStrP *actionstrp = &(sp->actions.at(actionIter)); |
---|
802 | if (actionstrp->action != NULL) { |
---|
803 | if (actionstrp->action->name == prodName && actionstrp->params.size() > paramIndex - 1) { |
---|
804 | change += paramName.len(); //more less |
---|
805 | actionstrp->params.erase(actionstrp->params.begin() + (paramIndex - 1)); |
---|
806 | } |
---|
807 | } |
---|
808 | } |
---|
809 | } |
---|
810 | } |
---|
811 | chg = (float) change / (float) in.len(); |
---|
812 | } |
---|
813 | |
---|
814 | mutated = newLsystem->toString(); |
---|
815 | |
---|
816 | delete newLsystem; |
---|
817 | |
---|
818 | return mutated; |
---|
819 | } |
---|
820 | |
---|
821 | SString Geno_f8::mutateDeleteCondition(SString &in, float& chg) { |
---|
822 | SString mutated; |
---|
823 | |
---|
824 | Lsystem *newLsystem = this->converter->createLsystem(in); |
---|
825 | if (newLsystem == NULL) { |
---|
826 | mutated += in; |
---|
827 | chg = -1.0; |
---|
828 | return mutated; |
---|
829 | } |
---|
830 | |
---|
831 | map<int, SubProduction*> interestingSubproductions; |
---|
832 | int counter = 0; |
---|
833 | |
---|
834 | for (map<string, Production*>::iterator prodIter = newLsystem->productions.begin(); |
---|
835 | prodIter != newLsystem->productions.end(); prodIter++) { |
---|
836 | for (vector<SubProduction>::iterator subprodIter = prodIter->second->subproductions.begin(); |
---|
837 | subprodIter != prodIter->second->subproductions.end(); subprodIter++) { |
---|
838 | SubProduction *sp = &(*subprodIter); |
---|
839 | if (sp->conditions.size() > 0) { |
---|
840 | interestingSubproductions[counter++] = sp; |
---|
841 | } |
---|
842 | } |
---|
843 | } |
---|
844 | |
---|
845 | if (interestingSubproductions.size() > 0) { |
---|
846 | int rnd = randomN(interestingSubproductions.size()); |
---|
847 | SubProduction *randomSubproduction = interestingSubproductions[rnd]; |
---|
848 | vector<Condition>::iterator condIter = randomSubproduction->conditions.begin(); |
---|
849 | condIter += randomN(randomSubproduction->conditions.size() - 1); |
---|
850 | Condition c = *condIter; |
---|
851 | chg = (float) (c.parameter.len() + 1 + SString::valueOf(c.value).len()) / (float) in.len(); |
---|
852 | randomSubproduction->conditions.erase(condIter); |
---|
853 | } |
---|
854 | |
---|
855 | mutated = newLsystem->toString(); |
---|
856 | |
---|
857 | delete newLsystem; |
---|
858 | |
---|
859 | return mutated; |
---|
860 | } |
---|
861 | |
---|
862 | SString Geno_f8::mutateAddLoop(SString &in, float& chg) { |
---|
863 | /* |
---|
864 | * Podczas wczytania genotypu do obiektu typu Lsystem nastepuje rozwiniecie petli, wiec kolejne mutacje |
---|
865 | * zniweczyly by zysk ktory mozna uzyskac dzieki petlom. Dlatego nic nie zmieniamy. |
---|
866 | */ |
---|
867 | SString mutated, line; |
---|
868 | int pos = 0; |
---|
869 | while (in.getNextToken(pos, line, '\n')) { |
---|
870 | mutated += line + "\n"; |
---|
871 | } |
---|
872 | chg = 0.0; |
---|
873 | return mutated; |
---|
874 | } |
---|
875 | |
---|
876 | SString Geno_f8::mutateDeleteLoop(SString &in, float& chg) { |
---|
877 | /* |
---|
878 | * Podczas wczytania genotypu do obiektu typu Lsystem nastepuje rozwiniecie petli, wiec kolejne mutacje |
---|
879 | * zniweczyly by zysk ktory mozna uzyskac dzieki petlom. Dlatego nic nie zmieniamy. |
---|
880 | */ |
---|
881 | SString mutated, line; |
---|
882 | int pos = 0; |
---|
883 | while (in.getNextToken(pos, line, '\n')) { |
---|
884 | mutated += line + "\n"; |
---|
885 | } |
---|
886 | chg = 0.0; |
---|
887 | return mutated; |
---|
888 | } |
---|
889 | |
---|
890 | SString Geno_f8::mutateAddSubproduction(SString &in, float& chg) { |
---|
891 | SString mutated, line; |
---|
892 | vector<ProductionInfo> prodInfo = this->getProductionsInfo(in); |
---|
893 | int rndProd = randomN(prodInfo.size()); |
---|
894 | int pos = 0; |
---|
895 | mutated = ""; |
---|
896 | while (in.getNextToken(pos, line, '\n')) { |
---|
897 | if (line.startsWith(prodInfo[rndProd].name) && line.indexOf(':', 0) != -1) { |
---|
898 | SString tmp = ":"; |
---|
899 | int paramCount = prodInfo[rndProd].paramNames.size(); |
---|
900 | if (paramCount > 0) { |
---|
901 | tmp += prodInfo[rndProd].paramNames[(int) randomN(paramCount)]; |
---|
902 | tmp += (randomN(2) == 0) ? ">" : "<"; |
---|
903 | tmp += SString::valueOf((int) randomN(21) - 10); |
---|
904 | tmp += "|"; |
---|
905 | } |
---|
906 | tmp += "X\n"; |
---|
907 | chg = (float) tmp.len() / (float) in.len(); |
---|
908 | mutated += line + tmp; |
---|
909 | } else { |
---|
910 | mutated += line + "\n"; |
---|
911 | } |
---|
912 | } |
---|
913 | return mutated; |
---|
914 | } |
---|
915 | |
---|
916 | SString Geno_f8::mutateChangeIterationsNumber(SString &in, float& chg) { |
---|
917 | SString mutated; |
---|
918 | Lsystem *newLsystem = this->converter->createLsystem(in); |
---|
919 | if (newLsystem == NULL) { |
---|
920 | mutated += in; |
---|
921 | chg = -1.0; |
---|
922 | return mutated; |
---|
923 | } |
---|
924 | |
---|
925 | newLsystem->iterations += randomN(7) - 3; //-3..3 |
---|
926 | if (newLsystem->iterations < 1) { |
---|
927 | newLsystem->iterations = 1; |
---|
928 | } |
---|
929 | mutated = newLsystem->toString(); |
---|
930 | delete newLsystem; |
---|
931 | chg = 1.0 / (float) in.len(); |
---|
932 | return mutated; |
---|
933 | } |
---|
934 | |
---|
935 | int Geno_f8::mutate(char *&g,float& chg, int &method) { |
---|
936 | SString in = g; |
---|
937 | |
---|
938 | /*struct timeval tv; |
---|
939 | gettimeofday(&tv, NULL); |
---|
940 | srandom(tv.tv_sec + tv.tv_usec); |
---|
941 | */ |
---|
942 | method = roulette(this->operation, F8_OPERATION_COUNT); |
---|
943 | if (method < 0) { |
---|
944 | return GENOPER_OPFAIL; |
---|
945 | } |
---|
946 | |
---|
947 | #if GENO_F8_DEBUG > 0 |
---|
948 | string mutationName = (method == 0) ? "F8_CHANGE_BEGINNING_ARG" : |
---|
949 | (method == 1) ? "F8_CHANGE_ARG" : |
---|
950 | (method == 2) ? "F8_DELETE_COMMAND" : |
---|
951 | (method == 3) ? "F8_INSERT_COMMANDS" : |
---|
952 | (method == 4) ? "F8_ENCAPSULATE" : |
---|
953 | (method == 5) ? "F8_CHANGE_CONDITION_SIGN" : |
---|
954 | (method == 6) ? "F8_REPLACE_COMMAND" : |
---|
955 | (method == 7) ? "F8_ADD_PARAMETER" : |
---|
956 | (method == 8) ? "F8_ADD_CONDITION" : |
---|
957 | (method == 9) ? "F8_ADD_SUBPRODUCTION" : |
---|
958 | (method == 10) ? "F8_CHANGE_ITERATIONS_NUMBER" : |
---|
959 | (method == 11) ? "F8_DELETE_PARAMETER" : |
---|
960 | (method == 12) ? "F8_DELETE_CONDITION" : |
---|
961 | (method == 13) ? "F8_ADD_LOOP" : |
---|
962 | (method == 14) ? "F8_DELETE_LOOP" : |
---|
963 | (method == 15) ? "F8_OPERATION_COUNT" : "babol"; |
---|
964 | //cout << "-------------------- " << mutationName << " --------------------" << endl; |
---|
965 | #endif |
---|
966 | |
---|
967 | const char* mutatedTmp; |
---|
968 | SString ssMutatedTmp; |
---|
969 | |
---|
970 | //cout << "mutate 1" << endl; |
---|
971 | switch (method) { |
---|
972 | case F8_CHANGE_BEGINNING_ARG: |
---|
973 | ssMutatedTmp = this->mutateChangeBeginningArg(in, chg); |
---|
974 | break; |
---|
975 | case F8_CHANGE_ARG: |
---|
976 | ssMutatedTmp = this->mutateChangeArg(in, chg); |
---|
977 | break; |
---|
978 | case F8_DELETE_COMMAND: |
---|
979 | ssMutatedTmp = this->mutateDeleteCommand(in, chg); |
---|
980 | break; |
---|
981 | case F8_INSERT_COMMANDS: |
---|
982 | ssMutatedTmp = this->mutateInsertCommands(in, chg); |
---|
983 | break; |
---|
984 | case F8_ENCAPSULATE: |
---|
985 | ssMutatedTmp = this->mutateEncapsulate(in, chg); |
---|
986 | break; |
---|
987 | case F8_CHANGE_CONDITION_SIGN: |
---|
988 | ssMutatedTmp = this->mutateChangeConditionSign(in, chg); |
---|
989 | break; |
---|
990 | /*case F8_REPLACE_COMMAND: |
---|
991 | ssMutatedTmp = this->mutateReplaceCommand(in, chg); |
---|
992 | break;*/ |
---|
993 | case F8_ADD_PARAMETER: |
---|
994 | ssMutatedTmp = this->mutateAddParameter(in, chg); |
---|
995 | break; |
---|
996 | case F8_ADD_CONDITION: |
---|
997 | ssMutatedTmp = this->mutateAddCondition(in, chg); |
---|
998 | break; |
---|
999 | case F8_ADD_SUBPRODUCTION: |
---|
1000 | ssMutatedTmp = this->mutateAddSubproduction(in, chg); |
---|
1001 | break; |
---|
1002 | case F8_CHANGE_ITERATIONS_NUMBER: |
---|
1003 | ssMutatedTmp = this->mutateChangeIterationsNumber(in, chg); |
---|
1004 | break; |
---|
1005 | case F8_DELETE_PARAMETER: |
---|
1006 | ssMutatedTmp = this->mutateDeleteParameter(in, chg); |
---|
1007 | break; |
---|
1008 | case F8_DELETE_CONDITION: |
---|
1009 | ssMutatedTmp = this->mutateDeleteCondition(in, chg); |
---|
1010 | break; |
---|
1011 | case F8_ADD_LOOP: |
---|
1012 | ssMutatedTmp = this->mutateAddLoop(in, chg); |
---|
1013 | break; |
---|
1014 | case F8_DELETE_LOOP: |
---|
1015 | ssMutatedTmp = this->mutateDeleteLoop(in, chg); |
---|
1016 | break; |
---|
1017 | default: |
---|
1018 | return GENOPER_OPFAIL; |
---|
1019 | } |
---|
1020 | |
---|
1021 | //cout << "mutate 2" << endl; |
---|
1022 | if (ssMutatedTmp.len() < 16) { |
---|
1023 | return GENOPER_OPFAIL; |
---|
1024 | } |
---|
1025 | if (chg == -1.0) { |
---|
1026 | chg = 0.0; |
---|
1027 | return GENOPER_OPFAIL; |
---|
1028 | } |
---|
1029 | |
---|
1030 | mutatedTmp = ssMutatedTmp; |
---|
1031 | |
---|
1032 | if (this->checkValidity(mutatedTmp) == GENOPER_OK) { |
---|
1033 | free(g); //must take care of the original allocation |
---|
1034 | g = (char*)malloc(strlen(mutatedTmp) + 1); //allocate for mutated genotype |
---|
1035 | strcpy(g, mutatedTmp); //the rest is originalg = mutated; |
---|
1036 | //cout << "mutate 3" << endl; |
---|
1037 | return GENOPER_OK; |
---|
1038 | } else { |
---|
1039 | return GENOPER_OPFAIL; |
---|
1040 | } |
---|
1041 | } |
---|
1042 | |
---|
1043 | int Geno_f8::crossOver(char *&g1,char *&g2,float& chg1,float& chg2) { |
---|
1044 | /* wymiana niewielkiej (max. 25%) ilości odpowiadającej sobie informacji |
---|
1045 | * ma to przypominać "celowaną" mutację, w której osobnik dostaje |
---|
1046 | * niewiele wiedzy, która sprawdziła się u innego osobnika |
---|
1047 | */ |
---|
1048 | SString in1 = g1; |
---|
1049 | SString in2 = g2; |
---|
1050 | SString mutated; |
---|
1051 | //SString dst; |
---|
1052 | //const char* src = in; |
---|
1053 | //const char* t; |
---|
1054 | |
---|
1055 | Lsystem *newLsystem = this->converter->createLsystem(in1); |
---|
1056 | Lsystem *lsystem2 = this->converter->createLsystem(in2); |
---|
1057 | if (newLsystem == NULL || lsystem2 == NULL) { |
---|
1058 | chg1 = 0.0; |
---|
1059 | chg2 = 0.0; |
---|
1060 | return GENOPER_OPFAIL; |
---|
1061 | } |
---|
1062 | |
---|
1063 | //shuffle second parent's productions |
---|
1064 | vector<int> indices; |
---|
1065 | for (int i = 0; i < lsystem2->productions.size(); i++) { |
---|
1066 | indices.push_back(i); |
---|
1067 | } |
---|
1068 | map<string, Production*> shuffledProductions; |
---|
1069 | while (!indices.empty()) { |
---|
1070 | int rnd = randomN(indices.size()); |
---|
1071 | int counter = 0; |
---|
1072 | //Production *p; |
---|
1073 | for (map<string, Production*>::iterator it = lsystem2->productions.begin(); |
---|
1074 | it != lsystem2->productions.end(); it++) { |
---|
1075 | if (counter == rnd) { |
---|
1076 | //p = it->second; |
---|
1077 | shuffledProductions[it->first] = it->second; |
---|
1078 | break; |
---|
1079 | } |
---|
1080 | } |
---|
1081 | //delete index number |
---|
1082 | indices.erase(indices.begin() + rnd); |
---|
1083 | } |
---|
1084 | |
---|
1085 | int productionCount = randomN(min(newLsystem->productions.size() / 4, lsystem2->productions.size())) + 1; |
---|
1086 | |
---|
1087 | int counter = 0; |
---|
1088 | for (map<string, Production*>::iterator it = shuffledProductions.begin(); |
---|
1089 | it != shuffledProductions.end() || counter < productionCount; it++) { |
---|
1090 | //if selected production's name exist in the first parent |
---|
1091 | if (newLsystem->productions.find(it->first) != newLsystem->productions.end()) { |
---|
1092 | newLsystem->productions[it->first]->subproductions = it->second->subproductions; |
---|
1093 | counter++; |
---|
1094 | } else { |
---|
1095 | /* This fragment is commented out because we are interested only in matching productions /////// |
---|
1096 | //search for first production, which name does not exist in one of the productions |
---|
1097 | //selected from second parent |
---|
1098 | //this is to avoid information loss when new subproductions will be overwritten |
---|
1099 | //just after adding to the child production |
---|
1100 | for (map<string, Production*>::iterator it2 = newLsystem->productions.begin(); |
---|
1101 | it2 != newLsystem->productions.end(); it2++) { |
---|
1102 | if (shuffledProductions.find(it2->first) == shuffledProductions.end()) { //not found |
---|
1103 | it2->second->subproductions = it->second->subproductions; |
---|
1104 | break; |
---|
1105 | } |
---|
1106 | //there are no "else" because there is at least twice as many productions |
---|
1107 | //in the first parent as selected productions from the second parent |
---|
1108 | //so always we will find "free" production name |
---|
1109 | }*/ |
---|
1110 | } |
---|
1111 | } |
---|
1112 | |
---|
1113 | //check validity of productions indicated in actions |
---|
1114 | for (map<string, Production*>::iterator prodIter = newLsystem->productions.begin(); |
---|
1115 | prodIter != newLsystem->productions.end(); prodIter++) { |
---|
1116 | vector<SString> paramNames; |
---|
1117 | for (int i = 1; i <= prodIter->second->parameters.size(); i++) { |
---|
1118 | paramNames.push_back(prodIter->second->parameters.getParameterName(i)); |
---|
1119 | } |
---|
1120 | for (vector<SubProduction>::iterator subprodIter = prodIter->second->subproductions.begin(); |
---|
1121 | subprodIter != prodIter->second->subproductions.end(); subprodIter++) { |
---|
1122 | //conditions |
---|
1123 | if (paramNames.size() > 0) { |
---|
1124 | for (vector<Condition>::iterator condIter = (*subprodIter).conditions.begin(); |
---|
1125 | condIter != (*subprodIter).conditions.end(); condIter++) { |
---|
1126 | vector<SString>::iterator searchIter = find(paramNames.begin(), paramNames.end(), |
---|
1127 | (*condIter).parameter); |
---|
1128 | if (searchIter == paramNames.end()) { //unknown parameter name! |
---|
1129 | //choose random existing parameter |
---|
1130 | (*condIter).parameter = paramNames[randomN(paramNames.size())]; |
---|
1131 | } |
---|
1132 | } |
---|
1133 | } else { //no params, so delete all conditions |
---|
1134 | (*subprodIter).conditions.clear(); |
---|
1135 | } |
---|
1136 | |
---|
1137 | //actions |
---|
1138 | for (vector<ActionStrP>::iterator actionIter = (*subprodIter).actions.begin(); |
---|
1139 | actionIter != (*subprodIter).actions.end(); actionIter++) { |
---|
1140 | SString &actionName = (*actionIter).action->name; |
---|
1141 | if (actionName[0] == 'n') { |
---|
1142 | if (paramNames.size() > 0) { |
---|
1143 | vector<SString>::iterator searchIter = find(paramNames.begin(), paramNames.end(), |
---|
1144 | actionName); |
---|
1145 | if (searchIter != paramNames.end()) { //valid name |
---|
1146 | //ensure it is linked to the correct production |
---|
1147 | (*actionIter).action = newLsystem->getParamProduction(actionName); |
---|
1148 | } else { |
---|
1149 | //link to random parameter prodution |
---|
1150 | SString name = paramNames[randomN(paramNames.size())]; |
---|
1151 | (*actionIter).action = newLsystem->getParamProduction(name); |
---|
1152 | } |
---|
1153 | } else { //no params, so delete this param production |
---|
1154 | (*subprodIter).actions.erase(actionIter); //TODO sprawdzić zachowanie iteratora!!! |
---|
1155 | } |
---|
1156 | } else if (actionName[0] == 'P') { |
---|
1157 | if (newLsystem->productions.find(sstringToString(actionName)) != newLsystem->productions.end()) { |
---|
1158 | //ensure it is linked to the correct production |
---|
1159 | (*actionIter).action = newLsystem->productions[sstringToString(actionName)]; |
---|
1160 | } else { |
---|
1161 | //delete this action |
---|
1162 | (*subprodIter).actions.erase(actionIter); |
---|
1163 | } |
---|
1164 | } |
---|
1165 | } |
---|
1166 | if ((*subprodIter).actions.size() == 0) { //we erased all the actions |
---|
1167 | ActionStrP a; |
---|
1168 | a.action = newLsystem->getPrimitiveProduction(SString("X")); |
---|
1169 | (*subprodIter).actions.push_back(a); |
---|
1170 | } |
---|
1171 | } |
---|
1172 | } |
---|
1173 | |
---|
1174 | mutated = newLsystem->toString(); |
---|
1175 | |
---|
1176 | shuffledProductions.clear(); |
---|
1177 | |
---|
1178 | delete newLsystem; |
---|
1179 | delete lsystem2; |
---|
1180 | |
---|
1181 | free(g1); //must take care of the original allocation |
---|
1182 | //free(g2); |
---|
1183 | const char* mutatedTmp = mutated; |
---|
1184 | char* mutatedTmp2 = (char*)malloc(strlen(mutatedTmp) + 1); //allocate for mutated genotype |
---|
1185 | strcpy(mutatedTmp2, mutatedTmp); //the rest is originalg = mutated; |
---|
1186 | g1 = mutatedTmp2; |
---|
1187 | chg1 = 0.5; |
---|
1188 | |
---|
1189 | return GENOPER_OK; |
---|
1190 | } |
---|
1191 | |
---|
1192 | unsigned long Geno_f8::style(const char *g, int pos) { |
---|
1193 | return GENSTYLE_RGBS(0, 0, 0, GENSTYLE_NONE); |
---|
1194 | } |
---|
1195 | |
---|
1196 | char* Geno_f8::getSimplest() { |
---|
1197 | const char* geno = "1\n---\nP0\nP0():X\n"; |
---|
1198 | char* retGeno = (char*)malloc(strlen(geno) + 1); |
---|
1199 | strcpy(retGeno, geno); |
---|
1200 | return retGeno; |
---|
1201 | } |
---|
1202 | |
---|
1203 | bool Geno_f8::checkProdNameExist(vector<ProductionInfo> info, SString name) const { |
---|
1204 | for (vector<ProductionInfo>::iterator it = info.begin(); it != info.end(); it++) { |
---|
1205 | if ((*it).name == name) { |
---|
1206 | return true; |
---|
1207 | } |
---|
1208 | } |
---|
1209 | return false; |
---|
1210 | } |
---|
1211 | |
---|
1212 | bool Geno_f8::checkParamNameExist(vector<SString> names, SString name) const { |
---|
1213 | for (vector<SString>::iterator it = names.begin(); it != names.end(); it++ ) { |
---|
1214 | if ((*it) == name) { |
---|
1215 | return true; |
---|
1216 | } |
---|
1217 | } |
---|
1218 | return false; |
---|
1219 | } |
---|
1220 | |
---|
1221 | SString Geno_f8::getOppositeCondition(const SString &c) const { |
---|
1222 | if (c.equals("==")) |
---|
1223 | return "!="; |
---|
1224 | if (c.equals("!=")) |
---|
1225 | return "=="; |
---|
1226 | if (c.equals(">")) |
---|
1227 | return "<="; |
---|
1228 | if (c.equals("<")) |
---|
1229 | return ">="; |
---|
1230 | if (c.equals(">=")) |
---|
1231 | return "<"; |
---|
1232 | if (c.equals("<=")) |
---|
1233 | return ">"; |
---|
1234 | return "<"; //default |
---|
1235 | } |
---|
1236 | |
---|
1237 | RelationType Geno_f8::getDifferentCondition(RelationType type) { |
---|
1238 | RelationType types[6]; |
---|
1239 | types[0] = r_greater; |
---|
1240 | types[1] = r_greaterEqual; |
---|
1241 | types[2] = r_equal; |
---|
1242 | types[3] = r_different; |
---|
1243 | types[4] = r_lessEqual; |
---|
1244 | types[5] = r_less; |
---|
1245 | |
---|
1246 | for (int i = 0; i < 6; i++) { |
---|
1247 | if (types[i] == type) { |
---|
1248 | types[i] = types[5]; |
---|
1249 | //types[5] = type; |
---|
1250 | break; |
---|
1251 | } |
---|
1252 | } |
---|
1253 | |
---|
1254 | int randomType = randomN(5); |
---|
1255 | return types[randomType]; |
---|
1256 | } |
---|
1257 | |
---|
1258 | SString Geno_f8::removeProductionCalls(const SString production) const { |
---|
1259 | SString line = trimSString(production); |
---|
1260 | SString result = ""; |
---|
1261 | bool skip = false; |
---|
1262 | for (int i = 0; i < line.len(); i++) { |
---|
1263 | if (skip) { |
---|
1264 | if (line[i] == ')') { |
---|
1265 | skip = false; |
---|
1266 | } else { |
---|
1267 | //do nothing |
---|
1268 | } |
---|
1269 | } else { |
---|
1270 | if (line[i] == 'P') { |
---|
1271 | skip = true; |
---|
1272 | } else { |
---|
1273 | result += line[i]; |
---|
1274 | } |
---|
1275 | } |
---|
1276 | } |
---|
1277 | return result; |
---|
1278 | } |
---|
1279 | |
---|
1280 | SString Geno_f8::addParameterToCalls(const SString line, SString &prodName) { |
---|
1281 | SString newStr = ""; |
---|
1282 | int colonIdx = line.indexOf(':', 0); |
---|
1283 | if (colonIdx != -1 && line.indexOf(prodName, colonIdx) != -1) { |
---|
1284 | int pos2 = colonIdx; |
---|
1285 | int beginIdx = 0; |
---|
1286 | int prodIdx; |
---|
1287 | while ((prodIdx = line.indexOf(prodName, pos2)) != -1) { |
---|
1288 | int indexRBrace = line.indexOf(')', prodIdx); |
---|
1289 | newStr += line.substr(beginIdx, indexRBrace); |
---|
1290 | if (newStr[newStr.len() - 1] != '(') { |
---|
1291 | newStr += SString(","); |
---|
1292 | } |
---|
1293 | newStr += "0.0"; |
---|
1294 | beginIdx = indexRBrace; |
---|
1295 | pos2 = indexRBrace; |
---|
1296 | } |
---|
1297 | newStr += line.substr(pos2); |
---|
1298 | } else { |
---|
1299 | newStr = line; |
---|
1300 | } |
---|
1301 | return newStr; |
---|
1302 | } |
---|
1303 | |
---|
1304 | SString Geno_f8::deleteParameterFromCalls(const SString line, SString &prodName, int paramIdx) { |
---|
1305 | SString newStr = ""; |
---|
1306 | SString tmp, before, mid, midTmp; |
---|
1307 | mid = ""; |
---|
1308 | int colonIdx = line.indexOf(':', 0); |
---|
1309 | if (colonIdx != -1 && line.indexOf(prodName, colonIdx) != -1) { |
---|
1310 | int pos2 = colonIdx; |
---|
1311 | int beginIdx = 0; |
---|
1312 | int prodIdx; |
---|
1313 | while ((prodIdx = line.indexOf(prodName, pos2)) != -1) { |
---|
1314 | int indexRBrace = line.indexOf(')', prodIdx); |
---|
1315 | before = line.substr(beginIdx, prodIdx + prodName.len() + 1); |
---|
1316 | midTmp = line.substr(prodIdx + prodName.len() + 1, indexRBrace - (prodIdx + prodName.len() + 1)); |
---|
1317 | pos2 = 0; |
---|
1318 | SString tok; |
---|
1319 | int i = 0; |
---|
1320 | while (midTmp.getNextToken(pos2, tok, ',')) { |
---|
1321 | if (i++ == paramIdx) { |
---|
1322 | //do nothing |
---|
1323 | } else { |
---|
1324 | mid += tok + ","; |
---|
1325 | } |
---|
1326 | } |
---|
1327 | if (mid[mid.len() - 1] == ',') { |
---|
1328 | mid = mid.substr(0, mid.len() - 1); |
---|
1329 | } |
---|
1330 | |
---|
1331 | newStr += before + mid + ")"; |
---|
1332 | beginIdx = indexRBrace; |
---|
1333 | pos2 = indexRBrace; |
---|
1334 | } |
---|
1335 | newStr += line.substr(pos2 + 1); |
---|
1336 | } else { |
---|
1337 | newStr = line; |
---|
1338 | } |
---|
1339 | return newStr; |
---|
1340 | } |
---|
1341 | |
---|
1342 | SString Geno_f8::testMutate(SString &in, int method) { |
---|
1343 | /*struct timeval tv; |
---|
1344 | gettimeofday(&tv, NULL); |
---|
1345 | srandom(tv.tv_sec + tv.tv_usec); |
---|
1346 | */ |
---|
1347 | SString mutatedTmp; |
---|
1348 | float chg = 0.0; |
---|
1349 | switch (method) { |
---|
1350 | case F8_CHANGE_BEGINNING_ARG: |
---|
1351 | mutatedTmp = this->mutateChangeBeginningArg(in, chg); |
---|
1352 | break; |
---|
1353 | case F8_CHANGE_ARG: |
---|
1354 | mutatedTmp = this->mutateChangeArg(in, chg); |
---|
1355 | break; |
---|
1356 | case F8_DELETE_COMMAND: |
---|
1357 | mutatedTmp = this->mutateDeleteCommand(in, chg); |
---|
1358 | break; |
---|
1359 | case F8_INSERT_COMMANDS: |
---|
1360 | mutatedTmp = this->mutateInsertCommands(in, chg); |
---|
1361 | break; |
---|
1362 | case F8_ENCAPSULATE: |
---|
1363 | mutatedTmp = this->mutateEncapsulate(in, chg); |
---|
1364 | break; |
---|
1365 | case F8_CHANGE_CONDITION_SIGN: |
---|
1366 | mutatedTmp = this->mutateChangeConditionSign(in, chg); |
---|
1367 | break; |
---|
1368 | /*case F8_REPLACE_COMMAND: |
---|
1369 | mutatedTmp = this->mutateReplaceCommand(in, chg); |
---|
1370 | break;*/ |
---|
1371 | case F8_ADD_PARAMETER: |
---|
1372 | mutatedTmp = this->mutateAddParameter(in, chg); |
---|
1373 | break; |
---|
1374 | case F8_ADD_CONDITION: |
---|
1375 | mutatedTmp = this->mutateAddCondition(in, chg); |
---|
1376 | break; |
---|
1377 | case F8_ADD_SUBPRODUCTION: |
---|
1378 | mutatedTmp = this->mutateAddSubproduction(in, chg); |
---|
1379 | break; |
---|
1380 | case F8_CHANGE_ITERATIONS_NUMBER: |
---|
1381 | mutatedTmp = this->mutateChangeIterationsNumber(in, chg); |
---|
1382 | break; |
---|
1383 | case F8_DELETE_PARAMETER: |
---|
1384 | mutatedTmp = this->mutateDeleteParameter(in, chg); |
---|
1385 | break; |
---|
1386 | case F8_DELETE_CONDITION: |
---|
1387 | mutatedTmp = this->mutateDeleteCondition(in, chg); |
---|
1388 | break; |
---|
1389 | case F8_ADD_LOOP: |
---|
1390 | mutatedTmp = this->mutateAddLoop(in, chg); |
---|
1391 | break; |
---|
1392 | case F8_DELETE_LOOP: |
---|
1393 | mutatedTmp = this->mutateDeleteLoop(in, chg); |
---|
1394 | break; |
---|
1395 | default: |
---|
1396 | mutatedTmp = ""; |
---|
1397 | } |
---|
1398 | return mutatedTmp; |
---|
1399 | |
---|
1400 | } |
---|