This is not specific to Java. This has to do with the way doubles are
stored in memory, and the way they are rounded before display.

The short answer: A computer cannot precisely represent a decimal
number. Therefore, it is forced to round off all of decimals. The
0.399999999 here is an example of where it was forced to round off.

The long answer: Java's default Double.toString(double) (how it converts
a double to a string) does some voodoo magic that prints out "0.2" when
the internal representation is equal to what 0.2 would be. Since the
decimal number has an infinite binary expansion, the computer rounds off
the number. When it adds 0.2 to that number, the round off (it appears
to be down here) is accumulated twice and the number is off, I believe,
by one ulp: the last binary digit in the representation is incorrect
(guesswork there).

Whenever one works with floating-point numbers on computers, one should
always have tolerance guards. A double has 52 bits of significance --
about 15 to 16 correct significant figures, although the last few may
have some accumulated round-off error. In a strictfp method/class, all
arithmetic is done in those 52 bits; otherwise, it may use the
computer's extended precision if available (Intel uses an 80-bit fp
number, which should give another dozen or so significant bits).

To limit the printout of these numbers, one can use:

System.out.printf("%.5d\n",i); // Java 5+

which prints the decimal digit to 5 decimal places.

That is how floating point works.

Floating point is intended for measurements with a bit
of inaccuracy.

You may have 0.4 km from your home to your children's school.

But it is not really wrong to say that there is 0.399999999 km.

On the other hand if you are doing accounting, then your auditor
prefer all calculations to be exact.

Try read an introduction like:
  http://www.lahey.com/float.htm

Arne

 Finite Sums of Dual fractions, as used by »double«, can not
 represent all decimal fractions precisely. The output
 sometimes is beautified, so that one can not always see this.
 But one can see it in:

public class Main
{ public static void main( final java.lang.String[] args )
 { java.lang.System.out.println( new java.math.BigDecimal(  0.1 ));
   java.lang.System.out.println( new java.math.BigDecimal( "0.1" )); }}

0.1000000000000000055511151231257827021181583404541015625
0.1

 See also

http://docs.sun.com/source/806-3568/ncg_goldberg.html

It is indeed amazing. When I run a program containing your code:

public class DoubleRounding {
  public static void main(String[] args) {
    for (double i = 0; i<1; i=i+0.2)
      System.out.println (i);
  }
}

I get:

0.0
0.2
0.4
0.6000000000000001
0.8

which has only the degree of rounding error I would expect from double.

0.399999999, as the result of two additions of 0.2, would imply much
bigger rounding errors than you should get with double.

Are you sure the output came from exactly the code you posted?

Patricia

You have to realize that 0.2 (and most of its multiples) are not
machine (JVM) numbers in that there are represented as is.  In fact,
you can construct examples like .2 + .2 != .4 in Java due to this
(this concrete example might not work, but something along the lines
can be constructed).

Printing such numbers is therefore not as trivial as it seems.  See
the javadoc description of Double.toString to see how it is solved.
By carefully calculating the steps mentioned, you will recover your
output.  That doesn't make it intuitive, though:-)

Basically, .399999999 represents .2+.2 (whatever they represent in
java code...) when printed, while .4 represents another number close
by when printed.

Michael

This question comes up entirely too often.  Computer arithmetic is
*not* what you learned in school.

Please read:

David Goldberg, "What Every Computer Scientist Should Know About
Floating-Point Arithmetic"
http://perso.ens-lyon.fr/jean-michel.muller/goldberg.pdf

and for more information see

http://montcs.bloomu.edu/~bobmon/Information/IEEE-754.shtml

George
--
for email reply remove "/" from address

    No.  I've tried your code on two different Java
versions on two different processor architectures, and
I get the same result Patricia Shanahan reports:

...

Only amazing if you are not used to it.  ;-)

(Looking at some of the earlier replies) Apparently.

Since they have already explained much, I will
simply add..

<sscce>
import java.text.DecimalFormat;

class NumberTest {
 public static void main(String[] args) {
   DecimalFormat format = new DecimalFormat("0.0");
   for (double i = 0; i<1; i+=0.2) {
     System.out.println (i);
     // get a 'user friendly' representation.
     System.out.println ("Value:\t" + format.format(i));
   }
 }
}
</sscce>

<output>
0.0
Value:  0.0
0.2
Value:  0.2
0.4
Value:  0.4
0.6000000000000001
Value:  0.6
0.8
Value:  0.8
</output>

HTH

On Sun, 9 Dec 2007 11:10:38 -0800 (PST), jorgeba
<jorgemarcc@gmail.com> wrote, quoted or indirectly quoted someone who
said :

It is one of the most commonly asked questions.  See
http://mindprod.com/jgloss/floatingpoint.html

On Sun, 9 Dec 2007 11:10:38 -0800 (PST), jorgeba
<jorgemarcc@gmail.com> wrote, quoted or indirectly quoted someone who
said :

What version of Java are you using? What hardware are you running it
on?

Could you also post your complete code.