Почему "dtoa.c " содержит так много кода?
Я буду первым, кто признает, что мои общие знания о программировании низкого уровня немного разрежены. Я понимаю многие из основных концепций, но я не использую их на регулярной основе. При этом я был абсолютно поражен тем, сколько кода было необходимо для dtoa.c.
в течение последних нескольких месяцев я работал над реализацией ECMAScript в C#, и я замедлял заполнение отверстий в моем двигателе. Прошлой ночью я начал работать над количество.прототип.метод 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# настолько продуктивнее.
5 ответов
dtoa.c содержит две основные функции: dtoa (), которая преобразует double в string, и strtod (), которая преобразует строку в double. Он также содержит множество функций поддержки, большинство из которых предназначены для собственной реализации арифметики произвольной точности. dtoa.претензия c на славу-это получение этих преобразований правильно, и это может быть сделано только с арифметикой произвольной точности. Он также имеет код для округления конверсий правильно в четырех разных округлениях режим.
ваш код только пытается реализовать эквивалент dtoa (), и поскольку он использует плавающую точку для выполнения своих преобразований, не всегда будет получать их правильно. (Update: см. мою статью 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-совместимом double
- это на самом деле
0.1000000000000000055511151231257827021181583404541015625
) таким образом, вы обычно хотите округления.
Итак, преобразование часто включает в себя приближение. Хорошие процедуры преобразования гарантируют производство ближе возможное приближение в рамках определенных ограничений (размер слова или количество цифр). Это где большинство сложностей.
взгляните на статья цитируется в комментарии в верхней части dtoa.c
реализация, Клингер в как читать числа с плавающей запятой точно, для аромата проблемы; и, возможно, Дэвид М. гей (автор)'s бумага,правильно округленные двоично-десятичные и Десятично-двоичные преобразования.
(также, в более общем плане: Что Каждый Компьютерщик Должен Знать Об Арифметике С Плавающей Запятой.)
основываясь на быстром взгляде на него, изрядная часть версии C имеет дело с несколькими платформами и, например, похоже, что этот файл предназначен для общего использования в компиляторах (C & C++), разрядах, реализациях с плавающей запятой и платформах; с тоннами #define
настраиваемость.
Я думаю, что код в dtoa.С может быть более эффективным (независимо от языка). Например, кажется, что он делает какую-то бит-скрипку, которая в руках эксперта часто означает скорость. Я предполагаю, что он просто использует менее интуитивный алгоритм по соображениям скорости.
короткий ответ: потому что dtoa.c
строительство.
это точно разница между хорошо отлаженным продуктом и прототипом NIH.