private string FormatRecursively(ISymbolicExpressionTreeNode node, int indentLength)
{
StringBuilder strBuilder = new StringBuilder();
if (Indent)
{
strBuilder.Append(' ', indentLength);
}
strBuilder.Append("(");
// internal nodes or leaf nodes?
if (node.Subtrees.Count() > 0)
{
// symbol on same line as '('
strBuilder.AppendLine(node.ToString());
// each subtree expression on a new line
// and closing ')' also on new line
foreach (var subtree in node.Subtrees)
{
strBuilder.AppendLine(FormatRecursively(subtree, indentLength + 2));
}
if (Indent)
{
strBuilder.Append(' ', indentLength);
}
strBuilder.Append(")");
}
else
{
// symbol in the same line with as '(' and ')'
strBuilder.Append(node.ToString());
strBuilder.Append(")");
}
return(strBuilder.ToString());
}
private string FormatRecursively(ISymbolicExpressionTreeNode node, int indentLength, ref int nodeId) {
// save id of current node
int currentNodeId = nodeId;
// increment id for next node
nodeId++;
StringBuilder strBuilder = new StringBuilder();
if (Indent) strBuilder.Append(' ', indentLength);
// get label for node and map if necessary
string nodeLabel = node.ToString();
if (symbolNameMap.ContainsKey(nodeLabel)) {
nodeLabel = symbolNameMap[nodeLabel];
}
strBuilder.Append("node" + currentNodeId + "[label=\"" + nodeLabel + "\"");
// leaf nodes should have box shape
if (node.SubtreeCount == 0) {
strBuilder.AppendLine(", shape=\"box\"];");
} else {
strBuilder.AppendLine("];");
}
// internal nodes or leaf nodes?
foreach (ISymbolicExpressionTreeNode subTree in node.Subtrees) {
// add an edge
if (Indent) strBuilder.Append(' ', indentLength);
strBuilder.AppendLine("node" + currentNodeId + " -- node" + nodeId + ";");
// format the whole subtree
strBuilder.Append(FormatRecursively(subTree, indentLength + 2, ref nodeId));
}
return strBuilder.ToString();
}
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());
}
public static int CompareNodes(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b) {
var ta = a as SymbolicExpressionTreeTerminalNode;
var tb = b as SymbolicExpressionTreeTerminalNode;
if (ta == null)
return tb == null ? String.CompareOrdinal(a.Symbol.Name, b.Symbol.Name) : -1;
if (tb == null)
return 1;
// at this point we know a and b are both terminals
var va = a as VariableTreeNode;
var vb = b as VariableTreeNode;
if (va != null)
return vb == null ? -1 : CompareVariables(va, vb);
if (vb != null)
return 1;
// at this point we know a and b are not variables
var ca = a as ConstantTreeNode;
var cb = b as ConstantTreeNode;
if (ca != null && cb != null)
return ca.Value.CompareTo(cb.Value);
// for other unknown terminal types, compare strings
return string.CompareOrdinal(a.ToString(), b.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 FormatRecursively(ISymbolicExpressionTreeNode node) {
StringBuilder strBuilder = new StringBuilder();
if (node.Subtrees.Count() > 0) {
// node
foreach (var subtree in node.Subtrees) {
strBuilder.Append(FormatRecursively(subtree));
}
} else {
// leaf
strBuilder.Append(node.ToString());
}
return strBuilder.ToString();
}
private string FormatRecursively(ISymbolicExpressionTreeNode node, int indentLength) {
StringBuilder strBuilder = new StringBuilder();
if (Indent) strBuilder.Append(' ', indentLength);
strBuilder.Append("(");
// internal nodes or leaf nodes?
if (node.Subtrees.Count() > 0) {
// symbol on same line as '('
strBuilder.AppendLine(node.ToString());
// each subtree expression on a new line
// and closing ')' also on new line
foreach (var subtree in node.Subtrees) {
strBuilder.AppendLine(FormatRecursively(subtree, indentLength + 2));
}
if (Indent) strBuilder.Append(' ', indentLength);
strBuilder.Append(")");
} else {
// symbol in the same line with as '(' and ')'
strBuilder.Append(node.ToString());
strBuilder.Append(")");
}
return strBuilder.ToString();
}
private string FormatRecursively(ISymbolicExpressionTreeNode node, int indentLength, ref int nodeId)
{
// save id of current node
int currentNodeId = nodeId;
// increment id for next node
nodeId++;
StringBuilder strBuilder = new StringBuilder();
if (Indent)
{
strBuilder.Append(' ', indentLength);
}
// get label for node and map if necessary
string nodeLabel = node.ToString();
if (symbolNameMap.ContainsKey(nodeLabel))
{
nodeLabel = symbolNameMap[nodeLabel];
}
strBuilder.Append("node" + currentNodeId + "[label=\"" + nodeLabel + "\"");
// leaf nodes should have box shape
if (node.SubtreeCount == 0)
{
strBuilder.AppendLine(", shape=\"box\"];");
}
else
{
strBuilder.AppendLine("];");
}
// internal nodes or leaf nodes?
foreach (ISymbolicExpressionTreeNode subTree in node.Subtrees)
{
// add an edge
if (Indent)
{
strBuilder.Append(' ', indentLength);
}
strBuilder.AppendLine("node" + currentNodeId + " -- node" + nodeId + ";");
// format the whole subtree
strBuilder.Append(FormatRecursively(subTree, indentLength + 2, ref nodeId));
}
return(strBuilder.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 string GetLabel(ISymbolicExpressionTreeNode node)
{
if (node.SubtreeCount > 0)
{
return(node.Symbol.Name);
}
if (node is ConstantTreeNode constant)
{
return(MatchConstantValues ? constant.Value.ToString(CultureInfo.InvariantCulture) : constant.Symbol.Name);
}
if (node is VariableTreeNode variable)
{
return(MatchVariableWeights ? variable.Weight + variable.VariableName : variable.VariableName);
}
return(node.ToString());
}
private static string FormatRecursively(ISymbolicExpressionTreeNode node)
{
StringBuilder strBuilder = new StringBuilder();
if (node.Subtrees.Count() > 0)
{
// node
foreach (var subtree in node.Subtrees)
{
strBuilder.Append(FormatRecursively(subtree));
}
}
else
{
// leaf
strBuilder.Append(node.ToString());
}
return(strBuilder.ToString());
}
public static int CompareNodes(ISymbolicExpressionTreeNode a, ISymbolicExpressionTreeNode b)
{
var ta = a as SymbolicExpressionTreeTerminalNode;
var tb = b as SymbolicExpressionTreeTerminalNode;
if (ta == null)
{
return(tb == null?String.CompareOrdinal(a.Symbol.Name, b.Symbol.Name) : -1);
}
if (tb == null)
{
return(1);
}
// at this point we know a and b are both terminals
var va = a as VariableTreeNode;
var vb = b as VariableTreeNode;
if (va != null)
{
return(vb == null ? -1 : CompareVariables(va, vb));
}
if (vb != null)
{
return(1);
}
// at this point we know a and b are not variables
var ca = a as ConstantTreeNode;
var cb = b as ConstantTreeNode;
if (ca != null && cb != null)
{
return(ca.Value.CompareTo(cb.Value));
}
// for other unknown terminal types, compare strings
return(string.CompareOrdinal(a.ToString(), b.ToString()));
}
private static string GetLabel(ISymbolicExpressionTreeNode node)
{
if (node.SubtreeCount > 0)
{
return(node.Symbol.Name);
}
var constant = node as ConstantTreeNode;
if (constant != null)
{
return(constant.Value.ToString(CultureInfo.InvariantCulture));
}
var variable = node as VariableTreeNode;
if (variable != null)
{
return(variable.Weight + variable.VariableName);
}
return(node.ToString());
}
public int GetHashCode(ISymbolicExpressionTreeNode n) {
return n.ToString().ToLower().GetHashCode();
}
public int GetHashCode(ISymbolicExpressionTreeNode n)
{
return(n.ToString().ToLower().GetHashCode());
}
private static string GetLabel(ISymbolicExpressionTreeNode node) {
if (node.SubtreeCount > 0)
return node.Symbol.Name;
var constant = node as ConstantTreeNode;
if (constant != null)
return constant.Value.ToString(CultureInfo.InvariantCulture);
var variable = node as VariableTreeNode;
if (variable != null)
return variable.Weight + variable.VariableName;
return node.ToString();
}
