.NET Math.Round（<double>，<int>，MidpointRounding.AwayFromZero）无法正常工作

Question

I am using Visual Studio Professional 2012. I created a new C# ConsoleApplication, targeting .NET Framework 4.5, with following code:

    static void Main(string[] args)
    {
        double x = 2.44445;
        double y = Math.Round(x, 4, MidpointRounding.AwayFromZero);
        Console.WriteLine(y);
        Console.ReadKey();
    }

The expected result should be 2.4445, but it actually returns 2.4444. //Same result with previous framework version, and I tried VCE2010.

I know such problem usually results from the way double data type is stored (ie finite decimals converted to infinite binary fraction). But I didn't expect this to happen with only 5 decimal digits like 2.44445

I'm worrying if such thing could happen with even shorter decimals. I would also like to learn a safer way to round (using away from zero convention) in C#. Thanks.

Answer 1

This is indeed due to the fragile precision of floating-point numbers. 0.5 can be stored perfectly in IEEE floating point, but 0.45, 0.445 etc. cannot. For example, the actual value that is stored when you specify 2.44445 is 11009049289107177/4503599627370496 which is 2.44449999999999989519494647... It should now be obvious why the number is rounded the way it is.

If you need to store fractional numbers precisely, consider using the decimal type instead.

Answer 2

Notes from msdn :

Because of the loss of precision that can result from representing decimal values as floating-point numbers or performing arithmetic operations on floating-point values, in some cases the Round(Double, Int32, MidpointRounding) method may not appear to round midpoint values as specified by the mode parameter. This is illustrated in the following example, where 2.135 is rounded to 2.13 instead of 2.14. This occurs because internally the method multiplies value by 10digits, and the multiplication operation in this case suffers from a loss of precision .

This is how Round implemented:

double num = roundPower10Double[digits];
value *= num;
if (mode == MidpointRounding.AwayFromZero)
{
    double num2 = SplitFractionDouble(&value);
    if (Abs(num2) >= 0.5)
    {
        value += Sign(num2);
    }
}

As you can see, value is multiplied by num, which is a value from

roundPower10Double = new double[] { 1.0, 10.0, 100.0, 1000.0, 10000.0, 
      100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0, 10000000000,  
      100000000000, 1000000000000, 10000000000000, 100000000000000, 1E+15 };    

So, actually you have 2.44445 * 10000.0 - 24444,0 which gives 0,499999999996362 . Which is less than 0.5 . Thus you have 2.4444 .