Is there a way to do 'correct' arithmetical rounding in .NET? / C#

Question

I'm trying to round a number to it's first decimal place and, considering the different MidpointRounding options, that seems to work well. A problem arises though when that number has sunsequent decimal places that would arithmetically affect the rounding.

An example:

With 0.1, 0.11..0.19 and 0.141..0.44 it works:

Math.Round(0.1, 1) == 0.1
Math.Round(0.11, 1) == 0.1
Math.Round(0.14, 1) == 0.1
Math.Round(0.15, 1) == 0.2
Math.Round(0.141, 1) == 0.1

But with 0.141..0.149 it always returns 0.1, although 0.146..0.149 should round to 0.2:

Math.Round(0.145, 1, MidpointRounding.AwayFromZero) == 0.1
Math.Round(0.146, 1, MidpointRounding.AwayFromZero) == 0.1
Math.Round(0.146, 1, MidpointRounding.ToEven) == 0.1
Math.Round(0.146M, 1, MidpointRounding.ToEven) == 0.1M
Math.Round(0.146M, 1, MidpointRounding.AwayFromZero) == 0.1M

I tried to come up with a function that addresses this problem, and it works well for this case, but of course it glamorously fails if you try to round i.e. 0.144449 to it's first decimal digit (which should be 0.2, but results 0.1.) (That doesn't work with Math.Round() either.)

private double "round"(double value, int digit)
{
    // basically the old "add 0.5, then truncate to integer" trick
    double fix = 0.5D/( Math.Pow(10D, digit+1) )*( value >= 0 ? 1D : -1D );
    double fixedValue = value + fix;

    // 'truncate to integer' - shift left, round, shift right
    return Math.Round(fixedValue * Math.Pow(10D, digit)) / Math.Pow(10D, digit);
}

I assume a solution would be to enumerate all digits, find the first value larger than 4 and then round up, or else round down. Problem 1: That seems idiotic, Problem 2: I have no idea how to enumerate the digits without a gazillion of multiplications and subtractios.

Long story short: What is the best way to do that?

Answer 1

I don't get what you are trying to accomplish here. 0.149 rounded to one decimal place is 0.1, not 0.2

Answer 2

Math.Round() is behaving correctly.

When you're performing standard midpoint rounding, you never need to look beyond 1 decimal digit beyond where you are rounding to. If you are rounding to the nearest tenth, then you never need to look beyond the second digit after the decimal point.

The idea with midpoint rounding is that half of the in-between numbers should round up and half should round down. So for numbers between 0.1 and 0.2, half of them should round to 0.1 and half should round to 0.2. The midpoint between these two numbers is 0.15, so that's the threshold for rounding up. 0.146 is less than 0.15, therefore it must round down to 0.1.

                    Midpoint
0.10                  0.15                  0.20
 |----------------|----|---------------------|
                0.146
       <---- Rounds Down

Answer 3

Don't try and compound the rounding 'errors'. Which is what you're trying to do.

.146 should round down to .1 if you're going to one decimal place.

By rounding it to .15 first, then again to .2 you're just introducing more rounding error, not less.

Answer 4

Rounding is not an iterative process, you round only once.

So 0.146 rounded to 1 decimal digit is 0.1.

You don't do this:

0.146 --> 0.15
0.15 -->  0.2

You only do this:

0.146 --> 0.1

Otherwise, the following:

0.14444444444444446

would also round to 0.2, but it doesn't, and shouldn't.