Provided by: manpages-es_1.55-3_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).