public void EvaluateTest()
{
var num = "225,155";
var expr = new NumberExpression(num);
Assert.AreEqual(225.155, expr.Evaluate(), "Ошибка в вычилсении NumberExpression");
}
public IExpression GetExpression(IExpression[] expressions)
{
if (Members != expressions.Count())
{
throw new ArgumentException();
}
var powers = new IExpression[Members, Exponent + 1];
for (int i = 0; i < Members; i++)
{
for (int j = 0; j < Exponent + 1; j++)
{
powers[i, j] = expressions[Members - i - 1].Power(new NumberExpression(new NumberDecimal(j, 0))).Format().Expand();
}
}
IExpression result = NumberExpression.Zero;
foreach (var item in this)
{
IExpression term = new NumberExpression(new NumberDecimal(item.Coefficient, 0));
for (int i = 0; i < item.Exponents.Count(); i++)
{
term = term.Multiply(powers[i, item.Exponents[i]]).Format().Expand();
}
result = result.Add(term);
}
return(result.Format().Expand());
}
public void SmallNumbersShouldBeCached()
{
for (int i = -128; i < 128; i++)
{
Assert.Same(NumberExpression.Create(i), NumberExpression.Create(i));
}
}
public override RawExpression SimplifyInternal()
{
RawExpression sleft = this.Left.Simplify();
RawExpression sright = this.Right.Simplify();
NumberExpression nleft = sleft as NumberExpression;
NumberExpression nright = sright as NumberExpression;
if (nleft != null && nleft.Number == 0)
{
return(new NegExpression
{
Op = sright,
});
}
else if (nright != null && nright.Number == 0)
{
return(sleft);
}
else
{
return(new SubExpression
{
Left = sleft,
Right = sright,
});
}
}
public void EvaluationTest()
{
var operand = new NumberExpression("10");
var addition = new AdditionBinaryExpression
{
LeftOperand = operand,
RightOperand = operand
};
var subraction = new SubtractionBinaryExpression
{
LeftOperand = operand,
RightOperand = operand
};
var division = new DivisionBinaryExpression
{
LeftOperand = operand,
RightOperand = operand
};
var multiplication = new MultiplicationBinaryExpression
{
LeftOperand = operand,
RightOperand = operand
};
Assert.AreEqual(20, addition.Evaluate(), "Ошибка в вычилсении AdditionBinaryExpression");
Assert.AreEqual(0, subraction.Evaluate(), "Ошибка в вычилсении SubtractionBinaryExpression");
Assert.AreEqual(1, division.Evaluate(), "Ошибка в вычилсении DivisionBinaryExpression");
Assert.AreEqual(100, multiplication.Evaluate(), "Ошибка в вычилсении MultiplicationBinaryExpression");
}
public static bool TryParseExpression(List <Token> tokens, out IExpression result)
{
// Number
if (NumberExpression.TryParse(tokens, out NumberExpression numExpr))
{
result = numExpr;
return(true);
}
// Symbol
else if (SymbolExpression.TryParse(tokens, out SymbolExpression symExpr))
{
result = symExpr;
return(true);
}
// Function definition
else if (FunctionExpression.TryParse(tokens, out FunctionExpression funcExpr))
{
result = funcExpr;
return(true);
}
// Function call
else if (CallExpression.TryParse(tokens, out CallExpression callExpr))
{
result = callExpr;
return(true);
}
result = null;
return(false);
}
public override RawExpression SimplifyInternal()
{
RawExpression sleft = this.Left.Simplify();
RawExpression sright = this.Right.Simplify();
NumberExpression nleft = sleft as NumberExpression;
NumberExpression nright = sright as NumberExpression;
if (nleft != null)
{
if (nleft.Number == 0)
{
return(new NumberExpression
{
Number = 0,
});
}
}
else if (nright != null)
{
if (nright.Number == 1)
{
return(sleft);
}
}
return(new DivExpression
{
Left = sleft,
Right = sright,
});
}
internal static Number Number(NumberExpression expression)
{
return(new Number()
{
SourceText = expression.SourceText,
}.Apply(n => n.TypeHint = expression.TryType().Null(t => TypeRef.Serialize(t))));
}
protected override string VisitNumberExpression(NumberExpression exp, out object retObject)
{
retObject = null;
var output = exp.ToString();
return(output);
}
public void Equals_SameNumber_Test()
{
var num1 = new NumberExpression <double>(1.1);
var num2 = 1.1;
Assert.IsTrue(num1.Equals(num2));
}
private IExpression ReadConstant()
{
var token = Reader.DiscardToken();
IExpression output = null;
switch (token.TokenType)
{
case TokenType.NumberValue:
output = new NumberExpression()
{
Value = int.Parse(token.Value)
};
break;
case TokenType.StringValue:
output = new StringExpression()
{
Value = token.Value
};
break;
case TokenType.FloatValue:
output = new FloatExpression()
{
Value = float.Parse(token.Value)
};
break;
default:
throw new Exception("Unexpected token for constant!");
}
return(output);
}
public void NumberExpressionTest()
{
string numbertest = "5";
NumberExpression number = new NumberExpression(numbertest);
Assert.AreEqual(number.ToString(), "5");
}
public void Equals_DifferentNumber_Test()
{
var num1 = new NumberExpression <double>(1.1);
var num2 = 1.2;
Assert.IsFalse(num1.Equals(num2));
}
public void ByteValuesShouldBeMappedProperly()
{
for (int i = 0; i < 256; i++)
{
Assert.Equal(i, NumberExpression.Create(checked ((byte)i)).Value);
}
}
public void Multiply_Number_FlatAdd()
{
//Arrange
var expected = new FlatAddExpression();
expected.Add(new VariableExpression("u", 2));
expected.Add(new NumberExpression(3));
expected.Count = new Complex(12, 0);
expected.Execute();
var c = new NumberExpression(3);
var n = new FlatAddExpression();
n.Add(new VariableExpression("u", 2));
n.Add(new NumberExpression(3));
n.Count = new Complex(4, 0);
var expr = new BinaryExpression(c, OperatorTypes.Multiply, n);
//Act
var actual = expr.Execute();
//Assert
Assert.AreEqual(expected.Count.Re.ToNumber(), actual.Count.Re.ToNumber());
Assert.AreEqual(expected.Count.Im.ToNumber(), actual.Count.Im.ToNumber());
}
public FrameResource Visit(NumberExpression expression)
{
var res = _frame.Allocate(new PrimitiveType(Primitive.Int));
_context.Emit(new Instruction(Opcode.Mov, res.Operand, new ImmediateOperand(expression.Value)));
return(res);
}
/// <summary>
/// Creates a tree for math expression represented in Infix notation.
/// </summary>
/// <param name="s">String representing math expression in Infix notation.</param>
/// <returns>Built expression.</returns>
public MathExpression Build(string s)
{
if (string.IsNullOrEmpty(s))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(s));
}
// Convert expression to use Reverse Polish (postfix) notation
var notationConverter = new ExpressionNotationConverter();
var rpnExprStr = notationConverter.ToReversePolishNotation(s);
var stack = new Stack <MathExpression>();
string token;
var index = 0;
while ((token = ReadNextToken(rpnExprStr, ref index)) != null)
{
MathExpression expr;
var tokenKind = GetTokenKind(token);
switch (tokenKind)
{
case TokenKind.Number:
expr = new NumberExpression(token);
break;
case TokenKind.Addition:
expr = new AdditionExpression(GetChildExpressions(stack, 2, tokenKind));
break;
case TokenKind.Subtraction:
expr = new SubtractionExpression(GetChildExpressions(stack, 2, tokenKind));
break;
case TokenKind.Multiplication:
expr = new MultiplicationExpression(GetChildExpressions(stack, 2, tokenKind));
break;
case TokenKind.Division:
expr = new DivisionExpression(GetChildExpressions(stack, 2, tokenKind));
break;
default:
throw new ArgumentOutOfRangeException($"Unexpected token kind: '{tokenKind}'.");
}
stack.Push(expr);
}
if (stack.Count != 1)
{
throw new InvalidOperationException("Incorrect math expression.");
}
return(stack.Pop());
}
// Commons as ITTEExpression
bool Number(out ITTEExpression numberExpression)
{
if (Double(out double value))
{
numberExpression = new NumberExpression(value);
return(true);
}
numberExpression = null;
return(false);
}
public void Clone_NumberExpression()
{
//Arrange
var expression = new NumberExpression(-2);
//Act
var clone = (NumberExpression)expression.Clone();
//Assert
Assert.AreEqual(expression.Count.Re.ToNumber(), clone.Count.Re.ToNumber());
}
private static bool TyeGetNumberExpression(ITokenizer tokenizer, out IExpression numberExpression)
{
numberExpression = null;
if (tokenizer.CurrentToken.Number.HasValue)
{
numberExpression = new NumberExpression(tokenizer.CurrentToken.Number.Value);
tokenizer.NextToken();
}
return(numberExpression != null);
}
public void Pow_Complex_0()
{
//Arrange
var expected = new NumberExpression(1);
var c = new ComplexExpression(-2, 3);
var n = new NumberExpression(0);
var expr = new BinaryExpression(c, OperatorTypes.Power, n);
//Act
var actual = (NumberExpression)expr.Execute();
//Assert
Assert.AreEqual(expected.Count.Re.ToNumber(), actual.Count.Re.ToNumber());
}
public void Clone_BinaryExpression()
{
//Arrange
var expr1 = new NumberExpression(-2);
var expr2 = new NumberExpression(3);
var actual = new BinaryExpression(expr1, OperatorTypes.Power, expr2);
//Act
var expected = (BinaryExpression)actual.Clone();
//Assert
Assert.IsTrue(!Object.ReferenceEquals(actual, expected));
Assert.AreEqual(actual.Execute().Count.Re.ToNumber(), expected.Execute().Count.Re.ToNumber());
}
public void Subtract_Complex_ResultAsNumber()
{
//Arrange
var expected = new NumberExpression(1);
var c = new ComplexExpression(2, 3);
var n = new ComplexExpression(1, 3);
var expr = new BinaryExpression(c, OperatorTypes.Subtract, n);
//Act
var actual = (NumberExpression)expr.Execute();
//Assert
Assert.AreEqual(expected.Count.Re.ToNumber(), actual.Count.Re.ToNumber());
}
public void NumberExpressionInterpretIsNotModified()
{
string constVariable = "z";
int constValue = 5;
int returnValue = 0;
ContextGrammar context = new ContextGrammar();
IExpression expression = new NumberExpression(constVariable);
context.SetVariable(constVariable, constValue);
returnValue = expression.Interpret(context);
Assert.AreEqual(constValue, returnValue);
}
public Linq.Expression Reverse(Expression expr)
{
if (expr is NumberExpression)
{
NumberExpression nexpr = (NumberExpression)expr;
return(Linq.Expression.Constant(nexpr.Value));
}
else if (expr is VariableExpression)
{
VariableExpression vexpr = (VariableExpression)expr;
return(Linq.Expression.Parameter(typeof(double), vexpr.Name));
}
else if (expr is FunctionExpression)
{
FunctionExpression fexpr = (FunctionExpression)expr;
IList <Linq.Expression> arguments = new List <Linq.Expression>();
foreach (Expression arg in fexpr.Arguments)
{
arguments.Add(Reverse(arg));
}
if (!exists(fexpr.Name))
{
throw new Exception("Method name doesn't exist in the scope");
}
MethodInfo method = get(fexpr.Name);
return(Linq.Expression.Call(method, arguments));
}
else if (expr is BinaryExpression)
{
BinaryExpression bexpr = (BinaryExpression)expr;
Linq.Expression left = Reverse(bexpr.Left);
Linq.Expression right = Reverse(bexpr.Right);
if (bexpr.Operator == Binary.Power)
{
return(Linq.Expression.Call(powMethod, left, right));
}
return(Linq.Expression.MakeBinary(getOperator(bexpr.Operator), left, right));
}
throw new Exception("Can't reverse expression");
}
public void Multiply_Number_Complex()
{
//Arrange
var expected = new ComplexExpression(2, -6);
var c = new NumberExpression(2);
var n = new ComplexExpression(1, -3);
var expr = new BinaryExpression(c, OperatorTypes.Multiply, n);
//Act
var actual = (ComplexExpression)expr.Execute();
//Assert
Assert.AreEqual(expected.Count.Re.ToNumber(), actual.Count.Re.ToNumber());
Assert.AreEqual(expected.Count.Im.ToNumber(), actual.Count.Im.ToNumber());
}
public void Multiply_Number_Function()
{
//Arrange
var expected = new CotExpression(new VariableExpression("x", 1), 12);
var c = new NumberExpression(3);
var n = new CotExpression(new VariableExpression("x", 1), 4);
var expr = new BinaryExpression(c, OperatorTypes.Multiply, n);
//Act
var actual = expr.Execute();
//Assert
Assert.AreEqual(expected.Count.Re.ToNumber(), actual.Count.Re.ToNumber());
Assert.AreEqual(expected.Count.Im.ToNumber(), actual.Count.Im.ToNumber());
}
public void Multiply_Number_NegativeNumber()
{
//Arrange
var expected = new NumberExpression(-4);
var c = new NumberExpression(-2);
var n = new NumberExpression(2);
var expr = new BinaryExpression(c, OperatorTypes.Multiply, n);
//Act
var actual = expr.Execute();
//Assert
Assert.AreEqual(expected.Count.Re.ToNumber(), actual.Count.Re.ToNumber());
Assert.AreEqual(expected.Count.Im.ToNumber(), actual.Count.Im.ToNumber());
}
public void Add_Complex_NegativeNumber()
{
//Arrange
var expected = new ComplexExpression(1, 3);
var c = new ComplexExpression(2, 3);
var n = new NumberExpression(-1);
var expr = new BinaryExpression(c, OperatorTypes.Add, n);
//Act
var actual = (ComplexExpression)expr.Execute();
//Assert
Assert.AreEqual(expected.Count.Re.ToNumber(), actual.Count.Re.ToNumber());
Assert.AreEqual(expected.Count.Im.ToNumber(), actual.Count.Im.ToNumber());
}
/// <summary>
/// Parses S-Expressions and builds an internal representation.
/// Named after the 'analyze procedure from SICP #4.1.7.
/// </summary>
/// <param name="sExpr"></param>
/// <returns></returns>
public static Expression Analyze(SExpression sExpression)
{
// Dispatch on S-Expression's type
if (sExpression is SAtom atom)
{
if (NumberExpression.IsInstance(atom))
{
return(NumberExpression.Analyze(atom));
}
else if (StringExpression.IsInstance(atom))
{
return(StringExpression.Analyze(atom));
}
else if (BooleanExpression.IsInstance(atom))
{
return(BooleanExpression.Analyze(atom));
}
else
{
return(Variable.Analyze(atom));
}
}
else
{
var list = (SList)sExpression;
if (list.Count == 0)
{
throw new BadSyntaxException("procedure application", "Empty application", list.Text);
}
string head = list[0].Text;
if (SpecialForm.Table.ContainsKey(head))
{
// $list is a special form
Func <SList, SpecialForm> spFormAnalyzer = SpecialForm.Table[head];
return(spFormAnalyzer(list));
}
else
{
// $list is a procedure application
return(Application.Analyze(list));
}
}
}
public void NumberExpressionProducesNumbers()
{
NumberExpression n1 = new NumberExpression(1.0);
NumberExpression n2 = new NumberExpression(12);
NumberExpression n3 = new NumberExpression(0.5);
NumberExpression n4 = new NumberExpression(-58);
Assert.AreEqual("1;", n1.ToString());
Assert.AreEqual("12;", n2.ToString());
Assert.AreEqual("0.5;", n3.ToString());
Assert.AreEqual("-58;", n4.ToString());
n4.Value = n4.Value + 1;
Assert.AreEqual("-57;", n4.ToString());
}
public Expression Add(NumberExpression expr)
{
return Number(val + expr.Value);
}
private IExpression ParseExpression()
{
List<IExpression> arguments;
List<KeyValuePair<IExpression, IExpression>> elements;
IExpression expression;
int index;
IExpression key;
decimal number;
IExpression value;
switch (this.lexer.Current.Type)
{
case LexemType.BracketBegin:
elements = new List<KeyValuePair<IExpression, IExpression>> ();
index = 0;
for (this.lexer.Next (LexerMode.BLOCK); this.lexer.Current.Type != LexemType.BracketEnd; )
{
key = this.ParseExpression ();
if (this.lexer.Current.Type == LexemType.Colon)
{
this.lexer.Next (LexerMode.BLOCK);
value = this.ParseExpression ();
}
else
{
value = key;
key = new NumberExpression (index++);
}
elements.Add (new KeyValuePair<IExpression, IExpression> (key, value));
if (this.lexer.Current.Type == LexemType.Comma)
this.lexer.Next (LexerMode.BLOCK);
}
this.lexer.Next (LexerMode.BLOCK);
expression = new ArrayExpression (elements);
break;
case LexemType.Number:
expression = new NumberExpression (decimal.TryParse (this.lexer.Current.Content, out number) ? number : 0);
this.lexer.Next (LexerMode.BLOCK);
break;
case LexemType.String:
expression = new StringExpression (this.lexer.Current.Content);
this.lexer.Next (LexerMode.BLOCK);
break;
case LexemType.Literal:
expression = this.ParseName ();
break;
default:
throw new UnexpectedException (this.lexer, "expression");
}
while (true)
{
switch (this.lexer.Current.Type)
{
case LexemType.BracketBegin:
this.lexer.Next (LexerMode.BLOCK);
value = this.ParseExpression ();
if (this.lexer.Current.Type != LexemType.BracketEnd)
throw new UnexpectedException (this.lexer, "array index end (']')");
this.lexer.Next (LexerMode.BLOCK);
expression = new AccessExpression (expression, value);
break;
case LexemType.Dot:
this.lexer.Next (LexerMode.BLOCK);
if (this.lexer.Current.Type != LexemType.Literal)
throw new UnexpectedException (this.lexer, "field name");
expression = new AccessExpression (expression, new StringExpression (this.lexer.Current.Content));
this.lexer.Next (LexerMode.BLOCK);
break;
case LexemType.ParenthesisBegin:
arguments = new List<IExpression> ();
for (this.lexer.Next (LexerMode.BLOCK); this.lexer.Current.Type != LexemType.ParenthesisEnd; )
{
arguments.Add (this.ParseExpression ());
if (this.lexer.Current.Type == LexemType.Comma)
this.lexer.Next (LexerMode.BLOCK);
}
this.lexer.Next (LexerMode.BLOCK);
expression = new CallExpression (expression, arguments);
break;
default:
return expression;
}
}
}
public Expression Divide(NumberExpression expr)
{
return Number(val / expr.Value);
}
public Expression Multiply(NumberExpression expr)
{
return Number(val * expr.Value);
}
/// <summary>
/// Finds the first instance of currentOperator (i.e. '+'), takes the operands on the left and right
/// to the operator and builds an Expression instance (i.e. AddExpression in case of '+').
/// </summary>
/// <param name="expression">A list containing numbers, operators and expressions.</param>
/// <param name="currentOperator">The symbol of the current operator to be processed.</param>
private static void CreateExpression(List<dynamic> expression, char currentOperator)
{
int operatorIndex = expression.IndexOf(currentOperator);
Expression operation;
dynamic leftOperand, rightOperand;
try
{
if (expression.ElementAt(operatorIndex - 1) is double)
{
leftOperand = new NumberExpression(expression.ElementAt(operatorIndex - 1));
}
else if (expression.ElementAt(operatorIndex - 1) is Expression)
{
leftOperand = expression.ElementAt(operatorIndex - 1);
}
else
{
throw new ArgumentException("Invalid expression string.");
}
if (expression.ElementAt(operatorIndex + 1) is double)
{
rightOperand = new NumberExpression(expression.ElementAt(operatorIndex + 1));
}
else if (expression.ElementAt(operatorIndex + 1) is Expression)
{
rightOperand = expression.ElementAt(operatorIndex + 1);
}
else
{
throw new ArgumentException("Invalid expression string.");
}
}
catch (Exception ex)
{
throw new ArgumentException("Invalid expression string.");
}
switch (currentOperator)
{
case '+':
operation = new AddExpression(leftOperand, rightOperand);
break;
case '-':
operation = new SubtractExpression(leftOperand, rightOperand);
break;
case '*':
operation = new MultiplyExpression(leftOperand, rightOperand);
break;
case '/':
operation = new DivideExpression(leftOperand, rightOperand);
break;
default:
operation = new NumberExpression(0);
break;
}
expression.RemoveAt(operatorIndex + 1);
expression.RemoveAt(operatorIndex);
expression.RemoveAt(operatorIndex - 1);
expression.Insert(operatorIndex - 1, operation);
}
public Expression Subtract(NumberExpression expr)
{
return Number(val - expr.Value);
}
public Expression Power(NumberExpression expr)
{
return Number(System.Math.Pow(val, expr.Value));
}
