public void DoubleDoubleErrorFunctionAgreement()
{
foreach (DoubleDouble x in GetRandomPositiveDoubleDoubles(1.0E-2, 1.0E2, 8))
{
DoubleDouble xErf = AdvancedDoubleDoubleMath.Erf(x);
double xErfAsDouble = (double)xErf;
double xAsDouble = (double)x;
double xAsDoubleErf = AdvancedMath.Erf(xAsDouble);
Assert.IsTrue(TestUtilities.IsNearlyEqual(xErfAsDouble, xAsDoubleErf));
DoubleDouble xErfc = AdvancedDoubleDoubleMath.Erfc(x);
Assert.IsTrue(IsNearlyEqual(xErf + xErfc, DoubleDouble.One));
}
}
public void DoubleDoubleComparison()
{
DoubleDouble x = DoubleDouble.E;
DoubleDouble y = DoubleDouble.Pi;
Assert.IsTrue(x <= DoubleDouble.E);
Assert.IsTrue(x >= DoubleDouble.E);
Assert.IsFalse(x < DoubleDouble.E);
Assert.IsFalse(x > DoubleDouble.E);
Assert.IsTrue(x.CompareTo(x) == 0);
Assert.IsTrue(x < y);
Assert.IsTrue(x <= y);
Assert.IsFalse(x > y);
Assert.IsFalse(x >= y);
Assert.IsTrue(x.CompareTo(y) == -1);
}
IEnumerable <DoubleDouble> GetRandomPositiveDoubleDoubles(double minimum, double maximum, int n, Random rng = null)
{
if (rng == null)
{
rng = new Random(1);
}
double logMinimum = Math.Log(minimum);
double logMaximum = Math.Log(maximum);
for (int i = 0; i < n; i++)
{
DoubleDouble x = DoubleDouble.GetRandomValue(rng);
DoubleDouble logValue = logMinimum * (1.0 - x) + logMaximum * x;
DoubleDouble value = DoubleDouble.Exp(logValue);
yield return(value);
}
}
public static IEnumerable <DoubleDouble> GetRandomDoubleDoubles(double minimum, double maximum, int n, bool negative = false, Random rng = null)
{
if (rng == null)
{
rng = new Random(1);
}
double logMinimum = Math.Log(minimum);
double logMaximum = Math.Log(maximum);
for (int i = 0; i < n; i++)
{
DoubleDouble x = DoubleDouble.GetRandomValue(rng);
DoubleDouble logValue = logMinimum * (1.0 - x) + logMaximum * x;
DoubleDouble value = DoubleDouble.Exp(logValue);
if (negative && rng.NextDouble() < 0.5)
{
value = -value;
}
yield return(value);
}
}
public void DoubleDoubleTrigSpecialCases()
{
Assert.IsTrue(DoubleDouble.Sin(0.0) == DoubleDouble.Zero);
Assert.IsTrue(DoubleDouble.Cos(0.0) == DoubleDouble.One);
Assert.IsTrue(DoubleDoubleTest.IsNearlyEqual(DoubleDouble.Sin(DoubleDouble.Pi / 6), DoubleDouble.One / 2));
Assert.IsTrue(DoubleDoubleTest.IsNearlyEqual(DoubleDouble.Cos(DoubleDouble.Pi / 6), DoubleDouble.Sqrt(3) / 2));
Assert.IsTrue(DoubleDoubleTest.IsNearlyEqual(DoubleDouble.Cos(DoubleDouble.Pi / 5), (1 + DoubleDouble.Sqrt(5)) / 4));
Assert.IsTrue(DoubleDoubleTest.IsNearlyEqual(DoubleDouble.Sin(DoubleDouble.Pi / 4), DoubleDouble.One / DoubleDouble.Sqrt(2)));
Assert.IsTrue(DoubleDoubleTest.IsNearlyEqual(DoubleDouble.Cos(DoubleDouble.Pi / 4), DoubleDouble.One / DoubleDouble.Sqrt(2)));
Assert.IsTrue(DoubleDoubleTest.IsNearlyEqual(DoubleDouble.Cos(DoubleDouble.Pi / 3), DoubleDouble.One / 2));
Assert.IsTrue(DoubleDoubleTest.IsNearlyEqual(DoubleDouble.Sin(DoubleDouble.Pi / 3), DoubleDouble.Sqrt(3) / 2));
Assert.IsTrue(DoubleDoubleTest.IsNearlyEqual(DoubleDouble.Sin(DoubleDouble.Pi / 2), DoubleDouble.One));
Assert.IsTrue(DoubleDoubleTest.IsNearlyEqual(DoubleDouble.Cos(DoubleDouble.Pi), -DoubleDouble.One));
// Not testing zeros because of need to distingish very small values
}
public void AccuracyTest()
{
SummaryStatistics s1 = new SummaryStatistics();
SummaryStatistics s2 = new SummaryStatistics();
foreach (double omx in TestUtilities.GenerateRealValues(1.0E-24, 1.0, 1000000))
{
double x = 1.0 - omx;
double f1 = Math.Sqrt((1.0 - x) * (1.0 + x));
double f2 = Math.Sqrt(1.0 - x * x);
DoubleDouble xe = (DoubleDouble)x;
DoubleDouble fc = DoubleDouble.Sqrt(DoubleDouble.One - xe * xe);
double e1 = Math.Abs((double)(f1 - fc));
double e2 = Math.Abs((double)(f2 - fc));
s1.Add(e1);
s2.Add(e2);
}
}
public void DoubleDoubleArithmeticAxioms()
{
Random rng = new Random(2);
foreach (DoubleDouble a in GetRandomDoubleDoubles(1.0E-4, 1.0E4, 8, true, rng))
{
Assert.IsTrue(a + DoubleDouble.Zero == a);
Assert.IsTrue(DoubleDouble.Zero + a == a);
Assert.IsTrue(a * DoubleDouble.One == a);
Assert.IsTrue(DoubleDouble.One * a == a);
DoubleDouble ma = -a;
Assert.IsTrue(DoubleDouble.Zero - a == ma);
Assert.IsTrue(-DoubleDouble.One * a == ma);
Assert.IsTrue(a + ma == DoubleDouble.Zero);
Assert.IsTrue(ma + a == DoubleDouble.Zero);
Assert.IsTrue(a + a == 2.0 * a);
foreach (DoubleDouble b in GetRandomDoubleDoubles(1.0E-4, 1.0E4, 4, true, rng))
{
Assert.IsTrue(a + b == b + a);
Assert.IsTrue(a * b == b * a);
Assert.IsTrue(a - b == -(b - a));
DoubleDouble a_over_b = a / b;
DoubleDouble b_over_a = b / a;
Assert.IsTrue(IsNearlyEqual(a_over_b * b, a));
Assert.IsTrue(IsNearlyEqual(b_over_a * a, b));
Assert.IsTrue(IsNearlyEqual(DoubleDouble.One / a_over_b, b_over_a));
}
}
}
public void DoubleDoubleInfinity()
{
// Addition
Assert.IsTrue(DoubleDouble.PositiveInfinity + DoubleDouble.One == DoubleDouble.PositiveInfinity);
Assert.IsTrue(DoubleDouble.One + DoubleDouble.NegativeInfinity == DoubleDouble.NegativeInfinity);
Assert.IsTrue(DoubleDouble.IsNaN(DoubleDouble.NegativeInfinity + DoubleDouble.PositiveInfinity));
// Subtraction
Assert.IsTrue(DoubleDouble.One - DoubleDouble.PositiveInfinity == DoubleDouble.NegativeInfinity);
Assert.IsTrue(DoubleDouble.IsNaN(DoubleDouble.PositiveInfinity - DoubleDouble.PositiveInfinity));
// Multiplication
Assert.IsTrue(DoubleDouble.One * DoubleDouble.PositiveInfinity == DoubleDouble.PositiveInfinity);
Assert.IsTrue(DoubleDouble.One * DoubleDouble.NegativeInfinity == DoubleDouble.NegativeInfinity);
Assert.IsTrue(DoubleDouble.IsNaN(DoubleDouble.Zero * DoubleDouble.PositiveInfinity));
// Division
Assert.IsTrue(DoubleDouble.One / DoubleDouble.Zero == DoubleDouble.PositiveInfinity);
Assert.IsTrue((-DoubleDouble.One) / DoubleDouble.Zero == DoubleDouble.NegativeInfinity);
Assert.IsTrue(DoubleDouble.One / DoubleDouble.PositiveInfinity == DoubleDouble.Zero);
Assert.IsTrue(DoubleDouble.One / DoubleDouble.NegativeInfinity == DoubleDouble.Zero);
Assert.IsTrue(DoubleDouble.IsNaN(DoubleDouble.Zero / DoubleDouble.Zero));
Assert.IsTrue(DoubleDouble.IsNaN(DoubleDouble.PositiveInfinity / DoubleDouble.PositiveInfinity));
}
public void DoubleDoubleSqrtSpecialValues()
{
Assert.IsTrue(DoubleDouble.Sqrt(DoubleDouble.Zero) == DoubleDouble.Zero);
Assert.IsTrue(DoubleDouble.Sqrt(DoubleDouble.One) == DoubleDouble.One);
}
public void DoubleDoubleParseSpecialCases()
{
Assert.IsTrue(DoubleDouble.Parse("0.0") == DoubleDouble.Zero);
Assert.IsTrue(DoubleDouble.Parse("1.0") == DoubleDouble.One);
Assert.IsTrue(DoubleDouble.Parse("-1.0") == -DoubleDouble.One);
}
