/// <summary> /// Use Fermat's Little Theorem to reindex integers around a prime number mod, localized to the region /// [mod\*floor(index/mod), mod+mod\*floor(index/mod)]. /// </summary> public static tfloat RemapIndexLoop(efloat mod, efloat index) => EEx.Resolve(mod, index, (m, i) => { var rem = VFloat(); return(Ex.Block(new[] { rem }, rem.Is(Mod(m, i)), i.Sub(rem).Add(RemapIndex(m, rem)) )); });
/// <summary> /// Periodize a value, /// "bouncing off" the endpoint instead of wrapping around. /// </summary> /// <example> /// <c> /// FSoftMod(X(), 4)(3.95) = 3.95 /// FSoftMod(X(), 4)(4.05) = 3.95 /// FSoftMod(X(), 4)(4.15) = 3.85 /// </c> /// </example> /// <param name="by">Period</param> /// <param name="x">Value</param> /// <returns></returns> public static tfloat SoftMod(efloat by, efloat x) => EEx.Resolve(by, _by => { var vd = VFloat(); return(Ex.Block(new[] { vd }, vd.Is(Mod(E2.Mul(_by), x)), Ex.Condition(vd.LT(_by), vd, E2.Mul(_by).Sub(vd)) )); });
/// <summary> /// Use this to draw "wings" where both go in opposite directions. /// <br/>Odd by: 0 is the center, [1,by/2-0.5] are one wing, and [by/2+0.5,by) are the other. /// <br/>Even by: [0, by/2) are one wing, [by/2, by) are the other. /// </summary> /// <example> /// <c> /// HNMod(X(), 9)(0) = HNMod(X(), 9)(9) = 0 /// HNMod(X(), 9)(1) = 1 /// HNMod(X(), 9)(5) = -1 /// HNMod(X(), 9)(8) = -4 /// HNMod(X(), 8)(0) = HNMod(X(), 8)(8) = 0.5 /// HNMod(X(), 8)(3) = 3.5 /// HNMod(X(), 8)(4) = -0.5 /// </c> /// </example> /// <param name="by">Period</param> /// <param name="x">Target function</param> /// <returns></returns> public static tfloat HNMod(tfloat by, tfloat x) => EEx.Resolve <float>(by.Div(E2), h => { var y = VFloat(); return(Ex.Block(new[] { y }, y.Is(Mod(h.Mul(E2), x)), Ex.Condition(y.LT(h), y.Add(Floor(h)).Add(E05).Sub(h), h.Sub(E05).Sub(y)) )); });
static Action <string, string> MakeNewProjectDialogMethod() { var newProjInfoType = AppDomain.CurrentDomain.GetAssemblies().SelectMany(a => a.GetTypesOrNone()).FirstOrDefault(t => t.Name == "VSNEWPROJECTDLGINFO"); var sDialogService = Microsoft.VisualStudio.Shell.ServiceProvider.GlobalProvider.GetService(typeof(SVsDialogService)); var rawDialogService = (SVsDialogService)sDialogService; var hierarchyArg = Expression.Parameter(typeof(string), "hierarchy"); var nameArg = Expression.Parameter(typeof(string), "name"); var newProjInfoVar = Expression.Variable(newProjInfoType, "newProjInfo"); var locVar = Expression.Variable(typeof(string), "locVar"); var expr = Expression.Lambda <Action <string, string> >( Expression.Block( new[] { newProjInfoVar, locVar }, Expression.Assign(newProjInfoVar, Expression.New(newProjInfoType)), Expression.Assign(Expression.Field(newProjInfoVar, newProjInfoType.GetField("pwzExpand")), hierarchyArg), Expression.Assign(Expression.Field(newProjInfoVar, newProjInfoType.GetField("pwzSelect")), nameArg), Expression.Call(Expression.Constant(rawDialogService, typeof(SVsDialogService)), rawDialogService.GetType().GetMethod("InvokeDialog"), newProjInfoVar, locVar) ), new[] { hierarchyArg, nameArg } ); var compiledExpr = expr.Compile(); return(compiledExpr); }
Expr Logical(DynamicMetaObject left, DynamicMetaObject right) { // Assign left operand to a temp variable for single evaluation var tempLeft = Expr.Variable(left.LimitType); var compareExpr = (Expr)tempLeft; Expr ifExpr = null; switch (Operation) { case ExprType.AndAlso: if (left.LimitType != typeof(bool)) { compareExpr = Expr.Equal(tempLeft, Expr.Constant(null)); } ifExpr = Expr.IfThenElse(compareExpr, right.Expression, tempLeft); break; case ExprType.OrElse: if (left.LimitType != typeof(bool)) { compareExpr = Expr.NotEqual(tempLeft, Expr.Constant(null)); } ifExpr = Expr.IfThenElse(compareExpr, tempLeft, right.Expression); break; } return (Expr.Block( new[] { tempLeft }, Expr.Assign(tempLeft, left.Expression), ifExpr)); }
protected override LinqExpression BuildLinqExpression() { var leftOperandExpression = LeftNode.GetEvaluationLinqExpression(); var rightOperandExpression = RightNode.GetEvaluationLinqExpression(); var variableLeft = LinqExpression.Variable(typeof(object)); var variableEvaluatedResult = LinqExpression.Variable(typeof(object)); return(LinqExpression.Block( typeof(object), new[] { variableLeft, variableEvaluatedResult }, LinqExpressionHelper.ExpressionCallThrowIfCancellationRequested, LinqExpression.Assign(variableLeft, leftOperandExpression), LinqExpression.IfThen( LinqExpression.Not( LinqExpression.Call( LinqExpression.Constant(Operator), LinqExpressionHelper.MethodInfoBinaryOperatorEvaluateLhs, LinqExpressionHelper.ExpressionParameterContext, variableLeft, variableEvaluatedResult)), LinqExpression.Assign( variableEvaluatedResult, LinqExpression.Call( LinqExpression.Constant(Operator), LinqExpressionHelper.MethodInfoBinaryOperatorEvaluate, LinqExpressionHelper.ExpressionParameterContext, variableLeft, rightOperandExpression))), variableEvaluatedResult)); }
/// <summary> /// Default block parser /// </summary> Exp ParseBlock(List <Expression> body) { var IL = new List <Exp>(); PushBlock(body, IL); return(Exp.Block(IL)); }
public void TypeExpressions() { var expected = LinqExpression.Block( typeof(object), LinqExpression.Default(typeof(string))); var actual = @" @prefix xsd: <http://www.w3.org/2001/XMLSchema#> . @prefix : <http://example.com/> . :s :blockType [ :typeName ""System.Object"" ; ] ; :blockExpressions ( [ :defaultType [ :typeName ""System.String"" ; ] ; ] ) ; . "; ShouldBe(actual, expected); }
/// <summary> /// Return the derivative of a cosine with a custom period/amplitude. /// </summary> /// <param name="period">Cosine period</param> /// <param name="peakHeight">Cosine peak height</param> /// <param name="f">Target function</param> /// <returns></returns> public static tfloat DCosine(tfloat period, tfloat peakHeight, tfloat f) { var w = VFloat(); return(Ex.Block(new[] { w }, w.Is(tau.Div(period)), w.Mul(peakHeight).Mul(Sin(w.Mul(f))).Neg() )); }
public static tfloat PowSub(tfloat bas, tfloat exp) { var val = VFloat(); return(Ex.Block(new[] { val }, Ex.Assign(val, bas), Pow(val, exp).Sub(val) )); }
/// <summary> /// Multiply a color's alpha component by a float value. /// </summary> public static tv4 MulA(tfloat a, tv4 tp) { var v4 = V <Vector4>(); return(Ex.Block(new[] { v4 }, v4.Is(tp), MulAssign(v4.Field("w"), a), v4 )); }
private static tfloat _ModWithPause(tfloat by, tfloat pauseAt, tfloat pauseLen, tfloat x) { var val = VFloat(); return(Ex.Block(new[] { val }, val.Is(Mod(pauseLen.Add(by), x)), Ex.Condition(val.LT(pauseAt), val, Ex.Condition(ExUtils.SubAssign(val, pauseLen).LT(pauseAt), pauseAt, val)) )); }
/// <summary> /// Normalize a vector. /// </summary> public static tv3 Norm3(ev3 v3) => EEx.ResolveV3(v3, xyz => { var mag = VFloat(); return(Ex.Block(new[] { mag }, mag.Is(v3Mag(xyz)), Ex.Condition(mag.GT(ExC(M.MAG_ERR)), xyz.Mul(E1.Div(mag)), xyz ) )); });
/// <summary> /// Normalize a vector. /// </summary> public static tv2 Norm(ev2 v2) => EEx.ResolveV2(v2, xy => { var mag = VFloat(); return(Ex.Block(new[] { mag }, mag.Is(Mag(xy)), Ex.Condition(mag.GT(ExC(M.MAG_ERR)), xy.Mul(E1.Div(mag)), xy ) )); });
/// <summary> /// Combine the R,G,B components of a vector4 and a separate alpha component. /// </summary> public static tv4 WithA(tfloat a, tv4 tp) { var v4 = V <Vector4>(); return(Ex.Block(new[] { v4 }, v4.Is(tp), v4.Field("w").Is(a), v4 )); }
/// <summary> /// Nest a predicate such that it only returns True once for a single bullet. /// </summary> /// <param name="pred"></param> /// <returns></returns> public static ExPred OnlyOnce(ExPred pred) => bpi => { var b = V <bool>(); var key = bpi.Ctx.NameWithSuffix("_OnlyOnce_Set"); return(Ex.Condition(FiringCtx.Contains <int>(bpi, key), ExC(false), Ex.Block(new[] { b }, Ex.IfThen(b.Is(pred(bpi)), FiringCtx.SetValue <int>(bpi, key, ExC(1))), b ) )); };
/// <summary> /// Return true iff the first argument is strictly between the second and third. /// </summary> /// <param name="b">First BPY function</param> /// <param name="br1">Lower bound BPY function</param> /// <param name="br2">Upper bound BPY function</param> /// <returns></returns> public static tbool In(tfloat b, tfloat br1, tfloat br2) { var f = ExUtils.VFloat(); return(Ex.Block(new[] { f }, Ex.Assign(f, b), Ex.AndAlso( Ex.GreaterThan(f, br1), Ex.LessThan(f, br2) ) )); }
Function ParseFunc(Expression def, bool has_self = false) { string name = def[0].Value; var ps = ParseParameters(def[1].Subset, omitFirstParameter: has_self); /* write IL */ LocalBuilder loc = Local; Local = new LocalBuilder(); var IL = new List <Exp>(); ret.Push(Exp.Label(typeof(Object))); // load parameters var arg = Exp.Parameter(typeof(Args), "arg"); if (has_self) { var self = Exp.Variable(typeof(Object), "self"); Local.Add(self); IL.Add(Exp.Assign(self, Exp.Field(arg, "self"))); } ParamInfo pi; for (int i = 0; i < ps.Info.Length; i++) { pi = ps.Info[i]; var p = Exp.Variable(typeof(Object), pi.Name.str); Local.Add(p); IL.Add(Exp.Assign(p, Exp.Property(arg, "Item", Exp.Constant(i)))); } PushBlock(def.Body, IL); // add the return label target IL.Add(Exp.Label(ret.Pop(), NoneExp)); var body = Exp.Block(Local.Variables, IL); Local = loc; var func = Exp.Lambda <Func <Args, Object> >(body, arg).Compile(); return(new Function { Name = name, Parameters = ps, handler = func }); }
private static NodeVisitFunction BuildMethodVisitor(MethodInfo method, out Type parameterType) { var declaringtype = method.DeclaringType; if (declaringtype == null) { throw new InvalidOperationException(string.Format("No declaring type for method [{0}]", method.Name)); } // Throws an exception if parammeters.Count != 1 if (method.GetParameters().Length != 1) { throw new InvalidOperationException( string.Format("Invalid number of parameters [{0}] for visit method [{1}] for type [{2}]. One parameter is expected", method.GetParameters().Length, method.Name, declaringtype.FullName)); } parameterType = method.GetParameters()[0].ParameterType; if (!parameterType.IsInterface && !typeof(Node).IsAssignableFrom(parameterType)) { throw new InvalidOperationException( string.Format("Invalid type parameter [{0}] for visit method [{1}] for type [{2}]. Parameter must inherit from Node", parameterType, method.Name, declaringtype.FullName)); } var thisParameter = LinqExpression.Parameter(typeof(VisitorBase), "this"); var nodeParameter = LinqExpression.Parameter(typeof(object), "node"); var thisCastVariable = LinqExpression.Variable(declaringtype, "thisCast"); var statements = new List <LinqExpression> { LinqExpression.Assign(thisCastVariable, LinqExpression.Convert(thisParameter, declaringtype)) }; var callVisitMethod = LinqExpression.Call(thisCastVariable, method, LinqExpression.Convert(nodeParameter, parameterType)); if (typeof(void) == method.ReturnType) { statements.Add(callVisitMethod); statements.Add(nodeParameter); } else { statements.Add(callVisitMethod); } var block = LinqExpression.Block(new[] { thisCastVariable }, statements); var lambda = LinqExpression.Lambda <NodeVisitFunction>(block, thisParameter, nodeParameter); return(lambda.Compile()); }
public Action MakeDirect() { List <Dlr> body = new List <Dlr>(); foreach (var line in lines) { var ex = line as IExecutable; if (ex == null) { continue; } body.Add(Dlr.Call(Dlr.Constant(ex), ex.GetType().GetMethod("Execute"), Dlr.Constant(new object[0]))); } return(Dlr.Lambda <Action>(Dlr.Block(body.ToArray())).Compile()); }
public static Expr ConvertToNumberAndCheck(Context context, Expr expression, string format, params object[] args) { var numberVar = Expr.Variable(typeof(double)); var assignNumber = Expr.Assign(numberVar, ConvertToNumber(context, expression)); return(Expr.Block( new[] { numberVar }, assignNumber, Expr.Condition( Expr.Invoke( Expr.Constant((Func <double, bool>)Double.IsNaN), numberVar), Expr.Block( Expr.Throw(Expr.New(MemberInfos.NewRuntimeException, Expr.Constant(format), Expr.Constant(args))), Expr.Constant(Double.NaN)), numberVar))); }
public override DynamicMetaObject BindGetIndex(GetIndexBinder binder, DynamicMetaObject[] indexes) { var valueVar = Expr.Variable(typeof(object)); var getValue = Expr.Call( Expr.Convert(Expression, typeof(LuaTable)), MemberInfos.LuaTableGetValue, Expr.Convert(indexes[0].Expression, typeof(object))); var valueAssign = Expr.Assign(valueVar, getValue); var expression = Expr.Block( valueVar, Expr.Condition( Expr.Equal(valueVar, Expr.Constant(null)), MetamethodFallbacks.Index(null, this, indexes), valueVar)); return(new DynamicMetaObject(expression, RuntimeHelpers.MergeTypeRestrictions(this))); }
Expr FallbackIfNumberIsNan(Expr numExpr) { // If we have performed a string to number conversion check that conversion went well by checking // number for NaN. If conversion failed do metatable fallback. Also assign to temp variable for single evaluation. var numVar = Expr.Variable(typeof(double)); var expr = Expr.IfThenElse( Expr.Invoke(Expr.Constant((Func <double, bool>)Double.IsNaN), numVar), Expr.Invoke( Expr.Constant((Func <Context, object, object>)LuaOps.UnaryMinusMetamethod), Expr.Constant(context), Expr.Constant(Operation), Expr.Convert(numExpr, typeof(object))), numVar); return(Expr.Block( new[] { numVar }, Expr.Assign(numVar, numExpr), expr)); }
Expr FallbackIfNumberIsNan(Expr conversionResult, DynamicMetaObject left, DynamicMetaObject right) { // If we have performed a string to number conversion check that conversion went well by checking // number for NaN. If conversion failed do metatable fallback. Also assign to temp variable for single evaluation. var conversionVar = Expr.Variable(typeof(double)); var expr = Expr.Condition( Expr.Invoke(Expr.Constant((Func <double, bool>)Double.IsNaN), conversionVar), Expr.Invoke( Expr.Constant((Func <Context, ExprType, object, object, object>)LuaOps.NumericMetamethod), Expr.Constant(context), Expr.Constant(Operation), Expr.Convert(left.Expression, typeof(object)), Expr.Convert(right.Expression, typeof(object))), Expr.Convert(conversionVar, typeof(object))); return(Expr.Block( new[] { conversionVar }, Expr.Assign(conversionVar, conversionResult), expr)); }
public void ExpressionsVariables() { var expected = LinqExpression.Block( new[] { LinqExpression.Parameter( typeof(string)), }, new[] { LinqExpression.Default( typeof(string)), }); var actual = @" @prefix xsd: <http://www.w3.org/2001/XMLSchema#> . @prefix : <http://example.com/> . :s :blockVariables ( [ :parameterType [ :typeName ""System.String"" ; ] ; ] ) ; :blockExpressions ( [ :defaultType [ :typeName ""System.String"" ; ] ; ] ) ; . "; ShouldBe(actual, expected); }
Class ParseClass(Expression cls) { string name = cls[0].Value; var methods = new Dictionary <string, Function>(); var fields = new Dictionary <string, Exp>(); Action <Object> initf = null; Class parent = null; // inheritance if (cls.Count == 2) { parent = (Class)Py.Global[cls[1].Subset[0].Value]; // copy methods foreach (var m in parent.Methods) { methods.Add(m.Key, m.Value); } // copy fields foreach (var f in parent.Fields) { fields.Add(f.Key, f.Value); } } // parse fields and methods // overload in case member is inherited from base class for (int i = 0; i < cls.Body.Count; i++) { Expression expr = cls.Body[i]; if (expr.Command == "def") { Function func = ParseFunc(expr, has_self: true); methods[func.Name] = func; } else if (Contains(expr, TokenType.Assign)) { (var left, var right, var op) = SplitAssign(expr); fields[left[0].Value] = Parse(right); } } // build field initializer if (fields.Count > 0) { var self = Exp.Parameter(typeof(Object), "self"); Exp loc = Exp.Property(self, "loc"); var buildr = new List <Exp>(); foreach (var f in fields) { buildr.Add(Exp.Call(loc, typeof(Dictionary <string, Object>).GetMethod("Add"), Exp.Constant(f.Key), f.Value)); } Exp body = Exp.Block(buildr); initf = Exp.Lambda <Action <Object> >(body, self).Compile(); } Class type = new Class(name, methods, fields, initf, parent); return(type); }