Example #1
0
        public void PositiveInfinityTest()
        {
            var number = double.PositiveInfinity;

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

            Assert.AreEqual(1.3263673994695693E+154, gama);
        }
Example #2
0
        public void Sqrt256Test()
        {
            var number = 256.0;

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

            Assert.AreEqual(16.0, gama, 0.173);
        }
Example #3
0
        public void LargestNormalizedNumberSqrt()
        {
            var number = BitConverter.Int64BitsToDouble(0x7FEF_FFFF_FFFF_FFFFL);

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

            Assert.AreEqual(1.3263673994695691E+154, gama);
        }
Example #4
0
        public void Sqrt4Test()
        {
            var number = 4.0;

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

            Assert.AreEqual(2.0, gama, 0.0216);
        }
Example #5
0
        public void Sqrt16Test()
        {
            var number = 16.0;

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

            Assert.AreEqual(4.0, gama, 0.0431);
        }
Example #6
0
        public void Sqrt1Test()
        {
            var number = 1.0;

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

            Assert.AreEqual(1.0, gama, 0.0108);
        }
Example #7
0
        public void MiddleDenormalizedNumberSqrt()
        {
            var number = BitConverter.Int64BitsToDouble(0x0008_0000_0000_0000L);

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

            Assert.AreEqual(1.2891741953879534E-154, gama);
        }
Example #8
0
        public void SqrtQuarterTest()
        {
            var number = 0.25;

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

            Assert.AreEqual(0.5, gama, 0.00538);
        }
Example #9
0
        public void SqrtHalfTest()
        {
            var number = 0.5;

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

            Assert.AreEqual(0.70710678118654752440084436210485, gama, 0.0322);
        }
Example #10
0
        public void SqrtOneSixteenthTest()
        {
            var number = 0.0625;

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

            Assert.AreEqual(0.25, gama, 0.00269);
        }
Example #11
0
        public void SmallestNormalizedNumberSqrt()
        {
            var number = BitConverter.Int64BitsToDouble(0x0010_0000_0000_0000L);

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

            Assert.AreEqual(1.4756327136679585E-154, gama);
        }
Example #12
0
        public void LargestDenormalizedNumberSqrt()
        {
            var number = BitConverter.Int64BitsToDouble(0x000F_FFFF_FFFF_FFFFL);

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

            Assert.AreEqual(1.4756327136679584E-154, gama);
        }
Example #13
0
        public void NotANumberTest()
        {
            var number = double.NaN;

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

            Assert.AreEqual(9.1625715882794302E-155, gama);
        }
Example #14
0
        public void Sqrt2Test()
        {
            var number = 2.0;

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

            Assert.AreEqual(1.4142135623730950488016887242097, gama, 0.0643);
        }
Example #15
0
        public void SmallestDenormalizedNumberSqrt()
        {
            var number = BitConverter.Int64BitsToDouble(0x0000_0000_0000_0001L);

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

            Assert.AreEqual(1.1027156771079482E-154, gama);
        }
Example #16
0
        public void ZeroSqrt()
        {
            var number = 0.0;
            var bits   = Double754.DoubleToString(number);

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

            var gama = Double754.FastSqrtDouble(number);

            Assert.AreEqual(1.1027156771079482E-154, gama);
        }
Example #17
0
        public void Test()
        {
            var number = 256.0;

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

            Assert.AreEqual("1.0000000000000000 * 2^(4)", Double754.DoubleToString(16));
            Assert.AreEqual("1.9784999999999968 * 2^(3)", Double754.DoubleToString(gama));
            Assert.AreEqual(16.0, gama, 0.173);
        }