NAN -> distinguish between a division by zero and an exponent with a very large negative value

Question

I included a check for nan's in my testsuite.

Now a SIGFPE is thrown at the following line

const double retVal =exp(exponent);

The exponent has a value of approximately value -4000. This is of course very near to zero and without the nan check the calculation goes on with zero.

The signal SIGFPE is now been thrown. I assume that this is a denormal number (represented as NAN).

How can I distinguish between a division by zero and an exponent with a very large negative value?

In the second case, doing further calculations with zero works in my case, since I do not need to distinguish between +0 and -0.

EDIT: I tried what @user2079303 suggested. My code looks like this

#include <signal.h>
void fpe_handler(int signo, siginfo_t *info, void *context) {
    switch(info->si_code) {
        case FPE_INTDIV: // division by zero
            break;
        case FPE_FLTUND: // underflow
            break;
        // other cases ...
    }
}

int main() {
    struct sigaction action = {};
    action.sa_flags     = SA_SIGINFO;
    action.sa_sigaction = fpe_handler;
    sigaction(SIGFPE, &action, NULL);
    const double a = 0.0/0.0;
    if (a>0) 
        return 0;
    else
        return 1;
}

This compiles, but does not throw a signal or an error message.

According to [this `std::exp` reference](http://en.cppreference.com/w/cpp/numeric/math/exp) valid ranges for a `double` argument is -708.4 to 709.8. Your exponent is clearly much out of that range, probably out of the range of `long double` as well. — Some programmer dude, Sep 13 '17 at 09:32
But is is also stated that `If the argument is -∞, +0 is returned`. What is about the gap between -inf and -708.4? — schorsch312, Sep 13 '17 at 10:01

eerorika · Accepted Answer · 2017-09-13T23:31:00.813

Technically, from C++ perspective, division by zero has undefined behaviour, so there is no standard way to handle it.

In the ubiquitous IEEE 754 standard division by zero is well defined, and will not raise a signal. It is possible to test whether a previously performed calculation divided by zero using the <cfenv> header:

std::feclearexcept(FE_ALL_EXCEPT);
// do calculation here
if(std::fetestexcept(FE_DIVBYZERO)) {
    // I was just divided by zero. The sky is falling.
    std::abort();
} else if(std::fetestexcept(FE_UNDERFLOW)) {
    // I just underflowed. This is my life now.
}

Now, dividing a normal floating point number with zero does not raise a signal unless you ask it to using feenableexcept (this is a GNU extension; non-standard).

There is no way to distinguish different reasons for SIGFPE in standard C++. But there is a way in POSIX standard:

void fpe_handler(int signo, siginfo_t *info, void *context)
{
    switch(info->si_code) {
        case FPE_FLTDIV: // division by zero
            break;
        case FPE_FLTUND: // underflow
            break;
        // other cases ...
    }
}

// registering
struct sigaction action = {};
action.sa_flags     = SA_SIGINFO;
action.sa_sigaction = fpe_handler;
sigaction(SIGFPE, &action, NULL);

@schorsch312 I expanded my answer with something that is probably more relevant. Dividing a normal floating point number by zero will not raise a SIGFPE. — eerorika, Sep 13 '17 at 13:29
The signal handling example is also now fixed with correct type for floating point division by zero. — eerorika, Sep 13 '17 at 13:37

NAN -> distinguish between a division by zero and an exponent with a very large negative value

1 Answers1