Почему использование не-десятичного типа данных плохо для денег? - PullRequest
Новая
       43

Почему использование не-десятичного типа данных плохо для денег?

8 голосов
/ 24 апреля 2011

tl; др: Что не так с моей Cur (валютой) структурой?

tl; др 2: Прочитать остальную частьвопрос, прежде чем привести пример с float или double. : -)

Я знаю, что этот вопрос неоднократно возникал раньше, чем во всем Интернете, но Я еще не видел убедительного ответа , поэтому я решил спросить еще раз.

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

Правда, сравнивать два double с a == b нецелесообразно.Но вы можете легко сказать a - b <= EPSILON или что-то в этом роде.

Что не так с этим подходом?

Например, я только что сделал struct в C #я считаю, что обрабатывает деньги правильно, без использования каких-либо десятичных форматов данных: 

struct Cur
{
  private const double EPS = 0.00005;
  private double val;
  Cur(double val) { this.val = Math.Round(val, 4); }
  static Cur operator +(Cur a, Cur b) { return new Cur(a.val + b.val); }
  static Cur operator -(Cur a, Cur b) { return new Cur(a.val - b.val); }
  static Cur operator *(Cur a, double factor) { return new Cur(a.val * factor); }
  static Cur operator *(double factor, Cur a) { return new Cur(a.val * factor); }
  static Cur operator /(Cur a, double factor) { return new Cur(a.val / factor); }
  static explicit operator double(Cur c) { return Math.Round(c.val, 4); }
  static implicit operator Cur(double d) { return new Cur(d); }
  static bool operator <(Cur a, Cur b) { return (a.val - b.val) < -EPS; }
  static bool operator >(Cur a, Cur b) { return (a.val - b.val) > +EPS; }
  static bool operator <=(Cur a, Cur b) { return (a.val - b.val) <= +EPS; }
  static bool operator >=(Cur a, Cur b) { return (a.val - b.val) >= -EPS; }
  static bool operator !=(Cur a, Cur b) { return Math.Abs(a.val - b.val) < EPS; }
  static bool operator ==(Cur a, Cur b) { return Math.Abs(a.val - b.val) > EPS; }
  bool Equals(Cur other) { return this == other; }
  override int GetHashCode() { return ((double)this).GetHashCode(); }
  override bool Equals(object o) { return o is Cur && this.Equals((Cur)o); }
  override string ToString() { return this.val.ToString("C4"); }
}

(извините за изменение имени Currency на Cur, за плохие имена переменных, за пропуск public и из-за плохой разметки; я попытался разместить все это на экране, чтобы вы могли читать его без прокрутки.):)

Вы можете использовать его так: 

Currency a = 2.50;
Console.WriteLine(a * 2);

Конечно, C # имеет тип данных decimal, но это не относится к этому вопросу - вопрос в том, почему вышеописанное опасно, а не в том, почему мы не должны использовать decimal.

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

Спасибо!

Примечание: я не обсуждаю, является ли decimal хорошимвыбор.Я спрашиваю, почему двоичная система считается неуместной.

Ответы [ 5 ]

10 голосов
/ 24 апреля 2011

Поплавки не стабильны для накопления и уменьшения средств.Вот ваш реальный пример: 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace BadFloat
{
    class Program
    {
        static void Main(string[] args)
        {
            Currency yourMoneyAccumulator = 0.0d;
            int count = 200000;
            double increment = 20000.01d; //1 cent
            for (int i = 0; i < count; i++)
                yourMoneyAccumulator += increment;
            Console.WriteLine(yourMoneyAccumulator + " accumulated vs. " + increment * count + " expected");
        }
    }

    struct Currency
    {
        private const double EPSILON = 0.00005;
        public Currency(double value) { this.value = value; }
        private double value;
        public static Currency operator +(Currency a, Currency b) { return new Currency(a.value + b.value); }
        public static Currency operator -(Currency a, Currency b) { return new Currency(a.value - b.value); }
        public static Currency operator *(Currency a, double factor) { return new Currency(a.value * factor); }
        public static Currency operator *(double factor, Currency a) { return new Currency(a.value * factor); }
        public static Currency operator /(Currency a, double factor) { return new Currency(a.value / factor); }
        public static Currency operator /(double factor, Currency a) { return new Currency(a.value / factor); }
        public static explicit operator double(Currency c) { return System.Math.Round(c.value, 4); }
        public static implicit operator Currency(double d) { return new Currency(d); }
        public static bool operator <(Currency a, Currency b) { return (a.value - b.value) < -EPSILON; }
        public static bool operator >(Currency a, Currency b) { return (a.value - b.value) > +EPSILON; }
        public static bool operator <=(Currency a, Currency b) { return (a.value - b.value) <= +EPSILON; }
        public static bool operator >=(Currency a, Currency b) { return (a.value - b.value) >= -EPSILON; }
        public static bool operator !=(Currency a, Currency b) { return Math.Abs(a.value - b.value) <= EPSILON; }
        public static bool operator ==(Currency a, Currency b) { return Math.Abs(a.value - b.value) > EPSILON; }
        public bool Equals(Currency other) { return this == other; }
        public override int GetHashCode() { return ((double)this).GetHashCode(); }
        public override bool Equals(object other) { return other is Currency && this.Equals((Currency)other); }
        public override string ToString() { return this.value.ToString("C4"); }
    }

}

На моем боксе это дает 4 000 002 000,0203 накопленных против 400 0002 000, ожидаемых в C #.Это плохая сделка, если она теряется из-за многих транзакций в банке - она ​​не должна быть крупной, просто много.Это помогает?

4 голосов
/ 24 апреля 2011

Я не уверен, почему ты игнорируешь ответ J Trana как несущественный.Почему бы тебе не попробовать это самому?Тот же пример работает и с вашей структурой.Вам просто нужно добавить пару дополнительных итераций, потому что вы используете double, а не float, что дает вам немного больше точности.Просто задерживает проблему, не избавляется от нее.

Доказательство: 

class Program
{
    static void Main(string[] args)
    {
        Currency currencyAccumulator = new Currency(0.00);
        double doubleAccumulator = 0.00f;
        float floatAccumulator = 0.01f;
        Currency currencyIncrement = new Currency(0.01);
        double doubleIncrement = 0.01;
        float floatIncrement = 0.01f;

        for(int i=0; i<100000000; ++i)
        {
            currencyAccumulator += currencyIncrement;
            doubleAccumulator += doubleIncrement;
            floatAccumulator += floatIncrement;
        }
        Console.WriteLine("Currency: {0}", currencyAccumulator);
        Console.WriteLine("Double: {0}", doubleAccumulator);
        Console.WriteLine("Float: {0}", floatAccumulator);
        Console.ReadLine();
    }
}

struct Currency
{
    private const double EPSILON = 0.00005;
    public Currency(double value) { this.value = value; }
    private double value;
    public static Currency operator +(Currency a, Currency b) { return new Currency(a.value + b.value); }
    public static Currency operator -(Currency a, Currency b) { return new Currency(a.value - b.value); }
    public static Currency operator *(Currency a, double factor) { return new Currency(a.value * factor); }
    public static Currency operator *(double factor, Currency a) { return new Currency(a.value * factor); }
    public static Currency operator /(Currency a, double factor) { return new Currency(a.value / factor); }
    public static Currency operator /(double factor, Currency a) { return new Currency(a.value / factor); }
    public static explicit operator double(Currency c) { return System.Math.Round(c.value, 4); }
    public static implicit operator Currency(double d) { return new Currency(d); }
    public static bool operator <(Currency a, Currency b) { return (a.value - b.value) < -EPSILON; }
    public static bool operator >(Currency a, Currency b) { return (a.value - b.value) > +EPSILON; }
    public static bool operator <=(Currency a, Currency b) { return (a.value - b.value) <= +EPSILON; }
    public static bool operator >=(Currency a, Currency b) { return (a.value - b.value) >= -EPSILON; }
    public static bool operator !=(Currency a, Currency b) { return Math.Abs(a.value - b.value) <= EPSILON; }
    public static bool operator ==(Currency a, Currency b) { return Math.Abs(a.value - b.value) > EPSILON; }
    public bool Equals(Currency other) { return this == other; }
    public override int GetHashCode() { return ((double)this).GetHashCode(); }
    public override bool Equals(object other) { return other is Currency && this.Equals((Currency)other); }
    public override string ToString() { return this.value.ToString("C4"); }
}

Результат: 

Currency: $1,000,000.0008
Double: 1000000.00077928
Float: 262144

У нас всего 0,08 цента, но со временем это сложится.

Ваше редактирование: 

    static void Main(string[] args)
    {
        Currency c = 1.00;
        c /= 100000;
        c *= 100000;
        Console.WriteLine(c);
        Console.ReadLine();
    }
}

struct Currency
{
    private const double EPS = 0.00005;
    private double val;
    public Currency(double val) { this.val = Math.Round(val, 4); }
    public static Currency operator +(Currency a, Currency b) { return new Currency(a.val + b.val); }
    public static Currency operator -(Currency a, Currency b) { return new Currency(a.val - b.val); }
    public static Currency operator *(Currency a, double factor) { return new Currency(a.val * factor); }
    public static Currency operator *(double factor, Currency a) { return new Currency(a.val * factor); }
    public static Currency operator /(Currency a, double factor) { return new Currency(a.val / factor); }
    public static Currency operator /(double factor, Currency a) { return new Currency(a.val / factor); }
    public static explicit operator double(Currency c) { return Math.Round(c.val, 4); }
    public static implicit operator Currency(double d) { return new Currency(d); }
    public static bool operator <(Currency a, Currency b) { return (a.val - b.val) < -EPS; }
    public static bool operator >(Currency a, Currency b) { return (a.val - b.val) > +EPS; }
    public static bool operator <=(Currency a, Currency b) { return (a.val - b.val) <= +EPS; }
    public static bool operator >=(Currency a, Currency b) { return (a.val - b.val) >= -EPS; }
    public static bool operator !=(Currency a, Currency b) { return Math.Abs(a.val - b.val) < EPS; }
    public static bool operator ==(Currency a, Currency b) { return Math.Abs(a.val - b.val) > EPS; }
    public bool Equals(Currency other) { return this == other; }
    public override int GetHashCode() { return ((double)this).GetHashCode(); }
    public override bool Equals(object o) { return o is Currency && this.Equals((Currency)o); }
    public override string ToString() { return this.val.ToString("C4"); }
}

Печать $ 0.

4 голосов
/ 24 апреля 2011

Обычно денежные расчеты требуют точных результатов, а не только точных результатов.Типы float и double не могут точно представлять весь диапазон 10 основных чисел.Например, 0.1 не может быть представлено переменной с плавающей точкой.То, что будет сохранено, является ближайшим представимым значением, которое может быть числом, таким как 0.0999999999999999996.Попробуйте сами, юнит-тестирование вашей структуры - например, попытка 2.00 - 1.10.

2 голосов
/ 24 апреля 2011

Mehrdad, я не думаю, что смогу убедить вас , если бы я принес весь SEC. Теперь весь ваш класс в основном реализует арифметику BigInteger с подразумеваемым сдвигом в 2 десятичных знака. (Для целей бухгалтерского учета должно быть не менее 4, но мы можем легко изменить 2 на 4.)

Какое преимущество у нас есть поддержка этого класса с двойным вместо BigDecimal (или длинным, если что-то подобное доступно)? За преимущество примитивного типа я расплачиваюсь дорогими операциями округления. И я тоже плачу с неточностями. [Пример отсюда 1 ] 

import java.text.*;

public class CantAdd {
   public static void main(String[] args) {
      float a = 8250325.12f;
      float b = 4321456.31f;
      float c = a + b;
      System.out.println(NumberFormat.getCurrencyInstance().format(c));
   }
}

Хорошо, здесь мы указали с плавающей точкой вместо двойного, но разве это не должно быть БОЛЬШИМ предупреждением о том, что вся концепция неверна и что у нас могут возникнуть проблемы, если нам придется делать миллионы вычислений? *

Каждый профессионал, работающий в сфере финансов, считает, что представление денег с плавающей запятой - плохая идея. (См. Среди десятков обращений http://discuss.joelonsoftware.com/default.asp?design.4.346343.29.) Что более вероятно: все они глупы или деньги с плавающей запятой действительно плохая идея?

0 голосов
/ 24 апреля 2011 
Cur c = 0.00015;
System.Console.WriteLine(c);
// rounds to 0.0001 instead of the expected 0.0002

Проблема в том, что 0.00015 в двоичном коде действительно равно 0,00014999999999999998685946966947568625982967205345630645751953125, которое округляет вниз , но точное десятичное значение округляет вверх .

...