public Node(string current, Queue <string> prefix)
{
expression = current;
int numOperands = MathProcessor.numberOfOperands(current);
switch (numOperands)
{
case 0:
left = null;
right = null;
break;
case 1:
left = new Node(prefix.Dequeue(), prefix);
right = null;
break;
case 2:
left = new Node(prefix.Dequeue(), prefix);
right = new Node(prefix.Dequeue(), prefix);
break;
default:
throw new Exception("Unknown error");
}
}
private void preAppendX()
{
if (textBoxCalcInput.Text.CompareTo("") == 0)
{
return;
}
if (MathProcessor.isOperand(textBoxCalcInput.Text.Last().ToString()))
{
textBoxCalcInput.Text += "x";
}
}
private void btnAns_Click(object sender, RoutedEventArgs e)
{
foreach (char c in textUserData.Text)
{
if (!MathProcessor.isOperand(c.ToString()))
{
return;
}
}
textBoxCalcInput.Text += textUserData.Text;
}
public double evaluate()
{
if (isLeaf())
{
return(Double.Parse(expression));
}
else
{
switch (expression)
{
case "+": return(left.evaluate() + right.evaluate());
case "-": return(left.evaluate() - right.evaluate());
case "x": return(left.evaluate() * right.evaluate());
case "/": return(left.evaluate() / right.evaluate());
case "^": return(Math.Pow(left.evaluate(), right.evaluate()));
case "P": return(MathProcessor.perm(left.evaluate(), right.evaluate()));
case "C": return(MathProcessor.comb(left.evaluate(), right.evaluate()));
case "rt": return(Math.Pow(right.evaluate(), 1f / left.evaluate()));
case "sin": return(Math.Sin(left.evaluate()));
case "cos": return(Math.Cos(left.evaluate()));
case "tan": return(Math.Tan(left.evaluate()));
case "asin": return(Math.Asin(left.evaluate()));
case "acos": return(Math.Acos(left.evaluate()));
case "atan": return(Math.Atan(left.evaluate()));
case MathProcessor.CUBEROOT: return(Math.Pow(left.evaluate(), 1f / 3f));
case MathProcessor.SQUAREROOT: return(Math.Pow(left.evaluate(), 1f / 2f));
case "exp": return(Math.Exp(left.evaluate()));
case "log": return(Math.Log10(left.evaluate()));
case "ln": return(Math.Log(left.evaluate(), Math.E));
default: throw new Exception("Node cannot evaluate");
}
}
}
/// <summary>
/// Decomposes the input string into it's components for an infix expression
/// </summary>
/// <param name="expression">Mathematical expression in string format</param>
/// <returns></returns>
private Queue <string> decomposeString(string expression)
{
Queue <string> infix = new Queue <string>();
string trimmed = textBoxCalcInput.Text.Trim();
trimmed = trimmed.ToLower();
char[] chars = trimmed.ToCharArray();
bool negative = false;
int i = 0;
while (i < chars.Length)
{
if (Char.IsWhiteSpace(chars[i]))
{
i++;
continue;
}
if (MathProcessor.isOperand(chars[i].ToString()))
{
string number = "";
while (MathProcessor.isOperand(chars[i].ToString()))
{
number += chars[i].ToString();
i++;
if (i >= chars.Length)
{
break;
}
}
if (number.CompareTo(".") == 0)
{
throw new Exception(number + " is not a valid number");
}
number = ((negative) ? "-" : "") + number;
infix.Enqueue(number);
negative = false;
}
else
{
switch (chars[i].ToString())
{
case "s":
infix.Enqueue("sin");
infix.Enqueue("(");
i += 4;
break;
case "c":
try
{
if (MathProcessor.isOperand(chars[i + 1].ToString()))
{
infix.Enqueue("C");
i++;
}
else
{
infix.Enqueue("cos");
infix.Enqueue("(");
i += 4;
}
break;
}
catch (IndexOutOfRangeException e)
{
throw new Exception("Syntax Error" + e.Message);
}
case "t":
infix.Enqueue("tan");
infix.Enqueue("(");
i += 4;
break;
case "a":
try
{
switch (chars[i + 1].ToString())
{
case "s":
infix.Enqueue("asin");
infix.Enqueue("(");
i += 5;
break;
case "c":
infix.Enqueue("acos");
infix.Enqueue("(");
i += 5;
break;
case "t":
infix.Enqueue("atan");
infix.Enqueue("(");
i += 5;
break;
default:
throw new Exception("Unknown Operation");
}
break;
}
catch (IndexOutOfRangeException e)
{
throw new Exception("Syntax Error" + e.Message);
}
case "p":
infix.Enqueue("P");
i++;
break;
case "e":
infix.Enqueue("exp");
infix.Enqueue("(");
i += 4;
break;
case "l":
try
{
if (chars[i + 1].ToString().CompareTo("o") == 0)
{
infix.Enqueue("log");
i += 4;
}
else
{
infix.Enqueue("ln");
i += 3;
}
infix.Enqueue("(");
break;
}
catch (IndexOutOfRangeException e)
{
throw new Exception("Syntax Error" + e.Message);
}
case MathProcessor.SUPERSCRIPTN:
infix.Enqueue("rt");
infix.Enqueue("(");
i += 3;
break;
case MathProcessor.SQUAREROOT:
case MathProcessor.CUBEROOT:
case "^":
infix.Enqueue(chars[i].ToString());
infix.Enqueue("(");
i += 2;
break;
case MathProcessor.SQUARED:
infix.Enqueue("^");
infix.Enqueue("(");
infix.Enqueue("2");
infix.Enqueue(")");
i++;
break;
case MathProcessor.CUBED:
infix.Enqueue("^");
infix.Enqueue("(");
infix.Enqueue("3");
infix.Enqueue(")");
i++;
break;
case "x":
case "/":
case "(":
case ")":
infix.Enqueue(chars[i].ToString());
i++;
break;
case "-":
if (infix.Count == 0)
{
negative = true;
i++;
break;
}
try
{
Double.Parse(infix.Last());
infix.Enqueue(chars[i].ToString());
i++;
negative = false;
}
catch (FormatException)
{
i++;
negative = true;
}
break;
case "+":
if (infix.Count == 0)
{
i++;
break;
}
try
{
Double.Parse(infix.Last());
infix.Enqueue(chars[i].ToString());
i++;
}
catch (FormatException)
{
i++;
}
break;
case MathProcessor.PI:
infix.Enqueue(Math.PI.ToString());
i++;
break;
default: throw new Exception("Currently Unsupported");
}
}
}
return(infix);
}
/// <summary>
/// Converts infix expression to prefix : reverse infix expression, convert reverse expression to postfix, then reverse postfix.
/// </summary>
/// <param name="infix">infix expression implemented as a Queue</param>
/// <returns></returns>
private Queue <string> infixToPrefix(Queue <string> infix)
{
Queue <string> postfix = new Queue <string>();
Queue <string> prefix;
Stack <string> operatorStack = new Stack <string>();
Queue <string> reverse = new Queue <string>(infix.Reverse());
string current;
while (reverse.Count > 0)
{
current = reverse.Dequeue();
try
{
Double.Parse(current);
postfix.Enqueue(current);
}
catch (FormatException)
{
//if (MathProcessor.isOperand(current))
//{
//operandStack.Push(reverse.Dequeue());
//}
if (current.CompareTo("(") == 0)
{
while (operatorStack.Peek().CompareTo(")") != 0)
{
postfix.Enqueue(operatorStack.Pop());
}
operatorStack.Pop();
}
else if (current.CompareTo(")") == 0 || operatorStack.Count == 0 || MathProcessor.operatorLevel(operatorStack.Peek()) < MathProcessor.operatorLevel(current))
{
operatorStack.Push(current);
}
else if (MathProcessor.operatorLevel(operatorStack.Peek()) >= MathProcessor.operatorLevel(current))
{
// while (operatorStack.Count > 0 && operatorLevel(operatorStack.Peek()) >= operatorLevel(current))
// {
string top = operatorStack.Peek();
if (MathProcessor.operatorLevel(top) < MathProcessor.operatorLevel("("))
{
postfix.Enqueue(operatorStack.Pop());
}
// }
operatorStack.Push(current);
}
}
}
while (operatorStack.Count > 0)
{
postfix.Enqueue(operatorStack.Pop());
}
prefix = new Queue <string>(postfix.Reverse());
return(prefix);
}
