// Selection Routines -----------------------------------------------
private CandidateSolution <T, S> TournamentSelectParent()
{
CandidateSolution <T, S> result = null;
float bestFitness = float.MaxValue;
if (IsLowerFitnessBetter == false)
{
bestFitness = float.MinValue;
}
for (int i = 0; i < TourneySize; i++)
{
int index = Randomizer.IntLessThan(PopulationSize);
var randomTree = currentGeneration[index];
var fitness = randomTree.Fitness;
bool isFitnessBetter = false;
if (IsLowerFitnessBetter)
{
isFitnessBetter = fitness < bestFitness;
}
else
{
isFitnessBetter = fitness > bestFitness;
}
if (isFitnessBetter)
{
result = randomTree;
bestFitness = fitness;
}
}
return(result);
}
internal TerminalNode <T, S> NewRandomTerminalNode()
{
int numConsts = primitiveSet.Constants.Count;
int numVars = primitiveSet.VariableNames.Count;
int numTerminalFunctions = primitiveSet.TerminalFunctions.Count;
int random = Randomizer.IntLessThan(numConsts + numVars + numTerminalFunctions);
// create a new constant node, simply passing the value
if (random < numConsts)
{
return(new ConstantNode <T, S>(primitiveSet.Constants[random]));
}
// create a new variable node, passing a reference to a GPVariable<T> object
int varIndex = random - numConsts;
if (varIndex < numVars)
{
var selectedVarName = primitiveSet.VariableNames[varIndex];
var newNode = new VariableNode <T, S>(selectedVarName, this);
return(newNode);
}
// terminal function node
int termFunctionIndex = random - (numVars + numConsts);
var selectedTerminalFunction = primitiveSet.TerminalFunctions.ToArray()[termFunctionIndex];
return(new TerminalFunctionNode <T, S>(selectedTerminalFunction, this)); // "this" is a reference to the candidate solution that owns the tree
}
internal FunctionNode <T, S> NewRandomFunctionNode()
{
// create a function node, leaving the Children unpopulated
int random = Randomizer.IntLessThan(primitiveSet.Functions.Count);
return(new FunctionNode <T, S>(primitiveSet.Functions[random], this));
}
internal NodeBaseType <T, S> AddRandomNode(NodeBaseType <T, S> parentNode, int levelsToCreate, bool buildFullTrees)
{
// we're either adding a terminal node (const or var), or a function node (which has children)
bool addingTerminal = false;
// if we're at the max depth, add a terminal node
if (levelsToCreate == 0)
{
addingTerminal = true;
}
else
if (levelsToCreate >= TreeMinDepth)
{
// make sure we're at least a certain depth
addingTerminal = false;
}
else
{
// we're somewhere between the min and max depth
if (buildFullTrees)
{
addingTerminal = false;
}
else
{
// pick a random type, either function or terminal
int numFuncs = primitiveSet.Functions.Count;
int numTerminalFuncs = primitiveSet.TerminalFunctions.Count;
int numVars = primitiveSet.VariableNames.Count;
int numConsts = primitiveSet.Constants.Count;
int random = Randomizer.IntLessThan(numFuncs + numTerminalFuncs + numVars + numConsts);
if (random < numFuncs)
{
addingTerminal = false;
}
else
{
addingTerminal = true;
}
}
}
// Now that we know whether to add a function or terminal node, go ahead and do it
if (addingTerminal)
{
var termNode = NewRandomTerminalNode();
termNode.Parent = parentNode;
return(termNode);
}
else
{
var funcNode = NewRandomFunctionNode();
funcNode.Parent = parentNode;
int numKids = funcNode.NumArguments;
for (int i = 0; i < numKids; i++)
{
// recursively create descendent nodes
funcNode.Children.Add(AddRandomNode(funcNode, levelsToCreate - 1, buildFullTrees));
}
return(funcNode);
}
}
