|
public static Negate ( |
||
| expression | An |
|
| return | ||
public void Method()
{
var expected =
LinqExpression.Negate(
LinqExpression.Default(
typeof(bool)),
typeof(SampleClass).GetMethod(nameof(SampleClass.StaticFunctionWithArgument)));
var actual = $@"
@prefix : <http://example.com/> .
@prefix xt: <http://example.com/ExpressionTypes/> .
:s
:unaryExpressionType xt:Negate ;
:unaryOperand [
:defaultType [
:typeName ""System.Boolean"" ;
] ;
] ;
:unaryMethod [
:memberType [
:typeName ""GraphEngine.Tests.SampleClass, GraphEngine.Tests"" ;
] ;
:memberName ""StaticFunctionWithArgument"" ;
] ;
.
";
ShouldBe(actual, expected);
}
static E Compile(
ElementExpression expression,
Dictionary <string, ParameterExpression> spans,
Dictionary <string, ParameterExpression> indices)
{
switch (expression.ArityKind)
{
case ArityKind.Element:
return(Compile(expression.Element, spans, indices));
case ArityKind.Unary:
switch (expression.UnaryKind)
{
case UnaryExpressionKind.Exp:
throw new NotImplementedException();
case UnaryExpressionKind.Log:
throw new NotImplementedException();
default:
throw new NotSupportedException();
}
case ArityKind.Binary:
switch (expression.BinaryKind)
{
case BinaryExpressionKind.Add:
return(E.Add(
Compile(expression.Expr1, spans, indices),
Compile(expression.Expr2, spans, indices)));
case BinaryExpressionKind.Subtract:
return(E.Add(
Compile(expression.Expr1, spans, indices),
E.Negate(Compile(expression.Expr2, spans, indices))));
case BinaryExpressionKind.Multiply:
return(E.Multiply(
Compile(expression.Expr1, spans, indices),
Compile(expression.Expr2, spans, indices)));
case BinaryExpressionKind.Divide:
return(E.Divide(
Compile(expression.Expr1, spans, indices),
Compile(expression.Expr2, spans, indices)));
default:
throw new NotSupportedException();
}
case ArityKind.Ternary:
throw new NotImplementedException();
default:
throw new NotSupportedException();
}
}
public void UnaryMethod()
{
var expression =
LinqExpression.Negate(
LinqExpression.Default(
typeof(bool)),
typeof(SampleClass).GetMethod(nameof(SampleClass.StaticFunctionWithArgument)));
ShouldRoundrip(expression);
}
private UnaryExpression UnaryExpression(
ExpressionType nodeType, System.Type type, JObject obj)
{
var operand = this.Prop(obj, "operand", this.Expression);
var method = this.Prop(obj, "method", this.Method);
switch (nodeType)
{
case ExpressionType.ArrayLength: return(Expr.ArrayLength(operand));
case ExpressionType.Convert: return(Expr.Convert(operand, type, method));
case ExpressionType.ConvertChecked: return(Expr.ConvertChecked(operand, type, method));
case ExpressionType.Decrement: return(Expr.Decrement(operand, method));
case ExpressionType.Increment: return(Expr.Increment(operand, method));
case ExpressionType.IsFalse: return(Expr.IsFalse(operand, method));
case ExpressionType.IsTrue: return(Expr.IsTrue(operand, method));
case ExpressionType.Negate: return(Expr.Negate(operand, method));
case ExpressionType.NegateChecked: return(Expr.NegateChecked(operand, method));
case ExpressionType.Not: return(Expr.Not(operand, method));
case ExpressionType.OnesComplement: return(Expr.OnesComplement(operand, method));
case ExpressionType.PostDecrementAssign: return(Expr.PostDecrementAssign(operand, method));
case ExpressionType.PostIncrementAssign: return(Expr.PostIncrementAssign(operand, method));
case ExpressionType.PreDecrementAssign: return(Expr.PreDecrementAssign(operand, method));
case ExpressionType.PreIncrementAssign: return(Expr.PreIncrementAssign(operand, method));
case ExpressionType.Quote: return(Expr.Quote(operand));
case ExpressionType.Throw: return(Expr.Throw(operand, type));
case ExpressionType.TypeAs: return(Expr.TypeAs(operand, type));
case ExpressionType.UnaryPlus: return(Expr.UnaryPlus(operand, method));
case ExpressionType.Unbox: return(Expr.Unbox(operand, type));
default: throw new NotSupportedException();
}
}
static E Compile(
IndexExpression expression,
Dictionary <string, ParameterExpression> spans,
Dictionary <string, ParameterExpression> indices)
{
switch (expression.ArityKind)
{
case IndexExpressionArityKind.Constant:
return(E.Constant(expression.Constant));
case IndexExpressionArityKind.Index:
return(indices[expression.Index.Name]);
case IndexExpressionArityKind.Element:
if (expression.Element.Symbol.Shape.Kind != ElementKind.Int32)
{
throw new InvalidOperationException("Integer tensor requires for table lookups.");
}
return(Compile(expression.Element, spans, indices));
case IndexExpressionArityKind.Binary:
switch (expression.BinaryKind)
{
case BinaryExpressionKind.Add:
return(E.Add(
Compile(expression.Expr1, spans, indices),
Compile(expression.Expr2, spans, indices)));
case BinaryExpressionKind.Subtract:
return(E.Add(
Compile(expression.Expr1, spans, indices),
E.Negate(Compile(expression.Expr2, spans, indices))));
case BinaryExpressionKind.Multiply:
return(E.Multiply(
Compile(expression.Expr1, spans, indices),
Compile(expression.Expr2, spans, indices)));
case BinaryExpressionKind.Divide:
return(E.Divide(
Compile(expression.Expr1, spans, indices),
Compile(expression.Expr2, spans, indices)));
default:
throw new NotSupportedException();
}
default:
throw new NotSupportedException();
}
}
// Solve a system of linear equations
private static void Solve(CodeGen code, LinqExpr Ab, IEnumerable <LinearCombination> Equations, IEnumerable <Expression> Unknowns)
{
LinearCombination[] eqs = Equations.ToArray();
Expression[] deltas = Unknowns.ToArray();
int M = eqs.Length;
int N = deltas.Length;
// Initialize the matrix.
for (int i = 0; i < M; ++i)
{
LinqExpr Abi = code.ReDeclInit <double[]>("Abi", LinqExpr.ArrayAccess(Ab, LinqExpr.Constant(i)));
for (int x = 0; x < N; ++x)
{
code.Add(LinqExpr.Assign(
LinqExpr.ArrayAccess(Abi, LinqExpr.Constant(x)),
code.Compile(eqs[i][deltas[x]])));
}
code.Add(LinqExpr.Assign(
LinqExpr.ArrayAccess(Abi, LinqExpr.Constant(N)),
code.Compile(eqs[i][1])));
}
// Gaussian elimination on this turd.
//RowReduce(code, Ab, M, N);
code.Add(LinqExpr.Call(
GetMethod <Simulation>("RowReduce", Ab.Type, typeof(int), typeof(int)),
Ab,
LinqExpr.Constant(M),
LinqExpr.Constant(N)));
// Ab is now upper triangular, solve it.
for (int j = N - 1; j >= 0; --j)
{
LinqExpr _j = LinqExpr.Constant(j);
LinqExpr Abj = code.ReDeclInit <double[]>("Abj", LinqExpr.ArrayAccess(Ab, _j));
LinqExpr r = LinqExpr.ArrayAccess(Abj, LinqExpr.Constant(N));
for (int ji = j + 1; ji < N; ++ji)
{
r = LinqExpr.Add(r, LinqExpr.Multiply(LinqExpr.ArrayAccess(Abj, LinqExpr.Constant(ji)), code[deltas[ji]]));
}
code.DeclInit(deltas[j], LinqExpr.Divide(LinqExpr.Negate(r), LinqExpr.ArrayAccess(Abj, _j)));
}
}
private Exp MakeUnary(CompilerState state, Node node)
{
if (state == null)
{
throw new Exception();
}
if (node == null)
{
throw new Exception();
}
var data = node.Token.Data as Tokenizing.OperatorData;
if (data == null)
{
throw new Exception();
}
if (node.Children.Count != 1)
{
throw new Exception();
}
if (data.Operator == Operator.Minus)
{
var value = Make(state, node.Children[0]);
return(Exp.Negate(value));
}
if (data.Operator == Operator.LogicalNot)
{
var value = Make(state, node.Children[0]);
return(Exp.Not(ToBoolean(value)));
}
throw new Exception();
}
public static Ex Neg(this Ex me) => Ex.Negate(me);
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();
}
}
public static UnaryExpression Negate(Expression expression) => Expression.Negate(expression);
public static UnaryExpression Negate(Expression expression, MethodInfo method) => Expression.Negate(expression, method);
