public void Construction_WhereNegativeFloatingPointNumber_ShouldBeNagative_Test() { double d = -100.005; var result = new ExpandedDouble(d); result.IsNegative.Should().Be(true, "-100.005 is a negative number"); }
public void Construction_WherePositiveInfinity_ShouldBePositive_Test() { double d = double.PositiveInfinity; var result = new ExpandedDouble(d); result.IsNegative.Should().Be(false, "+inf is a positive number"); }
public void Construction_WhereNegativeWholeNumber_ShouldBeNagative_Test() { double d = -100; var result = new ExpandedDouble(d); result.IsNegative.Should().Be(true, "-100 is a negative number"); }
public void IsQuietNaN_WithSignallingNaN_ShouldBeTrue_Test() { double d = 0d / 0d; var result = new ExpandedDouble(d); result.IsQuietNaN.Should().Be(true); }
public void MantissaAsStored_WhereExponentIsNotZero_ShouldBeCorrect_Test() { double d = 75.5; var result = new ExpandedDouble(d); result.MantissaAsStored.Should().Be(809240558043136, "The mantissa of 75.5 should be 809240558043136 as it is stored in binary"); }
public void Mantissa_WhereExponentIsNotZero_ShouldBeCorrectWithImpliedLeadingOne_Test() { double d = 75.5; var result = new ExpandedDouble(d); result.Mantissa.Should().Be(809240558043137, "The mantissa of 75.5 should be 809240558043137 with the leading one added"); }
public void Exponent_WhereExponentIsNotZero_ShouldBeCorrect_Test() { double d = 75.5; var result = new ExpandedDouble(d); result.Exponent.Should().Be(3, "The exponent of 75.5 should be 3 after removing the bias"); }
public void ExponentBitsAsStored_WhereExponentIsNotZero_ShouldBeCorrect_Test() { double d = 75.5; var result = new ExpandedDouble(d); result.ExponentBitsAsStored.Should().BeEquivalentTo(1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1); }
public void IsNegativeInfinity_WithOne_ShouldBeFalse_Test() { double d = 1d; var result = new ExpandedDouble(d); result.IsNegativeInfinity.Should().Be(false); }
public void ExponentAsStored_WhereExponentIsNotZero_ShouldBeCorrect_Test() { double d = 75.5; var result = new ExpandedDouble(d); result.ExponentAsStored.Should().Be(1029, "The exponent of 75.5 should be 1029 before removing the bias"); }
public void IsNegativeInfinity_WithNegativeInfinity_ShouldBeTrue_Test() { double d = double.NegativeInfinity; var result = new ExpandedDouble(d); result.IsNegativeInfinity.Should().Be(true); }
public void IsPositiveInfinity_WithNegativeInfinity_ShouldBeFalse_Test() { double d = double.NegativeInfinity; var result = new ExpandedDouble(d); result.IsPositiveInfinity.Should().Be(false); }
public void IsInfinite_WithPositiveInfinity_ShouldBeTrue_Test() { double d = double.PositiveInfinity; var result = new ExpandedDouble(d); result.IsInifinite.Should().Be(true); }
public void Construction_WhereNegativeInfinity_ShouldBeNagative_Test() { double d = double.NegativeInfinity; var result = new ExpandedDouble(d); result.IsNegative.Should().Be(true, "-inf is a negative number"); }
public void Construction_WherePositiveFloatingPointNumber_ShouldBePositive_Test() { double d = 100.005; var result = new ExpandedDouble(d); result.IsNegative.Should().Be(false, "100.005 is a positive number"); }
public void IsSignnallingNaN_WithSignallingNaN_ShouldBeTrue_Test() { double d = 0d / 0d; // Produces quite NaN var result = new ExpandedDouble(d); result.IsSignallingNaN.Should().Be(true); }
public void IsNaN_WithOne_ShouldBeFalse_Test() { double d = 1d; var result = new ExpandedDouble(d); result.IsNaN.Should().Be(false); }
private static void CheckNormaliseBaseTenResult(ExpandedDouble orig, NormalisedDecimal result) { String sigDigs = result.GetSignificantDecimalDigits(); BigInteger frac = orig.GetSignificand(); while (frac.BitLength() + orig.GetBinaryExponent() < 200) { frac = frac * (BIG_POW_10); } int binaryExp = orig.GetBinaryExponent() - orig.GetSignificand().BitLength(); String origDigs = (frac << (binaryExp + 1)).ToString(10); if (!origDigs.StartsWith(sigDigs)) { throw new AssertionException("Expected '" + origDigs + "' but got '" + sigDigs + "'."); } double dO = Double.Parse("0." + origDigs.Substring(sigDigs.Length)); double d1 = Double.Parse(result.GetFractionalPart().ToString()); BigInteger subDigsO = new BigInteger((int)(dO * 32768 + 0.5)); BigInteger subDigsB = new BigInteger((int)(d1 * 32768 + 0.5)); if (subDigsO.Equals(subDigsB)) { return; } BigInteger diff = (subDigsB - subDigsO).Abs(); if (diff.IntValue() > 100) { // 100/32768 ~= 0.003 throw new AssertionException("minor mistake"); } }
public void IsNaN_WithNaN_ShouldBeTrue_Test() { double d = double.NaN; var result = new ExpandedDouble(d); result.IsNaN.Should().Be(true); }
public void Construction_WhereNaN_ShouldBePositive_Test() { // Todo: We should maybe throw an exception when testing the sign of NaN instead double d = double.NaN; var result = new ExpandedDouble(d); result.IsNegative.Should().Be(true, "-NaN is a negative number"); }
public static String GetBaseDecimal(ExpandedDouble hd) { /*int gg = 64 - hd.GetBinaryExponent() - 1; * BigDecimal bd = new BigDecimal(hd.GetSignificand()).divide(new BigDecimal(BigInteger.ONE<<gg)); * int excessPrecision = bd.precision() - 23; * if (excessPrecision > 0) * { * bd = bd.SetScale(bd.scale() - excessPrecision, BigDecimal.ROUND_HALF_UP); * } * return bd.unscaledValue().ToString();*/ throw new NotImplementedException("This Method need BigDecimal class"); }
public void TestSubnormal() { ExpandedDouble hd = new ExpandedDouble(0x0000000000000001L); if (hd.GetBinaryExponent() == -1023) { throw new AssertionException("identified bug - subnormal numbers not decoded properly"); } Assert.AreEqual(-1086, hd.GetBinaryExponent()); BigInteger frac = hd.GetSignificand(); Assert.AreEqual(64, frac.BitLength()); Assert.AreEqual(1, frac.BitCount()); }
public void TestNegative() { ExpandedDouble hd = new ExpandedDouble(unchecked ((long)0xC010000000000000L)); if (hd.GetBinaryExponent() == -2046) { throw new AssertionException("identified bug - sign bit not masked out of exponent"); } Assert.AreEqual(2, hd.GetBinaryExponent()); BigInteger frac = hd.GetSignificand(); Assert.AreEqual(64, frac.BitLength()); Assert.AreEqual(1, frac.BitCount()); }
public static BigInteger GetNearby(ExpandedDouble hd, int offset) { return(GetNearby(hd.GetSignificand(), hd.GetBinaryExponent(), offset)); }
public static bool ConfirmRoundTrip(int i, long rawBitsA) { double a = BitConverter.Int64BitsToDouble(rawBitsA); if (a == 0.0) { // Can't represent 0.0 or -0.0 with NormalisedDecimal return(true); } ExpandedDouble ed1; NormalisedDecimal nd2; ExpandedDouble ed3; try { ed1 = new ExpandedDouble(rawBitsA); nd2 = ed1.NormaliseBaseTen(); CheckNormaliseBaseTenResult(ed1, nd2); ed3 = nd2.NormaliseBaseTwo(); } catch (Exception e) { Console.WriteLine("example[" + i + "] (" + FormatDoubleAsHex(a) + ") exception: " + e.Message); return(false); } if (ed3.GetBinaryExponent() != ed1.GetBinaryExponent()) { Console.WriteLine("example[" + i + "] (" + FormatDoubleAsHex(a) + ") bin exp mismatch"); return(false); } BigInteger diff = ed3.GetSignificand() - (ed1.GetSignificand()).Abs(); if (diff.Signum() == 0) { return(true); } // original quantity only has 53 bits of precision // these quantities may have errors in the 64th bit, which hopefully don't make any difference if (diff.BitCount() < 2) { // errors in the 64th bit happen from time to time // this is well below the 53 bits of precision required return(true); } // but bigger errors are a concern Console.WriteLine("example[" + i + "] (" + FormatDoubleAsHex(a) + ") frac mismatch: " + diff.ToString()); for (int j = -2; j < 3; j++) { Console.WriteLine((j < 0 ? "" : "+") + j + ": " + GetNearby(ed1, j)); } for (int j = -2; j < 3; j++) { Console.WriteLine((j < 0 ? "" : "+") + j + ": " + GetNearby(nd2, j)); } return(false); }