C# 双精度的尾数规范化

编辑：让它现在工作，在规范化螳螂时，首先设置隐式位很重要，在解码隐式位时，不必添加。我留下了标记的答案是正确的，因为那里的信息确实有帮助。

我目前正在实施编码(可分辨编码规则(，并且在编码双精度值时遇到一个小问题。

因此，我可以使用以下方法从 c# 中的双精度中取出符号、指数和尾数：

 // get parts
 double value = 10.0;
 long bits = BitConverter.DoubleToInt64Bits(value);
 // Note that the shift is sign-extended, hence the test against -1 not 1
 bool negative = (bits < 0);
 int exponent = (int)((bits >> 52) & 0x7ffL);
 long mantissa = bits & 0xfffffffffffffL;

(使用此处的代码(。这些值可以编码，简单的过程逆转将使我恢复原始的双精度。

但是，DER 编码规则指定尾数应规范化：

在 指定了规范编码规则和可分辨编码规则规范化，并且尾数(除非为 0(需要 反复移位，直到最低有效位为 1。

(请参阅此处的第 8.5.6.5 节(。

执行此操作：

 while ((mantissa & 1) == 0)
 {
     mantissa >>= 1;
     exponent++;
 }

行不通，给我奇怪的价值观。(即使使用上述链接中发布的整个功能Jon Skeet(。

我似乎在这里错过了一些东西，如果我首先可以规范化替身的尾钛并获取"位"，那将是最简单的。但是，我也不明白为什么手动规范化无法正常工作。

感谢您的任何帮助，

丹尼

编辑：实际工作问题显示我的螳螂规范化问题：

 static void Main(string[] args)
    {
        Console.WriteLine(CalculateDouble(GetBits(55.5, false))); 
        Console.WriteLine(CalculateDouble(GetBits(55.5, true)));
        Console.ReadLine();
    }
    private static double CalculateDouble(Tuple<bool, int, long> bits)
    {
        double result = 0;
        bool isNegative = bits.Item1;
        int exponent = bits.Item2;
        long significand = bits.Item3;
        if (exponent == 2047 && significand != 0)
        {
            // special case
        }
        else if (exponent == 2047 && significand == 0)
        {
            result = isNegative ? double.NegativeInfinity : double.PositiveInfinity;
        }
        else if (exponent == 0)
        {
            // special case, subnormal numbers
        }
        else
        {
            /* old code, wont work double actualSignificand = significand*Math.Pow(2,                   
               -52) + 1; */
            double actualSignificand = significand*Math.Pow(2, -52);
            int actualExponent = exponent - 1023;
            if (isNegative)
            {
                result = actualSignificand*Math.Pow(2, actualExponent);
            }
            else 
            {
                result = -actualSignificand*Math.Pow(2, actualExponent);**strong text**
            }
        }
        return result;
    }

    private static Tuple<bool, int, long> GetBits(double d, bool normalizeSignificand)
    {
        // Translate the double into sign, exponent and mantissa.
        long bits = BitConverter.DoubleToInt64Bits(d);
        // Note that the shift is sign-extended, hence the test against -1 not 1
        bool negative = (bits < 0);
        int exponent = (int)((bits >> 52) & 0x7ffL);
        long significand = bits & 0xfffffffffffffL;
        if (significand == 0)
        {
            return Tuple.Create<bool, int, long>(false, 0, 0);
        }
        // fix: add implicit bit before normalization
        if (exponent != 0)
        {
            significand = significand | (1L << 52);
        }
        if (normalizeSignificand)
        {
            //* Normalize */
            while ((significand & 1) == 0)
            {
                /*  i.e., Mantissa is even */
                significand >>= 1;
                exponent++;
            }
        }
        return Tuple.Create(negative, exponent, significand);
    }
    Output:
    55.5
    2.25179981368527E+15