Question

Consider the following code:

#include<stdio.h>
#define k 0.7
#define p 0.5
int main()
{
    float a=k,b=p;
    double aa=k;
    if(a<k)
    {
         if(b<p) printf("2 is right");    
         else      printf("1 is right");
    }
    else printf("0 is right");
    printf("\n");
    if(a>k)
    {
         if(b<p) printf("2 is right");    
         else      printf("1 is right");
    }
    else printf("0 is right");
    return 0;
}

Consider this as part II of this question, here the understanding was that the double precision values of floating point constants (doubles when represented as numeric constants) was lost when it was converted to their corresponding floating point values. The exceptional values were X.5 and X.0. But I observed the following results:

Input           Output
K=0.1 to 0.4        0 is right
                    1 is right

K=0.5               0 is right
                    1 is right

K=0.6               0 is right
                    1 is right

K=0.7               1 is right
                    0 is right

K=0.8               0 is right
                    1 is right

K=0.9               1 is right
                    0 is right

K=8.4               1 is right
                    0 is right

Why is this queer behavior? How come only few floating point values are displaying this property? Can’t we assume that float precision values are always less than double precision values?? How do we explain this behavior?

Answer 1

Can’t we assume that float precision values are always less than double precision values??

Not really, they may both have the same precision. You can assume that the range and precision of double is not smaller than that of float.

But, for all practical purposes, it’s a profitable bet that double has 53 bits of precision and float has 24. And that double has 11-bit exponents, float 8-bit.

So, disregarding exotic architectures, float has less precision and a smaller range than double, every float value is representable as a double, but not vice versa. So casting from float to double is value-preserving, but casting from double to float will change all values needing more than 24 bits of precision.

The cast is generally performed (for values in the float range) by rounding the significand of the double value to 24 bits of precision in the following way:

• if the 25^th most significant bit of the significand is 0, the significand is truncated (the value is rounded towards zero)
• if the 25^th most significant bit is 1, and not all bits of lower significance are 0, the value is rounded away from zero (the significand is truncated and then the value of the lest significant bit is added)
• otherwise, the significand is rounded so tat the 24^th most significant bit is zero, that rounds away from zero in half the cases and towards zero in half.

You cannot predict if casting a double to float increases or decreases the value by looking at the decimal expansion, except in the few cases where you can see that the value will be unchanged. It’s the binary expansion that matters.