public static Node BuildTree(Node node, Dictionary <int, Node> matchings, Rule[] Ruleset)
{
if (node is PatternNode)
{
PatternNode patternNode = node as PatternNode;
Node toret = matchings[patternNode.Key];
Simplify(Ruleset, ref toret);
return(toret);
}
else if (node is UniaryOperatorNode)
{
UniaryOperatorNode uniOp = node as UniaryOperatorNode;
Node left = BuildTree(uniOp.Left, matchings, Ruleset);
Simplify(Ruleset, ref left);
return(new UniaryOperatorNode(uniOp.Operator, left));
}
else if (node is BinaryOperatorNode)
{
BinaryOperatorNode binOp = node as BinaryOperatorNode;
Node right = BuildTree(binOp.Left, matchings, Ruleset);
Simplify(Ruleset, ref right);
Node left = BuildTree(binOp.Right, matchings, Ruleset);
Simplify(Ruleset, ref left);
return(new BinaryOperatorNode(binOp.Operator, right, left));
}
return(node.Clone() as Node);
}
public static List <Tuple <Node, LinearChildTag> > LinearChildren(Node node, BinaryOperator @operator, BinaryOperator inverse)
{
List <Tuple <Node, LinearChildTag> > results = new List <Tuple <Node, LinearChildTag> >();
if (node is BinaryOperatorNode)
{
BinaryOperatorNode binOp = node as BinaryOperatorNode;
if (binOp.Operator == @operator || binOp.Operator == inverse)
{
results.AddRange(LinearChildren(binOp.Left, @operator, inverse));
if (binOp.Operator == @operator)
{
results.AddRange(LinearChildren(binOp.Right, @operator, inverse));
}
else
{
results.AddRange(InvertResults(LinearChildren(binOp.Right, @operator, inverse)));
}
}
else
{
results.Add(new Tuple <Node, LinearChildTag>(node, LinearChildTag.Keep));
}
}
else if (node is UniaryOperatorNode)
{
UniaryOperatorNode uniOp = node as UniaryOperatorNode;
if (uniOp.Operator == UniaryOperator.Negate && inverse == BinaryOperator.Subtract)
{
results.AddRange(InvertResults(LinearChildren(uniOp.Left, @operator, inverse)));
}
else if (uniOp.Operator == UniaryOperator.Negate && @operator == BinaryOperator.Multiply)
{
results.Add(new Tuple <Node, LinearChildTag>(1, LinearChildTag.Keep));
results.AddRange(LinearChildren(uniOp.Left, @operator, inverse));
}
else
{
results.Add(new Tuple <Node, LinearChildTag>(uniOp, LinearChildTag.Keep));
}
}
else
{
results.Add(new Tuple <Node, LinearChildTag>(node, LinearChildTag.Keep));
}
return(results);
}