public void FastCos()
{
for (double angle = -2 * Math.PI; angle <= 2 * Math.PI; angle += 0.0001)
{
var f = (Fix64)angle;
var actualF = MathFix.FastCos(f);
var expected = (decimal)Math.Cos(angle);
var delta = Math.Abs(expected - (decimal)actualF);
Assert.True(delta <= 50000 * Fix64.Precision, string.Format("Cos({0}): expected {1} but got {2}", angle, expected, actualF));
}
foreach (var val in m_testCases)
{
var f = Fix64.FromRaw(val);
var actualF = MathFix.FastCos(f);
var expected = (decimal)Math.Cos((double)f);
var delta = Math.Abs(expected - (decimal)actualF);
Assert.True(delta <= 0.01M, string.Format("Cos({0}): expected {1} but got {2}", f, expected, actualF));
}
}
public void Acos()
{
var maxDelta = 0.00000001m;
var deltas = new List <decimal>();
Assert.Equal(Fix64.Zero, MathFix.Acos(Fix64.One));
Assert.Equal(MathFix.PIOver2, MathFix.Acos(Fix64.Zero));
Assert.Equal(MathFix.PI, MathFix.Acos(-Fix64.One));
// Precision
for (var x = -1.0; x < 1.0; x += 0.001)
{
var xf = (Fix64)x;
var actual = (decimal)MathFix.Acos(xf);
var expected = (decimal)Math.Acos((double)xf);
var delta = Math.Abs(actual - expected);
deltas.Add(delta);
Assert.True(delta <= maxDelta, string.Format("Precision: Acos({0}): expected {1} but got {2}", xf, expected, actual));
}
for (int i = 0; i < m_testCases.Length; ++i)
{
var b = Fix64.FromRaw(m_testCases[i]);
if (b < -Fix64.One || b > Fix64.One)
{
Assert.Throws <ArgumentOutOfRangeException>(() => MathFix.Acos(b));
}
else
{
var expected = (decimal)Math.Acos((double)b);
var actual = (decimal)MathFix.Acos(b);
var delta = Math.Abs(expected - actual);
deltas.Add(delta);
Assert.True(delta <= maxDelta, string.Format("Acos({0}) = expected {1} but got {2}", b, expected, actual));
}
}
Console.WriteLine("Max error: {0} ({1} times precision)", deltas.Max(), deltas.Max() / Fix64.Precision);
Console.WriteLine("Average precision: {0} ({1} times precision)", deltas.Average(), deltas.Average() / Fix64.Precision);
}
public void Ln()
{
double maxDelta = 0.00000001;
for (int j = 0; j < m_testCases.Length; ++j)
{
var b = Fix64.FromRaw(m_testCases[j]);
if (b <= Fix64.Zero)
{
Assert.Throws <ArgumentOutOfRangeException>(() => MathFix.Log(b));
}
else
{
var expected = Math.Log((double)b);
var actual = (double)MathFix.Log(b);
var delta = Math.Abs(expected - actual);
Assert.True(delta <= maxDelta, string.Format("Ln({0}) = expected {1} but got {2}", b, expected, actual));
}
}
}
public void MultiplicationTestCases()
{
var sw = new Stopwatch();
int failures = 0;
for (int i = 0; i < m_testCases.Length; ++i)
{
for (int j = 0; j < m_testCases.Length; ++j)
{
var x = Fix64.FromRaw(m_testCases[i]);
var y = Fix64.FromRaw(m_testCases[j]);
var xM = (decimal)x;
var yM = (decimal)y;
var expected = xM * yM;
expected =
expected > (decimal)Fix64.MaxValue
? (decimal)Fix64.MaxValue
: expected < (decimal)Fix64.MinValue
? (decimal)Fix64.MinValue
: expected;
sw.Start();
var actual = x * y;
sw.Stop();
var actualM = (decimal)actual;
var maxDelta = (decimal)Fix64.FromRaw(1);
if (Math.Abs(actualM - expected) > maxDelta)
{
Console.WriteLine("Failed for FromRaw({0}) * FromRaw({1}): expected {2} but got {3}",
m_testCases[i],
m_testCases[j],
(Fix64)expected,
actualM);
++failures;
}
}
}
Console.WriteLine("{0} total, {1} per multiplication", sw.ElapsedMilliseconds, (double)sw.Elapsed.Milliseconds / (m_testCases.Length * m_testCases.Length));
Assert.True(failures < 1);
}