// numbes, constants, variables and brakets private ExpressionTreeNode ExprLevel6() { ExpressionTreeNode temp = null; switch (CurrentLexeme.Lexeme) { case Lexeme.Number: case Lexeme.Pi: case Lexeme.E: case Lexeme.Var: temp = new ExpressionTreeNode(CurrentLexeme, null, null); NextLexeme(); break; case Lexeme.LeftBracket: NextLexeme(); temp = ExprLevel1(); if (CurrentLexeme.Lexeme != Lexeme.RightBracket) { throw new ExpressionSyntaxException(") excepted", _expression, _parsedExpression); } NextLexeme(); break; } return(temp); }
private SortedList FindVariables(ExpressionTreeNode node) { SortedList list = new SortedList(); if (node.ExpressionLexeme.Lexeme == Lexeme.Var) { list.Add(node.ExpressionLexeme.LexemeName.ToLower(), ""); } if (node.Left != null) { foreach (DictionaryEntry e in FindVariables(node.Left)) { if (!list.ContainsKey(e.Key)) { list.Add(e.Key, e.Value); } } } if (node.Right != null) { foreach (DictionaryEntry e in FindVariables(node.Right)) { if (!list.ContainsKey(e.Key)) { list.Add(e.Key, e.Value); } } } return(list); }
// ^ operator private ExpressionTreeNode ExprLevel3() { ExpressionTreeNode temp = ExprLevel4(); ExpressionLexeme lex; while (true) { switch (CurrentLexeme.Lexeme) { case Lexeme.Power: if (temp == null) { throw new ExpressionSyntaxException("expression expected", _expression, _parsedExpression); } lex = CurrentLexeme; NextLexeme(); ExpressionTreeNode right = ExprLevel3(); if (right == null) { throw new ExpressionSyntaxException("expression expected", _expression, _parsedExpression); } temp = new ExpressionTreeNode(lex, temp, right); break; default: return(temp); } } }
// unary + - operators private ExpressionTreeNode ExprLevel4() { ExpressionTreeNode temp = null; ExpressionLexeme lex; switch (CurrentLexeme.Lexeme) { case Lexeme.Plus: NextLexeme(); temp = ExprLevel5(); break; case Lexeme.Minus: lex = new ExpressionLexeme("", Lexeme.UMinus); NextLexeme(); ExpressionTreeNode right = ExprLevel5(); if (right == null) { throw new ExpressionSyntaxException("expression expected", _expression, _parsedExpression); } temp = new ExpressionTreeNode(lex, right); break; default: temp = ExprLevel5(); break; } return(temp); }
// math functions private ExpressionTreeNode ExprLevel5() { ExpressionTreeNode temp = null; switch (CurrentLexeme.LexemeType) { case LexemeType.ltFunction: temp = new ExpressionTreeNode(CurrentLexeme, null, null); NextLexeme(); if (CurrentLexeme.Lexeme != Lexeme.LeftBracket) { throw new ExpressionSyntaxException("( excepted", _expression, _parsedExpression); } NextLexeme(); ExpressionTreeNode left = ExprLevel1(); if (left == null) { throw new ExpressionSyntaxException("expression expected", _expression, _parsedExpression); } temp.Left = left; if (CurrentLexeme.Lexeme != Lexeme.RightBracket) { throw new ExpressionSyntaxException(") excepted", _expression, _parsedExpression); } NextLexeme(); break; default: temp = ExprLevel6(); break; } return(temp); }
private void CreateTree(ExpressionLexeme[] lexemes) { _root = null; _lexemesQueue = new Queue (lexemes); NextLexeme(); _root = ExprLevel1(); if (CurrentLexeme.Lexeme != ExpressionLexeme.EndLexeme.Lexeme) throw new ExpressionSyntaxException("operator expected", _expression, _parsedExpression); }
private void CreateTree(ExpressionLexeme[] lexemes) { _root = null; _lexemesQueue = new Queue(lexemes); NextLexeme(); _root = ExprLevel1(); if (CurrentLexeme.Lexeme != ExpressionLexeme.EndLexeme.Lexeme) { throw new ExpressionSyntaxException("operator expected", _expression, _parsedExpression); } }
// * / operators private ExpressionTreeNode ExprLevel2() { ExpressionTreeNode temp = ExprLevel3(); ExpressionLexeme lex; while (true) switch (CurrentLexeme.Lexeme) { case Lexeme.Multiply: case Lexeme.Divide: if (temp == null) throw new ExpressionSyntaxException("expression expected", _expression, _parsedExpression); lex = CurrentLexeme; NextLexeme(); ExpressionTreeNode right = ExprLevel2(); if (right == null) throw new ExpressionSyntaxException("expression expected", _expression, _parsedExpression); temp = new ExpressionTreeNode(lex,temp,right); break; default: return temp; } }
private static string df(ExpressionTreeNode node, string diffVar) { if (!node.HasVariable(diffVar)) { return("0"); } bool leftDiffVar = (node.Left != null) && (node.Left.HasVariable(diffVar)); bool rightDiffVar = (node.Right != null) && (node.Right.HasVariable(diffVar)); switch (node.ExpressionLexeme.LexemeType) { case LexemeType.ltConstant: switch (node.ExpressionLexeme.Lexeme) { case Lexeme.Var: return("1"); default: return("0"); } case LexemeType.ltOperator: switch (node.ExpressionLexeme.Lexeme) { case Lexeme.Plus: case Lexeme.Minus: return(String.Format("({0}{1}{2})", df(node.Left, diffVar), node.ExpressionLexeme.LexemeName, df(node.Right, diffVar))); case Lexeme.UMinus: return(String.Format("(-({0}))", df(node.Left, diffVar))); case Lexeme.Multiply: return(String.Format("(({0})*({1})+({2})*({3}))", df(node.Left, diffVar), node.Right, df(node.Right, diffVar), node.Left)); case Lexeme.Divide: return(String.Format("(({0})*({1})-({2})*({3}))/({4})^2", df(node.Left, diffVar), node.Right, df(node.Right, diffVar), node.Left, node.Right)); case Lexeme.Power: // diff f(x)^g(y) if (leftDiffVar && !rightDiffVar) { return(String.Format("((({0})^({1})*({1})*({2}))/({0}))", node.Left, node.Right, df(node.Left, diffVar))); } // diff f(y)^g(x) if (!leftDiffVar && rightDiffVar) { return(String.Format("((({0})^({1}))*({2})*log({0})))", node.Left, node.Right, df(node.Right, diffVar))); } // diff f(x)^g(x) return(String.Format("((({0})^({1}))*(({3})*log({0})+({1})*({2})/({0})))", node.Left, node.Right, df(node.Left, diffVar), df(node.Right, diffVar))); default: throw new Exception(); } case LexemeType.ltFunction: return(String.Format("((" + node.ExpressionLexeme.LexemeDiffMask + ")*({1}))", node.Left, df(node.Left, diffVar))); default: throw new Exception(); } }
public ExpressionTreeNode(ExpressionLexeme lexeme, ExpressionTreeNode leftNode, ExpressionTreeNode rightNode) { ExpressionLexeme = lexeme; Left = leftNode; Right = rightNode; }
public ExpressionTreeNode(ExpressionLexeme lexeme, ExpressionTreeNode leftNode) : this(lexeme, leftNode, null) { }
// math functions private ExpressionTreeNode ExprLevel5() { ExpressionTreeNode temp = null; switch (CurrentLexeme.LexemeType) { case LexemeType.ltFunction: temp = new ExpressionTreeNode(CurrentLexeme,null,null); NextLexeme(); if (CurrentLexeme.Lexeme != Lexeme.LeftBracket) throw new ExpressionSyntaxException("( excepted", _expression, _parsedExpression); NextLexeme(); ExpressionTreeNode left = ExprLevel1(); if (left == null) throw new ExpressionSyntaxException("expression expected", _expression, _parsedExpression); temp.Left = left; if (CurrentLexeme.Lexeme != Lexeme.RightBracket) throw new ExpressionSyntaxException(") excepted", _expression, _parsedExpression); NextLexeme(); break; default: temp = ExprLevel6(); break; } return temp; }
private ExpressionTreeNode SimplifyNode(ExpressionTreeNode node) { if (node.Left != null) { node.Left = SimplifyNode(node.Left); } if (node.Right != null) { node.Right = SimplifyNode(node.Right); } bool l_null = node.Left == null; bool r_null = node.Right == null; bool l_number = !l_null && (node.Left.ExpressionLexeme.Lexeme == Lexeme.Number); bool r_number = !r_null && (node.Right.ExpressionLexeme.Lexeme == Lexeme.Number); double l_value = l_number ? double.Parse(node.Left.ExpressionLexeme.LexemeName) : 0; double r_value = r_number ? double.Parse(node.Right.ExpressionLexeme.LexemeName) : 0; bool l_zero = l_number && (l_value == 0); bool r_zero = r_number && (r_value == 0); bool l_one = l_number && (l_value == 1); bool r_one = r_number && (r_value == 1); switch (node.ExpressionLexeme.LexemeType) { case LexemeType.ltOperator: bool equal = (!l_null && !r_null) && (0 == String.Compare(node.Left.ToString(), node.Right.ToString())); switch (node.ExpressionLexeme.Lexeme) { case Lexeme.Multiply: if (l_zero || r_zero) { return(new ExpressionTreeNode( new ExpressionLexeme("0", Lexeme.Number))); } if (l_one) { return(node.Right); } if (r_one) { return(node.Left); } if (l_number && r_number) { return(new ExpressionTreeNode( new ExpressionLexeme(Convert.ToString(l_value * r_value), Lexeme.Number))); } break; case Lexeme.Divide: if (l_zero && !r_zero) { return(new ExpressionTreeNode(new ExpressionLexeme("0", Lexeme.Number))); } if (equal) { return(new ExpressionTreeNode(new ExpressionLexeme("1", Lexeme.Number))); } if (r_one) { return(node.Left); } if (l_number && r_number) { return(new ExpressionTreeNode( new ExpressionLexeme(Convert.ToString(l_value / r_value), Lexeme.Number))); } break; case Lexeme.Plus: if (l_zero) { return(node.Right); } if (r_zero) { return(node.Left); } if (l_number && r_number) { return(new ExpressionTreeNode( new ExpressionLexeme(Convert.ToString(l_value + r_value), Lexeme.Number))); } if (node.Right.ExpressionLexeme.Lexeme == Lexeme.UMinus) { return(new ExpressionTreeNode( new ExpressionLexeme("-", Lexeme.Minus), node.Left, node.Right.Left)); } break; case Lexeme.Minus: if (r_zero) { return(node.Left); } if (l_zero) { return(new ExpressionTreeNode( new ExpressionLexeme("-", Lexeme.UMinus), node.Right)); } if (equal) { return(new ExpressionTreeNode(new ExpressionLexeme("0", Lexeme.Number))); } if (l_number && r_number) { return(new ExpressionTreeNode( new ExpressionLexeme(Convert.ToString(l_value - r_value), Lexeme.Number))); } break; case Lexeme.UMinus: if (node.Left.ExpressionLexeme.Lexeme == Lexeme.UMinus) { return(node.Left.Left); } break; } break; } return(node); }
/// <summary>Simplifies binary tree of expression.</summary> /// <remarks> /// <para><strong>Simplify</strong> method removes all unneccessary nodes that can be /// simplifided. For example, expression "1+(x*0)" will be simplifided to "1" because (x*0) /// will always return zero.</para> /// <para>Other samples of simplification</para> /// <para>"0/x + x" -> "x"</para> /// <para>"x/x" -> "1"</para> /// </remarks> public void Simplify() { _root = SimplifyNode(_root); }
// numbes, constants, variables and brakets private ExpressionTreeNode ExprLevel6() { ExpressionTreeNode temp = null; switch (CurrentLexeme.Lexeme) { case Lexeme.Number: case Lexeme.Pi: case Lexeme.E: case Lexeme.Var: temp = new ExpressionTreeNode(CurrentLexeme,null,null); NextLexeme(); break; case Lexeme.LeftBracket: NextLexeme(); temp = ExprLevel1(); if (CurrentLexeme.Lexeme != Lexeme.RightBracket) throw new ExpressionSyntaxException(") excepted", _expression, _parsedExpression); NextLexeme(); break; } return temp; }
private SortedList FindVariables(ExpressionTreeNode node) { SortedList list = new SortedList(); if (node.ExpressionLexeme.Lexeme == Lexeme.Var) { list.Add(node.ExpressionLexeme.LexemeName.ToLower(),""); } if (node.Left != null) foreach(DictionaryEntry e in FindVariables(node.Left)) { if (!list.ContainsKey(e.Key)) list.Add(e.Key,e.Value); } if (node.Right != null) foreach(DictionaryEntry e in FindVariables(node.Right)) { if (!list.ContainsKey(e.Key)) list.Add(e.Key,e.Value); } return list; }
// unary + - operators private ExpressionTreeNode ExprLevel4() { ExpressionTreeNode temp = null; ExpressionLexeme lex; switch (CurrentLexeme.Lexeme) { case Lexeme.Plus: NextLexeme(); temp = ExprLevel5(); break; case Lexeme.Minus: lex = new ExpressionLexeme("",Lexeme.UMinus); NextLexeme(); ExpressionTreeNode right = ExprLevel5(); if (right == null) throw new ExpressionSyntaxException("expression expected", _expression, _parsedExpression); temp = new ExpressionTreeNode(lex,right); break; default: temp = ExprLevel5(); break; } return temp; }
public ExpressionTreeNode(ExpressionLexeme lexeme,ExpressionTreeNode leftNode) : this (lexeme, leftNode,null) { }
private ExpressionTreeNode SimplifyNode(ExpressionTreeNode node) { if (node.Left != null) node.Left = SimplifyNode(node.Left); if (node.Right != null) node.Right = SimplifyNode(node.Right); bool l_null = node.Left == null; bool r_null = node.Right == null; bool l_number = !l_null && (node.Left.ExpressionLexeme.Lexeme == Lexeme.Number); bool r_number = !r_null && (node.Right.ExpressionLexeme.Lexeme == Lexeme.Number); double l_value = l_number ? double.Parse(node.Left.ExpressionLexeme.LexemeName) : 0; double r_value = r_number ? double.Parse(node.Right.ExpressionLexeme.LexemeName) : 0; bool l_zero = l_number && (l_value == 0); bool r_zero = r_number && (r_value == 0); bool l_one = l_number && (l_value == 1); bool r_one = r_number && (r_value == 1); switch (node.ExpressionLexeme.LexemeType) { case LexemeType.ltOperator: bool equal = (!l_null && !r_null) && (0==String.Compare(node.Left.ToString(),node.Right.ToString())); switch(node.ExpressionLexeme.Lexeme) { case Lexeme.Multiply: if (l_zero || r_zero) return new ExpressionTreeNode( new ExpressionLexeme("0",Lexeme.Number)); if (l_one) return node.Right; if (r_one) return node.Left; if (l_number && r_number) return new ExpressionTreeNode( new ExpressionLexeme(Convert.ToString(l_value*r_value),Lexeme.Number)); break; case Lexeme.Divide: if (l_zero && !r_zero) return new ExpressionTreeNode(new ExpressionLexeme("0",Lexeme.Number)); if (equal) return new ExpressionTreeNode(new ExpressionLexeme("1",Lexeme.Number)); if (r_one) return node.Left; if (l_number && r_number) return new ExpressionTreeNode( new ExpressionLexeme(Convert.ToString(l_value/r_value),Lexeme.Number)); break; case Lexeme.Plus: if (l_zero) return node.Right; if (r_zero) return node.Left; if (l_number && r_number) return new ExpressionTreeNode( new ExpressionLexeme(Convert.ToString(l_value+r_value),Lexeme.Number)); if (node.Right.ExpressionLexeme.Lexeme == Lexeme.UMinus) return new ExpressionTreeNode( new ExpressionLexeme("-",Lexeme.Minus),node.Left,node.Right.Left); break; case Lexeme.Minus: if (r_zero) return node.Left; if (l_zero) return new ExpressionTreeNode( new ExpressionLexeme("-",Lexeme.UMinus),node.Right); if (equal) return new ExpressionTreeNode(new ExpressionLexeme("0",Lexeme.Number)); if (l_number && r_number) return new ExpressionTreeNode( new ExpressionLexeme(Convert.ToString(l_value-r_value),Lexeme.Number)); break; case Lexeme.UMinus: if (node.Left.ExpressionLexeme.Lexeme == Lexeme.UMinus) return node.Left.Left; break; } break; } return node; }
public ExpressionTreeNode(ExpressionLexeme lexeme,ExpressionTreeNode leftNode,ExpressionTreeNode rightNode ) { ExpressionLexeme = lexeme; Left = leftNode; Right = rightNode; }
private static string df(ExpressionTreeNode node, string diffVar) { if (!node.HasVariable(diffVar)) return "0"; bool leftDiffVar = (node.Left != null) && (node.Left.HasVariable(diffVar)); bool rightDiffVar = (node.Right != null) && (node.Right.HasVariable(diffVar)); switch (node.ExpressionLexeme.LexemeType) { case LexemeType.ltConstant: switch (node.ExpressionLexeme.Lexeme) { case Lexeme.Var: return "1"; default: return "0"; } case LexemeType.ltOperator: switch (node.ExpressionLexeme.Lexeme) { case Lexeme.Plus: case Lexeme.Minus: return String.Format("({0}{1}{2})", df(node.Left,diffVar), node.ExpressionLexeme.LexemeName, df(node.Right,diffVar)); case Lexeme.UMinus: return String.Format("(-({0}))",df(node.Left,diffVar)); case Lexeme.Multiply: return String.Format("(({0})*({1})+({2})*({3}))", df(node.Left, diffVar), node.Right, df(node.Right, diffVar), node.Left); case Lexeme.Divide: return String.Format("(({0})*({1})-({2})*({3}))/({4})^2", df(node.Left, diffVar), node.Right, df(node.Right, diffVar), node.Left, node.Right); case Lexeme.Power: // diff f(x)^g(y) if (leftDiffVar && !rightDiffVar) { return String.Format("((({0})^({1})*({1})*({2}))/({0}))", node.Left, node.Right, df(node.Left, diffVar)); } // diff f(y)^g(x) if (!leftDiffVar && rightDiffVar) { return String.Format("((({0})^({1}))*({2})*log({0})))", node.Left, node.Right, df(node.Right, diffVar)); } // diff f(x)^g(x) return String.Format("((({0})^({1}))*(({3})*log({0})+({1})*({2})/({0})))", node.Left, node.Right, df(node.Left, diffVar), df(node.Right, diffVar)); default: throw new Exception(); } case LexemeType.ltFunction: return String.Format("(("+node.ExpressionLexeme.LexemeDiffMask+")*({1}))", node.Left, df(node.Left, diffVar)); default: throw new Exception(); } }