//Default constructor
public Expression(string newExp)
{
this._expression = null;
_myTree = new ExpressionTree();
setExpression(newExp);
_myTree.setRoot(_myTree.addNode(_expression));
}
public void TestEvaluateDivNormal()
{
string expression = "2/1";
double expectedValue = 2.0 / 1.0;
ExpressionTree tree = new ExpressionTree(expression);
Assert.That(tree.Evaluate(), Is.EqualTo(expectedValue), "Evaluate retuned unexpected value.");
}
public void TestEvaluateDivByZero()
{
string expression = "1/0";
double expectedValue = 1.0 / 0.0;
ExpressionTree tree = new ExpressionTree(expression);
Assert.That(tree.Evaluate(), Is.EqualTo(expectedValue), "Evaluate retuned unexpected value.");
}
public void TestEvaluateParensMultiple()
{
string expression = "((1+(1))*2)";
double expectedValue = (1.0 + 1.0) * 2.0;
ExpressionTree tree = new ExpressionTree(expression);
Assert.That(tree.Evaluate(), Is.EqualTo(expectedValue), "Evaluate retuned unexpected value.");
}
public void TestEvaluateAssociativeNormal()
{
string expression = "1+3*5";
double expectedValue = 1.0 + (3.0 * 5.0);
ExpressionTree tree = new ExpressionTree(expression);
Assert.That(tree.Evaluate(), Is.EqualTo(expectedValue), "Evaluate retuned unexpected value.");
}
public void TestEvaluateAllOperators()
{
string expression = "1+7*100/10-2/1";
double expectedValue = 1.0 + ((7.0 * 100.0) / 10.0) - (2.0 / 1.0);
ExpressionTree tree = new ExpressionTree(expression);
Assert.That(tree.Evaluate(), Is.EqualTo(expectedValue), "Evaluate retuned unexpected value.");
}
public void TestEvaluateAddMultiple()
{
string expression = "2+2+3";
double expectedValue = 2.0 + 2.0 + 3.0;
ExpressionTree tree = new ExpressionTree(expression);
Assert.That(tree.Evaluate(), Is.EqualTo(expectedValue), "Evaluate retuned unexpected value.");
}
public void EvaluateTest2()
{
ExpressionTree tree = new ExpressionTree("A1+B1+12");
tree.SetVariable("A1", 2);
tree.SetVariable("B1", 20);
Assert.AreEqual(34, tree.Evaluate());
}
public void TestEvaluateSubMultiple()
{
string expression = "10-2-3";
double expectedValue = 10.0 - 2.0 - 3.0;
ExpressionTree tree = new ExpressionTree(expression);
Assert.That(tree.Evaluate(), Is.EqualTo(expectedValue), "Evaluate retuned unexpected value.");
}
public void throwStatement2()
{
ExpressionTree <FunctionIntInt> tree = p => {
throw new IllegalStateException("Message " + p);
};
doTest("throwStatement2", tree);
}
public void TestEvaluateSubNegativeResult()
{
string expression = "10-11";
double expectedValue = 10.0 - 11.0;
ExpressionTree tree = new ExpressionTree(expression);
Assert.That(tree.Evaluate(), Is.EqualTo(expectedValue), "Evaluate retuned unexpected value.");
}
public void ExpressionTreeSingleVariableTestMethod()
{
string testExpression = "AB";
ExpressionTree expression = new ExpressionTree(testExpression);
expression.SetVariable("AB", 10);
Assert.AreEqual(10, expression.Evaluate());
}
public void throwStatement()
{
ExpressionTree <FunctionInt> tree = () => {
throw new IllegalStateException();
};
doTest("throwStatement", tree);
}
public Edge ExchangeRight(ExpressionTree <T> tree, EdgeKind k)
{
var r = this.Right;
this.Right = new Edge(this, tree, k);
return(r);
}
public Edge ExchangeLeft(ExpressionTree <T> tree, EdgeKind k)
{
var l = this.Left;
this.Left = new Edge(this, tree, k);
return(l);
}
public static string test()
{
ExpressionTree <FunctionIntT <Object> > expr = p => new ArrayList <string> {
"s1"
};
return(((NewObjectExpression)((ExpressionStatement)expr.Body).Expression).Initializers.first().Member.getName());
}
public static string test()
{
ExpressionTree <FunctionIntT <Object> > expr = p => new ExpressionTreeObjectCreation2 {
field = 1
};
return(((NewObjectExpression)((ExpressionStatement)expr.Body).Expression).Initializers.first().Member.getName());
}
static void Main(string[] args)
{
int choice = 0;
string val = " ";
ExpressionTree tree = new ExpressionTree("A1-12-B1");
// exit when 4 is read
while (choice != 4)
{
// print menu
Console.WriteLine("Menu (current expression= \"" + tree.Expression + "\")");
Console.WriteLine(" 1 = Enter a new expression");
Console.WriteLine(" 2 = Set a variable value");
Console.WriteLine(" 3 = Evaluate tree");
Console.WriteLine(" 4 = Quit");
// read input for choice
val = Console.ReadLine();
choice = Convert.ToInt32(val);
// carry out function based on input
if (choice == 1)
{
Console.WriteLine("Enter new expression: ");
// change expression
val = Console.ReadLine();
tree = new ExpressionTree(val);
}
else if (choice == 2)
{
// change variable value
Console.WriteLine("Enter variable name: ");
val = Console.ReadLine();
string number = " ";
int num = 0;
Console.WriteLine("Enter variable value: ");
number = Console.ReadLine();
num = Convert.ToInt32(number);
tree.SetVariable(val, num);
}
else if (choice == 3)
{
// evaluate tree
double num = tree.Evaluate();
Console.WriteLine("Tree evaluates to: " + num);
}
}
Console.WriteLine("Task Finished");
}
/// <summary>
/// Creates the chain.
/// </summary>
/// <param name="owner">The parameter1.</param>
/// <returns></returns>
/// <exception cref="NotSupportedException">Operation not supported for the given expression type {expression.Type}. "
/// + "Only MemberExpression and ConstantExpression are currently supported.</exception>
protected string CreateChain()
{
var tree = ExpressionTree.GetTree(this.propertyExpression.Body);
var expressionString = propertyExpression.ToString();
base.CreateChain(tree);
return(expressionString);
}
public void EvaluateTest11()
{
ExpressionTree tree = new ExpressionTree("(A1+2)*B1-D1*4");
tree.SetVariable("A1", 3);
tree.SetVariable("B1", 2);
tree.SetVariable("D1", 6);
Assert.AreEqual(-14, tree.Evaluate());
}
private void RunTest(string sExp, Expression e)
{
var tree = new ExpressionTree();
var items = new DfsIterator <Expression>(tree).PostOrder(e);
Assert.AreEqual(
sExp,
string.Join(", ", items));
}
public void TestingExpressionWithParenthesisAndCombinationOperators()
{
string testExpression = "(100*10/5-1)+(3+6-9*8)";
this.expressionTree = new ExpressionTree(testExpression);
double expressionValue = 136;
Assert.AreEqual(expressionValue, this.expressionTree.Evaluate());
}
public void VariableEvaluation()
{
ExpressionTree tree = new ExpressionTree("Him-Her+They");
tree.SetVariable("Him", 5);
tree.SetVariable("Her", 20);
tree.SetVariable("They", 5);
Assert.AreEqual(-10, tree.Evaluate());
}
public TreeDetails(ExpressionTree tree, FollowTable follows, TransitionTable transitions)
{
InitializeComponent();
this.tree = tree;
this.follows = follows;
this.transitions = transitions;
expressionTextBox.Text = tree.expression;
}
public void BuildingExpressionTreeUsingPostfixExpression()
{
string testExpression = "(1*2)+3";
this.expressionTree = new ExpressionTree(testExpression);
double expressionValue = 5;
Assert.AreEqual(expressionValue, this.expressionTree.Evaluate());
}
/// <summary>
/// Creates the chain.
/// </summary>
/// <param name="propertyExpression">The property expression.</param>
/// <returns>
/// The Expression String.
/// </returns>
/// <exception cref="NotSupportedException">
/// Operation not supported for the given expression type {expression.Type}. "
/// + "Only MemberExpression and ConstantExpression are currently supported.
/// </exception>
protected (string, IExpressionTree) CreateChain(Expression <Func <TResult> > propertyExpression)
{
var tree = ExpressionTree.GetTree(propertyExpression.Body);
var expressionString = propertyExpression.ToString();
this.CreateChain(tree);
return(expressionString, tree);
}
public Query()
{
Verb = HttpVerbs.Get;
Fields = new ExpressionTree <TEntity>();
Filter = new Filter <TEntity>();
OrderBys = new List <OrderBy <TEntity> >();
Options = new Options();
Page = Page.Unlimited;
}
public void TestIsLeftAssociative()
{
ExpressionTree test1 = new ExpressionTree("A1+B1");
Assert.That(true, Is.EqualTo(test1.IsLeftAssociative("+")), "Failed at +");
Assert.That(true, Is.EqualTo(test1.IsLeftAssociative("-")), "Failed at -");
Assert.That(true, Is.EqualTo(test1.IsLeftAssociative("*")), "Failed at *");
Assert.That(true, Is.EqualTo(test1.IsLeftAssociative("/")), "Failed at /");
}
public void Reload()
{
ExpressionTree = _reloader?.Invoke(this);
if (ExpressionTree == null)
{
throw new TestException($"Reload failed: reloader delegate returned null");
}
}
public void TestSetVariableLongName()
{
string expression = "IAmThree+1";
ExpressionTree tree = new ExpressionTree(expression);
tree.SetVariable("IAmThree", 3);
Assert.That(tree.Evaluate(), Is.EqualTo(4.0), "Evaluate retuned unexpected value.");
}
/// <summary>
/// Creates the chain.
/// </summary>
/// <param name="parameter1">The parameter1.</param>
/// <returns>
/// The Expression String.
/// </returns>
/// <exception cref="NotSupportedException">
/// Operation not supported for the given expression type {expression.Type}. "
/// + "Only MemberExpression and ConstantExpression are currently supported.
/// </exception>
private (string, IExpressionTree) CreateChain(TParameter1 parameter1)
{
var tree = ExpressionTree.GetTree(this.propertyExpression.Body);
var expressionString = this.propertyExpression.ToString();
this.CreateChain(parameter1, tree);
return(expressionString, tree);
}
public override void CopyDerivedFunctionToStack(ExpressionTree cur, ExpressionTree inner, StaticStack<MathOperation> DeriveStack, MathState State)
{
//sqrt(x)' = 1/(x * ln 10)
// 1 x 10 ln * /
DeriveStack.Push((Number)1);
inner.CopyToStack(DeriveStack);
DeriveStack.Push((Number)10,State.GetFunction("ln"),State.GetOperator("*"), State.GetOperator("/"));
}
public override void CopyDerivedFunctionToStack(ExpressionTree cur, ExpressionTree inner, StaticStack<MathOperation> DeriveStack, MathState State)
{
//sqrt(x)' = 1/(2*sqrt(x))
// 1 2 x sqrt * /
DeriveStack.Push((Number)1,(Number)2);
inner.CopyToStack(DeriveStack);
DeriveStack.Push(State.GetFunction("sqrt"), State.GetOperator("*"), State.GetOperator("/"));
}
public override void CopyDerivedFunctionToStack(ExpressionTree cur, ExpressionTree inner, StaticStack<MathOperation> DeriveStack,MathState State)
{
inner.CopyToStack(DeriveStack);
DeriveStack.Push(State.GetFunction("sin"), (Number)(-1), State.GetOperator("*"));
}
public override void CopyDerivedFunctionToStack(ExpressionTree cur,ExpressionTree inner, StaticStack<MathOperation> DeriveStack,MathState State)
{
inner.CopyToStack(DeriveStack);
DeriveStack.Push(State.GetFunction("cos"));
}
public override void DeriveToStack(ExpressionTree cur, MathState State, StaticStack<MathOperation> DeriveStack)
{
//f(x) = u(v(x))
//f'(x) = u'(v(x))*v'(x)
// v u' v' *
if(ArgumentCount != 1)
throw new MathEvaluator.Exceptions.UndefinedResultException(ToString() + " is not derivable");
ExpressionTree inner = cur.FunctionParameters[0];
CopyDerivedFunctionToStack(cur,inner, DeriveStack,State);
inner.DeriveToStack(DeriveStack,State);
DeriveStack.Push(new Multiplication());
}
public override void CopyToStack(ExpressionTree cur, StaticStack<MathOperation> Stack)
{
foreach (var b in cur.FunctionParameters)
b.CopyToStack(Stack);
Stack.Push(this);
}
public abstract void CopyToStack(ExpressionTree cur, StaticStack<MathOperation> Stack);
public abstract void BuildBinaryTree(StaticStack<MathOperation> NumStaticStack,ExpressionTree b);
public abstract void DeriveToStack(ExpressionTree cur,MathState State,StaticStack<MathOperation> DeriveStack);
public override void DeriveToStack(ExpressionTree cur, MathState State, StaticStack<MathOperation> DeriveStack)
{
//(u * v)' = u' * v + u * v'
//PF: = u' v * u v' * +
ExpressionTree left = cur.Left;
ExpressionTree right = cur.Right;
left.DeriveToStack(DeriveStack,State);
right.CopyToStack(DeriveStack);
DeriveStack.Push(State.GetOperator("*"));
left.CopyToStack(DeriveStack);
right.DeriveToStack(DeriveStack,State);
DeriveStack.Push(State.GetOperator("*"), State.GetOperator("+"));
}
public override void CopyDerivedFunctionToStack(ExpressionTree cur, ExpressionTree inner, StaticStack<MathOperation> DeriveStack, MathState State)
{
//ln(x)' = 1/x
// 1 x /
DeriveStack.Push((Number)1);
inner.CopyToStack(DeriveStack);
DeriveStack.Push(State.GetOperator("/"));
}
public override void DeriveToStack(ExpressionTree cur, MathState State, StaticStack<MathOperation> DeriveStack)
{
throw new UndefinedResultException(ToString() + " is not derivable");
}
public virtual void CopyDerivedFunctionToStack(ExpressionTree cur,ExpressionTree inner, StaticStack<MathOperation> DeriveStack,MathState State)
{
throw new MathEvaluator.Exceptions.UndefinedResultException(ToString() + " is not derivable");
}
public override void DeriveToStack(ExpressionTree cur, MathState State, StaticStack<MathOperation> DeriveStack)
{
// (f(x)^g(x))'
// f(x)^(g(x)-1) (g(x) f'(x)+f(x) ln(f(x)) g'(x))
// f(x) g(x) 1 - ^ g(x) f'(x) * f(x) f(x) ln * + * g'(x) *
// f g 1 - ^ g v * f f ln * b * + *
ExpressionTree f = cur.Left;
ExpressionTree g = cur.Right;
f.CopyToStack(DeriveStack);
g.CopyToStack(DeriveStack);
DeriveStack.Push((Number)1, State.GetOperator("-"), State.GetOperator("^"));
g.CopyToStack(DeriveStack);
f.DeriveToStack(DeriveStack,State);
DeriveStack.Push(State.GetOperator("*"));
f.CopyToStack(DeriveStack);
f.CopyToStack(DeriveStack);
DeriveStack.Push(State.GetFunction("ln"), State.GetOperator("*"));
g.DeriveToStack(DeriveStack,State);
DeriveStack.Push(State.GetOperator("*"), State.GetOperator("+"), State.GetOperator("*"));
/*
if (cur.Left.ContainsVariable("x"))
{
//(x^n)' = n * x^(n-1)
ExpressionTree left = cur.Left;
ExpressionTree right = cur.Right;
right.CopyToStack(DeriveStack);
left.CopyToStack(DeriveStack);
right.CopyToStack(DeriveStack);
DeriveStack.Push((Number)1,State.GetOperator("-"),State.GetOperator("^"),State.GetOperator("*"));
}
else if (cur.Right.ContainsVariable("x"))
{
// (a^x)' = a^x * ln a
// a x ^ a ln *
ExpressionTree left = cur.Left;
ExpressionTree right = cur.Right;
left.CopyToStack(DeriveStack);
right.CopyToStack(DeriveStack);
DeriveStack.Push(State.GetOperator("^"));
left.CopyToStack(DeriveStack);
DeriveStack.Push(State.GetFunction("ln"), State.GetOperator("*"));
//chain rule
right.DeriveToStack(DeriveStack, State);
DeriveStack.Push(State.GetOperator("*"));
}
else if (cur.Left.ToString() == "e" && cur.Right.ToString() == "x")
{
cur.Left.CopyToStack(DeriveStack);
cur.Right.CopyToStack(DeriveStack);
DeriveStack.Push(this);
}
else
{
DeriveStack.Push((Number)0);
}*/
}
public override void DeriveToStack(ExpressionTree cur, MathState State, StaticStack<MathOperation> DeriveStack)
{
DeriveStack.Push((Number)(_name.ToLower() == "x" ? 1 : 0));
}
public override void DeriveToStack(ExpressionTree cur, MathState State, StaticStack<MathOperation> DeriveStack)
{
cur.Left.DeriveToStack(DeriveStack, State);
cur.Right.DeriveToStack(DeriveStack, State);
DeriveStack.Push(this);
}
public override void BuildBinaryTree(StaticStack<MathOperation> NumStaticStack,ExpressionTree b)
{
b.Value = this;
}
public override void CopyToStack(ExpressionTree cur, StaticStack<MathOperation> Stack)
{
Stack.Push(this);
}
public override void DeriveToStack(ExpressionTree cur, MathState State, StaticStack<MathOperation> DeriveStack)
{
//(u * v)' = (u'v - uv')/v²
//PF: = u' v * u v' * - v 2 ^ /
ExpressionTree left = cur.Left;
ExpressionTree right = cur.Right;
left.DeriveToStack(DeriveStack,State);
right.CopyToStack(DeriveStack);
DeriveStack.Push(State.GetOperator("*"));
left.CopyToStack(DeriveStack);
right.DeriveToStack(DeriveStack,State);
DeriveStack.Push(State.GetOperator("*"), State.GetOperator("-"));
right.CopyToStack(DeriveStack);
DeriveStack.Push((Number)2, State.GetOperator("^"), State.GetOperator("/"));
}
public override void BuildBinaryTree(StaticStack<MathOperation> NumStaticStack, ExpressionTree b)
{
b.Value = this;
b.FunctionParameters = new List<ExpressionTree>();
for(int i = 0;i< ArgumentCount;i++)
{
b.FunctionParameters.Add(new ExpressionTree(NumStaticStack));
//b.FunctionParameters[0].Value.BuildBinaryTree(NumStaticStack,b.FunctionParameters[0]);
}
}
public override void CopyToStack(ExpressionTree cur, StaticStack<MathOperation> Stack)
{
cur.Left.CopyToStack(Stack);
cur.Right.CopyToStack(Stack);
Stack.Push(this);
}
public override void DeriveToStack(ExpressionTree cur, MathState State, StaticStack<MathOperation> DeriveStack)
{
DeriveStack.Push((Number)0);
}
