nextafter, nextafterf, nextafterl, nexttoward, nexttowardf, nexttowardl

Paramètres

Valeur de retour

Si aucune erreur ne se produit, la valeur représentable suivante de from dans la direction de to est retournée. Si from est égal à to , alors to est retourné, converti au type de la fonction.

Si une erreur de plage due à un dépassement de capacité se produit, ± HUGE_VAL , ±HUGE_VALF , ou ±HUGE_VALL est retourné (avec le même signe que from ).

Si une erreur de plage se produit en raison d'un dépassement inférieur, le résultat correct est retourné.

Gestion des erreurs

Les erreurs sont signalées comme spécifié dans math_errhandling .

Si l'implémentation prend en charge l'arithmétique à virgule flottante IEEE (IEC 60559),

• si from est fini, mais que le résultat attendu est un infini, lève FE_INEXACT et FE_OVERFLOW .
• si from n'est pas égal à to et que le résultat est sous-normal ou zéro, lève FE_INEXACT et FE_UNDERFLOW .
• dans tous les cas, la valeur retournée est indépendante du mode d'arrondi actuel
• si from ou to est NaN, NaN est retourné.

Notes

POSIX spécifie que les conditions de dépassement supérieur et de dépassement inférieur sont des erreurs de plage ( errno peut être défini).

La norme IEC 60559 recommande que from soit retourné lorsque from == to . Ces fonctions retournent to à la place, ce qui rend le comportement autour de zéro cohérent : nextafter(-0.0, +0.0) retourne + 0.0 et nextafter(+0.0, -0.0) retourne - 0.0 .

nextafter est généralement implémenté par manipulation de la représentation IEEE ( glibc musl ).

Exemple

#include <fenv.h>
#include <float.h>
#include <math.h>
#include <stdio.h>
int main(void)
{
    float from1 = 0, to1 = nextafterf(from1, 1);
    printf("Le prochain flottant représentable après %.2f est %.20g (%a)\n", from1, to1, to1);
    float from2 = 1, to2 = nextafterf(from2, 2);
    printf("Le prochain flottant représentable après %.2f est %.20f (%a)\n", from2, to2, to2);
    double from3 = nextafter(0.1, 0), to3 = 0.1;
    printf("Le nombre 0.1 se situe entre deux doubles valides :\n"
           "    %.56f (%a)\net %.55f  (%a)\n", from3, from3, to3, to3);
    // différence entre nextafter et nexttoward :
    long double dir = nextafterl(from1, 1); // premier long double subnormal
    float x = nextafterf(from1, dir); // convertit d'abord dir en float, donnant 0
    printf("En utilisant nextafter, le prochain flottant après %.2f (%a) est %.20g (%a)\n",
           from1, from1, x, x);
    x = nexttowardf(from1, dir);
    printf("En utilisant nexttoward, le prochain flottant après %.2f (%a) est %.20g (%a)\n",
           from1, from1, x, x);
    // valeurs spéciales
    {
        #pragma STDC FENV_ACCESS ON
        feclearexcept(FE_ALL_EXCEPT);
        double from4 = DBL_MAX, to4 = nextafter(from4, INFINITY);
        printf("Le prochain double représentable après %.2g (%a) est %.23f (%a)\n",
               from4, from4, to4, to4);
        if(fetestexcept(FE_OVERFLOW)) puts("   a déclenché FE_OVERFLOW");
        if(fetestexcept(FE_INEXACT)) puts("   a déclenché FE_INEXACT");
    } // fin du bloc FENV_ACCESS
    float from5 = 0.0, to5 = nextafter(from5, -0.0);
    printf("nextafter(+0.0, -0.0) donne %.2g (%a)\n", to5, to5);
}

Le prochain flottant représentable après 0.00 est 1.4012984643248170709e-45 (0x1p-149)
Le prochain flottant représentable après 1.00 est 1.00000011920928955078 (0x1.000002p+0)
Le nombre 0.1 se situe entre deux doubles valides :
    0.09999999999999999167332731531132594682276248931884765625 (0x1.9999999999999p-4)
et 0.1000000000000000055511151231257827021181583404541015625  (0x1.999999999999ap-4)
En utilisant nextafter, le prochain flottant après 0.00 (0x0p+0) est 0 (0x0p+0)
En utilisant nexttoward, le prochain flottant après 0.00 (0x0p+0) est 1.4012984643248170709e-45 (0x1p-149)
Le prochain double représentable après 1.8e+308 (0x1.fffffffffffffp+1023) est inf (inf)
   a déclenché FE_OVERFLOW
   a déclenché FE_INEXACT
nextafter(+0.0, -0.0) donne -0 (-0x0p+0)

Références

Voir aussi