is (0.1 + 0.2) == 0.3 true or false?

Question

I have a basic understanding in float-point number and was reading this article which says:

0.1 + 0.2: This equals 0.3, but in floating-point: (0.1 + 0.2) == 0.3 is false. This is because 0.1, 0.2 and 0.3 cannot be precisely represented in base 2 floating-point.

Well, that's true according to the nature of floating point number, but I wrote a simple program to test:

float a = 0.1;
float b = 0.2;

if(a+b == 0.3)
{
  printf("true");
} else 
{
  printf("false");
}
// result is true

but the output is actually true. Here is my two questions:

1. I think what happens is, because C uses the round-to-even rounding mode, so after rounding, it happens to be true, is my understanding correct?

2. If my understanding is correct, then there must be some specified float-point number won't be true in this case, because there is still a small chance that rounding might fail. So that must be some combination as

   float a = ...;
   float b = ...;
   if(a+b == XXX)  // where XXX is the "intuitive" sum of a and b
   {
     printf("true");
   } else 
   {
     printf("false");   
   }
   
   //result is false now
   

Is my understanding correct?

Answer 1

I get false for your program, not true as you indicate in your question. (0.3 is a double literal, so my guess is that when you tested this locally, you used a float variable instead of a 0.3 literal.) If you actually use float (== 0.3f instead of == 0.3), you get true as the output because it just so happens that with float, 0.1 + 0.2 == 0.3 is true.

But, the fundamental point remains that the IEEE-754 binary floating-point used by float (single-precision) and double (double-precision) is really fast to calculate and useful for lots of things, but inherently imprecise for some values, and so you get that kind of issue. With float, you get true for 0.1 + 0.2 == 0.3, but you get false for 0.1 + 0.6 == 0.7:

#include <stdio.h>

int main() {
    printf("%s\n", 0.1f + 0.6f == 0.7f ? "true" : "false"); // prints false
    //             ^^^^−−−^^^^−−−−^^^^−−− `float` literals
    return 0;
}

The famous 0.1 + 0.2 == 0.3 version of this issue happens to double:

#include <stdio.h>

int main() {
    printf("%s\n", 0.1 + 0.2 == 0.3 ? "true" : "false"); // prints false
    //             ^^^−−−^^^−−−−^^^−−− `double` literals
    return 0;
}

Answer 2

In a Math sense, 0.1 + 0.2 == 0.3 is always true

In a Floating point sense, 0.1 + 0.2 == 0.3 is only true if error in representing 0.1 + error in representing 0.2 == error in representing 0.3

As I'm sure your are aware the errors are dependent on the value and its magnitude. As such, there are a few cases where the errors align such that floating point numbers seem to work for equality, but the general case is that such comparisons in general are faulty, because they fail to account for errors.

To write strong floating point code, you need to look into measurement theory, and how to propagate measurement errors throughout your formulas. This also means that you'll have to replace the C type (bit comparison) equality with a "equals within the bounds of error".

Note that you cannot build a system that auto-handles the error in the program perfectly, because to do so would require an exact storage approach of finite size for any fractional number of possibly infinite repeating digits. As a result, error estimation is typically used, and the result is typically compared within an approximation boundary that is tuned for the values involved.

It doesn't take long to realize that while your program is correct, you can't trust the technique because the technique, in general, won't return the right values.

Answer 3

Generally, all the float rvalues are declared as double (e.g. 0.5, 11.332, 8.9, etc.) Thus, when you write the following statement:

float a = 0.1;
float b = 0.2;

if(a+b == 0.3)
  printf("true");
else
  printf("false");

It evaluates 0.1 + 0.2 = 0.3, that's okay, but in the right hand side, the 0.3 doesn't works as you're expecting it to be, as already mentioned, it's declared as double by default.

So, the compiler tries to compare the value:

0.3 == 0.2999999999999999889

Which is clearly not equal.

To solve this issue, you need to append a suffix to express the compiler you're trying to use a floating point value.

Try this instead:

(a + b == 0.3F)

The F or f indicates the value is a float.

Unfortunately, you can't do the same stuff with double. To prove that, you can write the following code:

#include <iomanip>
.
.
.
cout << setprecision(20) << 0.1 << endl;
cout << setprecision(20) << 0.2 << endl;
cout << setprecision(20) << 0.3 << endl;
cout << setprecision(20) << (0.1 + 0.2) << endl;

You'll get to know that all of the above values which will be displayed, will have different values:

0.10000000000000000555 // 0.1
0.2000000000000000111  // 0.2
0.2999999999999999889  // 0.3 -------- NOTE
0.30000000000000004441 // 0.1 + 0.2 -- NOTE

Now, compare the values of NOTE. They're also unequal.

Hence, the comparison of 0.2999999999999999889 and 0.30000000000000004441 fails and you get False at any cost.