public TGPOperator FindRandomOperator(TGPOperator current_operator = null)
{
for (int attempts = 0; attempts < 10; attempts++)
{
double r = mWeightSum * DistributionModel.GetUniform();
double current_sum = 0;
foreach (KeyValuePair <TGPOperator, double> point in mOperators)
{
current_sum += point.Value;
if (current_sum >= r)
{
if (point.Key != current_operator)
{
return(point.Key);
}
else
{
break;
}
}
}
}
return(current_operator);
}
public TGPOperator FindRandomOperator(int parameter_count, TGPOperator current_operator = null)
{
TGPOperator selected_op = null;
for (int attempts = 0; attempts < 10; attempts++)
{
double r = mWeightSum * DistributionModel.GetUniform();
double current_sum = 0;
foreach (KeyValuePair <TGPOperator, double> point in mOperators)
{
if (selected_op == null && point.Key.Arity == parameter_count && point.Key != current_operator)
{
selected_op = point.Key;
}
current_sum += point.Value;
if (current_sum >= r)
{
if (point.Key != current_operator && point.Key.Arity == parameter_count)
{
return(point.Key);
}
else
{
break;
}
}
}
}
return(selected_op);
}
/// <summary>
/// Method that implements the "Point Mutation" described in Section 2.4 of "A Field Guide to Genetic Programming"
/// In Section 5.2.2 of "A Field Guide to Genetic Programming", this is also described as node replacement mutation
/// </summary>
public virtual void MicroMutate()
{
TGPNode node = FindRandomNode();
if (node.IsTerminal)
{
TGPTerminal terminal = FindRandomTerminal();
int trials = 0;
int max_trials = 50;
while (node.Primitive == terminal)
{
terminal = FindRandomTerminal();
trials++;
if (trials > max_trials)
{
break;
}
}
if (terminal != null)
{
node.Primitive = terminal;
}
}
else
{
int parameter_count = node.Arity;
TGPOperator op = mOperatorSet.FindRandomOperator(parameter_count, (TGPOperator)node.Primitive);
if (op != null)
{
node.Primitive = op;
}
}
}
/// <summary>
/// Method that creates a GP tree with a maximum tree depth
/// </summary>
/// <param name="allowableDepth">The maximum tree depth</param>
/// <param name="method">The name of the method used to create the GP tree</param>
/// <param name="tag">The additional information used to create the GP tree if any</param>
public void CreateWithDepth(int allowableDepth, string method, object tag = null)
{
// Population Initialization method following the "RandomBranch" method described in "Kumar Chellapilla. Evolving computer programs without subtree crossover. IEEE Transactions on Evolutionary Computation, 1(3):209–216, September 1997."
if (method == INITIALIZATION_METHOD_RANDOMBRANCH)
{
int s = allowableDepth; //tree size
TGPOperator non_terminal = FindRandomOperatorWithArityLessThan(s);
if (non_terminal == null)
{
mRootNode = new TGPNode(FindRandomTerminal());
}
else
{
mRootNode = new TGPNode(non_terminal);
int b_n = non_terminal.Arity;
s = (int)System.Math.Floor((double)s / b_n);
RandomBranch(mRootNode, s);
}
CalcLength();
CalcDepth();
}
// Population Initialization method following the "PTC1" method described in "Sean Luke. Two fast tree-creation algorithms for genetic programming. IEEE Transactions in Evolutionary Computation, 4(3), 2000b."
else if (method == INITIALIZATION_METHOD_PTC1)
{
int expectedTreeSize = Convert.ToInt32(tag);
int b_n_sum = 0;
for (int i = 0; i < mOperatorSet.OperatorCount; ++i)
{
b_n_sum += mOperatorSet.FindOperatorByIndex(i).Arity;
}
double p = (1 - 1.0 / expectedTreeSize) / ((double)b_n_sum / mOperatorSet.OperatorCount);
TGPPrimitive data = null;
if (DistributionModel.GetUniform() <= p)
{
data = mOperatorSet.FindRandomOperator();
}
else
{
data = FindRandomTerminal();
}
mRootNode = new TGPNode(data);
PTC1(mRootNode, p, allowableDepth - 1);
CalcLength();
CalcDepth();
}
else // handle full and grow method
{
mRootNode = new TGPNode(FindRandomPrimitive(allowableDepth, method));
CreateWithDepth(mRootNode, allowableDepth - 1, method);
CalcLength();
CalcDepth();
}
}
/// <summary>
/// Method that is used by the "RandomBranch" initialization algorithm to obtain a random function node with arity less than s
/// </summary>
/// <param name="s">The tree size</param>
/// <returns></returns>
private TGPOperator FindRandomOperatorWithArityLessThan(int s)
{
List <TGPOperator> ops = new List <TGPOperator>();
for (int i = 0; i < mOperatorSet.OperatorCount; ++i)
{
TGPOperator op1 = mOperatorSet.FindOperatorByIndex(i);
if (op1.Arity < s)
{
ops.Add(op1);
}
}
if (ops.Count == 0)
{
return(null);
}
return(ops[DistributionModel.NextInt(ops.Count)]);
}
/// <summary>
/// Population Initialization Method described in "Kumar Chellapilla. Evolving computer programs without subtree crossover. IEEE Transactions on Evolutionary Computation, 1(3):209–216, September 1997."
/// </summary>
/// <param name="parent_node"></param>
/// <param name="s"></param>
/// <param name="?"></param>
private void RandomBranch(TGPNode parent_node, int s)
{
int child_count = parent_node.Arity;
for (int i = 0; i != child_count; i++)
{
TGPOperator non_terminal = FindRandomOperatorWithArityLessThan(s);
if (non_terminal == null)
{
TGPNode child = parent_node.CreateChild(FindRandomTerminal());
}
else
{
TGPNode child = parent_node.CreateChild(non_terminal);
int b_n = non_terminal.Arity;
int s_pi = (int)System.Math.Floor((double)s / b_n);
RandomBranch(child, s_pi);
}
}
}
public void AddOperator(TGPOperator op, double weight = 1)
{
mOperators.Add(new KeyValuePair <TGPOperator, double>(op, weight));
op.mOperatorIndex = mOperators.Count - 1;
mWeightSum += weight;
}
