Provided by: manpages-es_1.55-10_all bug

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).