std::nearbyint, std::nearbyintf, std::nearbyintl

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Numerik-Bibliothek

Allgemeine mathematische Funktionen
Mathematische Spezialfunktionen (C++17)
Mathematische Konstanten (C++20)
Grundlegende lineare Algebra-Algorithmen (C++26)
Datenparallele Typen (SIMD) (C++26)
Gleitkomma-Umgebung (C++11)
Komplexe Zahlen
Numerische Arrays (valarray)
Pseudozufallszahlengenerierung
Bit-Manipulation (C++20)
Faktoroperationen
gcd (C++17)	lcm (C++17)
Interpolationen
midpoint (C++20)	lerp (C++20)
Sättigungsarithmetik
add_sat (C++26) sub_sat (C++26) saturate_cast (C++26)	mul_sat (C++26) div_sat (C++26)
Generische numerische Operationen
iota (C++11) ranges::iota (C++23) accumulate inner_product adjacent_difference    partial_sum	reduce (C++17) transform_reduce (C++17) inclusive_scan (C++17) exclusive_scan (C++17) transform_inclusive_scan (C++17) transform_exclusive_scan (C++17)

 

Allgemeine mathematische Funktionen

Funktionen
Grundlegende Operationen
abs(int)labsllabsimaxabs (C++11)   abs(float)fabs divldivlldivimaxdiv (C++11)	fmod remainder (C++11)   remquo (C++11) fma (C++11) fmax (C++11) fmin (C++11) fdim (C++11) nannanfnanl (C++11)(C++11)(C++11)
Exponentialfunktionen
exp exp2 (C++11) expm1 (C++11)	log log10 log1p (C++11) log2 (C++11)
Potenzfunktionen
sqrt cbrt (C++11)	hypot (C++11) pow
Trigonometrische und hyperbolische Funktionen
sin cos tan asin acos atan atan2	sinh cosh tanh asinh (C++11) acosh (C++11) atanh (C++11)
Fehler- und Gammafunktionen
erf (C++11) erfc (C++11)	lgamma (C++11) tgamma (C++11)

Rundungsoperationen für Gleitkommazahlen
ceil floor roundlroundllround (C++11)(C++11)(C++11)	trunc (C++11) nearbyint (C++11) rintlrintllrint (C++11)(C++11)(C++11)
Gleitkomma-Manipulationsfunktionen
ldexp scalbnscalbln (C++11)(C++11) ilogb (C++11) logb (C++11)	frexp modf nextafternexttoward (C++11)(C++11) copysign (C++11)
Klassifizierung und Vergleich
fpclassify (C++11) isfinite (C++11) isinf (C++11) isnan (C++11) isnormal (C++11) signbit (C++11)	isgreater (C++11) isgreaterequal (C++11) isless (C++11) islessequal (C++11) islessgreater (C++11) isunordered (C++11)
Typen
div_t ldiv_t lldiv_t (C++11)	imaxdiv_t (C++11) float_t (C++11) double_t (C++11)
Makrokonstanten
HUGE_VALFHUGE_VALHUGE_VALL (C++11)(C++11) math_errhandlingMATH_ERRNOMATH_ERREXCEPT (C++11)   INFINITY (C++11) NAN (C++11)	Klassifizierung FP_NORMALFP_SUBNORMALFP_ZEROFP_INFINITEFP_NAN (C++11)(C++11)(C++11)(C++11)(C++11)

 

Definiert in der Header-Datei <cmath>
	(1)
float        nearbyint ( float num ); double      nearbyint ( double num ); long double nearbyint ( long double num );			(bis C++23)
/* Gleitkommazahl-Typ */             nearbyint ( /*Gleitkommazahltyp*/ num );			(seit C++23)
float        nearbyintf( float num );		(2)	(seit C++11)
long double    nearbyintl( long double num );		(3)	(seit C++11)
SIMD-Überladung (seit C++26)
Definiert im Header <simd>
template< /*math-floating-point*/ V > constexpr /*deduzierter-simd-t*/<V>             nearbyint ( const V& v_num );		(S)	(seit C++26)
Zusätzliche Überladungen (seit C++11)
Definiert in der Header-Datei <cmath>
template< class Integer > double      nearbyint ( Integer num );		(A)

1-3) Rundet das Gleitkommaargument num auf einen Ganzzahlwert im Gleitkommaformat, unter Verwendung des aktuellen Rundungsmodus. Die Bibliothek stellt Überladungen von std::nearbyint für alle cv-unqualifizierten Gleitkommatypen als Parametertyp bereit.(seit C++23)

S) Die SIMD-Überladung führt ein elementweises std::nearbyint für v_num durch. (Siehe math-floating-point und deduced-simd-t für ihre Definitionen.)

(seit C++26)

A) Zusätzliche Überladungen werden für alle ganzzahligen Typen bereitgestellt, die als double behandelt werden.

(seit C++11)

Parameter

num

-

Gleitkomma- oder Ganzzahlwert

Rückgabewert

Der nächste Ganzzahlwert zu num, entsprechend dem aktuellen Rundungsmodus, wird zurückgegeben.

Fehlerbehandlung

Diese Funktion unterliegt keiner der in math_errhandling spezifizierten Fehler.

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

• FE_INEXACT wird nie ausgelöst.
• 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.

Hinweise

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

Die größten darstellbaren Gleitkommawerte sind in allen Standard-Gleitkommaformaten exakte Ganzzahlen, daher tritt bei std::nearbyint kein Überlauf auf; das Ergebnis kann jedoch jeden Ganzzahltyp (einschließlich std::intmax_t) überlaufen, wenn es in einer Ganzzahlvariable gespeichert wird.

Wenn der aktuelle Rundungsmodus FE_TONEAREST ist, rundet diese Funktion bei Halbwertfällen auf die nächste gerade Zahl (wie std::rint, aber im Gegensatz zu std::round).

Die zusätzlichen Überladungen müssen nicht exakt wie (A) bereitgestellt werden. Sie müssen nur ausreichend sein, um sicherzustellen, dass für ihr Argument num vom Ganzzahltyp std::nearbyint(num) denselben Effekt hat wie std::nearbyint(static_cast<double>(num)).

Beispiel

Führen Sie diesen Code aus

#include <cfenv>
#include <cmath>
#include <iostream>
#pragma STDC FENV_ACCESS ON
 
int main()
{
    std::fesetround(FE_TONEAREST);
    std::cout << "rounding to nearest: \n"
              << "nearbyint(+2.3) = " << std::nearbyint(2.3)
              << "  nearbyint(+2.5) = " << std::nearbyint(2.5)
              << "  nearbyint(+3.5) = " << std::nearbyint(3.5) << '\n'
              << "nearbyint(-2.3) = " << std::nearbyint(-2.3)
              << "  nearbyint(-2.5) = " << std::nearbyint(-2.5)
              << "  nearbyint(-3.5) = " << std::nearbyint(-3.5) << '\n';
 
    std::fesetround(FE_DOWNWARD);
    std::cout << "rounding down:\n"
              << "nearbyint(+2.3) = " << std::nearbyint(2.3)
              << "  nearbyint(+2.5) = " << std::nearbyint(2.5)
              << "  nearbyint(+3.5) = " << std::nearbyint(3.5) << '\n'
              << "nearbyint(-2.3) = " << std::nearbyint(-2.3)
              << "  nearbyint(-2.5) = " << std::nearbyint(-2.5)
              << "  nearbyint(-3.5) = " << std::nearbyint(-3.5) << '\n';
 
    std::cout << "nearbyint(-0.0) = " << std::nearbyint(-0.0)  << '\n'
              << "nearbyint(-Inf) = " << std::nearbyint(-INFINITY) << '\n';
}

Ausgabe

rounding to nearest: 
nearbyint(+2.3) = 2  nearbyint(+2.5) = 2  nearbyint(+3.5) = 4
nearbyint(-2.3) = -2  nearbyint(-2.5) = -2  nearbyint(-3.5) = -4
rounding down:
nearbyint(+2.3) = 2  nearbyint(+2.5) = 2  nearbyint(+3.5) = 3
nearbyint(-2.3) = -3  nearbyint(-2.5) = -3  nearbyint(-3.5) = -4
nearbyint(-0.0) = -0
nearbyint(-Inf) = -inf

Siehe auch

rintrintfrintllrintlrintflrintlllrintllrintfllrintl (C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)	nächste ganze Zahl unter Verwendung des aktuellen Rundungsmodus mit Ausnahme, wenn das Ergebnis abweicht (Funktion)
roundroundfroundllroundlroundflroundlllroundllroundfllroundl (C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)	nächste ganze Zahl, Rundung weg von Null bei Halbwertigkeiten (Funktion)
fegetroundfesetround (C++11)(C++11)	holt oder setzt die Rundungsrichtung (function)
C-Dokumentation für nearbyint