surprising double comparison

Question

I have messed with code execution result.

code:

System.out.println(0.2==0.1+0.1);
System.out.println(0.3==0.1+0.1+0.1);

output:

true
false

I know that 0.2 and 0.3 cannot transform to binary correct.

Why do I see different results?

UPDATE:

Can I predict result in similar issues without compiler?

please read the [link](http://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html) that @nr4bt posted. This is a *complex* topic that every programmer should be aware of. — roippi, Jan 25 '14 at 16:55
herohuyongtao, I believe you. I want to be posible to predict result — gstackoverflow, Jan 25 '14 at 17:00
Sure you can predict it. But it is easier to use a calculator, as you probably cannot do binary IEEE conformant arithmetic in your head. — Ingo, Jan 25 '14 at 17:19

Orhan Obut · Answer 1 · 2014-01-25T17:13:19.887

9

System.out.println(0.1+0.1+0.1);

output

0.30000000000000004

There is a rounding error on floating point arithmetics. Some values are can not be represented in base 2, you can't rely on comparing float numbers. 0.1 in base-2 is like 1/3 in base-10.

You can see the link below

What Every Computer Scientist Should Know About Floating-Point Arithmetic

edited Jan 25 '14 at 17:13

answered Jan 25 '14 at 16:34

Orhan Obut

8,756
5
32
42

I was about to add a comment that this was probably it. – Jan 25 '14 at 16:35
2

Why ok for `0.1+0.1`? – herohuyongtao Jan 25 '14 at 16:36
Each time you perform an additional calculation with floats, you get more and more error in the answer. When you added just 2 floats, the error wasn't large enough to be considered !=. – takendarkk Jan 25 '14 at 16:47
@Takendarkk I cannot buy it. Check out `0.4==0.1+0.1+0.1+0.1`, it' true. – herohuyongtao Jan 25 '14 at 16:51
@herohuyongtao Interesting. That was definitely _not_ what I was expecting. I'm looking into it. – takendarkk Jan 25 '14 at 16:52
Offtopic, put OP please don't accept all suggested edits... I hate roboreviewers! – TN888 Mar 01 '14 at 09:58

score 2 · Answer 2 · answered Jan 25 '14 at 16:51

2

What you see is the fact that floating point values are not very accurate and you should not for example compare them using == operator. For comparisons you should use epsilon compares, ie. for two floating point values f1 and f2

if  (Math.abs(f1 - f2) < EPSILON ) {
   // they are equal
}

Where EPSILON is some very small floating point value

answered Jan 25 '14 at 16:51

marcinj

48,511
9
79
100

... Where EPSILON is some very small floating point value _reflecting the necessary precision in the comparison but not less than this_ – Axel Amthor Jan 25 '14 at 16:53

score 0 · Accepted Answer · answered Jan 25 '14 at 16:44

0

PHP gave this:

<?php

printf("%0.20f\n", 0.1+0.1);
printf("%0.20f\n", 0.1+0.1+0.1);

?>
0.20000000000000001110
0.30000000000000004441

and

<?php
  echo 0.2==0.1+0.1?"true\n":"false\n";
  echo 0.3==0.1+0.1+0.1?"true\n":"false\n";
?>
true
false

The reaseon for the first to be "true":

<?php
   printf("%0.20f\n", 0.1+0.1);
   printf("%0.20f\n", 0.1+0.1+0.1);
   echo "\n";
   printf("%0.20f\n", 0.2);
   printf("%0.20f\n", 0.3);
?>

Output

0.20000000000000001110
0.30000000000000004441

0.20000000000000001110
0.29999999999999998890

answered Jan 25 '14 at 16:44

Axel Amthor

10,980
1
25
44

nr4bt explained why *System.out.println(0.3==0.1+0.1+0.1)* returns false. but I have not answer why *System.out.println(0.2==0.1+0.1)* return true – gstackoverflow Jan 25 '14 at 16:47
According your results - it is very very strange – gstackoverflow Jan 25 '14 at 16:47
about your update: Can I predict result without compiler? – gstackoverflow Jan 25 '14 at 16:58
No, It's in the nature of floating point values and regardless what language you have, results are unpredictable to some extent. Either you set up a comparison routine which will compare exponent and mantissa as integers and separately or you go with @marcin_j ' s solution – Axel Amthor Jan 25 '14 at 17:05
it is *Double* - not float – gstackoverflow Jan 25 '14 at 17:11

score 0 · Answer 4 · answered Jan 25 '14 at 16:59

You cannot rely on == to work well for float numbers, whose results are undependable because they cannot be represented accurately on computers. When you want to check two float numbers equal or not, use fabs(a-b) < epsilon instead.

P.S. The following test are under C++, which gives surprising results (just for fun to show how un-dependable it is):

cout << (0.1==0.1) << endl;                                // true
cout << (0.2==0.1+0.1) << endl;                            // true
cout << (0.3==0.1+0.1+0.1) << endl;                        // false
cout << (0.4==0.1+0.1+0.1+0.1) << endl;                    // true
cout << (0.5==0.1+0.1+0.1+0.1+0.1) << endl;                // true
cout << (0.6==0.1+0.1+0.1+0.1+0.1+0.1) << endl;            // true
cout << (0.7==0.1+0.1+0.1+0.1+0.1+0.1+0.1) << endl;        // true        
cout << (0.8==0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1) << endl;    // false

surprising double comparison

4 Answers4