Standard library header <cmath>

This header was originally in the C standard library as <math.h>.

This header is part of the numeric library.

Types
float_t (C++11)	most efficient floating-point type at least as wide as float (typedef)
double_t (C++11)	most efficient floating-point type at least as wide as double (typedef)
Macros
HUGE_VALFHUGE_VALHUGE_VALL (C++11)(C++11)	indicates the overflow value for float, double and long double respectively (macro constant)
INFINITY (C++11)	evaluates to positive infinity or the value guaranteed to overflow a float (macro constant)
NAN (C++11)	evaluates to a quiet NaN of type float (macro constant)
math_errhandlingMATH_ERRNOMATH_ERREXCEPT (C++11)(C++11)(C++11)	defines the error handling mechanism used by the common mathematical functions (macro constant)
Classification
FP_NORMALFP_SUBNORMALFP_ZEROFP_INFINITEFP_NAN (C++11)(C++11)(C++11)(C++11)(C++11)	indicates a floating-point category (macro constant)
Functions
Basic operations
abs(float)fabsfabsffabsl (C++11)(C++11)	absolute value of a floating point value ($\small{\|x\|}$ $\|x\|$ ) (function)
fmodfmodffmodl (C++11)(C++11)	remainder of the floating point division operation (function)
remainderremainderfremainderl (C++11)(C++11)(C++11)	signed remainder of the division operation (function)
remquoremquofremquol (C++11)(C++11)(C++11)	signed remainder as well as the three last bits of the division operation (function)
fmafmaffmal (C++11)(C++11)(C++11)	fused multiply-add operation (function)
fmaxfmaxffmaxl (C++11)(C++11)(C++11)	larger of two floating-point values (function)
fminfminffminl (C++11)(C++11)(C++11)	smaller of two floating point values (function)
fdimfdimffdiml (C++11)(C++11)(C++11)	positive difference of two floating point values (${\small\max{(0, x-y)} }$ $max(0, x-y)$ ) (function)
nannanfnanl (C++11)(C++11)(C++11)	not-a-number (NaN) (function)
Linear interpolation
lerp (C++20)	linear interpolation function (function)
Exponential functions
expexpfexpl (C++11)(C++11)	returns e raised to the given power (${\small e^x}$ $e x$ ) (function)
exp2exp2fexp2l (C++11)(C++11)(C++11)	returns 2 raised to the given power (${\small 2^x}$ $2 x$ ) (function)
expm1expm1fexpm1l (C++11)(C++11)(C++11)	returns e raised to the given power, minus one (${\small e^x-1}$ $e x -1$ ) (function)
loglogflogl (C++11)(C++11)	computes natural (base e) logarithm (${\small \ln{x} }$ $ln(x)$ ) (function)
log10log10flog10l (C++11)(C++11)	computes common (base 10) logarithm (${\small \log_{10}{x} }$ $log 10 (x)$ ) (function)
log2log2flog2l (C++11)(C++11)(C++11)	base 2 logarithm of the given number (${\small \log_{2}{x} }$ $log 2 (x)$ ) (function)
log1plog1pflog1pl (C++11)(C++11)(C++11)	natural logarithm (to base e) of 1 plus the given number (${\small \ln{(1+x)} }$ $ln(1+x)$ ) (function)
Power functions
powpowfpowl (C++11)(C++11)	raises a number to the given power ($\small{x^y}$ $x y$ ) (function)
sqrtsqrtfsqrtl (C++11)(C++11)	computes square root ($\small{\sqrt{x} }$ $\sqrt x$ ) (function)
cbrtcbrtfcbrtl (C++11)(C++11)(C++11)	computes cubic root ($\small{\sqrt[3]{x} }$ $3 \sqrt x$ ) (function)
hypothypotfhypotl (C++11)(C++11)(C++11)	computes square root of the sum of the squares of two or three (C++17) given numbers ($\scriptsize{\sqrt{x^2+y^2} }$ $\sqrt x 2 +y 2$ ), ($\scriptsize{\sqrt{x^2+y^2+z^2} }$ $\sqrt x 2 +y 2 +z 2$ ) (function)
Trigonometric functions
sinsinfsinl (C++11)(C++11)	computes sine (${\small\sin{x} }$ $sin(x)$ ) (function)
coscosfcosl (C++11)(C++11)	computes cosine (${\small\cos{x} }$ $cos(x)$ ) (function)
tantanftanl (C++11)(C++11)	computes tangent (${\small\tan{x} }$ $tan(x)$ ) (function)
asinasinfasinl (C++11)(C++11)	computes arc sine (${\small\arcsin{x} }$ $arcsin(x)$ ) (function)
acosacosfacosl (C++11)(C++11)	computes arc cosine (${\small\arccos{x} }$ $arccos(x)$ ) (function)
atanatanfatanl (C++11)(C++11)	computes arc tangent (${\small\arctan{x} }$ $arctan(x)$ ) (function)
atan2atan2fatan2l (C++11)(C++11)	arc tangent, using signs to determine quadrants (function)
Hyperbolic functions
sinhsinhfsinhl (C++11)(C++11)	computes hyperbolic sine (${\small\sinh{x} }$ $sinh(x)$ ) (function)
coshcoshfcoshl (C++11)(C++11)	computes hyperbolic cosine (${\small\cosh{x} }$ $cosh(x)$ ) (function)
tanhtanhftanhl (C++11)(C++11)	computes hyperbolic tangent (${\small\tanh{x} }$ $tanh(x)$ ) (function)
asinhasinhfasinhl (C++11)(C++11)(C++11)	computes the inverse hyperbolic sine (${\small\operatorname{arsinh}{x} }$ $arsinh(x)$ ) (function)
acoshacoshfacoshl (C++11)(C++11)(C++11)	computes the inverse hyperbolic cosine (${\small\operatorname{arcosh}{x} }$ $arcosh(x)$ ) (function)
atanhatanhfatanhl (C++11)(C++11)(C++11)	computes the inverse hyperbolic tangent (${\small\operatorname{artanh}{x} }$ $artanh(x)$ ) (function)
Error and gamma functions
erferfferfl (C++11)(C++11)(C++11)	error function (function)
erfcerfcferfcl (C++11)(C++11)(C++11)	complementary error function (function)
tgammatgammaftgammal (C++11)(C++11)(C++11)	gamma function (function)
lgammalgammaflgammal (C++11)(C++11)(C++11)	natural logarithm of the gamma function (function)
Nearest integer floating-point operations
ceilceilfceill (C++11)(C++11)	nearest integer not less than the given value (function)
floorfloorffloorl (C++11)(C++11)	nearest integer not greater than the given value (function)
trunctruncftruncl (C++11)(C++11)(C++11)	nearest integer not greater in magnitude than the given value (function)
roundroundfroundllroundlroundflroundlllroundllroundfllroundl (C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)	nearest integer, rounding away from zero in halfway cases (function)
nearbyintnearbyintfnearbyintl (C++11)(C++11)(C++11)	nearest integer using current rounding mode (function)
rintrintfrintllrintlrintflrintlllrintllrintfllrintl (C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)	nearest integer using current rounding mode with exception if the result differs (function)
Floating-point manipulation functions
frexpfrexpffrexpl (C++11)(C++11)	decomposes a number into significand and a power of 2 (function)
ldexpldexpfldexpl (C++11)(C++11)	multiplies a number by 2 raised to a power (function)
modfmodffmodfl (C++11)(C++11)	decomposes a number into integer and fractional parts (function)
scalbnscalbnfscalbnlscalblnscalblnfscalblnl (C++11)(C++11)(C++11)(C++11)(C++11)(C++11)	multiplies a number by FLT_RADIX raised to a power (function)
ilogbilogbfilogbl (C++11)(C++11)(C++11)	extracts exponent of the number (function)
logblogbflogbl (C++11)(C++11)(C++11)	extracts exponent of the number (function)
nextafternextafterfnextafterlnexttowardnexttowardfnexttowardl (C++11)(C++11) (C++11)(C++11)(C++11)(C++11)	next representable floating point value towards the given value (function)
copysigncopysignfcopysignl (C++11)(C++11)(C++11)	copies the sign of a floating point value (function)
Classification and comparison
fpclassify (C++11)	categorizes the given floating-point value (function)
isfinite (C++11)	checks if the given number has finite value (function)
isinf (C++11)	checks if the given number is infinite (function)
isnan (C++11)	checks if the given number is NaN (function)
isnormal (C++11)	checks if the given number is normal (function)
signbit (C++11)	checks if the given number is negative (function)
isgreater (C++11)	checks if the first floating-point argument is greater than the second (function)
isgreaterequal (C++11)	checks if the first floating-point argument is greater or equal than the second (function)
isless (C++11)	checks if the first floating-point argument is less than the second (function)
islessequal (C++11)	checks if the first floating-point argument is less or equal than the second (function)
islessgreater (C++11)	checks if the first floating-point argument is less or greater than the second (function)
isunordered (C++11)	checks if two floating-point values are unordered (function)
Mathematical special functions
assoc_laguerreassoc_laguerrefassoc_laguerrel (C++17)(C++17)(C++17)	associated Laguerre polynomials (function)
assoc_legendreassoc_legendrefassoc_legendrel (C++17)(C++17)(C++17)	associated Legendre polynomials (function)
betabetafbetal (C++17)(C++17)(C++17)	beta function (function)
comp_ellint_1comp_ellint_1fcomp_ellint_1l (C++17)(C++17)(C++17)	(complete) elliptic integral of the first kind (function)
comp_ellint_2comp_ellint_2fcomp_ellint_2l (C++17)(C++17)(C++17)	(complete) elliptic integral of the second kind (function)
comp_ellint_3comp_ellint_3fcomp_ellint_3l (C++17)(C++17)(C++17)	(complete) elliptic integral of the third kind (function)
cyl_bessel_icyl_bessel_ifcyl_bessel_il (C++17)(C++17)(C++17)	regular modified cylindrical Bessel functions (function)
cyl_bessel_jcyl_bessel_jfcyl_bessel_jl (C++17)(C++17)(C++17)	cylindrical Bessel functions (of the first kind) (function)
cyl_bessel_kcyl_bessel_kfcyl_bessel_kl (C++17)(C++17)(C++17)	irregular modified cylindrical Bessel functions (function)
cyl_neumanncyl_neumannfcyl_neumannl (C++17)(C++17)(C++17)	cylindrical Neumann functions (function)
ellint_1ellint_1fellint_1l (C++17)(C++17)(C++17)	(incomplete) elliptic integral of the first kind (function)
ellint_2ellint_2fellint_2l (C++17)(C++17)(C++17)	(incomplete) elliptic integral of the second kind (function)
ellint_3ellint_3fellint_3l (C++17)(C++17)(C++17)	(incomplete) elliptic integral of the third kind (function)
expintexpintfexpintl (C++17)(C++17)(C++17)	exponential integral (function)
hermitehermitefhermitel (C++17)(C++17)(C++17)	Hermite polynomials (function)
legendrelegendreflegendrel (C++17)(C++17)(C++17)	Legendre polynomials (function)
laguerrelaguerreflaguerrel (C++17)(C++17)(C++17)	Laguerre polynomials (function)
riemann_zetariemann_zetafriemann_zetal (C++17)(C++17)(C++17)	Riemann zeta function (function)
sph_besselsph_besselfsph_bessell (C++17)(C++17)(C++17)	spherical Bessel functions (of the first kind) (function)
sph_legendresph_legendrefsph_legendrel (C++17)(C++17)(C++17)	spherical associated Legendre functions (function)
sph_neumannsph_neumannfsph_neumannl (C++17)(C++17)(C++17)	spherical Neumann functions (function)

Synopsis

namespace std {
  using float_t = /* see description */;
  using double_t = /* see description */;
}
 
#define HUGE_VAL /* see description */
#define HUGE_VALF /* see description */
#define HUGE_VALL /* see description */
#define INFINITY /* see description */
#define NAN /* see description */
#define FP_INFINITE /* see description */
#define FP_NAN /* see description */
#define FP_NORMAL /* see description */
#define FP_SUBNORMAL /* see description */
#define FP_ZERO /* see description */
#define FP_FAST_FMA /* see description */
#define FP_FAST_FMAF /* see description */
#define FP_FAST_FMAL /* see description */
#define FP_ILOGB0 /* see description */
#define FP_ILOGBNAN /* see description */
#define MATH_ERRNO /* see description */
#define MATH_ERREXCEPT /* see description */
 
#define math_errhandling /* see description */
 
namespace std {
  float acos(float x);
  double acos(double x);
  long double acos(long double x);
  float acosf(float x);
  long double acosl(long double x);
 
  float asin(float x);
  double asin(double x);
  long double asin(long double x);
  float asinf(float x);
  long double asinl(long double x);
 
  float atan(float x);
  double atan(double x);
  long double atan(long double x);
  float atanf(float x);
  long double atanl(long double x);
 
  float atan2(float y, float x);
  double atan2(double y, double x);
  long double atan2(long double y, long double x);
  float atan2f(float y, float x);
  long double atan2l(long double y, long double x);
 
  float cos(float x);
  double cos(double x);
  long double cos(long double x);
  float cosf(float x);
  long double cosl(long double x);
 
  float sin(float x);
  double sin(double x);
  long double sin(long double x);
  float sinf(float x);
  long double sinl(long double x);
 
  float tan(float x);
  double tan(double x);
  long double tan(long double x);
  float tanf(float x);
  long double tanl(long double x);
 
  float acosh(float x);
  double acosh(double x);
  long double acosh(long double x);
  float acoshf(float x);
  long double acoshl(long double x);
 
  float asinh(float x);
  double asinh(double x);
  long double asinh(long double x);
  float asinhf(float x);
  long double asinhl(long double x);
 
  float atanh(float x);
  double atanh(double x);
  long double atanh(long double x);
  float atanhf(float x);
  long double atanhl(long double x);
 
  float cosh(float x);
  double cosh(double x);
  long double cosh(long double x);
  float coshf(float x);
  long double coshl(long double x);
 
  float sinh(float x);
  double sinh(double x);
  long double sinh(long double x);
  float sinhf(float x);
  long double sinhl(long double x);
 
  float tanh(float x);
  double tanh(double x);
  long double tanh(long double x);
  float tanhf(float x);
  long double tanhl(long double x);
 
  float exp(float x);
  double exp(double x);
  long double exp(long double x);
  float expf(float x);
  long double expl(long double x);
 
  float exp2(float x);
  double exp2(double x);
  long double exp2(long double x);
  float exp2f(float x);
  long double exp2l(long double x);
 
  float expm1(float x);
  double expm1(double x);
  long double expm1(long double x);
  float expm1f(float x);
  long double expm1l(long double x);
 
  constexpr float frexp(float value, int* exp);
  constexpr double frexp(double value, int* exp);
  constexpr long double frexp(long double value, int* exp);
  constexpr float frexpf(float value, int* exp);
  constexpr long double frexpl(long double value, int* exp);
 
  constexpr int ilogb(float x);
  constexpr int ilogb(double x);
  constexpr int ilogb(long double x);
  constexpr int ilogbf(float x);
  constexpr int ilogbl(long double x);
 
  constexpr float ldexp(float x, int exp);
  constexpr double ldexp(double x, int exp);
  constexpr long double ldexp(long double x, int exp);
  constexpr float ldexpf(float x, int exp);
  constexpr long double ldexpl(long double x, int exp);
 
  float log(float x);
  double log(double x);
  long double log(long double x);
  float logf(float x);
  long double logl(long double x);
 
  float log10(float x);
  double log10(double x);
  long double log10(long double x);
  float log10f(float x);
  long double log10l(long double x);
 
  float log1p(float x);
  double log1p(double x);
  long double log1p(long double x);
  float log1pf(float x);
  long double log1pl(long double x);
 
  float log2(float x);
  double log2(double x);
  long double log2(long double x);
  float log2f(float x);
  long double log2l(long double x);
 
  constexpr float logb(float x);
  constexpr double logb(double x);
  constexpr long double logb(long double x);
  constexpr float logbf(float x);
  constexpr long double logbl(long double x);
 
  constexpr float modf(float value, float* iptr);
  constexpr double modf(double value, double* iptr);
  constexpr long double modf(long double value, long double* iptr);
  constexpr float modff(float value, float* iptr);
  constexpr long double modfl(long double value, long double* iptr);
 
  constexpr float scalbn(float x, int n);
  constexpr double scalbn(double x, int n);
  constexpr long double scalbn(long double x, int n);
  constexpr float scalbnf(float x, int n);
  constexpr long double scalbnl(long double x, int n);
 
  constexpr float scalbln(float x, long int n);
  constexpr double scalbln(double x, long int n);
  constexpr long double scalbln(long double x, long int n);
  constexpr float scalblnf(float x, long int n);
  constexpr long double scalblnl(long double x, long int n);
 
  float cbrt(float x);
  double cbrt(double x);
  long double cbrt(long double x);
  float cbrtf(float x);
  long double cbrtl(long double x);
 
  // absolute values
  constexpr int abs(int j);
  constexpr long int abs(long int j);
  constexpr long long int abs(long long int j);
  constexpr float abs(float j);
  constexpr double abs(double j);
  constexpr long double abs(long double j);
 
  constexpr float fabs(float x);
  constexpr double fabs(double x);
  constexpr long double fabs(long double x);
  constexpr float fabsf(float x);
  constexpr long double fabsl(long double x);
 
  float hypot(float x, float y);
  double hypot(double x, double y);
  long double hypot(long double x, long double y);
  float hypotf(float x, float y);
  long double hypotl(long double x, long double y);
 
  // three-dimensional hypotenuse
  float hypot(float x, float y, float z);
  double hypot(double x, double y, double z);
  long double hypot(long double x, long double y, long double z);
 
  float pow(float x, float y);
  double pow(double x, double y);
  long double pow(long double x, long double y);
  float powf(float x, float y);
  long double powl(long double x, long double y);
 
  float sqrt(float x);
  double sqrt(double x);
  long double sqrt(long double x);
  float sqrtf(float x);
  long double sqrtl(long double x);
 
  float erf(float x);
  double erf(double x);
  long double erf(long double x);
  float erff(float x);
  long double erfl(long double x);
 
  float erfc(float x);
  double erfc(double x);
  long double erfc(long double x);
  float erfcf(float x);
  long double erfcl(long double x);
 
  float lgamma(float x);
  double lgamma(double x);
  long double lgamma(long double x);
  float lgammaf(float x);
  long double lgammal(long double x);
 
  float tgamma(float x);
  double tgamma(double x);
  long double tgamma(long double x);
  float tgammaf(float x);
  long double tgammal(long double x);
 
  constexpr float ceil(float x);
  constexpr double ceil(double x);
  constexpr long double ceil(long double x);
  constexpr float ceilf(float x);
  constexpr long double ceill(long double x);
 
  constexpr float floor(float x);
  constexpr double floor(double x);
  constexpr long double floor(long double x);
  constexpr float floorf(float x);
  constexpr long double floorl(long double x);
 
  float nearbyint(float x);
  double nearbyint(double x);
  long double nearbyint(long double x);
  float nearbyintf(float x);
  long double nearbyintl(long double x);
 
  float rint(float x);
  double rint(double x);
  long double rint(long double x);
  float rintf(float x);
  long double rintl(long double x);
 
  long int lrint(float x);
  long int lrint(double x);
  long int lrint(long double x);
  long int lrintf(float x);
  long int lrintl(long double x);
 
  long long int llrint(float x);
  long long int llrint(double x);
  long long int llrint(long double x);
  long long int llrintf(float x);
  long long int llrintl(long double x);
 
  constexpr float round(float x);
  constexpr double round(double x);
  constexpr long double round(long double x);
  constexpr float roundf(float x);
  constexpr long double roundl(long double x);
 
  constexpr long int lround(float x);
  constexpr long int lround(double x);
  constexpr long int lround(long double x);
  constexpr long int lroundf(float x);
  constexpr long int lroundl(long double x);
 
  constexpr long long int llround(float x);
  constexpr long long int llround(double x);
  constexpr long long int llround(long double x);
  constexpr long long int llroundf(float x);
  constexpr long long int llroundl(long double x);
 
  constexpr float trunc(float x);
  constexpr double trunc(double x);
  constexpr long double trunc(long double x);
  constexpr float truncf(float x);
  constexpr long double truncl(long double x);
 
  constexpr float fmod(float x, float y);
  constexpr double fmod(double x, double y);
  constexpr long double fmod(long double x, long double y);
  constexpr float fmodf(float x, float y);
  constexpr long double fmodl(long double x, long double y);
 
  constexpr float remainder(float x, float y);
  constexpr double remainder(double x, double y);
  constexpr long double remainder(long double x, long double y);
  constexpr float remainderf(float x, float y);
  constexpr long double remainderl(long double x, long double y);
 
  constexpr float remquo(float x, float y, int* quo);
  constexpr double remquo(double x, double y, int* quo);
  constexpr long double remquo(long double x, long double 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 float copysign(float x, float y);
  constexpr double copysign(double x, double y);
  constexpr long double copysign(long double x, long double 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 float nextafter(float x, float y);
  constexpr double nextafter(double x, double y);
  constexpr long double nextafter(long double x, long double y);
  constexpr float nextafterf(float x, float y);
  constexpr long double nextafterl(long double x, long double y);
 
  constexpr float nexttoward(float x, long double y);
  constexpr double nexttoward(double x, long double y);
  constexpr long double nexttoward(long double x, long double y);
  constexpr float nexttowardf(float x, long double y);
  constexpr long double nexttowardl(long double x, long double y);
 
  constexpr float fdim(float x, float y);
  constexpr double fdim(double x, double y);
  constexpr long double fdim(long double x, long double y);
  constexpr float fdimf(float x, float y);
  constexpr long double fdiml(long double x, long double y);
 
  constexpr float fmax(float x, float y);
  constexpr double fmax(double x, double y);
  constexpr long double fmax(long double x, long double y);
  constexpr float fmaxf(float x, float y);
  constexpr long double fmaxl(long double x, long double y);
 
  constexpr float fmin(float x, float y);
  constexpr double fmin(double x, double y);
  constexpr long double fmin(long double x, long double y);
  constexpr float fminf(float x, float y);
  constexpr long double fminl(long double x, long double y);
 
  constexpr float fma(float x, float y, float z);
  constexpr double fma(double x, double y, double z);
  constexpr long double fma(long double x, long double y, long double z);
  constexpr float fmaf(float x, float y, float z);
  constexpr long double fmal(long double x, long double y, long double z);
 
  // linear interpolation
  constexpr float lerp(float a, float b, float t) noexcept;
  constexpr double lerp(double a, double b, double t) noexcept;
  constexpr long double lerp(long double a, long double b, long double t) noexcept;
 
  // classification / comparison functions
  constexpr int fpclassify(float x);
  constexpr int fpclassify(double x);
  constexpr int fpclassify(long double x);
 
  constexpr bool isfinite(float x);
  constexpr bool isfinite(double x);
  constexpr bool isfinite(long double x);
 
  constexpr bool isinf(float x);
  constexpr bool isinf(double x);
  constexpr bool isinf(long double x);
 
  constexpr bool isnan(float x);
  constexpr bool isnan(double x);
  constexpr bool isnan(long double x);
 
  constexpr bool isnormal(float x);
  constexpr bool isnormal(double x);
  constexpr bool isnormal(long double x);
 
  constexpr bool signbit(float x);
  constexpr bool signbit(double x);
  constexpr bool signbit(long double x);
 
  constexpr bool isgreater(float x, float y);
  constexpr bool isgreater(double x, double y);
  constexpr bool isgreater(long double x, long double y);
 
  constexpr bool isgreaterequal(float x, float y);
  constexpr bool isgreaterequal(double x, double y);
  constexpr bool isgreaterequal(long double x, long double y);
 
  constexpr bool isless(float x, float y);
  constexpr bool isless(double x, double y);
  constexpr bool isless(long double x, long double y);
 
  constexpr bool islessequal(float x, float y);
  constexpr bool islessequal(double x, double y);
  constexpr bool islessequal(long double x, long double y);
 
  constexpr bool islessgreater(float x, float y);
  constexpr bool islessgreater(double x, double y);
  constexpr bool islessgreater(long double x, long double y);
 
  constexpr bool isunordered(float x, float y);
  constexpr bool isunordered(double x, double y);
  constexpr bool isunordered(long double x, long double y);
 
  // mathematical special functions
 
  // associated Laguerre polynomials
  double       assoc_laguerre(unsigned n, unsigned m, double x);
  float        assoc_laguerref(unsigned n, unsigned m, float x);
  long double  assoc_laguerrel(unsigned n, unsigned m, long double x);
 
  // associated Legendre functions
  double       assoc_legendre(unsigned l, unsigned m, double x);
  float        assoc_legendref(unsigned l, unsigned m, float x);
  long double  assoc_legendrel(unsigned l, unsigned m, long double x);
 
  // beta function
  double       beta(double x, double y);
  float        betaf(float x, float y);
  long double  betal(long double x, long double y);
 
  // complete elliptic integral of the first kind
  double       comp_ellint_1(double k);
  float        comp_ellint_1f(float k);
  long double  comp_ellint_1l(long double k);
 
  // complete elliptic integral of the second kind
  double       comp_ellint_2(double k);
  float        comp_ellint_2f(float k);
  long double  comp_ellint_2l(long double k);
 
  // complete elliptic integral of the third kind
  double       comp_ellint_3(double k, double nu);
  float        comp_ellint_3f(float k, float nu);
  long double  comp_ellint_3l(long double k, long double nu);
 
  // regular modified cylindrical Bessel functions
  double       cyl_bessel_i(double nu, double x);
  float        cyl_bessel_if(float nu, float x);
  long double  cyl_bessel_il(long double nu, long double x);
 
  // cylindrical Bessel functions of the first kind
  double       cyl_bessel_j(double nu, double x);
  float        cyl_bessel_jf(float nu, float x);
  long double  cyl_bessel_jl(long double nu, long double x);
 
  // irregular modified cylindrical Bessel functions
  double       cyl_bessel_k(double nu, double x);
  float        cyl_bessel_kf(float nu, float x);
  long double  cyl_bessel_kl(long double nu, long double x);
 
  // cylindrical Neumann functions;
  // cylindrical Bessel functions of the second kind
  double       cyl_neumann(double nu, double x);
  float        cyl_neumannf(float nu, float x);
  long double  cyl_neumannl(long double nu, long double x);
 
  // incomplete elliptic integral of the first kind
  double       ellint_1(double k, double phi);
  float        ellint_1f(float k, float phi);
  long double  ellint_1l(long double k, long double phi);
 
  // incomplete elliptic integral of the second kind
  double       ellint_2(double k, double phi);
  float        ellint_2f(float k, float phi);
  long double  ellint_2l(long double k, long double phi);
 
  // incomplete elliptic integral of the third kind
  double       ellint_3(double k, double nu, double phi);
  float        ellint_3f(float k, float nu, float phi);
  long double  ellint_3l(long double k, long double nu, long double phi);
 
  // exponential integral
  double       expint(double x);
  float        expintf(float x);
  long double  expintl(long double x);
 
  // Hermite polynomials
  double       hermite(unsigned n, double x);
  float        hermitef(unsigned n, float x);
  long double  hermitel(unsigned n, long double x);
 
  // Laguerre polynomials
  double       laguerre(unsigned n, double x);
  float        laguerref(unsigned n, float x);
  long double  laguerrel(unsigned n, long double x);
 
  // Legendre polynomials
  double       legendre(unsigned l, double x);
  float        legendref(unsigned l, float x);
  long double  legendrel(unsigned l, long double x);
 
  // Riemann zeta function
  double       riemann_zeta(double x);
  float        riemann_zetaf(float x);
  long double  riemann_zetal(long double x);
 
  // spherical Bessel functions of the first kind
  double       sph_bessel(unsigned n, double x);
  float        sph_besself(unsigned n, float x);
  long double  sph_bessell(unsigned n, long double x);
 
  // spherical associated Legendre functions
  double       sph_legendre(unsigned l, unsigned m, double theta);
  float        sph_legendref(unsigned l, unsigned m, float theta);
  long double  sph_legendrel(unsigned l, unsigned m, long double theta);
 
  // spherical Neumann functions;
  // spherical Bessel functions of the second kind
  double       sph_neumann(unsigned n, double 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 headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Technical specifications
Symbols index
External libraries

Standard library header <cmath>

Types

Macros

Classification

Functions

Basic operations

Linear interpolation

Exponential functions

Power functions

Trigonometric functions

Hyperbolic functions

Error and gamma functions

Nearest integer floating-point operations

Floating-point manipulation functions

Classification and comparison

Mathematical special functions

Synopsis

Navigation