The trouble with rounding floating point numbers

[Tim McGuire]

I read Trouble with rounding floating point numbers. In the comments section, a couple of people are complaining about "newer, fadish languages like java" that don't have decimal types.

The article supplies some C code that highlights floating point precision errors and I tried those with floats in Java. Seems like you can't add 1/3f and 2/3f and get 1.

I also tried them using BigDecimal and they all seemed to work out OK. So, is the answer to that article "Use BigDecimal" ??

[marc weber]

Originally posted by Tim McGuire:
...is the answer to that article "Use BigDecimal" ??

This article is just an introduction. Note the last paragraph...

More important, perhaps, how do we avoid this problem? In a follow-up article I'm going to look at a different way of doing arithmetic (decimal arithmetic), used by lots of real world software, that avoids the approximation error in floats.

Yes, one "answer" in Java is BigDecimal.

But as far as some of the comments posted in response to this article... :roll:

[Tim McGuire]

ok. thank you Marc.

Java seems to handle the following example from the article OK:

// doCalc is a function that takes a euro price and a percent margin 
// and returns the result of applying margin to the price.  In the call 
// below the result should be �66.375� � Eur59.00 + 12.5% of 59
void test() {
    // As it�s a price we�re interested in 2 decimal places. Our 
    // rounding algorithm will look at third decimal place and round 
    // according to its value.  We expect this to round 66.375 to a 
    // result of Eur66.38
    float price = doRateCalc("59.00", "12.5"); 
 
    // However: our value is represented approximately and could be 
    // anywhere in the range of, lets say, 66.3749999999999 to
    // 66.37500000000000000001.  If the approximation is at the bottom
    // of this range then we will round to 66.37 otherwise we will round
    // to 66.38
}

I wonder why java does not suffer from precision problems in this case? i.e. it returns 66.375 like expected.

[Campbell Ritchie]

Java does suffer from floating-point precision problems. Oh yes it does. The double type is much less prone to that problem than the float type, but both can show imprecision. And we aren't really discussing C here, but remember that C has different compilers so a C app can produce different results on different compilers. I tried it recently because of this beginners' forum discussion.

Try repeating the exercise with "strictfp" in your method heading, see whether that makes any difference. Again this is a topic which came up recently on the JIG beginners' forum.

[Ulf Dittmer]

The JavaBeginnersFaq has links to some further reading on the subject, under #21.

[Ilja Preuss]

Originally posted by Tim McGuire:

I wonder why java does not suffer from precision problems in this case? i.e. it returns 66.375 like expected.

Java might suffer from the problem, depending on the platform you are running on. Only when you use strictfp it will be guaranteed to run exactly identically on every platform.