🚀 go-pugleaf

Rene,
Java is NOT "wrong" for showing 0.9999... rather than 1.0  It does that
because 0.999... _is_ a closer representation than 1.0

As a programmer you have to know the limitations of your tools and when
(not) to use what technique.

The automatic rounding you're proposing causes a real nasty situation.
It's the one where your client says "your program's calculations are
wrong", and then shows you a report or screen where the detail amounts
shown add up to an total amount that is slightly out from the total your
report/screen shows.

The problem being, of course, that the report/screen shows rounded
amounts, but in your total calculation uses the calculated (not-rounded)
amount.

The answer is:  dont use float or doubles for money amounts.  Use an
integer type (e.g. long or string) and carry no more decimal places than
you show on output.

-------------
Rene wrote:
> 
> On Tue, 09 Mar 1999 19:37:11 GMT, Rick Stabile
> <stabilpa@my-dejanews.com> wrote:
> 
> >Am I not getting something here? I tried this in PowerJ and my result was
> >0.1. In any case, I could understand a result of 0.0999999999998, or even
> >0.999999999998E-01 -- it's floating point arithmetic and this sort of result
> >is to be expected. But did the author of this post simply make a typo that no
> >one else mentioned, or is his result really an order of magnitude too large
> 
> The output of JDK 1.1.7 on Windows is
> 
> 0.09999999999999998
> 
> which is problably correct in terms of IEEE floating point
> specification. You get the same result with format %0.17f in C.
> However, using %g rounds to 0.1 as expected.
> 
> The result is surprising, because 0.1 does not seem to equal 0.3-0.2,
> which can be checked by 0.3-0.2==0.1 (resulting in false). This is
> again correct with proper rounding in base 2.
> 
> To learn the core of the problem, try
> 
> public class Test
> {       static public void main (String args[])
>         {       double x=2;
>                 for (int i=0; i<100; i++)
>                 {       System.out.println(i+" "+(1.0-x)+" "+((1.0-x)==1.0));
>                         x=x/2;
>                 }
>         }
> }
> 
> You will see that Java uses a 54 bit binary arithmetic. The output
> routine will not round 0.9999999999999999 to 1.0, which needs to be
> considered. If you think about it, we need to represent 1-2^(-53) in
> decimal. This is .999999999999999888977697537484 correct to 29 places.
> There are 15 9ers. Wether or not this should print as 1.0 is somewhat
> a matter of convention. In my opinion, it should and Java is wrong
> here (as well as C), because the closest representation is 1.0.
> 
> The other question is how to get a decent output of double numbers in
> Java. This can be done with the NumberFormatters of JDK 1.1.

-- 
Frans van Duinen     (416) 652-8085
Master Programmer Group Inc.
Toronto, Ont.