protected void Check(Func <double, double> reference, ExpressionTreeDerivativeParser parser, string expression)
{
double x = 0.0;
Func <double> var = () => x;
void VariableFound(object sender, VariableFoundEventArgs <Derivatives <Expression> > e)
{
if (e.Name == "x")
{
e.Result = new ExpressionTreeDerivatives();
e.Result[0] = Expression.Call(Expression.Constant(var), InvokeMethod);
}
}
parser.VariableFound += VariableFound;
var parsed = ((ISpiceDerivativeParser <double>)parser).Parse(expression)[0];
parser.VariableFound -= VariableFound;
for (x = -2; x <= 2; x += 0.5)
{
var expected = reference(x);
var actual = parsed();
var tol = Math.Max(Math.Abs(expected), Math.Abs(actual)) * RelativeTolerance + AbsoluteTolerance;
Assert.AreEqual(expected, actual, tol);
}
}
public void When_Brackets_Expect_Reference()
{
var parser = new ExpressionTreeDerivativeParser();
Check(1 - (5.8 - 12) - 3, parser.Parse("1 - (5.8 - 12) - 3"));
Check(2 * (2 + 3) * 4, parser.Parse("2 * ((2 + 3)) * 4"));
}
public void When_Conditional_Expect_Reference()
{
var parser = new ExpressionTreeDerivativeParser();
Check(1, parser.Parse("1 >= 0 ? 1 : 2"));
Check(2, parser.Parse("1 >= 3 ? 1 : 2"));
}
/// <summary>
/// Remove the default functions from the parser.
/// </summary>
/// <param name="parser">The parser.</param>
public static void UnregisterDefaultFunctions(this ExpressionTreeDerivativeParser parser)
{
parser.FunctionFound -= DefaultFunctionFound;
}
protected void Check(Func <double[], double>[] reference, ExpressionTreeDerivativeParser parser, string expression)
{
double[] x = new double[reference.Length];
Func <int, double> var = i => x[i];
void VariableFound(object sender, VariableFoundEventArgs <Derivatives <Expression> > e)
{
if (e.Name.Length == 1)
{
var c = e.Name[0] - 'a';
if (c >= 0 && c < reference.Length - 1)
{
e.Result = new ExpressionTreeDerivatives();
e.Result[0] = Expression.Call(Expression.Constant(var), Invoke2Method, Expression.Constant(c, typeof(int)));
e.Result[c + 1] = Expression.Constant(1.0);
}
}
}
parser.VariableFound += VariableFound;
var result = ((ISpiceDerivativeParser <double>)parser).Parse(expression);
parser.VariableFound -= VariableFound;
var parsed = new Func <double> [reference.Length];
for (var i = 0; i < reference.Length; i++)
{
parsed[i] = result[i];
}
// Iterate through a number of values
for (var i = 0; i < x.Length; i++)
{
x[i] = -2.0;
}
while (true)
{
Derivatives <Expression> .FudgeFactor = 0.0;
for (var i = 0; i < reference.Length; i++)
{
var expected = reference[i](x);
var actual = parsed[i]();
var tol = Math.Max(Math.Abs(expected), Math.Abs(actual)) * RelativeTolerance + AbsoluteTolerance;
Assert.AreEqual(expected, actual, tol);
}
// Find the last index that reached the maximum
var index = x.Length - 1;
while (index >= 0 && x[index] >= 2.0)
{
index--;
}
if (index < 0)
{
break;
}
x[index] += 0.5;
for (var i = index + 1; i < x.Length; i++)
{
x[i] = 0.0;
}
}
}
public void When_Power_Expect_Reference()
{
var parser = new ExpressionTreeDerivativeParser();
Check(Math.Pow(2, Math.Pow(0.5, 3)), parser.Parse("2^0.5^3"));
}
public void When_Division_Expect_Reference()
{
var parser = new ExpressionTreeDerivativeParser();
Check(4 / 0.4 / 2.8, parser.Parse("4 / 0.4 / 2.8"));
}
public void When_Multiplication_Expect_Reference()
{
var parser = new ExpressionTreeDerivativeParser();
Check(3 * 1.8 * 0.9, parser.Parse("3 * 1.8 * 0.9"));
}
public void When_Subtraction_Expect_Reference()
{
var parser = new ExpressionTreeDerivativeParser();
Check(2 - 5.8 - 12, parser.Parse("2 - 5.8 - 12"));
}
public void When_Addition_Expect_Reference()
{
var parser = new ExpressionTreeDerivativeParser();
Check(1 + 2.5 + 10.8, parser.Parse("1 + 2.5 + 10.8"));
}
