public Node Clone() { Node newNode = null; if (this is OperatorNode) { OperatorNode oldOperatorNode = (OperatorNode)this; newNode = new OperatorNode(); OperatorNode newOperatorNode = (OperatorNode)newNode; newOperatorNode.Operator = oldOperatorNode.Operator; foreach (Node child in oldOperatorNode.Children) { Node newChild = child.Clone(); newChild.Parent = newOperatorNode; newOperatorNode.Children.Add(newChild); } } else if (this is NumericNode) { NumericNode oldNumericNode = (NumericNode)this; newNode = new NumericNode(); NumericNode newNumericNode = (NumericNode)newNode; newNumericNode.Number = oldNumericNode.Number; } else if (this is VariableNode) { VariableNode oldVariableNode = (VariableNode)this; newNode = new VariableNode(); VariableNode newVariableNode = (VariableNode)newNode; newVariableNode.Variable = oldVariableNode.Variable; newVariableNode.VariableNodeType = oldVariableNode.VariableNodeType; newVariableNode.Number = oldVariableNode.Number; } return(newNode); }
public static Node RemoveDoubleNegatives(Node inNode) { Node workNode = inNode; if (workNode is OperatorNode) { OperatorNode operatorNode = (OperatorNode)workNode; if (operatorNode.Operator.OperatorString == "-" && operatorNode.Operator.OperatorType == OperatorType.Unary) { Node child = operatorNode.Children[0]; if (child is OperatorNode) { OperatorNode childOperatorNode = (OperatorNode)child; if (childOperatorNode.Operator.OperatorString == "-" && childOperatorNode.Operator.OperatorType == OperatorType.Unary) { workNode = childOperatorNode.Children[0]; } } else if (child is NumericNode) { NumericNode childNumericNode = (NumericNode)child; if (childNumericNode.Number < 0) { childNumericNode.Number *= -1; workNode = childNumericNode; } } } } List <Node> newChildren = new List <Node>(); foreach (Node child in workNode.Children) { Node newChild = RemoveDoubleNegatives(child); newChild.Parent = workNode; newChildren.Add(newChild); } workNode.Children = newChildren; return(workNode); }
public static Node ParseNewEnclosing(string inExpression, out bool foundOperator, List <Operator> operators) { foundOperator = false; int openingBracketLocation = inExpression.IndexOf('('); int closingBracketLocation = inExpression.Length - 1; if (inExpression.Substring(closingBracketLocation, 1) != ")") { return(null); } if (openingBracketLocation >= 0) { foundOperator = true; string keyword = inExpression.Substring(0, openingBracketLocation); string wholeOperands = inExpression.Substring(openingBracketLocation + 1, inExpression.Length - openingBracketLocation - 2); Operator commaOperator = new Operator(",", 0, OperatorType.Delimiting, null); List <int> bracketDepths = Node.BracketDepths(wholeOperands); bool foundOperator2 = false; List <string> operands = Node.ParseDelimiting(wholeOperands, commaOperator, bracketDepths, out foundOperator2); OperatorNode newNode = new OperatorNode(); Operator o = operators.FirstOrDefault(x => x.OperatorString == keyword); if (o == null) { o = new Operator(keyword, operators.Count, OperatorType.Enclosing, null); operators.Add(o); } newNode.Operator = o; foreach (string operand in operands) { Node childNode = Parse(operand, operators); childNode.Parent = newNode; newNode.Children.Add(childNode); } return(newNode); } return(null); }
public static string JoinNest(Node inNode, string useNumbers = "") { if (inNode is OperatorNode) { List <string> operandStrings = new List <string>(); OperatorNode operatorNode = (OperatorNode)inNode; string operatorString = operatorNode.Operator.OperatorString; foreach (Node child in inNode.Children) { string operandString = JoinNest(child, useNumbers); if (child is OperatorNode) { OperatorNode childOperatorNode = (OperatorNode)child; if (childOperatorNode.Operator.OperatorType == OperatorType.Delimiting) { string childOperatorString = childOperatorNode.Operator.OperatorString; if (operatorString == "-") { if (operatorNode.Children[0] != childOperatorNode && operatorNode.Operator.OperatorType == OperatorType.Delimiting) { if (childOperatorString == "+" || childOperatorString == "-") { operandString = "(" + operandString + ")"; } } else if (operatorNode.Operator.OperatorType == OperatorType.Unary) { if (childOperatorString == "+" || childOperatorString == "-" || childOperatorString == "," || childOperatorString == "=") { operandString = "(" + operandString + ")"; } } } else if (operatorString == "/") { if (childOperatorString == "+" || childOperatorString == "-" || childOperatorString == "," || childOperatorString == "=") { operandString = "(" + operandString + ")"; } else if (operatorNode.Children[0] != childOperatorNode) { if (childOperatorString == "*" || childOperatorString == "/") { operandString = "(" + operandString + ")"; } } } else if (operatorString == "*") { if (childOperatorString == "+" || childOperatorString == "-" || childOperatorString == "," || childOperatorString == "=") { operandString = "(" + operandString + ")"; } } else if (operatorString == "+") { if (childOperatorString == "," || childOperatorString == "=") { operandString = "(" + operandString + ")"; } } } } operandStrings.Add(operandString); } if (operatorNode.Operator.OperatorType == OperatorType.Delimiting) { string outString = string.Join(operatorNode.Operator.OperatorString, operandStrings.ToArray()); return(outString); } else if (operatorNode.Operator.OperatorType == OperatorType.Unary) { string outString = operatorNode.Operator.OperatorString + operandStrings[0]; return(outString); } else if (operatorNode.Operator.OperatorType == OperatorType.Enclosing) { string outString = operatorNode.Operator.OperatorString + "(" + string.Join(",", operandStrings.ToArray()) + ")"; return(outString); } } else if (inNode is VariableNode) { VariableNode variableNode = (VariableNode)inNode; if (useNumbers != "" && variableNode.Variable.Substring(0, useNumbers.Length) == useNumbers) { return(variableNode.Number.ToString().Trim()); } return(variableNode.Variable); } else if (inNode is NumericNode) { NumericNode numericNode = (NumericNode)inNode; return(numericNode.Number.ToString().Trim()); } return(null); }
public static Node Parse(string inExpression, List <Operator> operators) { //inExpression = RemoveEnclosingBrackets(inExpression); double number; if (double.TryParse(inExpression, out number)) { NumericNode numericNode = new NumericNode(); numericNode.Number = number; return(numericNode); } List <int> bracketDepths = BracketDepths(inExpression); bool foundOperator = false; foreach (Operator o in operators) { List <string> operands = null; if (o.OperatorType == OperatorType.Delimiting) { operands = ParseDelimiting(inExpression, o, bracketDepths, out foundOperator); } else if (o.OperatorType == OperatorType.Unary) { operands = ParseUnary(inExpression, o, out foundOperator); } else if (o.OperatorType == OperatorType.Enclosing) { operands = ParseEnclosing(inExpression, o, out foundOperator); } if (foundOperator) { OperatorNode operatorNode = new OperatorNode(); foreach (string operand in operands) { Node childNode = Parse(operand, operators); childNode.Parent = operatorNode; operatorNode.Children.Add(childNode); } operatorNode.Operator = o; return(operatorNode); } } Node newNode = ParseNewEnclosing(inExpression, out foundOperator, operators); if (foundOperator) { return(newNode); } VariableNode variableNode = new VariableNode(); variableNode.Variable = inExpression; if (inExpression.First() == 'C') { variableNode.VariableNodeType = VariableNodeType.RequireNumber; } else if (inExpression.First() == 'V') { variableNode.VariableNodeType = VariableNodeType.RequireVariable; } else { variableNode.VariableNodeType = VariableNodeType.NoRequirement; } return(variableNode); }