|
public static Divide ( |
||
| left | An |
|
| right | An |
|
| return | ||
/// <summary>
/// Home towards a target location at a fixed speed.
/// </summary>
/// <remarks>
/// Use with StopSampling to home for only a few seconds.
/// <para>This is primarily for use with non-rotational velocity.
/// Rotational use creates: contracting spirals (0,90), circle around player [90], expanding spiral (90,180).</para>
/// </remarks>
/// <param name="speed">Speed</param>
/// <param name="location">Target location</param>
/// <returns></returns>
public static ExTP VHome(ExBPY speed, ExTP location)
{
TExV2 l = new TExV2();
return(bpi => Ex.Block(new ParameterExpression[] { l },
Ex.Assign(l, location(bpi).Sub(bpi.loc)),
l.Mul(Ex.Divide(speed(bpi), Sqrt(Ex.Add(SqrMag(l), EPS))))
));
}
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();
}
}
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)));
}
}
public void TestWhereArithmetic()
{
var parameter = LinqExpression.Parameter(typeof(NumbersModel), "x");
var n1 = LinqExpression.Property(parameter, "Number1");
var n2 = LinqExpression.Property(parameter, "Number2");
var m2g8 = new Func <int, int, bool>((x1, x2) => x1 * 2 > 8);
var d2g3 = new Func <int, int, bool>((x1, x2) => x1 / 2 > 3);
var m2e0 = new Func <int, int, bool>((x1, x2) => (x1 % 2) == 0);
var a5g10 = new Func <int, int, bool>((x1, x2) => x1 + 5 > 10);
var s5g0 = new Func <int, int, bool>((x1, x2) => x1 - 5 > 0);
var mn2g10 = new Func <int, int, bool>((x1, x2) => x1 * x2 > 10);
var dn1g3 = new Func <int, int, bool>((x1, x2) => x2 / x1 > 3);
var mn2e0 = new Func <int, int, bool>((x1, x2) => (x1 % x2) == 0);
var an2e10 = new Func <int, int, bool>((x1, x2) => x1 + x2 == 10);
var sn2g0 = new Func <int, int, bool>((x1, x2) => x1 - x2 > 0);
var cases = new[] {
Tuple.Create((LinqExpression)LinqExpression.GreaterThan(LinqExpression.Multiply(n1, LinqExpression.Constant(2)), LinqExpression.Constant(8)),
(Func <NumbersModel, object, bool>)TestWhereMathValidator, (object)m2g8, parameter),
Tuple.Create((LinqExpression)LinqExpression.GreaterThan(LinqExpression.Divide(n1, LinqExpression.Constant(2)), LinqExpression.Constant(3)),
(Func <NumbersModel, object, bool>)TestWhereMathValidator, (object)d2g3, parameter),
Tuple.Create((LinqExpression)LinqExpression.Equal(LinqExpression.Modulo(n1, LinqExpression.Constant(2)), LinqExpression.Constant(0)),
(Func <NumbersModel, object, bool>)TestWhereMathValidator, (object)m2e0, parameter),
Tuple.Create((LinqExpression)LinqExpression.GreaterThan(LinqExpression.Add(n1, LinqExpression.Constant(5)), LinqExpression.Constant(10)),
(Func <NumbersModel, object, bool>)TestWhereMathValidator, (object)a5g10, parameter),
Tuple.Create((LinqExpression)LinqExpression.GreaterThan(LinqExpression.Subtract(n1, LinqExpression.Constant(5)), LinqExpression.Constant(0)),
(Func <NumbersModel, object, bool>)TestWhereMathValidator, (object)s5g0, parameter),
Tuple.Create((LinqExpression)LinqExpression.GreaterThan(LinqExpression.Multiply(n1, n2), LinqExpression.Constant(10)),
(Func <NumbersModel, object, bool>)TestWhereMathValidator, (object)mn2g10, parameter),
Tuple.Create((LinqExpression)LinqExpression.GreaterThan(LinqExpression.Divide(n2, n1), LinqExpression.Constant(3)),
(Func <NumbersModel, object, bool>)TestWhereMathValidator, (object)dn1g3, parameter),
Tuple.Create((LinqExpression)LinqExpression.Equal(LinqExpression.Modulo(n1, n2), LinqExpression.Constant(0)),
(Func <NumbersModel, object, bool>)TestWhereMathValidator, (object)mn2e0, parameter),
Tuple.Create((LinqExpression)LinqExpression.Equal(LinqExpression.Add(n1, n2), LinqExpression.Constant(10)),
(Func <NumbersModel, object, bool>)TestWhereMathValidator, (object)an2e10, parameter),
Tuple.Create((LinqExpression)LinqExpression.GreaterThan(LinqExpression.Subtract(n1, n2), LinqExpression.Constant(0)),
(Func <NumbersModel, object, bool>)TestWhereMathValidator, (object)sn2g0, parameter)
};
LoadModelNumbers(10);
RunTestWithNumbers(new[] { 6, 3, 5, 5, 5, 7, 2, 3, 10, 5 }, cases);
}
public override SysExpr ToExpression()
{
switch (NodeType)
{
case ExpressionType.Add:
return(SysExpr.Add(Left.ToExpression(), Right.ToExpression()));
case ExpressionType.Subtract:
return(SysExpr.Subtract(Left.ToExpression(), Right.ToExpression()));
case ExpressionType.Multiply:
return(SysExpr.Multiply(Left.ToExpression(), Right.ToExpression()));
case ExpressionType.Divide:
return(SysExpr.Divide(Left.ToExpression(), Right.ToExpression()));
case ExpressionType.Coalesce:
return(SysExpr.Coalesce(Left.ToExpression(), Right.ToExpression()));
default:
throw new NotSupportedException($"Not a valid {NodeType} for arithmetic binary expression.");
}
}
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 sDivide(double a, [NotNull] Expression b) => sDivide(Expression.Divide(Expression.Constant(a), b));
[NotNull] private static Expression sDivide([NotNull] Expression a, [NotNull] Expression b) => sDivide(Expression.Divide(a, b));
// Returns 1 / x.
private static LinqExpr Reciprocal(LinqExpr x)
{
return(LinqExpr.Divide(ConstantExpr(1.0, x.Type), x));
}
// Generate code to perform row reduction.
private static void RowReduce(CodeGen code, LinqExpr Ab, int M, int N)
{
// For each variable in the system...
for (int j = 0; j + 1 < N; ++j)
{
LinqExpr _j = LinqExpr.Constant(j);
LinqExpr Abj = code.ReDeclInit <double[]>("Abj", LinqExpr.ArrayAccess(Ab, _j));
// int pi = j
LinqExpr pi = code.ReDeclInit <int>("pi", _j);
// double max = |Ab[j][j]|
LinqExpr max = code.ReDeclInit <double>("max", Abs(LinqExpr.ArrayAccess(Abj, _j)));
// Find a pivot row for this variable.
//code.For(j + 1, M, _i =>
//{
for (int i = j + 1; i < M; ++i)
{
LinqExpr _i = LinqExpr.Constant(i);
// if(|Ab[i][j]| > max) { pi = i, max = |Ab[i][j]| }
LinqExpr maxj = code.ReDeclInit <double>("maxj", Abs(LinqExpr.ArrayAccess(LinqExpr.ArrayAccess(Ab, _i), _j)));
code.Add(LinqExpr.IfThen(
LinqExpr.GreaterThan(maxj, max),
LinqExpr.Block(
LinqExpr.Assign(pi, _i),
LinqExpr.Assign(max, maxj))));
}
// (Maybe) swap the pivot row with the current row.
LinqExpr Abpi = code.ReDecl <double[]>("Abpi");
code.Add(LinqExpr.IfThen(
LinqExpr.NotEqual(_j, pi), LinqExpr.Block(
new[] { LinqExpr.Assign(Abpi, LinqExpr.ArrayAccess(Ab, pi)) }.Concat(
Enumerable.Range(j, N + 1 - j).Select(x => Swap(
LinqExpr.ArrayAccess(Abj, LinqExpr.Constant(x)),
LinqExpr.ArrayAccess(Abpi, LinqExpr.Constant(x)),
code.ReDecl <double>("swap")))))));
//// It's hard to believe this swap isn't faster than the above...
//code.Add(LinqExpr.IfThen(LinqExpr.NotEqual(_j, pi), LinqExpr.Block(
// Swap(LinqExpr.ArrayAccess(Ab, _j), LinqExpr.ArrayAccess(Ab, pi), Redeclare<double[]>(code, "temp")),
// LinqExpr.Assign(Abj, LinqExpr.ArrayAccess(Ab, _j)))));
// Eliminate the rows after the pivot.
LinqExpr p = code.ReDeclInit <double>("p", LinqExpr.ArrayAccess(Abj, _j));
//code.For(j + 1, M, _i =>
//{
for (int i = j + 1; i < M; ++i)
{
LinqExpr _i = LinqExpr.Constant(i);
LinqExpr Abi = code.ReDeclInit <double[]>("Abi", LinqExpr.ArrayAccess(Ab, _i));
// s = Ab[i][j] / p
LinqExpr s = code.ReDeclInit <double>("scale", LinqExpr.Divide(LinqExpr.ArrayAccess(Abi, _j), p));
// Ab[i] -= Ab[j] * s
for (int ji = j + 1; ji < N + 1; ++ji)
{
code.Add(LinqExpr.SubtractAssign(
LinqExpr.ArrayAccess(Abi, LinqExpr.Constant(ji)),
LinqExpr.Multiply(LinqExpr.ArrayAccess(Abj, LinqExpr.Constant(ji)), s)));
}
}
}
}
public static ExTP Divide(ExBPY by, ExTP tp)
{
return(bpi => Ex.Divide(tp(bpi), by(bpi)));
}
public static BinaryExpression Divide(Expression left, Expression right, MethodInfo method) => Expression.Divide(left, right, method);
public static UnaryExpression ConvertChecked(Expression expression, Type type) => Expression.ConvertChecked(expression, type); // NB: Never binds to overload with MethodInfo parameter.
public static BinaryExpression Divide(Expression left, Expression right) => Expression.Divide(left, right);
public static Expression Divide(Expression arg0, Expression arg1)
{
return(new Expression(LinqExpression.Divide(arg0, arg1)));
}
