Provided by: manpages-fr_3.32d0.2p4-1_all bug

NOM

       math_error - Detecter des erreurs des fonctions mathematiques

SYNOPSIS

       #include <math.h>
       #include <errno.h>
       #include <fenv.h>

DESCRIPTION

       Quand  une erreur se produit, la plupart des fonctions de bibliotheques
       l'indiquent en renvoyant une valeur speciale (par exemple, -1 ou NULL).
       Parce qu'elles renvoient en general un nombre en virgule flottante, les
       fonctions mathematiques declarees dans <math.h> indiquent une erreur en
       utilisant  d'autres  mecanismes.  Il  y  a deux mecanismes d'indication
       d'erreur : l'ancien configure errno ; le nouveau utilise  le  mecanisme
       d'exception  de virgule flottante (l'utilisation de feclearexcept(3) et
       fetestexcept(3), comme explicite ci-dessous) decrit dans fenv(3).

       Un programme portable qui doit  verifier  les  erreurs  d'une  fonction
       mathematique devrait mettre errno a zero et effectuer l'appel suivant :

           feclearexcept(FE_ALL_EXCEPT);

       avant d'appeler une fonction mathematique.

       Apres le retour d'une fonction mathematique, si errno est non nul ou si
       l'appel suivant (consultez fenv(3)) ne renvoie pas zero :

           fetestexcept(FE_INVALID | FE_DIVBYZERO | FE_OVERFLOW |
                        FE_UNDERFLOW);

       alors une erreur s'est produite dans la fonction mathematique.

       Les conditions d'erreur qui peuvent  se  produire  pour  les  fonctions
       mathematiques sont decrites ci-dessous.

   Erreur de domaine
       Une erreur de domaine se produit quand une fonction mathematique recoit
       un parametre  dont  la  valeur  se  trouve  en  dehors  du  domaine  de
       definition  de la fonction (par exemple, fournir un parametre negatif a
       log(3)).  Lorsqu'une  erreur  de  domaine  se  produit,  les  fonctions
       renvoient  generalement  un NaN (mais certaines fonctions renvoient une
       valeur differente dans ce cas) ; errno prend  la  valeur  EDOM  et  une
       exception de virgule flottante << incorrecte >> (FE_INVALID) est levee.

   Erreur de p^ole
       Une  erreur  de  p^ole  se  produit quand le resultat mathematique d'une
       fonction est un infini (par exemple, le logarithme de  0  est  l'infini
       negatif).  Quand  une erreur de pole se produit, la fonction renvoie la
       valeur (signee) HUGE_VAL, HUGE_VALF ou HUGE_VALL suivant que la  valeur
       de  retour de la fonction est un double, un float ou un long double. Le
       signe du  resultat  est  celui  du  resultat  correct  de  la  fonction
       mathematique.  errno prend la valeur ERANGE et une exception de virgule
       flottante de division par zero (FE_DIVBYZERO) est levee.

   Erreur d'intervalle
       Une erreur d'intervalle se produit quand le module du  resultat  de  la
       fonction  ne  peut  pas  etre  represente  par  le type utilise pour le
       resultat de la fonction. La valeur de  retour  de  la  fonction  depend
       suivant   qu'il   s'agit  d'un  depassement  (<< overflow >>)  ou  d'un
       soupassement (<< underflow >>).

       Un d'epassement se produit pour le resultat flottant si le resultat  est
       fini,  mais  trop  grand pour etre represente dans le type du resultat.
       Quand  un  depassement  se  produit,  la  fonction  renvoie  la  valeur
       HUGE_VAL,  HUGE_VALF  ou HUGE_VALL, suivant que le type de retour de la
       fonction est un double, un float ou un  long  double.  errno  prend  la
       valeur  ERANGE  et  une  exception  de virgule flottante de depassement
       (FE_OVERFLOW) est levee.

       Un soupassement se produit pour le resultat flottant si le resultat est
       trop  petit  pour  etre  represente  dans le type du resultat. Quand un
       soupassement se produit, une fonction mathematique renvoie generalement
       0,0  (C99  indique qu'une fonction doit renvoyer << une valeur propre a
       l'implementation dont le module n'est pas plus grand que la plus petite
       valeur  normalisee  positive  du  type donne >>). errno prend la valeur
       ERANGE  et  une  exception  de  virgule   flottante   de   soupassement
       (FE_UNDERFLOW) peut etre levee.

       Certaines  fonctions produisent une erreur d'intervalle si la valeur du
       parametre fourni, ou le resultat exact de la fonction, est  d'enormalis'e
       (<< subnormal >>). Une valeur denormalisee est une valeur qui n'est pas
       nulle, mais dont le module est si petit qu'il ne peut  etre  represente
       dans  la  forme normalisee (c'est-a-dire avec un 1 dans le bit de poids
       fort  de  la  mantisse).  La  representation  d'un  nombre  denormalise
       contiendra un ou plusieurs zeros en tete de la mantisse.

NOTES

       L'identifiant  math_errhandling  specifie par C99 et POSIX.1-2001 n'est
       pas pris en charge par la glibc. Cet identifiant est  suppose  indiquer
       lequel  des deux mecanismes d'indication d'erreur est utilise (errno ou
       des exceptions recuperables avec fettestexcept(3)). Les normes imposent
       qu'au moins l'un d'entre eux soit utilise, mais autorisent a ce que les
       deux  soient  disponibles.  La   situation   actuelle   de   la   glibc
       (version 2.8) n'est pas tres propre. La plupart des fonctions (mais pas
       toutes) levent des exceptions en cas d'erreur.  Certaines  positionnent
       egalement  errno. Quelques fonctions positionnent errno, mais ne levent
       pas d'exception. Tres peu ne font ni l'un  ni  l'autre.  Consultez  les
       differentes pages de manuel pour avoir les details.

       Pour  eviter  la complexite d'avoir a utiliser errno et fetestexcept(3)
       pour la detection d'erreurs, il est souvent recommande de  verifier  la
       validite  des parametres avant les appels. Par exemple, le code suivant
       s'assure que le parametre de log(3) n'est  ni  un  NaN,  ni  zero  (une
       erreur de pole) ou inferieur a zero (une erreur de domaine) :

           double x, r;

           if (isnan(x) || islessequal(x, 0)) {
               /* Deal with NaN / pole error / domain error */
           }

           r = log(x);

       La   discussion   sur  cette  page  ne  s'applique  pas  aux  fonctions
       mathematiques a variables complexes (c'est-a-dire celles declarees  par
       <complex.h>),  pour  lesquelles  C99  et  POSIX.1-2001 n'exigent pas en
       general de renvoyer d'erreurs.

       L'option   de   gcc(1)   -fno-math-errno    permet    d'utiliser    des
       implementations  de  certaines fonctions mathematiques plus rapides que
       les implementations  standard,  mais  qui  ne  positionnent  pas  errno
       (l'option  -ffast-math de gcc(1) active egalement -fno-math-errno). Une
       erreur peut toujours etre testee en utilisant fetestexcept(3).

VOIR AUSSI

       gcc(1), errno(3), fenv(3),  fpclassify(3),  INFINITY(3),  isgreater(3),
       matherr(3), nan(3)
       info libc

COLOPHON

       Cette  page  fait  partie  de  la  publication 3.32 du projet man-pages
       Linux. Une description du projet et des instructions pour signaler  des
       anomalies       peuvent       etre       trouvees      a      l'adresse
       <URL:http://www.kernel.org/doc/man-pages/>.

TRADUCTION

       Depuis 2010, cette traduction est maintenue a l'aide  de  l'outil  po4a
       <URL:http://po4a.alioth.debian.org/>   par   l'equipe   de   traduction
       francophone       au       sein        du        projet        perkamon
       <URL:http://perkamon.alioth.debian.org/>.

       Alain Portal <URL:http://manpagesfr.free.fr/> (2008).

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

       Vous  pouvez  toujours avoir acces a la version anglaise de ce document
       en utilisant la commande << man -L C <section> <page_de_man> >>.

Linux                            11 aout 2008                    MATH_ERROR(7)