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 Add(Expression arg0, Expression arg1) { return(new Expression(LinqExpression.Add(arg0, arg1))); }
/// <summary> /// Add to the rotational components of an RV2. /// </summary> public static trv2 AddRV(trv2 rv2, tv2 rv) => Ex.Add(rv2, Ex.Convert(rv, typeof(Vector3)));
/// <summary> /// Add to the rotational components and angle of an RV2. /// </summary> public static trv2 AddRVA(trv2 rv2, tv3 rva) => Ex.Add(rv2, rva);
/// <summary> /// Add to the nonrotational components and angle of an RV2. /// </summary> public static trv2 AddNVA(trv2 rv2, tv2 nv, tfloat ang) => Ex.Add(Ex.Add(rv2, nv), ang);
/// <summary> /// Add to the angle of an RV2. /// </summary> public static trv2 AddA(trv2 rv2, tfloat ang) => Ex.Add(rv2, ang);
/// <summary> /// Add to the nonrotational components of an RV2. /// </summary> public static trv2 AddNV(trv2 rv2, tv2 nv) => Ex.Add(rv2, nv);