GNU Info

Info Node: (libc.info)Status bit operations

(libc.info)Status bit operations


Next: Math Error Reporting Prev: Infinity and NaN Up: Floating Point Errors
Enter node , (file) or (file)node

Examining the FPU status word
-----------------------------

   ISO C99 defines functions to query and manipulate the floating-point
status word.  You can use these functions to check for untrapped
exceptions when it's convenient, rather than worrying about them in the
middle of a calculation.

   These constants represent the various IEEE 754 exceptions.  Not all
FPUs report all the different exceptions.  Each constant is defined if
and only if the FPU you are compiling for supports that exception, so
you can test for FPU support with `#ifdef'.  They are defined in
`fenv.h'.

`FE_INEXACT'
     The inexact exception.

`FE_DIVBYZERO'
     The divide by zero exception.

`FE_UNDERFLOW'
     The underflow exception.

`FE_OVERFLOW'
     The overflow exception.

`FE_INVALID'
     The invalid exception.

   The macro `FE_ALL_EXCEPT' is the bitwise OR of all exception macros
which are supported by the FP implementation.

   These functions allow you to clear exception flags, test for
exceptions, and save and restore the set of exceptions flagged.

 - Function: int feclearexcept (int EXCEPTS)
     This function clears all of the supported exception flags
     indicated by EXCEPTS.

     The function returns zero in case the operation was successful, a
     non-zero value otherwise.

 - Function: int feraiseexcept (int EXCEPTS)
     This function raises the supported exceptions indicated by
     EXCEPTS.  If more than one exception bit in EXCEPTS is set the
     order in which the exceptions are raised is undefined except that
     overflow (`FE_OVERFLOW') or underflow (`FE_UNDERFLOW') are raised
     before inexact (`FE_INEXACT').  Whether for overflow or underflow
     the inexact exception is also raised is also implementation
     dependent.

     The function returns zero in case the operation was successful, a
     non-zero value otherwise.

 - Function: int fetestexcept (int EXCEPTS)
     Test whether the exception flags indicated by the parameter EXCEPT
     are currently set.  If any of them are, a nonzero value is returned
     which specifies which exceptions are set.  Otherwise the result is
     zero.

   To understand these functions, imagine that the status word is an
integer variable named STATUS.  `feclearexcept' is then equivalent to
`status &= ~excepts' and `fetestexcept' is equivalent to `(status &
excepts)'.  The actual implementation may be very different, of course.

   Exception flags are only cleared when the program explicitly
requests it, by calling `feclearexcept'.  If you want to check for
exceptions from a set of calculations, you should clear all the flags
first.  Here is a simple example of the way to use `fetestexcept':

     {
       double f;
       int raised;
       feclearexcept (FE_ALL_EXCEPT);
       f = compute ();
       raised = fetestexcept (FE_OVERFLOW | FE_INVALID);
       if (raised & FE_OVERFLOW) { /* ... */ }
       if (raised & FE_INVALID) { /* ... */ }
       /* ... */
     }

   You cannot explicitly set bits in the status word.  You can, however,
save the entire status word and restore it later.  This is done with the
following functions:

 - Function: int fegetexceptflag (fexcept_t *FLAGP, int EXCEPTS)
     This function stores in the variable pointed to by FLAGP an
     implementation-defined value representing the current setting of
     the exception flags indicated by EXCEPTS.

     The function returns zero in case the operation was successful, a
     non-zero value otherwise.

 - Function: int fesetexceptflag (const fexcept_t *FLAGP, int
     EXCEPTS) This function restores the flags for the exceptions
     indicated by EXCEPTS to the values stored in the variable pointed
     to by FLAGP.

     The function returns zero in case the operation was successful, a
     non-zero value otherwise.

   Note that the value stored in `fexcept_t' bears no resemblance to
the bit mask returned by `fetestexcept'.  The type may not even be an
integer.  Do not attempt to modify an `fexcept_t' variable.


automatically generated by info2www version 1.2.2.9