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