Why does >= operator work as > operator in C when compared with 0.9

Question

I was working with C and tried this :-

#include<stdio.h>
int main()
{
     float b=0.8,a=0.6;
     if(a&&b>=0.8)
     printf("\nclass")  ;
     else
     printf("\nb");
     return 0;
}

And the output came :-

class

But when I changed the value of b to 0.9 and expression in if to a&&b>=0.9 :-

#include<stdio.h>
int main()
{
     float b=0.9,a=0.6;
     if(a&&b>=0.9)
     printf("\nclass")  ;
     else
     printf("\nb");
     return 0;
}

then output was:-

b

Can anyone explain why >= operator started to act as > operator when the value of b was 0.9 ?

Thanks in advance.

Something to add as some guys think I am wasting their time :- I also tried to debug it as :-

    #include<stdio.h>
int main()
{
float b=0.9,a=0.6;
printf(" int a   -   %d\n", (int)a);
printf("int b -    %d\n", (int)b);
printf("a&&b  -   %d\n", a&&b);
printf("b>=0.9  -  %d\n", b>=0.9);
if(a&&b>=0.9)
printf("\nclass");
else
printf("\nb");
return 0;   
}

Now the O/p was :-

int a   -   0
int b -    0
a&&b  -   1
b>=0.9  -  0

Now please that "Precedence Guy" tell me what order of precedence would be followed in a single >= operator.

Answer 1

Your code is equivalent to:

double x1 = 0.9;
float xf = (float)x1; // discard some precision
double x2 = (double)xf;

if (x2 >= x1) {
    // ...
}

The problem is that, after you discarded some precision from x1 by converting it to float, it can never be recovered; casting it back to double doesn't regain that precision. So x2 is still not the same as 0.9, and due to the rounding direction, it happens to be a bit less. (Note: if you try the same thing with other values, you will sometimes find that it's a bit more.)

Answer 2

0.9 can't be exactly represented in binary .

And also importantly 0.9(being double) is first implicitly converted to float(less precesion) and then converted back to double(higher precession than float) does no remain excalty 0.9.

Therefore, the value of b is apporximately close to 0.9 not equal to 0.9. Therefore ,you get b.

Answer 3

Computers only know binary representation. It is able to represent decimal numbers in binary without a problem(and that changes with extremely large numbers too), but when it comes to fractional numbers it is not able to fully represent the number.

In binary each number is multiplied with 2 instead of 10 in decimal.

For example look at number 13

1*10^1 + 3*10^0

to represent the same number in binary system we need

1*2^3 + 1*2^2 + 0*2^1 + 1*2^0 = (1101)

But things get complicated at fractional parts. Again with an example:

13.26 = 13 + 2/10^1 + 6/10^2

but in binary

(1101) + 0/2^1 + 1/2^2 + 0/2^3 + 0/2^4 + 0/2^5 + 0/2^6 + 1/2^7 + 0/2^8 + 1/2^9 + ... = (1101.010000101....)

I hope this shows that it's not that easy to represent a fractional number with limited space.

Now, as soon as you declare your variables as floats, there's a limited space allocated for them and computer barely gets close to that fractional number. In the if condition you don't specify a type and compiler automatically chooses double over float which has more space and can represent the fractional number more accurately. In one case float represents the number bigger and in the other one it represents the number as smaller.

To fix that you can convert the literal to a float

float b = 0.9, a = 0.6;
if (a&&b >= (float)0.9)
    printf("\nclass");
else
    printf("\nb");
cin.get();
return 0;

which will output

\nclass