/// <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);
}
