public static And ( |
||
left | An |
|
right | An |
|
return |
public override Expression<Func<Unbrickable.Models.Post, bool>> filterPosts(Expression<Func<Unbrickable.Models.Post, bool>> predicate) { if (operation != 1 && operation != 2 && operation != 3) { return predicate; } if (this.isOr) { Debug.WriteLine("Or " + this.operation + " on " + this.date.Date); switch (operation) { case 1: return predicate.Or(x => DbFunctions.TruncateTime(x.date_posted) >= this.date); case 2: return predicate.Or(x => DbFunctions.TruncateTime(x.date_posted) <= this.date); case 3: return predicate.Or(x => DbFunctions.TruncateTime(x.date_posted) == this.date); default: return predicate; } } else { Debug.WriteLine("And " + this.operation + " on " + this.date.Date); switch (operation) { case 1: return predicate.And(x => DbFunctions.TruncateTime(x.date_posted) >= this.date); case 2: return predicate.And(x => DbFunctions.TruncateTime(x.date_posted) <= this.date); case 3: return predicate.And(x => DbFunctions.TruncateTime(x.date_posted) == this.date); default: return predicate; } } }
/// <summary> /// And condition join /// </summary> /// <typeparam name="T"></typeparam> /// <param name="exp_left"></param> /// <param name="exp_right"></param> /// <returns></returns> public static Expression <Func <T, bool> > And <T>(this Expression <Func <T, bool> > exp_left, Expression <Func <T, bool> > exp_right) { var candidateExpr = Expression.Parameter(typeof(T), "candidate"); var parameterReplacer = new ParameterReplacer(candidateExpr); var left = parameterReplacer.Replace(exp_left.Body); var right = parameterReplacer.Replace(exp_right.Body); var body = Expression.And(left, right); return(Expression.Lambda <Func <T, bool> >(body, candidateExpr)); }
public override Expression<Func<Unbrickable.Models.Post, bool>> filterPosts(Expression<Func<Unbrickable.Models.Post, bool>> predicate) { if (this.isOr) { Debug.WriteLine("Or " + this.min_date.Date + " to " + this.max_date.Date); return predicate.Or(x => DbFunctions.TruncateTime(x.date_posted) >= min_date && DbFunctions.TruncateTime(x.date_posted) <= max_date); } else { Debug.WriteLine("And " + this.min_date.Date + " to " + this.max_date.Date); return predicate.And(x => DbFunctions.TruncateTime(x.date_posted) >= min_date && DbFunctions.TruncateTime(x.date_posted) <= max_date); } }
public override Expression<Func<Unbrickable.Models.Post, bool>> filterPosts(Expression<Func<Unbrickable.Models.Post, bool>> predicate) { this.username = this.username ?? ""; if (this.isOr) { Debug.WriteLine("Or " + this.username); return predicate.Or(x => x.Account.username.Equals(this.username)); } else { Debug.WriteLine("And " + this.username); return predicate.And(x => x.Account.username.Equals(this.username)); } }
public override Expression<Func<Unbrickable.Models.Post, bool>> filterPosts(Expression<Func<Unbrickable.Models.Post, bool>> predicate) { this.search_contents = this.search_contents ?? ""; if (this.isOr) { Debug.WriteLine("Or " + this.search_contents); return predicate.Or(x => x.entry.Contains(this.search_contents)); } else { Debug.WriteLine("And " + this.search_contents); return predicate.And(x => x.entry.Contains(this.search_contents)); } }
public object Convert(object value, Type targetType, object parameter, CultureInfo culture) { if (value == null || parameter == null) { return(null); } if (!value.GetType().IsEnum || !parameter.GetType().IsEnum) { return(null); } var flagsParam = Expression.Parameter(typeof(object), "flags"); var flagParam = Expression.Parameter(typeof(object), "flag"); var hasFlag = Expression.Equal(Expression.And(Expression.Convert(flagsParam, value.GetType()), Expression.Convert(flagParam, parameter.GetType())), flagParam); var expression = Expression.Lambda <Func <object, object, bool> >(hasFlag, flagsParam, flagParam); return(expression.Compile()(value, parameter) ? Visibility.Visible : Visibility.Collapsed); }
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(); } }
/// <summary> /// 添加表达式 /// </summary> /// <param name="property">属性表达式</param> /// <param name="operator">运算符</param> /// <param name="value">值</param> public void Append <TProperty>(Expression <Func <TEntity, TProperty> > property, Operator @operator, object value) { _result = _result.And(_parameter.Property(Lambda.GetMember(property)).Operation(@operator, value)); }
private Expression<Func<AccountTransactionValue, bool>> GetPastRange(int filterType, Expression<Func<AccountTransactionValue, bool>> activeSpecification, WorkPeriod workPeriod) { //Resources.All, Resources.Month, Resources.Week, Resources.WorkPeriod DateTime? date = null; if (filterType == 1) date = DateTime.Now.MonthStart(); if (filterType == 2) date = DateTime.Now.StartOfWeek(); if (filterType == 3) date = workPeriod.StartDate; return date.HasValue ? activeSpecification.And(x => x.Date < date) : activeSpecification; }
private Expression<Func<AccountTransactionValue, bool>> GetPastRange(Expression<Func<AccountTransactionValue, bool>> activeSpecification) { if (FilterType == Resources.Month) return activeSpecification.And(x => x.Date < DateTime.Now.MonthStart()); if (FilterType == Resources.WorkPeriod) return activeSpecification.And(x => x.Date < _applicationState.CurrentWorkPeriod.StartDate); return activeSpecification; }
// 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 Expression And(Expression arg0, Expression arg1) { return(new Expression(LinqExpression.And(arg0, arg1))); }
private static Ex dGetDegIndex(TEx <double> angleDeg) => Ex.And(angleDeg.Mul(ExC(degRatio)).As <int>(), ExC(LookupMask));
private static Ex dGetRadIndex(TEx <double> angleRad) => Ex.And(angleRad.Mul(ExC(radRatio)).As <int>(), ExC(LookupMask));
public static Expression <Func <T, bool> > And <T>(this Expression <Func <T, bool> > expr1, Expression <Func <T, bool> > expr2) { var invokedExpr = Expression.Invoke(expr2, expr1.Parameters); return(Expression.Lambda <Func <T, bool> >(Expression.And(expr1.Body, invokedExpr), expr1.Parameters)); }