Когда я должен использовать дважды вместо десятичного числа?

Используйте числа с плавающей запятой, если вы цените производительность выше правильности.

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

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

Графика голодна? достаточно float или double. Анализ финансовых данных, метеориты, ударяющие планету, в точности? Этим нужно немного точности :)

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

Но двойное обычно более точно для произвольных вычисляемых значений.

Например, если вы хотите вычислить вес каждой строки в портфеле, используйте double, так как в результате более всего будет добавлено до 100%.

В следующем примере doubleResult ближе к 1, чем decimalResult:

// Add one third + one third + one third with decimal
decimal decimalValue = 1M / 3M;
decimal decimalResult = decimalValue + decimalValue + decimalValue;
// Add one third + one third + one third with double
double doubleValue = 1D / 3D;
double doubleResult = doubleValue + doubleValue + doubleValue;

Итак, снова рассмотрим пример портфеля. :

• Рыночная стоимость каждой строки в портфеле является денежной величиной, и, вероятно, ее лучше всего представить в виде десятичной дроби.

• Вес каждой строки в портфеле (= рыночная стоимость / SUM (рыночная стоимость)) обычно лучше представить как double.

Если вам нужно выполнить двоичное взаимодействие с другими языками или платформами, то вам может понадобиться использовать float или double, которые стандартизированы.

Похоже, вы замечаете преимущества использования типа с плавающей запятой. Я склонен проектировать десятичные дроби во всех случаях и полагаюсь на профилировщик, чтобы сообщить мне, если операции с десятичной дробью вызывают узкие места или замедления. В этих случаях я буду «понижать» до удвоения или смещения, но делаю это только внутренне, и тщательно пытаюсь управлять потерей точности, ограничивая количество значащих цифр в выполняемой математической операции.

В общем, если ваш значение является временным (не используется повторно), вы можете безопасно использовать тип с плавающей запятой. Настоящая проблема с типами с плавающей запятой заключается в следующих трех сценариях. 128-битный тип данных. По сравнению с типы с плавающей точкой, десятичный тип имеет большую точность и меньшую диапазон, что делает его подходящим для финансовые и денежные расчеты.

Итак, чтобы прояснить мое утверждение выше:

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

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

Десятичное число не является бесконечно точным (невозможно представить бесконечную точность для нецелого в примитивный тип данных), но он гораздо точнее двойного:

• десятичный = 28-29 значащих цифр
• двойной = 15-16 значащих цифр
• float = 7 значащих цифр

РЕДАКТИРОВАТЬ 2

В ответ на комментарий Конрада Рудольфа , пункт № 1 (выше) определенно правильный. Агрегация неточности действительно усугубляет. Посмотрите код ниже для примера:

private const float THREE_FIFTHS = 3f / 5f;
private const int ONE_MILLION = 1000000;

public static void Main(string[] args)
{
    Console.WriteLine("Three Fifths: {0}", THREE_FIFTHS.ToString("F10"));
    float asSingle = 0f;
    double asDouble = 0d;
    decimal asDecimal = 0M;

    for (int i = 0; i < ONE_MILLION; i++)
    {
        asSingle += THREE_FIFTHS;
        asDouble += THREE_FIFTHS;
        asDecimal += (decimal) THREE_FIFTHS;
    }
    Console.WriteLine("Six Hundred Thousand: {0:F10}", THREE_FIFTHS * ONE_MILLION);
    Console.WriteLine("Single: {0}", asSingle.ToString("F10"));
    Console.WriteLine("Double: {0}", asDouble.ToString("F10"));
    Console.WriteLine("Decimal: {0}", asDecimal.ToString("F10"));
    Console.ReadLine();
}

Это выводит следующее:

Three Fifths: 0.6000000000
Six Hundred Thousand: 600000.0000000000
Single: 599093.4000000000
Double: 599999.9999886850
Decimal: 600000.0000000000

Как вы можете видеть, даже если мы добавляем из одной и той же исходной константы,

Используйте двойное число или число с плавающей точкой, когда вам не нужна точность, например, в написанной мной платформерной игре я использовал число с плавающей точкой для хранения скоростей игрока. Очевидно, мне здесь не нужна сверхточность, потому что я в итоге округляю Int для рисования на экране.