std:: rint, std:: rintf, std:: rintl, std:: lrint, std:: lrintf, std:: lrintl, std:: llrint, std:: llrintf

Paramètres

Valeur de retour

Si aucune erreur ne se produit, la valeur entière la plus proche de num , selon le mode d'arrondi actuel , est retournée.

Gestion des erreurs

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

Si le résultat de std::lrint ou std::llrint 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::rint :

• 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::lrint et std::llrint :

• Si num est ±∞, FE_INVALID est déclenché 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é et une valeur définie par l'implémentation est retournée.
• Si num est NaN, FE_INVALID est déclenché et une valeur définie par l'implémentation est retournée.

Notes

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

Comme spécifié dans math_errhandling , FE_INEXACT peut être (mais n'est pas requis sur les plateformes à virgule flottante non-IEEE) déclenché par std::rint lors de l'arrondi d'une valeur finie non entière.

La seule différence entre std::rint et std::nearbyint est que std::nearbyint ne lève jamais FE_INEXACT .

Les plus grandes valeurs représentables en virgule flottante sont des entiers exacts dans tous les formats standard de virgule flottante, donc std::rint 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.

Si le mode d'arrondi actuel est :

• FE_DOWNWARD , alors std::rint est équivalent à std::floor .
• FE_UPWARD , alors std::rint est équivalent à std::ceil .
• FE_TOWARDZERO , alors std::rint est équivalent à std::trunc .
• FE_TONEAREST , alors std::rint diffère de std::round en ce que les cas à mi-chemin sont arrondis vers le pair plutôt que vers zéro.

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 :: rint ( num ) a le même effet que std :: rint ( static_cast < double > ( num ) ) .
• std :: lrint ( num ) a le même effet que std :: lrint ( static_cast < double > ( num ) ) .
• std :: llrint ( num ) a le même effet que std :: llrint ( static_cast < double > ( num ) ) .

Exemple

#include <cfenv>
#include <climits>
#include <cmath>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
int main()
{
    std::fesetround(FE_TONEAREST);
    std::cout << "Arrondi au plus proche (cas à mi-chemin vers le pair) :\n"
              << "  rint(+2.3) = " << std::rint(2.3) << '\n'
              << "  rint(+2.5) = " << std::rint(2.5) << '\n'
              << "  rint(+3.5) = " << std::rint(3.5) << '\n'
              << "  rint(-2.3) = " << std::rint(-2.3) << '\n'
              << "  rint(-2.5) = " << std::rint(-2.5) << '\n'
              << "  rint(-3.5) = " << std::rint(-3.5) << '\n';
    std::fesetround(FE_DOWNWARD);
    std::cout << "Arrondi vers le bas :\n"
              << "  rint(+2.3) = " << std::rint(2.3) << '\n'
              << "  rint(+2.5) = " << std::rint(2.5) << '\n'
              << "  rint(+3.5) = " << std::rint(3.5) << '\n'
              << "  rint(-2.3) = " << std::rint(-2.3) << '\n'
              << "  rint(-2.5) = " << std::rint(-2.5) << '\n'
              << "  rint(-3.5) = " << std::rint(-3.5) << '\n'
              << "Arrondi vers le bas avec lrint :\n"
              << "  lrint(+2.3) = " << std::lrint(2.3) << '\n'
              << "  lrint(+2.5) = " << std::lrint(2.5) << '\n'
              << "  lrint(+3.5) = " << std::lrint(3.5) << '\n'
              << "  lrint(-2.3) = " << std::lrint(-2.3) << '\n'
              << "  lrint(-2.5) = " << std::lrint(-2.5) << '\n'
              << "  lrint(-3.5) = " << std::lrint(-3.5) << '\n'
              << "Valeurs spéciales :\n"
              << "  lrint(-0.0) = " << std::lrint(-0.0) << '\n'
              << std::hex << std::showbase
              << "  lrint(-Inf) = " << std::lrint(-INFINITY) << '\n';
    // gestion des erreurs
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "std::rint(0.1) = " << std::rint(.1) << '\n';
    if (std::fetestexcept(FE_INEXACT))
        std::cout << "  FE_INEXACT a été déclenché\n";
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "std::lrint(LONG_MIN-2048.0) = "
              << std::lrint(LONG_MIN - 2048.0) << '\n';
    if (std::fetestexcept(FE_INVALID))
        std::cout << "  FE_INVALID a été déclenché\n";
}

Arrondi au plus proche (cas médians vers l'égalité) :
  rint(+2.3) = 2
  rint(+2.5) = 2
  rint(+3.5) = 4
  rint(-2.3) = -2
  rint(-2.5) = -2
  rint(-3.5) = -4
Arrondi vers le bas :
  rint(+2.3) = 2
  rint(+2.5) = 2
  rint(+3.5) = 4
  rint(-2.3) = -2
  rint(-2.5) = -2
  rint(-3.5) = -4
Arrondi vers le bas avec lrint :
  lrint(+2.3) = 2
  lrint(+2.5) = 2
  lrint(+3.5) = 3
  lrint(-2.3) = -3
  lrint(-2.5) = -3
  lrint(-3.5) = -4
Valeurs spéciales :
  lrint(-0.0) = 0
  lrint(-Inf) = 0x8000000000000000
std::rint(0.1) = 0
std::lrint(LONG_MIN-2048.0) = 0x8000000000000000
  FE_INVALID a été déclenchée

Voir aussi