private static void CompileNativeExpressions()
{
#if WINDOWS
Arithmetic.CompileExpression(
(a, b, x) =>
a + ((b - a) * x),
out _Linear
);
Arithmetic.CompileExpression(
(a, b, x) =>
a + ((b - a) * ((1.0f - (float)Math.Cos(x * Math.PI)) * 0.5f)),
out _Cosine
);
Arithmetic.CompileExpression(
(a, b, c, d) =>
(d - c) - (a - b),
out _CubicP
);
Arithmetic.CompileExpression(
(a, b, c, d, p, x, x2, x3) =>
(p * x3) + ((a - b - p) * x2) + ((c - a) * x) + b,
out _CubicR
);
#endif
}
public void CompileExpression()
{
Func <float, float> fn;
Arithmetic.CompileExpression(
(a) => a * 2.0f,
out fn
);
Assert.AreEqual(fn(2.0f), 4.0f);
Assert.AreEqual(fn(2), 4.0f);
Arithmetic.CompileExpression(
(a) => - a / 2.0f + 1.0f,
out fn
);
Assert.AreEqual(fn(2.0f), 0.0f);
Assert.AreEqual(fn(-1), 1.5f);
Func <float, bool> cmp;
Arithmetic.CompileExpression(
(a) => a == 2.0f,
out cmp
);
Assert.IsTrue(cmp(2.0f));
Assert.IsTrue(cmp(2));
Assert.IsFalse(cmp(3.0f));
Func <ValueType, ValueType, bool> cmpvt;
Arithmetic.CompileExpression(
(a, b) => a == b,
out cmpvt
);
ValueType vtA = new ValueType(1.0f, 1.0f);
ValueType vtB = new ValueType(1.0f, 2.0f);
Assert.IsTrue(cmpvt(vtA, vtA));
Assert.IsFalse(cmpvt(vtA, vtB));
Arithmetic.CompileExpression(
(a) => Math.Cos(a),
out fn
);
Assert.AreEqual(fn(5.0f), (float)Math.Cos(5.0f));
Assert.AreEqual(fn(0.5f), (float)Math.Cos(0.5f));
}
public void CompileExpressionWithMixedTypes()
{
Func <ValueType, float, ValueType> mul;
Arithmetic.CompileExpression(
(a, b) => a * b,
out mul
);
ValueType vt = new ValueType(1.0f, 1.0f);
Assert.AreEqual(mul(vt, 2.0f), new ValueType(2.0f, 2.0f));
}
private static void CompileNativeExpressions()
{
#if !DYNAMICMETHOD
if (_Linear == null)
{
Arithmetic.CompileExpression(
(a, b, x) =>
a + ((b - a) * x),
out _Linear
);
}
// FIXME: This is the best we can do
if (_Cosine == null)
{
Arithmetic.CompileExpression(
(a, b, x) =>
a + ((b - a) * ((1.0f - (float)Math.Cos(x * Math.PI)) * 0.5f)),
out _Cosine
);
}
if (_CubicP == null)
{
Arithmetic.CompileExpression(
(a, b, c, d) =>
(d - c) - (a - b),
out _CubicP
);
}
if (_CubicR == null)
{
Arithmetic.CompileExpression(
(a, b, c, d, p, x, x2, x3) =>
(p * x3) + ((a - b - p) * x2) + ((c - a) * x) + b,
out _CubicR
);
}
#endif
}
public void PerformanceTest()
{
int numIterations = 20000;
float[] r = new float[numIterations];
float numIterationsF = numIterations;
float a = 0.0f, b = 1.0f, c;
var _add = Arithmetic.GetOperator <float, float>(Arithmetic.Operators.Add);
var _mul = Arithmetic.GetOperator <float, float>(Arithmetic.Operators.Multiply);
var _sub = Arithmetic.GetOperator <float, float>(Arithmetic.Operators.Subtract);
_add(0.0f, 0.0f);
_mul(0.0f, 0.0f);
_sub(0.0f, 0.0f);
Expression <Func <float, float, float, float> > expr = (A, B, C) => A + ((B - A) * C);
Func <float, float, float, float> nativeExpr = expr.Compile();
Func <float, float, float, float> genericExpr;
Arithmetic.CompileExpression(
(A, B, C) => A + ((B - A) * C),
out genericExpr
);
long start = Time.Ticks;
for (int i = 0; i < numIterations; i++)
{
c = (i / numIterationsF);
r[i] = a + ((b - a) * c);
}
long end = Time.Ticks;
Console.WriteLine("Native expression execution time: {0} ticks for {1} iterations ({2:0.000} ticks/iter)", end - start, numIterations, (end - start) / numIterationsF);
start = Time.Ticks;
for (int i = 0; i < numIterations; i++)
{
c = (i / numIterationsF);
r[i] = Arithmetic.InvokeOperator(Arithmetic.Operators.Add, a, Arithmetic.InvokeOperator(Arithmetic.Operators.Multiply, Arithmetic.InvokeOperator(Arithmetic.Operators.Subtract, b, a), c));
}
end = Time.Ticks;
Console.WriteLine("Naive delegate generic execution time: {0} ticks for {1} iterations ({2:0.000} ticks/iter)", end - start, numIterations, (end - start) / numIterationsF);
start = Time.Ticks;
for (int i = 0; i < numIterations; i++)
{
c = (i / numIterationsF);
r[i] = _add(a, _mul(_sub(b, a), c));
}
end = Time.Ticks;
Console.WriteLine("Cached delegate execution time: {0} ticks for {1} iterations ({2:0.000} ticks/iter)", end - start, numIterations, (end - start) / numIterationsF);
start = Time.Ticks;
for (int i = 0; i < numIterations; i++)
{
c = (i / numIterationsF);
r[i] = nativeExpr(a, b, c);
}
end = Time.Ticks;
Console.WriteLine("Native expression delegate execution time: {0} ticks for {1} iterations ({2:0.000} ticks/iter)", end - start, numIterations, (end - start) / numIterationsF);
start = Time.Ticks;
for (int i = 0; i < numIterations; i++)
{
c = (i / numIterationsF);
r[i] = genericExpr(a, b, c);
}
end = Time.Ticks;
Console.WriteLine("Generic expression delegate execution time: {0} ticks for {1} iterations ({2:0.000} ticks/iter)", end - start, numIterations, (end - start) / numIterationsF);
}