public void Overlapping_AreNot_NonOverlapping() { var d1 = DoubleConverter.FromFloatingPointBinaryString("101"); var d2 = DoubleConverter.FromFloatingPointBinaryString("10"); Assert.IsFalse(ExpansionExtensions.AreNonOverlapping(d1, d2)); }
public void NonOverlapping_Are_NonOverlapping() { var d1 = DoubleConverter.FromFloatingPointBinaryString("1100"); var d2 = DoubleConverter.FromFloatingPointBinaryString("-10.1"); Assert.IsTrue(ExpansionExtensions.AreNonOverlapping(d1, d2)); }
public void StronglyNonOverlapping() { // Two examples that are strongly nonoverlapping (S.p12) var sn1 = new[] { DoubleConverter.FromFloatingPointBinaryString("11000"), DoubleConverter.FromFloatingPointBinaryString("11") }; var sn2 = new[] { DoubleConverter.FromFloatingPointBinaryString("10000"), DoubleConverter.FromFloatingPointBinaryString("1000"), DoubleConverter.FromFloatingPointBinaryString("10"), DoubleConverter.FromFloatingPointBinaryString("1") }; Assert.IsTrue(sn1.IsStronglyNonOverlapping()); Assert.IsTrue(sn2.IsStronglyNonOverlapping()); // Two examples that are _not_ strongly nonoverlapping (S.p12) var nsn1 = new[] { DoubleConverter.FromFloatingPointBinaryString("11100"), DoubleConverter.FromFloatingPointBinaryString("11") }; var nsn2 = new[] { DoubleConverter.FromFloatingPointBinaryString("100"), DoubleConverter.FromFloatingPointBinaryString("10"), DoubleConverter.FromFloatingPointBinaryString("1") }; Assert.IsFalse(nsn1.IsStronglyNonOverlapping()); Assert.IsFalse(nsn2.IsStronglyNonOverlapping()); }
public void BitWidth_Large() { double d = DoubleConverter.FromFloatingPointBinaryString("1010101" + '0'.Repeat(200)); int width = d.BitWidth(); Assert.AreEqual(7, width); }
public void ShowDoubleRoundingPriestExplicit() { double a = DoubleConverter.FromFloatingPointBinaryString("1" + '0'.Repeat(51) + "1"); // 100....00001 (53-bits wide) double b = DoubleConverter.FromFloatingPointBinaryString("0.0" + '1'.Repeat(53)); // 0.0111...111 (53 1's) double expected53 = a; double expected64 = a + 1.0; // The point is that this is different to expceted53. Debug.Print(DoubleConverter.ToFloatingPointBinaryString(a)); Debug.Print(DoubleConverter.ToFloatingPointBinaryString(b)); Debug.Print(DoubleConverter.ToFloatingPointBinaryString(expected53)); Debug.Print(DoubleConverter.ToFloatingPointBinaryString(expected64)); // Set Fpu to 53-bit precision (the default) FpuControl.SetState((uint)FpuControl.PrecisionControl.Double53Bits, FpuControl.Mask.PrecisionControl); double result53 = a + b; Debug.Print(DoubleConverter.ToFloatingPointBinaryString(result53)); Assert.AreEqual(expected53, result53); // Explicit rounding makes no difference here (since we're in Double53bits precision FPU mode) result53 = (double)(a + b); Debug.Print(DoubleConverter.ToFloatingPointBinaryString(result53)); Assert.AreEqual(expected53, result53); // Set Fpu to 64-bit precision (extended precision) FpuControl.SetState((uint)FpuControl.PrecisionControl.Extended64Bits, FpuControl.Mask.PrecisionControl); double result64 = (double)(a + b); Debug.Print(DoubleConverter.ToFloatingPointBinaryString(result64)); Assert.AreEqual(expected64, result64); }
public void OptimTest() { // 53 ones string a_s = "11111111111111111111111111111111111111111111111111110.0"; double a = DoubleConverter.FromFloatingPointBinaryString("11111111111111111111111111111111111111111111111111110.0"); double b = DoubleConverter.FromFloatingPointBinaryString("-11111111111111111111111111111111111111111111111111110.0"); double c = DoubleConverter.FromFloatingPointBinaryString("00000000000000000000000000000000000000000000000000000.01"); string a_s2 = DoubleConverter.ToFloatingPointBinaryString(9.0071992547409900e+0015); Assert.AreEqual(a_s, a_s2); bool ok = Test(a, b, c); Assert.IsTrue(ok); double acc = TestAcc(a, b, c); double acc2 = TestAcc(a, b, c); if (acc != acc2) { Assert.Fail(); } Assert.AreEqual(0.0, acc); Assert.AreEqual(0.0, acc2); double tst2 = Test2(a, b, c); if (tst2 != 0.0) { Assert.Fail(); } }
public void ShowDoubleRounding() { double a = DoubleConverter.FromFloatingPointBinaryString('1'.Repeat(52) + "0"); // 111....11110 double b = DoubleConverter.FromFloatingPointBinaryString("0.100000000001"); // 000....00000.100000000001 double expected53 = DoubleConverter.FromFloatingPointBinaryString('1'.Repeat(52) + "1"); // 111....11111 double expected64 = a; // Set Fpu to 53-bit precision (the default) FpuControl.SetState((uint)FpuControl.PrecisionControl.Double53Bits, FpuControl.Mask.PrecisionControl); double result53 = a + b; Assert.AreEqual(expected53, result53); // Set Fpu to 64-bit precision (extended precision) FpuControl.SetState((uint)FpuControl.PrecisionControl.Extended64Bits, FpuControl.Mask.PrecisionControl); double result64 = (double)(a + b); Assert.AreEqual(expected64, result64); double result64_0 = (a + b) - a; Assert.AreNotEqual(0.0, result64_0); Assert.AreNotEqual(b, result64_0); Assert.AreEqual(0.5, result64_0); // 000....00000.1 }
public void BitWidth_Simple() { double d = DoubleConverter.FromFloatingPointBinaryString("-0.001010101000"); int width = d.BitWidth(); Assert.AreEqual(7, width); }
public void Split_Simple() { double d = DoubleConverter.FromFloatingPointBinaryString("-0.001010101000"); double ahi; double alo; Split_Checked(d, out ahi, out alo); }
// Here we add an explicit cast, which ensures that (a + b) is evaluated to 64-bits before continuing public double TestCalcSafe() { double a = DoubleConverter.FromFloatingPointBinaryString("11111111111111111111111111111111111111111111111111110.0"); double b = DoubleConverter.FromFloatingPointBinaryString("00000000000000000000000000000000000000000000000000000.1"); double result = (double)(a + b) - a; return(result); }
public void Split_FullPrecision() { var dstr = "1." + '1'.Repeat(52); double d = DoubleConverter.FromFloatingPointBinaryString(dstr); var dstr2 = d.ToFloatingPointBinaryString(); NUnit.Framework.Assert.AreEqual(dstr, dstr2); double ahi; double alo; Split_Checked(d, out ahi, out alo); }
public void FastTwoSum_OppositeSign() { // Adapted example from Shewchuk p. 7 - Figure 4 - expanded to double // We expect a+b=x+y double a = DoubleConverter.FromFloatingPointBinaryString("1" + '0'.Repeat(51) + "10"); // 100...0010 double b = DoubleConverter.FromFloatingPointBinaryString("-" + '1'.Repeat(49) + "1011"); // -11...1011 double x_correct = DoubleConverter.FromFloatingPointBinaryString("111"); // 111 double y_correct = 0.0; double x; double y; EA.FastTwoSum(a, b, out x, out y); Assert.AreEqual(x_correct, x); Assert.AreEqual(y_correct, y); }
public void Split_FullPrecisionLarge() { // -1111...(53)...11111000000....000000000 var dstr = "-1" + '1'.Repeat(52) + '0'.Repeat(200); double d = DoubleConverter.FromFloatingPointBinaryString(dstr); var dstr2 = d.ToFloatingPointBinaryString(); NUnit.Framework.Assert.AreEqual(DoubleConverter.FromFloatingPointBinaryString(dstr), DoubleConverter.FromFloatingPointBinaryString(dstr2)); double ahi; double alo; Split_Checked(d, out ahi, out alo); }
public void TwoSum_Small_a() { // This is an example that FastTwoSum gets wrong (|a|<|b|), but TwoSum does right // Shewchuck p. 8, Figure 5 double a = DoubleConverter.FromFloatingPointBinaryString('1'.Repeat(51) + ".11"); // 111...111.11 double b = DoubleConverter.FromFloatingPointBinaryString("110" + '0'.Repeat(49) + "1"); // 11000...001 double x_correct = DoubleConverter.FromFloatingPointBinaryString("1" + '0'.Repeat(53)); // 100000...000 double y_correct = DoubleConverter.FromFloatingPointBinaryString("0.11"); // 0.11 double x; double y; EA.TwoSum(a, b, out x, out y); Assert.AreEqual(x_correct, x); Assert.AreEqual(y_correct, y); }
public void FastTwoSum_SameSign() { // Example ismilar to Shewchuk p. 7 - Figure 3 (expanded for double) // We expect a+b=x+y double a = DoubleConverter.FromFloatingPointBinaryString('1'.Repeat(53) + "00"); // 1111...1100 double b = DoubleConverter.FromFloatingPointBinaryString("1001"); // 1001 double x_correct = DoubleConverter.FromFloatingPointBinaryString("1" + '0'.Repeat(51) + "1000"); // 1000...00100 double y_correct = DoubleConverter.FromFloatingPointBinaryString("-11"); // - 11 double x; double y; EA.FastTwoSum(a, b, out x, out y); Assert.AreEqual(x_correct, x); Assert.AreEqual(y_correct, y); }
public void RoundToEvenTiebreaking() { var d1 = DoubleConverter.FromFloatingPointBinaryString("100000000000000000000000000000000000000000000000000010"); var d2 = DoubleConverter.FromFloatingPointBinaryString("1"); // Closest even to ~~~011 var d3 = DoubleConverter.FromFloatingPointBinaryString("100000000000000000000000000000000000000000000000000100"); var dtest = (double)d1 + d2; var stest = dtest.ToFloatingPointBinaryString(); Assert.AreEqual(d3, dtest); // Closest even to ~~~001 var d4 = DoubleConverter.FromFloatingPointBinaryString("100000000000000000000000000000000000000000000000000000"); var dtest2 = (double)d1 - d2; var stest2 = dtest2.ToFloatingPointBinaryString(); Assert.AreEqual(d4, dtest2); }
public void TestPrecision53() { double a = DoubleConverter.FromFloatingPointBinaryString('1'.Repeat(52) + "0"); // 111....11110 double b = DoubleConverter.FromFloatingPointBinaryString("0.1"); // 000....00000.1 double expected53 = a; FpuControl.SetState((uint)FpuControl.PrecisionControl.Double53Bits, FpuControl.Mask.PrecisionControl); double result53 = (double)(a + b); Assert.AreEqual(expected53, result53); double result53_0 = (a + b) - a; Assert.AreEqual(0.0, result53_0); double result53_X = ((double)(a + b)) - a; Assert.AreEqual(0.0, result53_X); }
public void TestPrecision64() { double a = DoubleConverter.FromFloatingPointBinaryString('1'.Repeat(52) + "0"); // 111....11110 double b = DoubleConverter.FromFloatingPointBinaryString("0.1"); // 000....00000.1 double expected64 = a; FpuControl.SetState((uint)FpuControl.PrecisionControl.Extended64Bits, FpuControl.Mask.PrecisionControl); double result64 = (double)(a + b); Assert.AreEqual(expected64, result64); double result64_b = (a + b) - a; Assert.AreEqual(b, result64_b); double result64_0 = ((double)(a + b)) - a; Assert.AreNotEqual(b, result64_0); Assert.AreEqual(0.0, result64_0); }
public void FloatingPointBinaryString_MatchesValue() { var tests = new[] { Tuple.Create(4.0, "100.0"), Tuple.Create(0.25, "0.01"), Tuple.Create(0.0, "0.0"), Tuple.Create(-2.5, "-10.1"), Tuple.Create(double.MaxValue, "1111111111111111111111111111111111111111111111111111100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0"), Tuple.Create(double.MinValue, "-1111111111111111111111111111111111111111111111111111100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0"), Tuple.Create(double.Epsilon, "0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001"), Tuple.Create(DoubleEpsilonSplitter().Item1, "0.00000000000000000000000000000000000000000000000000001"), // biggest exponent of 2 s.t. 1.0 + eps = 1.0 }; foreach (var t in tests) { string r = DoubleConverter.ToFloatingPointBinaryString(t.Item1); Assert.AreEqual(t.Item2, r); double d = DoubleConverter.FromFloatingPointBinaryString(r); Assert.AreEqual(t.Item1, d); } }