NOM

       nextafter,  nextafterf,  nextafterl,  nexttoward,  nexttowardf,  nexttowardl - Manipulation de nombres en
       virgule flottante

BIBLIOTHÈQUE

       Bibliothèque de math (libm, -lm)

SYNOPSIS

       #include <math.h>

       double nextafter(double x, double y);
       float nextafterf(float x, float y);
       long double nextafterl(long double x, long double y);

       double nexttoward(double x, long double y);
       float nexttowardf(float x, long double y);
       long double nexttowardl(long double x, long double y);

   Exigences de macros de test de fonctionnalités pour la glibc (consulter feature_test_macros(7)) :

       nextafter() :
           _ISOC99_SOURCE || _POSIX_C_SOURCE >= 200112L
               || _XOPEN_SOURCE >= 500
               || /* Depuis la glibc 2.19 : */ _DEFAULT_SOURCE
               || /* glibc <= 2.19 : */ _BSD_SOURCE || _SVID_SOURCE

       nextafterf(), nextafterl() :
           _ISOC99_SOURCE || _POSIX_C_SOURCE >= 200112L
               || /* Depuis la glibc 2.19 : */ _DEFAULT_SOURCE
               || /* glibc <= 2.19 : */ _BSD_SOURCE || _SVID_SOURCE

       nexttoward(), nexttowardf(), nexttowardl() :
           _XOPEN_SOURCE >= 600 || _ISOC99_SOURCE
               || _POSIX_C_SOURCE >= 200112L

DESCRIPTION

       Les fonctions nextafter(), nextafterf() et nextafterl() renvoient la valeur en virgule flottante  pouvant
       être  représentée  suivant  x dans la direction de y. Si y est inférieur à x, ces fonctions renverront la
       valeur la plus élevée pouvant être représentée inférieure à x.

       Si x est égal à y, la fonction renvoie y.

       Les fonctions nexttoward(), nexttowardf() et nexttowardl() réalisent le même travail  que  les  fonctions
       nextafter() correspondantes sauf qu'elles ont un second argument de type long double.

VALEUR RENVOYÉE

       En  cas  de  réussite,  ces  fonctions  renvoient  la  valeur  en virgule flottante suivante pouvant être
       représentée après x dans la direction de y.

       Si x est égal à y, alors y (converti dans le même type que x) est renvoyé.

       Si x n’est pas un nombre, un NaN est renvoyé.

       Si x est une valeur finie et que le résultat produit un dépassement, une erreur d'intervalle est produite
       et les fonctions renvoient HUGE_VAL, HUGE_VALF ou HUGE_VALL, resp. avec le bon signe mathématique.

       Si x n'est pas égal à  y  et  que  le  résultat  correct  de  la  fonction  aurait  dû  être  dénormalisé
       («  subnormal  »),  zéro,  ou  en  cas de soupassement (« underflow »), alors une erreur d'intervalle est
       produite et la valeur renvoyée est soit la valeur correcte (si elle peut être représentée), soit 0.

ERREURS

       Voir math_error(7) pour savoir comment déterminer si une erreur s'est produite lors de l'appel  d'une  de
       ces fonctions.

       Les erreurs suivantes peuvent se produire :

       Erreur de plage : débordement du résultat
              errno  est  configurée  à  ERANGE.  Une  exception de dépassement par le haut de virgule flottante
              (FE_OVERFLOW) est levée.

       Erreur d'intervalle : le résultat est dénormalisé ou un soupassement se produit.
              errno prend la valeur ERANGE. Une exception  de  dépassement  par  le  bas  de  virgule  flottante
              (FE_UNDERFLOW) est levée.

ATTRIBUTS

       Pour une explication des termes utilisés dans cette section, consulter attributes(7).
       ┌──────────────────────────────────────────────────────────────────────┬──────────────────────┬─────────┐
       │ Interface                                                            │ Attribut             │ Valeur  │
       ├──────────────────────────────────────────────────────────────────────┼──────────────────────┼─────────┤
       │ nextafter(), nextafterf(), nextafterl(), nexttoward(),               │ Sécurité des threads │ MT-Safe │
       │ nexttowardf(), nexttowardl()                                         │                      │         │
       └──────────────────────────────────────────────────────────────────────┴──────────────────────┴─────────┘

STANDARDS

       C11, POSIX.1-2008.

       Cette   fonction   est   définie   dans   IEC  559  (et  l'annexe  avec  les  fonctions  recommandées  de
       IEEE 754/IEEE 854).

HISTORIQUE

       C99, POSIX.1-2001.

BOGUES

       Dans la glibc 2.5 et antérieures, ces  fonction  ne  lèvent  pas  d'exception  de  virgule  flottante  de
       soupassement (FE_UNDERFLOW) quand un soupassement se produit.

       Avant la glibc 2.23, ces fonctions n'affectaient pas de valeur à errno.

VOIR AUSSI

       nearbyint(3)

TRADUCTION

       La   traduction   française   de   cette   page   de   manuel   a   été   créée   par  Christophe  Blaess
       <https://www.blaess.fr/christophe/>,   Stéphan   Rafin   <stephan.rafin@laposte.net>,   Thierry   Vignaud
       <tvignaud@mandriva.com>,  François  Micaux,  Alain Portal <aportal@univ-montp2.fr>, Jean-Philippe Guérard
       <fevrier@tigreraye.org>,   Jean-Luc   Coulon   (f5ibh)   <jean-luc.coulon@wanadoo.fr>,   Julien   Cristau
       <jcristau@debian.org>,      Thomas      Huriaux      <thomas.huriaux@gmail.com>,     Nicolas     François
       <nicolas.francois@centraliens.net>,    Florentin    Duneau    <fduneau@gmail.com>,     Simon     Paillard
       <simon.paillard@resel.enst-bretagne.fr>,     Denis    Barbier    <barbier@debian.org>,    David    Prévot
       <david@tilapin.org>,  Cédric  Boutillier  <cedric.boutillier@gmail.com>  et  Jean-Pierre  Giraud   <jean-
       pierregiraud@neuf.fr>

       Cette  traduction  est  une  documentation libre ; veuillez vous reporter à la GNU General Public License
       version 3 concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.

       Si vous découvrez un bogue dans la traduction de cette page de manuel,  veuillez  envoyer  un  message  à
       debian-l10n-french@lists.debian.org.

Pages du manuel de Linux 6.9.1                     2 mai 2024                                       nextafter(3)