Standard library header <cmath>

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

This header is part of the numeric library.

Macro constants

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)

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)

Functions

Basic operations
abs(float)fabsfabsffabsl (C++11)(C++11)	absolute value of a floating point value ( $\|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 ( $max(0, x-y)$ ) (function)
nannanfnanl (C++11)(C++11)(C++11)	not-a-number (NaN) (function)
Exponential functions
expexpfexpl (C++11)(C++11)	returns e raised to the given power ( $e x$ ) (function)
exp2exp2fexp2l (C++11)(C++11)(C++11)	returns 2 raised to the given power ( $2 x$ ) (function)
expm1expm1fexpm1l (C++11)(C++11)(C++11)	returns e raised to the given power, minus one ( $e x -1$ ) (function)
loglogflogl (C++11)(C++11)	computes natural (base e) logarithm ( $ln(x)$ ) (function)
log10log10flog10l (C++11)(C++11)	computes common (base 10) logarithm ( $log 10 (x)$ ) (function)
log2log2flog2l (C++11)(C++11)(C++11)	base 2 logarithm of the given number ( $log 2 (x)$ ) (function)
log1plog1pflog1pl (C++11)(C++11)(C++11)	natural logarithm (to base e) of 1 plus the given number ( $ln(1+x)$ ) (function)
Power functions
powpowfpowl (C++11)(C++11)	raises a number to the given power ( $x y$ ) (function)
sqrtsqrtfsqrtl (C++11)(C++11)	computes square root ( $\sqrt x$ ) (function)
cbrtcbrtfcbrtl (C++11)(C++11)(C++11)	computes cubic root ( $3 \sqrt x$ ) (function)
hypothypotfhypotl (C++11)(C++11)(C++11)	computes square root of the sum of the squares of two given numbers ( $\sqrt x 2 +y 2$ ) (function)
Trigonometric functions
sinsinfsinl (C++11)(C++11)	computes sine ( $sin(x)$ ) (function)
coscosfcosl (C++11)(C++11)	computes cosine ( $cos(x)$ ) (function)
tantanftanl (C++11)(C++11)	computes tangent ( $tan(x)$ ) (function)
asinasinfasinl (C++11)(C++11)	computes arc sine ( $arcsin(x)$ ) (function)
acosacosfacosl (C++11)(C++11)	computes arc cosine ( $arccos(x)$ ) (function)
atanatanfatanl (C++11)(C++11)	computes arc tangent ( $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 ( $sh(x)$ ) (function)
coshcoshfcoshl (C++11)(C++11)	computes hyperbolic cosine ( $ch(x)$ ) (function)
tanhtanhftanhl (C++11)(C++11)	hyperbolic tangent (function)
asinhasinhfasinhl (C++11)(C++11)(C++11)	computes the inverse hyperbolic sine ( $arsinh(x)$ ) (function)
acoshacoshfacoshl (C++11)(C++11)(C++11)	computes the inverse hyperbolic cosine ( $arcosh(x)$ ) (function)
atanhatanhfatanhl (C++11)(C++11)(C++11)	computes the inverse hyperbolic tangent ( $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)
Special mathematical 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 definition*/;
  using double_t = /*see definition*/;
}
 
#define HUGE_VAL /*see definition*/
#define HUGE_VALF /*see definition*/
#define HUGE_VALL /*see definition*/
#define INFINITY /*see definition*/
#define NAN /*see definition*/
#define FP_INFINITE /*see definition*/
#define FP_NAN /*see definition*/
#define FP_NORMAL /*see definition*/
#define FP_SUBNORMAL /*see definition*/
#define FP_ZERO /*see definition*/
#define FP_FAST_FMA /*see definition*/
#define FP_FAST_FMAF /*see definition*/
#define FP_FAST_FMAL /*see definition*/
#define FP_ILOGB0 /*see definition*/
#define FP_ILOGBNAN /*see definition*/
#define MATH_ERRNO /*see definition*/
#define MATH_ERREXCEPT /*see definition*/
 
#define math_errhandling /*see definition*/
 
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);
 
  float frexp(float value, int* exp);
  double frexp(double value, int* exp);
  long double frexp(long double value, int* exp);
  float frexpf(float value, int* exp);
  long double frexpl(long double value, int* exp);
 
  int ilogb(float x);
  int ilogb(double x);
  int ilogb(long double x);
  int ilogbf(float x);
  int ilogbl(long double x);
 
  float ldexp(float x, int exp);
  double ldexp(double x, int exp);
  long double ldexp(long double x, int exp);
  float ldexpf(float x, int exp);
  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);
 
  float logb(float x);
  double logb(double x);
  long double logb(long double x);
  float logbf(float x);
  long double logbl(long double x);
 
  float modf(float value, float* iptr);
  double modf(double value, double* iptr);
  long double modf(long double value, long double* iptr);
  float modff(float value, float* iptr);
  long double modfl(long double value, long double* iptr);
 
  float scalbn(float x, int n);
  double scalbn(double x, int n);
  long double scalbn(long double x, int n);
  float scalbnf(float x, int n);
  long double scalbnl(long double x, int n);
 
  float scalbln(float x, long int n);
  double scalbln(double x, long int n);
  long double scalbln(long double x, long int n);
  float scalblnf(float x, long int n);
  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
  int abs(int j);
  long int abs(long int j);
  long long int abs(long long int j);
  float abs(float j);
  double abs(double j);
  long double abs(long double j);
 
  float fabs(float x);
  double fabs(double x);
  long double fabs(long double x);
  float fabsf(float x);
  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);
 
  float ceil(float x);
  double ceil(double x);
  long double ceil(long double x);
  float ceilf(float x);
  long double ceill(long double x);
 
  float floor(float x);
  double floor(double x);
  long double floor(long double x);
  float floorf(float x);
  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);
 
  float round(float x);
  double round(double x);
  long double round(long double x);
  float roundf(float x);
  long double roundl(long double x);
 
  long int lround(float x);
  long int lround(double x);
  long int lround(long double x);
  long int lroundf(float x);
  long int lroundl(long double x);
 
  long long int llround(float x);
  long long int llround(double x);
  long long int llround(long double x);
  long long int llroundf(float x);
  long long int llroundl(long double x);
 
  float trunc(float x);
  double trunc(double x);
  long double trunc(long double x);
  float truncf(float x);
  long double truncl(long double x);
 
  float fmod(float x, float y);
  double fmod(double x, double y);
  long double fmod(long double x, long double y);
  float fmodf(float x, float y);
  long double fmodl(long double x, long double y);
 
  float remainder(float x, float y);
  double remainder(double x, double y);
  long double remainder(long double x, long double y);
  float remainderf(float x, float y);
  long double remainderl(long double x, long double y);
 
  float remquo(float x, float y, int* quo);
  double remquo(double x, double y, int* quo);
  long double remquo(long double x, long double y, int* quo);
  float remquof(float x, float y, int* quo);
  long double remquol(long double x, long double y, int* quo);
 
  float copysign(float x, float y);
  double copysign(double x, double y);
  long double copysign(long double x, long double y);
  float copysignf(float x, float y);
  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);
 
  float nextafter(float x, float y);
  double nextafter(double x, double y);
  long double nextafter(long double x, long double y);
  float nextafterf(float x, float y);
  long double nextafterl(long double x, long double y);
 
  float nexttoward(float x, long double y);
  double nexttoward(double x, long double y);
  long double nexttoward(long double x, long double y);
  float nexttowardf(float x, long double y);
  long double nexttowardl(long double x, long double y);
 
  float fdim(float x, float y);
  double fdim(double x, double y);
  long double fdim(long double x, long double y);
  float fdimf(float x, float y);
  long double fdiml(long double x, long double y);
 
  float fmax(float x, float y);
  double fmax(double x, double y);
  long double fmax(long double x, long double y);
  float fmaxf(float x, float y);
  long double fmaxl(long double x, long double y);
 
  float fmin(float x, float y);
  double fmin(double x, double y);
  long double fmin(long double x, long double y);
  float fminf(float x, float y);
  long double fminl(long double x, long double y);
 
  float fma(float x, float y, float z);
  double fma(double x, double y, double z);
  long double fma(long double x, long double y, long double z);
  float fmaf(float x, float y, float z);
  long double fmal(long double x, long double y, long double z);
 
  // classification / comparison functions
  int fpclassify(float x);
  int fpclassify(double x);
  int fpclassify(long double x);
 
  bool isfinite(float x);
  bool isfinite(double x);
  bool isfinite(long double x);
 
  bool isinf(float x);
  bool isinf(double x);
  bool isinf(long double x);
 
  bool isnan(float x);
  bool isnan(double x);
  bool isnan(long double x);
 
  bool isnormal(float x);
  bool isnormal(double x);
  bool isnormal(long double x);
 
  bool signbit(float x);
  bool signbit(double x);
  bool signbit(long double x);
 
  bool isgreater(float x, float y);
  bool isgreater(double x, double y);
  bool isgreater(long double x, long double y);
 
  bool isgreaterequal(float x, float y);
  bool isgreaterequal(double x, double y);
  bool isgreaterequal(long double x, long double y);
 
  bool isless(float x, float y);
  bool isless(double x, double y);
  bool isless(long double x, long double y);
 
  bool islessequal(float x, float y);
  bool islessequal(double x, double y);
  bool islessequal(long double x, long double y);
 
  bool islessgreater(float x, float y);
  bool islessgreater(double x, double y);
  bool islessgreater(long double x, long double y);
 
  bool isunordered(float x, float y);
  bool isunordered(double x, double y);
  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);
}

Language
Standard Library Headers
Freestanding and hosted implementations
Named requirements
Language support library
Concepts library (C++20)
Diagnostics library
Utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Input/output library
Localizations library
Regular expressions library (C++11)
Atomic operations library (C++11)
Thread support library (C++11)
Filesystem library (C++17)
Technical Specifications

Standard library header <cmath>

Macro constants

Classification

Types

Functions

Basic operations

Exponential functions

Power functions

Trigonometric functions

Hyperbolic functions

Error and gamma functions

Nearest integer floating point operations

Floating point manipulation functions

Classification and comparison

Special mathematical functions

Synopsis

Navigation