Why is using a non-decimal data type bad for money?

Question

tl; dr: What happened to my Cur (currency) structure?

tl; dr 2: Read the rest of the question before giving an example with float or double . double

---

I know that this question has arisen many times earlier than anything else on the Internet, but I have not yet seen a convincing answer, so I thought I would ask again.

I do not understand why using a non-decimal data type is bad for processing money. (This applies to data types that store binary digits instead of decimal digits.)

True, it is impractical to compare two double with a == b . But you can easily say a - b <= EPSILON or something like that.

What is wrong with this approach?

For example, I just did a struct in C #, which I believe handles money correctly without using any data formats based on decimals:

 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"); } } 

(Sorry for changing the Currency name to Cur , for poor variable names, for public exceptions, and for poor layout, I tried putting all of this on the screen so you can read it without scrolling.) :)

You can use it like:

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

Of course, C # has a decimal data type, but that’s the point here - the question is why it is dangerous and not why we should not use decimal .

So could someone give me a real counterexample from a dangerous statement that would not work for this in C #? I can’t come up with.

Thanks!

---

Note. I am not discussing whether decimal good choice. I ask why a binary system is considered inappropriate.

Answer 1

Floats are not stable for the accumulation and reduction of funds. Here is your actual example:

 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"); } } } 

In my field, this gives 4,000,000,000,000,0203 accumulated versus 400,0002,000 expected in C #. This is a bad deal, if it gets lost in many transactions in the bank - it should not be large, just many. Does it help?

Answer 2

Typically, monetary calculations require accurate results, not just accurate results. float and double cannot accurately represent the entire range of real numbers of base 10. For example, 0.1 cannot be represented by a floating point variable. What will be stored is the closest representable value, which may be a number, for example 0.0999999999999999996. Try it yourself by doing a unit check of your structure - for example, try 2.00 - 1.10 .

Answer 3

I'm not sure why you dismiss J Trana's answer as inconsequential. Why don't you give it a try? The same example works with your structure. You just need to add a few extra iterations because you use double instead of float, which gives you a bit more precision. It just delays the problem, does not get rid of it.

Evidence:

 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"); } } 

Result:

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

We are only up to 0.8 cents, but in the end it will add up.

---

Your edit:

  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"); } } 

Prints $ 0.

Answer 4

Mehrdad, I don’t think I can convince you if I bring the whole SEC. Now your whole class basically implements BigInteger arithmetic with an implied shift of 2 decimal places. (There should be at least 4 for accounting, but we can easily change 2-4.)

What advantage do we support with this class using double instead of BigDecimal (or longlong if something like this is available)? For the benefit of the primitive type, I pay for expensive rounding operations. And I also cry with inaccuracies. [Example from here 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)); } } 

OK, here we support float instead of double, but should it not be a warning sign of BIG that the whole concept is wrong and that we may have problems if we have to do millions of calculations?

Every finance professional thinks that introducing floating point money is a bad idea. (See, Among dozens of hits, http://discuss.joelonsoftware.com/default.asp?design.4.346343.29 .) Most likely: are they all stupid or is floating point money really a bad idea?

Answer 5

 Cur c = 0.00015; System.Console.WriteLine(c); // rounds to 0.0001 instead of the expected 0.0002 

The problem is that 0.00015 in the binary is indeed 0.00014999999999999998685946966947568625982967205345630645751953125, which is rounded, but the exact decimal value is rounded.