internal static string InterpretIf(ISymbolicExpressionTreeNode node)
{
ISymbolicExpressionTreeNode condition = null, truePart = null, falsePart = null;
string[] parts = new string[3];
if (node.SubtreeCount < 2 || node.SubtreeCount > 3)
{
throw new Exception("Unexpected number of children. Expected 2 or 3 children.");
}
condition = node.GetSubtree(0);
truePart = node.GetSubtree(1);
if (node.SubtreeCount == 3)
{
falsePart = node.GetSubtree(2);
}
parts[0] = Interpret(condition);
parts[1] = Interpret(truePart);
if (falsePart != null)
{
parts[2] = Interpret(falsePart);
}
return(string.Format("if ({0}) {{ {1} }} else {{ {2} }}", Interpret(condition), Interpret(truePart),
falsePart == null ? string.Empty : Interpret(falsePart)));
}
internal static string InterpretWhile(ISymbolicExpressionTreeNode node)
{
var cond = Interpret(node.GetSubtree(0));
var body = Interpret(node.GetSubtree(1));
return(string.Format("while ({0}) {{ {2} {1} {2} }} {2}", cond, body, Environment.NewLine));
}
/// Evaluate a whole tree branch, each branch returns an integer vector.
/// Evaluation algorithm-> transform tree to graph
/// 1. Recursive decention within node
/// - if current node is a end node then return
/// - else if current node is regular node then add the type to the builder
/// and if node has futher nodes create new builder for branches
/// 2. Use the NetworkBuilder to transform into vertices and relashionships
/// 3. Send result via Rest API to external Evaluation Endpoint
/// 4. Return final result
private void EvaluateNetworkProgram(ISymbolicExpressionTreeNode node)
{
// The program-root and start symbols are predefined symbols
// in each problem using the symbolic expression tree encoding.
// These symbols must be handled by the interpreter. Here simply
// evaluate the whole sub-tree
if (node.Symbol is ProgramRootSymbol)
{
EvaluateNetworkProgram(node.GetSubtree(0));
}
else if (node.Symbol is StartSymbol)
{
EvaluateNetworkProgram(node.GetSubtree(0));
}
else if (node.Symbol is ConvolutionalLayerSymbol)
{
// TODO
currentScore += 1;
}
else if (node.Symbol is FullyConnectedLayerSymbol)
{
// TODO
currentScore += 0.5;
}
else if (node.Symbol is PoolingLayerSymbol)
{
// TODO
currentScore += 2;
}
currentTimeSteps++;
}
private void FormatRoot(ISymbolicExpressionTreeNode node, StringBuilder strBuilder)
{
strBuilder.Append("Power[");
FormatRecursively(node.GetSubtree(0), strBuilder);
strBuilder.Append(", Divide[1,");
FormatRecursively(node.GetSubtree(1), strBuilder);
strBuilder.Append("]]");
}
private void FormatRoot(int level, ISymbolicExpressionTreeNode node, StringBuilder strBuilder)
{
strBuilder.AppendLine("POWER(");
FormatRecursively(level, node.GetSubtree(0), strBuilder);
strBuilder.AppendLineIndented(level, " , 1.0 / (");
FormatRecursively(level, node.GetSubtree(1), strBuilder);
strBuilder.AppendLineIndented(level, "))");
}
private void FormatRoot(ISymbolicExpressionTreeNode node, StringBuilder strBuilder)
{
strBuilder.Append("Math.Pow(");
FormatRecursively(node.GetSubtree(0), strBuilder);
strBuilder.Append(", 1.0 / (");
FormatRecursively(node.GetSubtree(1), strBuilder);
strBuilder.Append("))");
}
private void FormatIf(ISymbolicExpressionTreeNode node, StringBuilder strBuilder)
{
strBuilder.Append("If[Greater[");
FormatRecursively(node.GetSubtree(0), strBuilder);
strBuilder.Append(", 0], ");
FormatRecursively(node.GetSubtree(1), strBuilder);
strBuilder.Append(", ");
FormatRecursively(node.GetSubtree(2), strBuilder);
strBuilder.Append("]");
}
private void FormatAverage(ISymbolicExpressionTreeNode node, StringBuilder strBuilder)
{
// mean function needs a list of values
strBuilder.Append("Mean[{");
FormatRecursively(node.GetSubtree(0), strBuilder);
for (int i = 1; i < node.SubtreeCount; i++)
{
strBuilder.Append(",");
FormatRecursively(node.GetSubtree(i), strBuilder);
}
strBuilder.Append("}]");
}
private void FormatIfThenElse(int level, ISymbolicExpressionTreeNode node, StringBuilder strBuilder)
{
strBuilder.Append("CASE ISNULL((SELECT 1 WHERE");
FormatRecursively(level, node.GetSubtree(0), strBuilder);
strBuilder.AppendLine("),0)");
strBuilder.AppendIndented(level, "WHEN 1 THEN ");
FormatRecursively(level, node.GetSubtree(1), strBuilder);
strBuilder.AppendLine();
strBuilder.AppendIndented(level, "WHEN 0 THEN ");
FormatRecursively(level, node.GetSubtree(2), strBuilder);
strBuilder.AppendLine();
strBuilder.AppendIndented(level, "END");
}
private IEnumerable <double> InterpretRec(ISymbolicExpressionTreeNode node, IDataset dataset, IEnumerable <int> rows)
{
Func <ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode, Func <double, double, double>, IEnumerable <double> > binaryEval =
(left, right, f) => InterpretRec(left, dataset, rows).Zip(InterpretRec(right, dataset, rows), f);
switch (node.Symbol.Name)
{
case "+": return(binaryEval(node.GetSubtree(0), node.GetSubtree(1), (x, y) => x + y));
case "*": return(binaryEval(node.GetSubtree(0), node.GetSubtree(1), (x, y) => x * y));
case "-": return(binaryEval(node.GetSubtree(0), node.GetSubtree(1), (x, y) => x - y));
case "%": return(binaryEval(node.GetSubtree(0), node.GetSubtree(1), (x, y) => y.IsAlmost(0.0) ? 0.0 : x / y)); // protected division
default: {
double erc;
if (double.TryParse(node.Symbol.Name, out erc))
{
return(rows.Select(_ => erc));
}
else
{
// assume that this is a variable name
return(dataset.GetDoubleValues(node.Symbol.Name, rows));
}
}
}
}
public static string InterpretComparison(string compSy, ISymbolicExpressionTreeNode node)
{
ISymbolicExpressionTreeNode lhs = null, rhs = null;
if (node.SubtreeCount != 2)
{
throw new ArgumentException(string.Format("Expected exactly two children in {0}.", node.Symbol), "node");
}
lhs = node.GetSubtree(0);
rhs = node.GetSubtree(1);
return(Interpret(lhs) + compSy + Interpret(rhs));
}
private static IEnumerable <bool> InterpretRec(ISymbolicExpressionTreeNode node, IEnumerable <int> bs)
{
Func <ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode, Func <bool, bool, bool>, IEnumerable <bool> > binaryEval =
(left, right, f) => InterpretRec(left, bs).Zip(InterpretRec(right, bs), f);
switch (node.Symbol.Name)
{
case "AND": return(binaryEval(node.GetSubtree(0), node.GetSubtree(1), (x, y) => x & y));
case "OR": return(binaryEval(node.GetSubtree(0), node.GetSubtree(1), (x, y) => x | y));
case "NAND": return(binaryEval(node.GetSubtree(0), node.GetSubtree(1), (x, y) => !(x & y)));
case "NOR": return(binaryEval(node.GetSubtree(0), node.GetSubtree(1), (x, y) => !(x | y)));
default: {
byte bitPos;
if (byte.TryParse(node.Symbol.Name, out bitPos))
{
return(bs.Select(b => GetBits(b, bitPos)));
}
else
{
throw new NotSupportedException(string.Format("Found unexpected symbol {0}", node.Symbol.Name));
}
}
}
}
///<summary>
/// Finds the longest common subsequence in quadratic time and linear space
/// Variant of:
/// D. S. Hirschberg. A linear space algorithm for or computing maximal common subsequences. 1975.
/// http://dl.acm.org/citation.cfm?id=360861
/// </summary>
/// <returns>Number of pairs that were matched</returns>
public static int Match(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b, ISymbolicExpressionTreeNodeSimilarityComparer comp)
{
if (!comp.Equals(a, b))
{
return(0);
}
int m = a.SubtreeCount;
int n = b.SubtreeCount;
if (m == 0 || n == 0)
{
return(1);
}
var matrix = new int[m + 1, n + 1];
for (int i = 1; i <= m; ++i)
{
var ai = a.GetSubtree(i - 1);
for (int j = 1; j <= n; ++j)
{
var bj = b.GetSubtree(j - 1);
int match = Match(ai, bj, comp);
matrix[i, j] = Math.Max(Math.Max(matrix[i, j - 1], matrix[i - 1, j]), matrix[i - 1, j - 1] + match);
}
}
return(matrix[m, n] + 1);
}
public string FormatOnlyExpression(ISymbolicExpressionTreeNode expressionNode) {
var stringBuilder = new StringBuilder();
stringBuilder.AppendLine(" for " + CurrentIndexVariable + " = 1:1:rows");
stringBuilder.AppendLine(" estimated(" + CurrentIndexVariable + ") = " + FormatRecursively(expressionNode.GetSubtree(0)) + ";");
stringBuilder.AppendLine(" end;");
return stringBuilder.ToString();
}
public static void RenderNode(TextWriter writer, ISymbolicExpressionTreeNode node, string prefix) {
string label = node.ToString();
writer.Write(label);
if (node.SubtreeCount > 0) {
var padding = prefix + new string(' ', label.Length);
for (int i = 0; i != node.SubtreeCount; ++i) {
char connector, extender = ' ';
if (i == 0) {
if (node.SubtreeCount > 1) {
connector = RenderChars.JunctionDown;
extender = RenderChars.VerticalLine;
} else {
connector = RenderChars.HorizontalLine;
extender = ' ';
}
} else {
writer.Write(padding);
if (i == node.SubtreeCount - 1) {
connector = RenderChars.CornerRight;
extender = ' ';
} else {
connector = RenderChars.JunctionRight;
extender = RenderChars.VerticalLine;
}
}
writer.Write(string.Concat(connector, RenderChars.HorizontalLine));
var newPrefix = string.Concat(padding, extender, ' ');
RenderNode(writer, node.GetSubtree(i), newPrefix);
}
} else
writer.WriteLine();
}
private static string GetTextualRepresentationFromSubtreeOfDepth(ISymbolicExpressionTreeNode tree, int d)
{
if (d == 0)
{
return("");
}
StringBuilder builder = new StringBuilder();
var varTreeNode = tree as VariableTreeNode;
var constTreeNode = tree as ConstantTreeNode;
if (varTreeNode != null)
{
builder.Append("(var " + varTreeNode.VariableName);
}
else if (constTreeNode != null)
{
builder.Append("(const");
}
else
{
builder.Append("(" + tree.ToString());
}
for (int i = 0; i < tree.SubtreeCount; i++)
{
builder.Append(" " + GetTextualRepresentationFromSubtreeOfDepth(tree.GetSubtree(i), d - 1));
}
builder.Append(")");
return(builder.ToString());
}
private string FormatRecursively(ISymbolicExpressionTreeNode node)
{
StringBuilder strBuilder = new StringBuilder();
currentLag = 0;
FormatBegin(node, strBuilder);
if (node.SubtreeCount > 0)
{
strBuilder.Append(FormatRecursively(node.GetSubtree(0)));
}
int i = 1;
foreach (var subTree in node.Subtrees.Skip(1))
{
FormatSep(node, strBuilder, i);
// format the whole subtree
strBuilder.Append(FormatRecursively(subTree));
i++;
}
FormatEnd(node, strBuilder);
return(strBuilder.ToString());
}
private static void GetVariableReferences(Dictionary <string, int> references, ISymbolicExpressionTreeNode node, int currentLag)
{
if (node.Symbol is LaggedVariable)
{
var laggedVarNode = node as LaggedVariableTreeNode;
IncReferenceCount(references, laggedVarNode.VariableName, currentLag + laggedVarNode.Lag);
}
else if (node.Symbol is Variable)
{
var varNode = node as VariableTreeNode;
IncReferenceCount(references, varNode.VariableName, currentLag);
}
else if (node.Symbol is VariableCondition)
{
var varCondNode = node as VariableConditionTreeNode;
IncReferenceCount(references, varCondNode.VariableName, currentLag);
GetVariableReferences(references, node.GetSubtree(0), currentLag);
GetVariableReferences(references, node.GetSubtree(1), currentLag);
}
else if (node.Symbol is Integral)
{
var laggedNode = node as LaggedTreeNode;
for (int l = laggedNode.Lag; l <= 0; l++)
{
GetVariableReferences(references, node.GetSubtree(0), currentLag + l);
}
}
else if (node.Symbol is Derivative)
{
for (int l = -4; l <= 0; l++)
{
GetVariableReferences(references, node.GetSubtree(0), currentLag + l);
}
}
else if (node.Symbol is TimeLag)
{
var laggedNode = node as LaggedTreeNode;
GetVariableReferences(references, node.GetSubtree(0), currentLag + laggedNode.Lag);
}
else
{
foreach (var subtree in node.Subtrees)
{
GetVariableReferences(references, subtree, currentLag);
}
}
}
public static string InterpretFunc1(string functionId, ISymbolicExpressionTreeNode node)
{
if (node.SubtreeCount != 1)
{
throw new ArgumentException(string.Format("Expected 1 child in {0}.", node.Symbol.Name), "node");
}
return(string.Format("{0}({1})", functionId, Interpret(node.GetSubtree(0))));
}
/// <summary>
/// Remove, Replace or Insert subtrees
/// </summary>
/// <param name="tree">The symbolic expression tree</param>
/// <param name="parent">The insertion point (ie, the parent node who will receive a new child)</param>
/// <param name="oldChild">The subtree to be replaced</param>
/// <param name="newChild">The replacement subtree</param>
/// <param name="removeSubtree">Flag used to indicate if whole subtrees should be removed (default behavior), or just the subtree root</param>
private void Modify(ISymbolicExpressionTree tree, ISymbolicExpressionTreeNode parent,
ISymbolicExpressionTreeNode oldChild, ISymbolicExpressionTreeNode newChild, bool removeSubtree = true)
{
if (oldChild == null && newChild == null)
{
throw new ArgumentNullException("Cannot deduce operation type from the arguments. Please provide non null operands.");
}
if (oldChild == null)
{
// insertion operation
parent.AddSubtree(newChild);
newChild.Parent = parent;
}
else if (newChild == null)
{
// removal operation
parent.RemoveSubtree(parent.IndexOfSubtree(oldChild));
if (!removeSubtree)
{
for (int i = oldChild.SubtreeCount - 1; i >= 0; --i)
{
var subtree = oldChild.GetSubtree(i);
oldChild.RemoveSubtree(i);
parent.AddSubtree(subtree);
}
}
}
else
{
// replacement operation
var replacementIndex = parent.IndexOfSubtree(oldChild);
parent.RemoveSubtree(replacementIndex);
parent.InsertSubtree(replacementIndex, newChild);
newChild.Parent = parent;
if (changedNodes.ContainsKey(oldChild))
{
changedNodes.Add(newChild, changedNodes[oldChild]); // so that on double click the original node is restored
changedNodes.Remove(oldChild);
}
else
{
changedNodes.Add(newChild, oldChild);
}
}
treeState = IsValid(tree) ? TreeState.Valid : TreeState.Invalid;
switch (treeState)
{
case TreeState.Valid:
this.grpViewHost.Enabled = true;
UpdateModel(Content.Model.SymbolicExpressionTree);
break;
case TreeState.Invalid:
this.grpViewHost.Enabled = false;
break;
}
}
public static string InterpretChild(ISymbolicExpressionTreeNode node)
{
if (node.SubtreeCount != 1)
{
throw new ArgumentException(string.Format("Expected exactly one child in {0}.", node.Symbol), "node");
}
return(Interpret(node.GetSubtree(0)));
}
private void FormatSubtraction(ISymbolicExpressionTreeNode node, StringBuilder strBuilder)
{
if (node.SubtreeCount == 1)
{
strBuilder.Append("-");
FormatRecursively(node.GetSubtree(0), strBuilder);
return;
}
//Default case: more than 1 child
FormatOperator(node, "-", strBuilder);
}
private void FormatSubtraction(ISymbolicExpressionTreeNode node, StringBuilder strBuilder)
{
strBuilder.Append("Subtract[");
FormatRecursively(node.GetSubtree(0), strBuilder);
strBuilder.Append(", Times[-1");
foreach (var t in node.Subtrees)
{
strBuilder.Append(",");
FormatRecursively(t, strBuilder);
}
strBuilder.Append("]]");
}
private void SwitchNode(ISymbolicExpressionTreeNode root, ISymbolicExpressionTreeNode oldBranch, ISymbolicExpressionTreeNode newBranch)
{
for (int i = 0; i < root.SubtreeCount; i++)
{
if (root.GetSubtree(i) == oldBranch)
{
root.RemoveSubtree(i);
root.InsertSubtree(i, newBranch);
return;
}
}
}
private void FormatDivision(ISymbolicExpressionTreeNode node, StringBuilder strBuilder)
{
if (node.SubtreeCount == 1)
{
strBuilder.Append("Divide[1, ");
FormatRecursively(node.GetSubtree(0), strBuilder);
strBuilder.Append("]");
}
else
{
strBuilder.Append("Divide[");
FormatRecursively(node.GetSubtree(0), strBuilder);
strBuilder.Append(", Times[");
FormatRecursively(node.GetSubtree(1), strBuilder);
for (int i = 2; i < node.SubtreeCount; i++)
{
strBuilder.Append(",");
FormatRecursively(node.GetSubtree(i), strBuilder);
}
strBuilder.Append("]]");
}
}
private void FormatDivision(ISymbolicExpressionTreeNode node, StringBuilder strBuilder)
{
if (node.SubtreeCount == 1)
{
strBuilder.Append("1.0 / ");
FormatRecursively(node.GetSubtree(0), strBuilder);
}
else
{
FormatRecursively(node.GetSubtree(0), strBuilder);
strBuilder.Append("/ (");
for (int i = 1; i < node.SubtreeCount; i++)
{
if (i > 1)
{
strBuilder.Append(" * ");
}
FormatRecursively(node.GetSubtree(i), strBuilder);
}
strBuilder.Append(")");
}
}
private void SwitchNodeWithReplacementNode(ISymbolicExpressionTreeNode parent, int subTreeIndex)
{
ISymbolicExpressionTreeNode subTree = parent.GetSubtree(subTreeIndex);
if (foldedNodes.ContainsKey(subTree))
{
parent.RemoveSubtree(subTreeIndex);
var replacementNode = foldedNodes[subTree];
parent.InsertSubtree(subTreeIndex, replacementNode);
// exchange key and value
foldedNodes.Remove(subTree);
foldedNodes.Add(replacementNode, subTree);
}
}
public static void IsValid(ISymbolicExpressionTreeNode treeNode)
{
var matchingSymbol = (from symb in treeNode.Grammar.Symbols
where symb.Name == treeNode.Symbol.Name
select symb).SingleOrDefault();
Assert.IsTrue(treeNode.Subtrees.Count() >= treeNode.Grammar.GetMinimumSubtreeCount(matchingSymbol));
Assert.IsTrue(treeNode.Subtrees.Count() <= treeNode.Grammar.GetMaximumSubtreeCount(matchingSymbol));
Assert.AreNotEqual(0.0, matchingSymbol.InitialFrequency); // check that no deactivated symbols occur in the tree
for (int i = 0; i < treeNode.Subtrees.Count(); i++)
{
Assert.IsTrue(treeNode.Grammar.GetAllowedChildSymbols(treeNode.Symbol, i).Select(x => x.Name).Contains(treeNode.GetSubtree(i).Symbol.Name));
IsValid(treeNode.GetSubtree(i));
}
}
public static void RenderNode(TextWriter writer, ISymbolicExpressionTreeNode node, string prefix)
{
string label = node.ToString();
writer.Write(label);
if (node.SubtreeCount > 0)
{
var padding = prefix + new string(' ', label.Length);
for (int i = 0; i != node.SubtreeCount; ++i)
{
char connector, extender = ' ';
if (i == 0)
{
if (node.SubtreeCount > 1)
{
connector = RenderChars.JunctionDown;
extender = RenderChars.VerticalLine;
}
else
{
connector = RenderChars.HorizontalLine;
extender = ' ';
}
}
else
{
writer.Write(padding);
if (i == node.SubtreeCount - 1)
{
connector = RenderChars.CornerRight;
extender = ' ';
}
else
{
connector = RenderChars.JunctionRight;
extender = RenderChars.VerticalLine;
}
}
writer.Write(string.Concat(connector, RenderChars.HorizontalLine));
var newPrefix = string.Concat(padding, extender, ' ');
RenderNode(writer, node.GetSubtree(i), newPrefix);
}
}
else
{
writer.WriteLine();
}
}
private static void FindCrossoverPoint(ISymbolicExpressionTreeNode childNode, ISymbolicExpressionTreeNode parentNode, int curDepth, IList <Tuple <ISymbolicExpressionTreeNode, int> > possibleCrossoverPoints)
{
if (childNode.Symbol.Name != parentNode.Symbol.Name)
{
possibleCrossoverPoints.Add(new Tuple <ISymbolicExpressionTreeNode, int>(childNode, curDepth));
return;
}
if (childNode.Subtrees != null)
{
for (int i = 0; i < childNode.SubtreeCount; i++)
{
FindCrossoverPoint(childNode.GetSubtree(i), parentNode.GetSubtree(i), curDepth + 1, possibleCrossoverPoints);
}
}
}
///<summary>
/// Finds the longest common subsequence in quadratic time and linear space
/// Variant of:
/// D. S. Hirschberg. A linear space algorithm for or computing maximal common subsequences. 1975.
/// http://dl.acm.org/citation.cfm?id=360861
/// </summary>
/// <returns>Number of pairs that were matched</returns>
public static int Match(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b, ISymbolicExpressionTreeNodeSimilarityComparer comp) {
if (!comp.Equals(a, b)) return 0;
int m = a.SubtreeCount;
int n = b.SubtreeCount;
if (m == 0 || n == 0) return 1;
var matrix = new int[m + 1, n + 1];
for (int i = 1; i <= m; ++i) {
var ai = a.GetSubtree(i - 1);
for (int j = 1; j <= n; ++j) {
var bj = b.GetSubtree(j - 1);
int match = Match(ai, bj, comp);
matrix[i, j] = Math.Max(Math.Max(matrix[i, j - 1], matrix[i - 1, j]), matrix[i - 1, j - 1] + match);
}
}
return matrix[m, n] + 1;
}
/// <summary>
/// Remove, Replace or Insert subtrees
/// </summary>
/// <param name="tree">The symbolic expression tree</param>
/// <param name="parent">The insertion point (ie, the parent node who will receive a new child)</param>
/// <param name="oldChild">The subtree to be replaced</param>
/// <param name="newChild">The replacement subtree</param>
/// <param name="removeSubtree">Flag used to indicate if whole subtrees should be removed (default behavior), or just the subtree root</param>
private void Modify(ISymbolicExpressionTree tree, ISymbolicExpressionTreeNode parent,
ISymbolicExpressionTreeNode oldChild, ISymbolicExpressionTreeNode newChild, bool removeSubtree = true) {
if (oldChild == null && newChild == null)
throw new ArgumentNullException("Cannot deduce operation type from the arguments. Please provide non null operands.");
if (oldChild == null) {
// insertion operation
parent.AddSubtree(newChild);
newChild.Parent = parent;
} else if (newChild == null) {
// removal operation
parent.RemoveSubtree(parent.IndexOfSubtree(oldChild));
if (!removeSubtree) {
for (int i = oldChild.SubtreeCount - 1; i >= 0; --i) {
var subtree = oldChild.GetSubtree(i);
oldChild.RemoveSubtree(i);
parent.AddSubtree(subtree);
}
}
} else {
// replacement operation
var replacementIndex = parent.IndexOfSubtree(oldChild);
parent.RemoveSubtree(replacementIndex);
parent.InsertSubtree(replacementIndex, newChild);
newChild.Parent = parent;
if (changedNodes.ContainsKey(oldChild)) {
changedNodes.Add(newChild, changedNodes[oldChild]); // so that on double click the original node is restored
changedNodes.Remove(oldChild);
} else {
changedNodes.Add(newChild, oldChild);
}
}
treeState = IsValid(tree) ? TreeState.Valid : TreeState.Invalid;
switch (treeState) {
case TreeState.Valid:
this.grpViewHost.Enabled = true;
UpdateModel(Content.Model.SymbolicExpressionTree);
break;
case TreeState.Invalid:
this.grpViewHost.Enabled = false;
break;
}
}
private static IEnumerable <bool> InterpretRec(ISymbolicExpressionTreeNode node, IEnumerable <int> bs, byte addrBits)
{
Func <ISymbolicExpressionTreeNode, Func <bool, bool>, IEnumerable <bool> > unaryEval =
(child, f) => InterpretRec(child, bs, addrBits).Select(f);
Func <ISymbolicExpressionTreeNode, ISymbolicExpressionTreeNode, Func <bool, bool, bool>, IEnumerable <bool> > binaryEval =
(left, right, f) => InterpretRec(left, bs, addrBits).Zip(InterpretRec(right, bs, addrBits), f);
switch (node.Symbol.Name)
{
case "AND": return(binaryEval(node.GetSubtree(0), node.GetSubtree(1), (x, y) => x & y));
case "OR": return(binaryEval(node.GetSubtree(0), node.GetSubtree(1), (x, y) => x | y));
case "NOT": return(unaryEval(node.GetSubtree(0), (x) => !x));
case "IF": return(EvalIf(node.GetSubtree(0), node.GetSubtree(1), node.GetSubtree(2), bs, addrBits));
default: {
if (node.Symbol.Name[0] == 'a')
{
byte bitPos;
if (byte.TryParse(node.Symbol.Name.Substring(1), out bitPos))
{
return(bs.Select(b => GetBits(b, bitPos)));
}
}
else if (node.Symbol.Name[0] == 'd')
{
byte bitPos;
if (byte.TryParse(node.Symbol.Name.Substring(1), out bitPos))
{
return(bs.Select(b => GetBits(b, (byte)(bitPos + addrBits)))); // offset of input line bits
}
}
throw new NotSupportedException(string.Format("Found unexpected symbol {0}", node.Symbol.Name));
}
}
}
private string FormatRecursively(ISymbolicExpressionTreeNode node) {
StringBuilder strBuilder = new StringBuilder();
currentLag = 0;
FormatBegin(node, strBuilder);
if (node.SubtreeCount > 0) {
strBuilder.Append(FormatRecursively(node.GetSubtree(0)));
}
int i = 1;
foreach (SymbolicExpressionTreeNode subTree in node.Subtrees.Skip(1)) {
FormatSep(node, strBuilder, i);
// format the whole subtree
strBuilder.Append(FormatRecursively(subTree));
i++;
}
FormatEnd(node, strBuilder);
return strBuilder.ToString();
}
private void FormatSquare(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
strBuilder.Append("Power[");
FormatRecursively(node.GetSubtree(0), strBuilder);
strBuilder.Append(", 2]");
}
private static bool TryTransformToAutoDiff(ISymbolicExpressionTreeNode node, List<AutoDiff.Variable> variables, List<AutoDiff.Variable> parameters, List<string> variableNames, out AutoDiff.Term term) {
if (node.Symbol is Constant) {
var var = new AutoDiff.Variable();
variables.Add(var);
term = var;
return true;
}
if (node.Symbol is Variable) {
var varNode = node as VariableTreeNode;
var par = new AutoDiff.Variable();
parameters.Add(par);
variableNames.Add(varNode.VariableName);
var w = new AutoDiff.Variable();
variables.Add(w);
term = AutoDiff.TermBuilder.Product(w, par);
return true;
}
if (node.Symbol is Addition) {
List<AutoDiff.Term> terms = new List<Term>();
foreach (var subTree in node.Subtrees) {
AutoDiff.Term t;
if (!TryTransformToAutoDiff(subTree, variables, parameters, variableNames, out t)) {
term = null;
return false;
}
terms.Add(t);
}
term = AutoDiff.TermBuilder.Sum(terms);
return true;
}
if (node.Symbol is Subtraction) {
List<AutoDiff.Term> terms = new List<Term>();
for (int i = 0; i < node.SubtreeCount; i++) {
AutoDiff.Term t;
if (!TryTransformToAutoDiff(node.GetSubtree(i), variables, parameters, variableNames, out t)) {
term = null;
return false;
}
if (i > 0) t = -t;
terms.Add(t);
}
term = AutoDiff.TermBuilder.Sum(terms);
return true;
}
if (node.Symbol is Multiplication) {
AutoDiff.Term a, b;
if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out a) ||
!TryTransformToAutoDiff(node.GetSubtree(1), variables, parameters, variableNames, out b)) {
term = null;
return false;
} else {
List<AutoDiff.Term> factors = new List<Term>();
foreach (var subTree in node.Subtrees.Skip(2)) {
AutoDiff.Term f;
if (!TryTransformToAutoDiff(subTree, variables, parameters, variableNames, out f)) {
term = null;
return false;
}
factors.Add(f);
}
term = AutoDiff.TermBuilder.Product(a, b, factors.ToArray());
return true;
}
}
if (node.Symbol is Division) {
// only works for at least two subtrees
AutoDiff.Term a, b;
if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out a) ||
!TryTransformToAutoDiff(node.GetSubtree(1), variables, parameters, variableNames, out b)) {
term = null;
return false;
} else {
List<AutoDiff.Term> factors = new List<Term>();
foreach (var subTree in node.Subtrees.Skip(2)) {
AutoDiff.Term f;
if (!TryTransformToAutoDiff(subTree, variables, parameters, variableNames, out f)) {
term = null;
return false;
}
factors.Add(1.0 / f);
}
term = AutoDiff.TermBuilder.Product(a, 1.0 / b, factors.ToArray());
return true;
}
}
if (node.Symbol is Logarithm) {
AutoDiff.Term t;
if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out t)) {
term = null;
return false;
} else {
term = AutoDiff.TermBuilder.Log(t);
return true;
}
}
if (node.Symbol is Exponential) {
AutoDiff.Term t;
if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out t)) {
term = null;
return false;
} else {
term = AutoDiff.TermBuilder.Exp(t);
return true;
}
}
if (node.Symbol is Square) {
AutoDiff.Term t;
if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out t)) {
term = null;
return false;
} else {
term = AutoDiff.TermBuilder.Power(t, 2.0);
return true;
}
} if (node.Symbol is SquareRoot) {
AutoDiff.Term t;
if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out t)) {
term = null;
return false;
} else {
term = AutoDiff.TermBuilder.Power(t, 0.5);
return true;
}
} if (node.Symbol is Sine) {
AutoDiff.Term t;
if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out t)) {
term = null;
return false;
} else {
term = sin(t);
return true;
}
} if (node.Symbol is Cosine) {
AutoDiff.Term t;
if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out t)) {
term = null;
return false;
} else {
term = cos(t);
return true;
}
} if (node.Symbol is Tangent) {
AutoDiff.Term t;
if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out t)) {
term = null;
return false;
} else {
term = tan(t);
return true;
}
} if (node.Symbol is Erf) {
AutoDiff.Term t;
if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out t)) {
term = null;
return false;
} else {
term = erf(t);
return true;
}
} if (node.Symbol is Norm) {
AutoDiff.Term t;
if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out t)) {
term = null;
return false;
} else {
term = norm(t);
return true;
}
}
if (node.Symbol is StartSymbol) {
var alpha = new AutoDiff.Variable();
var beta = new AutoDiff.Variable();
variables.Add(beta);
variables.Add(alpha);
AutoDiff.Term branchTerm;
if (TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, out branchTerm)) {
term = branchTerm * alpha + beta;
return true;
} else {
term = null;
return false;
}
}
term = null;
return false;
}
public static void IsValid(ISymbolicExpressionTreeNode treeNode) {
var matchingSymbol = (from symb in treeNode.Grammar.Symbols
where symb.Name == treeNode.Symbol.Name
select symb).SingleOrDefault();
Assert.IsTrue(treeNode.Subtrees.Count() >= treeNode.Grammar.GetMinimumSubtreeCount(matchingSymbol));
Assert.IsTrue(treeNode.Subtrees.Count() <= treeNode.Grammar.GetMaximumSubtreeCount(matchingSymbol));
Assert.AreNotEqual(0.0, matchingSymbol.InitialFrequency); // check that no deactivated symbols occur in the tree
for (int i = 0; i < treeNode.Subtrees.Count(); i++) {
Assert.IsTrue(treeNode.Grammar.GetAllowedChildSymbols(treeNode.Symbol, i).Select(x => x.Name).Contains(treeNode.GetSubtree(i).Symbol.Name));
IsValid(treeNode.GetSubtree(i));
}
}
public static string InterpretFunc1(string functionId, ISymbolicExpressionTreeNode node) {
if (node.SubtreeCount != 1)
throw new ArgumentException(string.Format("Expected 1 child in {0}.", node.Symbol.Name), "node");
return string.Format("{0}({1})", functionId, Interpret(node.GetSubtree(0)));
}
public static string InterpretChild(ISymbolicExpressionTreeNode node) {
if (node.SubtreeCount != 1)
throw new ArgumentException(string.Format("Expected exactly one child in {0}.", node.Symbol), "node");
return Interpret(node.GetSubtree(0));
}
internal static string InterpretIf(ISymbolicExpressionTreeNode node) {
ISymbolicExpressionTreeNode condition = null, truePart = null, falsePart = null;
string[] parts = new string[3];
if (node.SubtreeCount < 2 || node.SubtreeCount > 3)
throw new Exception("Unexpected number of children. Expected 2 or 3 children.");
condition = node.GetSubtree(0);
truePart = node.GetSubtree(1);
if (node.SubtreeCount == 3)
falsePart = node.GetSubtree(2);
parts[0] = Interpret(condition);
parts[1] = Interpret(truePart);
if (falsePart != null) parts[2] = Interpret(falsePart);
return string.Format("if ({0}) {{ {1} }} else {{ {2} }}", Interpret(condition), Interpret(truePart),
falsePart == null ? string.Empty : Interpret(falsePart));
}
private void FormatRecursively(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
if (node.Subtrees.Any()) {
if (node.Symbol is Addition) {
FormatFunction(node, "Plus", strBuilder);
} else if (node.Symbol is Average) {
FormatAverage(node, strBuilder);
} else if (node.Symbol is Multiplication) {
FormatFunction(node, "Times", strBuilder);
} else if (node.Symbol is Subtraction) {
FormatSubtraction(node, strBuilder);
} else if (node.Symbol is Division) {
FormatDivision(node, strBuilder);
} else if (node.Symbol is Sine) {
FormatFunction(node, "Sin", strBuilder);
} else if (node.Symbol is Cosine) {
FormatFunction(node, "Cos", strBuilder);
} else if (node.Symbol is Tangent) {
FormatFunction(node, "Tan", strBuilder);
} else if (node.Symbol is Exponential) {
FormatFunction(node, "Exp", strBuilder);
} else if (node.Symbol is Logarithm) {
FormatFunction(node, "Log", strBuilder);
} else if (node.Symbol is IfThenElse) {
FormatIf(node, strBuilder);
} else if (node.Symbol is GreaterThan) {
strBuilder.Append("If[Greater[");
FormatRecursively(node.GetSubtree(0), strBuilder);
strBuilder.Append(",");
FormatRecursively(node.GetSubtree(1), strBuilder);
strBuilder.Append("], 1, -1]");
} else if (node.Symbol is LessThan) {
strBuilder.Append("If[Less[");
FormatRecursively(node.GetSubtree(0), strBuilder);
strBuilder.Append(",");
FormatRecursively(node.GetSubtree(1), strBuilder);
strBuilder.Append("], 1, -1]");
} else if (node.Symbol is And) {
FormatAnd(node, strBuilder);
} else if (node.Symbol is Not) {
strBuilder.Append("If[Greater[");
FormatRecursively(node.GetSubtree(0), strBuilder);
strBuilder.Append(", 0], -1, 1]");
} else if (node.Symbol is Or) {
FormatOr(node, strBuilder);
} else if (node.Symbol is Xor) {
FormatXor(node, strBuilder);
} else if (node.Symbol is Square) {
FormatSquare(node, strBuilder);
} else if (node.Symbol is SquareRoot) {
FormatFunction(node, "Sqrt", strBuilder);
} else if (node.Symbol is Power) {
FormatFunction(node, "Power", strBuilder);
} else if (node.Symbol is Root) {
FormatRoot(node, strBuilder);
} else {
throw new NotSupportedException("Formatting of symbol: " + node.Symbol + " is not supported.");
}
} else {
if (node is VariableTreeNode) {
var varNode = node as VariableTreeNode;
strBuilder.AppendFormat("Times[{0}, {1}]", varNode.VariableName, varNode.Weight.ToString("G17", CultureInfo.InvariantCulture));
} else if (node is ConstantTreeNode) {
var constNode = node as ConstantTreeNode;
strBuilder.Append(constNode.Value.ToString("G17", CultureInfo.InvariantCulture));
} else {
throw new NotSupportedException("Formatting of symbol: " + node.Symbol + " is not supported.");
}
}
}
private static bool TryTransformToAutoDiff(ISymbolicExpressionTreeNode node, List<AutoDiff.Variable> variables, List<AutoDiff.Variable> parameters, List<string> variableNames, bool updateVariableWeights, out AutoDiff.Term term) {
if (node.Symbol is Constant) {
var var = new AutoDiff.Variable();
variables.Add(var);
term = var;
return true;
}
if (node.Symbol is Variable) {
var varNode = node as VariableTreeNode;
var par = new AutoDiff.Variable();
parameters.Add(par);
variableNames.Add(varNode.VariableName);
if (updateVariableWeights) {
var w = new AutoDiff.Variable();
variables.Add(w);
term = AutoDiff.TermBuilder.Product(w, par);
} else {
term = par;
}
return true;
}
if (node.Symbol is Addition) {
List<AutoDiff.Term> terms = new List<Term>();
foreach (var subTree in node.Subtrees) {
AutoDiff.Term t;
if (!TryTransformToAutoDiff(subTree, variables, parameters, variableNames, updateVariableWeights, out t)) {
term = null;
return false;
}
terms.Add(t);
}
term = AutoDiff.TermBuilder.Sum(terms);
return true;
}
if (node.Symbol is Subtraction) {
List<AutoDiff.Term> terms = new List<Term>();
for (int i = 0; i < node.SubtreeCount; i++) {
AutoDiff.Term t;
if (!TryTransformToAutoDiff(node.GetSubtree(i), variables, parameters, variableNames, updateVariableWeights, out t)) {
term = null;
return false;
}
if (i > 0) t = -t;
terms.Add(t);
}
if (terms.Count == 1) term = -terms[0];
else term = AutoDiff.TermBuilder.Sum(terms);
return true;
}
if (node.Symbol is Multiplication) {
List<AutoDiff.Term> terms = new List<Term>();
foreach (var subTree in node.Subtrees) {
AutoDiff.Term t;
if (!TryTransformToAutoDiff(subTree, variables, parameters, variableNames, updateVariableWeights, out t)) {
term = null;
return false;
}
terms.Add(t);
}
if (terms.Count == 1) term = terms[0];
else term = terms.Aggregate((a, b) => new AutoDiff.Product(a, b));
return true;
}
if (node.Symbol is Division) {
List<AutoDiff.Term> terms = new List<Term>();
foreach (var subTree in node.Subtrees) {
AutoDiff.Term t;
if (!TryTransformToAutoDiff(subTree, variables, parameters, variableNames, updateVariableWeights, out t)) {
term = null;
return false;
}
terms.Add(t);
}
if (terms.Count == 1) term = 1.0 / terms[0];
else term = terms.Aggregate((a, b) => new AutoDiff.Product(a, 1.0 / b));
return true;
}
if (node.Symbol is Logarithm) {
AutoDiff.Term t;
if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out t)) {
term = null;
return false;
} else {
term = AutoDiff.TermBuilder.Log(t);
return true;
}
}
if (node.Symbol is Exponential) {
AutoDiff.Term t;
if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out t)) {
term = null;
return false;
} else {
term = AutoDiff.TermBuilder.Exp(t);
return true;
}
}
if (node.Symbol is Square) {
AutoDiff.Term t;
if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out t)) {
term = null;
return false;
} else {
term = AutoDiff.TermBuilder.Power(t, 2.0);
return true;
}
}
if (node.Symbol is SquareRoot) {
AutoDiff.Term t;
if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out t)) {
term = null;
return false;
} else {
term = AutoDiff.TermBuilder.Power(t, 0.5);
return true;
}
}
if (node.Symbol is Sine) {
AutoDiff.Term t;
if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out t)) {
term = null;
return false;
} else {
term = sin(t);
return true;
}
}
if (node.Symbol is Cosine) {
AutoDiff.Term t;
if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out t)) {
term = null;
return false;
} else {
term = cos(t);
return true;
}
}
if (node.Symbol is Tangent) {
AutoDiff.Term t;
if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out t)) {
term = null;
return false;
} else {
term = tan(t);
return true;
}
}
if (node.Symbol is Erf) {
AutoDiff.Term t;
if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out t)) {
term = null;
return false;
} else {
term = erf(t);
return true;
}
}
if (node.Symbol is Norm) {
AutoDiff.Term t;
if (!TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out t)) {
term = null;
return false;
} else {
term = norm(t);
return true;
}
}
if (node.Symbol is StartSymbol) {
var alpha = new AutoDiff.Variable();
var beta = new AutoDiff.Variable();
variables.Add(beta);
variables.Add(alpha);
AutoDiff.Term branchTerm;
if (TryTransformToAutoDiff(node.GetSubtree(0), variables, parameters, variableNames, updateVariableWeights, out branchTerm)) {
term = branchTerm * alpha + beta;
return true;
} else {
term = null;
return false;
}
}
term = null;
return false;
}
private void SwitchNodeWithReplacementNode(ISymbolicExpressionTreeNode parent, int subTreeIndex) {
ISymbolicExpressionTreeNode subTree = parent.GetSubtree(subTreeIndex);
if (foldedNodes.ContainsKey(subTree)) {
parent.RemoveSubtree(subTreeIndex);
var replacementNode = foldedNodes[subTree];
parent.InsertSubtree(subTreeIndex, replacementNode);
// exchange key and value
foldedNodes.Remove(subTree);
foldedNodes.Add(replacementNode, subTree);
}
}
// MakeFraction, MakeProduct and MakeSum take two already simplified trees and create a new simplified tree
private ISymbolicExpressionTreeNode MakeFraction(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
if (IsConstant(a) && IsConstant(b)) {
// fold constants
return MakeConstant(((ConstantTreeNode)a).Value / ((ConstantTreeNode)b).Value);
} if (IsConstant(a) && !((ConstantTreeNode)a).Value.IsAlmost(1.0)) {
return MakeFraction(MakeConstant(1.0), MakeProduct(b, Invert(a)));
} else if (IsVariable(a) && IsConstant(b)) {
// merge constant values into variable weights
var constB = ((ConstantTreeNode)b).Value;
((VariableTreeNode)a).Weight /= constB;
return a;
} else if (IsVariable(a) && IsVariable(b) && AreSameVariable(a, b)) {
// cancel variables
var aVar = a as VariableTreeNode;
var bVar = b as VariableTreeNode;
return MakeConstant(aVar.Weight / bVar.Weight);
} else if (IsAddition(a) && IsConstant(b)) {
return a.Subtrees
.Select(x => GetSimplifiedTree(x))
.Select(x => MakeFraction(x, b))
.Aggregate((c, d) => MakeSum(c, d));
} else if (IsMultiplication(a) && IsConstant(b)) {
return MakeProduct(a, Invert(b));
} else if (IsDivision(a) && IsConstant(b)) {
// (a1 / a2) / c => (a1 / (a2 * c))
return MakeFraction(a.GetSubtree(0), MakeProduct(a.GetSubtree(1), b));
} else if (IsDivision(a) && IsDivision(b)) {
// (a1 / a2) / (b1 / b2) =>
return MakeFraction(MakeProduct(a.GetSubtree(0), b.GetSubtree(1)), MakeProduct(a.GetSubtree(1), b.GetSubtree(0)));
} else if (IsDivision(a)) {
// (a1 / a2) / b => (a1 / (a2 * b))
return MakeFraction(a.GetSubtree(0), MakeProduct(a.GetSubtree(1), b));
} else if (IsDivision(b)) {
// a / (b1 / b2) => (a * b2) / b1
return MakeFraction(MakeProduct(a, b.GetSubtree(1)), b.GetSubtree(0));
} else {
var div = divSymbol.CreateTreeNode();
div.AddSubtree(a);
div.AddSubtree(b);
return div;
}
}
private ISymbolicExpressionTreeNode MakeSum(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
if (IsConstant(a) && IsConstant(b)) {
// fold constants
((ConstantTreeNode)a).Value += ((ConstantTreeNode)b).Value;
return a;
} else if (IsConstant(a)) {
// c + x => x + c
// b is not constant => make sure constant is on the right
return MakeSum(b, a);
} else if (IsConstant(b) && ((ConstantTreeNode)b).Value.IsAlmost(0.0)) {
// x + 0 => x
return a;
} else if (IsAddition(a) && IsAddition(b)) {
// merge additions
var add = addSymbol.CreateTreeNode();
// add all sub trees except for the last
for (int i = 0; i < a.Subtrees.Count() - 1; i++) add.AddSubtree(a.GetSubtree(i));
for (int i = 0; i < b.Subtrees.Count() - 1; i++) add.AddSubtree(b.GetSubtree(i));
if (IsConstant(a.Subtrees.Last()) && IsConstant(b.Subtrees.Last())) {
add.AddSubtree(MakeSum(a.Subtrees.Last(), b.Subtrees.Last()));
} else if (IsConstant(a.Subtrees.Last())) {
add.AddSubtree(b.Subtrees.Last());
add.AddSubtree(a.Subtrees.Last());
} else {
add.AddSubtree(a.Subtrees.Last());
add.AddSubtree(b.Subtrees.Last());
}
MergeVariablesInSum(add);
if (add.Subtrees.Count() == 1) {
return add.GetSubtree(0);
} else {
return add;
}
} else if (IsAddition(b)) {
return MakeSum(b, a);
} else if (IsAddition(a) && IsConstant(b)) {
// a is an addition and b is a constant => append b to a and make sure the constants are merged
var add = addSymbol.CreateTreeNode();
// add all sub trees except for the last
for (int i = 0; i < a.Subtrees.Count() - 1; i++) add.AddSubtree(a.GetSubtree(i));
if (IsConstant(a.Subtrees.Last()))
add.AddSubtree(MakeSum(a.Subtrees.Last(), b));
else {
add.AddSubtree(a.Subtrees.Last());
add.AddSubtree(b);
}
return add;
} else if (IsAddition(a)) {
// a is already an addition => append b
var add = addSymbol.CreateTreeNode();
add.AddSubtree(b);
foreach (var subtree in a.Subtrees) {
add.AddSubtree(subtree);
}
MergeVariablesInSum(add);
if (add.Subtrees.Count() == 1) {
return add.GetSubtree(0);
} else {
return add;
}
} else {
var add = addSymbol.CreateTreeNode();
add.AddSubtree(a);
add.AddSubtree(b);
MergeVariablesInSum(add);
if (add.Subtrees.Count() == 1) {
return add.GetSubtree(0);
} else {
return add;
}
}
}
private ISymbolicExpressionTreeNode MakeProduct(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
if (IsConstant(a) && IsConstant(b)) {
// fold constants
((ConstantTreeNode)a).Value *= ((ConstantTreeNode)b).Value;
return a;
} else if (IsConstant(a)) {
// a * $ => $ * a
return MakeProduct(b, a);
} else if (IsConstant(b) && ((ConstantTreeNode)b).Value.IsAlmost(1.0)) {
// $ * 1.0 => $
return a;
} else if (IsConstant(b) && IsVariable(a)) {
// multiply constants into variables weights
((VariableTreeNode)a).Weight *= ((ConstantTreeNode)b).Value;
return a;
} else if (IsConstant(b) && IsAddition(a)) {
// multiply constants into additions
return a.Subtrees.Select(x => MakeProduct(x, b)).Aggregate((c, d) => MakeSum(c, d));
} else if (IsDivision(a) && IsDivision(b)) {
// (a1 / a2) * (b1 / b2) => (a1 * b1) / (a2 * b2)
return MakeFraction(MakeProduct(a.GetSubtree(0), b.GetSubtree(0)), MakeProduct(a.GetSubtree(1), b.GetSubtree(1)));
} else if (IsDivision(a)) {
// (a1 / a2) * b => (a1 * b) / a2
return MakeFraction(MakeProduct(a.GetSubtree(0), b), a.GetSubtree(1));
} else if (IsDivision(b)) {
// a * (b1 / b2) => (b1 * a) / b2
return MakeFraction(MakeProduct(b.GetSubtree(0), a), b.GetSubtree(1));
} else if (IsMultiplication(a) && IsMultiplication(b)) {
// merge multiplications (make sure constants are merged)
var mul = mulSymbol.CreateTreeNode();
for (int i = 0; i < a.Subtrees.Count(); i++) mul.AddSubtree(a.GetSubtree(i));
for (int i = 0; i < b.Subtrees.Count(); i++) mul.AddSubtree(b.GetSubtree(i));
MergeVariablesAndConstantsInProduct(mul);
return mul;
} else if (IsMultiplication(b)) {
return MakeProduct(b, a);
} else if (IsMultiplication(a)) {
// a is already an multiplication => append b
a.AddSubtree(b);
MergeVariablesAndConstantsInProduct(a);
return a;
} else {
var mul = mulSymbol.CreateTreeNode();
mul.AddSubtree(a);
mul.AddSubtree(b);
MergeVariablesAndConstantsInProduct(mul);
return mul;
}
}
private void FormatRoot(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
strBuilder.Append("Power[");
FormatRecursively(node.GetSubtree(0), strBuilder);
strBuilder.Append(", Divide[1,");
FormatRecursively(node.GetSubtree(1), strBuilder);
strBuilder.Append("]]");
}
private static Tuple<int, int> EvaluateLawnMowerProgram(ISymbolicExpressionTreeNode node, MowerState mowerState, bool[,] lawn, IEnumerable<ISymbolicExpressionTreeNode> adfs) {
if (mowerState.Energy <= 0) return Tuple.Create(0, 0);
if (node.Symbol is ProgramRootSymbol) {
return EvaluateLawnMowerProgram(node.GetSubtree(0), mowerState, lawn, adfs);
} else if (node.Symbol is StartSymbol) {
return EvaluateLawnMowerProgram(node.GetSubtree(0), mowerState, lawn, adfs);
} else if (node.Symbol.Name == "Left") {
switch (mowerState.Heading) {
case Heading.East: mowerState.Heading = Heading.North;
break;
case Heading.North: mowerState.Heading = Heading.West;
break;
case Heading.West: mowerState.Heading = Heading.South;
break;
case Heading.South:
mowerState.Heading = Heading.East;
break;
}
return new Tuple<int, int>(0, 0);
} else if (node.Symbol.Name == "Forward") {
int dRow = 0;
int dCol = 0;
switch (mowerState.Heading) {
case Heading.East:
dCol++;
break;
case Heading.North:
dRow--;
break;
case Heading.West:
dCol--;
break;
case Heading.South:
dRow++;
break;
}
uint newRow = (uint)((mowerState.Position.Item1 + lawn.GetLength(0) + dRow) % lawn.GetLength(0));
uint newColumn = (uint)((mowerState.Position.Item2 + lawn.GetLength(1) + dCol) % lawn.GetLength(1));
mowerState.Position = Tuple.Create(newRow, newColumn);
mowerState.Energy = mowerState.Energy - 1;
lawn[newRow, newColumn] = true;
return Tuple.Create(0, 0);
} else if (node.Symbol.Name == "Sum") {
var p = EvaluateLawnMowerProgram(node.GetSubtree(0), mowerState, lawn, adfs);
var q = EvaluateLawnMowerProgram(node.GetSubtree(1), mowerState, lawn, adfs);
return Tuple.Create(p.Item1 + q.Item1, p.Item2 + q.Item2);
} else if (node.Symbol.Name == "Prog") {
EvaluateLawnMowerProgram(node.GetSubtree(0), mowerState, lawn, adfs);
return EvaluateLawnMowerProgram(node.GetSubtree(1), mowerState, lawn, adfs);
} else if (node.Symbol.Name == "Frog") {
var p = EvaluateLawnMowerProgram(node.GetSubtree(0), mowerState, lawn, adfs);
int x = p.Item1;
int y = p.Item2;
while (x < 0) x += lawn.GetLength(0);
while (y < 0) y += lawn.GetLength(1);
var newRow = (uint)((mowerState.Position.Item1 + x) % lawn.GetLength(0));
var newCol = (uint)((mowerState.Position.Item2 + y) % lawn.GetLength(1));
mowerState.Position = Tuple.Create(newRow, newCol);
mowerState.Energy = mowerState.Energy - 1;
lawn[newRow, newCol] = true;
return Tuple.Create(0, 0);
} else if (node.Symbol is InvokeFunction) {
var invokeNode = node as InvokeFunctionTreeNode;
// find the function definition for the invoke call
var functionDefinition = (from adf in adfs.Cast<DefunTreeNode>()
where adf.FunctionName == invokeNode.Symbol.FunctionName
select adf).Single();
// clone the function definition because we are replacing the argument nodes
functionDefinition = (DefunTreeNode)functionDefinition.Clone();
// find the argument tree nodes and their parents in the original function definition
// toList is necessary to prevent that newly inserted branches are iterated
var argumentCutPoints = (from parent in functionDefinition.IterateNodesPrefix()
from subtree in parent.Subtrees
where subtree is ArgumentTreeNode
select new { Parent = parent, Argument = subtree.Symbol as Argument, ChildIndex = parent.IndexOfSubtree(subtree) })
.ToList();
// replace all argument tree ndoes with the matching argument of the invoke node
foreach (var cutPoint in argumentCutPoints) {
cutPoint.Parent.RemoveSubtree(cutPoint.ChildIndex);
cutPoint.Parent.InsertSubtree(cutPoint.ChildIndex, (SymbolicExpressionTreeNode)invokeNode.GetSubtree(cutPoint.Argument.ArgumentIndex).Clone());
}
return EvaluateLawnMowerProgram(functionDefinition.GetSubtree(0), mowerState, lawn, adfs);
} else {
// try to parse as ephemeral random const with format: "x,y" (x, y in [0..32[)
int x, y;
var tokens = node.Symbol.Name.Split(',');
if (tokens.Length == 2 &&
int.TryParse(tokens[0], out x) &&
int.TryParse(tokens[1], out y)) {
return Tuple.Create(x, y);
} else {
throw new ArgumentException("Invalid symbol in the lawn mower program.");
}
}
}
private void FormatDivision(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
if (node.SubtreeCount == 1) {
strBuilder.Append("Divide[1, ");
FormatRecursively(node.GetSubtree(0), strBuilder);
strBuilder.Append("]");
} else {
strBuilder.Append("Divide[");
FormatRecursively(node.GetSubtree(0), strBuilder);
strBuilder.Append(", Times[");
FormatRecursively(node.GetSubtree(1), strBuilder);
for (int i = 2; i < node.SubtreeCount; i++) {
strBuilder.Append(",");
FormatRecursively(node.GetSubtree(i), strBuilder);
}
strBuilder.Append("]]");
}
}
private static List<CutPoint> SelectRandomArgumentBranches(ISymbolicExpressionTreeNode selectedRoot,
IRandom random,
double cutProbability,
int maxArguments) {
// breadth first determination of argument cut-off points
// we must make sure that we cut off all original argument nodes and that the number of new argument is smaller than the limit
List<CutPoint> argumentBranches = new List<CutPoint>();
if (selectedRoot is ArgumentTreeNode) {
argumentBranches.Add(new CutPoint(selectedRoot.Parent, selectedRoot));
return argumentBranches;
} else {
// get the number of argument nodes (which must be cut-off) in the sub-trees
var numberOfArgumentsInSubtrees = (from subtree in selectedRoot.Subtrees
let nArgumentsInTree = subtree.IterateNodesPrefix().OfType<ArgumentTreeNode>().Count()
select nArgumentsInTree).ToList();
// determine the minimal number of new argument nodes for each sub-tree
//if we exceed the maxArguments return the same cutpoint as the start cutpoint to create a ADF that returns only its argument
var minNewArgumentsForSubtrees = numberOfArgumentsInSubtrees.Select(x => x > 0 ? 1 : 0).ToList();
if (minNewArgumentsForSubtrees.Sum() > maxArguments) {
argumentBranches.Add(new CutPoint(selectedRoot.Parent, selectedRoot));
return argumentBranches;
}
// cut-off in the sub-trees in random order
var randomIndexes = (from index in Enumerable.Range(0, selectedRoot.Subtrees.Count())
select new { Index = index, OrderValue = random.NextDouble() })
.OrderBy(x => x.OrderValue)
.Select(x => x.Index);
foreach (var subtreeIndex in randomIndexes) {
var subtree = selectedRoot.GetSubtree(subtreeIndex);
minNewArgumentsForSubtrees[subtreeIndex] = 0;
// => cut-off at 0..n points somewhere in the current sub-tree
// determine the maximum number of new arguments that should be created in the branch
// as the maximum for the whole branch minus already added arguments minus minimal number of arguments still left
int maxArgumentsFromBranch = maxArguments - argumentBranches.Count - minNewArgumentsForSubtrees.Sum();
// when no argument is allowed from the current branch then we have to include the whole branch into the function
// otherwise: choose randomly wether to cut off immediately or wether to extend the function body into the branch
if (maxArgumentsFromBranch == 0) {
// don't cut at all => the whole sub-tree branch is included in the function body
// (we already checked ahead of time that there are no arguments left over in the subtree)
} else if (random.NextDouble() >= cutProbability) {
argumentBranches.AddRange(SelectRandomArgumentBranches(subtree, random, cutProbability, maxArgumentsFromBranch));
} else {
// cut-off at current sub-tree
argumentBranches.Add(new CutPoint(subtree.Parent, subtree));
}
}
return argumentBranches;
}
}
internal static string InterpretStat(ISymbolicExpressionTreeNode node) {
// must only have one sub-tree
Contract.Assert(node.SubtreeCount == 1);
return Interpret(node.GetSubtree(0)) + " ;" + Environment.NewLine;
}
private string FormatRecursively(ISymbolicExpressionTreeNode node) {
ISymbol symbol = node.Symbol;
StringBuilder stringBuilder = new StringBuilder();
if (symbol is ProgramRootSymbol) {
stringBuilder.AppendLine(FormatRecursively(node.GetSubtree(0)));
} else if (symbol is StartSymbol)
return FormatRecursively(node.GetSubtree(0));
else if (symbol is Addition) {
stringBuilder.Append("(");
for (int i = 0; i < node.SubtreeCount; i++) {
if (i > 0) stringBuilder.Append("+");
stringBuilder.Append(FormatRecursively(node.GetSubtree(i)));
}
stringBuilder.Append(")");
} else if (symbol is Average) {
stringBuilder.Append("(1/");
stringBuilder.Append(node.SubtreeCount);
stringBuilder.Append(")*(");
for (int i = 0; i < node.SubtreeCount; i++) {
if (i > 0) stringBuilder.Append("+");
stringBuilder.Append("(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(i)));
stringBuilder.Append(")");
}
stringBuilder.Append(")");
} else if (symbol is Constant) {
ConstantTreeNode constantTreeNode = node as ConstantTreeNode;
stringBuilder.Append(constantTreeNode.Value.ToString(CultureInfo.InvariantCulture));
} else if (symbol is Cosine) {
stringBuilder.Append("COS(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
} else if (symbol is Division) {
if (node.SubtreeCount == 1) {
stringBuilder.Append("1/");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
} else {
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append("/(");
for (int i = 1; i < node.SubtreeCount; i++) {
if (i > 1) stringBuilder.Append("*");
stringBuilder.Append(FormatRecursively(node.GetSubtree(i)));
}
stringBuilder.Append(")");
}
} else if (symbol is Exponential) {
stringBuilder.Append("EXP(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
} else if (symbol is Square) {
stringBuilder.Append("POWER(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(",2)");
} else if (symbol is SquareRoot) {
stringBuilder.Append("SQRT(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
} else if (symbol is Logarithm) {
stringBuilder.Append("LN(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
} else if (symbol is Multiplication) {
for (int i = 0; i < node.SubtreeCount; i++) {
if (i > 0) stringBuilder.Append("*");
stringBuilder.Append(FormatRecursively(node.GetSubtree(i)));
}
} else if (symbol is Sine) {
stringBuilder.Append("SIN(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
} else if (symbol is Subtraction) {
stringBuilder.Append("(");
if (node.SubtreeCount == 1) {
stringBuilder.Append("-");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
} else {
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
for (int i = 1; i < node.SubtreeCount; i++) {
stringBuilder.Append("-");
stringBuilder.Append(FormatRecursively(node.GetSubtree(i)));
}
}
stringBuilder.Append(")");
} else if (symbol is Tangent) {
stringBuilder.Append("TAN(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
} else if (symbol is Variable) {
VariableTreeNode variableTreeNode = node as VariableTreeNode;
stringBuilder.Append(variableTreeNode.Weight.ToString(CultureInfo.InvariantCulture));
stringBuilder.Append("*");
stringBuilder.Append(GetColumnToVariableName(variableTreeNode.VariableName));// + LagToString(currentLag));
} else if (symbol is Power) {
stringBuilder.Append("POWER(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(",ROUND(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(1)));
stringBuilder.Append(",0))");
} else if (symbol is Root) {
stringBuilder.Append("(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")^(1 / ROUND(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(1)));
stringBuilder.Append(",0))");
} else if (symbol is IfThenElse) {
stringBuilder.Append("IF(");
stringBuilder.Append("(" + FormatRecursively(node.GetSubtree(0)) + " ) > 0");
stringBuilder.Append(",");
stringBuilder.Append(FormatRecursively(node.GetSubtree(1)));
stringBuilder.Append(",");
stringBuilder.Append(FormatRecursively(node.GetSubtree(2)));
stringBuilder.Append(")");
} else if (symbol is VariableCondition) {
VariableConditionTreeNode variableConditionTreeNode = node as VariableConditionTreeNode;
double threshold = variableConditionTreeNode.Threshold;
double slope = variableConditionTreeNode.Slope;
string p = "(1 / (1 + EXP(-" + slope.ToString(CultureInfo.InvariantCulture) + " * (" + GetColumnToVariableName(variableConditionTreeNode.VariableName) + "-" + threshold.ToString(CultureInfo.InvariantCulture) + "))))";
stringBuilder.Append("((");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append("*");
stringBuilder.Append(p);
stringBuilder.Append(") + (");
stringBuilder.Append(FormatRecursively(node.GetSubtree(1)));
stringBuilder.Append("*(");
stringBuilder.Append("1 - " + p + ")");
stringBuilder.Append("))");
} else if (symbol is Xor) {
stringBuilder.Append("IF(");
stringBuilder.Append("XOR(");
stringBuilder.Append("(" + FormatRecursively(node.GetSubtree(0)) + ") > 0,");
stringBuilder.Append("(" + FormatRecursively(node.GetSubtree(1)) + ") > 0");
stringBuilder.Append("), 1.0, -1.0)");
} else if (symbol is Or) {
stringBuilder.Append("IF(");
stringBuilder.Append("OR(");
stringBuilder.Append("(" + FormatRecursively(node.GetSubtree(0)) + ") > 0,");
stringBuilder.Append("(" + FormatRecursively(node.GetSubtree(1)) + ") > 0");
stringBuilder.Append("), 1.0, -1.0)");
} else if (symbol is And) {
stringBuilder.Append("IF(");
stringBuilder.Append("AND(");
stringBuilder.Append("(" + FormatRecursively(node.GetSubtree(0)) + ") > 0,");
stringBuilder.Append("(" + FormatRecursively(node.GetSubtree(1)) + ") > 0");
stringBuilder.Append("), 1.0, -1.0)");
} else if (symbol is Not) {
stringBuilder.Append("IF(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(" > 0, -1.0, 1.0)");
} else if (symbol is GreaterThan) {
stringBuilder.Append("IF((");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(") > (");
stringBuilder.Append(FormatRecursively(node.GetSubtree(1)));
stringBuilder.Append("), 1.0, -1.0)");
} else if (symbol is LessThan) {
stringBuilder.Append("IF((");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(") < (");
stringBuilder.Append(FormatRecursively(node.GetSubtree(1)));
stringBuilder.Append("), 1.0, -1.0)");
} else {
throw new NotImplementedException("Excel export of " + node.Symbol + " is not implemented.");
}
return stringBuilder.ToString();
}
internal static string InterpretWhile(ISymbolicExpressionTreeNode node) {
var cond = Interpret(node.GetSubtree(0));
var body = Interpret(node.GetSubtree(1));
return string.Format("while ({0}) {{ {2} {1} {2} }} {2}", cond, body, Environment.NewLine);
}
private void FormatIf(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
strBuilder.Append("If[Greater[");
FormatRecursively(node.GetSubtree(0), strBuilder);
strBuilder.Append(", 0], ");
FormatRecursively(node.GetSubtree(1), strBuilder);
strBuilder.Append(", ");
FormatRecursively(node.GetSubtree(2), strBuilder);
strBuilder.Append("]");
}
public static string InterpretComparison(string compSy, ISymbolicExpressionTreeNode node) {
ISymbolicExpressionTreeNode lhs = null, rhs = null;
if (node.SubtreeCount != 2)
throw new ArgumentException(string.Format("Expected exactly two children in {0}.", node.Symbol), "node");
lhs = node.GetSubtree(0);
rhs = node.GetSubtree(1);
return Interpret(lhs) + compSy + Interpret(rhs);
}
private void FormatAverage(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
// mean function needs a list of values
strBuilder.Append("Mean[{");
FormatRecursively(node.GetSubtree(0), strBuilder);
for (int i = 1; i < node.SubtreeCount; i++) {
strBuilder.Append(",");
FormatRecursively(node.GetSubtree(i), strBuilder);
}
strBuilder.Append("}]");
}
private string FormatRecursively(ISymbolicExpressionTreeNode node) {
ISymbol symbol = node.Symbol;
StringBuilder stringBuilder = new StringBuilder();
if (symbol is ProgramRootSymbol) {
stringBuilder.AppendLine(FormatRecursively(node.GetSubtree(0)));
} else if (symbol is StartSymbol)
return FormatRecursively(node.GetSubtree(0));
else if (symbol is Addition) {
stringBuilder.Append("(");
for (int i = 0; i < node.SubtreeCount; i++) {
if (i > 0) stringBuilder.Append("+");
stringBuilder.Append(FormatRecursively(node.GetSubtree(i)));
}
stringBuilder.Append(")");
} else if (symbol is And) {
stringBuilder.Append("((");
for (int i = 0; i < node.SubtreeCount; i++) {
if (i > 0) stringBuilder.Append("&");
stringBuilder.Append("((");
stringBuilder.Append(FormatRecursively(node.GetSubtree(i)));
stringBuilder.Append(")>0)");
}
stringBuilder.Append(")-0.5)*2");
// MATLAB maps false and true to 0 and 1, resp., we map this result to -1.0 and +1.0, resp.
} else if (symbol is Average) {
stringBuilder.Append("(1/");
stringBuilder.Append(node.SubtreeCount);
stringBuilder.Append(")*(");
for (int i = 0; i < node.SubtreeCount; i++) {
if (i > 0) stringBuilder.Append("+");
stringBuilder.Append("(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(i)));
stringBuilder.Append(")");
}
stringBuilder.Append(")");
} else if (symbol is Constant) {
ConstantTreeNode constantTreeNode = node as ConstantTreeNode;
stringBuilder.Append(constantTreeNode.Value.ToString(CultureInfo.InvariantCulture));
} else if (symbol is Cosine) {
stringBuilder.Append("cos(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
} else if (symbol is Division) {
if (node.SubtreeCount == 1) {
stringBuilder.Append("1/");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
} else {
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append("/(");
for (int i = 1; i < node.SubtreeCount; i++) {
if (i > 1) stringBuilder.Append("*");
stringBuilder.Append(FormatRecursively(node.GetSubtree(i)));
}
stringBuilder.Append(")");
}
} else if (symbol is Exponential) {
stringBuilder.Append("exp(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
} else if (symbol is Square) {
stringBuilder.Append("(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(").^2");
} else if (symbol is SquareRoot) {
stringBuilder.Append("sqrt(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
} else if (symbol is GreaterThan) {
stringBuilder.Append("((");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(">");
stringBuilder.Append(FormatRecursively(node.GetSubtree(1)));
stringBuilder.Append(")-0.5)*2");
// MATLAB maps false and true to 0 and 1, resp., we map this result to -1.0 and +1.0, resp.
} else if (symbol is IfThenElse) {
stringBuilder.Append("(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(">0)*");
stringBuilder.Append(FormatRecursively(node.GetSubtree(1)));
stringBuilder.Append("+");
stringBuilder.Append("(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append("<=0)*");
stringBuilder.Append(FormatRecursively(node.GetSubtree(2)));
} else if (symbol is LaggedVariable) {
// this if must be checked before if(symbol is LaggedVariable)
LaggedVariableTreeNode laggedVariableTreeNode = node as LaggedVariableTreeNode;
stringBuilder.Append(laggedVariableTreeNode.Weight.ToString(CultureInfo.InvariantCulture));
stringBuilder.Append("*");
stringBuilder.Append(laggedVariableTreeNode.VariableName +
LagToString(currentLag + laggedVariableTreeNode.Lag));
} else if (symbol is LessThan) {
stringBuilder.Append("((");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append("<");
stringBuilder.Append(FormatRecursively(node.GetSubtree(1)));
stringBuilder.Append(")-0.5)*2");
// MATLAB maps false and true to 0 and 1, resp., we map this result to -1.0 and +1.0, resp.
} else if (symbol is Logarithm) {
stringBuilder.Append("log_(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
} else if (symbol is Multiplication) {
for (int i = 0; i < node.SubtreeCount; i++) {
if (i > 0) stringBuilder.Append("*");
stringBuilder.Append(FormatRecursively(node.GetSubtree(i)));
}
} else if (symbol is Not) {
stringBuilder.Append("~(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(" > 0 )");
} else if (symbol is Or) {
stringBuilder.Append("((");
for (int i = 0; i < node.SubtreeCount; i++) {
if (i > 0) stringBuilder.Append("|");
stringBuilder.Append("((");
stringBuilder.Append(FormatRecursively(node.GetSubtree(i)));
stringBuilder.Append(")>0)");
}
stringBuilder.Append(")-0.5)*2");
// MATLAB maps false and true to 0 and 1, resp., we map this result to -1.0 and +1.0, resp.
} else if (symbol is Sine) {
stringBuilder.Append("sin(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
} else if (symbol is Subtraction) {
stringBuilder.Append("(");
if (node.SubtreeCount == 1) {
stringBuilder.Append("-");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
} else {
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
for (int i = 1; i < node.SubtreeCount; i++) {
stringBuilder.Append("-");
stringBuilder.Append(FormatRecursively(node.GetSubtree(i)));
}
}
stringBuilder.Append(")");
} else if (symbol is Tangent) {
stringBuilder.Append("tan(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
} else if (node.Symbol is AiryA) {
stringBuilder.Append("airy(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
} else if (node.Symbol is AiryB) {
stringBuilder.Append("airy(2, ");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
} else if (node.Symbol is Bessel) {
stringBuilder.Append("besseli(0.0,");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
} else if (node.Symbol is CosineIntegral) {
stringBuilder.Append("cosint(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
} else if (node.Symbol is Dawson) {
stringBuilder.Append("dawson(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
} else if (node.Symbol is Erf) {
stringBuilder.Append("erf(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
} else if (node.Symbol is ExponentialIntegralEi) {
stringBuilder.Append("expint(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
} else if (node.Symbol is FresnelCosineIntegral) {
stringBuilder.Append("FresnelC(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
} else if (node.Symbol is FresnelSineIntegral) {
stringBuilder.Append("FresnelS(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
} else if (node.Symbol is Gamma) {
stringBuilder.Append("gamma(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
} else if (node.Symbol is HyperbolicCosineIntegral) {
stringBuilder.Append("Chi(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
} else if (node.Symbol is HyperbolicSineIntegral) {
stringBuilder.Append("Shi(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
} else if (node.Symbol is Norm) {
stringBuilder.Append("normpdf(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
} else if (node.Symbol is Psi) {
stringBuilder.Append("psi(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
} else if (node.Symbol is SineIntegral) {
stringBuilder.Append("sinint(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
} else if (symbol is HeuristicLab.Problems.DataAnalysis.Symbolic.Variable) {
VariableTreeNode variableTreeNode = node as VariableTreeNode;
stringBuilder.Append(variableTreeNode.Weight.ToString(CultureInfo.InvariantCulture));
stringBuilder.Append("*");
stringBuilder.Append(variableTreeNode.VariableName + LagToString(currentLag));
} else if (symbol is Power) {
stringBuilder.Append("(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")^round(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(1)));
stringBuilder.Append(")");
} else if (symbol is Root) {
stringBuilder.Append("(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")^(1 / round(");
stringBuilder.Append(FormatRecursively(node.GetSubtree(1)));
stringBuilder.Append("))");
} else if (symbol is Derivative) {
stringBuilder.Append("fivePoint(");
// f0
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(", ");
// f1
currentLag--;
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(", ");
// f3
currentLag -= 2;
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(", ");
currentLag--;
// f4
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
stringBuilder.Append(")");
currentLag += 4;
} else if (symbol is Integral) {
var laggedNode = node as LaggedTreeNode;
string prevCounterVariable = CurrentIndexVariable;
string counterVariable = AllocateIndexVariable();
stringBuilder.AppendLine(" sum (map(@(" + counterVariable + ") " + FormatRecursively(node.GetSubtree(0)) +
", (" + prevCounterVariable + "+" + laggedNode.Lag + "):" + prevCounterVariable +
"))");
ReleaseIndexVariable();
} else if (symbol is TimeLag) {
var laggedNode = node as LaggedTreeNode;
currentLag += laggedNode.Lag;
stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
currentLag -= laggedNode.Lag;
} else {
stringBuilder.Append("ERROR");
}
return stringBuilder.ToString();
}
private void FormatSubtraction(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
strBuilder.Append("Subtract[");
FormatRecursively(node.GetSubtree(0), strBuilder);
strBuilder.Append(", Times[-1");
foreach (var t in node.Subtrees) {
strBuilder.Append(",");
FormatRecursively(t, strBuilder);
}
strBuilder.Append("]]");
}
/// <summary>
/// 1. find a mutation point
/// 2. generate new random tree
/// 3. calculate semantic of old and new subtree (or of the closest parent)
/// 4. do mutation if semantically different
/// 5. retry until a certain number of tries is reached
///
/// if no mutation has happened, do random mutation
/// </summary>
public static void ReplaceSemanticallyDifferentBranch(IRandom random, ISymbolicExpressionTree symbolicExpressionTree, ICFGPythonProblemData problemData, ItemArray <PythonStatementSemantic> semantics, PythonProcess pythonProcess, double timeout, int maxTreeLength, int maxTreeDepth, int maximumSemanticTries)
{
if (semantics == null || semantics.Length == 0)
{
ReplaceBranchManipulation.ReplaceRandomBranch(random, symbolicExpressionTree, maxTreeLength, maxTreeDepth);
return;
}
var statementProductionNames = SemanticOperatorHelper.GetSemanticProductionNames(symbolicExpressionTree.Root.Grammar);
var variables = problemData.Variables.GetVariableNames().ToList();
string variableSettings = problemData.VariableSettings.Count == 0 ? String.Empty : String.Join(Environment.NewLine, problemData.VariableSettings.Select(x => x.Value));
var allowedSymbols = new List <ISymbol>();
// repeat until a fitting parent and child are found (MAX_TRIES times)
int tries = 0;
int semanticTries = 0;
do
{
#region find mutation point
#pragma warning disable 612, 618
ISymbolicExpressionTreeNode parent = symbolicExpressionTree.Root.IterateNodesPrefix().Skip(1).Where(n => n.SubtreeCount > 0).SelectRandom(random);
#pragma warning restore 612, 618
int childIndex = random.Next(parent.SubtreeCount);
var child = parent.GetSubtree(childIndex);
int maxLength = maxTreeLength - symbolicExpressionTree.Length + child.GetLength();
int maxDepth = maxTreeDepth - symbolicExpressionTree.Root.GetBranchLevel(child);
allowedSymbols.Clear();
foreach (var symbol in parent.Grammar.GetAllowedChildSymbols(parent.Symbol, childIndex))
{
// check basic properties that the new symbol must have
if ((symbol.Name != child.Symbol.Name || symbol.MinimumArity > 0) &&
symbol.InitialFrequency > 0 &&
parent.Grammar.GetMinimumExpressionDepth(symbol) <= maxDepth &&
parent.Grammar.GetMinimumExpressionLength(symbol) <= maxLength)
{
allowedSymbols.Add(symbol);
}
}
#endregion
#region check for semantic difference with a new random tree
if (allowedSymbols.Count > 0)
{
if (semanticTries <= maximumSemanticTries)
{
// do semantic mutation
#region calculate original json output
ISymbolicExpressionTreeNode statement = SemanticOperatorHelper.GetStatementNode(child, statementProductionNames);
var statementPos0 = symbolicExpressionTree.IterateNodesPrefix().ToList().IndexOf(statement);
if (String.IsNullOrEmpty(variableSettings))
{
variableSettings = SemanticOperatorHelper.SemanticToPythonVariableSettings(semantics.First(x => x.TreeNodePrefixPos == statementPos0).Before, problemData.Variables.GetVariableTypes());
}
var jsonOriginal = SemanticOperatorHelper.EvaluateStatementNode(statement, pythonProcess, random, problemData, variables, variableSettings, timeout);
#endregion
var seedNode = GenerateAndInsertNewSubtree(random, parent, allowedSymbols, childIndex, maxLength, maxDepth);
#region calculate new json output
JObject jsonReplaced;
if (child == statement)
{
// child is executable, so is the new child
jsonReplaced = SemanticOperatorHelper.EvaluateStatementNode(seedNode, pythonProcess, random, problemData, variables, variableSettings, timeout);
}
else
{
jsonReplaced = SemanticOperatorHelper.EvaluateStatementNode(statement, pythonProcess, random, problemData, variables, variableSettings, timeout);
}
if (JToken.EqualityComparer.Equals(jsonOriginal, jsonReplaced))
{
// semantically equivalent. undo mutation
parent.RemoveSubtree(childIndex);
parent.InsertSubtree(childIndex, child);
allowedSymbols.Clear();
}
else
{
Console.WriteLine("never happens?");
}
if (problemData.VariableSettings.Count == 0)
{
// reset variableSettings
variableSettings = String.Empty;
}
semanticTries++;
#endregion
}
else
{
// do random mutation
GenerateAndInsertNewSubtree(random, parent, allowedSymbols, childIndex, maxLength, maxDepth);
}
}
#endregion
tries++;
} while (tries < MAX_TRIES && allowedSymbols.Count == 0 && semanticTries <= maximumSemanticTries);
}
private void FormatRecursively(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
if (node.SubtreeCount > 1) {
var token = GetToken(node.Symbol);
if (token == "+" || token == "-" || token == "OR" || token == "XOR") {
strBuilder.Append("(");
FormatRecursively(node.Subtrees.First(), strBuilder);
foreach (var subtree in node.Subtrees.Skip(1)) {
strBuilder.Append(" ").Append(token).Append(" ");
FormatRecursively(subtree, strBuilder);
}
strBuilder.Append(")");
} else if (token == "*" || token == "/" || token == "AND") {
strBuilder.Append("(");
FormatRecursively(node.Subtrees.First(), strBuilder);
foreach (var subtree in node.Subtrees.Skip(1)) {
strBuilder.Append(" ").Append(token).Append(" ");
FormatRecursively(subtree, strBuilder);
}
strBuilder.Append(")");
}
} else if (node.SubtreeCount == 1) {
var token = GetToken(node.Symbol);
if (token == "-" || token == "NOT") {
strBuilder.Append("(").Append(token).Append("(");
FormatRecursively(node.GetSubtree(0), strBuilder);
strBuilder.Append("))");
} else if (token == "/") {
strBuilder.Append("1/");
FormatRecursively(node.GetSubtree(0), strBuilder);
} else if (token == "+" || token == "*") {
FormatRecursively(node.GetSubtree(0), strBuilder);
} else {
// function
strBuilder.Append(token).Append("(");
FormatRecursively(node.GetSubtree(0), strBuilder);
strBuilder.Append(")");
}
} else {
// no subtrees
if (node.Symbol is Variable) {
var varNode = node as VariableTreeNode;
if (!varNode.Weight.IsAlmost(1.0)) {
strBuilder.Append("(");
strBuilder.AppendFormat(CultureInfo.InvariantCulture, "{0}", varNode.Weight);
strBuilder.Append("*");
}
if (varNode.VariableName.Contains("'")) {
strBuilder.AppendFormat("\"{0}\"", varNode.VariableName);
} else {
strBuilder.AppendFormat("'{0}'", varNode.VariableName);
}
if (!varNode.Weight.IsAlmost(1.0)) {
strBuilder.Append(")");
}
} else if (node.Symbol is Constant) {
var constNode = node as ConstantTreeNode;
if (constNode.Value >= 0.0)
strBuilder.AppendFormat(CultureInfo.InvariantCulture, "{0}", constNode.Value);
else
strBuilder.AppendFormat(CultureInfo.InvariantCulture, "({0})", constNode.Value); // (-1)
}
}
}
