| private static Number ( string expression, int &index ) : double | ||
| expression | string | |
| index | int | |
| Результат | double | |
private Expression F()
{
if (lexer.Current == LexicalToken.Id)
{
var result = Expression.Identifier(lexer.Value);
AddVariable(lexer.Value);
lexer.Next();
return(result);
}
else if (lexer.Current == LexicalToken.Num)
{
var result = Expression.Number(lexer.Value);
lexer.Next();
return(result);
}
else if (lexer.Current == LexicalToken.OpenPar)
{
lexer.Next();
var e = E();
lexer.Expect(LexicalToken.ClosePar);
return(Expression.Parenthesis(e));
}
else
{
throw new ApplicationException(String.Format("Parse error: Incorrent token '{0}' encountered. Expected ')'.", lexer.Value));
}
}
public BinaryExpression(string left, char op, string right)
{
int temp1;
if (Int32.TryParse(left, out temp1))
{
int temp2;
if (Int32.TryParse(right, out temp2))
{
Init(Expression.Number(temp1), Expression.Operator(op), Expression.Number(temp2));
}
else
{
Init(Expression.Number(temp1), Expression.Operator(op), Expression.Identifier(right));
}
}
else
{
int temp2;
if (Int32.TryParse(right, out temp2))
{
Init(Expression.Identifier(left), Expression.Operator(op), Expression.Number(temp2));
}
else
{
Init(Expression.Identifier(left), Expression.Operator(op), Expression.Identifier(right));
}
}
}
public IList <ITypeTranslationContext> BuildDefault()
{
return(new List <ITypeTranslationContext>
{
TypeTranslationContextFactory.Direct(typeof(object), Expression.Any()),
TypeTranslationContextFactory.Direct(typeof(short), Expression.Number()),
TypeTranslationContextFactory.Direct(typeof(int), Expression.Number()),
TypeTranslationContextFactory.Direct(typeof(long), Expression.Number()),
TypeTranslationContextFactory.Direct(typeof(ushort), Expression.Number()),
TypeTranslationContextFactory.Direct(typeof(uint), Expression.Number()),
TypeTranslationContextFactory.Direct(typeof(ulong), Expression.Number()),
TypeTranslationContextFactory.Direct(typeof(byte), Expression.Number()),
TypeTranslationContextFactory.Direct(typeof(sbyte), Expression.Number()),
TypeTranslationContextFactory.Direct(typeof(float), Expression.Number()),
TypeTranslationContextFactory.Direct(typeof(double), Expression.Number()),
TypeTranslationContextFactory.Direct(typeof(decimal), Expression.Number()),
TypeTranslationContextFactory.Direct(typeof(bool), Expression.Bool()),
TypeTranslationContextFactory.Direct(typeof(string), Expression.String()),
TypeTranslationContextFactory.Direct(typeof(char), Expression.String()), // TODO consider better options if possible
TypeTranslationContextFactory.Direct(typeof(DateTime), Expression.Date()), // TODO consider better options if possible
// TODO TimeSpan -> ???
TypeTranslationContextFactory.Enum(),
TypeTranslationContextFactory.Nullable(),
TypeTranslationContextFactory.GenericDictionary(),
TypeTranslationContextFactory.Special(typeof(IDictionary), Expression.UntypedDictionary()),
TypeTranslationContextFactory.Array(),
TypeTranslationContextFactory.GenericEnumerable(),
TypeTranslationContextFactory.Special(typeof(IEnumerable), Expression.UntypedArray())
});
}
public void PrettyPrinter_Object()
{
var d = new Dictionary <string, Expression>
{
{ "bar", Expression.Number("1") },
{ "foo", Expression.Number("2") },
};
AssertPretty(Expression.Object(d), "{" + Environment.NewLine + " \"bar\": 1," + Environment.NewLine + " \"foo\": 2" + Environment.NewLine + "}");
}
private Expression numbers(IList <Token> tokens, ref int index)
{
if (index < tokens.Count && tokens[index].Type == Symbol.Number)
{
double number = double.Parse(tokens[index].Value);
index++;
return(Expression.Number(number));
}
throw new Exception("Unknown token");
}
public BinaryExpression(Expression left, OperatorExpression op, string right)
{
int temp;
if (Int32.TryParse(right, out temp))
{
Init(left, op, Expression.Number(temp));
}
else
{
Init(left, op, Expression.Identifier(right));
}
}
public BinaryExpression(string left, char op, Expression right)
{
int temp;
if (Int32.TryParse(left, out temp))
{
Init(Expression.Number(temp), Expression.Operator(op), right);
}
else
{
Init(Expression.Identifier(left), Expression.Operator(op), right);
}
}
public override Expression VisitConstant(ConstantExpression node)
{
if (node.NodeType == ExpressionType.Number)
{
var value = int.Parse((string)node.Value);
if (value % 2 == 0)
{
return(Expression.Number((value / 2).ToString()));
}
}
return(base.VisitConstant(node));
}
public void UnaryOperationExpressionHelpersRequireExpression()
{
Expression expression = null;
Expect.Throw <ArgumentNullException>(() => expression.BitwiseNot());
Expect.Throw <ArgumentNullException>(() => expression.Delete());
Expect.Throw <ArgumentNullException>(() => expression.Group());
Expect.Throw <ArgumentNullException>(() => expression.LogicalNot());
Expect.Throw <ArgumentNullException>(() => expression.Negative());
Expect.Throw <ArgumentNullException>(() => expression.New());
Expect.Throw <ArgumentNullException>(() => expression.Number());
Expect.Throw <ArgumentNullException>(() => expression.PostDecrement());
Expect.Throw <ArgumentNullException>(() => expression.PostIncrement());
Expect.Throw <ArgumentNullException>(() => expression.PreDecrement());
Expect.Throw <ArgumentNullException>(() => expression.PreIncrement());
Expect.Throw <ArgumentNullException>(() => expression.TypeOf());
}
public override Expression Differentiate(IList <Expression> arguments, int position, int count)
{
if (count != 2)
{
throw new Exception("Logarithm function can't take more than 2 arguments");
}
Expression b = arguments[0];
Expression x = arguments[1];
if (position == 1)
{
return(Expression.Divide(Expression.Number(1), Expression.Multiply(x, Expression.Function(Alias, b))));
}
return(Expression.Divide(Expression.Multiply(Expression.Number(-1), Expression.Function(Alias, b)), Expression.Multiply(x, Expression.Power(Expression.Function(Alias, x), Expression.Number(2)))));
}
public Expression Eliminate(Expression expr)
{
if (expr is FunctionExpression)
{
FunctionExpression fexpr = (FunctionExpression)expr;
IList <Expression> arguments = new List <Expression>();
foreach (Expression arg in fexpr.Arguments)
{
arguments.Add(Eliminate(arg));
}
return(Expression.Function(fexpr.Name, arguments));
}
else if (expr is BinaryExpression)
{
BinaryExpression bexpr = (BinaryExpression)expr;
Expression left = Eliminate(bexpr.Left);
Expression right = Eliminate(bexpr.Right);
if (bexpr.Operator == Binary.Subtract)
{
if (right is NumberExpression)
{
double num = ((NumberExpression)right).Value;
num *= -1;
right = Expression.Number(num);
}
else
{
right = Expression.Multiply(Expression.Number(-1), right);
}
return(Expression.FromBinary(Binary.Add, left, right));
}
return(Expression.FromBinary(bexpr.Operator, left, right));
}
return(expr);
}
/// <summary>
/// Parses the given JSON token stream and returns an expression tree representing the JSON expression.
/// </summary>
/// <param name="tokens">JSON token stream to be parsed.</param>
/// <returns>Expression tree representing the JSON expression.</returns>
private static Expression Parse(IEnumerator <Token> tokens)
{
//
// JSON is LL(1); we can simply look-ahead one symbol to decide how to proceed
// with parsing, i.e. { indicates an object, [ indicates an array, etc.
//
var token = tokens.Current;
return(token.Type switch
{
TokenType.LeftCurly => ParseObject(tokens),
TokenType.LeftBracket => ParseArray(tokens),
TokenType.False => Expression.Boolean(false),
TokenType.True => Expression.Boolean(true),
TokenType.Null => Expression.Null(),
TokenType.String => Expression.String(token.Data),
TokenType.Number => Expression.Number(token.Data),
_ => throw new ParseException("Unexpected token: " + token.Type, token.Position, ParseError.UnexpectedToken),
});
static void Main()
{
// create abstract syntax tree for
// the expression: a + b * 4 - 1
var exp1 = Expression.Binary(Expression.Identifier("b"), Expression.Operator('*'), Expression.Number(4));
var exp2 = Expression.Binary(Expression.Identifier("a"), Expression.Operator('+'), exp1);
var exp3 = Expression.Binary(exp2, Expression.Operator('-'), Expression.Number(1));
var context = new Context();
context.Variables.Add("a", 2);
context.Variables.Add("b", 3);
exp3.Interpret(context);
Console.WriteLine(context.Value); // writes 13
Console.ReadKey();
}
/// <summary>
/// Parses the given JSON token stream and returns an expression tree representing the JSON expression.
/// </summary>
/// <param name="tokens">JSON token stream to be parsed.</param>
/// <returns>Expression tree representing the JSON expression.</returns>
private static Expression Parse(IEnumerator <Token> tokens)
{
//
// JSON is LL(1); we can simply look-ahead one symbol to decide how to proceed
// with parsing, i.e. { indicates an object, [ indicates an array, etc.
//
var token = tokens.Current;
switch (token.Type)
{
case TokenType.LeftCurly:
return(ParseObject(tokens));
case TokenType.LeftBracket:
return(ParseArray(tokens));
case TokenType.False:
return(Expression.Boolean(false));
case TokenType.True:
return(Expression.Boolean(true));
case TokenType.Null:
return(Expression.Null());
case TokenType.String:
return(Expression.String(JsonStringToBclString(token.Data)));
case TokenType.Number:
return(Expression.Number(token.Data));
case TokenType.Eof:
case TokenType.White: // indicates improper filtering earlier on
case TokenType.RightCurly:
case TokenType.RightBracket:
case TokenType.Comma:
case TokenType.Colon:
default:
throw new ParseException("Unexpected token: " + token.Type, token.Position, ParseError.UnexpectedToken);
}
}
public void ExpressionVisitor_Unchanged()
{
var e1 = Expression.Null();
var e2 = Expression.Number("42");
var e3 = Expression.String("foo");
var e4 = Expression.Array(e2, e3);
var e5 = Expression.Object(new Dictionary <string, Expression> {
{ "bar", e2 }, { "foo", e3 }
});
var v = new ExpressionVisitor();
var es = new Expression[]
{
e1, e2, e3, e4, e5,
};
foreach (var e in es)
{
Assert.AreSame(e, v.Visit(e));
}
}
public void TokenStack_Push1()
{
var tokens = new TokenStack();
Assert.IsFalse(tokens.TryPop(out _));
Assert.AreEqual(0, tokens.Count);
for (var i = 0; i < 99; i++)
{
tokens.Push(new Token {
Expression = Expression.Number(i.ToString())
});
Assert.AreEqual(i + 1, tokens.Count);
}
for (var i = 98; i >= 0; i--)
{
Assert.IsTrue(tokens.TryPop(out var token));
Assert.AreEqual(i, tokens.Count);
Assert.AreEqual(i.ToString(), ((ConstantExpression)token.Expression).Value);
}
}
/// <summary>
/// Recursive serialization method.
/// </summary>
/// <param name="o">Object to serialize.</param>
/// <param name="refs">Stack to keep track of objects being serialized, to spot cycles.</param>
/// <returns>JSON expression tree for the serialized object.</returns>
private Expression Serialize(object o, Stack <object> refs)
{
if (o == null)
{
return(Expression.Null());
}
var type = o.GetType();
// Nullables are weird. If they're not assigned null, we'll see their underlying value type here.
// The null check above takes care of our untyped null case.
if (type.IsEnum)
{
type = Enum.GetUnderlyingType(type);
}
if (type == typeof(string))
{
return(Expression.String((string)o));
}
else if (type == typeof(bool))
{
return(Expression.Boolean((bool)o));
}
else if (type == typeof(int))
{
return(Expression.Number(((int)o).ToString(CultureInfo.InvariantCulture)));
}
else if (type == typeof(uint))
{
return(Expression.Number(((uint)o).ToString(CultureInfo.InvariantCulture)));
}
else if (type == typeof(byte))
{
return(Expression.Number(((byte)o).ToString(CultureInfo.InvariantCulture)));
}
else if (type == typeof(sbyte))
{
return(Expression.Number(((sbyte)o).ToString(CultureInfo.InvariantCulture)));
}
else if (type == typeof(long))
{
return(Expression.Number(((long)o).ToString(CultureInfo.InvariantCulture)));
}
else if (type == typeof(ulong))
{
return(Expression.Number(((ulong)o).ToString(CultureInfo.InvariantCulture)));
}
else if (type == typeof(short))
{
return(Expression.Number(((short)o).ToString(CultureInfo.InvariantCulture)));
}
else if (type == typeof(ushort))
{
return(Expression.Number(((ushort)o).ToString(CultureInfo.InvariantCulture)));
}
else if (type == typeof(float))
{
return(Expression.Number(((float)o).ToString(CultureInfo.InvariantCulture)));
}
else if (type == typeof(double))
{
return(Expression.Number(((double)o).ToString(CultureInfo.InvariantCulture)));
}
else if (type == typeof(decimal))
{
return(Expression.Number(((decimal)o).ToString(CultureInfo.InvariantCulture)));
}
else if (type.IsArray || type.GetInterface("System.Collections.Generic.IList`1", false) != null || typeof(IList).IsAssignableFrom(type))
{
return(SerializeArray(o, refs));
}
else
{
return(SerializeObject(o, refs));
}
}
public override Expression Differentiate(Expression argument)
{
return(Expression.Divide(Expression.Number(1), argument));
}
public void JsonExpressionReader_Primitives_Decimal_InvalidInput()
{
Deserialize(FloatParseHandling.Decimal, Expression.Number("12.34???"));
}
public Expression Simplify(Expression expr)
{
if (expr is VariableExpression)
{
VariableExpression vexpr = (VariableExpression)expr;
string name = vexpr.Name;
if (existsVariable(name))
{
return(getVariable(name));
}
}
else if (expr is FunctionExpression)
{
FunctionExpression fexpr = (FunctionExpression)expr;
string name = fexpr.Name;
bool exists = existsFunction(name);
if (exists && !acceptsFunction(name, fexpr.Arguments.Count))
{
throw new Exception("Function doesn't accept as many arguments");
}
IList <double> varguments = new List <double>();
IList <Expression> arguments = new List <Expression>();
foreach (Expression arg in fexpr.Arguments)
{
Expression sarg = Simplify(arg);
arguments.Add(sarg);
if (sarg is NumberExpression)
{
varguments.Add(((NumberExpression)sarg).Value);
}
}
if (exists)
{
if (varguments.Count == arguments.Count)
{
return(Expression.Number(calculateFunction(name, varguments)));
}
return(evaluateFunction(name, arguments));
}
else
{
return(Expression.Function(name, arguments));
}
}
else if (expr is BinaryExpression)
{
BinaryExpression bexpr = (BinaryExpression)expr;
Binary op = bexpr.Operator;
Expression left = Simplify(bexpr.Left);
Expression right = Simplify(bexpr.Right);
if (left is NumberExpression && right is NumberExpression)
{
return(calculate(op, (NumberExpression)left, (NumberExpression)right));
}
else if (left is NumberExpression || right is NumberExpression)
{
double num;
Expression other;
bool isLeft = true;
if (left is NumberExpression)
{
num = ((NumberExpression)left).Value;
other = right;
}
else
{
isLeft = false;
num = ((NumberExpression)right).Value;
other = left;
}
if (num == 0 && op == Binary.Add ||
num == 0 && op == Binary.Subtract && !isLeft ||
num == 1 && op == Binary.Multiply ||
num == 1 && op == Binary.Divide && !isLeft ||
num == 1 && op == Binary.Power && !isLeft)
{
return(other);
}
if (num == 0 && op == Binary.Multiply ||
num == 0 && op == Binary.Divide && isLeft ||
num == 0 && op == Binary.Power && isLeft)
{
return(Expression.Number(0));
}
if (num == 0 && op == Binary.Power && !isLeft ||
num == 1 && op == Binary.Power && isLeft)
{
return(Expression.Number(1));
}
if (isLeft && op == Binary.Add)
{
return(Expression.Add(right, left));
}
if (!isLeft && op == Binary.Multiply)
{
return(Expression.Multiply(right, left));
}
}
else
{
if (op == Binary.Divide && left.Equals(right))
{
return(Expression.Number(1));
}
if (op == Binary.Subtract && left.Equals(right))
{
return(Expression.Number(0));
}
if (op == Binary.Add && right is BinaryExpression && ((BinaryExpression)right).Operator == Binary.Multiply && ((BinaryExpression)right).Left is NumberExpression && ((NumberExpression)((BinaryExpression)right).Left).Value == -1)
{
BinaryExpression bright = (BinaryExpression)right;
if (left.Equals(bright.Right))
{
return(Expression.Number(0));
}
}
}
return(Expression.FromBinary(bexpr.Operator, left, right));
}
else if (expr is LinearExpression)
{
LinearExpression lexpr = (LinearExpression)expr;
IList <Expression> list = new List <Expression>();
foreach (Expression item in lexpr.List)
{
list.Add(Simplify(item));
}
return(new LinearExpression(lexpr.Operator, list));
}
return(expr);
}
public void PrettyPrinter_Array()
{
AssertPretty(Expression.Array(Expression.Number("1"), Expression.Number("2")), "[" + Environment.NewLine + " 1," + Environment.NewLine + " 2" + Environment.NewLine + "]");
}
public void PrettyPrinter_Constant_Int()
{
AssertPretty(Expression.Number("42"), "42");
}
public Expression Differentiate(Expression expr)
{
if (expr is NumberExpression)
{
return(Expression.Number(0));
}
else if (expr is VariableExpression)
{
VariableExpression vexpr = (VariableExpression)expr;
if (vexpr.Name != var)
{
return(Expression.Number(0));
}
return(Expression.Number(1));
}
else if (expr is FunctionExpression)
{
FunctionExpression fexpr = (FunctionExpression)expr;
if (fexpr.Arguments.Count == 0)
{
return(Expression.Number(0));
}
int pos = 0;
Expression result = null;
foreach (Expression arg in fexpr.Arguments)
{
Expression darg = Differentiate(arg);
if (darg.Equals(Expression.Number(0)))
{
pos++;
continue;
}
else
{
Expression argResult = null;
Expression derivative = null;
if (fexpr.Arguments.Count > 1)
{
derivative = functions.Differentiate(fexpr.Name, fexpr.Arguments, pos, fexpr.Arguments.Count);
}
else
{
derivative = functions.Differentiate(fexpr.Name, fexpr.Arguments[0]);
}
if (darg.Equals(Expression.Number(1)))
{
argResult = derivative;
}
else
{
argResult = Expression.Multiply(derivative, darg);
}
if (result == null)
{
result = argResult;
}
else
{
result = Expression.Add(result, argResult);
}
}
pos++;
}
if (result == null)
{
result = Expression.Number(0);
}
return(result);
}
else if (expr is BinaryExpression)
{
BinaryExpression bexpr = (BinaryExpression)expr;
Expression left = bexpr.Left;
Expression right = bexpr.Right;
Expression dleft = Differentiate(left);
Expression dright = Differentiate(right);
if (bexpr.Operator == Binary.Add)
{
return(Expression.Add(dleft, dright));
}
else if (bexpr.Operator == Binary.Subtract)
{
return(Expression.Subtract(dleft, dright));
}
else if (bexpr.Operator == Binary.Multiply)
{
if (dleft.Equals(Expression.Number(0)))
{
return(Expression.Multiply(left, dright));
}
else if (dright.Equals(Expression.Number(0)))
{
return(Expression.Multiply(dleft, right));
}
return(Expression.Add(Expression.Multiply(dleft, right), Expression.Multiply(left, dright)));
}
else if (bexpr.Operator == Binary.Divide)
{
if (dright.Equals(Expression.Number(0)))
{
return(Expression.Divide(dleft, right));
}
else if (dleft.Equals(Expression.Number(0)))
{
return(Expression.Divide(Expression.Multiply(Expression.Multiply(Expression.Number(-1), left), dright), Expression.Power(right, Expression.Number(2))));
}
return(Expression.Divide(Expression.Subtract(Expression.Multiply(dleft, right), Expression.Multiply(left, dright)), Expression.Power(right, Expression.Number(2))));
}
else if (bexpr.Operator == Binary.Power)
{
if (dright.Equals(Expression.Number(0)))
{
return(Expression.Multiply(Expression.Multiply(right, Expression.Power(left, Expression.Subtract(right, Expression.Number(1)))), dleft));
}
else if (dleft.Equals(Expression.Number(0)))
{
return(Expression.Multiply(Expression.Multiply(Expression.Power(left, right), dright), log(left)));
}
return(Expression.Multiply(expr, Expression.Add(Expression.Multiply(dright, log(left)), Expression.Multiply(right, Expression.Divide(dleft, left)))));
}
}
return(expr);
}
public override Expression Evaluate(IList <Expression> arguments)
{
Expression arg = arguments[0];
return(Expression.Power(arg, Expression.Number(0.5)));
}
public void Add(string name, double value)
{
vars.Add(name, Expression.Number(value));
}
public BinaryExpression(double left, OperatorExpression op, double right)
{
Init(Expression.Number(left), op, Expression.Number(right));
}
public BinaryExpression(double left, char op, double right)
{
Init(Expression.Number(left), Expression.Operator(op), Expression.Number(right));
}
public override Expression Differentiate(Expression argument)
{
return(Expression.Multiply(Expression.Number(-1), Expression.Function(Sine.Alias, argument)));
}
public Expression ReturnSubtraction(Expression expr)
{
if (expr is FunctionExpression)
{
FunctionExpression fexpr = (FunctionExpression)expr;
IList <Expression> args = new List <Expression>();
foreach (Expression arg in fexpr.Arguments)
{
args.Add(Return(arg));
}
return(Expression.Function(fexpr.Name, args));
}
else if (expr is BinaryExpression)
{
BinaryExpression bexpr = (BinaryExpression)expr;
Expression left = ReturnSubtraction(bexpr.Left);
Expression right = ReturnSubtraction(bexpr.Right);
Expression oleft = left;
Expression oright = right;
if (bexpr.Operator == Binary.Multiply || bexpr.Operator == Binary.Divide)
{
/*
* bool negative = false;
*
* NumberExpression number = null;
* bool isLeft = false;
*
* if (left is NumberExpression && ((NumberExpression)left).Value < 0)
* {
* negative = true;
* nleft = Expression.Number(((NumberExpression)left).Value * -1);
*
* isLeft = true;
* number = (NumberExpression)nleft;
* }
* else if (right is NumberExpression && ((NumberExpression)right).Value < 0)
* {
* negative = true;
* nright = Expression.Number(((NumberExpression)right).Value * -1);
*
* number = (NumberExpression)nright;
* }
*
* if (left is NegativeExpression || right is NegativeExpression)
* negative = !negative;
*
* if (left is NegativeExpression)
* {
* nleft = ((NegativeExpression)nleft).Value;
* left = ((NegativeExpression)left).Original;
* }
* else if (right is NegativeExpression)
* {
* nright = ((NegativeExpression)nright).Value;
* right = ((NegativeExpression)right).Original;
* }
*
* Expression toReturn = null;
*
* if (number != null && number.Value == 1 && (bexpr.Operator == Binary.Multiply || bexpr.Operator == Binary.Divide && !isLeft))
* {
* if (isLeft)
* toReturn = nright;
* else
* toReturn = nleft;
* }
* else
* toReturn = Expression.FromBinary(bexpr.Operator, nleft, nright);
*
* if (!negative)
* return toReturn;
*
* return new NegativeExpression(toReturn, Expression.FromBinary(bexpr.Operator, left, right));
*/
bool negative = false;
if (left is NegativeExpression)
{
negative = !negative;
oleft = ((NegativeExpression)left).Original;
left = ((NegativeExpression)left).Value;
}
if (right is NegativeExpression)
{
negative = !negative;
oright = ((NegativeExpression)right).Original;
right = ((NegativeExpression)right).Value;
}
Expression full = null;
if (left is NumberExpression && ((NumberExpression)left).Value == 1 && bexpr.Operator == Binary.Multiply)
{
full = right;
}
else if (right is NumberExpression && ((NumberExpression)right).Value == 1 && (bexpr.Operator == Binary.Multiply || bexpr.Operator == Binary.Divide))
{
full = left;
}
else
{
full = Expression.FromBinary(bexpr.Operator, left, right);
}
if (negative)
{
full = new NegativeExpression(full, Expression.FromBinary(bexpr.Operator, oleft, oright));
}
return(full);
}
else if (bexpr.Operator == Binary.Add && (left is NegativeExpression || right is NegativeExpression))
{
if (!(left is NegativeExpression) && right is NegativeExpression)
{
return(Expression.Subtract(left, ((NegativeExpression)right).Value));
}
else if (left is NegativeExpression && !(right is NegativeExpression))
{
return(Expression.Subtract(right, ((NegativeExpression)left).Value));
}
else
{
return(Expression.Subtract(((NegativeExpression)left).Original, ((NegativeExpression)right).Value));
}
}
return(Expression.FromBinary(bexpr.Operator, left, right));
}
else if (expr is NumberExpression)
{
NumberExpression nexpr = (NumberExpression)expr;
if (nexpr.Value < 0)
{
return(new NegativeExpression(Expression.Number(-1 * nexpr.Value), nexpr));
}
return(nexpr);
}
return(expr);
}
