Provided by: manpages-fr-dev_3.17.1-1_all bug

NOM

       feclearexcept,    fegetexceptflag,    feraiseexcept,   fesetexceptflag,
       fetestexcept, fegetenv, fegetround, feholdexcept, fesetround, fesetenv,
       feupdateenv, feenableexcept, fedisableexcept, fegetexcept - Gestion des
       exceptions et des arrondis des nombres flottants

SYNOPSIS

       #include <fenv.h>

       int feclearexcept(int excepts);
       int fegetexceptflag(fexcept_t *flagp, int excepts);
       int feraiseexcept(int excepts);
       int fesetexceptflag(const fexcept_t *flagp, int excepts);
       int fetestexcept(int excepts);

       int fegetround(void);
       int fesetround(int rounding_mode);

       int fegetenv(fenv_t *envp);
       int feholdexcept(fenv_t *envp);
       int fesetenv(const fenv_t *envp);
       int feupdateenv(const fenv_t *envp);

       Effectuez l’édition des liens avec l’option -lm.

DESCRIPTION

       Ces onze fonctions ont été définies dans la norme C99, et décrivent  la
       gestion   des   arrondis   des  nombres  flottants  et  des  exceptions
       (débordement, division par zéro, etc.) sur les nombres flottants.

   Exceptions
       L’exception divide-by-zero (division par zéro)  se  produit  quand  une
       opération sur des nombres finis donne un résultat infini.

       L’exception  overflow  (débordement)  se produit quand un résultat doit
       être représenté par un nombre flottant, mais que sa valeur absolue  est
       trop grande pour être représentée par un nombre flottant.

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

       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 overflow 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), et ces bits  correspondent,
       de  manière  dépendante  à  l’implémentation, avec une position au sein
       d’un entier, et aussi en tant que  structure  opaque  pouvant  contenir
       plus d’informations 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  gère 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 au format OU binaire
       correspondant à toutes les exceptions supportées.

       La  fonction   feclearexcept()   efface   les   exceptions   supportées
       représentées par les bits de 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 son argument excepts.

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

       La  fonction  fetestexcept()  renvoie un mot dont les bits définis sont
       également les bits définis dans l’argument  excepts  et  pour  lesquels
       l’exception correspondante est définie.

   Mode darrondis
       Le  mode  d’arrondi  détermine  comment  le  résultat des opérations en
       virgule flottante doit être traité quand le résultat ne peut  pas  être
       représenté exactement avec le « significand » (la précision). Plusieurs
       modes d’arrondis peuvent être fournis : arrondis  au  plus  proche  (le
       mode par défaut), arrondi vers le haut (vers l’infini positif), arrondi
       vers le bas (vers l’infini négatif) et l’arrondi vers zéro.

       Chacune   des   macros   FE_TONEAREST,   FE_UPWARD,   FE_DOWNWARD    et
       FE_TOWARDZERO  est  définie lorsque l’implémentation gère la définition
       et la lecture de la direction d’arrondi correspondante.

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

       La  fonction  fesetround()  définit  le  mode  d’arrondi  tel qu’il est
       spécifié par son argument et renvoie zéro en cas de succès.

       C99 et POSIX.1-2008 spécifient un identifiant, FLT_ROUNDS, défini  dans
       <float.h>,  qui indique le mode d’arrondis de l’implémentation pour les
       additions en virgule flottante. Cet identifiant peut  prendre  une  des
       valeurs suivantes :

       -1     Le mode d’arrondi est indéterminé.

       0      L’arrondi se fait vers 0.

       1      L’arrondi se fait vers le plus proche nombre.

       2      L’arrondi se fait vers l’infini positive.

       3      L’arrondi se fait vers l’infini négatif.

       Les  autres  valeurs  sont dépendantes des machines, et ne sont pas des
       modes d’arrondi standard.

       La valeur de FLT_ROUNDS devrait refléter le mode  d’arrondis  en  cours
       tel  qu’il  est  configuré  par fesetround() (mais consultez la section
       BOGUES).

   Environnement en virgule flottante
       L’environnement de travail en virgule flottante, y compris les modes de
       contrôle  et les drapeaux d’état 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 d’un programme, et elle est définie par
       ISO  C  comme  ayant  un  arrondi au plus proche, toutes les exceptions
       effacées et un mode sans arrêt (continuer en présence des  exceptions).

       La  fonction  fegetenv()  sauve  l’environnement de travail en cours en
       virgule flottante 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 sans arrêt
       (continuer en présence des exceptions). Elle renvoie  zéro  en  cas  de
       succès.

       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   d’un   appel   à  fegetenv(),  de
       feholdexcept() ou  égal  à  FE_DFL_ENV.  Cet  appel  ne  déclenche  pas
       d’exception.

       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   *envp  doit être
       valide.

VALEUR RENVOYÉE

       Ces fonctions renvoient 0 en cas de succès et une valeur non  nulle  en
       cas d’erreur.

VERSIONS

       Ces fonctions ont été introduites dans la glibc dans sa version 2.1.

CONFORMITÉ

       IEC 60559 (IEC 559:1989), ANSI/IEEE 854, C99, POSIX.1-2001.

NOTES

   Notes sur la glibc
       Si  possible, la bibliothèque GNU C définit une macro FE_NOMASK_ENV qui
       représente un environnement lorsque toutes les  exceptions  déclenchées
       entraîne  une interception. La présence de cette macro peut être testée
       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 comment
       positionner les bits individuels dans le masque de  virgule  flottante,
       par  exemple  pour  intercepter des drapeaux particuliers. La glibc 2.2
       gère    feenableexcept()    et    fedisableexcept()    pour     définir
       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)  les  interceptions 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.

BOGUES

       C99  spécifie  que  la  valeur  de  FLT_ROUNDS  devrait  refléter   les
       changements  du mode d’arrondis en cours, tels qu’ils sont demandés par
       fesetround(). Actuellement, ce n’est  pas  le  cas :  FLT_ROUNDS  prend
       toujours la valeur 1.

VOIR AUSSI

       feature_test_macros(7), math_error(7)

COLOPHON

       Cette  page  fait  partie  de  la  publication 3.17 du projet man-pages
       Linux. Une description du projet et des instructions pour signaler  des
       anomalies       peuvent       être       trouvées      à      l’adresse
       http://www.kernel.org/doc/man-pages/.

TRADUCTION

       Cette page de manuel a été traduite  et  mise  à  jour  par  Christophe
       Blaess  <http://www.blaess.fr/christophe/> entre 1996 et 2003, puis par
       Alain Portal <aportal AT univ-montp2 DOT fr> jusqu’en 2006, et  mise  à
       disposition sur http://manpagesfr.free.fr/.

       Les mises à jour et corrections de la version présente dans Debian sont
       directement gérées par Florentin Duneau <fduneau@gmail.com> et l’équipe
       francophone de traduction de Debian.

       Veuillez   signaler   toute   erreur   de   traduction  en  écrivant  à
       <debian-l10n-french@lists.debian.org> ou par un rapport de bogue sur le
       paquet manpages-fr.

       Vous  pouvez  toujours avoir accès à la version anglaise de ce document
       en utilisant la commande « man -L C <section> <page_de_man> ».