| public static PostIncrementAssign ( Expression expression ) : UnaryExpression | ||
| expression | Expression | An |
| return | UnaryExpression | |
// Define a function for running the simulation of a population system S with timestep
// dt. The number of timesteps and the data buffer are parameters of the defined function.
static Func <int, double[, ], int> DefineSimulate(double dt, PopulationSystem S)
{
CodeGen code = new CodeGen();
// Define a parameter for the current population x, and define mappings to the
// expressions defined above.
LinqExpr N = code.Decl <int>(Scope.Parameter, "N");
LinqExpr Data = code.Decl <double[, ]>(Scope.Parameter, "Data");
// Loop over the sample range requested. Note that this loop is a 'runtime' loop,
// while the rest of the loops nested in the body of this loop are 'compile time' loops.
LinqExpr n = code.DeclInit <int>("n", 1);
code.For(
() => { },
LinqExpr.LessThan(n, N),
() => code.Add(LinqExpr.PostIncrementAssign(n)),
() =>
{
// Define expressions representing the population of each species.
List <Expression> x = new List <Expression>();
for (int i = 0; i < S.N; ++i)
{
// Define a variable xi.
Expression xi = "x" + i.ToString();
x.Add(xi);
// xi = Data[n, i].
code.DeclInit(xi, LinqExpr.ArrayAccess(Data, LinqExpr.Subtract(n, LinqExpr.Constant(1)), LinqExpr.Constant(i)));
}
for (int i = 0; i < S.N; ++i)
{
// This list is the elements of the sum representing the i'th
// row of f, i.e. r_i + (A*x)_i.
Expression dx_dt = 1;
for (int j = 0; j < S.N; ++j)
{
dx_dt -= S.A[i, j] * x[j];
}
// Define dx_i/dt = x_i * f_i(x), as per the Lotka-Volterra equations.
dx_dt *= x[i] * S.r[i];
// Euler's method for x(t) is: x(t) = x(t - h) + h * x'(t - h).
Expression integral = x[i] + dt * dx_dt;
// Data[n, i] = Data[n - 1, i] + dt * dx_dt;
code.Add(LinqExpr.Assign(
LinqExpr.ArrayAccess(Data, n, LinqExpr.Constant(i)),
code.Compile(integral)));
}
});
code.Return(N);
// Compile the generated code.
LinqExprs.Expression <Func <int, double[, ], int> > expr = code.Build <Func <int, double[, ], int> >();
return(expr.Compile());
}
private UnaryExpression UnaryExpression(
ExpressionType nodeType, System.Type type, JObject obj)
{
var operand = this.Prop(obj, "operand", this.Expression);
var method = this.Prop(obj, "method", this.Method);
switch (nodeType)
{
case ExpressionType.ArrayLength: return(Expr.ArrayLength(operand));
case ExpressionType.Convert: return(Expr.Convert(operand, type, method));
case ExpressionType.ConvertChecked: return(Expr.ConvertChecked(operand, type, method));
case ExpressionType.Decrement: return(Expr.Decrement(operand, method));
case ExpressionType.Increment: return(Expr.Increment(operand, method));
case ExpressionType.IsFalse: return(Expr.IsFalse(operand, method));
case ExpressionType.IsTrue: return(Expr.IsTrue(operand, method));
case ExpressionType.Negate: return(Expr.Negate(operand, method));
case ExpressionType.NegateChecked: return(Expr.NegateChecked(operand, method));
case ExpressionType.Not: return(Expr.Not(operand, method));
case ExpressionType.OnesComplement: return(Expr.OnesComplement(operand, method));
case ExpressionType.PostDecrementAssign: return(Expr.PostDecrementAssign(operand, method));
case ExpressionType.PostIncrementAssign: return(Expr.PostIncrementAssign(operand, method));
case ExpressionType.PreDecrementAssign: return(Expr.PreDecrementAssign(operand, method));
case ExpressionType.PreIncrementAssign: return(Expr.PreIncrementAssign(operand, method));
case ExpressionType.Quote: return(Expr.Quote(operand));
case ExpressionType.Throw: return(Expr.Throw(operand, type));
case ExpressionType.TypeAs: return(Expr.TypeAs(operand, type));
case ExpressionType.UnaryPlus: return(Expr.UnaryPlus(operand, method));
case ExpressionType.Unbox: return(Expr.Unbox(operand, type));
default: throw new NotSupportedException();
}
}
// Pseudocode:
//I input =>
//{
// var i = (UI)input;
// var result = new char[base64sizeof(UI)];
// for (int j = 0; j == 0 || i > 0; j++)
// {
// result[j] = _mapChar[i & 0x3f];
// i >>= 6;
// }
//}
private LambdaExpression toLambda(Type from)
{
var input = Ex.Parameter(from, "input");
var result = Ex.Parameter(typeof(char[]), "result");
var i = workingType(from) == from ? input : Ex.Parameter(workingType(from), "i");
var j = Ex.Parameter(typeof(int), "j");
var loopstart = Ex.Label("loopstart");
var loopend = Ex.Label("loopend");
var loop = Ex.Block(
Ex.Label(loopstart),
Ex.IfThen(Ex.MakeBinary(ExpressionType.AndAlso,
Ex.MakeBinary(ExpressionType.GreaterThan, j, Ex.Constant(0)),
i.Type == typeof(BigInteger)
? (Ex)Ex.Call(i, nameof(BigInteger.Equals), Type.EmptyTypes, Ex.Constant(BigInteger.Zero))
: Ex.MakeBinary(ExpressionType.Equal, i, Ex.Convert(Ex.Constant(0), i.Type))),
Ex.Goto(loopend)),
Ex.Assign(
Ex.ArrayAccess(result, j),
Ex.ArrayIndex(Ex.Constant(_mapChars),
Ex.Convert(Ex.MakeBinary(ExpressionType.And, i, Ex.Convert(Ex.Constant(0x3f), i.Type)), typeof(int)))),
Ex.RightShiftAssign(i, Ex.Constant(6)),
Ex.PostIncrementAssign(j),
Ex.Goto(loopstart));
var ret = Result(typeof(string),
Ex.New(typeof(string).GetTypeInfo().DeclaredConstructors
.Select(c => new { c, p = c.GetParameters() })
.First(c => c.p.Length == 3 && c.p[0].ParameterType == typeof(char[]) && c.p[1].ParameterType == typeof(int) && c.p[2].ParameterType == typeof(int)).c,
result, Ex.Constant(0), j));
var block = Ex.Block(Ex.Assign(j, Ex.Constant(0)),
Ex.Assign(result, Ex.NewArrayBounds(typeof(char), Ex.Constant(charbound(from)))),
loop,
Ex.Label(loopend),
ret);
block = input == i
? Ex.Block(new[] { j, result },
block)
: Ex.Block(new[] { i, j, result },
Ex.Assign(i, Ex.Convert(input, i.Type)),
block);
return(Ex.Lambda(block, input));
}
public static Ex Ipp(this Ex me) => Ex.PostIncrementAssign(me);
