255 lines
11 KiB
C#
255 lines
11 KiB
C#
namespace Just.PreciseMath.Tests;
|
|
|
|
public class DoubleDoubleTests
|
|
{
|
|
[Fact]
|
|
public void EpsilonIsTheMinimumPositiveBinary64Subnormal()
|
|
{
|
|
// Each finite component is an integer multiple of 2^-1074, so their
|
|
// exact sum cannot have a smaller positive quantum. This is not a
|
|
// relative-error tolerance or a fixed significand spacing near one.
|
|
DoubleDouble value = DoubleDouble.Epsilon;
|
|
BitConverter.DoubleToInt64Bits(value.High).ShouldBe(1L);
|
|
BitConverter.DoubleToInt64Bits(value.Low).ShouldBe(0L);
|
|
DoubleDouble.IsCanonical(value).ShouldBeTrue();
|
|
DoubleDouble.IsFinite(value).ShouldBeTrue();
|
|
DoubleDouble.IsSubnormal(value).ShouldBeTrue();
|
|
DoubleDouble.IsNormal(value).ShouldBeFalse();
|
|
DoubleDouble.IsPositive(value).ShouldBeTrue();
|
|
(value > DoubleDouble.Zero).ShouldBeTrue();
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("NegativeZero", -0.0)]
|
|
[InlineData("PositiveInfinity", double.PositiveInfinity)]
|
|
[InlineData("NegativeInfinity", double.NegativeInfinity)]
|
|
[InlineData("NaN", double.NaN)]
|
|
public void SpecialConstantsHaveCanonicalComponentBits(string name, double expectedHigh)
|
|
{
|
|
DoubleDouble value = name switch
|
|
{
|
|
"NegativeZero" => DoubleDouble.NegativeZero,
|
|
"PositiveInfinity" => DoubleDouble.PositiveInfinity,
|
|
"NegativeInfinity" => DoubleDouble.NegativeInfinity,
|
|
"NaN" => DoubleDouble.NaN,
|
|
_ => throw new ArgumentOutOfRangeException(nameof(name)),
|
|
};
|
|
BitConverter.DoubleToInt64Bits(value.High).ShouldBe(BitConverter.DoubleToInt64Bits(expectedHigh));
|
|
BitConverter.DoubleToInt64Bits(value.Low).ShouldBe(0L);
|
|
DoubleDouble.IsCanonical(value).ShouldBeTrue();
|
|
DoubleDouble.IsNaN(value).ShouldBe(double.IsNaN(expectedHigh));
|
|
DoubleDouble.IsFinite(value).ShouldBe(double.IsFinite(expectedHigh));
|
|
DoubleDouble.IsPositiveInfinity(value).ShouldBe(double.IsPositiveInfinity(expectedHigh));
|
|
DoubleDouble.IsNegativeInfinity(value).ShouldBe(double.IsNegativeInfinity(expectedHigh));
|
|
DoubleDouble.IsNegative(value).ShouldBe(double.IsNegative(expectedHigh));
|
|
DoubleDouble.IsZero(value).ShouldBe(expectedHigh == 0.0);
|
|
}
|
|
|
|
[Fact]
|
|
public void NegativeZeroConstantPreservesZeroEqualityAndHashing()
|
|
{
|
|
DoubleDouble value = DoubleDouble.NegativeZero;
|
|
(value == DoubleDouble.Zero).ShouldBeTrue();
|
|
value.Equals(DoubleDouble.Zero).ShouldBeTrue();
|
|
value.CompareTo(DoubleDouble.Zero).ShouldBe(0);
|
|
value.GetHashCode().ShouldBe(DoubleDouble.Zero.GetHashCode());
|
|
BitConverter.DoubleToInt64Bits((-value).High).ShouldBe(0L);
|
|
BitConverter.DoubleToInt64Bits((-value).Low).ShouldBe(0L);
|
|
BitConverter.DoubleToInt64Bits(DoubleDouble.Zero.High).ShouldBe(0L);
|
|
}
|
|
|
|
[Fact]
|
|
public void FloatingPointConstantsSupportGenericDispatch()
|
|
{
|
|
(DoubleDouble e, DoubleDouble pi, DoubleDouble tau) = GetFloatingPointConstants<DoubleDouble>();
|
|
e.ShouldBe(DoubleDouble.E);
|
|
pi.ShouldBe(DoubleDouble.Pi);
|
|
tau.ShouldBe(DoubleDouble.Tau);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData("Pi", 3.141592653589793, 1.2246467991473532e-16)]
|
|
[InlineData("E", 2.718281828459045, 1.4456468917292502e-16)]
|
|
[InlineData("Ln2", 0.6931471805599453, 2.3190468138462996e-17)]
|
|
[InlineData("Tau", 6.283185307179586, 2.4492935982947064e-16)]
|
|
[InlineData("PiOver2", 1.5707963267948966, 6.123233995736766e-17)]
|
|
[InlineData("PiOver3", 1.0471975511965979, -1.072081766451091e-16)]
|
|
[InlineData("PiOver4", 0.7853981633974483, 3.061616997868383e-17)]
|
|
[InlineData("PiOver6", 0.5235987755982989, -5.360408832255455e-17)]
|
|
[InlineData("InvPi", 0.3183098861837907, -1.9678676675182486e-17)]
|
|
[InlineData("InvTau", 0.15915494309189535, -9.839338337591243e-18)]
|
|
[InlineData("DegToRad", 0.017453292519943295, 2.9486522708701687e-19)]
|
|
[InlineData("RadToDeg", 57.29577951308232, -1.9878495670576283e-15)]
|
|
[InlineData("InvE", 0.36787944117144233, -1.2428753672788363e-17)]
|
|
[InlineData("Ln10", 2.302585092994046, -2.1707562233822494e-16)]
|
|
[InlineData("Log2E", 1.4426950408889634, 2.0355273740931033e-17)]
|
|
[InlineData("Log10E", 0.4342944819032518, 1.098319650216765e-17)]
|
|
[InlineData("Log2Of10", 3.321928094887362, 1.661617516973592e-16)]
|
|
[InlineData("Log10Of2", 0.3010299956639812, -2.8037281277851704e-18)]
|
|
[InlineData("Sqrt2", 1.4142135623730951, -9.667293313452913e-17)]
|
|
[InlineData("Sqrt3", 1.7320508075688772, 1.0035084221806903e-16)]
|
|
[InlineData("Sqrt5", 2.23606797749979, -1.0864230407365012e-16)]
|
|
[InlineData("InvSqrt2", 0.7071067811865476, -4.833646656726457e-17)]
|
|
[InlineData("InvSqrt3", 0.5773502691896257, 3.3450280739356345e-17)]
|
|
[InlineData("SqrtPi", 1.772453850905516, -7.666586499825799e-17)]
|
|
[InlineData("InvSqrtPi", 0.5641895835477563, 7.66772980658294e-18)]
|
|
[InlineData("TwoInvSqrtPi", 1.1283791670955126, 1.533545961316588e-17)]
|
|
[InlineData("SqrtTau", 2.5066282746310007, -1.8328579980459167e-16)]
|
|
[InlineData("InvSqrtTau", 0.3989422804014327, -2.49232720227773e-17)]
|
|
[InlineData("GoldenRatio", 1.618033988749895, -5.432115203682506e-17)]
|
|
public void ConstantsHaveNearestBinary64Residuals(string name, double high, double low)
|
|
{
|
|
// Each residual is round_binary64(constant - exact_binary64(high)).
|
|
// Reproduce with ReferenceData/generate_constants.py: Python Decimal at
|
|
// 160 and 240 digits, Machin's pi, exp/ln/sqrt and exact Fraction splitting.
|
|
// The generator records every formula and checks normalized components.
|
|
DoubleDouble value = name switch
|
|
{
|
|
"Pi" => DoubleDouble.Pi,
|
|
"E" => DoubleDouble.E,
|
|
"Ln2" => DoubleDouble.Ln2,
|
|
"Tau" => DoubleDouble.Tau,
|
|
"PiOver2" => DoubleDouble.PiOver2,
|
|
"PiOver3" => DoubleDouble.PiOver3,
|
|
"PiOver4" => DoubleDouble.PiOver4,
|
|
"PiOver6" => DoubleDouble.PiOver6,
|
|
"InvPi" => DoubleDouble.InvPi,
|
|
"InvTau" => DoubleDouble.InvTau,
|
|
"DegToRad" => DoubleDouble.DegToRad,
|
|
"RadToDeg" => DoubleDouble.RadToDeg,
|
|
"InvE" => DoubleDouble.InvE,
|
|
"Ln10" => DoubleDouble.Ln10,
|
|
"Log2E" => DoubleDouble.Log2E,
|
|
"Log10E" => DoubleDouble.Log10E,
|
|
"Log2Of10" => DoubleDouble.Log2Of10,
|
|
"Log10Of2" => DoubleDouble.Log10Of2,
|
|
"Sqrt2" => DoubleDouble.Sqrt2,
|
|
"Sqrt3" => DoubleDouble.Sqrt3,
|
|
"Sqrt5" => DoubleDouble.Sqrt5,
|
|
"InvSqrt2" => DoubleDouble.InvSqrt2,
|
|
"InvSqrt3" => DoubleDouble.InvSqrt3,
|
|
"SqrtPi" => DoubleDouble.SqrtPi,
|
|
"InvSqrtPi" => DoubleDouble.InvSqrtPi,
|
|
"TwoInvSqrtPi" => DoubleDouble.TwoInvSqrtPi,
|
|
"SqrtTau" => DoubleDouble.SqrtTau,
|
|
"InvSqrtTau" => DoubleDouble.InvSqrtTau,
|
|
"GoldenRatio" => DoubleDouble.GoldenRatio,
|
|
_ => throw new ArgumentOutOfRangeException(nameof(name)),
|
|
};
|
|
value.High.ShouldBe(high);
|
|
value.Low.ShouldBe(low);
|
|
BitConverter.DoubleToInt64Bits(value.High).ShouldBe(BitConverter.DoubleToInt64Bits(high));
|
|
BitConverter.DoubleToInt64Bits(value.Low).ShouldBe(BitConverter.DoubleToInt64Bits(low));
|
|
DoubleDouble.IsCanonical(value).ShouldBeTrue();
|
|
DoubleDouble.IsFinite(value).ShouldBeTrue();
|
|
value.Low.ShouldNotBe(0.0);
|
|
}
|
|
|
|
[Fact]
|
|
public void OneHasExpectedComponents()
|
|
{
|
|
DoubleDouble value = DoubleDouble.One;
|
|
|
|
value.High.ShouldBe(1.0);
|
|
value.Low.ShouldBe(0.0);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(1.0, 0.0)]
|
|
[InlineData(10.0, 0.0)]
|
|
[InlineData(100.0, 0.0)]
|
|
[InlineData(-1.0, 0.0)]
|
|
[InlineData(-10.0, 0.0)]
|
|
[InlineData(-100.0, 0.0)]
|
|
[InlineData(3.141592653589793, 1.2246467991473532e-16)]
|
|
[InlineData(2.718281828459045, 1.4456468917292502e-16)]
|
|
[InlineData(0.6931471805599453, 2.3190468138462996e-17)]
|
|
public void AdditiveIdentityAdd(double high, double low)
|
|
{
|
|
DoubleDouble value = new(high, low);
|
|
|
|
DoubleDouble result = value + DoubleDouble.AdditiveIdentity;
|
|
DoubleDouble resultInversedOrder = DoubleDouble.AdditiveIdentity + value;
|
|
|
|
result.High.ShouldBe(high);
|
|
result.Low.ShouldBe(low);
|
|
|
|
resultInversedOrder.High.ShouldBe(high);
|
|
resultInversedOrder.Low.ShouldBe(low);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(1.0, 0.0)]
|
|
[InlineData(10.0, 0.0)]
|
|
[InlineData(100.0, 0.0)]
|
|
[InlineData(-1.0, 0.0)]
|
|
[InlineData(-10.0, 0.0)]
|
|
[InlineData(-100.0, 0.0)]
|
|
[InlineData(3.141592653589793, 1.2246467991473532e-16)]
|
|
[InlineData(2.718281828459045, 1.4456468917292502e-16)]
|
|
[InlineData(0.6931471805599453, 2.3190468138462996e-17)]
|
|
public void AdditiveIdentitySubtract(double high, double low)
|
|
{
|
|
DoubleDouble value = new(high, low);
|
|
DoubleDouble negativeValue = -value;
|
|
|
|
DoubleDouble result = value - DoubleDouble.AdditiveIdentity;
|
|
DoubleDouble resultInversedOrder = DoubleDouble.AdditiveIdentity - value;
|
|
|
|
result.High.ShouldBe(high);
|
|
result.Low.ShouldBe(low);
|
|
|
|
resultInversedOrder.High.ShouldBe(negativeValue.High);
|
|
resultInversedOrder.Low.ShouldBe(negativeValue.Low);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(1.0, 0.0)]
|
|
[InlineData(10.0, 0.0)]
|
|
[InlineData(100.0, 0.0)]
|
|
[InlineData(-1.0, 0.0)]
|
|
[InlineData(-10.0, 0.0)]
|
|
[InlineData(-100.0, 0.0)]
|
|
[InlineData(3.141592653589793, 1.2246467991473532e-16)]
|
|
[InlineData(2.718281828459045, 1.4456468917292502e-16)]
|
|
[InlineData(0.6931471805599453, 2.3190468138462996e-17)]
|
|
public void MultiplicativeIdentityMultiply(double high, double low)
|
|
{
|
|
DoubleDouble value = new(high, low);
|
|
|
|
DoubleDouble result = value * DoubleDouble.MultiplicativeIdentity;
|
|
DoubleDouble resultInversedOrder = DoubleDouble.MultiplicativeIdentity * value;
|
|
|
|
result.High.ShouldBe(high);
|
|
result.Low.ShouldBe(low);
|
|
|
|
resultInversedOrder.High.ShouldBe(high);
|
|
resultInversedOrder.Low.ShouldBe(low);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(1.0, 0.0)]
|
|
[InlineData(10.0, 0.0)]
|
|
[InlineData(100.0, 0.0)]
|
|
[InlineData(-1.0, 0.0)]
|
|
[InlineData(-10.0, 0.0)]
|
|
[InlineData(-100.0, 0.0)]
|
|
[InlineData(3.141592653589793, 1.2246467991473532e-16)]
|
|
[InlineData(2.718281828459045, 1.4456468917292502e-16)]
|
|
[InlineData(0.6931471805599453, 2.3190468138462996e-17)]
|
|
public void MultiplicativeIdentityDivide(double high, double low)
|
|
{
|
|
DoubleDouble value = new(high, low);
|
|
|
|
DoubleDouble result = value / DoubleDouble.MultiplicativeIdentity;
|
|
|
|
result.High.ShouldBe(high);
|
|
result.Low.ShouldBe(low);
|
|
}
|
|
|
|
private static (T E, T Pi, T Tau) GetFloatingPointConstants<T>() where T : IFloatingPointConstants<T>
|
|
{
|
|
return (T.E, T.Pi, T.Tau);
|
|
}
|
|
}
|