| private static Power ( string expression, int &index ) : double | ||
| expression | string | |
| index | int | |
| return | double | |
private static void VerifyNullableSBytePower(sbyte?a, sbyte?b)
{
Expression <Func <sbyte?> > e =
Expression.Lambda <Func <sbyte?> >(
Expression.Power(
Expression.Constant(a, typeof(sbyte?)),
Expression.Constant(b, typeof(sbyte?)),
typeof(BinaryNullablePowerTests).GetTypeInfo().GetDeclaredMethod("PowerSByte")
));
Func <sbyte?> f = e.Compile();
// compute with expression tree
sbyte? etResult = default(sbyte);
Exception etException = null;
try
{
etResult = f();
}
catch (Exception ex)
{
etException = ex;
}
// compute with real IL
sbyte? csResult = default(sbyte);
Exception csException = null;
if (a == null || b == null)
{
csResult = null;
}
else
{
try
{
csResult = (sbyte?)Math.Pow((double)a, (double)b);
}
catch (Exception ex)
{
csException = ex;
}
}
// either both should have failed the same way or they should both produce the same result
if (etException != null || csException != null)
{
Assert.NotNull(etException);
Assert.NotNull(csException);
Assert.Equal(csException.GetType(), etException.GetType());
}
else
{
Assert.Equal(csResult, etResult);
}
}
public void VisitBinaryExpression_Power()
{
var binaryExpression = Expression.Power(_leftDoubleExpression, _rightDoubleExpression);
_generator.GenerateSqlForBinaryExpression(binaryExpression);
var result = _commandBuilder.GetCommandText();
Assert.That(result, Is.EqualTo("POWER (leftDouble, rightDouble)"));
}
public void ReplacePower()
{
var power = Expression.Power(Expression.Constant(1d, typeof(double)),
Expression.Constant(2d, typeof(double)));
var sourceExpression = Expression.Lambda <Action>(power);
var replacement = Expression.Constant(3d, typeof(double));
Assert.AreEqual(replacement, new ReplacementVisitor().Transform(sourceExpression.Body, null,
power, replacement));
}
public void ShouldTranslateAMultiplicationPowerExpression()
{
var variableOne = Expression.Variable(typeof(double), "d1");
var variableTwo = Expression.Variable(typeof(double), "d2");
var varOneToThePowerOfVarTwo = Expression.Power(variableOne, variableTwo);
var translated = ToReadableString(varOneToThePowerOfVarTwo);
translated.ShouldBe("d1 ** d2");
}
public void TestCompile()
{
var a = Expression.Parameter(typeof(double), "a");
var b = Expression.Parameter(typeof(double), "b");
var power = Expression.Lambda <Func <double, double, double> > (
Expression.Power(a, b), a, b).Compile();
Assert.AreEqual(1, power(1, 10));
Assert.AreEqual(16, power(2, 4));
}
public T Power(T a, T b)
{
ParameterExpression param_a = Expression.Parameter(typeof(T), "a");
ParameterExpression param_b = Expression.Parameter(typeof(T), "b");
BinaryExpression body = Expression.Power(param_a, param_b);
Func <T, T, T> power = Expression.Lambda <Func <T, T, T> >(body, param_a, param_b).Compile();
return(power(a, b));
}
public virtual void Test024()
{
var expr = Expression.Default(typeof(double));
var expr1 = Expression.Power(expr, expr);
var expr2 = Expression.Power(expr, expr);
_assert.AreEqual(expr1, expr2);
}
public void Power()
{
Assert.AreEqual(8, Eval <int> (Expression.Power(
Expression.ConstantInt(2), Expression.ConstantInt(3))));
Assert.AreEqual(System.Math.Pow(2.1, 1.2), Eval <double> (Expression.Power(
Expression.ConstantDouble(2.1), Expression.ConstantDouble(1.2))));
Assert.AreEqual(System.Math.Pow(2.1, 1.2f), Eval <double> (Expression.Power(
Expression.ConstantDouble(2.1), Expression.ConstantFloat(1.2f))));
Assert.AreEqual((float)System.Math.Pow(2.1f, 1.2f), Eval <float> (Expression.Power(
Expression.ConstantFloat(2.1f), Expression.ConstantFloat(1.2f))));
}
public void ReplaceParameterInPowerOnRight()
{
var sourceParameter = Expression.Parameter(typeof(double), "a");
var sourceBody = sourceParameter;
var sourceExpression = Expression.Lambda <Action <double> >(sourceBody, sourceParameter);
var replacementParameter = Expression.Parameter(typeof(double), "a");
var replacement = Expression.Power(Expression.Constant(1d, typeof(double)), replacementParameter);
Assert.AreEqual(sourceParameter, (new ReplacementVisitor().Transform(sourceExpression.Body,
sourceExpression.Parameters,
sourceBody, replacement) as BinaryExpression).Right);
}
public IActionResult SomeIndex()
{
// The expression tree to execute.
BinaryExpression be = Expression.Power(Expression.Constant(2D), Expression.Constant(3D));
// Create a lambda expression.
Expression <Func <double> > le = Expression.Lambda <Func <double> >(be);
Func <double> compiledExpression = le.Compile();
double result = compiledExpression();
return(View());
}
public void TestPower1()
{
ParameterExpression a = Expression.Parameter(typeof(double));
ParameterExpression b = Expression.Parameter(typeof(double));
var exp = Expression.Lambda <Func <double, double, double> >(Expression.Power(a, b), a, b);
var f = Compile(exp, CompilerOptions.All);
Assert.AreEqual(1, f(0, 0));
Assert.AreEqual(1, f(1, 2));
Assert.AreEqual(16, f(2, 4));
Assert.AreEqual(1, f(-1, 2));
}
public void CompressWithPowerOfConstantsOnRight()
{
// (a * (3.4 ^ 2))
var parameter = Expression.Parameter(typeof(double), "a");
var body = Expression.Multiply(parameter,
Expression.Power(
Expression.Constant(3.4d),
Expression.Constant(2.0d)));
Assert.AreEqual("(a * (3.4 ^ 2))", body.ToString());
Assert.AreEqual("(a * 11.56)", body.Compress().ToString());
}
public void CompressWithPowerOfConstantsOnLeft()
{
// ((3.4 ^ 2) * a)
var parameter = Expression.Parameter(typeof(double), "a");
var body = Expression.Multiply(
Expression.Power(
Expression.Constant(3.4d),
Expression.Constant(2.0d)), parameter);
Assert.AreEqual("((3.4 ^ 2) * a)", body.ToString());
Assert.AreEqual("(11.56 * a)", body.Compress().ToString());
}
public void GetNodeWithParameterAsTarget()
{
// a => (((a + 3) ^ 0.5) ^ 0.5)
var parameter = Expression.Parameter(typeof(double), "a");
var body = Expression.Power(
Expression.Power(
Expression.Add(parameter, Expression.Constant(3d)),
Expression.Constant(0.5d)),
Expression.Constant(0.5d));
Assert.AreSame(parameter, body.GetNode(3));
}
//If an expression tree does not represent a lambda expression,
//you can create a new lambda expression that has the original expression tree as its body,
//by calling the Lambda<TDelegate>(Expression, IEnumerable<ParameterExpression>) method.
//Then, you can execute the lambda expression as described earlier in this section.
public static void ExecuteExpresionTree()
{
BinaryExpression binaryExpr = Expression.Power(Expression.Constant(2D), Expression.Constant(3D));
Expression <Func <double> > lambdaExpr = Expression.Lambda <Func <double> >(binaryExpr);
Func <double> compliedExpression = lambdaExpr.Compile();
double result = compliedExpression();
Console.WriteLine("result: " + result);
}
private static void VerifyFloatPower(float a, float b, bool useInterpreter)
{
Expression <Func <float> > e =
Expression.Lambda <Func <float> >(
Expression.Power(
Expression.Constant(a, typeof(float)),
Expression.Constant(b, typeof(float)),
typeof(BinaryPowerTests).GetTypeInfo().GetDeclaredMethod("PowerFloat")
));
Func <float> f = e.Compile(useInterpreter);
Assert.Equal(PowerFloat(a, b), f());
}
public void ArgTypesDouble()
{
var p = Expression.Power(Expression.Constant(1.0), Expression.Constant(2.0));
Assert.AreEqual(ExpressionType.Power, p.NodeType, "Power#01");
Assert.AreEqual(typeof(double), p.Type, "Add#02");
#if TARGETS_NETCORE
// This changed for .NET Core
Assert.AreEqual("(1 ** 2)", p.ToString());
#else
Assert.AreEqual("(1 ^ 2)", p.ToString());
#endif
}
private static void VerifyLongPower(long a, long b, bool useInterpreter)
{
Expression <Func <long> > e =
Expression.Lambda <Func <long> >(
Expression.Power(
Expression.Constant(a, typeof(long)),
Expression.Constant(b, typeof(long)),
typeof(BinaryPowerTests).GetTypeInfo().GetDeclaredMethod("PowerLong")
));
Func <long> f = e.Compile(useInterpreter);
Assert.Equal(PowerLong(a, b), f());
}
public void CompressWithNestedPowers()
{
// a => (((a + 3) ^ 0.5) ^ 0.5)
var parameter = Expression.Parameter(typeof(double), "a");
var body = Expression.Power(
Expression.Power(
Expression.Add(parameter, Expression.Constant(3d)),
Expression.Constant(0.5d)),
Expression.Constant(0.5d));
Assert.AreEqual("(((a + 3) ^ 0.5) ^ 0.5)", body.ToString());
Assert.AreEqual("((a + 3) ^ 0.25)", body.Compress().ToString());
}
private static IEnumerable <Expression> Power_Nullable()
{
foreach (var t in s_binaryPowerTypes)
{
foreach (var l in s_nullableExprs[t])
{
foreach (var r in s_nullableExprs[t])
{
yield return(Expression.Power(l, r));
}
}
}
}
private static void VerifyDoublePower(double a, double b, bool useInterpreter)
{
Expression <Func <double> > e =
Expression.Lambda <Func <double> >(
Expression.Power(
Expression.Constant(a, typeof(double)),
Expression.Constant(b, typeof(double)),
typeof(BinaryPowerTests).GetTypeInfo().GetDeclaredMethod("PowerDouble")
));
Func <double> f = e.Compile(useInterpreter);
Assert.Equal(PowerDouble(a, b), f());
}
private static void VerifyCharPower(char a, char b, bool useInterpreter)
{
Expression <Func <char> > e =
Expression.Lambda <Func <char> >(
Expression.Power(
Expression.Constant(a, typeof(char)),
Expression.Constant(b, typeof(char)),
typeof(BinaryPowerTests).GetTypeInfo().GetDeclaredMethod("PowerChar")
));
Func <char> f = e.Compile(useInterpreter);
Assert.Equal(PowerChar(a, b), f());
}
public void TestPower()
{
var p1 = Expression.Parameter(typeof(double), "a");
var p2 = Expression.Parameter(typeof(double), "b");
var expression = Expression.Lambda(
Expression.Power(p1, p2),
new ParameterExpression[] { p1, p2, });
Test(
expression,
"TestFiles\\Binary\\LambdaPower.xml");
}
public void ExpressionSlimCSharpPrinter_Binary()
{
var x = Expression.Parameter(typeof(int), "x");
var y = Expression.Parameter(typeof(double), "y");
AssertPrint(new Dictionary <Expression, string>
{
{ Expression.Add(Expression.Constant(1), Expression.Constant(2)), "1 + 2" },
{ Expression.AddChecked(Expression.Constant(1), Expression.Constant(2)), "checked(1 + 2)" },
{ Expression.And(Expression.Constant(1), Expression.Constant(2)), "1 & 2" },
{ Expression.And(Expression.Constant(true), Expression.Constant(false)), "true & false" },
{ Expression.AndAlso(Expression.Constant(true), Expression.Constant(false)), "true && false" },
{ Expression.ArrayIndex(Expression.NewArrayInit(typeof(int), Expression.Constant(1)), Expression.Constant(7)), "new int[] { 1 }[7]" },
{ Expression.Coalesce(Expression.Constant("foo"), Expression.Constant("bar")), "\"foo\" ?? \"bar\"" },
{ Expression.Divide(Expression.Constant(1), Expression.Constant(2)), "1 / 2" },
{ Expression.Equal(Expression.Constant(1), Expression.Constant(2)), "1 == 2" },
{ Expression.ExclusiveOr(Expression.Constant(1), Expression.Constant(2)), "1 ^ 2" },
{ Expression.GreaterThan(Expression.Constant(1), Expression.Constant(2)), "1 > 2" },
{ Expression.GreaterThanOrEqual(Expression.Constant(1), Expression.Constant(2)), "1 >= 2" },
{ Expression.LeftShift(Expression.Constant(1), Expression.Constant(2)), "1 << 2" },
{ Expression.LessThan(Expression.Constant(1), Expression.Constant(2)), "1 < 2" },
{ Expression.LessThanOrEqual(Expression.Constant(1), Expression.Constant(2)), "1 <= 2" },
{ Expression.Modulo(Expression.Constant(1), Expression.Constant(2)), "1 % 2" },
{ Expression.Multiply(Expression.Constant(1), Expression.Constant(2)), "1 * 2" },
{ Expression.MultiplyChecked(Expression.Constant(1), Expression.Constant(2)), "checked(1 * 2)" },
{ Expression.NotEqual(Expression.Constant(1), Expression.Constant(2)), "1 != 2" },
{ Expression.Or(Expression.Constant(1), Expression.Constant(2)), "1 | 2" },
{ Expression.Or(Expression.Constant(true), Expression.Constant(false)), "true | false" },
{ Expression.OrElse(Expression.Constant(true), Expression.Constant(false)), "true || false" },
{ Expression.Power(Expression.Constant(1.0), Expression.Constant(2.0)), "System.Math.Pow(1D, 2D)" },
{ Expression.RightShift(Expression.Constant(1), Expression.Constant(2)), "1 >> 2" },
{ Expression.Subtract(Expression.Constant(1), Expression.Constant(2)), "1 - 2" },
{ Expression.SubtractChecked(Expression.Constant(1), Expression.Constant(2)), "checked(1 - 2)" },
{ Expression.AddAssign(x, Expression.Constant(2)), "x += 2" },
{ Expression.AddAssignChecked(x, Expression.Constant(2)), "checked(x += 2)" },
{ Expression.AndAssign(x, Expression.Constant(2)), "x &= 2" },
{ Expression.Assign(x, Expression.Constant(2)), "x = 2" },
{ Expression.DivideAssign(x, Expression.Constant(2)), "x /= 2" },
{ Expression.ExclusiveOrAssign(x, Expression.Constant(2)), "x ^= 2" },
{ Expression.LeftShiftAssign(x, Expression.Constant(2)), "x <<= 2" },
{ Expression.ModuloAssign(x, Expression.Constant(2)), "x %= 2" },
{ Expression.MultiplyAssign(x, Expression.Constant(2)), "x *= 2" },
{ Expression.MultiplyAssignChecked(x, Expression.Constant(2)), "checked(x *= 2)" },
{ Expression.OrAssign(x, Expression.Constant(2)), "x |= 2" },
{ Expression.PowerAssign(y, Expression.Constant(2.0)), "y = System.Math.Pow(y, 2D)" },
{ Expression.RightShiftAssign(x, Expression.Constant(2)), "x >>= 2" },
{ Expression.SubtractAssign(x, Expression.Constant(2)), "x -= 2" },
{ Expression.SubtractAssignChecked(x, Expression.Constant(2)), "checked(x -= 2)" },
});
}
public void GetNodeCountOfLambda()
{
// a => (((a + 3) ^ 0.5) ^ 0.5)
var target = Expression.Constant(3d);
var parameter = Expression.Parameter(typeof(double), "a");
var body = Expression.Lambda(
Expression.Power(
Expression.Power(
Expression.Add(parameter, target),
Expression.Constant(0.5d)),
Expression.Constant(0.5d)), parameter);
Assert.AreEqual(7, body.GetNodeCount());
}
private static Expression HandlePowerReductionCase(Expression reduced, BinaryExpression binary)
{
if (binary.NodeType == ExpressionType.Power &&
binary.Right.NodeType == ExpressionType.Constant &&
binary.Left.NodeType == ExpressionType.Power &&
(binary.Left as BinaryExpression).Right.NodeType == ExpressionType.Constant)
{
reduced = Expression.Power((binary.Left as BinaryExpression).Left,
Expression.Constant(
(double)((binary.Right as ConstantExpression).Value) *
(double)(((binary.Left as BinaryExpression).Right as ConstantExpression).Value)));
}
return(reduced);
}
public void Power()
{
var parameter = Expression.Parameter(typeof(Cook), "c");
var weight = Expression.MakeMemberAccess(parameter, typeof(Cook).GetProperty("Weight"));
var selector = Expression.Lambda <Func <Cook, double> > (Expression.Power(weight, Expression.Constant(3.0)), parameter);
var query = Cooks.Select(selector); // from c in Cooks select c.Weight**3
CheckQuery(
query,
"SELECT (POWER ([t0].[Weight], @1)) AS [value] FROM [CookTable] AS [t0]",
row => (object)row.GetValue <double> (new ColumnID("value", 0)),
new CommandParameter("@1", 3.0)
);
}
public void NullablePower()
{
var a = Expression.Parameter(typeof(double?), "a");
var b = Expression.Parameter(typeof(double?), "b");
var power = Expression.Lambda <Func <double?, double?, double?> > (
Expression.Power(a, b), a, b).Compile();
Assert.AreEqual((double?)1, power(1, 10));
Assert.AreEqual((double?)16, power(2, 4));
Assert.AreEqual((double?)null, power(1, null));
Assert.AreEqual((double?)null, power(null, 1));
Assert.AreEqual((double?)null, power(null, null));
}
private static Expression Differentiate(BinaryExpression expression)
{
switch (expression.NodeType)
{
case ExpressionType.Add:
return(Expression.Add(
Differentiate(expression.Left),
Differentiate(expression.Right)
));
case ExpressionType.Subtract:
return(Expression.Subtract(
Differentiate(expression.Left),
Differentiate(expression.Right)
));
case ExpressionType.Multiply:
return(Expression.Add(
Expression.Multiply(
Differentiate(expression.Left),
expression.Right
),
Expression.Multiply(
expression.Left,
Differentiate(expression.Right)
)
));
case ExpressionType.Divide:
return(Expression.Divide(
Expression.Subtract(
Expression.Multiply(
Differentiate(expression.Left),
expression.Right
),
Expression.Multiply(
expression.Left,
Differentiate(expression.Right)
)
),
Expression.Power(
expression.Right,
Expression.Constant(2)
)
));
}
throw new ArgumentException("Unknown binary operation!");
}
public void ReplacePowerRightPart()
{
var leftPart = Expression.Constant(1d, typeof(double));
var rightPart = Expression.Constant(2d, typeof(double));
var power = Expression.Power(leftPart, rightPart);
var sourceExpression = Expression.Lambda <Action>(power);
var replacement = Expression.Constant(3d, typeof(double));
var result = new ReplacementVisitor().Transform(sourceExpression.Body, null,
rightPart, replacement) as BinaryExpression;
Assert.AreEqual(ExpressionType.Power, result.NodeType);
Assert.AreEqual(leftPart, result.Left);
Assert.AreEqual(replacement, result.Right);
}
