|
public static Add ( |
||
| left | An |
|
| right | An |
|
| return | ||
public void Binary()
{
var param = LinqExpression.Parameter(typeof(int));
var expression = LinqExpression.Add(param, param);
ShouldRoundrip(expression);
}
public void ZeroOneRemoval()
{
var x = VF("x");
var ex = Ex.Block(Ex.Add(x, E1), Ex.Add(x, E0), E1.Mul(x), x.Mul(E0), x.Sub(E0), E0.Sub(x));
AreEqual("((x+1);\n(x+0);\n(1*x);\n(x*0);\n(x-0);\n(0-x);)", ex.Debug());
AreEqual("((x+1);\nx;\nx;\n0;\nx;\n(0-x);)", ex.FlatDebug());
}
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();
}
}
/// <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))))
));
}
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()
));
};
public void TestConvert()
{
Ex ex = Ex.Add(ExC(5.2f), Ex.Convert(Ex.Convert(Ex.Add(ExC(1.2f), ExC(2.1f)), typeof(int)), typeof(float)));
AreEqual("(5.2+(1.2+2.1):>Int32:>Single)", ex.Debug());
AreEqual("8.2", ex.FlatDebug());
var x = VF("x");
ex = Ex.Add(ExC(5), Ex.Convert(Ex.Add(x, Ex.Add(ExC(1.2f), ExC(2.1f))), typeof(int)));
AreEqual("(5+(x+(1.2+2.1)):>Int32)", ex.Debug());
AreEqual("(5+(x+3.3):>Int32)", 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()
));
}
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();
}
}
public void BinaryMethod()
{
var zero =
LinqExpression.Default(
typeof(long));
var expression =
LinqExpression.Add(
zero,
zero,
typeof(SampleClass).GetMethod(nameof(SampleClass.Equal)));
ShouldRoundrip(expression);
}
public void TestIfThen()
{
var y = VF("y");
var ex = Ex.Block(new[] { y }, Ex.Assign(y, ExC(4f)), Ex.Condition(Ex.GreaterThan(y, ExC(3f)),
Ex.Assign(y, ExC(3f)),
Ex.Add(y, ExC(1f))
), Ex.Add(y, ExC(2f)));
AreEqual("((y=4);\nif(y>3){(y=3)}else{(y+1)};\n(y+2);)", ex.Debug());
ex = Ex.Block(new[] { y }, Ex.Assign(y, ExC(4f)), Ex.Condition(Ex.GreaterThan(y, ExC(3f)),
Ex.Add(y, ExC(1f)),
Ex.Assign(y, ExC(3f))
), Ex.Add(y, ExC(2f)));
AreEqual("((y=4);\n5;\n6;)", ex.FlatDebug());
}
public static Func <TExArgCtx, TEx <T> > Pivot <S, T>(Func <TExArgCtx, TEx <float> > pivot, Func <TExArgCtx, TEx <T> > f1, Func <TExArgCtx, TEx <T> > f2, Func <TExArgCtx, TEx> pivotVar)
where S : TEx, new() => t => {
var pv = VFloat();
var pivotT = t.MakeCopyForType <S>(out var currEx, out var pivotEx);
return(Ex.Block(new[] { pv },
pv.Is(pivot(t)),
Ex.Condition(pv.LT(pivotVar(t)),
Ex.Block(new ParameterExpression[] { pivotEx },
Ex.Assign(pivotEx, currEx),
Ex.Assign(pivotVar(pivotT), pv),
Ex.Add(f1(pivotT), Ex.Subtract(f2(t), f2(pivotT)))
),
f1(t)
)
));
};
// 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 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 <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.");
}
}
public void Method()
{
var zero =
LinqExpression.Default(
typeof(long));
var expected =
LinqExpression.Add(
zero,
zero,
typeof(SampleClass).GetMethod(nameof(SampleClass.Equal)));
var actual = $@"
@prefix : <http://example.com/> .
@prefix xt: <http://example.com/ExpressionTypes/> .
:s
:binaryExpressionType xt:Add ;
:binaryLeft _:zero ;
:binaryRight _:zero ;
:binaryMethod [
:memberType [
:typeName ""GraphEngine.Tests.SampleClass, GraphEngine.Tests"" ;
] ;
:memberName ""Equal"" ;
] ;
.
_:zero
:defaultType [
:typeName ""System.Int64"" ;
] ;
.
";
ShouldBe(actual, expected);
}
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 Add(this Ex me, float other) => me.Add(Ex.Constant(other));
//See notes for why these exist public static Ex AddAssign(Ex into, Ex from) => Ex.Assign(into, Ex.Add(into, from));
public void ReplaceMember()
{
var x = V <Vector2>("x");
var y = VF("y");
var ex = Ex.Block(new[] { x }, Ex.Assign(x, ExC(new Vector2(2f, 3f))), Ex.Field(x, "x").Add(ExC(6f)));
AreEqual("((x=(2.0, 3.0));\n(x.x+6);)", ex.Debug());
AreEqual("((x=(2.0, 3.0));\n8;)", ex.FlatDebug());
AreEqual(Compile(ex.Flatten()), 8f);
ex = Ex.Block(new[] { x }, Ex.Assign(x, ExC(new Vector2(2f, 3f))), Ex.IfThen(y.GT(E1), x.Is(ExC(Vector2.right))), Ex.Add(Ex.Field(x, "x"), ExC(6f)));
AreEqual("((x=(2.0, 3.0));\nif(y>1){(x=(1.0, 0.0))}else{};\n(x.x+6);)", ex.FlatDebug());
ex = Ex.Block(new[] { x }, x.Is(ExC(new Vector2(2f, 3f))), Ex.IfThen(y.GT(E1), Ex.Field(x, "x").Is(ExC(6f))), Ex.Add(Ex.Field(x, "x"), ExC(6f)));
AreEqual("((x=(2.0, 3.0));\nif(y>1){(x.x=6)}else{};\n(x.x+6);)", ex.FlatDebug());
}
private static Expression <Func <T, bool> > CreateDateTimeComparerLambda <T>(Expression expression, ParameterExpression parameter, string keyword)
{
var indexOfEmptySpace = Expression.Call(expression, InternalExpressionExtensions.GetIndexOfMethod(), Expression.Constant(" "));
var dateExpression = Expression.Call(expression, InternalExpressionExtensions.GetSubstringWithStartAndEndMethod(), Expression.Constant(0), indexOfEmptySpace);
var timeExpression = Expression.Call(expression, InternalExpressionExtensions.GetSubstringWithStartMethod(), Expression.Add(indexOfEmptySpace, Expression.Constant(1)));
var date = keyword;
var time = keyword;
if (keyword.Contains(' ') == true)
{
var dateAndTime = keyword.Split(new char[] { ' ' });
var dateComparerExpression = GetDateComparerExpression <T>(dateExpression, parameter, dateAndTime[0]);
var timeComparerExpression = GetTimeComparerExpression <T>(timeExpression, parameter, dateAndTime[1], InternalExpressionExtensions.GetStartsWithMethod());
//o => o.ComparerMethod((property ?? "").Substring(0, property.IndexOf(' ')).ToLower().Contains(date))
// .And(o.ComparerMethod((property ?? "").Substring(property.IndexOf(' ')).ToLower().StartsWith(time)))
return(dateComparerExpression.And(timeComparerExpression));
}
else
{
var dateComparerExpression = GetDateComparerExpression <T>(dateExpression, parameter, date);
var timeComparerExpression = GetTimeComparerExpression <T>(timeExpression, parameter, time, InternalExpressionExtensions.GetContainsMethod());
//o => o.ComparerMethod((property ?? "").Substring(0, property.IndexOf(' ')).ToLower().Contains(date))
// .Or(o.ComparerMethod((property ?? "").Substring(property.IndexOf(' ')).ToLower().Contains(time)))
return(dateComparerExpression.Or(timeComparerExpression));
}
}
public static Expression Add(Expression arg0, Expression arg1)
{
return(new Expression(LinqExpression.Add(arg0, arg1)));
}
// 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);
}
// Returns a * b + c.
private static LinqExpr MultiplyAdd(LinqExpr a, LinqExpr b, LinqExpr c)
{
return(LinqExpr.Add(LinqExpr.Multiply(a, b), c));
}
