|
public static Multiply ( |
||
| left | An |
|
| right | An |
|
| return | ||
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 static ExCoordF CartesianRot(ExTP erv) => (c, s, bpi, nrv, fxy) => {
var v2 = new TExV2();
return(Ex.Block(new ParameterExpression[] { v2 },
Ex.Assign(v2, erv(bpi)),
fxy(Ex.Subtract(Ex.Multiply(c, v2.x), Ex.Multiply(s, v2.y)),
Ex.Add(Ex.Multiply(s, v2.x), Ex.Multiply(c, v2.y))),
Expression.Empty()
));
};
/// <summary>
/// Lerp from the target parametric to zero.
/// </summary>
/// <param name="from_time">Time to start lerping</param>
/// <param name="end_time">Time to end lerping</param>
/// <param name="p">Target parametric</param>
/// <returns></returns>
public static ExTP LerpOut(float from_time, float end_time, ExTP p)
{
Ex etr = ExC(1f / (end_time - from_time));
Ex ex_end = ExC(end_time);
return(bpi => Ex.Condition(Ex.GreaterThan(bpi.t, ex_end), v20,
Ex.Multiply(p(bpi), Ex.Condition(Ex.LessThan(bpi.t, ExC(from_time)), E1,
Ex.Multiply(etr, Ex.Subtract(ex_end, bpi.t))
))
));
}
public void TestFuncReplace()
{
Expression ex = Expression.Add(ExC(5f),
Expression.Call(null, typeof(Mathf).GetMethod("Sin"), Ex.Multiply(E2, ExC(1.5f))));
AreEqual(5.14112, Compile(ex), err);
AreEqual("(5+Mathf.Sin(Null,(2*1.5)))", ex.Debug());
AreEqual("5.14112", ex.FlatDebug());
ex = Ex.Call(null, typeof(ExOptTests).GetMethod("Add1"), Ex.Multiply(E2, ExC(1.5f)));
AreEqual("ExOptTests.Add1(Null,(2*1.5))", ex.Debug());
AreEqual("ExOptTests.Add1(Null,3)", ex.FlatDebug());
}
public static ExCoordF Polar2(ExTP radThetaDeg)
{
var rt = new TExV2();
var lookup = new TExV2();
return((c, s, bpi, nrv, fxy) => Ex.Block(new ParameterExpression[] { rt, lookup },
Ex.Assign(rt, radThetaDeg(bpi)),
Ex.Assign(lookup, ExM.CosSinDeg(rt.y)),
fxy(Ex.Subtract(Ex.Multiply(c, lookup.x), Ex.Multiply(s, lookup.y)).Mul(rt.x),
Ex.Add(Ex.Multiply(s, lookup.x), Ex.Multiply(c, lookup.y)).Mul(rt.x)),
Expression.Empty()
));
}
public static ExCoordF Polar(ExBPY r, ExBPY theta)
{
var vr = ExUtils.VFloat();
var lookup = new TExV2();
return((c, s, bpi, nrv, fxy) => Ex.Block(new[] { vr, lookup },
Ex.Assign(lookup, ExM.CosSinDeg(theta(bpi))),
Ex.Assign(vr, r(bpi)),
fxy(Ex.Subtract(Ex.Multiply(c, lookup.x), Ex.Multiply(s, lookup.y)).Mul(vr),
Ex.Add(Ex.Multiply(s, lookup.x), Ex.Multiply(c, lookup.y)).Mul(vr)),
Expression.Empty()
));
}
public static Func <T, TEx <R> > EaseD <T, R>(Func <tfloat, tfloat> easer, float maxTime,
Func <T, TEx <R> > fd, Func <T, Ex> t, Func <T, Ex, T> withT)
{
var ratTime = ExUtils.VFloat();
// x'(t) = f'(g(t)) g'(t). Where g(t) = T e(t/T): g'(t) = e'(t/T)
return(bpi => Ex.Block(new[] { ratTime },
Ex.Assign(ratTime, Clamp01(ExC(1f / maxTime).Mul(t(bpi)))),
Ex.Multiply(
DerivativeVisitor.Derivate(ratTime, E1, easer(ratTime)),
fd(withT(bpi, ExC(maxTime).Mul(easer(ratTime)))))
));
}
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);
}
static E CompileAsIndex(
Element element,
Dictionary <string, ParameterExpression> spans,
Dictionary <string, ParameterExpression> indices)
{
var strides = element.Symbol.Shape.Strides();
var expr = Compile(element.Expressions.Last(), spans, indices);
for (var i = element.Expressions.Count - 2; i >= 0; i--)
{
expr = E.Add(
E.Multiply(
E.Constant(strides[i]),
Compile(element.Expressions[i], spans, indices)),
expr);
}
return(expr);
}
public static Expression <Func <Complex, Complex> > GetExpression([NotNull] Complex[] A)
{
var length = A.Length;
Ex y;
var px = Ex.Parameter(typeof(Complex), "z");
if (length == 0)
{
y = Ex.Constant(0d);
}
else
{
y = Ex.Constant(A[length - 1]);
for (var i = 1; i < length; i++)
{
y = Ex.Add(Ex.Multiply(y, px), Ex.Constant(A[length - 1 - i]));
}
}
return(Ex.Lambda <Func <Complex, Complex> >(y, px));
}
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();
}
}
public static Ex MulAssign(Ex into, Ex from) => Ex.Assign(into, Ex.Multiply(into, from));
// Use homotopy method with newton's method to find a solution for F(x) = 0.
private static List <Arrow> NSolve(List <Expression> F, List <Arrow> x0, double Epsilon, int MaxIterations)
{
int M = F.Count;
int N = x0.Count;
// Compute JxF, the Jacobian of F.
List <Dictionary <Expression, Expression> > JxF = Jacobian(F, x0.Select(i => i.Left)).ToList();
// Define a function to evaluate JxH(x), where H = F(x) - s*F(x0).
CodeGen code = new CodeGen();
ParamExpr _JxH = code.Decl <double[, ]>(Scope.Parameter, "JxH");
ParamExpr _x0 = code.Decl <double[]>(Scope.Parameter, "x0");
ParamExpr _s = code.Decl <double>(Scope.Parameter, "s");
// Load x_j from the input array and add them to the map.
for (int j = 0; j < N; ++j)
{
code.DeclInit(x0[j].Left, LinqExpr.ArrayAccess(_x0, LinqExpr.Constant(j)));
}
LinqExpr error = code.Decl <double>("error");
// Compile the expressions to assign JxH
for (int i = 0; i < M; ++i)
{
LinqExpr _i = LinqExpr.Constant(i);
for (int j = 0; j < N; ++j)
{
code.Add(LinqExpr.Assign(
LinqExpr.ArrayAccess(_JxH, _i, LinqExpr.Constant(j)),
code.Compile(JxF[i][x0[j].Left])));
}
// e = F(x) - s*F(x0)
LinqExpr e = code.DeclInit <double>("e", LinqExpr.Subtract(code.Compile(F[i]), LinqExpr.Multiply(LinqExpr.Constant((double)F[i].Evaluate(x0)), _s)));
code.Add(LinqExpr.Assign(LinqExpr.ArrayAccess(_JxH, _i, LinqExpr.Constant(N)), e));
// error += e * e
code.Add(LinqExpr.AddAssign(error, LinqExpr.Multiply(e, e)));
}
// return error
code.Return(error);
Func <double[, ], double[], double, double> JxH = code.Build <Func <double[, ], double[], double, double> >().Compile();
double[] x = new double[N];
// Remember where we last succeeded/failed.
double s0 = 0.0;
double s1 = 1.0;
do
{
try
{
// H(F, s) = F - s*F0
NewtonsMethod(M, N, JxH, s0, x, Epsilon, MaxIterations);
// Success at this s!
s1 = s0;
for (int i = 0; i < N; ++i)
{
x0[i] = Arrow.New(x0[i].Left, x[i]);
}
// Go near the goal.
s0 = Lerp(s0, 0.0, 0.9);
}
catch (FailedToConvergeException)
{
// Go near the last success.
s0 = Lerp(s0, s1, 0.9);
for (int i = 0; i < N; ++i)
{
x[i] = (double)x0[i].Right;
}
}
} while (s0 > 0.0 && s1 >= s0 + 1e-6);
// Make sure the last solution is at F itself.
if (s0 != 0.0)
{
NewtonsMethod(M, N, JxH, 0.0, x, Epsilon, MaxIterations);
for (int i = 0; i < N; ++i)
{
x0[i] = Arrow.New(x0[i].Left, x[i]);
}
}
return(x0);
}
public void TestReplaceWithVars()
{
var x = VF("x");
Expression ex = Ex.Add(ExC(5f), Expression.Call(null, typeof(Mathf).GetMethod("Sin"), Ex.Add(x, Ex.Multiply(ExC(2f), ExC(1.5f)))));
AreEqual("(5+Mathf.Sin(Null,(x+(2*1.5))))", ex.Debug());
AreEqual("(5+Mathf.Sin(Null,(x+3)))", ex.FlatDebug());
var y = VF("y");
ex = Ex.Block(new[] { y }, Ex.Assign(y, ExC(3f)), Ex.Add(y, E2));
AreEqual("((y=3);\n(y+2);)", ex.Debug());
AreEqual("((y=3);\n5;)", ex.FlatDebug());
ex = Ex.Block(new[] { y }, Ex.Assign(y, E1), Ex.Add(ExC(5f), Ex.Call(null, typeof(Mathf).GetMethod("Sin"), Ex.Add(y, Ex.Multiply(ExC(2f), ExC(1.5f))))));
AreEqual("((y=1);\n(5+Mathf.Sin(Null,(y+(2*1.5))));)", ex.Debug());
AreEqual("((y=1);\n4.243197;)", ex.FlatDebug());
AreEqual(4.2431974, Compile(ex.Flatten()), err);
ex = Ex.Block(new[] { y }, Ex.Assign(y, x), Ex.Add(ExC(5f), Expression.Call(null, typeof(Mathf).GetMethod("Sin"), Ex.Add(y, Ex.Multiply(E2, ExC(1.5f))))));
AreEqual("((y=x);\n(5+Mathf.Sin(Null,(y+(2*1.5))));)", ex.Debug());
AreEqual("((y=x);\n(5+Mathf.Sin(Null,(x+3)));)", ex.FlatDebug());
}
public static Expression Multiply(Expression arg0, Expression arg1)
{
return(new Expression(LinqExpression.Multiply(arg0, arg1)));
}
private static Expression sMultiply([NotNull] Expression a, [NotNull] Expression b) => sMultiply(Expression.Multiply(a, b));
// Returns x*x.
private static LinqExpr Square(LinqExpr x)
{
return(LinqExpr.Multiply(x, 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)));
}
}
}
}
// The resulting lambda processes N samples, using buffers provided for Input and Output:
// void Process(int N, double t0, double T, double[] Input0 ..., double[] Output0 ...)
// { ... }
private Delegate DefineProcess()
{
// Map expressions to identifiers in the syntax tree.
List <KeyValuePair <Expression, LinqExpr> > inputs = new List <KeyValuePair <Expression, LinqExpr> >();
List <KeyValuePair <Expression, LinqExpr> > outputs = new List <KeyValuePair <Expression, LinqExpr> >();
// Lambda code generator.
CodeGen code = new CodeGen();
// Create parameters for the basic simulation info (N, t, Iterations).
ParamExpr SampleCount = code.Decl <int>(Scope.Parameter, "SampleCount");
ParamExpr t = code.Decl(Scope.Parameter, Simulation.t);
// Create buffer parameters for each input...
foreach (Expression i in Input)
{
inputs.Add(new KeyValuePair <Expression, LinqExpr>(i, code.Decl <double[]>(Scope.Parameter, i.ToString())));
}
// ... and output.
foreach (Expression i in Output)
{
outputs.Add(new KeyValuePair <Expression, LinqExpr>(i, code.Decl <double[]>(Scope.Parameter, i.ToString())));
}
// Create globals to store previous values of inputs.
foreach (Expression i in Input.Distinct())
{
AddGlobal(i.Evaluate(t_t0));
}
// Define lambda body.
// int Zero = 0
LinqExpr Zero = LinqExpr.Constant(0);
// double h = T / Oversample
LinqExpr h = LinqExpr.Constant(TimeStep / (double)Oversample);
// Load the globals to local variables and add them to the map.
foreach (KeyValuePair <Expression, GlobalExpr <double> > i in globals)
{
code.Add(LinqExpr.Assign(code.Decl(i.Key), i.Value));
}
foreach (KeyValuePair <Expression, LinqExpr> i in inputs)
{
code.Add(LinqExpr.Assign(code.Decl(i.Key), code[i.Key.Evaluate(t_t0)]));
}
// Create arrays for linear systems.
int M = Solution.Solutions.OfType <NewtonIteration>().Max(i => i.Equations.Count(), 0);
int N = Solution.Solutions.OfType <NewtonIteration>().Max(i => i.UnknownDeltas.Count(), 0) + 1;
LinqExpr JxF = code.DeclInit <double[][]>("JxF", LinqExpr.NewArrayBounds(typeof(double[]), LinqExpr.Constant(M)));
for (int j = 0; j < M; ++j)
{
code.Add(LinqExpr.Assign(LinqExpr.ArrayAccess(JxF, LinqExpr.Constant(j)), LinqExpr.NewArrayBounds(typeof(double), LinqExpr.Constant(N))));
}
// for (int n = 0; n < SampleCount; ++n)
ParamExpr n = code.Decl <int>("n");
code.For(
() => code.Add(LinqExpr.Assign(n, Zero)),
LinqExpr.LessThan(n, SampleCount),
() => code.Add(LinqExpr.PreIncrementAssign(n)),
() =>
{
// Prepare input samples for oversampling interpolation.
Dictionary <Expression, LinqExpr> dVi = new Dictionary <Expression, LinqExpr>();
foreach (Expression i in Input.Distinct())
{
LinqExpr Va = code[i];
// Sum all inputs with this key.
IEnumerable <LinqExpr> Vbs = inputs.Where(j => j.Key.Equals(i)).Select(j => j.Value);
LinqExpr Vb = LinqExpr.ArrayAccess(Vbs.First(), n);
foreach (LinqExpr j in Vbs.Skip(1))
{
Vb = LinqExpr.Add(Vb, LinqExpr.ArrayAccess(j, n));
}
// dVi = (Vb - Va) / Oversample
code.Add(LinqExpr.Assign(
Decl <double>(code, dVi, i, "d" + i.ToString().Replace("[t]", "")),
LinqExpr.Multiply(LinqExpr.Subtract(Vb, Va), LinqExpr.Constant(1.0 / (double)Oversample))));
}
// Prepare output sample accumulators for low pass filtering.
Dictionary <Expression, LinqExpr> Vo = new Dictionary <Expression, LinqExpr>();
foreach (Expression i in Output.Distinct())
{
code.Add(LinqExpr.Assign(
Decl <double>(code, Vo, i, i.ToString().Replace("[t]", "")),
LinqExpr.Constant(0.0)));
}
// int ov = Oversample;
// do { -- ov; } while(ov > 0)
ParamExpr ov = code.Decl <int>("ov");
code.Add(LinqExpr.Assign(ov, LinqExpr.Constant(Oversample)));
code.DoWhile(() =>
{
// t += h
code.Add(LinqExpr.AddAssign(t, h));
// Interpolate the input samples.
foreach (Expression i in Input.Distinct())
{
code.Add(LinqExpr.AddAssign(code[i], dVi[i]));
}
// Compile all of the SolutionSets in the solution.
foreach (SolutionSet ss in Solution.Solutions)
{
if (ss is LinearSolutions)
{
// Linear solutions are easy.
LinearSolutions S = (LinearSolutions)ss;
foreach (Arrow i in S.Solutions)
{
code.DeclInit(i.Left, i.Right);
}
}
else if (ss is NewtonIteration)
{
NewtonIteration S = (NewtonIteration)ss;
// Start with the initial guesses from the solution.
foreach (Arrow i in S.Guesses)
{
code.DeclInit(i.Left, i.Right);
}
// int it = iterations
LinqExpr it = code.ReDeclInit <int>("it", Iterations);
// do { ... --it } while(it > 0)
code.DoWhile((Break) =>
{
// Solve the un-solved system.
Solve(code, JxF, S.Equations, S.UnknownDeltas);
// Compile the pre-solved solutions.
if (S.KnownDeltas != null)
{
foreach (Arrow i in S.KnownDeltas)
{
code.DeclInit(i.Left, i.Right);
}
}
// bool done = true
LinqExpr done = code.ReDeclInit("done", true);
foreach (Expression i in S.Unknowns)
{
LinqExpr v = code[i];
LinqExpr dv = code[NewtonIteration.Delta(i)];
// done &= (|dv| < |v|*epsilon)
code.Add(LinqExpr.AndAssign(done, LinqExpr.LessThan(LinqExpr.Multiply(Abs(dv), LinqExpr.Constant(1e4)), LinqExpr.Add(Abs(v), LinqExpr.Constant(1e-6)))));
// v += dv
code.Add(LinqExpr.AddAssign(v, dv));
}
// if (done) break
code.Add(LinqExpr.IfThen(done, Break));
// --it;
code.Add(LinqExpr.PreDecrementAssign(it));
}, LinqExpr.GreaterThan(it, Zero));
//// bool failed = false
//LinqExpr failed = Decl(code, code, "failed", LinqExpr.Constant(false));
//for (int i = 0; i < eqs.Length; ++i)
// // failed |= |JxFi| > epsilon
// code.Add(LinqExpr.OrAssign(failed, LinqExpr.GreaterThan(Abs(eqs[i].ToExpression().Compile(map)), LinqExpr.Constant(1e-3))));
//code.Add(LinqExpr.IfThen(failed, ThrowSimulationDiverged(n)));
}
}
// Update the previous timestep variables.
foreach (SolutionSet S in Solution.Solutions)
{
foreach (Expression i in S.Unknowns.Where(i => globals.Keys.Contains(i.Evaluate(t_t0))))
{
code.Add(LinqExpr.Assign(code[i.Evaluate(t_t0)], code[i]));
}
}
// Vo += i
foreach (Expression i in Output.Distinct())
{
LinqExpr Voi = LinqExpr.Constant(0.0);
try
{
Voi = code.Compile(i);
}
catch (Exception Ex)
{
Log.WriteLine(MessageType.Warning, Ex.Message);
}
code.Add(LinqExpr.AddAssign(Vo[i], Voi));
}
// Vi_t0 = Vi
foreach (Expression i in Input.Distinct())
{
code.Add(LinqExpr.Assign(code[i.Evaluate(t_t0)], code[i]));
}
// --ov;
code.Add(LinqExpr.PreDecrementAssign(ov));
}, LinqExpr.GreaterThan(ov, Zero));
// Output[i][n] = Vo / Oversample
foreach (KeyValuePair <Expression, LinqExpr> i in outputs)
{
code.Add(LinqExpr.Assign(LinqExpr.ArrayAccess(i.Value, n), LinqExpr.Multiply(Vo[i.Key], LinqExpr.Constant(1.0 / (double)Oversample))));
}
// Every 256 samples, check for divergence.
if (Vo.Any())
{
code.Add(LinqExpr.IfThen(LinqExpr.Equal(LinqExpr.And(n, LinqExpr.Constant(0xFF)), Zero),
LinqExpr.Block(Vo.Select(i => LinqExpr.IfThenElse(IsNotReal(i.Value),
ThrowSimulationDiverged(n),
LinqExpr.Assign(i.Value, RoundDenormToZero(i.Value)))))));
}
});
// Copy the global state variables back to the globals.
foreach (KeyValuePair <Expression, GlobalExpr <double> > i in globals)
{
code.Add(LinqExpr.Assign(i.Value, code[i.Key]));
}
LinqExprs.LambdaExpression lambda = code.Build();
Delegate ret = lambda.Compile();
return(ret);
}
private static TDelegate Simdize <T, TDelegate>(LambdaExpression expr)
where T : unmanaged
where TDelegate : Delegate
{
if (_cache.TryGetValue(expr, out var value))
{
return((TDelegate)value);
}
var simdVisitor = new SimdVisitor <T>(expr);
var simdBody = simdVisitor.Visit(expr.Body);
var i = Expr.Parameter(typeof(int), "i");
var len = Expr.Parameter(typeof(int), "len");
var xMemories = expr.Parameters.Select(p => Expr.Parameter(typeof(ReadOnlyMemory <T>), p.Name)).ToArray();
var resultMemory = Expr.Parameter(typeof(Memory <T>), "result");
var xSpans = xMemories.Select(p => Expr.Variable(typeof(ReadOnlySpan <T>), $"{p.Name}Span")).ToArray();
var resultSpan = Expr.Variable(typeof(Span <T>), "resultSpan");
var xVecSpans = xMemories.Select(p => Expr.Variable(typeof(ReadOnlySpan <Vector <T> >), $"{p.Name}VecSpan")).ToArray();
var resultVecSpan = Expr.Variable(typeof(Span <Vector <T> >), "resultVecSpan");
var xSpanGetters = xSpans.Select(p => Expr.Call(null, MemberTable._ReadOnlySpan <T> .GetItem, p, i)).ToArray();
var xVecSpanGetters = xVecSpans.Select(p => Expr.Call(null, MemberTable._ReadOnlySpan <Vector <T> > .GetItem, p, i)).ToArray();
var exprCall = new LambdaArgsVisitor(expr.Parameters.Zip(xSpanGetters).ToDictionary(tpl => tpl.Item1, tpl => (Expr)tpl.Item2)).Visit(expr.Body);
var simdCall = new LambdaArgsVisitor(simdVisitor.NewArguments.Zip(xVecSpanGetters).ToDictionary(tpl => tpl.Item1, tpl => (Expr)tpl.Item2)).Visit(simdBody);
var resultSpanSetter = Expr.Call(null, MemberTable._Span <T> .SetItem, resultSpan, i, exprCall);
var resultVecSpanSetter = Expr.Call(null, MemberTable._Span <Vector <T> > .SetItem, resultVecSpan, i, simdCall);
var parameters = xMemories.Concat(new[] { resultMemory });
var variables = xSpans.Concat(xVecSpans).Concat(new[] { i, len, resultSpan, resultVecSpan });
var block = new List <Expr>();
// xSpan = xMemory.Span;
block.AddRange(xMemories.Zip(xSpans, (memory, span) =>
Expr.Assign(
span,
Expr.Property(memory, MemberTable._ReadOnlyMemory <T> .Span)
)
));
// xVecSpan = MemoryMarshal.Cast<T, Vector<T>>(xSpan);
block.AddRange(xSpans.Zip(xVecSpans, (span, vSpan) =>
Expr.Assign(
vSpan,
Expr.Call(null, MemberTable._MemoryMarshal.Cast <T, Vector <T> > .ForReadOnlySpan, span)
)
));
// resultSpan = resultMemory.Span;
block.Add(
Expr.Assign(
resultSpan,
Expr.Property(resultMemory, MemberTable._Memory <T> .Span)
)
);
// resultVecSpan = MemoryMarshal.Cast<T, Vector<T>>(resultSpan);
block.Add(
Expr.Assign(
resultVecSpan,
Expr.Call(null, MemberTable._MemoryMarshal.Cast <T, Vector <T> > .ForSpan, resultSpan)
)
);
// for(i = 0, len = resultVecSpan.Length & ~0b1111; i < len; )
// {
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x0
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x1
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x2
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x3
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x4
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x5
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x6
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x7
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x8
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x9
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0xA
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0xB
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0xC
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0xD
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0xE
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0xF
// }
block.Add(
ExpressionEx.For(
Expr.Block(
Expr.Assign(i, Expr.Constant(0)),
Expr.Assign(
len,
Expr.And(Expr.Property(resultVecSpan, MemberTable._Span <Vector <T> > .Length), Expr.Constant(~0b1111))
)
),
Expr.LessThan(i, len),
Expr.Empty(),
Expr.Block(
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x0
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x1
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x2
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x3
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x4
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x5
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x6
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x7
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x8
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x9
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0xA
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0xB
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0xC
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0xD
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0xE
resultVecSpanSetter, Expr.PreIncrementAssign(i) // 0xF
)
)
);
// if(i < (resultVecSpan.Length & ~0b111))
// {
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x0
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x1
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x2
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x3
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x4
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x5
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x6
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x7
// }
block.Add(
Expr.IfThen(
Expr.LessThan(
i,
Expr.And(Expr.Property(resultVecSpan, MemberTable._Span <Vector <T> > .Length), Expr.Constant(~0b111))
),
Expr.Block(
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x0
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x1
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x2
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x3
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x4
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x5
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x6
resultVecSpanSetter, Expr.PreIncrementAssign(i) // 0x7
)
)
);
// if(i < (resultVecSpan.Length & ~0b11))
// {
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x0
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x1
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x2
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x3
// }
block.Add(
Expr.IfThen(
Expr.LessThan(
i,
Expr.And(Expr.Property(resultVecSpan, MemberTable._Span <Vector <T> > .Length), Expr.Constant(~0b11))
),
Expr.Block(
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x0
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x1
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x2
resultVecSpanSetter, Expr.PreIncrementAssign(i) // 0x3
)
)
);
// if(i < (resultVecSpan.Length & ~0b1))
// {
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x0
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x1
// }
block.Add(
Expr.IfThen(
Expr.LessThan(
i,
Expr.And(Expr.Property(resultVecSpan, MemberTable._Span <Vector <T> > .Length), Expr.Constant(~0b1))
),
Expr.Block(
resultVecSpanSetter, Expr.PreIncrementAssign(i), // 0x0
resultVecSpanSetter, Expr.PreIncrementAssign(i) // 0x1
)
)
);
// if(i < resultVecSpan.Length)
// {
// resultVecSpan[i] = simdCall(xVecSpan[i], ...); ++i; // 0x0
// }
block.Add(
Expr.IfThen(
Expr.LessThan(
i,
Expr.Property(resultVecSpan, MemberTable._Span <Vector <T> > .Length)
),
Expr.Block(
resultVecSpanSetter, Expr.PreIncrementAssign(i) // 0x0
)
)
);
// for(i = Vector<T>.Count * resultVecSpan.Length; i < resultSpan.Length; )
// {
// resultSpan[i] = exprCall(xSpan[i], ...); ++i;
// }
block.Add(
ExpressionEx.For(
Expr.Assign(
i,
Expr.Multiply(
Expr.Constant(Vector <T> .Count),
Expr.Property(resultVecSpan, MemberTable._Span <Vector <T> > .Length)
)
),
Expr.LessThan(i, Expr.Property(resultSpan, MemberTable._Span <T> .Length)),
Expr.Empty(),
Expr.Block(
resultSpanSetter, Expr.PreIncrementAssign(i)
)
)
);
var retval = Expr.Lambda <TDelegate>(Expr.Block(variables, block), parameters).Compile();
_cache.TryAdd(expr, retval);
return(retval);
}
public static BinaryExpression Multiply(Expression left, Expression right) => Expression.Multiply(left, right);
public static Ex QRotate(Ex quat, Ex v3) => Ex.Multiply(quat, v3);
public static BinaryExpression Multiply(Expression left, Expression right, MethodInfo method) => Expression.Multiply(left, right, method);
// Returns a * b + c.
private static LinqExpr MultiplyAdd(LinqExpr a, LinqExpr b, LinqExpr c)
{
return(LinqExpr.Add(LinqExpr.Multiply(a, b), c));
}
