Десятичная и двойная скорость

1. Арифметика с плавающей запятой почти всегда будет значительно быстрее, потому что она поддерживается напрямую оборудованием. До сих пор почти ни одно широко используемое оборудование не поддерживает десятичную арифметику (хотя это меняется, см. Комментарии).
2. Финансовые приложения должны всегда использовать десятичные числа, количество ужасных историй, связанных с использованием плавающей запятой в финансовых приложениях, бесконечно, вы сможете найти много таких примеров с помощью поиска Google.
3. Хотя десятичная арифметика может быть значительно медленнее, чем арифметика с плавающей запятой, если вы не тратите значительное количество времени на обработку десятичных данных, влияние на вашу программу, вероятно, будет незначительным. Как всегда, сделайте соответствующее профилирование, прежде чем беспокоиться о разнице.

Здесь есть две отдельные проблемы. Во-первых, достаточно ли точности у двойника для хранения всех нужных вам битов, а во втором-то, где он может точно представлять ваши числа.

Что касается точного представления, вы правы, проявляя осторожность, потому что точная десятичная дробь, такая как 1/10, не имеет точного двоичного эквивалента. Однако, если вы знаете, что вам нужно только 5 десятичных знаков точности, вы можете использовать масштабированную арифметику, в которой вы работаете с числами, умноженными на 10 ^ 5. Так, например, если вы хотите точно представить 23,7205, вы представляете его как 2372050.

Посмотрим, достаточно ли точности: двойная точность дает 53 бита точности. Это эквивалентно 15+ десятичным знакам точности. Таким образом, это позволит вам получить пять цифр после десятичной точки и 10 цифр перед десятичной точкой, что кажется достаточным для вашего приложения.

Я бы поместил этот код C в файл .h:

typedef double scaled_int;

#define SCALE_FACTOR 1.0e5  /* number of digits needed after decimal point */

static inline scaled_int adds(scaled_int x, scaled_int y) { return x + y; }
static inline scaled_int muls(scaled_int x, scaled_int y) { return x * y / SCALE_FACTOR; }

static inline scaled_int scaled_of_int(int x) { return (scaled_int) x * SCALE_FACTOR; }
static inline int intpart_of_scaled(scaled_int x) { return floor(x / SCALE_FACTOR); }
static inline int fraction_of_scaled(scaled_int x) { return x - SCALE_FACTOR * intpart_of_scaled(x); }

void fprint_scaled(FILE *out, scaled_int x) {
  fprintf(out, "%d.%05d", intpart_of_scaled(x), fraction_of_scaled(x));
}

Вероятно, есть несколько неровностей, но этого должно быть достаточно, чтобы вы начали.

Нет накладных расходов на сложение, стоимость умножения или деления удваивается.

Если у вас есть доступ к C99, вы также можете попробовать масштабированную целочисленную арифметику, используя int64_t 64-битный целочисленный тип. Что быстрее, будет зависеть от вашей аппаратной платформы.

Всегда используйте Decimal для любых финансовых расчетов, иначе вы всегда будете гоняться за ошибками округления в 1 цент.

1. Да; программная арифметика действительно в 100 раз медленнее, чем аппаратная. Или, по крайней мере, он намного медленнее, и коэффициент 100, плюс-минус порядка величины, примерно правильный. В старые плохие времена, когда вы не могли предположить, что каждый 80386 имеет сопроцессор с плавающей запятой 80387, тогда у вас также было программное моделирование двоичной с плавающей запятой, и это было медленным.
2. Нет; вы живете в стране фантазий, если думаете, что чистая двоичная плавающая точка может когда-либо точно представлять все десятичные числа. Двоичные числа могут объединять половинки, четверти, восьмые и т. Д., Но поскольку точное десятичное число 0,01 требует двух делителей одной пятой и одного четверти (1/100 = (1/4) * (1/5) * (1 / 5)), и поскольку одна пятая не имеет точного представления в двоичном формате, вы не можете точно представить все десятичные значения двоичными значениями (потому что 0,01 - это контрпример, который не может быть представлен точно, но представляет огромный класс десятичных чисел, которые не могут быть представлены точно).

Итак, вы должны решить, сможете ли вы справиться с округлением перед вызовом ToString () или вам нужно найти какой-то другой механизм, который будет обрабатывать округление ваших результатов при их преобразовании в строку. Или вы можете продолжать использовать десятичную арифметику, поскольку она останется точной и станет быстрее, когда будут выпущены машины, поддерживающие новую аппаратную десятичную арифметику IEEE 754.

Обязательная перекрестная ссылка: Что должен знать каждый компьютерный ученый о Floating- Точечная арифметика. Это один из многих возможных URL-адресов.

Информацию о десятичной арифметике и новом стандарте IEEE 754: 2008 можно найти на этом сайте Speleotrove.

Просто используйте длинное число и умножьте на степень 10. После того, как вы закончите, разделите на такую ​​же степень 10.

Для финансовых расчетов всегда следует использовать десятичные дроби. Размер чисел не важен.

Самый простой способ объяснить это с помощью кода на C #.

double one = 3.05;
double two = 0.05;

System.Console.WriteLine((one + two) == 3.1);

Этот фрагмент кода распечатает False, даже если 3,1 равно 3,1 ...

То же самое ... но с использованием десятичной дроби:

decimal one = 3.05m;
decimal two = 0.05m;

System.Console.WriteLine((one + two) == 3.1m);

Теперь будет распечатано Верно!

Если вы хотите избежать подобных проблем, я рекомендую использовать десятичные дроби.

Я отсылаю вас к моему ответу на этот вопрос.

Используйте длинный, храните наименьшую сумму, которую вам нужно отслеживать, и отображайте значения соответственно.