round, roundf, roundl, lround, lroundf, lroundl, llround, llroundf, llroundl

Paramètres

Valeur de retour

Si aucune erreur ne se produit, la valeur entière la plus proche de arg , en arrondissant les cas à mi-chemin vers zéro, est retournée.

Valeur de retour

Argument

Si une erreur de domaine se produit, une valeur définie par l'implémentation est retournée.

Gestion des erreurs

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

Si le résultat de lround ou llround est en dehors de la plage représentable par le type de retour, une erreur de domaine ou une erreur de plage peut survenir.

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

Pour les fonctions round , roundf , et roundl :

• Le mode d'arrondi actuel n'a aucun effet.
• Si arg est ±∞, il est retourné, non modifié.
• Si arg est ±0, il est retourné, non modifié.
• Si arg est NaN, NaN est retourné.

Pour les familles de fonctions lround et llround :

• FE_INEXACT n'est jamais déclenchée.
• Le mode d'arrondi actuel n'a aucun effet.
• Si arg est ±∞, FE_INVALID est déclenchée et une valeur définie par l'implémentation est retournée
• Si le résultat de l'arrondi est en dehors de la plage du type de retour, FE_INVALID est déclenchée et une valeur définie par l'implémentation est retournée.
• Si arg est NaN, FE_INVALID est déclenchée et une valeur définie par l'implémentation est retournée.

Notes

FE_INEXACT peut être (mais n'est pas obligatoirement) déclenchée par round lors de l'arrondi d'une valeur finie non entière.

Les plus grandes valeurs représentables en virgule flottante sont des entiers exacts dans tous les formats standard de virgule flottante, donc round ne provoque jamais de dépassement par lui-même ; cependant le résultat peut dépasser la capacité de tout type entier (y compris intmax_t ), lorsqu'il est stocké dans une variable entière.

POSIX spécifie que tous les cas où lround ou llround lèvent FE_INVALID sont des erreurs de domaine.

La version double de round se comporte comme si elle était implémentée comme suit :

#include <math.h>
#pragma STDC FENV_ACCESS ON
double round(double x)
{
    return signbit(x) ? ceil(x - 0.5) : floor(x + 0.5);
}

Exemple

#include <assert.h>
#include <fenv.h>
#include <float.h>
#include <limits.h>
#include <math.h>
#include <stdio.h>
// #pragma STDC FENV_ACCESS ON
double custom_round(double x)
{
    return signbit(x) ? ceil(x - 0.5) : floor(x + 0.5);
}
void test_custom_round()
{
    const double sample[] =
    {
        0.0, 2.3, 2.5 - DBL_EPSILON, 2.5, 2.5 + DBL_EPSILON, 2.7, INFINITY
    };
    for (size_t t = 0; t < sizeof sample / sizeof(double); ++t)
        assert(round(+sample[t]) == custom_round(+sample[t]) &&
               round(-sample[t]) == custom_round(-sample[t]));
}
int main(void)
{
    // round
    printf("round(+2.3) = %+.1f  ", round(2.3));
    printf("round(+2.5) = %+.1f  ", round(2.5));
    printf("round(+2.7) = %+.1f\n", round(2.7));
    printf("round(-2.3) = %+.1f  ", round(-2.3));
    printf("round(-2.5) = %+.1f  ", round(-2.5));
    printf("round(-2.7) = %+.1f\n", round(-2.7));
    printf("round(-0.0) = %+.1f\n", round(-0.0));
    printf("round(-Inf) = %+f\n",   round(-INFINITY));
    test_custom_round();
    // lround
    printf("lround(+2.3) = %+ld  ", lround(2.3));
    printf("lround(+2.5) = %+ld  ", lround(2.5));
    printf("lround(+2.7) = %+ld\n", lround(2.7));
    printf("lround(-2.3) = %+ld  ", lround(-2.3));
    printf("lround(-2.5) = %+ld  ", lround(-2.5));
    printf("lround(-2.7) = %+ld\n", lround(-2.7));
    printf("lround(-0.0) = %+ld\n", lround(-0.0));
    printf("lround(-Inf) = %+ld\n", lround(-INFINITY)); // FE_INVALID raised
    // error handling
    feclearexcept(FE_ALL_EXCEPT);
    printf("lround(LONG_MAX+1.5) = %ld\n", lround(LONG_MAX + 1.5));
    if (fetestexcept(FE_INVALID))
        puts("    FE_INVALID was raised");
}

round(+2.3) = +2.0  round(+2.5) = +3.0  round(+2.7) = +3.0
round(-2.3) = -2.0  round(-2.5) = -3.0  round(-2.7) = -3.0
round(-0.0) = -0.0
round(-Inf) = -inf
lround(+2.3) = +2  lround(+2.5) = +3  lround(+2.7) = +3
lround(-2.3) = -2  lround(-2.5) = -3  lround(-2.7) = -3
lround(-0.0) = +0
lround(-Inf) = -9223372036854775808
lround(LONG_MAX+1.5) = -9223372036854775808
    FE_INVALID was raised

Références

Voir aussi