为什么“dtoa.c”包含这么多代码？

Question

我将是第一个承认我对低级编程的整体知识有点稀疏的人。我了解许多核心概念，但我不经常使用它们。 话虽如此，我对dtoa.c 需要多少代码感到非常震惊。

在过去的几个月里，我一直致力于 C# 中的 ECMAScript 实现，我一直在减慢填补引擎漏洞的速度。昨晚我开始研究 Number.prototype.toString，这在 ECMAScript specification(pdf) 的 15.7.4.2 部分有所描述。在 9.8.1 部分，NOTE 3 提供了一个到 dtoa.c 的链接，但我正在寻找一个挑战，所以我等待查看它。以下是我想出的。

private IDynamic ToString(Engine engine, Args args)
{
    var thisBinding = engine.Context.ThisBinding;
    if (!(thisBinding is NumberObject) && !(thisBinding is NumberPrimitive))
    {
        throw RuntimeError.TypeError("The current 'this' must be a number or a number object.");
    }

    var num = thisBinding.ToNumberPrimitive();

    if (double.IsNaN(num))
    {
        return new StringPrimitive("NaN");
    }
    else if (double.IsPositiveInfinity(num))
    {
        return new StringPrimitive("Infinity");
    }
    else if (double.IsNegativeInfinity(num))
    {
        return new StringPrimitive("-Infinity");
    }

    var radix = !args[0].IsUndefined ? args[0].ToNumberPrimitive().Value : 10D;

    if (radix < 2D || radix > 36D)
    {
        throw RuntimeError.RangeError("The parameter [radix] must be between 2 and 36.");
    }
    else if (radix == 10D)
    {
        return num.ToStringPrimitive();
    }

    var sb = new StringBuilder();
    var isNegative = false;

    if (num < 0D)
    {
        isNegative = true;
        num = -num;
    }

    var integralPart = Math.Truncate(num);
    var decimalPart = (double)((decimal)num.Value - (decimal)integralPart);
    var radixChars = RadixMap.GetArray((int)radix);

    if (integralPart == 0D)
    {
        sb.Append('0');
    }
    else
    {
        var integralTemp = integralPart;
        while (integralTemp > 0)
        {
            sb.Append(radixChars[(int)(integralTemp % radix)]);
            integralTemp = Math.Truncate(integralTemp / radix);
        }
    }

    var count = sb.Length - 1;
    for (int i = 0; i < count; i++)
    {
        var k = count - i;
        var swap = sb[i];
        sb[i] = sb[k];
        sb[k] = swap;
    }

    if (isNegative)
    {
        sb.Insert(0, '-');
    }

    if (decimalPart == 0D)
    {
        return new StringPrimitive(sb.ToString());
    }

    var runningValue = 0D;
    var decimalIndex = 1D;
    var decimalTemp = decimalPart;

    sb.Append('.');
    while (decimalIndex < 100 && decimalPart - runningValue > 1.0e-50)
    {
        var result = decimalTemp * radix;
        var integralResult = Math.Truncate(result);
        runningValue += integralResult / Math.Pow(radix, decimalIndex++);
        decimalTemp = result - integralResult;
        sb.Append(radixChars[(int)integralResult]);
    }

    return new StringPrimitive(sb.ToString());
}

谁能解释一下为什么 dtoa.c 有大约 40 倍的代码？我简直无法想象 C# 会变得如此高效。

Answer 1

dtoa.c 包含两个主要函数：dtoa()，它将双精度数转换为字符串，以及 strtod()，它将字符串转换为双精度数。它还包含很多支持函数，其中大部分是针对它自己的任意精度算术实现的。 dtoa.c 声名鹊起的是正确地进行这些转换，而这通常只能通过任意精度的算术来完成。它还具有在四种不同舍入模式下正确舍入转换的代码。

您的代码仅尝试实现 dtoa() 的等效项，并且由于它使用浮点进行转换，因此并不总是正确。 （更新：详见我的文章http://www.exploringbinary.com/quick-and-dirty-floating-point-to-decimal-conversion/。）

（我在我的博客http://www.exploringbinary.com/ 上写了很多关于此的内容。我过去的七篇文章中有六篇仅关于 strtod() 转换。通读它们以了解正确舍入转换是多么复杂。 )

Answer 2

为十进制和二进制浮点表示之间的转换产生良好的结果是一个相当困难的问题。

困难的主要来源是许多小数，即使是简单的小数，也不能准确用二进制浮点表示——例如，0.5 可以（显然），但0.1不能。并且，反过来（从二进制到十进制），您通常不想要绝对准确的结果（例如，最接近 0.1 的数字的准确十进制值，可以在符合 IEEE-754 的double 其实是 0.1000000000000000055511151231257827021181583404541015625) 所以你通常需要一些舍入。

因此，转换通常涉及近似值。良好的转换例程保证在特定（字长或位数）约束内产生最接近可能的近似值。这就是大部分复杂性的来源。

查看dtoa.c 实现顶部的评论中引用的论文，Clinger 的How to Read Floating Point Numbers Accurately，以了解问题的含义；或许还有 David M. Gay（作者）的论文，Correctly Rounded Binary-Decimal and Decimal-Binary Conversions。

（另外，更一般地说：What Every Computer Scientist Should Know About Floating Point Arithmetic。）

Answer 3

快速浏览一下，相当多的 C 版本正在处理多个平台，并且看起来该文件旨在通用地跨编译器（C 和 C++）、位数、浮点实现使用和平台；具有大量 #define 可配置性。

Answer 4

我还认为 dtoa.c 中的代码可能更有效（独立于语言）。例如，它似乎在做一些琐碎的事情，这在专家手中通常意味着速度。出于速度原因，我认为它只是使用了一种不太直观的算法。

Answer 5

简答：因为dtoa.c 有效。

这正是调试良好的产品和 NIH 原型之间的区别。