public static GreaterThan ( |
||
left | An |
|
right | An |
|
return |
public void Factorial() { var value = LinqExpression.Parameter(typeof(int), "value"); var result = LinqExpression.Parameter(typeof(int), "result"); var label = LinqExpression.Label(typeof(int), "label"); var one = LinqExpression.Constant(1); var expression = LinqExpression.Block( new[] { result }, LinqExpression.Assign( result, one), LinqExpression.Loop( LinqExpression.Condition( LinqExpression.GreaterThan( value, one), LinqExpression.MultiplyAssign( result, LinqExpression.PostDecrementAssign( value)), LinqExpression.Break( label, result), typeof(void)), label)); ShouldRoundrip(expression); }
public void TestWhereComparison() { // Partial LINQ expression (x => x.Number1) var parameter = LinqExpression.Parameter(typeof(NumbersModel), "x"); var n1 = LinqExpression.Property(parameter, "Number1"); var l3 = new Func <int, bool>(n => n < 3); var le3 = new Func <int, bool>(n => n <= 3); var g6 = new Func <int, bool>(n => n > 6); var ge6 = new Func <int, bool>(n => n >= 6); var e7 = new Func <int, bool>(n => n == 7); var ne7 = new Func <int, bool>(n => n != 7); var cases = new[] { Tuple.Create((LinqExpression)LinqExpression.LessThan(n1, LinqExpression.Constant(3)), (Func <NumbersModel, object, bool>)TestWhereCompareValidator, (object)l3, parameter), Tuple.Create((LinqExpression)LinqExpression.LessThanOrEqual(n1, LinqExpression.Constant(3)), (Func <NumbersModel, object, bool>)TestWhereCompareValidator, (object)le3, parameter), Tuple.Create((LinqExpression)LinqExpression.GreaterThan(n1, LinqExpression.Constant(6)), (Func <NumbersModel, object, bool>)TestWhereCompareValidator, (object)g6, parameter), Tuple.Create((LinqExpression)LinqExpression.GreaterThanOrEqual(n1, LinqExpression.Constant(6)), (Func <NumbersModel, object, bool>)TestWhereCompareValidator, (object)ge6, parameter), Tuple.Create((LinqExpression)LinqExpression.Equal(n1, LinqExpression.Constant(7)), (Func <NumbersModel, object, bool>)TestWhereCompareValidator, (object)e7, parameter), Tuple.Create((LinqExpression)LinqExpression.NotEqual(n1, LinqExpression.Constant(7)), (Func <NumbersModel, object, bool>)TestWhereCompareValidator, (object)ne7, parameter) }; LoadModelNumbers(10); Db.Count.Should().Be(10); RunTestWithNumbers(new[] { 2, 3, 4, 5, 1, 9 }, cases); }
//See Design/Engine Math Tips for details on these two functions. They are not raw easing. public static Func <T, TEx <R> > Ease <T, R>(Func <tfloat, tfloat> easer, float maxTime, Func <T, TEx <R> > f, Func <T, Ex> t, Func <T, Ex, T> withT) // x = f(g(t)), where g(t) = T e(t/T) => bpi => Ex.Condition(Ex.GreaterThan(t(bpi), ExC(maxTime)), f(bpi), f(withT(bpi, ExC(maxTime).Mul( easer(t(bpi).Mul(1f / maxTime)) )) ));
/// <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 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 void TestWhereAndOr() { var parameter = LinqExpression.Parameter(typeof(NumbersModel), "x"); var n1 = LinqExpression.Property(parameter, "Number1"); var n2 = LinqExpression.Property(parameter, "Number2"); var cases = new[] { Tuple.Create((LinqExpression)LinqExpression.AndAlso(LinqExpression.GreaterThan(n1, LinqExpression.Constant(3)), LinqExpression.GreaterThan(n2, LinqExpression.Constant(3))), (Func <NumbersModel, object, bool>)TestWhereAndValidator, default(object), parameter), Tuple.Create((LinqExpression)LinqExpression.OrElse(LinqExpression.LessThan(n1, LinqExpression.Constant(3)), LinqExpression.LessThan(n2, LinqExpression.Constant(3))), (Func <NumbersModel, object, bool>)TestWhereOrValidator, default(object), parameter) }; LoadModelNumbers(10); RunTestWithNumbers(new[] { 3, 5 }, cases); }
public void TestCond() { var x = VF("x"); var yi = VF("y"); var zi = VF("z"); var ex = Ex.Condition(Ex.Block(zi.Is(ExC(5f)), ExC(true)), Ex.Block(new[] { yi }, yi.Is(ExC(5f)), yi.Add(x)), ExC(2f) ); AreEqual(ex.Linearize().ToCSharpString(), @" float linz_0; z = (5f); if (true) { float y; y = (5f); linz_0 = ((y) + (x)); } else { linz_0 = (2f); } linz_0;;"); //ternary ok var ex2 = Ex.Condition(Ex.Block(zi.Is(ExC(5f)), ExC(true)), yi.Add(x), ExC(2f) ); AreEqual(ex2.Linearize().ToCSharpString(), @" z = (5f); (true ? (y) + (x) : 2f);;"); //cond can be simplified var ex3 = Ex.Condition(Ex.GreaterThan(zi, ExC(5f)), yi.Add(x), ExC(2f) ); AreEqual(ex3.Linearize().ToCSharpString(), @"((z) > (5f) ? (y) + (x) : 2f);"); }
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); }
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 Expression CreateLambdaExpression <T, TModel>(IEnumerable <FilterElement> filterElements, Type querytype, ParameterExpression arg) { Expression expression = Expression.Constant(true); foreach (var filterElement in filterElements) { string[] props = filterElement.FilterSpecs.DataElement.Split('.'); Expression propertyExpression = arg; var type = typeof(T); Expression notNullExpression = Expression.Constant(true); foreach (var property in props) { PropertyInfo pi = type.GetProperty(property); propertyExpression = Expression.Property(propertyExpression, pi); var nullExpression = Expression.Constant(GetNullExpressionForType(pi.PropertyType), pi.PropertyType); notNullExpression = Expression.AndAlso(notNullExpression, Expression.NotEqual(propertyExpression, nullExpression)); type = pi.PropertyType; } var isLiteralType = type.IsEquivalentTo(typeof(string)); var valueExpression = Expression.Constant(filterElement.FieldValue, filterElement.Property.PropertyType); Expression inputExpression, variableExpression; if (filterElement.FilterSpecs.CaseSensitive && isLiteralType) { variableExpression = Expression.Call(propertyExpression, typeof(String).GetMethod("ToUpper", new Type[] { })); inputExpression = Expression.Call(valueExpression, typeof(String).GetMethod("ToUpper", new Type[] { })); } else { // special case to handle nullable values if (valueExpression.Type.IsNullable()) { valueExpression = Expression.Constant(valueExpression.Value, filterElement.Property.PropertyType.NullableOf()); } inputExpression = valueExpression; variableExpression = propertyExpression; } BinaryExpression conditionExpression = Expression.Equal(variableExpression, valueExpression); switch (filterElement.FilterSpecs.OperatorOption) { case Operator.Equal: conditionExpression = Expression.Equal(variableExpression, inputExpression); break; case Operator.GreaterThan: conditionExpression = Expression.GreaterThan(variableExpression, inputExpression); break; case Operator.GreaterThanOrEqualTo: conditionExpression = Expression.GreaterThanOrEqual(variableExpression, inputExpression); break; case Operator.LessThan: conditionExpression = Expression.LessThan(variableExpression, inputExpression); break; case Operator.LessThanOrEqualTo: conditionExpression = Expression.LessThanOrEqual(variableExpression, inputExpression); break; case Operator.Unequal: conditionExpression = Expression.NotEqual(variableExpression, inputExpression); break; case Operator.Like: MethodInfo method = typeof(string).GetMethod("Contains", new[] { typeof(string) }); var containsMethodCall = Expression.Call(variableExpression, method, inputExpression); conditionExpression = Expression.Equal(containsMethodCall, Expression.Constant(true)); break; } var clausePart = Expression.AndAlso(notNullExpression, conditionExpression); if (!filterElement.FieldValue.Equals(GetNullExpressionForType(filterElement.Property.PropertyType))) { expression = Expression.AndAlso(expression, clausePart); } } return(expression); }
public void Factorial() { var value = LinqExpression.Parameter(typeof(int)); var result = LinqExpression.Parameter(typeof(int)); var label = LinqExpression.Label(typeof(int)); var expected = LinqExpression.Block( new[] { result }, LinqExpression.Assign( result, LinqExpression.Constant(1)), LinqExpression.Loop( LinqExpression.Condition( LinqExpression.GreaterThan( value, LinqExpression.Constant(1)), LinqExpression.MultiplyAssign( result, LinqExpression.PostDecrementAssign( value)), LinqExpression.Break( label, result), typeof(void)), label)); using var g = new GraphEngine.Graph(); g.LoadFromString(@" @prefix xsd: <http://www.w3.org/2001/XMLSchema#> . @prefix : <http://example.com/> . @prefix xt: <http://example.com/ExpressionTypes/> . _:constantValue :parameterType [ :typeName ""System.Int32"" ; ] ; . _:result :parameterType [ :typeName ""System.Int32"" ; ] ; . _:label :targetType [ :typeName ""System.Int32"" ; ] ; . _:one :constantValue ""1""^^xsd:int ; . :s :blockVariables ( _:result ) ; :blockExpressions ( [ :binaryExpressionType xt:Assign ; :binaryLeft _:result ; :binaryRight _:one ; ] [ :loopBody [ :conditionTest [ :binaryExpressionType xt:GreaterThan ; :binaryLeft _:constantValue ; :binaryRight _:one ; ] ; :conditionIfTrue [ :binaryExpressionType xt:MultiplyAssign ; :binaryLeft _:result ; :binaryRight [ :unaryExpressionType xt:PostDecrementAssign ; :unaryOperand _:constantValue ; ] ; ] ; :conditionIfFalse [ a :Break ; :gotoTarget _:label ; :gotoValue _:result ; ] ; :conditionType [ :typeName ""System.Void"" ; ] ; ] ; :loopBreak _:label ; ] ) ; . "); var s = g.GetUriNode(":s"); var actual = Expression.Parse(s).LinqExpression; Console.WriteLine(actual.GetDebugView()); actual.Should().Be(expected); }
/// <summary> /// 创建大于运算表达式 /// </summary> /// <param name="left">左操作数</param> /// <param name="right">右操作数</param> public static MicrosoftExpression Greater(this MicrosoftExpression left, MicrosoftExpression right) { return(MicrosoftExpression.GreaterThan(left, right)); }
public static Ex GT0(this Ex me) => Ex.GreaterThan(me, Ex.Constant(0f));
public static Ex GT(this Ex me, Ex than) => Ex.GreaterThan(me, than);
// 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); }
/// <summary> /// Switch between two parametrics based on time. /// </summary> /// <param name="at_time">Switch reference</param> /// <param name="from">Parametric to return before switch</param> /// <param name="to">Parametric to return after switch</param> /// <returns></returns> public static ExTP Switch(float at_time, ExTP from, ExTP to) { return(bpi => Ex.Condition(Ex.GreaterThan(bpi.t, ExC(at_time)), to(bpi), from(bpi))); }
private static BinaryExpression GreaterThanExpression(ParameterExpression parameter, string propertyName, object value) { var(bodyLeft, bodyRight) = GetBodyExpressions(parameter, propertyName, value); return(SystemExpression.GreaterThan(bodyLeft, bodyRight)); }
private static Expression GetExpression <T>(ParameterExpression param, Filter filter) { object filterValue = filter.Value; Op operation = filter.Operation; MemberExpression member = Expression.Property(param, filter.PropertyName); ConstantExpression constant; #region NULLABLE HANDLING if (filterValue != null && IsNullableType(member.Type)) { var targetType = Nullable.GetUnderlyingType(member.Type); var propertyValue = Convert.ChangeType(filterValue, targetType); constant = Expression.Constant(propertyValue, member.Type); } else { constant = Expression.Constant(filterValue); } #endregion switch (operation) { case Op.GreaterThan: return(Expression.GreaterThan(member, constant)); case Op.GreaterThanOrEqual: return(Expression.GreaterThanOrEqual(member, constant)); case Op.LessThan: return(Expression.LessThan(member, constant)); case Op.LessThanOrEqual: return(Expression.LessThanOrEqual(member, constant)); case Op.Equals: //string equals ignore case comparison if (member.Type.TypeHandle.Equals(typeof(string).TypeHandle)) { var compareExpression = Expression.Call(null, compareMethod, member, constant, Expression.Constant(StringComparison.InvariantCultureIgnoreCase)); return(Expression.Equal(compareExpression, Expression.Constant(0))); } return(Expression.Equal(member, constant)); case Op.Contains: return(Expression.Call(member, containsMethod, constant)); case Op.StartsWith: return(Expression.Call(member, startsWithMethod, constant)); case Op.EndsWith: return(Expression.Call(member, endsWithMethod, constant)); case Op.NotEqual: return(Expression.NotEqual(member, constant)); case Op.HasFlag: constant = Expression.Constant(filter.Value, typeof(Enum)); return(Expression.Call(member, hasFlagMethod, constant)); } return(null); }
public static Expression GreaterThan(Expression arg0, Expression arg1) { return(new Expression(LinqExpression.GreaterThan(arg0, arg1))); }