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'ON

       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  excepcion  <<dividir  por  cero>>  (DivideByZero) ocurre cuando una
       operacion sobre numeros finitos produce infinito como resultado exacto.

       La excepcion <<desbordamiento por arriba>> (Overflow) ocurre cuando  un
       resultado  tiene  que ser representado como un numero en coma flotante,
       pero su valor absoluto es (mucho) mas grande  que  el  numero  en  coma
       flotante mas grande (finito) que se puede representar.

       La  excepcion <<desbordamiento por abajo>> (Underflow) ocurre cuando un
       resultado tiene que ser representado como un numero en  coma  flotante,
       pero  su  valor  absoluto es mas pequeno que el numero positivo en coma
       flotante normalizado mas pequeno (y se perderia mucha precision  si  se
       representara como un numero desnormalizado).

       The  exception  <<inexacto>>  (Inexact)  se produce cuando el resultado
       redondeado de una operacion no  es  igual  al  resultado  de  precision
       infinita.  Puede  ocurrir siempre que se produzca un desbordamiento por
       arriba o por abajo.

       La excepcion <<invalido>> (Invalid) ocurre cuando no hay  un  resultado
       definido para una operacion, 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
       (excepcion  presente/ausente),  que  se  situa  dentro  de un entero de
       alguna manera definida  por  la  implementacion,  y  tambien  como  una
       estructura  opaca que puede contener mas informacion sobre la excepcion
       (tal vez la direccion dentro del codigo donde se produjo).

       Cada  una  de  las   macros   FE_DIVBYZERO,   FE_INEXACT,   FE_INVALID,
       FE_OVERFLOW, FE_UNDERFLOW se define cuando la implementacion soporta el
       manejo de la correspondiente excepcion,  definiendose  tambien  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 esta formada mediante un OR logico con todos los
       bits que se corresponden con excepciones soportadas.

       La    funcion   feclearexcept   limpia   las   excepciones   soportadas
       representadas por los bits de su argumento.

       La funcion fegetexceptflag almacena una representacion  del  estado  de
       las  banderas de excepcion representadas por el argumento excepts en el
       objeto opaco *flagp.

       La funcion feraiseexcept lanza las excepciones soportadas representadas
       por los bits en excepts.

       La  funcion  fesetexceptflag configura por completo la situacion de las
       excepciones representadas por excepts segun el valor dado  por  *flagp.
       Este  valor  debe  haber  sido  obtenido  mediante una llamada previa a
       fegetexceptflag con un ultimo argumento que tuviera todos los  bits  en
       excepts.

       La funcion fetestexcept devuelve una palabra en la que los bits activos
       son aquellos que estaban activos en el argumento excepts y para los que
       la excepcion correspondiente esta activa actualmente.

   Redondeo
       Cada  una  de  las  macros  FE_DOWNWARD,  FE_TONEAREST,  FE_TOWARDZERO,
       FE_UPWARD se define cuando  la  implementacion  soporta  el  obtener  y
       establecer la correspondiente direccion de redondeo.

       La  funcion fegetround devuelve la macro correspondiente al modo actual
       de redondeo.

       La funcion fesetround fija el modo de  redondeo  segun  especifique  su
       argumento y devuelve cero cuando tiene exito.

   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
       configuracion  del  entorno al inicio de la ejecucion de un programa y,
       segun establece el ISO C, equivale a redondear al  mas  cercano,  tener
       todas   las  expeciones  desactivadas  y  usar  un  modo  de  no-parada
       (continuar en excepciones).

       La funcion fegetenv guarda el entorno de coma  flotante  actual  en  el
       objeto *envp.

       La funcion feholdexcept hace lo mismo y a continuacion limpia todas las
       banderas de excepcion y establece un modo de  no-parada  (continuar  en
       excepciones), si esto es posible. Devuelve cero cuando tiene exito.

       La  funcion  fesetenv  restablece  el entorno de coma flotante segun el
       objeto *envp.  Debemos asegurarnos de que este  objeto  es  valido,  es
       decir,  de que es el resultado de una llamada a fegetenv o feholdexcept
       o de que es igual a FE_DFL_ENV.  Esta llamada no provoca excepciones.

       La funcion feupdateenv instala el entorno de coma flotante representado
       por  el  objeto  *envp,  pero  no desactiva las excepciones actualmente
       lanzadas. Tras llamar a esta funcion, las excepciones lanzadas  vendran
       dadas  por  el  resultado  de  un  O-logico  entre aquellas previamente
       activas y las que haya en *envp.  Como antes,  debemos  asegurarnos  de
       que el objeto *envp es valido.

DETALLES DE GNU

       Si  es  posible, la Biblioteca GNU C define una macro FE_NOMASK_ENV que
       representa un entorno donde toda excepcion lanzada provoca una  trampa.
       Puede  preguntar por esta macro usando #ifdef.  Solamente esta definida
       si _GNU_SOURCE esta definida.  El estandar C99  no  define  una  manera
       para  activar  bits  individuales  en la mascara de coma flotante, p.e.
       para atrapar segun  banderas  especificas.   glibc  2.2  soportara  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  excepcion  representada por excepts y devuelven el
       conjunto previo de excepciones habilitadas cuando tienen exito y -1  en
       caso  contrario.   La funcion 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).

Pagina de Manual de Linux       12 agosto 2000                         FENV(3)