尾数标准化C#double

我目前正在实现编码(专有编码规则),并且编码双值时会有轻微问题.

所以,我可以通过使用以下方式从c#中的double中取出符号,指数和尾数：

// 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编码规则指定应该对尾数进行规范化：

In the
Canonical Encoding Rules and the Distinguished Encoding Rules normalization is specified and the mantissa (unless it is 0) needs
to be repeatedly shifted until the least significant bit is a 1.

(见here in section 8.5.6.5).

手动执行此操作：

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

不行,并给我奇怪的价值观. (即使使用Jon Skeet在上述链接中发布的整个功能).

我似乎在这里遗漏了一些东西,如果我第一次能够规范化双重的mantiassa并得到“位”,那将是最简单的.但是,我也无法真正理解为什么手动标准化将无法正常工作.

谢谢你的帮助,

丹尼

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

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,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,long>(false,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