Standard library header <cmath>

From cppreference.net

Dieser Header war ursprünglich in der C-Standardbibliothek als <math.h> enthalten.

Dieser Header ist Teil der numeric Bibliothek.

**Übersetzungserläuterungen:** - HTML-Tags und Attribute wurden unverändert beibehalten - C++-spezifische Begriffe (`asin`, `asinf`, `asinl`, `C++11`) wurden nicht übersetzt - Mathematische Formeln in ` ` und ` ` wurden nicht übersetzt - "computes arc sine" wurde präzise als "berechnet den Arkussinus" übersetzt - "(function)" wurde als "(Funktion)" übersetzt - Die Formatierung und Struktur des Original-HTML wurde vollständig erhalten **Übersetzungserläuterungen:** - "cylindrical Bessel functions (of the first kind)" → "Zylinder-Bessel-Funktionen (erster Art)" - Fachbegriff aus der Mathematik - "(function)" → "(Funktion)" - Standardübersetzung für Programmierungskontext - Alle HTML-Tags, Attribute und C++-spezifische Begriffe (wie Funktionsnamen) wurden unverändert beibehalten - Die Formatierung und Struktur des HTML-Codes wurde exakt erhalten

Inhaltsverzeichnis

Typen

float_t

(C++11)

effizientester Gleitkommatyp mit mindestens der Breite von float
(typedef)

double_t

(C++11)

effizientester Gleitkommatyp mit mindestens der Breite von double
(typedef)

Makros

HUGE_VALF HUGE_VAL HUGE_VALL

(C++11) (C++11)

kennzeichnet den Überlaufwert für float , double und long double entsprechend
(Makrokonstante)

INFINITY

(C++11)

ergibt positive Unendlichkeit oder den Wert, der garantiert einen float überlauf verursacht
(Makrokonstante)

NAN

(C++11)

ergibt einen stillen NaN vom Typ float
(Makrokonstante)

math_errhandling MATH_ERRNO MATH_ERREXCEPT

(C++11) (C++11) (C++11)

definiert den Fehlerbehandlungsmechanismus, der von den allgemeinen mathematischen Funktionen verwendet wird
(Makrokonstante)

Klassifikation

FP_NORMAL FP_SUBNORMAL FP_ZERO FP_INFINITE FP_NAN

(C++11) (C++11) (C++11) (C++11) (C++11)

kennzeichnet eine Gleitkomma-Kategorie an
(Makrokonstante)

Funktionen

Grundlegende Operationen

abs (float) fabs fabsf fabsl

(C++11) (C++11)

Absolutwert eines Gleitkommawerts (

|x|

)
(Funktion)

fmod fmodf fmodl

(C++11) (C++11)

Rest der Gleitkomma-Divisionsoperation
(Funktion)

remainder remainderf remainderl

(C++11) (C++11) (C++11)

Vorzeichenbehafteter Rest der Divisionsoperation
(Funktion)

remquo remquof remquol

(C++11) (C++11) (C++11)

Signierter Rest sowie die drei letzten Bits der Divisionsoperation
(Funktion)

fma fmaf fmal

(C++11) (C++11) (C++11)

Fused-Multiply-Add-Operation
(Funktion)

fmax fmaxf fmaxl

(C++11) (C++11) (C++11)

Größerer von zwei Gleitkommawerten
(Funktion)

fmin fminf fminl

(C++11) (C++11) (C++11)

kleinerer von zwei Gleitkommawerten
(Funktion)

fdim fdimf fdiml

(C++11) (C++11) (C++11)

positive Differenz zweier Gleitkommawerte (

max(0, x-y)

)
(Funktion)

nan nanf nanl

(C++11) (C++11) (C++11)

Keine-Zahl (NaN)
(Funktion)

Lineare Interpolation

lerp

(C++20)

Lineare Interpolationsfunktion
(Funktion)

Exponentialfunktionen

exp expf expl

(C++11) (C++11)

gibt

e

hoch den gegebenen Exponenten zurück (

e x

)
(Funktion)

exp2 exp2f exp2l

(C++11) (C++11) (C++11)

gibt

2

hoch der gegebenen Potenz zurück (

2 x

)
(Funktion)

expm1 expm1f expm1l

(C++11) (C++11) (C++11)

gibt

e

hoch der gegebenen Potenz zurück, minus

1

(

e x -1

)
(Funktion)

log logf logl

(C++11) (C++11)

berechnet den natürlichen Logarithmus (Basis

e

) (

ln(x)

)
(Funktion)

log10 log10f log10l

(C++11) (C++11)

berechnet den dekadischen Logarithmus (Basis

10

) (

log 10 (x)

)
(Funktion)

log2 log2f log2l

(C++11) (C++11) (C++11)

Basis-

2

Logarithmus der gegebenen Zahl (

log 2 (x)

)
(Funktion)

log1p log1pf log1pl

(C++11) (C++11) (C++11)

Natürlicher Logarithmus (zur Basis

e

) von

1

plus der gegebenen Zahl (

ln(1+x)

)
(Funktion)

Potenzfunktionen

pow powf powl

(C++11) (C++11)

potenziert eine Zahl mit dem gegebenen Exponenten (

x y

)
(Funktion)

sqrt sqrtf sqrtl

(C++11) (C++11)

berechnet Quadratwurzel (

\sqrt x

)
(Funktion)

cbrt cbrtf cbrtl

(C++11) (C++11) (C++11)

berechnet Kubikwurzel (

3 \sqrt x

)
(Funktion)

hypot hypotf hypotl

(C++11) (C++11) (C++11)

berechnet die Hypotenuse

\sqrt x 2 +y 2

und

\sqrt x 2 +y 2 +z 2

(since C++17)
(Funktion)

Trigonometrische Funktionen

sin sinf sinl

(C++11) (C++11)

berechnet den Sinus (

sin(x)

)
(Funktion)

cos cosf cosl

(C++11) (C++11)

berechnet den Kosinus (

cos(x)

)
(Funktion)

tan tanf tanl

(C++11) (C++11)

berechnet den Tangens (

tan(x)

)
(Funktion)

asin asinf asinl

(C++11) (C++11)

berechnet den Arkussinus (

arcsin(x)

)
(Funktion)

acos acosf acosl

(C++11) (C++11)

berechnet den Arkuskosinus (

arccos(x)

)
(Funktion)

atan atanf atanl

(C++11) (C++11)

berechnet den Arkustangens (

arctan(x)

)
(Funktion)

atan2 atan2f atan2l

(C++11) (C++11)

Arkustangens, unter Verwendung von Vorzeichen zur Bestimmung der Quadranten
(Funktion)

Hyperbelfunktionen

sinh sinhf sinhl

(C++11) (C++11)

berechnet den hyperbolischen Sinus (

sinh(x)

)
(Funktion)

cosh coshf coshl

(C++11) (C++11)

berechnet den hyperbolischen Kosinus (

cosh(x)

)
(Funktion)

tanh tanhf tanhl

(C++11) (C++11)

berechnet den hyperbolischen Tangens (

tanh(x)

)
(Funktion)

asinh asinhf asinhl

(C++11) (C++11) (C++11)

berechnet den Areasinus Hyperbolicus (

arsinh(x)

)
(Funktion)

acosh acoshf acoshl

(C++11) (C++11) (C++11)

berechnet den Areakosinus Hyperbolicus (

arcosh(x)

)
(Funktion)

atanh atanhf atanhl

(C++11) (C++11) (C++11)

berechnet den Areatangens Hyperbolicus (

artanh(x)

)
(Funktion)

Fehler- und Gammafunktionen

erf erff erfl

(C++11) (C++11) (C++11)

Fehlerfunktion
(Funktion)

erfc erfcf erfcl

(C++11) (C++11) (C++11)

Komplementäre Fehlerfunktion
(Funktion)

tgamma tgammaf tgammal

(C++11) (C++11) (C++11)

Gamma-Funktion
(Funktion)

lgamma lgammaf lgammal

(C++11) (C++11) (C++11)

Natürlicher Logarithmus der Gammafunktion
(Funktion)

Nächste Ganzzahl-Gleitkommaoperationen

ceil ceilf ceill

(C++11) (C++11)

nächstgelegene Ganzzahl, die nicht kleiner als der gegebene Wert ist
(Funktion)

floor floorf floorl

(C++11) (C++11)

nächstkleinere ganze Zahl nicht größer als der gegebene Wert
(Funktion)

trunc truncf truncl

(C++11) (C++11) (C++11)

nächstgelegene Ganzzahl, die nicht größer im Betrag als der gegebene Wert ist
(Funktion)

round roundf roundl lround lroundf lroundl llround llroundf llroundl

(C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11)

Nächste Ganzzahl, Rundung von Null weg in Halbwegsfällen
(Funktion)

nearbyint nearbyintf nearbyintl

(C++11) (C++11) (C++11)

nächste Ganzzahl unter Verwendung des aktuellen Rundungsmodus
(Funktion)

rint rintf rintl lrint lrintf lrintl llrint llrintf llrintl

(C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11)

nächstliegende Ganzzahl unter Verwendung des aktuellen Rundungsmodus mit
Ausnahme, wenn das Ergebnis abweicht
(Funktion)

Gleitkomma-Manipulationsfunktionen

frexp frexpf frexpl

(C++11) (C++11)

zerlegt eine Zahl in Signifikand und Basis-

2

-Exponent
(Funktion)

ldexp ldexpf ldexpl

(C++11) (C++11)

multipliziert eine Zahl mit

2

potenziert mit einem ganzzahligen Exponenten
(Funktion)

modf modff modfl

(C++11) (C++11)

zerlegt eine Zahl in Ganzzahl- und Nachkommateil
(Funktion)

scalbn scalbnf scalbnl scalbln scalblnf scalblnl

(C++11) (C++11) (C++11) (C++11) (C++11) (C++11)

multipliziert eine Zahl mit FLT_RADIX potenziert
(Funktion)

ilogb ilogbf ilogbl

(C++11) (C++11) (C++11)

extrahiert den Exponenten der Zahl
(Funktion)

logb logbf logbl

(C++11) (C++11) (C++11)

extrahiert den Exponenten der Zahl
(Funktion)

nextafter nextafterf nextafterl nexttoward nexttowardf nexttowardl

(C++11) (C++11) (C++11) (C++11) (C++11) (C++11)

Nächster darstellbarer Gleitkommawert in Richtung des gegebenen Werts
(Funktion)

copysign copysignf copysignl

(C++11) (C++11) (C++11)

kopiert das Vorzeichen eines Gleitkommawerts
(Funktion)

Klassifizierung und Vergleich

fpclassify

(C++11)

kategorisiert den angegebenen Gleitkommawert
(Funktion)

isfinite

(C++11)

prüft, ob die gegebene Zahl einen endlichen Wert hat
(Funktion)

isinf

(C++11)

prüft, ob die gegebene Zahl unendlich ist
(Funktion)

isnan

(C++11)

prüft, ob die gegebene Zahl NaN ist
(Funktion)

isnormal

(C++11)

prüft, ob die gegebene Zahl normal ist
(Funktion)

signbit

(C++11)

prüft, ob die gegebene Zahl negativ ist
(Funktion)

isgreater

(C++11)

prüft, ob das erste Gleitkomma-Argument größer als das zweite ist
(Funktion)

isgreaterequal

(C++11)

prüft, ob das erste Gleitkomma-Argument größer oder gleich dem zweiten ist
(Funktion)

isless

(C++11)

prüft, ob das erste Gleitkomma-Argument kleiner als das zweite ist
(Funktion)

islessequal

(C++11)

prüft, ob das erste Gleitkomma-Argument kleiner oder gleich dem zweiten ist
(Funktion)

islessgreater

(C++11)

prüft, ob das erste Gleitkomma-Argument kleiner oder größer als das zweite ist
(Funktion)

isunordered

(C++11)

prüft, ob zwei Gleitkommawerte ungeordnet sind
(Funktion)

Mathematische Spezialfunktionen

assoc_laguerre assoc_laguerref assoc_laguerrel

(C++17) (C++17) (C++17)

assoziierte Laguerre-Polynome
(Funktion)

assoc_legendre assoc_legendref assoc_legendrel

(C++17) (C++17) (C++17)

Assoziierte Legendre-Polynome
(Funktion)

beta betaf betal

(C++17) (C++17) (C++17)

Betafunktion
(Funktion)

comp_ellint_1 comp_ellint_1f comp_ellint_1l

(C++17) (C++17) (C++17)

(vollständiges) elliptisches Integral erster Art
(Funktion)

comp_ellint_2 comp_ellint_2f comp_ellint_2l

(C++17) (C++17) (C++17)

(vollständiges) elliptisches Integral zweiter Art
(Funktion)

comp_ellint_3 comp_ellint_3f comp_ellint_3l

(C++17) (C++17) (C++17)

(vollständiges) elliptisches Integral dritter Art
(Funktion)

cyl_bessel_i cyl_bessel_if cyl_bessel_il

(C++17) (C++17) (C++17)

Reguläre modifizierte zylindrische Bessel-Funktionen
(Funktion)

cyl_bessel_j cyl_bessel_jf cyl_bessel_jl

(C++17) (C++17) (C++17)

Zylinder-Bessel-Funktionen (erster Art)
(Funktion)

cyl_bessel_k cyl_bessel_kf cyl_bessel_kl

(C++17) (C++17) (C++17)

Irreguläre modifizierte zylindrische Bessel-Funktionen
(Funktion)

cyl_neumann cyl_neumannf cyl_neumannl

(C++17) (C++17) (C++17)

Zylindrische Neumann-Funktionen
(Funktion)

ellint_1 ellint_1f ellint_1l

(C++17) (C++17) (C++17)

(unvollständiges) elliptisches Integral erster Art
(Funktion)

ellint_2 ellint_2f ellint_2l

(C++17) (C++17) (C++17)

(unvollständiges) elliptisches Integral zweiter Art
(Funktion)

ellint_3 ellint_3f ellint_3l

(C++17) (C++17) (C++17)

(unvollständiges) elliptisches Integral dritter Art
(Funktion)

expint expintf expintl

(C++17) (C++17) (C++17)

Exponentialintegral
(Funktion)

hermite hermitef hermitel

(C++17) (C++17) (C++17)

Hermite-Polynome
(Funktion)

legendre legendref legendrel

(C++17) (C++17) (C++17)

Legendre-Polynome
(Funktion)

laguerre laguerref laguerrel

(C++17) (C++17) (C++17)

Laguerre-Polynome
(Funktion)

riemann_zeta riemann_zetaf riemann_zetal

(C++17) (C++17) (C++17)

Riemannsche Zeta-Funktion
(Funktion)

sph_bessel sph_besself sph_bessell

(C++17) (C++17) (C++17)

Sphärische Bessel-Funktionen (erster Art)
(Funktion)

sph_legendre sph_legendref sph_legendrel

(C++17) (C++17) (C++17)

Sphärische assoziierte Legendre-Funktionen
(Funktion)

sph_neumann sph_neumannf sph_neumannl

(C++17) (C++17) (C++17)

Sphärische Neumann-Funktionen
(Funktion)

Übersicht

Für jede Funktion mit mindestens einem Parameter vom Typ /* floating-point-type */ wird eine Überladung für jeden cv-unqualifizierten Gleitkommatyp bereitgestellt, bei der alle Verwendungen von /* floating-point-type */ in der Funktionssignatur durch diesen Gleitkommatyp ersetzt werden.

Für jede Funktion mit mindestens einem Parameter vom Typ /* floating-point-type */ außer std::abs werden zusätzliche Überladungen bereitgestellt, um sicherzustellen, dass, wenn jedes Argument, das einem /* floating-point-type */ -Parameter entspricht, einen arithmetischen Typ hat, dann jedes solche Argument effektiv in den Gleitkommatyp mit dem höchsten Gleitkomma-Konvertierungsrang und dem höchsten Gleitkomma-Konvertierungsunterrang unter den Typen aller solcher Argumente umgewandelt wird, wobei Argumente vom Ganzzahltyp als mit demselben Gleitkomma-Konvertierungsrang wie double betrachtet werden. Wenn kein solcher Gleitkommatyp mit dem höchsten Rang und Unterrang existiert, führt die Überladungsauflösung nicht zu einem verwendbaren Kandidaten aus den bereitgestellten Überladungen.

namespace std {
  using float_t = /* siehe Beschreibung */;
  using double_t = /* siehe Beschreibung */;
}
#define HUGE_VAL /* siehe Beschreibung */
#define HUGE_VALF /* siehe Beschreibung */
#define HUGE_VALL /* siehe Beschreibung */
#define INFINITY /* siehe Beschreibung */
#define NAN /* siehe Beschreibung */
#define FP_INFINITE /* siehe Beschreibung */
#define FP_NAN /* siehe Beschreibung */
#define FP_NORMAL /* Beschreibung siehe */
#define FP_SUBNORMAL /* siehe Beschreibung */
#define FP_ZERO /* siehe Beschreibung */
#define FP_FAST_FMA /* siehe Beschreibung */
#define FP_FAST_FMAF /* Beschreibung siehe */
#define FP_FAST_FMAL /* Beschreibung siehe */
#define FP_ILOGB0 /* siehe Beschreibung */
#define FP_ILOGBNAN /* siehe Beschreibung */
#define MATH_ERRNO /* siehe Beschreibung */
#define MATH_ERREXCEPT /* siehe Beschreibung */
#define math_errhandling /* siehe Beschreibung */
namespace std {
  /* Gleitkommatyp */ acos(/* Gleitkommatyp */ x);
  float acosf(float x);
  long double acosl(long double x);
  /* Gleitkommatyp */ asin(/* Gleitkommatyp */ x);
  float asinf(float x);
  long double asinl(long double x);
  /* Gleitkommatyp */ atan(/* Gleitkommatyp */ x);
  float atanf(float x);
  long double atanl(long double x);
  /* Gleitkommatyp */ atan2(/* Gleitkommatyp */ y,
                                  /* Gleitkommatyp */ x);
  float atan2f(float y, float x);
  long double atan2l(long double y, long double x);
  /* Gleitkommatyp */ cos(/* Gleitkommatyp */e x);
  float cosf(float x);
  long double cosl(long double x);
  /* Gleitkommatyp */ sin(/* Gleitkommatyp */ x);
  float sinf(float x);
  long double sinl(long double x);
  /* Gleitkommatyp */ tan(/* Gleitkommatyp */ x);
  float tanf(float x);
  long double tanl(long double x);
  /* Gleitkommatyp */ acosh(/* Gleitkommatyp */ x);
  float acoshf(float x);
  long double acoshl(long double x);
  /* Gleitkommatyp */ asinh(/* Gleitkommatyp */ x);
  float asinhf(float x);
  long double asinhl(long double x);
  /* Gleitkommatyp */ atanh(/* Gleitkommatyp */ x);
  float atanhf(float x);
  long double atanhl(long double x);
  /* Gleitkommatyp */ cosh(/* Gleitkommatyp */ x);
  float coshf(float x);
  long double coshl(long double x);
  /* Gleitkommatyp */ sinh(/* Gleitkommatyp */ x);
  float sinhf(float x);
  long double sinhl(long double x);
  /* Gleitkommatyp */ tanh(/* Gleitkommatyp */ x);
  float tanhf(float x);
  long double tanhl(long double x);
  /* Gleitkommatyp */ exp(/* Gleitkommatyp */ x);
  float expf(float x);
  long double expl(long double x);
  /* Gleitkommatyp */ exp2(/* Gleitkommatyp */ x);
  float exp2f(float x);
  long double exp2l(long double x);
  /* Gleitkommatyp */ expm1(/* Gleitkommatyp */ x);
  float expm1f(float x);
  long double expm1l(long double x);
  constexpr /* Gleitkommatyp */ frexp(/* Gleitkommatyp */ value, int* exp);
  constexpr float frexpf(float value, int* exp);
  constexpr long double frexpl(long double value, int* exp);
  constexpr int ilogb(/* Gleitkommatyp */ x);
  constexpr int ilogbf(float x);
  constexpr int ilogbl(long double x);
  constexpr /* Gleitkommatyp */ ldexp(/* Gleitkommatyp */ x, int exp);
  constexpr float ldexpf(float x, int exp);
  constexpr long double ldexpl(long double x, int exp);
  /* Gleitkommatyp */ log(/* Gleitkommatyp */ x);
  float logf(float x);
  long double logl(long double x);
  /* Gleitkommatyp */ log10(/* Gleitkommatyp */ x);
  float log10f(float x);
  long double log10l(long double x);
  /* Gleitkommatyp */ log1p(/* Gleitkommatyp */ x);
  float log1pf(float x);
  long double log1pl(long double x);
  /* Gleitkommatyp */ log2(/* Gleitkommatyp */ x);
  float log2f(float x);
  long double log2l(long double x);
  constexpr /* Gleitkommatyp */ logb(/* Gleitkommatyp */ x);
  constexpr float logbf(float x);
  constexpr long double logbl(long double x);
  constexpr /* Gleitkommatyp */ modf(/* Gleitkommatyp */ value,
                                           /* Gleitkommatyp */* iptr);
  constexpr float modff(float value, float* iptr);
  constexpr long double modfl(long double value, long double* iptr);
  constexpr /* Gleitkommatyp */ scalbn(/* Gleitkommatyp */ x, int n);
  constexpr float scalbnf(float x, int n);
  constexpr long double scalbnl(long double x, int n);
  constexpr /* Gleitkommatyp */ scalbln(/* Gleitkommatyp */ x, long int n);
  constexpr float scalblnf(float x, long int n);
  constexpr long double scalblnl(long double x, long int n);
  /* Gleitkommatyp */ cbrt(/* Gleitkommatyp */ x);
  float cbrtf(float x);
  long double cbrtl(long double x);
  // absolute Werte
  constexpr int abs(int j);                     // freestanding
  constexpr long int abs(long int j);           // freestanding
  constexpr long long int abs(long long int j); // freestanding
  constexpr /* Gleitkommatyp */
    abs(/* Gleitkommatyp */ j);           // freestanding-deleted
  constexpr /* Gleitkommatyp */ fabs(/* Gleitkommatyp */ x);
  constexpr float fabsf(float x);
  constexpr long double fabsl(long double x);
  /* Gleitkommatyp */ hypot(/* Gleitkommatyp */ x,
                                  /* Gleitkommatyp */ y);
  float hypotf(float x, float y);
  long double hypotl(long double x, long double y);
  // dreidimensionale Hypotenuse
  float hypot(/* Gleitkommatyp */ x,
              /* Gleitkommatyp */ y,
              /* Gleitkommatyp */ z);
  /* Gleitkommatyp */ pow(/* Gleitkommatyp */ x,
                                /* Gleitkommatyp */ y);
  float powf(float x, float y);
  long double powl(long double x, long double y);
  /* Gleitkommatyp */ sqrt(/* Gleitkommatyp */ x);
  float sqrtf(float x);
  long double sqrtl(long double x);
  /* Gleitkommatyp */ erf(/* Gleitkommatyp */ x);
  float erff(float x);
  long double erfl(long double x);
  /* Gleitkommatyp */ erfc(/* Gleitkommatyp */ x);
  float erfcf(float x);
  long double erfcl(long double x);
  /* Gleitkommatyp */ lgamma(/* Gleitkommatyp */ x);
  float lgammaf(float x);
  long double lgammal(long double x);
  /* Gleitkommatyp */ tgamma(/* Gleitkommatyp */ x);
  float tgammaf(float x);
  long double tgammal(long double x);
  constexpr /* Gleitkommatyp */ ceil(/* Gleitkommatyp */ x);
  constexpr float ceilf(float x);
  constexpr long double ceill(long double x);
  constexpr /* Gleitkommatyp */ floor(/* Gleitkommatyp */ x);
  constexpr float floorf(float x);
  constexpr long double floorl(long double x);
  /* Gleitkommatyp */ nearbyint(/* Gleitkommatyp */ x);
  float nearbyintf(float x);
  long double nearbyintl(long double x);
  /* Gleitkommatyp */ rint(/* Gleitkommatyp */ x);
  float rintf(float x);
  long double rintl(long double x);
  long int lrint(/* Gleitkommatyp */ x);
  long int lrintf(float x);
  long int lrintl(long double x);
  long long int llrint(/* Gleitkommatyp */ x);
  long long int llrintf(float x);
  long long int llrintl(long double x);
  constexpr /* Gleitkommatyp */ round(/* Gleitkommatyp */ x);
  constexpr float roundf(float x);
  constexpr long double roundl(long double x);
  constexpr long int lround(/* Gleitkommatyp */ x);
  constexpr long int lroundf(float x);
  constexpr long int lroundl(long double x);
  constexpr long long int llround(/* Gleitkommatyp */ x);
  constexpr long long int llroundf(float x);
  constexpr long long int llroundl(long double x);
  constexpr /* Gleitkommatyp */ trunc(/* Gleitkommatyp */ x);
  constexpr float truncf(float x);
  constexpr long double truncl(long double x);
  constexpr /* Gleitkommatyp */ fmod(/* Gleitkommatyp */ x,
                                           /* Gleitkommatyp */ y);
  constexpr float fmodf(float x, float y);
  constexpr long double fmodl(long double x, long double y);
  constexpr /* Gleitkommatyp */ remainder(/* Gleitkommatyp */ x,
                                                /* Gleitkommatyp */ y);
  constexpr float remainderf(float x, float y);
  constexpr long double remainderl(long double x, long double y);
  constexpr /* Gleitkommatyp */ remquo(/* Gleitkommatyp */ x,
                                             /* Gleitkommatyp */ y, int* quo);
  constexpr float remquof(float x, float y, int* quo);
  constexpr long double remquol(long double x, long double y, int* quo);
  constexpr /* Gleitkommatyp */ copysign(/* Gleitkommatyp */ x,
                                               /* Gleitkommatyp */ y);
  constexpr float copysignf(float x, float y);
  constexpr long double copysignl(long double x, long double y);
  double nan(const char* tagp);
  float nanf(const char* tagp);
  long double nanl(const char* tagp);
  constexpr /* Gleitkommatyp */ nextafter(/* Gleitkommatyp */ x,
                                                /* Gleitkommatyp */ y);
  constexpr float nextafterf(float x, float y);
  constexpr long double nextafterl(long double x, long double y);
  constexpr /* Gleitkommatyp */ nexttoward(/* Gleitkommatyp */ x,
                                                 long double y);
  constexpr float nexttowardf(float x, long double y);
  constexpr long double nexttowardl(long double x, long double y);
  constexpr /* Gleitkommatyp */ fdim(/* Gleitkommatyp */ x,
                                           /* Gleitkommatyp */ y);
  constexpr float fdimf(float x, float y);
  constexpr long double fdiml(long double x, long double y);
  constexpr /* Gleitkommatyp */ fmax(/* Gleitkommatyp */ x,
                                           /* Gleitkommatyp */ y);
  constexpr float fmaxf(float x, float y);
  constexpr long double fmaxl(long double x, long double y);
  constexpr /* Gleitkommatyp */ fmin(/* Gleitkommatyp */ x,
                                           /* Gleitkommatyp */ y);
  constexpr float fminf(float x, float y);
  constexpr long double fminl(long double x, long double y);
  constexpr /* Gleitkommatyp */ fma(/* Gleitkommatyp */ x,
                                          /* Gleitkommatyp */ y,
                                          /* Gleitkommatyp */ z);
  constexpr float fmaf(float x, float y, float z);
  constexpr long double fmal(long double x, long double y, long double z);
  // lineare Interpolation
  constexpr /* Gleitkommatyp */ lerp(/* Gleitkommatyp */ a,
                                           /* Gleitkommatyp */ b,
                                           /* Gleitkommatyp */ t) noexcept;
  // Klassifizierungs-/Vergleichsfunktionen
  constexpr int fpclassify(/* Gleitkommatyp */ x);
  constexpr bool isfinite(/* Gleitkommatyp */ x);
  constexpr bool isinf(/* Gleitkommatyp */ x);
  constexpr bool isnan(/* Gleitkommatyp */ x);
  constexpr bool isnormal(/* Gleitkommatyp */ x);
  constexpr bool signbit(/* Gleitkommatyp */ x);
  constexpr bool isgreater(/* Gleitkommatyp */ x,
                           /* Gleitkommatyp */ y);
  constexpr bool isgreaterequal(/* Gleitkommatyp */ x,
                                /* Gleitkommatyp */ y);
  constexpr bool isless(/* Gleitkommatyp */ x,
                        /* Gleitkommatyp */ y);
  constexpr bool islessequal(/* Gleitkommatyp */ x,
                             /* Gleitkommatyp */ y);
  constexpr bool islessgreater(/* Gleitkommatyp */ x,
                               /* Gleitkommatyp */ y);
  constexpr bool isunordered(/* Gleitkommatyp */ x,
                             /* Gleitkommatyp */ y);
  // mathematische Spezialfunktionen
  // assoziierte Laguerre-Polynome
  /* Gleitkommatyp */ assoc_laguerre(unsigned n, unsigned m,
                                           /* Gleitkommatyp */ x);
  float assoc_laguerref(unsigned n, unsigned m, float x);
  long double assoc_laguerrel(unsigned n, unsigned m, long double x);
  // assoziierte Legendre-Funktionen
  /* Gleitkommatyp */ assoc_legendre(unsigned l, unsigned m,
                                           /* Gleitkommatyp */ x);
  float assoc_legendref(unsigned l, unsigned m, float x);
  long double assoc_legendrel(unsigned l, unsigned m, long double x);
  // Beta-Funktion
  /* Gleitkommatyp */ beta(/* Gleitkommatyp */ x,
                                 /* Gleitkommatyp */ y);
  float betaf(float x, float y);
  long double betal(long double x, long double y);
  // vollständiges elliptisches Integral erster Art
  /* Gleitkommatyp */ comp_ellint_1(/* Gleitkommatyp */ k);
  float comp_ellint_1f(float k);
  long double comp_ellint_1l(long double k);
  // vollständiges elliptisches Integral zweiter Art
  /* Gleitkommatyp */ comp_ellint_2(/* Gleitkommatyp */ k);
  float comp_ellint_2f(float k);
  long double comp_ellint_2l(long double k);
  // vollständiges elliptisches Integral dritter Art
  /* Gleitkommatyp */ comp_ellint_3(/* Gleitkommatyp */ k,
                                          /* Gleitkommatyp */ nu);
  float comp_ellint_3f(float k, float nu);
  long double comp_ellint_3l(long double k, long double nu);
  // reguläre modifizierte zylindrische Bessel-Funktionen
  /* Gleitkommatyp */ cyl_bessel_i(/* Gleitkommatyp */ nu,
                                         /* Gleitkommatyp */ x);
  float cyl_bessel_if(float nu, float x);
  long double cyl_bessel_il(long double nu, long double x);
  // Zylinder-Bessel-Funktionen erster Art
  /* Gleitkommatyp */ cyl_bessel_j(/* Gleitkommatyp */ nu,
                                         /* Gleitkommatyp */ x);
  float cyl_bessel_jf(float nu, float x);
  long double cyl_bessel_jl(long double nu, long double x);
  // unregelmäßig modifizierte zylindrische Bessel-Funktionen
  /* Gleitkommatyp */ cyl_bessel_k(/* Gleitkommatyp */ nu,
                                         /* Gleitkommatyp */ x);
  float cyl_bessel_kf(float nu, float x);
  long double cyl_bessel_kl(long double nu, long double x);
  // zylindrische Neumann-Funktionen;
  // Zylinder-Bessel-Funktionen zweiter Art
  /* Gleitkommatyp */ cyl_neumann(/* Gleitkommatyp */ nu,
                                        /* Gleitkommatyp */ x);
  float cyl_neumannf(float nu, float x);
  long double cyl_neumannl(long double nu, long double x);
  // unvollständiges elliptisches Integral erster Art
  /* Gleitkommatyp */ ellint_1(/* Gleitkommatyp */ k,
                                     /* Gleitkommatyp */ phi);
  float ellint_1f(float k, float phi);
  long double ellint_1l(long double k, long double phi);
  // unvollständiges elliptisches Integral zweiter Art
  /* Gleitkommatyp */ ellint_2(/* Gleitkommatyp */ k,
                                     /* Gleitkommatyp */ phi);
  float ellint_2f(float k, float phi);
  long double ellint_2l(long double k, long double phi);
  // unvollständiges elliptisches Integral dritter Art
  /* Gleitkommatyp */ ellint_3(/* Gleitkommatyp */ k,
                                     /* Gleitkommatyp */ nu,
                                     /* Gleitkommatyp */ phi);
  float ellint_3f(float k, float nu, float phi);
  long double ellint_3l(long double k, long double nu, long double phi);
  // Exponentialintegral
  /* Gleitkommatyp */ expint(/* Gleitkommatyp */ x);
  float expintf(float x);
  long double expintl(long double x);
  // Hermite-Polynome
  /* Gleitkommatyp */ hermite(unsigned n, /* Gleitkommatyp */ x);
  float hermitef(unsigned n, float x);
  long double hermitel(unsigned n, long double x);
  // Laguerre-Polynome
  /* Gleitkommatyp */ laguerre(unsigned n, /* Gleitkommatyp */ x);
  float laguerref(unsigned n, float x);
  long double laguerrel(unsigned n, long double x);
  // Legendre-Polynome
  /* Gleitkommatyp */ legendre(unsigned l, /* Gleitkommatyp */ x);
  float legendref(unsigned l, float x);
  long double legendrel(unsigned l, long double x);
  // Riemannsche Zeta-Funktion
  /* Gleitkommatyp */ riemann_zeta(/* Gleitkommatyp */ x);
  float riemann_zetaf(float x);
  long double riemann_zetal(long double x);
  // sphärische Bessel-Funktionen erster Art
  /* Gleitkommatyp */ sph_bessel(unsigned n, /* Gleitkommatyp */ x);
  float sph_besself(unsigned n, float x);
  long double sph_bessell(unsigned n, long double x);
  // sphärische assoziierte Legendre-Funktionen
  /* Gleitkommatyp */ sph_legendre(unsigned l, unsigned m,
                                         /* Gleitkommatyp */ theta);
  float sph_legendref(unsigned l, unsigned m, float theta);
  long double  sph_legendrel(unsigned l, unsigned m, long double theta);
  // sphärische Neumann-Funktionen;
  // sphärische Bessel-Funktionen zweiter Art
  /* Gleitkommatyp */ sph_neumann(unsigned n, /* Gleitkommatyp */ x);
  float sph_neumannf(unsigned n, float x);
  long double sph_neumannl(unsigned n, long double x);
}

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants

Standard library header <cmath>

Inhaltsverzeichnis

Typen

Makros

Klassifikation

Funktionen

Grundlegende Operationen

Lineare Interpolation

Exponentialfunktionen

Potenzfunktionen

Trigonometrische Funktionen

Hyperbelfunktionen

Fehler- und Gammafunktionen

Nächste Ganzzahl-Gleitkommaoperationen

Gleitkomma-Manipulationsfunktionen

Klassifizierung und Vergleich

Mathematische Spezialfunktionen

Übersicht