Я буду первым, чтобы признать, что мое полное знание низкоуровневого программирования немного редко. Я понимаю многие базовые понятия, но я не использую их регулярно. Это сказанное я был абсолютно изумлен в том, сколько кода было необходимо для dtoa.c.
В течение прошлых месяцев пары я работал над реализацией ECMAScript в C#, и я замедлял заполнение дыр в моем механизме. Вчера вечером я начал работать над Number.prototype.toString, который описан в разделе 15.7.4.2 из Спецификация ECMAScript (PDF). В разделе 9.8.1, ПРИМЕЧАНИЕ 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#, являющийся что намного более продуктивным.
dtoa.c содержит две основные функции: dtoa (), которая преобразует double в строку, и strtod (), которая преобразует строку в double. Он также содержит множество вспомогательных функций, большинство из которых предназначены для собственной реализации арифметики произвольной точности. Претензия dtoa.c на известность заключается в правильном выполнении этих преобразований, а это, как правило, можно сделать только с помощью арифметики произвольной точности. Он также имеет код для правильного округления преобразований в четырех различных режимах округления.
Ваш код пытается реализовать только эквивалент dtoa (), и, поскольку он использует числа с плавающей запятой для выполнения своих преобразований, не всегда будет выполнять их правильно. (Обновление: подробности см. В моей статье http://www.exploringbinary.com/quick-and-dirty-floating-point-to-decimal-conversion/ .)
(Я написал много об этом в моем блоге, http://www.exploringbinary.com/ . Шесть из моих последних семи статей были посвящены только преобразованию strtod (). Прочтите их, чтобы увидеть, насколько сложно делайте правильно округленные преобразования.)
Получение хороших результатов для преобразований между десятичным и двоичным представлениями с плавающей запятой является довольно сложной задачей.
Основная проблема заключается в том, что многие десятичные дроби, даже простые, не могут быть точно выражены с использованием двоичной с плавающей запятой - например, 0,5
может (очевидно), но 0,1
не может. И, идя другим путем (от двоичного к десятичному), вам обычно не нужен абсолютно точный результат (например, точное десятичное значение ближайшего числа к 0,1
, которое может быть представлено в IEEE -754-совместимый двойной
на самом деле
0,1000000000000000055511151231257827021181583404541015625
), поэтому обычно требуется округление.
Таким образом, преобразование часто включает аппроксимацию. Хорошие процедуры преобразования гарантируют получение наиболее близкого возможного приближения в рамках определенных ограничений (размер слова или количество цифр). Отсюда большая часть сложности.
Взгляните на статью, процитированную в комментарии в верхней части реализации dtoa.c
, Как правильно читать числа с плавающей точкой Клингера, чтобы понять суть проблемы; и, возможно, статья Дэвида М. Гей (автора) Правильно округленные двоично-десятичные и десятично-двоичные преобразования .
(Также, в более общем плане: Что должен знать каждый компьютерный ученый об арифметике с плавающей запятой .)
На первый взгляд, значительная часть версии C работает с несколькими платформами, и, например, похоже, что этот файл предназначен для общего использования в компиляторах (C и C ++), разрядности, реализациях с плавающей запятой. , и платформы; с множеством возможностей настройки #define
.
Короткий ответ: потому что dtoa.c
работает.
Это как раз и есть разница между хорошо отлаженным продуктом и прототипом NIH.
Я также думаю, что код в dtoa.c мог бы быть более эффективным (независимо от языка). Например, кажется, что он немного возится с битами, что в руках эксперта часто означает скорость. Я предполагаю, что он просто использует менее интуитивный алгоритм из соображений скорости.