NOMBRE

       feclearexcept,  fegetexceptflag,  feraiseexcept,  fesetexceptflag,  fetestexcept,  fegetenv,  fegetround,
       feholdexcept, fesetround, fesetenv, feupdateenv - manejo de redondeo y excepciones en coma flotante C99

SINOPSIS

       #include <fenv.h>

       void feclearexcept(int excepts);
       void fegetexceptflag(fexcept_t *flagp, int excepts);
       void feraiseexcept(int excepts);
       void fesetexceptflag(const fexcept_t *flagp, int excepts);
       int fetestexcept(int excepts);

       int fegetround(void);
       int fesetround(int rounding_mode);

       void fegetenv(fenv_t *envp);
       int feholdexcept(fenv_t *envp);
       void fesetenv(const fenv_t *envp);
       void feupdateenv(const fenv_t *envp);

DESCRIPCIÓN

       Estas once funciones fueron definidas dentro de  C99  y  describen  el  manejo  del  redondeo  y  de  las
       excepciones (desbordamiento por arriba, dividir-por-cero etc.) en coma flotante.

   Excepciones
       La  excepción «dividir por cero» (DivideByZero) ocurre cuando una operación sobre números finitos produce
       infinito como resultado exacto.

       La excepción «desbordamiento por arriba» (Overflow) ocurre cuando un resultado tiene que ser representado
       como un número en coma flotante, pero su valor absoluto es (mucho) más  grande  que  el  número  en  coma
       flotante más grande (finito) que se puede representar.

       La excepción «desbordamiento por abajo» (Underflow) ocurre cuando un resultado tiene que ser representado
       como  un  número  en  coma flotante, pero su valor absoluto es más pequeño que el número positivo en coma
       flotante normalizado más pequeño (y se perdería  mucha  precisión  si  se  representara  como  un  número
       desnormalizado).

       The exception «inexacto» (Inexact) se produce cuando el resultado redondeado de una operación no es igual
       al  resultado de precisión infinita. Puede ocurrir siempre que se produzca un desbordamiento por arriba o
       por abajo.

       La excepción «inválido» (Invalid) ocurre cuando no hay un resultado definido para una operación, como por
       ejemplo 0/0 o infinito - infinito o sqrt(-1).

   Manejo de excepciones
       Las excepciones se representan de dos maneras: como un bit individual (excepción  presente/ausente),  que
       se  sitúa  dentro  de  un  entero  de  alguna  manera  definida por la implementación, y también como una
       estructura opaca que puede contener más información sobre la excepción (tal vez la dirección  dentro  del
       código donde se produjo).

       Cada  una  de las macros FE_DIVBYZERO, FE_INEXACT, FE_INVALID, FE_OVERFLOW, FE_UNDERFLOW se define cuando
       la implementación soporta el  manejo  de  la  correspondiente  excepción,  definiendose  también  el  bit
       correspondiente,  de  forma  que  se pueda llamar a las funciones de manejo de excepciones usando p.e. el
       argumento  entero  FE_OVERFLOW|FE_UNDERFLOW.   Otras  excepciones  pueden  estar  soportadas.  La   macro
       FE_ALL_EXCEPT  está  formada mediante un OR lógico con todos los bits que se corresponden con excepciones
       soportadas.

       La función feclearexcept limpia las excepciones soportadas representadas por los bits de su argumento.

       La función  fegetexceptflag  almacena  una  representación  del  estado  de  las  banderas  de  excepción
       representadas por el argumento excepts en el objeto opaco *flagp.

       La función feraiseexcept lanza las excepciones soportadas representadas por los bits en excepts.

       La  función  fesetexceptflag  configura  por  completo  la situación de las excepciones representadas por
       excepts según el valor dado por *flagp.  Este valor debe haber sido obtenido mediante una llamada  previa
       a fegetexceptflag con un último argumento que tuviera todos los bits en excepts.

       La  función fetestexcept devuelve una palabra en la que los bits activos son aquellos que estaban activos
       en el argumento excepts y para los que la excepción correspondiente está activa actualmente.

   Redondeo
       Cada una  de  las  macros  FE_DOWNWARD,  FE_TONEAREST,  FE_TOWARDZERO,  FE_UPWARD  se  define  cuando  la
       implementación soporta el obtener y establecer la correspondiente dirección de redondeo.

       La función fegetround devuelve la macro correspondiente al modo actual de redondeo.

       La  función  fesetround  fija  el  modo de redondeo según especifique su argumento y devuelve cero cuando
       tiene éxito.

   Entorno de coma flotante
       El entorno de coma flotante por completo, incluyendo los modos de control y las banderas de estado, puede
       ser manejado como un objeto opaco, de tipo fenv_t.  El entorno por defecto se denota por  FE_DFL_ENV  (de
       tipo  const  fenv_t  *).   El  entorno por defecto determina la configuración del entorno al inicio de la
       ejecución de un programa y, según establece el ISO C, equivale a redondear al más  cercano,  tener  todas
       las expeciones desactivadas y usar un modo de no-parada (continuar en excepciones).

       La función fegetenv guarda el entorno de coma flotante actual en el objeto *envp.

       La función feholdexcept hace lo mismo y a continuación limpia todas las banderas de excepción y establece
       un modo de no-parada (continuar en excepciones), si ésto es posible. Devuelve cero cuando tiene éxito.

       La función fesetenv restablece el entorno de coma flotante según el objeto *envp.  Debemos asegurarnos de
       que este objeto es válido, es decir, de que es el resultado de una llamada a fegetenv o feholdexcept o de
       que es igual a FE_DFL_ENV.  Ésta llamada no provoca excepciones.

       La  función  feupdateenv  instala  el  entorno de coma flotante representado por el objeto *envp, pero no
       desactiva las excepciones actualmente lanzadas. Tras llamar a  esta  función,  las  excepciones  lanzadas
       vendrán dadas por el resultado de un O-lógico entre aquellas previamente activas y las que haya en *envp.
       Como antes, debemos asegurarnos de que el objeto *envp es válido.

DETALLES DE GNU

       Si  es  posible,  la Biblioteca GNU C define una macro FE_NOMASK_ENV que representa un entorno donde toda
       excepción lanzada provoca una trampa. Puede preguntar por  esta  macro  usando  #ifdef.   Solamente  está
       definida  si  _GNU_SOURCE  está  definida.   El  estándar  C99  no  define  una  manera para activar bits
       individuales en la máscara de coma flotante, p.e. para atrapar según  banderas  específicas.   glibc  2.2
       soportará  las  funciones  feenableexcept  y  fedisableexcept  para instalar trampas individuales de coma
       flotante y fegetexcept para consultar el estado.

       int feenableexcept (int excepts);
       int fedisableexcept (int excepts);
       int fegetexcept (void);

       Las funciones feenableexcept y fedisableexcept  habilitan  (deshabilitan)  trampas  para  cada  excepción
       representada  por excepts y devuelven el conjunto previo de excepciones habilitadas cuando tienen éxito y
       -1 en caso contrario.  La función fegetexcept devuelve el conjunto de todas las  excepciones  habilitadas
       actualmente.

CONFORME A

       IEC 60559 (IEC 559:1989), ANSI/IEEE 854, ISO C99 (ISO/IEC 9899:1999).

Página de Manual de Linux                        12 agosto 2000                                          FENV(3)