added sanity checks

1-tests/Just.PreciseMath.Tests/SanityChecks/DoubleDoubleAdditionChecks.cs

@@ -0,0 +1,27 @@
+namespace Just.PreciseMath.Tests.SanityChecks;
+
+public class DoubleDoubleAdditionChecks
+{
+    public static IEnumerable<TheoryDataRow<DoubleDouble, DoubleDouble, DoubleDouble>> ReferenceCases =>
+    [
+        (new DoubleDouble(1.0), new DoubleDouble(1.0), new DoubleDouble(2.0)),
+        (new DoubleDouble(1.0), new DoubleDouble(2.0), new DoubleDouble(3.0)),
+        (new DoubleDouble(1.25), new DoubleDouble(2.5), new DoubleDouble(3.75)),
+        (new DoubleDouble(65535.0), new DoubleDouble(1.0), new DoubleDouble(65536.0)),
+        (DoubleDouble.Parse("812563124576179134546", System.Globalization.CultureInfo.InvariantCulture), DoubleDouble.Parse("-812563124576179134504", System.Globalization.CultureInfo.InvariantCulture), new DoubleDouble(42.0)),
+        (DoubleDouble.Parse("812563124576179134546", System.Globalization.CultureInfo.InvariantCulture), new DoubleDouble(127.0), DoubleDouble.Parse("812563124576179134673", System.Globalization.CultureInfo.InvariantCulture)),
+        (DoubleDouble.Parse("812563124576179134546", System.Globalization.CultureInfo.InvariantCulture), new DoubleDouble(27.0), DoubleDouble.Parse("812563124576179134573", System.Globalization.CultureInfo.InvariantCulture)),
+        (DoubleDouble.Parse("812563124576179134546", System.Globalization.CultureInfo.InvariantCulture), new DoubleDouble(2.70), DoubleDouble.Parse("812563124576179134548.7", System.Globalization.CultureInfo.InvariantCulture)),
+    ];
+
+    [Theory]
+    [MemberData(nameof(ReferenceCases))]
+    public void AdditionShouldProduceExpectedResults(DoubleDouble left, DoubleDouble right, DoubleDouble expected)
+    {
+        DoubleDouble result = left + right;
+
+        result.High.ShouldBe(expected.High);
+        result.Low.ShouldBe(expected.Low);
+        result.ShouldBe(expected);
+    }
+}

1-tests/Just.PreciseMath.Tests/SanityChecks/DoubleDoubleArithmeticEqualityChecks.cs

@@ -0,0 +1,108 @@
+namespace Just.PreciseMath.Tests.SanityChecks;
+
+public class DoubleDoubleArithmeticEqualityChecks
+{
+    public static IEnumerable<TheoryDataRow<double>> ReferenceCases => [1.0, 2.0, 3.0, 100.0, 0.1, 0.5, 0.333333333333333333, -1.0, 1553.0, 1.0e+10];
+
+    [Theory]
+    [MemberData(nameof(ReferenceCases))]
+    public void AdditionShouldProduceIdenticalResults(double reference)
+    {
+        DoubleDouble testValue = DoubleDouble.E; // any value with full precision range used
+
+        DoubleDouble ddxdd_Result = testValue + (new DoubleDouble(reference));
+        DoubleDouble ddxd_Result = testValue + reference;
+        DoubleDouble dxdd_Result = reference + testValue;
+
+        ddxdd_Result.High.ShouldBe(ddxd_Result.High);
+        ddxdd_Result.Low.ShouldBe(ddxd_Result.Low);
+        ddxdd_Result.ShouldBe(ddxd_Result);
+
+        ddxdd_Result.High.ShouldBe(dxdd_Result.High);
+        ddxdd_Result.Low.ShouldBe(dxdd_Result.Low);
+        ddxdd_Result.ShouldBe(dxdd_Result);
+
+        ddxd_Result.High.ShouldBe(dxdd_Result.High);
+        ddxd_Result.Low.ShouldBe(dxdd_Result.Low);
+        ddxd_Result.ShouldBe(dxdd_Result);
+    }
+
+    [Theory]
+    [MemberData(nameof(ReferenceCases))]
+    public void SubtractionFromShouldProduceIdenticalResults(double reference)
+    {
+        DoubleDouble testValue = DoubleDouble.E; // any value with full precision range used
+
+        DoubleDouble ddxdd_Result = testValue - (new DoubleDouble(reference));
+        DoubleDouble ddxd_Result = testValue - reference;
+
+        ddxdd_Result.High.ShouldBe(ddxd_Result.High);
+        ddxdd_Result.Low.ShouldBe(ddxd_Result.Low);
+        ddxdd_Result.ShouldBe(ddxd_Result);
+    }
+
+    [Theory]
+    [MemberData(nameof(ReferenceCases))]
+    public void SubtractionShouldProduceIdenticalResults(double reference)
+    {
+        DoubleDouble testValue = DoubleDouble.E; // any value with full precision range used
+
+        DoubleDouble ddxdd_Result = (new DoubleDouble(reference)) - testValue;
+        DoubleDouble dxdd_Result = reference - testValue;
+
+        ddxdd_Result.High.ShouldBe(dxdd_Result.High);
+        ddxdd_Result.Low.ShouldBe(dxdd_Result.Low);
+        ddxdd_Result.ShouldBe(dxdd_Result);
+    }
+
+    [Theory]
+    [MemberData(nameof(ReferenceCases))]
+    public void MultiplicationShouldProduceIdenticalResults(double reference)
+    {
+        DoubleDouble testValue = DoubleDouble.E; // any value with full precision range used
+
+        DoubleDouble ddxdd_Result = testValue * (new DoubleDouble(reference));
+        DoubleDouble ddxd_Result = testValue * reference;
+        DoubleDouble dxdd_Result = reference * testValue;
+
+        ddxdd_Result.High.ShouldBe(ddxd_Result.High);
+        ddxdd_Result.Low.ShouldBe(ddxd_Result.Low);
+        ddxdd_Result.ShouldBe(ddxd_Result);
+
+        ddxdd_Result.High.ShouldBe(dxdd_Result.High);
+        ddxdd_Result.Low.ShouldBe(dxdd_Result.Low);
+        ddxdd_Result.ShouldBe(dxdd_Result);
+
+        ddxd_Result.High.ShouldBe(dxdd_Result.High);
+        ddxd_Result.Low.ShouldBe(dxdd_Result.Low);
+        ddxd_Result.ShouldBe(dxdd_Result);
+    }
+
+    [Theory]
+    [MemberData(nameof(ReferenceCases))]
+    public void DivisionShouldProduceIdenticalResults(double reference)
+    {
+        DoubleDouble testValue = DoubleDouble.E; // any value with full precision range used
+
+        DoubleDouble ddxdd_Result = testValue / (new DoubleDouble(reference));
+        DoubleDouble ddxd_Result = testValue / reference;
+
+        ddxdd_Result.High.ShouldBe(ddxd_Result.High);
+        ddxdd_Result.Low.ShouldBe(ddxd_Result.Low);
+        ddxdd_Result.ShouldBe(ddxd_Result);
+    }
+
+    [Theory]
+    [MemberData(nameof(ReferenceCases))]
+    public void DivisionByShouldProduceIdenticalResults(double reference)
+    {
+        DoubleDouble testValue = DoubleDouble.E; // any value with full precision range used
+
+        DoubleDouble ddxdd_Result = (new DoubleDouble(reference)) / testValue;
+        DoubleDouble dxdd_Result = reference / testValue;
+
+        ddxdd_Result.High.ShouldBe(dxdd_Result.High);
+        ddxdd_Result.Low.ShouldBe(dxdd_Result.Low);
+        ddxdd_Result.ShouldBe(dxdd_Result);
+    }
+}

1-tests/Just.PreciseMath.Tests/SanityChecks/DoubleDoubleDivisionChecks.cs

@@ -0,0 +1,29 @@
+namespace Just.PreciseMath.Tests.SanityChecks;
+
+public class DoubleDoubleDivisionChecks
+{
+    public static IEnumerable<TheoryDataRow<DoubleDouble, DoubleDouble, DoubleDouble>> ReferenceCases =>
+    [
+        (new DoubleDouble(6.0), new DoubleDouble(2.0), new DoubleDouble(3.0)),
+        (new DoubleDouble(6.0), new DoubleDouble(3.0), new DoubleDouble(2.0)),
+        (new DoubleDouble(5.0), new DoubleDouble(2.0), new DoubleDouble(2.5)),
+        (new DoubleDouble(1.0), new DoubleDouble(4.0), new DoubleDouble(0.25)),
+        (new DoubleDouble(3.75), new DoubleDouble(1.25), new DoubleDouble(3.0)),
+        (new DoubleDouble(65536.0), new DoubleDouble(1024.0), new DoubleDouble(64.0)),
+        (DoubleDouble.Parse("812563124576179134546", System.Globalization.CultureInfo.InvariantCulture), new DoubleDouble(2.0), DoubleDouble.Parse("406281562288089567273", System.Globalization.CultureInfo.InvariantCulture)),
+        (DoubleDouble.Parse("812563124576179134546", System.Globalization.CultureInfo.InvariantCulture), new DoubleDouble(4.0), DoubleDouble.Parse("203140781144044783636.5", System.Globalization.CultureInfo.InvariantCulture)),
+        (DoubleDouble.Parse("812563124576179134546", System.Globalization.CultureInfo.InvariantCulture), new DoubleDouble(8.0), DoubleDouble.Parse("101570390572022391818.25", System.Globalization.CultureInfo.InvariantCulture)),
+        (DoubleDouble.Parse("812563124576179134546", System.Globalization.CultureInfo.InvariantCulture), DoubleDouble.Parse("812563124576179134546", System.Globalization.CultureInfo.InvariantCulture), new DoubleDouble(1.0)),
+    ];
+
+    [Theory]
+    [MemberData(nameof(ReferenceCases))]
+    public void DivisionShouldProduceExpectedResults(DoubleDouble left, DoubleDouble right, DoubleDouble expected)
+    {
+        DoubleDouble result = left / right;
+
+        result.High.ShouldBe(expected.High);
+        result.Low.ShouldBe(expected.Low);
+        result.ShouldBe(expected);
+    }
+}

1-tests/Just.PreciseMath.Tests/SanityChecks/DoubleDoubleMultiplicationChecks.cs

@@ -0,0 +1,29 @@
+namespace Just.PreciseMath.Tests.SanityChecks;
+
+public class DoubleDoubleMultiplicationChecks
+{
+    public static IEnumerable<TheoryDataRow<DoubleDouble, DoubleDouble, DoubleDouble>> ReferenceCases =>
+    [
+        (new DoubleDouble(1.0), new DoubleDouble(1.0), new DoubleDouble(1.0)),
+        (new DoubleDouble(2.0), new DoubleDouble(3.0), new DoubleDouble(6.0)),
+        (new DoubleDouble(1.25), new DoubleDouble(2.5), new DoubleDouble(3.125)),
+        (new DoubleDouble(-1.25), new DoubleDouble(2.5), new DoubleDouble(-3.125)),
+        (new DoubleDouble(65535.0), new DoubleDouble(65536.0), new DoubleDouble(4294901760.0)),
+        (new DoubleDouble(65536.0), new DoubleDouble(65536.0), new DoubleDouble(4294967296.0)),
+        (DoubleDouble.Parse("812563124576179134546", System.Globalization.CultureInfo.InvariantCulture), new DoubleDouble(2.0), DoubleDouble.Parse("1625126249152358269092", System.Globalization.CultureInfo.InvariantCulture)),
+        (DoubleDouble.Parse("812563124576179134546", System.Globalization.CultureInfo.InvariantCulture), new DoubleDouble(0.5), DoubleDouble.Parse("406281562288089567273", System.Globalization.CultureInfo.InvariantCulture)),
+        (DoubleDouble.Parse("812563124576179134546", System.Globalization.CultureInfo.InvariantCulture), new DoubleDouble(27.0), DoubleDouble.Parse("21939204363556836632742", System.Globalization.CultureInfo.InvariantCulture)),
+        (DoubleDouble.Parse("812563124576179134546", System.Globalization.CultureInfo.InvariantCulture), new DoubleDouble(127.0), DoubleDouble.Parse("103195516821174750087342", System.Globalization.CultureInfo.InvariantCulture)),
+    ];
+
+    [Theory]
+    [MemberData(nameof(ReferenceCases))]
+    public void MultiplicationShouldProduceExpectedResults(DoubleDouble left, DoubleDouble right, DoubleDouble expected)
+    {
+        DoubleDouble result = left * right;
+
+        result.High.ShouldBe(expected.High);
+        result.Low.ShouldBe(expected.Low);
+        result.ShouldBe(expected);
+    }
+}

1-tests/Just.PreciseMath.Tests/SanityChecks/DoubleDoubleSubtractionChecks.cs

@@ -0,0 +1,30 @@
+namespace Just.PreciseMath.Tests.SanityChecks;
+
+public class DoubleDoubleSubtractionChecks
+{
+    public static IEnumerable<TheoryDataRow<DoubleDouble, DoubleDouble, DoubleDouble>> ReferenceCases =>
+    [
+        (new DoubleDouble(2.0), new DoubleDouble(1.0), new DoubleDouble(1.0)),
+        (new DoubleDouble(1.0), new DoubleDouble(2.0), new DoubleDouble(-1.0)),
+        (new DoubleDouble(3.75), new DoubleDouble(2.5), new DoubleDouble(1.25)),
+        (new DoubleDouble(2.5), new DoubleDouble(3.75), new DoubleDouble(-1.25)),
+        (new DoubleDouble(65536.0), new DoubleDouble(1.0), new DoubleDouble(65535.0)),
+        (new DoubleDouble(65536.0), new DoubleDouble(65535.0), new DoubleDouble(1.0)),
+        (DoubleDouble.Parse("812563124576179134673", System.Globalization.CultureInfo.InvariantCulture), new DoubleDouble(127.0), DoubleDouble.Parse("812563124576179134546", System.Globalization.CultureInfo.InvariantCulture)),
+        (DoubleDouble.Parse("812563124576179134546", System.Globalization.CultureInfo.InvariantCulture), new DoubleDouble(127.0), DoubleDouble.Parse("812563124576179134419", System.Globalization.CultureInfo.InvariantCulture)),
+        (DoubleDouble.Parse("812563124576179134546", System.Globalization.CultureInfo.InvariantCulture), DoubleDouble.Parse("812563124576179134504", System.Globalization.CultureInfo.InvariantCulture), new DoubleDouble(42.0)),
+        (DoubleDouble.Parse("812563124576179134546", System.Globalization.CultureInfo.InvariantCulture), new DoubleDouble(0.5), DoubleDouble.Parse("812563124576179134545.5", System.Globalization.CultureInfo.InvariantCulture)),
+        (DoubleDouble.Parse("812563124576179134546", System.Globalization.CultureInfo.InvariantCulture), DoubleDouble.Parse("812563124576179134546", System.Globalization.CultureInfo.InvariantCulture), new DoubleDouble(0.0)),
+    ];
+
+    [Theory]
+    [MemberData(nameof(ReferenceCases))]
+    public void SubtractionShouldProduceExpectedResults(DoubleDouble left, DoubleDouble right, DoubleDouble expected)
+    {
+        DoubleDouble result = left - right;
+
+        result.High.ShouldBe(expected.High);
+        result.Low.ShouldBe(expected.Low);
+        result.ShouldBe(expected);
+    }
+}