Esempio n. 1
0
        public void PositiveInfinityTest()
        {
            var number = double.PositiveInfinity;

            Assert.IsTrue(double.IsInfinity(number));
            var gama = Double754.FastInvSqrtDouble(number);

            Assert.AreEqual(7.2178092426191764E-155, gama);
        }
Esempio n. 2
0
        public void Sqrt256Test()
        {
            var number = 256.0;

            Assert.AreEqual("1.0000000000000000 * 2^(8)", Double754.DoubleToString(number));
            var gama = Double754.FastInvSqrtDouble(number);

            Assert.AreEqual(0.0625, gama, 0.0025);
        }
Esempio n. 3
0
        public void LargestNormalizedNumberSqrt()
        {
            var number = BitConverter.Int64BitsToDouble(0x7FEF_FFFF_FFFF_FFFFL);

            Assert.AreEqual(1.7976931348623157E+308, number);
            var gama = Double754.FastInvSqrtDouble(number);

            Assert.AreEqual(7.2178092426191773E-155, gama);
        }
Esempio n. 4
0
        public void Sqrt4Test()
        {
            var number = 4.0;

            Assert.AreEqual("1.0000000000000000 * 2^(2)", Double754.DoubleToString(number));
            var gama = Double754.FastInvSqrtDouble(number);

            Assert.AreEqual(0.5, gama, 0.017);
        }
Esempio n. 5
0
        public void Sqrt16Test()
        {
            var number = 16.0;

            Assert.AreEqual("1.0000000000000000 * 2^(4)", Double754.DoubleToString(number));
            var gama = Double754.FastInvSqrtDouble(number);

            Assert.AreEqual(0.25, gama, 0.012);
        }
Esempio n. 6
0
        public void Sqrt1Test()
        {
            var number = 1.0;

            Assert.AreEqual("1.0000000000000000 * 2^(0)", Double754.DoubleToString(number));
            var gama = Double754.FastInvSqrtDouble(number);

            Assert.AreEqual(1.0, gama, 0.0323);
        }
Esempio n. 7
0
        public void MiddleDenormalizedNumberSqrt()
        {
            var number = BitConverter.Int64BitsToDouble(0x0008_0000_0000_0000L);

            Assert.AreEqual(1.1125369292536007E-308, number);
            var gama = Double754.FastInvSqrtDouble(number);

            Assert.AreEqual(7.9474781504737915E+153, gama);
        }
Esempio n. 8
0
        public void SqrtQuarterTest()
        {
            var number = 0.25;

            Assert.AreEqual("1.0000000000000000 * 2^(-2)", Double754.DoubleToString(number));
            var gama = Double754.FastInvSqrtDouble(number);

            Assert.AreEqual(2.0, gama, 0.065);
        }
Esempio n. 9
0
        public void SqrtHalfTest()
        {
            var number = 0.5;

            Assert.AreEqual("1.0000000000000000 * 2^(-1)", Double754.DoubleToString(number));
            var gama = Double754.FastInvSqrtDouble(number);

            Assert.AreEqual(1.414213562, gama, 0.022);
        }
Esempio n. 10
0
        public void SqrtOneSixteenthTest()
        {
            var number = 0.0625;

            Assert.AreEqual("1.0000000000000000 * 2^(-4)", Double754.DoubleToString(number));
            var gama = Double754.FastInvSqrtDouble(number);

            Assert.AreEqual(4.0, gama, 0.13);
        }
Esempio n. 11
0
        public void SmallestNormalizedNumberSqrt()
        {
            var number = BitConverter.Int64BitsToDouble(0x0010_0000_0000_0000L);

            Assert.AreEqual(2.2250738585072014E-308, number);
            var gama = Double754.FastInvSqrtDouble(number);

            Assert.AreEqual(6.4877030621011327E+153, gama);
        }
Esempio n. 12
0
        public void LargestDenormalizedNumberSqrt()
        {
            var number = BitConverter.Int64BitsToDouble(0x000F_FFFF_FFFF_FFFFL);

            Assert.AreEqual(2.2250738585072009E-308, number);
            var gama = Double754.FastInvSqrtDouble(number);

            Assert.AreEqual(6.4877030621011334E+153, gama);
        }
Esempio n. 13
0
        public void NotANumberTest()
        {
            var number = double.NaN;

            Assert.IsTrue(double.IsNaN(number));
            var gama = Double754.FastInvSqrtDouble(number);

            Assert.AreEqual(1.1299430132959441E+154, gama);
        }
Esempio n. 14
0
        public void Sqrt2Test()
        {
            var number = 2.0;

            Assert.AreEqual("1.0000000000000000 * 2^(1)", Double754.DoubleToString(number));
            var gama = Double754.FastInvSqrtDouble(number);

            Assert.AreEqual(0.7071067811, gama, 0.011);
        }
Esempio n. 15
0
        public void SmallestDenormalizedNumberSqrt()
        {
            var number = BitConverter.Int64BitsToDouble(0x0000_0000_0000_0001L);

            Assert.AreEqual(4.9406564584124654E-324, number);
            var gama = Double754.FastInvSqrtDouble(number);

            Assert.AreEqual(9.6234541417166161E+153, gama);
        }
Esempio n. 16
0
        public void ZeroSqrt()
        {
            var number = 0.0;
            var bits   = Double754.DoubleToString(number);

            Assert.AreEqual("0.0000000000000000 * 2^(-1022)", bits);

            var gama = Double754.FastInvSqrtDouble(number);

            Assert.AreEqual(9.6234541417166161E+153, gama);
        }
Esempio n. 17
0
        public void Test()
        {
            var number = 256.0;

            Assert.AreEqual("1.0000000000000000 * 2^(8)", Double754.DoubleToString(number));
            var gama = Double754.FastInvSqrtDouble(number);

            Assert.AreEqual("1.0000000000000000 * 2^(-4)", Double754.DoubleToString(0.0625));
            var y = BitConverter.Int64BitsToDouble(0x5FE6F7CED9168800L);

            Assert.AreEqual("1.4355000000000473 * 2^(511)", Double754.DoubleToString(y));

            Assert.AreEqual("1.9355000000000473 * 2^(-5)", Double754.DoubleToString(gama));
            Assert.AreEqual(0.0625, gama, 0.01);
        }