rint, rintf, rintl, lrint, lrintf, lrintl, llrint, llrintf, llrintl

 

C

Compiler-Unterstützung

Sprache

Header

Typunterstützung

Programm-Dienstprogramme

Unterstützung für variable Funktionsargumente

Fehlerbehandlung

Dynamische Speicherverwaltung

Bibliothek für Zeichenketten

Algorithmen

Numerik

Datums- und Zeitdienstprogramme

Ein-/Ausgabeunterstützung

Lokalisierungsunterstützung

Unterstützung für Nebenläufigkeit (C11)

Technische Spezifikationen

Symbolindex

 

Numerik

Allgemeine mathematische Funktionen

Gleitkomma-Umgebung (C99)

Pseudozufallszahlengenerierung

Komplexe Arithmetik (C99)

Typ-generierte Mathematik (C99)

Bitmanipulation (C23)

Geprüfte Ganzzahl-Arithmetik (C23)

 

Allgemeine mathematische Funktionen

Funktionen Grundlegende Operationen abslabsllabsimaxabs (C99)(C99) fabs divldivlldivimaxdiv (C99)(C99) fmod remainder (C99) remquo (C99) fma (C99) fdim (C99) nannanfnanlnandN (C99)(C99)(C99)(C23) Maximum/Minimum-Operationen fmax (C99) fmin (C99) fmaximum (C23) fminimum (C23) fmaximum_mag (C23)  fmaximum_num (C23) fminimum_mag (C23) fminimum_num (C23) fmaximum_mag_num (C23) fminimum_mag_num (C23)   Exponentialfunktionen exp exp10 (C23) exp2 (C99) expm1 (C99) exp10m1 (C23) exp2m1 (C23) log log10 log2 (C99) log1plogp1 (C99)(C23) log10p1 (C23) log2p1 (C23) Potenzfunktionen sqrt cbrt (C99) rootn (C23) rsqrt (C23) hypot (C99) compound (C23) pow pown (C23) powr (C23) Trigonometrische und hyperbolische Funktionen sin cos tan asin acos atan atan2 sinpi (C23) cospi (C23) tanpi (C23) asinpi (C23) acospi (C23) atanpi (C23) atan2pi (C23) sinh cosh tanh asinh (C99) acosh (C99) atanh (C99)

Nächste ganze Gleitkommazahlen ceil floor roundlroundllround (C99)(C99)(C99) roundeven (C23) trunc (C99) nearbyint (C99) rintlrintllrint (C99)(C99)(C99) fromfpfromfpxufromfpufromfpx (C23)(C23)(C23)(C23) Gleitkomma-Manipulation ldexp frexp scalbnscalbln (C99)(C99) ilogbllogb (C99)(C23) logb (C99) modf nextafternexttoward (C99)(C99) nextupnextdown (C23)(C23) copysign (C99) canonicalize (C23) Verengende Operationen fadd (C23) fsub (C23) fmul (C23) fdiv (C23) ffma (C23) fsqrt (C23) Quanten- und Quantenexponent-Funktionen quantizedN (C23) quantumdN (C23) samequantumdN (C23) llquantexpdN (C23) Dezimal-Neu-Kodierungsfunktionen encodedecdN (C23) decodedecdN (C23) encodebindN (C23) decodebindN (C23) Gesamtordnung und Payload-Funktionen totalorder (C23) getpayload (C23) setpayload (C23) setpayloadsig (C23) Klassifizierung fpclassify (C99) iscanonical (C23)  isfinite (C99) isinf (C99) isnan (C99) isnormal (C99) signbit (C99) issubnormal (C23) iszero (C23) isgreater (C99) isgreaterequal (C99)   isless (C99) islessequal (C99) islessgreater (C99) isunordered (C99) issignaling (C23) iseqsig (C23)

Fehler- und Gammafunktionen erf (C99) erfc (C99) lgamma (C99) tgamma (C99) Typen div_tldiv_tlldiv_timaxdiv_t (C99)(C99) float_tdouble_t (C99)(C99) _Decimal32_t_Decimal64_t (C23)(C23) Makrokonstanten Spezielle Gleitkommawerte HUGE_VALHUGE_VALFHUGE_VALLHUGE_VALDN (C99)(C99)(C23) INFINITYDEC_INFINITY (C99)(C23) NANDEC_NAN (C99)(C23) Argumente und Rückgabewerte FP_ILOGB0FP_ILOGBNAN (C99)(C99) FP_NORMALFP_SUBNORMALFP_ZEROFP_INFINITEFP_NAN (C99)(C99)(C99)(C99)(C99) FP_LLOGB0FP_LLOGBNAN (C23)(C23) FP_INT_UPWARDFP_INT_DOWNWARDFP_INT_TOWARDZEROFP_INT_TONEARESTFROMZEROFP_INT_TONEAREST (C23)(C23)(C23)(C23)(C23) Fehlerbehandlung MATH_ERRNOMATH_ERRNOEXCEPT (C99)(C99)  math_errhandling (C99) Schnelle Operationsanzeigen FP_FAST_FMAFFP_FAST_FMA (C99)(C99) FP_FAST_FADDFP_FAST_FADDLFP_FAST_DADDLFP_FAST_DMADDDN (C23)(C23)(C23)(C23) FP_FAST_FMULFP_FAST_FMULLFP_FAST_DMULLFP_FAST_DMMULDN (C23)(C23)(C23)(C23) FP_FAST_FFMAFP_FAST_FFMALFP_FAST_DFMALFP_FAST_DMFMADN (C23)(C23)(C23)(C23) FP_FAST_FMALFP_FAST_FMADN (C99)(C23) FP_FAST_FSUBFP_FAST_FSUBLFP_FAST_DSUBLFP_FAST_DMSUBDN (C23)(C23)(C23)(C23) FP_FAST_FDIVFP_FAST_FDIVLFP_FAST_DDIVLFP_FAST_DMDIVDN (C23)(C23)(C23)(C23) FP_FAST_FSQRTFP_FAST_FSQRTLFP_FAST_DSQRTLFP_FAST_DMSQRTDN (C23)(C23)(C23)(C23)

 

Definiert in Header <math.h>
float rintf( float arg );	(1)	(seit C99)
double rint( double arg );	(2)	(seit C99)
long double rintl( long double arg );	(3)	(seit C99)
Definiert in Header <tgmath.h>
#define rint( arg )	(4)	(seit C99)
Definiert in Header <math.h>
long lrintf( float arg );	(5)	(seit C99)
long lrint( double arg );	(6)	(seit C99)
long lrintl( long double arg );	(7)	(seit C99)
Definiert in Header <tgmath.h>
#define lrint( arg )	(8)	(seit C99)
Definiert in Header <math.h>
long long llrintf( float arg );	(9)	(seit C99)
long long llrint( double arg );	(10)	(seit C99)
long long llrintl( long double arg );	(11)	(seit C99)
Definiert in Header <tgmath.h>
#define llrint( arg )	(12)	(seit C99)

1-3) Rundet das Gleitkommaargument arg gemäß dem aktuellen Rundungsmodus auf einen ganzzahligen Wert im Gleitkommaformat.

5-7, 9-11) Rundet das Gleitkommaargument arg gemäß dem aktuellen Rundungsmodus auf einen ganzzahligen Wert im Ganzzahlformat.

4,8,12) Typerdefinierende Makros: Wenn arg den Typ long double hat, wird rintl, lrintl, llrintl aufgerufen. Andernfalls, wenn arg einen ganzzahligen Typ oder den Typ double hat, werden rint, lrint, llrint aufgerufen. Andernfalls werden rintf, lrintf, llrintf aufgerufen.

Parameter

arg

-

Gleitkommawert

Rückgabewert

Wenn keine Fehler auftreten, wird der ganzzahlige Wert, der dem Argument arg am nächsten liegt, gemäß dem aktuellen Rundungsmodus zurückgegeben.

Fehlerbehandlung

Fehler werden wie in math_errhandling angegeben gemeldet.

Wenn das Ergebnis von lrint oder 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 rint

• Wenn arg ±∞ ist, wird es unverändert zurückgegeben.
• Wenn arg ±0 ist, wird es unverändert zurückgegeben.
• Wenn arg NaN ist, wird NaN zurückgegeben.

Für die Funktionen lrint und llrint

• Wenn arg ±∞ ist, wird FE_INVALID ausgelöst und ein implementierungsabhängiger Wert zurückgegeben.
• Wenn das Ergebnis der Rundung außerhalb des Bereichs des Rückgabetyps liegt, wird FE_INVALID ausgelöst und ein implementierungsabhängiger Wert zurückgegeben.
• Wenn arg NaN ist, wird FE_INVALID ausgelöst und ein implementierungsabhängiger Wert zurückgegeben.

Hinweise

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

Wie in math_errhandling angegeben, kann FE_INEXACT (auf nicht-IEEE-Gleitkomma-Plattformen aber nicht zwingend) von rint ausgelöst werden, wenn eine endliche Nicht-Ganzzahl gerundet wird.

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

Die größten darstellbaren Gleitkommawerte sind in allen Standard-Gleitkommaformaten exakte ganze Zahlen, daher führt rint an sich nie zu einem Überlauf; das Ergebnis kann jedoch jeden ganzzahligen Typ (einschließlich intmax_t) überschreiten, wenn es in einer Ganzzahlvariable gespeichert wird.

Wenn der aktuelle Rundungsmodus...

• FE_DOWNWARD ist, dann ist rint äquivalent zu floor.
• FE_UPWARD ist, dann ist rint äquivalent zu ceil.
• FE_TOWARDZERO ist, dann ist rint äquivalent zu trunc.
• FE_TONEAREST ist, dann unterscheidet sich rint von round darin, dass Halb-Fälle zum nächsten geraden Wert gerundet werden und nicht vom Nullpunkt weg.

Beispiel

Führen Sie diesen Code aus

#include <fenv.h>
#include <limits.h>
#include <math.h>
#include <stdio.h>
 
int main(void)
{
#pragma STDC FENV_ACCESS ON
    fesetround(FE_TONEAREST);
    printf("rounding to nearest (halfway cases to even):\n"
           "rint(+2.3) = %+.1f  ", rint(2.3));
    printf("rint(+2.5) = %+.1f  ", rint(2.5));
    printf("rint(+3.5) = %+.1f\n", rint(3.5));
    printf("rint(-2.3) = %+.1f  ", rint(-2.3));
    printf("rint(-2.5) = %+.1f  ", rint(-2.5));
    printf("rint(-3.5) = %+.1f\n", rint(-3.5));
 
    fesetround(FE_DOWNWARD);
    printf("rounding down: \nrint(+2.3) = %+.1f  ", rint(2.3));
    printf("rint(+2.5) = %+.1f  ", rint(2.5));
    printf("rint(+3.5) = %+.1f\n", rint(3.5));
    printf("rint(-2.3) = %+.1f  ", rint(-2.3));
    printf("rint(-2.5) = %+.1f  ", rint(-2.5));
    printf("rint(-3.5) = %+.1f\n", rint(-3.5));
    printf("rounding down with lrint: \nlrint(+2.3) = %ld  ", lrint(2.3));
    printf("lrint(+2.5) = %ld  ", lrint(2.5));
    printf("lrint(+3.5) = %ld\n", lrint(3.5));
    printf("lrint(-2.3) = %ld  ", lrint(-2.3));
    printf("lrint(-2.5) = %ld  ", lrint(-2.5));
    printf("lrint(-3.5) = %ld\n", lrint(-3.5));
 
    printf("lrint(-0.0) = %ld\n", lrint(-0.0));
    printf("lrint(-Inf) = %ld\n", lrint(-INFINITY)); // FE_INVALID raised
 
    // error handling
    feclearexcept(FE_ALL_EXCEPT);
    printf("rint(1.1) = %.1f\n", rint(1.1));
    if (fetestexcept(FE_INEXACT))
        puts("    FE_INEXACT was raised");
 
    feclearexcept(FE_ALL_EXCEPT);
    printf("lrint(LONG_MIN-2048.0) = %ld\n", lrint(LONG_MIN-2048.0));
    if (fetestexcept(FE_INVALID))
        puts("    FE_INVALID was raised");
}

Mögliche Ausgabe

rounding to nearest (halfway cases to even):
rint(+2.3) = +2.0  rint(+2.5) = +2.0  rint(+3.5) = +4.0
rint(-2.3) = -2.0  rint(-2.5) = -2.0  rint(-3.5) = -4.0
rounding down:
rint(+2.3) = +2.0  rint(+2.5) = +2.0  rint(+3.5) = +3.0
rint(-2.3) = -3.0  rint(-2.5) = -3.0  rint(-3.5) = -4.0
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
lrint(-0.0) = 0
lrint(-Inf) = -9223372036854775808
rint(1.1) = 1.0
    FE_INEXACT was raised
lrint(LONG_MIN-2048.0) = -9223372036854775808
    FE_INVALID was raised

Referenzen

• C23-Standard (ISO/IEC 9899:2024)

• 7.12.9.4 The rint functions (p: TBD)

• 7.12.9.5 The lrint and llrint functions (p: TBD)

• 7.25 Typ-generische Mathematik <tgmath.h> (S. TBD)

• F.10.6.4 The rint functions (p: TBD)

• F.10.6.5 The lrint and llrint functions (p: TBD)

• C17-Standard (ISO/IEC 9899:2018)

• 7.12.9.4 The rint functions (p: 184)

• 7.12.9.5 The lrint and llrint functions (p: 184)

• 7.25 Typ-generische Mathematik <tgmath.h> (S. 272-273)

• F.10.6.4 The rint functions (p: 384)

• F.10.6.5 The lrint and llrint functions (p: 384)

• C11-Standard (ISO/IEC 9899:2011)

• 7.12.9.4 The rint functions (p: 252)

• 7.12.9.5 The lrint and llrint functions (p: 252)

• 7.25 Typ-generische Mathematik <tgmath.h> (S. 373-375)

• F.10.6.4 The rint functions (p: 527)

• F.10.6.5 The lrint and llrint functions (p: 527)

• C99-Standard (ISO/IEC 9899:1999)

• 7.12.9.4 The rint functions (p: 232-233)

• 7.12.9.5 The lrint and llrint functions (p: 233)

• 7.22 Typ-generische Mathematik <tgmath.h> (S. 335-337)

• F.9.6.4 The rint functions (p: 463)

• F.9.6.5 The lrint and llrint functions (p: 463)

Siehe auch

trunctruncftruncl (C99)(C99)(C99)	rundet auf die größte ganze Zahl, deren Betrag nicht größer als der gegebene Wert ist (Funktion)
nearbyintnearbyintfnearbyintl (C99)(C99)(C99)	rundet auf eine ganze Zahl gemäß der aktuellen Rundungsregel (Funktion)
fegetroundfesetround (C99)(C99)	holt oder setzt die Rundungsrichtung (function)
C++ Dokumentation für rint