C# double 的尾数规范化

Question

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

我目前正在实现一种编码（可区分编码规则）并且在编码双精度值时遇到了一点问题。

所以，我可以通过以下方式从 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;

（使用来自here 的代码）。 这些值可以被编码，只要简单地反转这个过程，我就能找回原来的双精度值。

但是，DER 编码规则指定尾数应该被归一化：

在 Canonical Encoding Rules 和 Distinguished Encoding Rules 规范化被指定并且尾数（除非它是 0）需要 重复移位，直到最低有效位为 1。

（见here in section 8.5.6.5）。

手动使用：

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

不起作用，并给了我奇怪的值。 （即使使用上述链接中发布的整个功能 Jon Skeet）。

我似乎在这里遗漏了一些东西，如果我首先可以规范化双倍的 mantiassa 并获得“位”，那将是最简单的。但是，我也无法真正理解为什么手动标准化不能正常工作。

感谢您的帮助，

丹尼

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

 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

Answer 1

当您使用 BitConverter.DoubleToInt64Bits 时，它会为您提供已经以 IEEE 754 格式编码的 double 值。这意味着有效数字使用隐式前导位进行编码。 （“有效位”是浮点值小数部分的首选术语，在 IEEE 754 中使用。有效位是线性的。尾数是对数的。“尾数”源于人们不得不使用对数和纸的时代和函数表来进行粗略的计算。）要恢复未编码的有效位，您必须恢复隐式位。

这并不难。将符号位、编码的指数（作为整数）和编码的有效数（作为整数）分开后，对于 64 位二进制浮点：

• 如果编码的指数是它的最大值 (2047) 并且编码的有效位不为零，则该值为 NaN。有效位中有关于 NaN 是否发出信号的附加信息以及其他用户或实现定义的信息。
• 如果编码的指数是其最大值并且编码的有效位为零，则该值为无穷大（+ 或 - 根据符号）。
• 如果编码指数为零，则隐含位为零，实际有效位为编码有效位乘以 2^–52，实际指数为 1 减去偏差 (1023)（所以–1022)。
• 否则，隐含位为1，实际有效位为编码有效位先乘以2^–52再加1，实际指数为编码指数减去偏差（1023 )。

（如果您想使用整数并且没有分数作为有效数，您可以省略乘以 2^–52 并改为将 –52 添加到指数。在最后一种情况下，有效位被添加到 2⁵² 而不是 1。）

有一种替代方法可以避免使用BitConverter 和 IEEE-754 编码。如果您可以从 C# 调用 frexp 例程，它将以数学方式返回分数和指数，而不是作为编码。首先，分别处理零、无穷大和 NaN。然后使用：

int exponent;
double fraction = frexp(value, &exponent);

这会将fraction 设置为幅度在[½, 1) 和exponent 中的值，这样fraction•2^exponent 等于value。 （请注意，fraction 仍然有符号；您可能希望将其分开并使用绝对值。）

此时，您可以根据需要缩放fraction（并相应地调整exponent）。要将其缩放为奇数，您可以将其重复乘以 2，直到它没有小数部分。