编辑：现在可以工作了，在规范化螳螂时，首先设置隐式位很重要，在解码隐式位时不必添加。我将标记的答案保留为正确，因为那里的信息确实有帮助。
我目前正在实施编码（可区分编码规则），并且在编码双精度值时遇到了小问题。
因此，我可以使用以下方法从 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 编码规则指定尾数应该被归一化：
在 Canonical Encoding Rules 和 Distinguished Encoding Rules 中指定了规范化，并且尾数（除非它是 0）需要重复移位，直到最低有效位为 1。
（参见第 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