Provided by: manpages-fr_1.67.0-1_all bug

NOM

       feclearexcept,    fegetexceptflag,    feraiseexcept,   fesetexceptflag,
       fetestexcept, fegetenv, fegetround, feholdexcept, fesetround, fesetenv,
       feupdateenv, fedisableexcept, feenableexcept, fegetexcept - Gestion des
       exceptions C99 pour les arrondis et les erreurs en virgule flottante.

SYNOPSIS

       #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);

DESCRIPTION

       Ces onze fonctions ont été définies  dans  le  C99,  et  permettent  de
       paramétrer   les  arrondis  et  les  gestions  d’erreurs  (débordement,
       division par zéro, etc.)  en virgule flottante.

   Exceptions
       L’exception DivideByZero se produit quand une opération sur des nombres
       finis donne un infini comme réponse exacte.

       L’exception  Overflow se produit quand un résultat doit être représenté
       par un nombre en virgule flottante, mais que sa valeur absolue est trop
       grande pour être représentée par un nombre fini.

       L’exception Underflow se produit quand un résultat doit être représenté
       par un nombre en virgule flottante, mais que sa valeur absolue est trop
       petite pour être représentée.

       L’exception   Inexact  se  produit  quand  le  résultat  arrondi  d’une
       opération n’est pas égal au résultat en précision infinie. Elle peut se
       déclencher quand les exceptions Overflown ou Underflow se produisent.

       L’exception  Invalid  se  produit  quand  il n’y a pas de résultat bien
       défini pour une opération, comme 0/0 ou infini-infini ou sqrt(-1).

   Gestion des exceptions
       Les exceptions sont représentées  de  deux  manières :  en  tant  qu’un
       unique  bit  (exception  présente  ou absente) correspondant de manière
       dépendant de l’implémentation avec une position au sein d’un entier, et
       aussi en tant que structure opaque pouvant véhiculer plus d’information
       concernant l’exception (éventuellement l’adresse  du  code  déclenchant
       l’erreur).

       Chacune  des  macros FE_DIVBYZERO, FE_INEXACT, FE_INVALID, FE_OVERFLOW,
       FE_UNDERFLOW est définie lorsque l’implémentation supporte  la  gestion
       de  l’exception  correspondante.  Les bits sont alors définis, ainsi on
       peut appeler par exemple les fonctions de gestion des  exceptions  avec
       un   argument  entier  FE_OVERFLOW|FE_UNDERFLOW.   D’autres  exceptions
       peuvent  être  supportées.  La  macro  FE_ALL_EXCEPT  est   un   masque
       regroupant par OU binaire tous les bits des exceptions supportées.

       La fonction feclearexcept efface les exceptions supportées représentées
       par les bits présents dans son argument.

       La fonction fegetexceptflag stocke une  représentation  de  l’état  des
       exceptions  contenues  dans  son  argument  excepts dans l’objet opaque
       *flagp.

       La  fonction  feraiseexcept   déclenche   les   exceptions   supportées
       représentées par les bits de l’argument excepts.

       La fonction fesetexceptflag fixe l’état des exceptions représentées par
       l’argument excepts en employant la valeur *flagp.  Cette dernière  doit
       être le résultat d’un appel préalable à fegetexceptflag avec un dernier
       argument contenant au moins tous les bits présents dans excepts.

       La fonction  fetestexcept  renvoie  un  mot  dont  les  bits  également
       présents  dans  l’argument  excepts  seront  positionnés si l’exception
       correspondante est présente.

   Arrondis
       Chacune des macros FE_DOWNWARD, FE_TONEAREST, FE_TOWARDZERO,  FE_UPWARD
       est  définie  lorsque l’implémentation supporte l’usage de la direction
       d’arrondi correspondante.

       La fonction fegetround renvoie la macro correspondant au mode d’arrondi
       en cours.

       La  fonction  fesetround  fixe le mode d’arrondi tel qu’il est spécifié
       par son argument et renvoie zéro lorsqu’elle réussit.

   Environnement en virgule flottante.
       L’environnement de travail en virgule flottante, y compris les modes de
       contrôle  et  les  états  peuvent  être manipulés sous forme d’un objet
       opaque de type fenv_t.  L’environnement par défaut, est représenté  par
       FE_DFL_ENV  (de type const fenv_t *).  Il s’agit de la configuration de
       l’environnement au démarrage du programme et elle est définie par ISO C
       comme  ayant  un arrondi au plus proche, toutes les exceptions effacées
       et un mode non-stop (continuer sur exception).

       La fonction  fegetenv  sauve  l’environnement  de  travail  en  virgule
       flottante en cours dans l’objet *envp.

       La  fonction  feholdexcept effectue la même chose, puis efface tous les
       drapeaux d’exceptions, et bascule si  possible  sur  un  mode  non-stop
       (continuer  en  présence  d’exceptions).   Elle  renvoie  zéro  si elle
       réussit.

       La fonction fesetenv recharge l’environnement  de  travail  en  virgule
       flottante à partir de l’objet *envp.  Cet objet doit être valide, c’est
       à dire être  le  résultat  de  fegetenv,  de  feholdexcept  ou  égal  à
       FE_DFL_ENV.  Cet appel ne déclenche pas les exceptions.

       La  fonction  feupdateenv installe l’environnement en virgule flottante
       représenté par l’objet *envp, sauf que les exceptions déjà  déclenchées
       ne  sont pas effacées.  Après l’appel de cette fonction, les exceptions
       déclenchées seront un OU binaire entre l’ensemble précédent,  et  celui
       contenu  dans  *envp.  Comme précédemment, l’objet pointé par envp doit
       être valide.

DÉTAILS GNU

       Si possible, la bibliothèque GNU LibC définit une  macro  FE_NOMASK_ENV
       qui  représente l’environnement quand toutes les exceptions déclenchent
       un appel. On peut tester  la  présence  de  cette  macro  en  utilisant
       #ifdef.   Elle n’est définie que si la constante symbolique _GNU_SOURCE
       est définie.  Le standard C99 ne définit pas de manière  de  fixer  des
       bits  individuels  dans  le  masque,  par  exemple pour intercepter des
       exceptions particulières.  La  GLibC  2.2  supporte  feenableexcept  et
       fedisableexcept  pour  fixer  individuellement  des  interceptions,  et
       fegetexcept pour demander l’état.

       #define _GNU_SOURCE
       #include <fenv.h>

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

       Les fonctions feenableexcept et fedisableexcept activent  (désactivent)
       l’interception   pour  chaque  exception  représentée  par  excepts  et
       renvoient l’ensemble précédent  des  exceptions  activées  lorsqu’elles
       réussissent,  et  -1 sinon.  La fonction fegetexcept renvoie l’ensemble
       des exceptions actuellement activées.

Effectuez lédition des liens avec loption
       -lm.

CONFORMITÉ

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

TRADUCTION

       Christophe Blaess, 2000-2003.