Decimal rounding errors upon division (C#)

5
votes

I have basically four numbers (say 100, 200, 300, 400), and I need to calculate the probability as 100/(100+200+300+400), 200/(100+200+300+400), and so on.

When I use the decimal data type to store these probabilities, they don't up to one due to round issues. What's the best way to past this without making the probabilities too inaccurate? Basically I do this calculation many many times, so I don't want to have to change all the divisions into Math.Round stuff. :|

2
c#decimalroundingfloating-accuracy
Are you sure you are using decimial? That should be exact as decimal.... You aren't perhaps using double, or using a literal such as 1.0 (which should be 1.0M to mean decimal) - Marc Gravell
Post your code that would make this issue relevant to us. - V4Vendetta
If you want to preserve exactness, look at a 'fraction' class/struct. - leppie
I am using decimal. Here's an example of my code: probabilities[i, j] = ((decimal)Count[i, j]) / ((decimal)(NUMBER_OF_TIMESTEPS - numberOfTimestepsToSkip)); The double array probabilities is decimal type. - Matt
@Matt, @Marc: Matt, your example is accidentally misleading; since the denominators add up to 1000, a power of ten, Marc is right; that will be represented exactly by a decimal. If you have different denominators that do not add up to a power of ten then you will get rounding error, since decimals always round off to something that is representable by a decimal. - Eric Lippert

2 Answers

7
votes

The solution is straightforward: if it hurts when you do that then don't do that.

If you have rational probabilities, that is, probabilities that are ratios of whole numbers, and you want them to add to exactly one, then don't convert them to decimal or double in the first place. Use an arbitrary-precision rational type to represent your arbitrary precision rationals.

There's an arbitrary-precision rational type included with Microsoft Solver Foundation; you could download and use that. Or, it is easy to write your own by simply making an immutable struct that has two BigIntegers for the numerator and denominator, and then write implementations of the operators you need.

1
votes

There is no call to Math.Round that will resolve this the way you want. The issue is that all of the roundings must work together - ie. have awareness that individually they are all right but viewed together they are wrong.

One way to deal with rounding error of division, is to adjust the values to accomodate it:

List<decimal> decimals = new List<decimal>() { 100m, 200m, 300m, 300m };
decimal total = decimals.Sum();

List<decimal> probabilities = decimals.Select(x => x / total).ToList();
decimal sum = probabilities.Sum();
decimal error = 1.0m - sum;
Console.WriteLine("{0}, {1}", sum, error);

probabilities[0] += error; //put all of the error into the first item.
decimal newSum = probabilities.Sum();

Console.WriteLine(newSum);

More sophisticated approaches spread the error over the values. For example, spreading 0.0000000000000000000000000004 over 4 values instead of 1.