Dlr getDlr() { var aToken = childs.Dequeue(); var asig = aToken as Operator; if (asig != null && asig.type == OperatorType.OpenParenthesis) { return(getDlr()); } var a = aToken as Value; if (childs.count == 0) { return(a.value); } var op = childs.Dequeue() as Operator; if (op.type == OperatorType.CloseParenthesis) { return(Dlr.Constant(a.value)); } var b = getValue(); switch (op.type) { case OperatorType.Add: return(Dlr.Add(Dlr.Constant(a.value), Dlr.Constant(b))); case OperatorType.Subtract: return(Dlr.Subtract(Dlr.Constant(a.value), Dlr.Constant(b))); case OperatorType.Divide: return(Dlr.Divide(Dlr.Constant(a.value), Dlr.Constant(b))); case OperatorType.Multiply: return(Dlr.Multiply(Dlr.Constant(a.value), Dlr.Constant(b))); } return(Dlr.Empty()); }
public override System.Linq.Expressions.Expression GenerateLinqExpression(IASTContext context) { GenerateLinqExpresions(context, left, right, out LinqExpression expLeft, out LinqExpression expRight); if (IsNullable(expLeft.Type) && !IsNullable(expRight.Type)) { expRight = LinqExpression.MakeUnary(System.Linq.Expressions.ExpressionType.Convert, expRight, expLeft.Type); } else if (IsNullable(expRight.Type) && !IsNullable(expLeft.Type)) { expLeft = LinqExpression.MakeUnary(System.Linq.Expressions.ExpressionType.Convert, expLeft, expRight.Type); } switch (op) { case Operator.OP_ADD: return(LinqExpression.Add(expLeft, expRight)); case Operator.OP_SUB: return(LinqExpression.Subtract(expLeft, expRight)); case Operator.OP_DIV: return(LinqExpression.Divide(expLeft, expRight)); case Operator.OP_MUL: return(LinqExpression.Multiply(expLeft, expRight)); case Operator.OP_AND: return(LinqExpression.AndAlso(expLeft, expRight)); case Operator.OP_OR: return(LinqExpression.OrElse(expLeft, expRight)); case Operator.OP_EQUAL: return(LinqExpression.Equal(expLeft, expRight)); case Operator.OP_DISTINT: return(LinqExpression.NotEqual(expLeft, expRight)); case Operator.OP_LIKE: return(CreateLike(expLeft, expRight)); case Operator.OP_LESS: return(LinqExpression.LessThan(expLeft, expRight)); case Operator.OP_GREATHER: return(LinqExpression.GreaterThan(expLeft, expRight)); case Operator.OP_GREATHER_EQ: return(LinqExpression.GreaterThanOrEqual(expLeft, expRight)); case Operator.OP_LESS_EQ: return(LinqExpression.LessThanOrEqual(expLeft, expRight)); default: throw new InvalidOperationException("operator not supported"); } }
static MetaNumeric() { Type type = typeof(T); var left = Ex.Parameter(type, "left"); var right = Ex.Parameter(type, "right"); addition = Ex.Lambda <Func <T, T, T> >(Ex.Add(left, right), left, right).Compile(); subtraction = Ex.Lambda <Func <T, T, T> >(Ex.Subtract(left, right), left, right).Compile(); multiplication = Ex.Lambda <Func <T, T, T> >(Ex.Multiply(left, right), left, right).Compile(); division = Ex.Lambda <Func <T, T, T> >(Ex.Divide(left, right), left, right).Compile(); }
public static Expression Divide(Expression arg0, Expression arg1) { return(new Expression(LinqExpression.Divide(arg0, arg1))); }
public static Func <TExArgCtx, TEx <R> > PA_Div <R>(Func <TExArgCtx, TEx <R> > a, Func <TExArgCtx, TEx <float> > b) => t => Ex.Divide(a(t), b(t));