Namensräume
Varianten
Aktionen

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

Von cppreference.com
< cpp‎ | numeric‎ | math
 
C++
 
Numerik-Bibliothek
 
Allgemeine mathematische Funktionen
Rundungsoperationen für Gleitkommazahlen
(C++11)(C++11)(C++11)
(C++11)
(C++11)
rintlrintllrint
(C++11)(C++11)(C++11)
Gleitkomma-Manipulationsfunktionen
(C++11)(C++11)
(C++11)
(C++11)
(C++11)(C++11)
(C++11)
Klassifizierung und Vergleich
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Typen
(C++11)
(C++11)
(C++11)
Makrokonstanten
 
Definiert in der Header-Datei <cmath>
Runden auf Gleitkommatypen
(1)
float        rint ( float num );

double      rint ( double num );

long double  rint ( long double num );
 (seit C++11)
(bis C++23)
/* gleitkomma-typ */ rint( /* gleitkomma-typ */ num );
 (seit C++23)
float       rintf( float num );
 (2) (seit C++11)
long double rintl( long double num );
 (3) (seit C++11)
Runden auf long
(4)
long        lrint ( float num );

long        lrint ( double num );

long        lrint ( long double num );
 (seit C++11)
(bis C++23)
long       lrint ( /* gleitkomma-typ */ num );
 (seit C++23)
long       lrintf( float num );
 (5) (seit C++11)
long       lrintl( long double num );
 (6) (seit C++11)
Runden auf long long
(7)
long long    llrint ( float num );

long long  llrint ( double num );

long long  llrint ( long double num );
 (seit C++11)
(bis C++23)
long long   llrint ( /* gleitkomma-typ */ num );
 (seit C++23)
long long   llrintf( float num );
 (8) (seit C++11)
long long   llrintl( long double num );
 (9) (seit C++11)
Definiert in der Header-Datei <cmath>
template< class Integer >
double rint( Integer num );
 (A) (seit C++11)
template< class Integer >
long lrint( Integer num );
 (B) (seit C++11)
template< class Integer >
long long llrint( Integer num );
 (C) (seit C++11)
1-3) Rundet das Gleitkommaargument num auf einen ganzzahligen Wert (im Gleitkommaformat) unter Verwendung des aktuellen Rundungsmodus. Die Bibliothek stellt Überladungen von std::rint für alle nicht qualifizierten Gleitkommatypen als Parametertyp num bereit.(seit C++23)
4-9) Rundet das Gleitkommaargument num auf einen ganzzahligen Wert unter Verwendung des aktuellen Rundungsmodus. Die Bibliothek stellt Überladungen von std::lrint und std::llrint für alle nicht qualifizierten Gleitkommatypen als Parametertyp num bereit.(seit C++23)
A-C) Zusätzliche Überladungen werden für alle ganzzahligen Typen bereitgestellt, die als double behandelt werden.

Inhalt

[edit] Parameter

num - Gleitkomma- oder Ganzzahlwert

[edit] Rückgabewert

Wenn keine Fehler auftreten, wird der nächstgelegene ganzzahlige Wert zu num zurückgegeben, entsprechend dem aktuellen Rundungsmodus.

[edit] Fehlerbehandlung

Fehler werden wie in math_errhandling beschrieben gemeldet.

Wenn das Ergebnis von std::lrint oder std::llrint außerhalb des durch den Rückgabetyp darstellbaren Bereichs liegt, kann ein Domänenfehler oder ein Bereichsfehler auftreten.

Wenn die Implementierung IEEE-Gleitkomma-Arithmetik (IEC 60559) unterstützt,

Für die Funktion std::rint
  • Wenn num ±∞ ist, wird es unverändert zurückgegeben.
  • Wenn num ±0 ist, wird es unverändert zurückgegeben.
  • Wenn num NaN ist, wird NaN zurückgegeben.
Für die Funktionen std::lrint und std::llrint
  • Wenn num ±∞ ist, wird FE_INVALID ausgelöst und ein implementierungsdefinierter Wert zurückgegeben.
  • Wenn das Ergebnis der Rundung außerhalb des Bereichs des Rückgabetyps liegt, wird FE_INVALID ausgelöst und ein implementierungsdefinierter Wert zurückgegeben.
  • Wenn num NaN ist, wird FE_INVALID ausgelöst und ein implementierungsdefinierter Wert zurückgegeben.

[edit] Hinweise

POSIX spezifiziert, dass alle Fälle, in denen std::lrint oder std::llrint FE_INEXACT auslösen, Domänenfehler sind.

Wie in math_errhandling spezifiziert, kann FE_INEXACT (aber nicht zwangsläufig auf Nicht-IEEE-Gleitkomma-Plattformen) von std::rint ausgelöst werden, wenn ein nicht ganzzahliger endlicher Wert gerundet wird.

Der einzige Unterschied zwischen std::rint und std::nearbyint besteht darin, dass std::nearbyint niemals FE_INEXACT auslöst.

Die größten darstellbaren Gleitkommawerte sind in allen standardmäßigen Gleitkommaformaten exakte ganze Zahlen, daher tritt bei std::rint kein Überlauf auf; das Ergebnis kann jedoch jeden Ganzzahltyp (einschließlich std::intmax_t) überlaufen, wenn es in einer Ganzzahlvariablen gespeichert wird.

Wenn der aktuelle Rundungsmodus

Die zusätzlichen Überladungen müssen nicht exakt als (A-C) bereitgestellt werden. Sie müssen nur ausreichen, um sicherzustellen, dass für ihr Argument num vom ganzzahligen Typ

  • std::rint(num) dieselbe Wirkung hat wie std::rint(static_cast<double>(num)).
  • std::lrint(num) hat dieselbe Wirkung wie std::lrint(static_cast<double>(num)).
  • std::llrint(num) hat dieselbe Wirkung wie std::llrint(static_cast<double>(num)).

[edit] Beispiel

Führen Sie diesen Code aus
#include <cfenv>
#include <climits>
#include <cmath>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
 
int main()
{
    std::fesetround(FE_TONEAREST);
    std::cout << "Rounding to nearest (halfway cases to even):\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 << "Rounding down:\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'
              << "Rounding down with 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'
              << "Special values:\n"
              << "  lrint(-0.0) = " << std::lrint(-0.0) << '\n'
              << std::hex << std::showbase
              << "  lrint(-Inf) = " << std::lrint(-INFINITY) << '\n';
 
    // error handling
    std::feclearexcept(FE_ALL_EXCEPT);
 
    std::cout << "std::rint(0.1) = " << std::rint(.1) << '\n';
    if (std::fetestexcept(FE_INEXACT))
        std::cout << "  FE_INEXACT was raised\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 was raised\n";
}

Mögliche Ausgabe

Rounding to nearest (halfway cases to even):
  rint(+2.3) = 2
  rint(+2.5) = 2
  rint(+3.5) = 4
  rint(-2.3) = -2
  rint(-2.5) = -2
  rint(-3.5) = -4
Rounding down:
  rint(+2.3) = 2
  rint(+2.5) = 2
  rint(+3.5) = 4
  rint(-2.3) = -2
  rint(-2.5) = -2
  rint(-3.5) = -4
Rounding down with 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
Special values:
  lrint(-0.0) = 0
  lrint(-Inf) = 0x8000000000000000
std::rint(0.1) = 0
std::lrint(LONG_MIN-2048.0) = 0x8000000000000000
  FE_INVALID was raised

[edit] Siehe auch

(C++11)(C++11)(C++11)
 nächste ganze Zahl, die nicht größer im Betrag ist als der gegebene Wert
(Funktion) [bearbeiten]
(C++11)(C++11)(C++11)
 nächste ganze Zahl unter Verwendung des aktuellen Rundungsmodus
(Funktion) [bearbeiten]
(C++11)(C++11)
 holt oder setzt die Rundungsrichtung
(function) [bearbeiten]
C-Dokumentation für rint
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/numeric/math/rint&oldid=160769"