NOM

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

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

       Éditer les liens avec -lm.

   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
               || /* Versions <= 2.19 de la glibc : */ _BSD_SOURCE || _SVID_SOURCE
       nextafterf(), nextafterl() :
           _ISOC99_SOURCE || _POSIX_C_SOURCE >= 200112L
               || /* Depuis la glibc 2.19 : */ _DEFAULT_SOURCE
               || /* Versions <= 2.19 de la glibc : */ _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 ou y 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(),   │ Sécurité des threads │ MT-Safe │
       │ nextafterl(), nexttoward(),  │                      │         │
       │ nexttowardf(), nexttowardl() │                      │         │
       └──────────────────────────────┴──────────────────────┴─────────┘

CONFORMITÉ

       C99,  POSIX.1-2001,  POSIX.1-2008. This function is defined in IEC 559 (and the appendix with recommended
       functions in IEEE 754/IEEE 854).

BOGUES

       Dans la glibc version 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.

       Before glibc version 2.23 these functions did not set errno.

VOIR AUSSI

       nearbyint(3)

COLOPHON

       Cette page fait partie de la publication 5.10 du projet man-pages Linux. Une description du projet et des
       instructions  pour  signaler  des  anomalies et la dernière version de cette page peuvent être trouvées à
       l'adresse https://www.kernel.org/doc/man-pages/.

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> et Cédric Boutillier <cedric.boutillier@gmail.com>

       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.

GNU                                             21 décembre 2020                                    NEXTAFTER(3)