Floating-point computations can error or produce inaccurate results under many circumstances. C programs can detect when these have happened by observing errno and checking for floating-point exceptions.

Exception types are identified by macros defined in <fenv.h> beginning with FE_ and an upper-case letter. (Note that there are other macros with the same pattern that do not identify exceptions, such as FE_DOWNWARD.) Each one is a distinct integer expression, and they can be OR-ed together to represent sets of exception types, e.g., FE_INEXACT | FE_UNDERFLOW. FE_ALL_EXCEPT represents the set of all exception types. The following exception types are specified:

• FE_DIVBYZERO
• FE_INEXACT
• FE_INVALID
• FE_OVERFLOW
• FE_UNDERFLOW

Raising a floating-point exception can result in a signal of type SIGFPE being raised. Returning from the signal handler has undefined behaviour, so all you can portably do in there is perhaps print a message an abort. [Not even sure whether printing is safe.] However, no function in <math.h> may raise SIGFPE, though it can quietly raise FE_INVALID, FE_DIVBYZERO or FE_OVERFLOW according to the result. feholdexcept can also be used to disable raising of SIGFPE until a subsequent call to feupdateenv.

The floating-point environment includes a set of status flags, which remember which exceptions have been recently raised in the current thread. An object of type fexcept_t can be used to store a copy these flags:

#include <fenv.h>
#pragma STDC FENV_ACCESS ON
int fegetexceptflag(fexcept_t *flp, int excepts);
int fesetexceptflag(const fexcept_t *flp, int excepts);

These functions allow a program to save (fegetexceptflag) and restore (fesetexceptflag) the floating-point status flags as a single operation. Restoring the state does not cause the exceptions to be raised. The argument excepts acts as a filter, indicating which flags to save or restore. State is saved to or restored from *flp. The functions return non-zero on failure.

There is no direct portable way to set an fexcept_t to a specific value; the state passed to fesetexceptflag must come from a previous call to fegetexceptflag, and the filter controlling fesetexceptflag must be a subset of the filter controlling fegetexceptflag. However, it should be possible by enabling non-stop mode for all exceptions, raising the ones you want, recording the new state, restoring all FP state, and then optionally setting the state from the stored flags:

#pragma STDC FENV_ACCESS ON
fenv_t env;
fexcept_t exes;
feholdexcept(&env);
feraiseexcept(FE_INVALID);
fegetexceptflag(&exes, FE_INVALID);
feupdateenv(&env);
fesetexceptflag(&exes, FE_INVALID);

#include <fenv.h>
#pragma STDC FENV_ACCESS ON
int feclearexcept(int excepts);
int fetestexcept(int excepts);
int feraiseexcept(int excepts);

These functions directly interact with the status flags identified by excepts. feclearexcept attempts to clear the specified status flags, while feraiseexcept attempts to raise the specified exceptions. The functions return zero on total success. fetestexcept tests the specified exceptions, and returns the OR of the flags that are set.

A domain error occurs when a mathematical function is computed, but the input is outside the function's domain, i.e., the set of arguments for which the function is defined. For example, the domain of the arc sine does not include real numbers greater than +1 or less than −1. A domain error is signalled by the FE_INVALID exception, and by errno containing EDOM.

A pole error occurs when the input is correctly in the domain, but the result is some form of infinity. For example, the logarithm of zero is negative infinity. A pole error is signalled by FE_DIVBYZERO.

A range error is an overflow or underflow.

• An overflow occurs when the input is correctly in the domain, and the result is not an infinity, but it is too large to be represented. The actual value yielded by the computation will be one of ±HUGE_VAL, ±HUGE_VALF and ±HUGE_VALL, as appropriate to the type of the computation and the sign of the true result. An overflow exception is signalled by FE_OVERFLOW. If this macro is not defined, overflows are not signalled by exceptions.

  [: If infinity is not supported, is HUGE_VAL used instead, and is it considered an overflow?]

• An underflow occurs when the input is correctly in the domain, and the result is not zero, but it is too small to be represented. The actual value yielded by the computation will be a small non-zero amount with the correct sign. An overflow exception is signalled by FE_UNDERFLOW. If this macro is not defined, underflows are not signalled by exceptions.

Overflows and pole errors are additionally signalled by errno containing ERANGE. Underflows might also be signalled this way.

FE_INEXACT is an exception that may be raised by functions in <math.h> when the true mathematical result cannot be represented exactly in the result type, or when a floating-point value is converted to an integer. Functions such as nearbyint exist specifically to avoid this exception. Other rounding functions are permitted to raise it when the input and output differ.

math_errhandling is an expression of type int. If the expression math_errhandling & MATH_ERREXCEPT is non-zero, then:

• FE_INVALID is raised when a domain error occurs,
• FE_DIVBYZERO is raised when a pole error occurs, and
• FE_OVERFLOW is raised when an overflow occurs,

If the expression is zero, then:

• FE_UNDERFLOW is not raised when an underflow occurs.

If the expression math_errhandling & MATH_ERRNO is non-zero, then:

• errno is set to EDOM when a domain error occurs, and
• errno is set to ERANGE when a pole error or an overflow occurs.

If the expression is zero, then:

• errno is not set when an underflow occurs.