The floating point comparison is exact, so 10^-10 is not the same as 0.0.

Basically, you should be comparing against some tolerable difference, say 10^-7 based on the number of decimals you're writing out, that can be accomplished as:

while(fabs(tmp) > 10e-7)

You are correct with your observation.

If x == 0.0, then abs(x) * epsilon is zero and you're testing whether abs(y) <= 0.0.

If y == 0.0 then you're testing abs(x) <= abs(x) * epsilon which means either epsilon >= 1 (it isn't) or x == 0.0.

So either is_equal(val, 0.0) or is_equal(0.0, val) would be pointless, and you could just say val == 0.0. If you want to only accept exactly +0.0 and -0.0.

The FAQ's recommendation in this case is of limited utility. There is no "one size fits all" floating-point comparison. You have to think about the semantics of your variables, the acceptable range of values, and the magnitude of error introduced by your computations. Even the FAQ mentions a caveat, saying this function is not usually a problem "when the magnitudes of x and y are significantly larger than epsilon, but your mileage may vary".

It depends on how b and a got their values. Zero has an exact representation in floating point format, but the bigger problem would be almost-but-not-quite zero values. It would always be safe to check:

if (abs(b-a) > 0.00000001  && ...

Where 0.00000001 is whatever value makes sense.

You can use the standard macro signbit(arg) from math.h. It will return nonzero value if arg is negative and ​0​ otherwise.

From the man page:

signbit() is a generic macro which can work on all real floating- point types. It returns a nonzero value if the value of x has its sign bit set.

This is not the same as x < 0.0, because IEEE 754 floating point allows zero to be signed. The comparison -0.0 < 0.0 is false, but signbit(-0.0) will return a nonzero value.

NaNs and infinities have a sign bit.

Also, from cppreference.com:

This macro detects the sign bit of zeroes, infinities, and NaNs. Along with copysign, this macro is one of the only two portable ways to examine the sign of a NaN.

If you use a floating point number for the timer then maybe the only way is to use a condition like:

if(abs(TIME) < number )... 

where number is very small value like e-9 than means practically zero.

The value ±0 only indicates if the value approached 0 from negative or positive values (but this is not a guarantee for every case, of course). However, it still is 0.

Therefore, x >= 0 will include both +0 and -0 zero. You can test that for yourself in a simple program. :)

In the IEEE754 standard, it explicitly says

Comparisons shall ignore the sign of zero (so +0 = -0).

IEEE754 is used by most processors and implementations, so for all practical purposes -0 >= 0 is true.

For any number x, x >= 0 and !(x < 0) are the same. This is also true for +0 and -0.

As pointed out by aschepler in a comment, the two tests x >= 0 and !(x < 0) differ when x is NaN (not-a-number). NaN is always different from any real number, thus !(x < 0) will be true when x is NaN. If NaN can occur in your calculations, you may want to handle that separately.

You can use strtod. Check if the result is zero and subsequently if endptr == nptr, according to the man page:

If no conversion is performed, zero is returned and the value of nptr is stored in the location referenced by endptr.

Something like this:

char input[50];
char * end;
double result = 0;

fgets(input, sizeof input, stdin);

errno = 0;

result = strtod(input, &end);

if(result == 0 && (errno != 0 || end == input)){
    fprintf(stderr, "Error: input is not a valid double\n");
    exit(EXIT_FAILURE);
}

EDIT there seems to be a bit of a discrepancy between the standard and the man page. The man page says that endptr == nptr when no conversion is performed, while the standard seems to imply this isn't necessarily the case. Worse still it says that in case of no conversion errno may be set to EINVAL. Edited the example code to check errno as well.

Alternatively, sscanf could be used (preferred over scanf), in conjunction with fgets:

/* just fgetsed input */
if(sscanf(input, "%lf", &result) != 1){
    fprintf(stderr, "Error: input is not a valid double\n");
    exit(EXIT_FAILURE);
}

Also, don't forget to check the return value of fgets for NULL, in case it failed!

Assuming 64-bit IEEE double, there is a 52-bit mantissa and 11-bit exponent. Let's break it to bits:

1.0000 00000000 00000000 00000000 00000000 00000000 00000000 × 2^0 = 1

The smallest representable number greater than 1:

1.0000 00000000 00000000 00000000 00000000 00000000 00000001 × 2^0 = 1 + 2^-52

Therefore:

epsilon = (1 + 2^-52) - 1 = 2^-52

Are there any numbers between 0 and epsilon? Plenty... E.g. the minimal positive representable (normal) number is:

1.0000 00000000 00000000 00000000 00000000 00000000 00000000 × 2^-1022 = 2^-1022

In fact there are (1022 - 52 + 1)×2^52 = 4372995238176751616 numbers between 0 and epsilon, which is 47% of all the positive representable numbers...