Division by zero prevention: Checking the divisor's expression doesn't result in zero vs. checking the divisor isn't zero?

Question

Is division by zero possible in the following case due to the floating point error in the subtraction?

float x, y, z;
...
if (y != 1.0)
    z = x / (y - 1.0);

In other words, is the following any safer?

float divisor = y - 1.0;
if (divisor != 0.0)
    z = x / divisor;

Answer 1

Assuming IEEE-754 floating-point, they are equivalent.

It is a basic theorem of FP arithmetic that for finite x and y, x - y == 0 if and only if x == y, assuming gradual underflow.

If subnormal results are flushed to zero (instead of gradual underflow), this theorem holds only if the result x - y is normal. Because 1.0 is well scaled, y - 1.0 is never subnormal, and so y - 1.0 is zero if and only if y is exactly 1.0, regardless of how underflow are handled.

C++ doesn't guarantee IEEE-754, of course, but the theorem is true for most "reasonable" floating-point systems.

Answer 2

This will prevent you from dividing by exactly zero, however that does not mean still won't end up with +/-inf as a result. The denominator could still be small enough so that the answer is not representable with a double and you will end up with an inf. For example:

#include <iostream>
#include <limits>

int main(int argc, char const *argv[])
{
    double small = std::numeric_limits<double>::epsilon();
    double large = std::numeric_limits<double>::max() / small;
    std::cout << "small: " << small << std::endl;
    std::cout << "large: " << large << std::endl;
    return 0;
}

In this program small is non-zero, but it is so small that large exceeds the range of double and is inf.

Answer 3

There is no difference between the two code snippets () - in fact, the optimizer could even optimize both fragments to the same binary code, assuming that there are no further uses of the divisor variable.

Note, however, that division by a floating point zero 0.0 does not result in a run-time error, but produces an inf or -inf instead.