public override void evaluate(EvolutionState state,
Individual ind,
int subpopulation,
int threadnum)
{
try
{
this.state = state;
this.ind = ((GPIndividual)ind);
this.subpopulation = subpopulation;
this.threadnum = threadnum;
model.problem = this;
// Signal model to start simulation
model._signal.Set();
// Model plays out scene with individual and sets fitness
_signal.WaitOne();
Debug.Log("Fitness " + model.fitness + " Result " + model.result
+ " = " + this.ind.trees [0].child.makeCTree(true, true, true));
KozaFitness f = ((KozaFitness)ind.fitness);
f.setStandardizedFitness(state, model.fitness);
f.hits = 0;
ind.evaluated = true;
} catch (Exception e)
{
Debug.LogError(e.Message);
throw new Exception("Error while evaluating: ", e);
}
}
public override void eval(ec.EvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
Problem problem)
{
UnityProblem p = (UnityProblem)problem;
GameObject ball = p.model.ball.gameObject;
GameObject car = p.model.car.gameObject;
((RegressionData)input).x = Vector3.Distance(ball.transform.position, car.transform.position);
}
public override void Eval(IEvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
IProblem problem)
{
var rd = ((DoubleData)(input));
Children[0].Eval(state, thread, input, stack, individual, problem);
var result = rd.x;
Children[1].Eval(state, thread, input, stack, individual, problem);
rd.x = result * rd.x;
}
public void EvalPrint(
IEvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
IProblem problem,
int[][] map2)
{
// Evaluate children. Easy as cake.
((IEvalPrint)Children[0]).EvalPrint(state, thread, input, stack, individual, problem, map2);
((IEvalPrint)Children[1]).EvalPrint(state, thread, input, stack, individual, problem, map2);
((IEvalPrint)Children[2]).EvalPrint(state, thread, input, stack, individual, problem, map2);
((IEvalPrint)Children[3]).EvalPrint(state, thread, input, stack, individual, problem, map2);
}
public override void Eval(IEvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
IProblem problem)
{
// shortcutting OR
Children[0].Eval(state, thread, input, stack, individual, problem);
if (((ParityData)input).x == 0) // return the second item
{
Children[1].Eval(state, thread, input, stack, individual, problem);
}
// else return the first item (already there)
}
/**
* This is an ugly hack to simulate the "Sensible Initialization",
* First we create a GPIndividual, then reverse-map it to GEIndividuals,
* We do not need to call IntegerVectorSpecies.newIndividual() since it is overriden
* by the GPSpecies.newIndividual();
*
* Moreover, as in the case for non-identical representations (i,e, GP-GE island
* models etc,), the grammar rules, tree constraints, ERC's etc, are supposed to be
* identical across all islands, so we are using the same "gpspecies" inside this class.
*
* However, the identicality of the GPTree particulars like grammar, constraints, ADFs,
* ERC's may not be universally true.
*/
public override Individual NewIndividual(IEvolutionState state, int thread)
{
GEIndividual gei = null;
if (InitScheme != null && InitScheme.Equals("sensible"))
{
GPIndividual gpi = (GPIndividual)GPSpecies.NewIndividual(state, thread);
gei = ReverseMap(state, gpi, thread);
}
else
{
gei = (GEIndividual)base.NewIndividual(state, thread);
gei.Species = this;
}
return(gei);
}
public override void Eval(IEvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
IProblem problem)
{
var edge = ((EdgeData)(input)).edge;
var prob = (Edge)problem;
prob.Accept[prob.To[edge]] = true;
// pass the edge down
Children[0].Eval(state, thread, input, stack, individual, problem);
}
public override void Eval(IEvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
IProblem problem)
{
var rd = ((RegressionData)(input));
Children[0].Eval(state, thread, input, stack, individual, problem);
double result = rd.x;
// can't shortcut because of NaN or +-Infinity
Children[1].Eval(state, thread, input, stack, individual, problem);
rd.x = result * rd.x;
}
public override void Eval(IEvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
IProblem problem)
{
var rd = ((TwoBoxData)(input));
Children[0].Eval(state, thread, input, stack, individual, problem);
if (rd.x != 0) // safe to short-circuit
{
double result = rd.x;
Children[1].Eval(state, thread, input, stack, individual, problem);
rd.x = result * rd.x;
}
}
/// <summary>
/// Default version assumes that every individual is a GEIndividual.
/// The underlying problem.evaluate() must be prepared for the possibility that some
/// GPIndividuals handed it are in fact null, meaning that they couldn't be extracted
/// from the GEIndividual string. You should assign them bad fitness in some appropriate way.
/// </summary>
/// <param name="state">The current EvolutionState.</param>
/// <param name="ind">The individuals to evaluate together</param>
/// <param name="updateFitness">Should this individuals' fitness be updated?</param>
/// <param name="countVictoriesOnly">Don't bother updating Fitness with socres, just victories</param>
/// <param name="subpops">Subpopulations</param>
/// <param name="threadnum">Thread number</param>
public void Evaluate(IEvolutionState state,
Individual[] ind,
bool[] updateFitness,
bool countVictoriesOnly,
int[] subpops,
int threadnum)
{
// the default version assumes that every subpopulation is a GE Individual
var gpi = new GPIndividual[ind.Length];
for (var i = 0; i < gpi.Length; i++)
{
if (ind[i] is GEIndividual)
{
var indiv = (GEIndividual)ind[i];
var species = (GESpecies)ind[i].Species;
// warning: gpi[i] may be null
gpi[i] = species.Map(state, indiv, threadnum, null);
}
else if (ind[i] is GPIndividual)
{
state.Output.WarnOnce("GPIndividual provided to GEProblem. Hope that's correct.");
gpi[i] = (GPIndividual)ind[i];
}
else
{
state.Output.Fatal("Individual " + i +
" passed to Grouped evaluate(...) was neither a GP nor GE Individual: " +
ind[i]);
}
}
((IGroupedProblem)Problem).Evaluate(state, gpi, updateFitness, countVictoriesOnly, subpops, threadnum);
for (var i = 0; i < gpi.Length; i++)
{
// Now we need to move the evaluated flag from the GPIndividual
// to the GEIndividual, and also for good measure, let's copy over
// the GPIndividual's fitness because even though the mapping function
// set the two Individuals to share the same fitness, it's possible
// that the evaluation function may have replaced the fitness.
ind[i].Fitness = gpi[i].Fitness; // if it's a GPIndividual anyway it'll just copy onto itself
ind[i].Evaluated = gpi[i].Evaluated; // if it's a GPIndividual anyway it'll just copy onto itself
}
}
public virtual GPNode PickNode(IEvolutionState s, int subpop, int thread, GPIndividual ind, GPTree tree)
{
var rnd = s.Random[thread].NextDouble();
if (rnd > NonterminalProbability + TerminalProbability + RootProbability)
// pick anyone
{
if (Nodes == -1)
{
Nodes = tree.Child.NumNodes(GPNode.NODESEARCH_ALL);
}
{
return(tree.Child.NodeInPosition(s.Random[thread].NextInt(Nodes), GPNode.NODESEARCH_ALL));
}
}
if (rnd > NonterminalProbability + TerminalProbability)
// pick the root
{
return(tree.Child);
}
if (rnd > NonterminalProbability)
// pick terminals
{
if (Terminals == -1)
{
Terminals = tree.Child.NumNodes(GPNode.NODESEARCH_TERMINALS);
}
return(tree.Child.NodeInPosition(s.Random[thread].NextInt(Terminals), GPNode.NODESEARCH_TERMINALS));
}
// pick nonterminals if you can
if (Nonterminals == -1)
{
Nonterminals = tree.Child.NumNodes(GPNode.NODESEARCH_NONTERMINALS);
}
if (Nonterminals > 0)
// there are some nonterminals
{
return(tree.Child.NodeInPosition(s.Random[thread].NextInt(Nonterminals), GPNode.NODESEARCH_NONTERMINALS));
}
// there ARE no nonterminals! It must be the root node
return(tree.Child);
}
public override void Eval(IEvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
IProblem problem)
{
Children[0].Eval(state, thread, input, stack, individual, problem);
if (((MultiplexerData)input).x == 1) // return the second item
{
Children[1].Eval(state, thread, input, stack, individual, problem);
}
else // return the third item.
{
Children[2].Eval(state, thread, input, stack, individual, problem);
}
}
public override void Eval(IEvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
IProblem problem)
{
var md = (MultiplexerData)input;
if (md.Status == MultiplexerData.STATUS_3)
md.Dat3 = Fast.M_3[bitpos + MultiplexerData.STATUS_3];
else if (md.Status == MultiplexerData.STATUS_6)
md.Dat6 = Fast.M_6[bitpos + MultiplexerData.STATUS_6];
else // md.status == MultiplexerData.STATUS_11
Array.Copy(Fast.M_11[bitpos + MultiplexerData.STATUS_11], 0,
md.Dat11, 0,
MultiplexerData.MULTI_11_NUM_BITSTRINGS);
}
public override void Eval(IEvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
IProblem problem)
{
Children[0].Eval(state, thread, input, stack, individual, problem);
var md = (MajorityData)input;
long y0 = md.Data0;
long y1 = md.Data1;
Children[1].Eval(state, thread, input, stack, individual, problem);
md.Data0 = md.Data0 & y0;
md.Data1 = md.Data1 & y1;
}
public override void Eval(IEvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
IProblem problem)
{
var rd = ((RegressionData)(input));
double[] c = ((Benchmarks)problem).currentValue;
if (c.Length >= 4)
{
rd.x = ((Benchmarks)problem).currentValue[3];
}
else
{
rd.x = 0;
}
}
public override void Eval(IEvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
IProblem problem)
{
int resultx;
int resulty;
var rd = ((LawnmowerData)(input));
Children[0].Eval(state, thread, input, stack, individual, problem);
resultx = rd.x;
resulty = rd.y;
Children[1].Eval(state, thread, input, stack, individual, problem);
rd.x = (resultx + rd.x) % MODULO;
rd.y = (resulty + rd.y) % MODULO;
}
public override void Eval(IEvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
IProblem problem)
{
var d = ((ParityData)input);
// shortcutting NAND
Children[0].Eval(state, thread, input, stack, individual, problem);
if (d.x == 1) // return the second item
{
Children[1].Eval(state, thread, input, stack, individual, problem);
}
// invert
d.x ^= 1;
}
public override void Eval(IEvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
IProblem problem)
{
var edge = ((EdgeData)(input)).edge;
var prob = (Edge)problem;
if (prob.From.Length == prob.NumEdges) // we're full, need to expand
{
var from_ = new int[prob.NumEdges * 2];
var to_ = new int[prob.NumEdges * 2];
var reading_ = new int[prob.NumEdges * 2];
Array.Copy(prob.From, 0, from_, 0, prob.From.Length);
Array.Copy(prob.To, 0, to_, 0, prob.To.Length);
Array.Copy(prob.Reading, 0, reading_, 0, prob.Reading.Length);
prob.From = from_;
prob.To = to_;
prob.Reading = reading_;
}
var newedge = prob.NumEdges;
prob.NumEdges++;
prob.From[newedge] = prob.To[edge];
prob.To[newedge] = prob.To[edge]; // same
prob.Reading[newedge] = prob.Reading[edge];
// pass the original edge down the left child
Children[0].Eval(state, thread, input, stack, individual, problem);
// reset input for right child
((EdgeData)(input)).edge = newedge;
// pass the new edge down the right child
Children[1].Eval(state, thread, input, stack, individual, problem);
}
/**
* Reverse of the original map() function, takes a GPIndividual and returns
* a corresponding GEIndividual; The GPIndividual may contain more than one trees,
* and such cases are handled accordingly, see the 3rd bullet below --
*
* NOTE:
* This reverse mapping is only valid for S-expression trees ;
*
* This procedure supports ERC for the current population (not for population
* /subpopulation from other islands); However, that could be done by merging
* all ERCBanks from all the sub-populations but that is not done yet ;
*
* Support for the ADF's are done as follows -- suppose in one GPIndividual,
* there are N trees -- T1, T2, ,,, Tn and each of them follows n different
* grammars G1, G2, ,,, Gn respectively; now if they are reverse-mapped to
* int arrays, there will be n int arrays A1[], A2[], ,,, An[]; and suppose
* the i-th tree Ti is reverse mapped to int array Ai[] and morevoer Ai[] is
* the longest among all the arrays (Bj[]s); so Bi[] is sufficient to build
* all ADF trees Tjs.
*/
public GEIndividual ReverseMap(IEvolutionState state, GPIndividual ind, int threadnum)
{
// create a dummy individual
GEIndividual newind = (GEIndividual)I_Prototype.Clone();
// The longest int will be able to contain all ADF trees.
int longestIntLength = -1;
int[] longestInt = null;
// Now go through all the ADF trees.
for (int treeIndex = 0; treeIndex < ind.Trees.Length; treeIndex++)
{
// Flatten the Lisp tree
ArrayList flatSexp = (ArrayList)FlattenSexp(state, threadnum,
ind.Trees[treeIndex]);
// Now convert the flatten list into an array of ints
// no. of trees == no. of grammars
int[] genomeVals = ParseSexp(flatSexp, GrammarParser[treeIndex]);
// store the longest int array
if (genomeVals.Length >= longestIntLength)
{
longestIntLength = genomeVals.Length;
longestInt = new int[genomeVals.Length];
Array.Copy(genomeVals, 0, longestInt, 0, genomeVals.Length);
}
genomeVals = null;
}
// assign the longest int to the individual's genome
newind.genome = longestInt;
// update the GPIndividual's fitness information
newind.Fitness = ind.Fitness;
newind.Evaluated = false;
// Set the species to me ? not sure.
newind.Species = this;
// return it
return(newind);
}
public override void Eval(IEvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
IProblem problem)
{
var p = (Lawnmower)problem;
var d = (LawnmowerData)input;
switch (p.Orientation)
{
case Lawnmower.O_UP:
p.Orientation = Lawnmower.O_LEFT;
break;
case Lawnmower.O_LEFT:
p.Orientation = Lawnmower.O_DOWN;
break;
case Lawnmower.O_DOWN:
p.Orientation = Lawnmower.O_RIGHT;
break;
case Lawnmower.O_RIGHT:
p.Orientation = Lawnmower.O_UP;
break;
default: // whoa!
state.Output.Fatal("Whoa, somehow I got a bad orientation! (" + p.Orientation + ")");
break;
}
//p.moves++;
// return [0,0]
d.x = 0;
d.y = 0;
}
public override void Eval(IEvolutionState state,
int thread,
GPData input,
ADFStack stack,
GPIndividual individual,
IProblem problem)
{
var rd = ((TwoBoxData)(input));
// evaluate children[1] first to determine if the demoniator is 0
Children[1].Eval(state, thread, input, stack, individual, problem);
if (rd.x == 0.0)
{
// the answer is 1.0 since the denominator was 0.0
rd.x = 1.0;
}
else
{
double result = rd.x;
Children[0].Eval(state, thread, input, stack, individual, problem);
rd.x = rd.x / result;
}
}
/// <summary>
/// Just like eval, but it retraces the map and prints out info.
/// </summary>
public void EvalPrint(IEvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, IProblem problem, int[][] map2)
{
var p = (Ant)problem;
switch (p.Orientation)
{
case Ant.O_UP:
p.PosY--;
if (p.PosY < 0)
{
p.PosY = p.MaxY - 1;
}
break;
case Ant.O_LEFT:
p.PosX--;
if (p.PosX < 0)
{
p.PosX = p.MaxX - 1;
}
break;
case Ant.O_DOWN:
p.PosY++;
if (p.PosY >= p.MaxY)
{
p.PosY = 0;
}
break;
case Ant.O_RIGHT:
p.PosX++;
if (p.PosX >= p.MaxX)
{
p.PosX = 0;
}
break;
default: // whoa!
state.Output.Fatal("Whoa, somehow I got a bad orientation! (" + p.Orientation + ")");
break;
}
p.Moves++;
if (p.Map[p.PosX][p.PosY] == Ant.FOOD && p.Moves < p.MaxMoves)
{
p.Sum++;
p.Map[p.PosX][p.PosY] = Ant.ATE;
}
if (p.Moves < p.MaxMoves)
{
if (++p.PMod > 122 /* ascii z */)
{
p.PMod = 97; /* ascii a */
}
map2[p.PosX][p.PosY] = p.PMod;
}
}
public override void Eval(IEvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, IProblem problem)
{
var p = (FeatureExtractionProblem2)problem;
Children[0].Eval(state, thread, input, stack, individual, problem);
p.imageTransformer.TransformImage(p.currentImage[thread], Image.ImageTransformer.TransformationType.GAUSSIAN3);
p.imageTransformer.TransformImage(p.currentImage[thread], Image.ImageTransformer.TransformationType.GAUSSIAN5);
}
public override void Eval(IEvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, IProblem problem)
{
ClassificationData data = (ClassificationData)input;
Children[0].Eval(state, thread, input, stack, individual, problem);
if (data.boolVal)
{
Children[1].Eval(state, thread, input, stack, individual, problem);
}
else
{
Children[2].Eval(state, thread, input, stack, individual, problem);
}
}
public override void Eval(IEvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, IProblem problem)
{
ClassificationData result = (ClassificationData)input;
result.boolVal = false;
}
public override void Eval(IEvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, IProblem problem)
{
var p = (FeatureExtractionProblem)problem;
Children[0].Eval(state, thread, input, stack, individual, problem);
p.currentImage[thread] = p.currentImage[thread].Not();
}
public override void Eval(IEvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, IProblem problem)
{
var p = (FeatureExtractionProblem2)problem;
var c0 = p.currentImage[thread].Copy();
Children[0].Eval(state, thread, input, stack, individual, problem);
var c1 = p.currentImage[thread].Copy();
c0.CopyTo(p.currentImage[thread]);
Children[1].Eval(state, thread, input, stack, individual, problem);
p.currentImage[thread] = p.currentImage[thread].Mul(c1);
}
public override int Produce(
int min,
int max,
int subpop,
IList <Individual> inds,
IEvolutionState state,
int thread,
IDictionary <string, object> misc)
{
int start = inds.Count;
// how many individuals should we make?
int n = TypicalIndsProduced;
if (n < min)
{
n = min;
}
if (n > max)
{
n = max;
}
// should we bother?
if (!state.Random[thread].NextBoolean(Likelihood))
{
// just load from source 0 and clone 'em
Sources[0].Produce(n, n, subpop, inds, state, thread, misc);
return(n);
}
IntBag[] parentparents = null;
IntBag[] preserveParents = null;
if (misc != null && misc.ContainsKey(KEY_PARENTS))
{
preserveParents = (IntBag[])misc[KEY_PARENTS];
parentparents = new IntBag[2];
misc[KEY_PARENTS] = parentparents;
}
GPInitializer initializer = (GPInitializer)state.Initializer;
for (int q = start; q < n + start; /* no increment */) // keep on going until we're filled up
{
Parents.Clear();
// grab two individuals from our sources
if (Sources[0] == Sources[1]) // grab from the same source
{
Sources[0].Produce(2, 2, subpop, Parents, state, thread, misc);
}
else // grab from different sources
{
Sources[0].Produce(1, 1, subpop, Parents, state, thread, misc);
Sources[1].Produce(1, 1, subpop, Parents, state, thread, misc);
}
// at this point, Parents[] contains our two selected individuals
// are our tree values valid?
if (Tree1 != TREE_UNFIXED && (Tree1 < 0 || Tree1 >= ((GPIndividual)Parents[0]).Trees.Length))
{
// uh oh
state.Output.Fatal(
"GP Crossover Pipeline attempted to fix tree.0 to a value which was out of bounds of the array of the individual's trees. Check the pipeline's fixed tree values -- they may be negative or greater than the number of trees in an individual");
}
if (Tree2 != TREE_UNFIXED && (Tree2 < 0 || Tree2 >= ((GPIndividual)Parents[1]).Trees.Length))
{
// uh oh
state.Output.Fatal(
"GP Crossover Pipeline attempted to fix tree.1 to a value which was out of bounds of the array of the individual's trees. Check the pipeline's fixed tree values -- they may be negative or greater than the number of trees in an individual");
}
int t1;
int t2;
if (Tree1 == TREE_UNFIXED || Tree2 == TREE_UNFIXED)
{
do
// pick random trees -- their GPTreeConstraints must be the same
{
if (Tree1 == TREE_UNFIXED)
{
if (((GPIndividual)Parents[0]).Trees.Length > 1)
{
t1 = state.Random[thread].NextInt(((GPIndividual)Parents[0]).Trees.Length);
}
else
{
t1 = 0;
}
}
else
{
t1 = Tree1;
}
if (Tree2 == TREE_UNFIXED)
{
if (((GPIndividual)Parents[1]).Trees.Length > 1)
{
t2 = state.Random[thread].NextInt(((GPIndividual)Parents[1]).Trees.Length);
}
else
{
t2 = 0;
}
}
else
{
t2 = Tree2;
}
} while (((GPIndividual)Parents[0]).Trees[t1].Constraints(initializer) !=
((GPIndividual)Parents[1]).Trees[t2].Constraints(initializer));
}
else
{
t1 = Tree1;
t2 = Tree2;
// make sure the constraints are okay
if (((GPIndividual)Parents[0]).Trees[t1].Constraints(initializer) !=
((GPIndividual)Parents[1]).Trees[t2].Constraints(initializer)) // uh oh
{
state.Output.Fatal(
"GP Crossover Pipeline's two tree choices are both specified by the user -- but their GPTreeConstraints are not the same");
}
}
bool res1 = false;
bool res2 = false;
// BRS: This is kind of stupid to name it this way!
GPTree currTree = ((GPIndividual)Parents[1]).Trees[t2];
// pick some nodes
GPNode p1 = null;
GPNode p2 = null;
// lets walk on parent2 all nodes to get subtrees for each node, doing it once for O(N) and not O(N^2)
// because depth etc are computed and not stored
ArrayList nodeToSubtrees = new ArrayList();
// also Hashtable for size to List() of nodes in that size for O(1) lookup
Hashtable sizeToNodes = new Hashtable();
TraverseTreeForDepth(currTree.Child, nodeToSubtrees, sizeToNodes);
// sort the ArrayList with comparator that sorts by subtrees
nodeToSubtrees.Sort(new NodeComparator());
for (int x = 0; x < NumTries; x++)
{
// pick a node in individual 1
p1 = NodeSelect1.PickNode(state, subpop, thread, (GPIndividual)Parents[0], ((GPIndividual)Parents[0]).Trees[t1]);
// now lets find "similar" in parent 2
p2 = FindFairSizeNode(nodeToSubtrees, sizeToNodes, p1, currTree, state, thread);
// check for depth and swap-compatibility limits
res1 = VerifyPoints(initializer, p2, p1); // p2 can fill p1's spot -- order is important!
if (n - (q - start) < 2 || TossSecondParent)
{
res2 = true;
}
else
{
res2 = VerifyPoints(initializer, p1, p2); // p1 can fill p2's spot -- order is important!
}
// did we get something that had both nodes verified?
// we reject if EITHER of them is invalid. This is what lil-gp
// does.
// Koza only has numTries set to 1, so it's compatible as well.
if (res1 && res2)
{
break;
}
}
// at this point, res1 AND res2 are valid, OR
// either res1 OR res2 is valid and we ran out of tries, OR
// neither res1 nor res2 is valid and we rand out of tries.
// So now we will transfer to a tree which has res1 or res2
// valid, otherwise it'll just get replicated. This is
// compatible with both Koza and lil-gp.
// at this point I could check to see if my sources were breeding
// pipelines -- but I'm too lazy to write that code (it's a little
// complicated) to just swap one individual over or both over,
// -- it might still entail some copying. Perhaps in the future.
// It would make things faster perhaps, not requiring all that
// cloning.
// Create some new individuals based on the old ones -- since
// GPTree doesn't deep-clone, this should be just fine. Perhaps we
// should change this to proto off of the main species prototype,
// but
// we have to then copy so much stuff over; it's not worth it.
GPIndividual j1 = ((GPIndividual)Parents[0]).LightClone();
GPIndividual j2 = null;
if (n - (q - start) >= 2 && !TossSecondParent)
{
j2 = ((GPIndividual)Parents[1]).LightClone();
}
// Fill in various tree information that didn't get filled in there
j1.Trees = new GPTree[((GPIndividual)Parents[0]).Trees.Length];
if (n - (q - start) >= 2 && !TossSecondParent)
{
j2.Trees = new GPTree[((GPIndividual)Parents[1]).Trees.Length];
}
// at this point, p1 or p2, or both, may be null.
// If not, swap one in. Else just copy the parent.
for (int x = 0; x < j1.Trees.Length; x++)
{
if (x == t1 && res1) // we've got a tree with a kicking cross
// position!
{
j1.Trees[x] = ((GPIndividual)Parents[0]).Trees[x].LightClone();
j1.Trees[x].Owner = j1;
j1.Trees[x].Child = ((GPIndividual)Parents[0]).Trees[x].Child.CloneReplacing(p2, p1);
j1.Trees[x].Child.Parent = j1.Trees[x];
j1.Trees[x].Child.ArgPosition = 0;
j1.Evaluated = false;
} // it's changed
else
{
j1.Trees[x] = ((GPIndividual)Parents[0]).Trees[x].LightClone();
j1.Trees[x].Owner = j1;
j1.Trees[x].Child = (GPNode)((GPIndividual)Parents[0]).Trees[x].Child.Clone();
j1.Trees[x].Child.Parent = j1.Trees[x];
j1.Trees[x].Child.ArgPosition = 0;
}
}
if (n - (q - start) >= 2 && !TossSecondParent)
{
for (int x = 0; x < j2.Trees.Length; x++)
{
if (x == t2 && res2) // we've got a tree with a kicking
// cross position!
{
j2.Trees[x] = ((GPIndividual)Parents[1]).Trees[x].LightClone();
j2.Trees[x].Owner = j2;
j2.Trees[x].Child = ((GPIndividual)Parents[1]).Trees[x].Child.CloneReplacing(p1, p2);
j2.Trees[x].Child.Parent = j2.Trees[x];
j2.Trees[x].Child.ArgPosition = 0;
j2.Evaluated = false;
} // it's changed
else
{
j2.Trees[x] = ((GPIndividual)Parents[1]).Trees[x].LightClone();
j2.Trees[x].Owner = j2;
j2.Trees[x].Child = (GPNode)((GPIndividual)Parents[1]).Trees[x].Child.Clone();
j2.Trees[x].Child.Parent = j2.Trees[x];
j2.Trees[x].Child.ArgPosition = 0;
}
}
}
// add the individuals to the population
// by Ermo. I think this should be add
// inds.set(q,j1);
// Yes -- Sean
inds.Add(j1);
if (preserveParents != null)
{
parentparents[0].AddAll(parentparents[1]);
preserveParents[q] = parentparents[0];
}
q++;
if (q < n + start && !TossSecondParent)
{
// by Ermo. Same reason, should changed to add
//inds[q] = j2;
inds.Add(j2);
if (preserveParents != null)
{
preserveParents[q] = parentparents[0];
}
q++;
}
}
return(n);
}
public override void Eval(IEvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, IProblem problem)
{
ClassificationData result = (ClassificationData)input;
result.stringVal = "Iris-setosa";
}
public override void Eval(IEvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, IProblem problem)
{
var p = (FeatureExtractionProblem2)problem;
Children[0].Eval(state, thread, input, stack, individual, problem);
Children[1].Eval(state, thread, input, stack, individual, problem);
int r1 = ((ProblemData)input).range + 60;
Children[2].Eval(state, thread, input, stack, individual, problem);
int r2 = ((ProblemData)input).range + 160;
for (int w = 0; w < 64; w++)
{
for (int h = 0; h < 64; h++)
{
if (p.currentImage[thread][w, h].Intensity <r1 || p.currentImage[thread][w, h].Intensity> r2)
{
p.currentImage[thread][w, h] = new Gray(0);
}
}
}
}
public override void Eval(IEvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, IProblem problem)
{
var p = (FeatureExtractionProblem2)problem;
Children[0].Eval(state, thread, input, stack, individual, problem);
p.currentImage[thread] = p.imageTransformer.RotateViaCenter(p.currentImage[thread], 20);
}
public override void Eval(IEvolutionState state, int thread, GPData input, ADFStack stack, GPIndividual individual, IProblem problem)
{
var cProblem = (MultiClassifierProblem)problem;
((ClassificationData)input).doubleVal = cProblem.CurrentParam[paramIndex];
((ClassificationData)input).index = (int)paramIndex;
}
