101 lines
4.4 KiB
C#
101 lines
4.4 KiB
C#
using Shouldly;
|
|
using Xunit;
|
|
|
|
namespace Just.PreciseMath.Tests;
|
|
|
|
public class DoubleDoubleRepresentationTests
|
|
{
|
|
[Fact]
|
|
public void ArbitraryComponentsUseThePublicFactoryNotAPublicPairConstructor()
|
|
{
|
|
typeof(DoubleDouble).GetConstructor([typeof(double), typeof(double)]).ShouldBeNull();
|
|
DoubleDouble value = DoubleDouble.FromComponents(1.0, 1.0);
|
|
value.High.ShouldBe(2.0);
|
|
value.Low.ShouldBe(0.0);
|
|
}
|
|
|
|
[Fact]
|
|
public void TrustedConstructorPreservesAlreadyNormalizedComponents()
|
|
{
|
|
DoubleDouble value = new(1.0, Math.ScaleB(1.0, -54));
|
|
value.High.ShouldBe(1.0);
|
|
value.Low.ShouldBe(Math.ScaleB(1.0, -54));
|
|
DoubleDouble negativeZero = new(-0.0, 0.0);
|
|
BitConverter.DoubleToInt64Bits(negativeZero.High).ShouldBe(long.MinValue);
|
|
BitConverter.DoubleToInt64Bits(negativeZero.Low).ShouldBe(0L);
|
|
}
|
|
|
|
[Fact]
|
|
public void NegationPreservesNormalizationAndCanonicalComponents()
|
|
{
|
|
DoubleDouble[] values = [DoubleDouble.NaN, new(double.PositiveInfinity), new(double.NegativeInfinity),
|
|
new(0.0), new(-0.0), new(double.Epsilon), new(-double.Epsilon),
|
|
DoubleDouble.FromComponents(1.0, Math.ScaleB(1.0, -54))];
|
|
foreach (DoubleDouble value in values)
|
|
{
|
|
DoubleDouble negated = -value;
|
|
double expectedHigh = DoubleDouble.IsNaN(value) ? double.NaN : -value.High;
|
|
double expectedLow = value.Low == 0.0 ? 0.0 : -value.Low;
|
|
BitConverter.DoubleToInt64Bits(negated.High).ShouldBe(BitConverter.DoubleToInt64Bits(expectedHigh));
|
|
BitConverter.DoubleToInt64Bits(negated.Low).ShouldBe(BitConverter.DoubleToInt64Bits(expectedLow));
|
|
(-negated).Equals(value).ShouldBeTrue();
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void FactoryCanonicalizesNaNPayloadsAndZeroResidualSigns()
|
|
{
|
|
double nan = BitConverter.Int64BitsToDouble(0x7ff8000000000001L);
|
|
foreach (DoubleDouble value in new[] { new DoubleDouble(nan), DoubleDouble.FromComponents(nan, 0.0),
|
|
DoubleDouble.FromComponents(1.0, nan), DoubleDouble.FromComponents(double.PositiveInfinity, double.NegativeInfinity) })
|
|
{
|
|
BitConverter.DoubleToInt64Bits(value.High).ShouldBe(BitConverter.DoubleToInt64Bits(double.NaN));
|
|
BitConverter.DoubleToInt64Bits(value.Low).ShouldBe(0L);
|
|
}
|
|
DoubleDouble negativeZero = DoubleDouble.FromComponents(-0.0, -0.0);
|
|
BitConverter.DoubleToInt64Bits(negativeZero.High).ShouldBe(long.MinValue);
|
|
BitConverter.DoubleToInt64Bits(negativeZero.Low).ShouldBe(0L);
|
|
DoubleDouble cancelled = DoubleDouble.FromComponents(1.0, -1.0);
|
|
BitConverter.DoubleToInt64Bits(cancelled.High).ShouldBe(0L);
|
|
BitConverter.DoubleToInt64Bits(cancelled.Low).ShouldBe(0L);
|
|
}
|
|
|
|
[Theory]
|
|
[InlineData(0.0, 1.0, 1.0, 0.0)]
|
|
[InlineData(1.0, 1.0, 2.0, 0.0)]
|
|
[InlineData(1.0, -1.0, 0.0, 0.0)]
|
|
[InlineData(1e300, -1e300, 0.0, 0.0)]
|
|
[InlineData(double.Epsilon, double.Epsilon, 2 * double.Epsilon, 0.0)]
|
|
[InlineData(double.MaxValue, double.MaxValue, double.PositiveInfinity, 0.0)]
|
|
[InlineData(1.0, double.PositiveInfinity, double.PositiveInfinity, 0.0)]
|
|
[InlineData(double.NegativeInfinity, 1.0, double.NegativeInfinity, 0.0)]
|
|
public void FactoryNormalizesComponents(double high, double low, double expectedHigh, double expectedLow)
|
|
{
|
|
DoubleDouble value = DoubleDouble.FromComponents(high, low);
|
|
value.High.ShouldBe(expectedHigh);
|
|
value.Low.ShouldBe(expectedLow);
|
|
}
|
|
|
|
[Fact]
|
|
public void NaNHasCanonicalComponentsAndCollectionEquality()
|
|
{
|
|
DoubleDouble value = DoubleDouble.FromComponents(double.PositiveInfinity, double.NegativeInfinity);
|
|
double.IsNaN(value.High).ShouldBeTrue();
|
|
value.Low.ShouldBe(0.0);
|
|
value.Equals(DoubleDouble.NaN).ShouldBeTrue();
|
|
value.GetHashCode().ShouldBe(DoubleDouble.NaN.GetHashCode());
|
|
new HashSet<DoubleDouble> { value }.Contains(DoubleDouble.NaN).ShouldBeTrue();
|
|
(value == DoubleDouble.NaN).ShouldBeFalse();
|
|
(value != DoubleDouble.NaN).ShouldBeTrue();
|
|
}
|
|
|
|
[Fact]
|
|
public void ZeroSignsArePreservedButEqual()
|
|
{
|
|
DoubleDouble negative = new(-0.0);
|
|
BitConverter.DoubleToInt64Bits(negative.High).ShouldBe(long.MinValue);
|
|
negative.Equals(DoubleDouble.Zero).ShouldBeTrue();
|
|
negative.GetHashCode().ShouldBe(DoubleDouble.Zero.GetHashCode());
|
|
}
|
|
}
|