| public static Power ( Expression left, Expression right ) : BinaryExpression | ||
| left | Expression | An |
| right | Expression | An |
| return | BinaryExpression | |
public static Expression Power(Expression arg0, Expression arg1)
{
var arg0b = LinqExpression.Convert(arg0, typeof(double));
var arg1b = LinqExpression.Convert(arg1, typeof(double));
return(new Expression(LinqExpression.Convert(LinqExpression.Power(arg0b, arg1b), arg0.Type)));
}
public void BinaryExpression_Power()
{
ExecuteBinaryExpr(Property.Id, id =>
{
var pow = Expr.Convert(Expr.Power(Expr.Convert(id, typeof(double)), Expr.Constant(2.0)), typeof(int));
return(pow);
}, ExpressionType.Power);
}
private BinaryExpression BinaryExpression(
ExpressionType nodeType, System.Type type, JObject obj)
{
var left = this.Prop(obj, "left", this.Expression);
var right = this.Prop(obj, "right", this.Expression);
var method = this.Prop(obj, "method", this.Method);
var conversion = this.Prop(obj, "conversion", this.LambdaExpression);
var liftToNull = this.Prop(obj, "liftToNull").Value <bool>();
switch (nodeType)
{
case ExpressionType.Add: return(Expr.Add(left, right, method));
case ExpressionType.AddAssign: return(Expr.AddAssign(left, right, method, conversion));
case ExpressionType.AddAssignChecked: return(Expr.AddAssignChecked(left, right, method, conversion));
case ExpressionType.AddChecked: return(Expr.AddChecked(left, right, method));
case ExpressionType.And: return(Expr.And(left, right, method));
case ExpressionType.AndAlso: return(Expr.AndAlso(left, right, method));
case ExpressionType.AndAssign: return(Expr.AndAssign(left, right, method, conversion));
case ExpressionType.ArrayIndex: return(Expr.ArrayIndex(left, right));
case ExpressionType.Assign: return(Expr.Assign(left, right));
case ExpressionType.Coalesce: return(Expr.Coalesce(left, right, conversion));
case ExpressionType.Divide: return(Expr.Divide(left, right, method));
case ExpressionType.DivideAssign: return(Expr.DivideAssign(left, right, method, conversion));
case ExpressionType.Equal: return(Expr.Equal(left, right, liftToNull, method));
case ExpressionType.ExclusiveOr: return(Expr.ExclusiveOr(left, right, method));
case ExpressionType.ExclusiveOrAssign: return(Expr.ExclusiveOrAssign(left, right, method, conversion));
case ExpressionType.GreaterThan: return(Expr.GreaterThan(left, right, liftToNull, method));
case ExpressionType.GreaterThanOrEqual: return(Expr.GreaterThanOrEqual(left, right, liftToNull, method));
case ExpressionType.LeftShift: return(Expr.LeftShift(left, right, method));
case ExpressionType.LeftShiftAssign: return(Expr.LeftShiftAssign(left, right, method, conversion));
case ExpressionType.LessThan: return(Expr.LessThan(left, right, liftToNull, method));
case ExpressionType.LessThanOrEqual: return(Expr.LessThanOrEqual(left, right, liftToNull, method));
case ExpressionType.Modulo: return(Expr.Modulo(left, right, method));
case ExpressionType.ModuloAssign: return(Expr.ModuloAssign(left, right, method, conversion));
case ExpressionType.Multiply: return(Expr.Multiply(left, right, method));
case ExpressionType.MultiplyAssign: return(Expr.MultiplyAssign(left, right, method, conversion));
case ExpressionType.MultiplyAssignChecked: return(Expr.MultiplyAssignChecked(left, right, method, conversion));
case ExpressionType.MultiplyChecked: return(Expr.MultiplyChecked(left, right, method));
case ExpressionType.NotEqual: return(Expr.NotEqual(left, right, liftToNull, method));
case ExpressionType.Or: return(Expr.Or(left, right, method));
case ExpressionType.OrAssign: return(Expr.OrAssign(left, right, method, conversion));
case ExpressionType.OrElse: return(Expr.OrElse(left, right, method));
case ExpressionType.Power: return(Expr.Power(left, right, method));
case ExpressionType.PowerAssign: return(Expr.PowerAssign(left, right, method, conversion));
case ExpressionType.RightShift: return(Expr.RightShift(left, right, method));
case ExpressionType.RightShiftAssign: return(Expr.RightShiftAssign(left, right, method, conversion));
case ExpressionType.Subtract: return(Expr.Subtract(left, right, method));
case ExpressionType.SubtractAssign: return(Expr.SubtractAssign(left, right, method, conversion));
case ExpressionType.SubtractAssignChecked: return(Expr.SubtractAssignChecked(left, right, method, conversion));
case ExpressionType.SubtractChecked: return(Expr.SubtractChecked(left, right, method));
default: throw new NotSupportedException();
}
}
protected Expression VisitMathMethodCall([NotNull] MethodCallExpression m)
{
switch (m.Method.Name)
{
case "Pow": return(Visit(sPower(Expression.Power(m.Arguments[0], m.Arguments[1]))));
case "Sin":
{
var x = m.Arguments[0];
return(sMultiply(Visit(x), MathMethod("Cos", x)));
}
case "Cos":
{
var x = m.Arguments[0];
return(Expression.Negate(sMultiply(Visit(x), MathMethod("Sin", x))));
}
case "Tan":
{
var x = m.Arguments[0];
return(sMultiply(Visit(x), sDivide(1, sPower(MathMethod("Cos", x), 2))));
}
case "Asin":
{
var x = m.Arguments[0];
return(sMultiply(Visit(x), sDivide(1, MathMethod("Sqrt", sSubtract(1, sPower(x, 2))))));
}
case "Acos":
{
var x = m.Arguments[0];
return(Expression.Negate(sMultiply(Visit(x), sDivide(1, MathMethod("Sqrt", sSubtract(1, sPower(x, 2)))))));
}
case "Atan":
{
var x = m.Arguments[0];
return(sMultiply(Visit(x), sDivide(1, sAdd(1, sPower(x, 2)))));
}
case "Sinh":
{
var x = m.Arguments[0];
return(sMultiply(Visit(x), MathMethod("Cosh", x)));
}
case "Cosh":
{
var x = m.Arguments[0];
return(sMultiply(Visit(x), MathMethod("Sinh", x)));
}
case "Tanh":
{
var x = m.Arguments[0];
return(sMultiply(Visit(x), sDivide(1, sPower(sDivide(1, MathMethod("Tanh", x)), 2))));
}
case "Abs":
{
var x = m.Arguments[0];
var condition = Expression.Condition
(
Expression.Equal(x, Expression.Constant(0.0)),
Expression.Constant(0.0),
Expression.Convert(MathMethod("Sign", x), typeof(double))
);
return(sMultiply(Visit(x), condition));
}
case "Sign":
{
var x = m.Arguments[0];
var condition = Expression.Condition
(
Expression.Equal(x, Expression.Constant(0.0)),
Expression.Constant(double.PositiveInfinity),
Expression.Constant(0.0)
);
return(sMultiply(Visit(x), condition));
}
case "Sqrt":
return(Visit(sPower(m.Arguments[0],
Expression.Divide(Expression.Constant(1.0), Expression.Constant(2.0)))));
case "Exp":
{
var x = m.Arguments[0];
return(sMultiply(Visit(x), MathMethod("Exp", x)));
}
case "Log":
{
var x = m.Arguments[0];
if (m.Arguments.Count > 1)
{
var a = m.Arguments[1];
var expr = sDivide(MathMethod("Log", x), MathMethod("Log", a));
return(Visit(expr));
}
var dx = Visit(x);
return(sDivide(dx, x));
}
case "Log10":
{
var x = m.Arguments[0];
var expr = MathMethod("Log", x, Expression.Constant(10.0));
return(Visit(expr));
}
default:
throw new NotSupportedException();
}
}
[NotNull] private static Expression sPower([NotNull] Expression a, double b) => sPower(Expression.Power(a, Expression.Constant(b)));
[NotNull] private static Expression sPower([NotNull] Expression a, [NotNull] Expression b) => sPower(Expression.Power(a, b));
