public static bool CreateNewArgument(
IRandom random,
ISymbolicExpressionTree symbolicExpressionTree,
int maxTreeLength, int maxTreeDepth,
int maxFunctionDefinitions, int maxFunctionArguments)
{
// work on a copy in case we find out later that the tree would be too big
// in this case it's easiest to simply return the original tree.
ISymbolicExpressionTree clonedTree = (ISymbolicExpressionTree)symbolicExpressionTree.Clone();
var functionDefiningBranches = clonedTree.IterateNodesPrefix().OfType <DefunTreeNode>().ToList();
if (!functionDefiningBranches.Any())
{
// no function defining branch found => abort
return(false);
}
// select a random function defining branch
var selectedDefunBranch = functionDefiningBranches.SampleRandom(random);
var definedArguments = (from symbol in selectedDefunBranch.Grammar.Symbols.OfType <Argument>()
select symbol.ArgumentIndex).Distinct();
if (definedArguments.Count() >= maxFunctionArguments)
{
// max number of arguments reached => abort
return(false);
}
var allowedArgumentIndexes = Enumerable.Range(0, maxFunctionArguments);
var newArgumentIndex = allowedArgumentIndexes.Except(definedArguments).First();
ArgumentTreeNode newArgumentNode = MakeArgumentNode(newArgumentIndex);
// this operation potentially creates very big trees so the access to the length property might throw overflow exception
try {
if (CreateNewArgumentForDefun(random, clonedTree, selectedDefunBranch, newArgumentNode) && clonedTree.Length <= maxTreeLength && clonedTree.Depth <= maxTreeDepth)
{
// size constraints are fulfilled
// replace root of original tree with root of manipulated tree
symbolicExpressionTree.Root = clonedTree.Root;
return(true);
}
else
{
// keep originalTree
return(false);
}
}
catch (OverflowException) {
// keep original tree
return(false);
}
}
private static ISymbolicExpressionTreeNode ReplaceArgumentsInBranch(ISymbolicExpressionTreeNode branch, IEnumerable <ISymbolicExpressionTreeNode> argumentTrees)
{
ArgumentTreeNode argNode = branch as ArgumentTreeNode;
if (argNode != null)
{
// replace argument nodes by a clone of the original subtree that provided the result for the argument node
return((SymbolicExpressionTreeNode)argumentTrees.ElementAt(argNode.Symbol.ArgumentIndex).Clone());
}
else
{
// call recursively for all subtree
List <ISymbolicExpressionTreeNode> subtrees = new List <ISymbolicExpressionTreeNode>(branch.Subtrees);
while (branch.Subtrees.Count() > 0)
{
branch.RemoveSubtree(0);
}
foreach (var subtree in subtrees)
{
branch.AddSubtree(ReplaceArgumentsInBranch(subtree, argumentTrees));
}
return(branch);
}
}
private ArgumentTreeNode(ArgumentTreeNode original, Cloner cloner) : base(original, cloner) { }
private ArgumentTreeNode(ArgumentTreeNode original, Cloner cloner) : base(original, cloner)
{
}
private static bool CreateNewArgumentForDefun(IRandom random, ISymbolicExpressionTree tree, DefunTreeNode defunBranch, ArgumentTreeNode newArgumentNode)
{
// select a random cut point in the function defining branch
// the branch at the cut point is to be replaced by a new argument node
var cutPoints = (from node in defunBranch.IterateNodesPrefix()
where node.Subtrees.Count() > 0 &&
!node.IterateNodesPrefix().OfType <ArgumentTreeNode>().Any() &&
!node.IterateNodesPrefix().OfType <InvokeFunctionTreeNode>().Any()
from subtree in node.Subtrees
select new CutPoint(node, subtree)).ToList();
if (cutPoints.Count() == 0)
{
// no cut point found => abort;
return(false);
}
var selectedCutPoint = cutPoints[random.Next(cutPoints.Count)];
// replace the branch at the cut point with an argument node
var replacedBranch = selectedCutPoint.Child;
selectedCutPoint.Parent.RemoveSubtree(selectedCutPoint.ChildIndex);
selectedCutPoint.Parent.InsertSubtree(selectedCutPoint.ChildIndex, newArgumentNode);
// find all old invocations of the selected ADF and attach a cloned version of the replaced branch (with all argument-nodes expanded)
// iterate in post-fix order to make sure that the subtrees of n are already adapted when n is processed
var invocationNodes = (from node in tree.IterateNodesPostfix().OfType <InvokeFunctionTreeNode>()
where node.Symbol.FunctionName == defunBranch.FunctionName
where node.Subtrees.Count() == defunBranch.NumberOfArguments
select node).ToList();
// do this repeatedly until no matching invocations are found
while (invocationNodes.Count > 0)
{
List <ISymbolicExpressionTreeNode> newlyAddedBranches = new List <ISymbolicExpressionTreeNode>();
foreach (var invocationNode in invocationNodes)
{
// check that the invocation node really has the correct number of arguments
if (invocationNode.Subtrees.Count() != defunBranch.NumberOfArguments)
{
throw new InvalidOperationException();
}
// append a new argument branch after expanding all argument nodes
var clonedBranch = (ISymbolicExpressionTreeNode)replacedBranch.Clone();
clonedBranch = ReplaceArgumentsInBranch(clonedBranch, invocationNode.Subtrees);
invocationNode.InsertSubtree(newArgumentNode.Symbol.ArgumentIndex, clonedBranch);
newlyAddedBranches.Add(clonedBranch);
}
// iterate in post-fix order to make sure that the subtrees of n are already adapted when n is processed
invocationNodes = (from newlyAddedBranch in newlyAddedBranches
from node in newlyAddedBranch.IterateNodesPostfix().OfType <InvokeFunctionTreeNode>()
where node.Symbol.FunctionName == defunBranch.FunctionName
where node.Subtrees.Count() == defunBranch.NumberOfArguments
select node).ToList();
}
// increase expected number of arguments of function defining branch
// it's possible that the number of actually referenced arguments was reduced (all references were replaced by a single new argument)
// but the number of expected arguments is increased anyway
defunBranch.NumberOfArguments++;
defunBranch.Grammar.AddSymbol(newArgumentNode.Symbol);
defunBranch.Grammar.SetSubtreeCount(newArgumentNode.Symbol, 0, 0);
// allow the argument as child of any other symbol
GrammarModifier.SetAllowedParentSymbols(defunBranch.Grammar, selectedCutPoint.Child.Symbol, newArgumentNode.Symbol);
foreach (var subtree in tree.Root.Subtrees)
{
// when the changed function is known in the branch then update the number of arguments
var matchingSymbol = subtree.Grammar.Symbols.OfType <InvokeFunction>().Where(s => s.FunctionName == defunBranch.FunctionName).SingleOrDefault();
if (matchingSymbol != null)
{
subtree.Grammar.SetSubtreeCount(matchingSymbol, defunBranch.NumberOfArguments, defunBranch.NumberOfArguments);
foreach (var symb in subtree.Grammar.Symbols)
{
if (symb is StartSymbol || symb is ProgramRootSymbol)
{
continue;
}
if (symb.Name == matchingSymbol.Name)
{
continue; //don't allow invoke as child of invoke
}
if (subtree.Grammar.IsAllowedChildSymbol(selectedCutPoint.Parent.Symbol, symb, selectedCutPoint.ChildIndex))
{
subtree.Grammar.AddAllowedChildSymbol(matchingSymbol, symb, newArgumentNode.Symbol.ArgumentIndex);
}
}
}
}
return(true);
}
private static bool CreateNewArgumentForDefun(IRandom random, ISymbolicExpressionTree tree, DefunTreeNode defunBranch, ArgumentTreeNode newArgumentNode) {
// select a random cut point in the function defining branch
// the branch at the cut point is to be replaced by a new argument node
var cutPoints = (from node in defunBranch.IterateNodesPrefix()
where node.Subtrees.Count() > 0 &&
!node.IterateNodesPrefix().OfType<ArgumentTreeNode>().Any() &&
!node.IterateNodesPrefix().OfType<InvokeFunctionTreeNode>().Any()
from subtree in node.Subtrees
select new CutPoint(node, subtree)).ToList();
if (cutPoints.Count() == 0)
// no cut point found => abort;
return false;
var selectedCutPoint = cutPoints[random.Next(cutPoints.Count)];
// replace the branch at the cut point with an argument node
var replacedBranch = selectedCutPoint.Child;
selectedCutPoint.Parent.RemoveSubtree(selectedCutPoint.ChildIndex);
selectedCutPoint.Parent.InsertSubtree(selectedCutPoint.ChildIndex, newArgumentNode);
// find all old invocations of the selected ADF and attach a cloned version of the replaced branch (with all argument-nodes expanded)
// iterate in post-fix order to make sure that the subtrees of n are already adapted when n is processed
var invocationNodes = (from node in tree.IterateNodesPostfix().OfType<InvokeFunctionTreeNode>()
where node.Symbol.FunctionName == defunBranch.FunctionName
where node.Subtrees.Count() == defunBranch.NumberOfArguments
select node).ToList();
// do this repeatedly until no matching invocations are found
while (invocationNodes.Count > 0) {
List<ISymbolicExpressionTreeNode> newlyAddedBranches = new List<ISymbolicExpressionTreeNode>();
foreach (var invocationNode in invocationNodes) {
// check that the invocation node really has the correct number of arguments
if (invocationNode.Subtrees.Count() != defunBranch.NumberOfArguments) throw new InvalidOperationException();
// append a new argument branch after expanding all argument nodes
var clonedBranch = (ISymbolicExpressionTreeNode)replacedBranch.Clone();
clonedBranch = ReplaceArgumentsInBranch(clonedBranch, invocationNode.Subtrees);
invocationNode.InsertSubtree(newArgumentNode.Symbol.ArgumentIndex, clonedBranch);
newlyAddedBranches.Add(clonedBranch);
}
// iterate in post-fix order to make sure that the subtrees of n are already adapted when n is processed
invocationNodes = (from newlyAddedBranch in newlyAddedBranches
from node in newlyAddedBranch.IterateNodesPostfix().OfType<InvokeFunctionTreeNode>()
where node.Symbol.FunctionName == defunBranch.FunctionName
where node.Subtrees.Count() == defunBranch.NumberOfArguments
select node).ToList();
}
// increase expected number of arguments of function defining branch
// it's possible that the number of actually referenced arguments was reduced (all references were replaced by a single new argument)
// but the number of expected arguments is increased anyway
defunBranch.NumberOfArguments++;
defunBranch.Grammar.AddSymbol(newArgumentNode.Symbol);
defunBranch.Grammar.SetSubtreeCount(newArgumentNode.Symbol, 0, 0);
// allow the argument as child of any other symbol
GrammarModifier.SetAllowedParentSymbols(defunBranch.Grammar, selectedCutPoint.Child.Symbol, newArgumentNode.Symbol);
foreach (var subtree in tree.Root.Subtrees) {
// when the changed function is known in the branch then update the number of arguments
var matchingSymbol = subtree.Grammar.Symbols.OfType<InvokeFunction>().Where(s => s.FunctionName == defunBranch.FunctionName).SingleOrDefault();
if (matchingSymbol != null) {
subtree.Grammar.SetSubtreeCount(matchingSymbol, defunBranch.NumberOfArguments, defunBranch.NumberOfArguments);
foreach (var symb in subtree.Grammar.Symbols) {
if (symb is StartSymbol || symb is ProgramRootSymbol) continue;
if (symb.Name == matchingSymbol.Name) continue; //don't allow invoke as child of invoke
if (subtree.Grammar.IsAllowedChildSymbol(selectedCutPoint.Parent.Symbol, symb, selectedCutPoint.ChildIndex))
subtree.Grammar.AddAllowedChildSymbol(matchingSymbol, symb, newArgumentNode.Symbol.ArgumentIndex);
}
}
}
return true;
}