CODEWITHSUNDEEP
c#mathfloating-pointdivision
cusimar9
cusimar9

Reputation: 5259

C# Maths gives wrong results!

I understand the principle behind this problem but it's giving me a headache to think that this is going on throughout my application and I need to find as solution.

double Value = 141.1;
double Discount = 25.0;
double disc = Value * Discount / 100; // disc = 35.275
Value -= disc; // Value = 105.824999999999999

Value = Functions.Round(Value, 2); // Value = 105.82

I'm using doubles to represent quite small numbers. Somehow in the calculation 141.1 - 35.275 the binary representation of the result gives a number which is just 0.0000000000001 out. Unfortunately, since I am then rounding this number, this gives the wrong answer.

I've read about using Decimals instead of Doubles but I can't replace every instance of a Double with a Decimal. Is there some easier way to get around this?

Upvotes: 2

Views: 6898

Answers (4)

cusimar9
cusimar9

Reputation: 5259

After spending most of the morning trying to replace every instance of a 'double' to 'decimal' and realising I was fighting a losing battle, I had another look at my Round function. This may be useful to those who can't implement the proper solution:

public static double Round(double dbl, int decimals) {            
        return (double)Math.Round((decimal)dbl, decimals, MidpointRounding.AwayFromZero);
    }

By first casting the value to a decimal, and then calling Math.Round, this will return the 'correct' value.

Upvotes: 0

Stewart
Stewart

Reputation: 4028

Instead of using Round to round the number, you could use some function you write yourself which uses a small epsilon when rounding to allow for the error. That's the answer you want.

The answer you don't want, but I'm going to give anyway, is that if you want precision, and since you're dealing with money judging by your example you probably do, you should not be using binary floating point maths. Binary floating point is inherently inaccurate and some numbers just can't be represented correctly. Using Decimal, which does base-10 floating point, would be a much better approach everywhere and will avoid you making costly mistakes with your doubles.

Upvotes: 0

David Heffernan
David Heffernan

Reputation: 612794

You should use decimal – that's what it's for.

The behaviour of floating point arithmetic? That's just what it does. It has limited finite precision. Not all numbers are exactly representable. In fact, there are an infinite number of real valued numbers, and only a finite number can be representable. The key to decimal, for this application, is that it uses a base 10 representation – double uses base 2.

Upvotes: 3

Jon Skeet
Jon Skeet

Reputation: 1499770

If you're looking for exact representations of values which are naturally decimal, you will need to replace double with decimal everywhere. You're simply using the wrong datatype. If you'd been using short everywhere for integers and then found out that you needed to cope with larger values than that supports, what would you do? It's the same deal.

However, you should really try to understand what's going on to start with... why Value doesn't equal exactly 141.1, for example.

I have two articles on this:

Upvotes: 17

Related Questions