std:: round, std:: roundf, std:: roundl, std:: lround, std:: lroundf, std:: lroundl, std:: llround, std:: llroundf

Paramètres

Valeur de retour

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

Valeur de retour

num

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 std::lround ou std::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 la fonction std::round :

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

Pour les fonctions std::lround et std::llround :

• FE_INEXACT n'est jamais déclenchée.
• Le mode d'arrondi actuel n'a aucun effet.
• Si num 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 num 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 std::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 std::round ne provoque jamais de dépassement de capacité par lui-même ; cependant le résultat peut dépasser la capacité de tout type entier (y compris std::intmax_t ), lorsqu'il est stocké dans une variable entière.

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

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

#include <cfenv>
#include <cmath>
#pragma STDC FENV_ACCESS ON
double round(double x)
{
    const int save_round = std::fegetround();
    std::fesetround(FE_TOWARDZERO);
    const double result = std::rint(std::copysign(0.5 + std::fabs(x), x));
    std::fesetround(save_round);
    return result;
}

Les surcharges supplémentaires ne sont pas obligées d'être fournies exactement comme (A-C) . Elles doivent seulement être suffisantes pour garantir que pour leur argument num de type entier :

• std :: round ( num ) a le même effet que std :: round ( static_cast < double > ( num ) ) .
• std :: lround ( num ) a le même effet que std :: lround ( static_cast < double > ( num ) ) .
• std :: llround ( num ) a le même effet que std :: llround ( static_cast < double > ( num ) ) .

Exemple

#include <cassert>
#include <cfenv>
#include <cfloat>
#include <climits>
#include <cmath>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
double custom_round(double x)
{
    const int save_round = std::fegetround();
    std::fesetround(FE_TOWARDZERO);
    const double result = std::rint(std::copysign(0,5 + std::fabs(x), x));
    std::fesetround(save_round);
    return result;
}
void test_custom_round()
{
    for (const double x :
        {
            0.0, 0.3,
            0,5 - DBL_EPSILON / 2,
            0,5,
            0,5 + DBL_EPSILON / 2,
            0,7, 1.0, 2.3, 2.5, 2.7, 3.0,
            static_cast<double>(INFINITY)
        })
        assert(round(+x) == custom_round(+x) && round(-x) == custom_round(-x));
}
int main()
{
    test_custom_round();
    std::cout << std::showpos;
    // arrondir
    std::cout << "round(+2.3) = " << std::round(2.3)
              << "  round(+2.5) = " << std::round(2.5)
              << "  round(+2.7) = " << std::round(2.7) << '\n'
              << "round(-2.3) = " << std::round(-2.3)
              << "  round(-2.5) = " << std::round(-2.5)
              << "  round(-2.7) = " << std::round(-2.7) << '\n';
    std::cout << "round(-0.0) = " << std::round(-0.0)  << '\n'
              << "round(-Inf) = " << std::round(-INFINITY) << '\n';
    // lround
    std::cout << "lround(+2.3) = " << std::lround(2.3)
              << "  lround(+2.5) = " << std::lround(2.5)
              << "  lround(+2.7) = " << std::lround(2.7) << '\n'
              << "lround(-2.3) = " << std::lround(-2.3)
              << "  lround(-2.5) = " << std::lround(-2.5)
              << "  lround(-2.7) = " << std::lround(-2.7) << '\n';
    std::cout << "lround(-0.0) = " << std::lround(-0.0)  << '\n'
              << "lround(-Inf) = " << std::lround(-INFINITY) << '\n';
    // gestion des erreurs
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "std::lround(LONG_MAX+1.5) = "
              << std::lround(LONG_MAX + 1.5) << '\n';
    if (std::fetestexcept(FE_INVALID))
        std::cout << "    FE_INVALID a été déclenché\n";
}

round(+2.3) = +2  round(+2.5) = +3  round(+2.7) = +3
round(-2.3) = -2  round(-2.5) = -3  round(-2.7) = -3
round(-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
std::lround(LONG_MAX+1.5) = -9223372036854775808
    FE_INVALID a été déclenché

Voir aussi