Archivo de encabezado de la biblioteca estándar <cmath>

Este archivo de encabezado se encontraba originalmente en la biblioteca estándar de C como <math.h>.

Este archivo de encabezado es parte de la biblioteca numérica.

Sumario 1 Tipos 2 Macros 2.1 Classification 3 Funciones 3.1 Operaciones básicas 3.2 Interpolación lineal 3.3 Funciones exponenciales 3.4 Funciones de potencias 3.5 Funciones trigonométricas 3.6 Funciones hiperbólicas 3.7 Funciones de error y gamma 3.8 Operaciones de punto flotante del entero más cercano 3.9 Funciones de manipulación de punto flotante 3.10 Clasificación y comparación 3.11 Funciones matemáticas especiales special functions 4 Sinopsis Tipos
float_t (C++11)	El tipo de punto flotante más eficiente al menos tan ancho como un `float` (typedef) [editar]
double_t (C++11)	El tipo de punto flotante más eficiente al menos tan ancho como un `double` (typedef) [editar]
Macros
HUGE_VALFHUGE_VALHUGE_VALL (C++11)(C++11)	Indica el valor de desbordamiento para `float`, `double` y `long double`, respectivamente (constante de macro) [editar]
INFINITY (C++11)	Se evalúa a la infinidad positiva o al valor garantizado para desbordar un `float` (constante de macro) [editar]
NAN (C++11)	Se evalúa a un tipo simple de NaN de tipo `float` (constante de macro) [editar]
math_errhandlingMATH_ERRNOMATH_ERREXCEPT (C++11)(C++11)(C++11)	Define el mecanismo de control de errores usado por las funciones matemáticas comunes (constante de macro) [editar]
Classification
FP_NORMALFP_SUBNORMALFP_ZEROFP_INFINITYFP_NAN (C++11)(C++11)(C++11)(C++11)(C++11)	Indica una categoría de punto flotante (constante de macro) [editar]
Funciones
Operaciones básicas
abs(float)fabsfabsffabsl (C++11)(C++11)	Valor absoluto de un valor de punto flotante ($\small{\|x\|}$ $\|x\|$ ) (función) [editar]
fmodfmodffmodl (C++11)(C++11)	El resto de la operación de división de punto flotante (función) [editar]
remainderremainderfremainderl (C++11)(C++11)(C++11)	Resto con signo de la operación de división (función) [editar]
remquoremquofremquol (C++11)(C++11)(C++11)	Resto con signo, así como los tres últimos bits de la operación de división (función) [editar]
fmafmaffmal (C++11)(C++11)(C++11)	Operación de multiplicación y suma fusionada (función) [editar]
fmaxfmaxffmaxl (C++11)(C++11)(C++11)	El mayor de dos valores de punto flotante (función) [editar]
fminfminffminl (C++11)(C++11)(C++11)	El menor de dos valores de punto flotante (función) [editar]
fdimfdimffdiml (C++11)(C++11)(C++11)	Diferencia positiva de dos valores de punto flotante (${\small\max{(0, x-y)} }$ $max(0, x-y)$ ) (función) [editar]
nannanfnanl (C++11)(C++11)(C++11)	No es un Número (NaN) (función) [editar]
Interpolación lineal
lerp (C++20)	Función de interpolación lineal (función) [editar]
Funciones exponenciales
expexpfexpl (C++11)(C++11)	Devuelve e elevada a la potencia dada (${\small e^x}$ $e x$ ) (función) [editar]
exp2exp2fexp2l (C++11)(C++11)(C++11)	Devuelve 2 elevado a la potencia dada (${\small 2^x}$ $2 x$ ) (función) [editar]
expm1expm1fexpm1l (C++11)(C++11)(C++11)	Devuelve e elevada a la potencia dada, menos uno (${\small e^x-1}$ $e x -1$ ) (función) [editar]
loglogflogl (C++11)(C++11)	Calcula el logaritmo natural (base e) (${\small \ln{x} }$ $ln(x)$ ) (función) [editar]
log10log10flog10l (C++11)(C++11)	Calcula el logaritmo común (base 10) (${\small \log_{10}{x} }$ $log 10 (x)$ ) (función) [editar]
log2log2flog2l (C++11)(C++11)(C++11)	Logaritmo de base 2 del número dado (${\small \log_{2}{x} }$ $log 2 (x)$ ) (función) [editar]
log1plog1pflog1pl (C++11)(C++11)(C++11)	Logaritmo natural (a base e) de 1 más el número dado (${\small \ln{(1+x)} }$ $ln(1+x)$ ) (función) [editar]
Funciones de potencias
powpowfpowl (C++11)(C++11)	Eleva un número a la potencia dada ($\small{x^y}$ $x y$ ) (función) [editar]
sqrtsqrtfsqrtl (C++11)(C++11)	Calcula la raíz cuadrada ($\small{\sqrt{x} }$ $\sqrt x$ ) (función) [editar]
cbrtcbrtfcbrtl (C++11)(C++11)(C++11)	Calcula la raíz cúbica ($\small{\sqrt[3]{x} }$ $3 \sqrt x$ ) (función) [editar]
hypothypotfhypotl (C++11)(C++11)(C++11)	Calcula la raíz cuadrada de la suma de los cuadrados de dos o tres (C++17) números dados ($\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$ ) (función) [editar]
Funciones trigonométricas
sinsinfsinl (C++11)(C++11)	Calcula el seno (${\small\sin{x} }$ $sin(x)$ ) (función) [editar]
coscosfcosl (C++11)(C++11)	Calcula el coseno (${\small\cos{x} }$ $cos(x)$ ) (función) [editar]
tantanftanl (C++11)(C++11)	Calcula la tangente (${\small\tan{x} }$ $tan(x)$ ) (función) [editar]
asinasinfasinl (C++11)(C++11)	Calcula el arco seno (${\small\arcsin{x} }$ $arcsen(x)$ ) (función) [editar]
acosacosfacosl (C++11)(C++11)	Calcula el arco coseno (${\small\arccos{x} }$ $arccos(x)$ ) (función) [editar]
atanatanfatanl (C++11)(C++11)	Calcula el arco tangente (${\small\arctan{x} }$ $arctan(x)$ ) (función) [editar]
atan2atan2fatan2l (C++11)(C++11)	El arco tangente, usando signos para determinar cuadrantes. (función) [editar]
Funciones hiperbólicas
sinhsinhfsinhl (C++11)(C++11)	Calcula el seno hiperbólico (${\small\sinh{x} }$ $sinh(x)$ ) (función) [editar]
coshcoshfcoshl (C++11)(C++11)	Calcula el coseno hiperbólico (${\small\cosh{x} }$ $cosh(x)$ ) (función) [editar]
tanhtanhftanhl (C++11)(C++11)	Calcula la tangente hiperbólica (${\small\tanh{x} }$ $tanh(x)$ ) (función) [editar]
asinhasinhfasinhl (C++11)(C++11)(C++11)	Calcula el seno hiperbólico inverso (${\small\operatorname{arsinh}{x} }$ $arsinh(x)$ ) (función) [editar]
acoshacoshfacoshl (C++11)(C++11)(C++11)	Calcula el coseno hiperbólico inverso (${\small\operatorname{arcosh}{x} }$ $arcosh(x)$ ) (función) [editar]
atanhatanhfatanhl (C++11)(C++11)(C++11)	Calcula la tangente hiperbólica inversa (${\small\operatorname{artanh}{x} }$ $artanh(x)$ ) (función) [editar]
Funciones de error y gamma
erferfferfl (C++11)(C++11)(C++11)	Función de error. (función) [editar]
erfcerfcferfcl (C++11)(C++11)(C++11)	Función de error complementaria. (función) [editar]
tgammatgammaftgammal (C++11)(C++11)(C++11)	Función gamma (función) [editar]
lgammalgammaflgammal (C++11)(C++11)(C++11)	Logaritmo natural de la función gamma (función) [editar]
Operaciones de punto flotante del entero más cercano
ceilceilfceill (C++11)(C++11)	Entero más cercano entero no menor que el valor dado. (función) [editar]
floorfloorffloorl (C++11)(C++11)	Entero más cercano no mayor que el valor dado (función) [editar]
trunctruncftruncl (C++11)(C++11)(C++11)	Entero más cercano no mayor en magnitud que el valor dado (función) [editar]
roundroundfroundllroundlroundflroundlllroundllroundfllroundl (C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)	Entero más cercano, redondeando alejándose de cero en los casos intermedios (función) [editar]
nearbyintnearbyintfnearbyintl (C++11)(C++11)(C++11)	Entero más cercano usando el modo de redondeo actual (función) [editar]
rintrintfrintllrintlrintflrintlllrintllrintfllrintl (C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)	Entero más cercano usando el modo de redondeo actual con excepción si el resultado difiere (función) [editar]
Funciones de manipulación de punto flotante
frexpfrexpffrexpl (C++11)(C++11)	Descompone un número en mantisa y una potencia de `2` (función) [editar]
ldexpldexpfldexpl (C++11)(C++11)	Multiplica un número por `2` elevado a una potencia (función) [editar]
modfmodffmodfl (C++11)(C++11)	Descompone un número en sus partes entera y fraccionaria (función) [editar]
scalbnscalbnfscalbnlscalblnscalblnfscalblnl (C++11)(C++11)(C++11)(C++11)(C++11)(C++11)	Multiplica un número por FLT_RADIX elevado a una potencia (función) [editar]
ilogbilogbfilogbl (C++11)(C++11)(C++11)	Extrae el exponente del número (función) [editar]
logblogbflogbl (C++11)(C++11)(C++11)	Extrae el exponente del número (función) [editar]
nextafternextafterfnextafterlnexttowardnexttowardfnexttowardl (C++11)(C++11) (C++11)(C++11)(C++11)(C++11)	El siguiente valor representable de punto flotante hacia a un valor dado (función) [editar]
copysigncopysignfcopysignl (C++11)(C++11)(C++11)	Copia el signo de un valor de punto flotante. (función) [editar]
Clasificación y comparación
fpclassify (C++11)	Categoriza el valor de punto flotante dado (función) [editar]
isfinite (C++11)	Comprueba si el número dado tiene un valor finito (función) [editar]
isinf (C++11)	Comprueba si el número dado es infinito (función) [editar]
isnan (C++11)	Comprueba si el número dado es NaN (función) [editar]
isnormal (C++11)	Comprueba si el número dado es normal (función) [editar]
signbit (C++11)	Comprueba si el número dado es negativo (función) [editar]
isgreater (C++11)	Comprueba si el primer argumento de punto flotante es mayor que el segundo (función) [editar]
isgreaterequal (C++11)	Comprueba si el primer argumento de punto flotante es mayor o igual que el segundo (función) [editar]
isless (C++11)	Comprueba si el primer argumento de punto flotante es menor que el segundo (función) [editar]
islessequal (C++11)	Comprueba si el primer argumento de punto flotante es menor o igual que el segundo (función) [editar]
islessgreater (C++11)	Comprueba si el primer argumento de punto flotante es menor o mayor que el segundo (función) [editar]
isunordered (C++11)	Comprueba si dos valores de punto flotante son no ordenados (función) [editar]
Funciones matemáticas especiales special functions
assoc_laguerreassoc_laguerrefassoc_laguerrel (C++17)(C++17)(C++17)	Polinomios asociados de Laguerre. (función) [editar]
assoc_legendreassoc_legendrefassoc_legendrel (C++17)(C++17)(C++17)	Polinomios asociados de Legendre. (función) [editar]
betabetafbetal (C++17)(C++17)(C++17)	Función beta. (función) [editar]
comp_ellint_1comp_ellint_1fcomp_ellint_1l (C++17)(C++17)(C++17)	Integral elíptica completa de primera especie. (función) [editar]
comp_ellint_2comp_ellint_2fcomp_ellint_2l (C++17)(C++17)(C++17)	Integral elíptica completa de segunda especie. (función) [editar]
comp_ellint_3comp_ellint_3fcomp_ellint_3l (C++17)(C++17)(C++17)	Integral elíptica completa de tercera especie. (función) [editar]
cyl_bessel_icyl_bessel_ifcyl_bessel_il (C++17)(C++17)(C++17)	Funciones cilíndricas de Bessel regulares modificadas. (función) [editar]
cyl_bessel_jcyl_bessel_jfcyl_bessel_jl (C++17)(C++17)(C++17)	Funciones cilíndricas de Bessel de primera especie. (función) [editar]
cyl_bessel_kcyl_bessel_kfcyl_bessel_kl (C++17)(C++17)(C++17)	Funciones cilíndricas de Bessel irregulares modificadas (o de segunda especie). (función) [editar]
cyl_neumanncyl_neumannfcyl_neumannl (C++17)(C++17)(C++17)	Funciones cilíndricas de Neumann (funciones cilíndricas de Bessel de segunda especie o funciones de Weber). (función) [editar]
ellint_1ellint_1fellint_1l (C++17)(C++17)(C++17)	Integral elíptica incompleta de primera especie. (función) [editar]
ellint_2ellint_2fellint_2l (C++17)(C++17)(C++17)	Integral elíptica incompleta de segunda especie. (función) [editar]
ellint_3ellint_3fellint_3l (C++17)(C++17)(C++17)	Integral elíptica incompleta de tercera especie. (función) [editar]
expintexpintfexpintl (C++17)(C++17)(C++17)	Integral exponencial. (función) [editar]
hermitehermitefhermitel (C++17)(C++17)(C++17)	Polinomios de Hermite. (función) [editar]
legendrelegendreflegendrel (C++17)(C++17)(C++17)	Polinomios de Legendre. (función) [editar]
laguerrelaguerreflaguerrel (C++17)(C++17)(C++17)	Polinomios de Laguerre. (función) [editar]
riemann_zetariemann_zetafriemann_zetal (C++17)(C++17)(C++17)	Función zeta de Riemann. (función) [editar]
sph_besselsph_besselfsph_bessell (C++17)(C++17)(C++17)	Funciones esféricas de Bessel functions de primera especie. (función) [editar]
sph_legendresph_legendrefsph_legendrel (C++17)(C++17)(C++17)	Funciones esféricas asociadas de Legendre. (función) [editar]
sph_neumannsph_neumannfsph_neumannl (C++17)(C++17)(C++17)	Funciones esféricas de Neumann (funciones esféricas de Bessel de segunda especie). (función) [editar]

Sinopsis

namespace std {
  using float_t = /* véase descripción */;
  using double_t = /* véase descripción */;
}

#define HUGE_VAL /* véase descripción */
#define HUGE_VALF /* véase descripción */
#define HUGE_VALL /* véase descripción */
#define INFINITY /* véase descripción */
#define NAN /* véase descripción */
#define FP_INFINITE /* véase descripción */
#define FP_NAN /* véase descripción */
#define FP_NORMAL /* véase descripción */
#define FP_SUBNORMAL /* véase descripción */
#define FP_ZERO /* véase descripción */
#define FP_FAST_FMA /* véase descripción */
#define FP_FAST_FMAF /* véase descripción */
#define FP_FAST_FMAL /* véase descripción */
#define FP_ILOGB0 /* véase descripción */
#define FP_ILOGBNAN /* véase descripción */
#define MATH_ERRNO /* véase descripción */
#define MATH_ERREXCEPT /* véase descripción */

#define math_errhandling /* véase descripción */

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);

  // valores absolutos
  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);

  // hipotenusa tridimensional
  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);

  // interpolación lineal
  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;

  // funciones de clasificación y comparación
  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);

  // funciones matemáticas especiales

  // polinomios asociados de Laguerre
  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);

  // funciones asociadas de Legendre
  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);

  // función beta
  double       beta(double x, double y);
  float        betaf(float x, float y);
  long double  betal(long double x, long double y);

  // integral elíptica completa de primera especie
  double       comp_ellint_1(double k);
  float        comp_ellint_1f(float k);
  long double  comp_ellint_1l(long double k);

  // integral elíptica completa de segunda especie
  double       comp_ellint_2(double k);
  float        comp_ellint_2f(float k);
  long double  comp_ellint_2l(long double k);

  // integral elíptica completa de tercera especie
  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);

  // funciones cilíndricas de Bessel regulares modificadas
  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);

  // funciones cilíndricas de Bessel de primera especie
  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);

  // funciones cilíndricas de Bessel irregulares modificadas
  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);

  // funciones cilíndricas de Neumann
  // funciones cilíndricas de Bessel de segunda especie
  double       cyl_neumann(double nu, double x);
  float        cyl_neumannf(float nu, float x);
  long double  cyl_neumannl(long double nu, long double x);

  // integral elíptica incompleta de primera especie
  double       ellint_1(double k, double phi);
  float        ellint_1f(float k, float phi);
  long double  ellint_1l(long double k, long double phi);

  // integral elíptica incompleta de segunda especie
  double       ellint_2(double k, double phi);
  float        ellint_2f(float k, float phi);
  long double  ellint_2l(long double k, long double phi);

  // integral elíptica incompleta de tercera especie
  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);

  // integral exponencial
  double       expint(double x);
  float        expintf(float x);
  long double  expintl(long double x);

  // polinomios de Hermite
  double       hermite(unsigned n, double x);
  float        hermitef(unsigned n, float x);
  long double  hermitel(unsigned n, long double x);

  // polinomios de Laguerre
  double       laguerre(unsigned n, double x);
  float        laguerref(unsigned n, float x);
  long double  laguerrel(unsigned n, long double x);

  // polinomios de Legendre
  double       legendre(unsigned l, double x);
  float        legendref(unsigned l, float x);
  long double  legendrel(unsigned l, long double x);

  // función zeta de Riemann
  double       riemann_zeta(double x);
  float        riemann_zetaf(float x);
  long double  riemann_zetal(long double x);

  // funciones esféricas de Bessel de primera especie
  double       sph_bessel(unsigned n, double x);
  float        sph_besself(unsigned n, float x);
  long double  sph_bessell(unsigned n, long double x);

  // funciones esféricas asociadas de Legendre
  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);

  // funciones esféricas de Neumann;
  // funciones esféricas de Bessel de segunda especie
  double       sph_neumann(unsigned n, double x);
  float        sph_neumannf(unsigned n, float x);
  long double  sph_neumannl(unsigned n, long double x);
}

Apoyo de compiladores
Implementaciones independientes y albergadas
Lenguaje
Biblioteca estándar
Encabezados de la biblioteca estándar
Requisitos denominados
Macros de prueba de característica (C++20)
Biblioteca de apoyo del lenguaje
Biblioteca de conceptos (C++20)
Biblioteca de diagnósticos
Biblioteca de gestión de memoria
Biblioteca de metaprogramación (C++11)
Biblioteca de servicios generales
Biblioteca de contenedores
Biblioteca de iteradores
Biblioteca de rangos (C++20)
Biblioteca de algoritmos
Biblioteca de cadenas
Biblioteca de procesamiento de texto
Biblioteca numérica
Biblioteca de fecha y hora
Biblioteca de entrada/salida
Biblioteca del sistema de archivos (C++17)
Biblioteca de apoyo de concurrencia (C++11)
Biblioteca de apoyo de ejecución (C++26)
Especificaciones técnicas
Índice de símbolos
Bibliotecas externas

cppreference.com

Buscar

Espacios de nombres

Variantes

Vistas

Acciones

Archivo de encabezado de la biblioteca estándar <cmath>

Sumario

Tipos

Macros

Classification

Funciones

Operaciones básicas

Interpolación lineal

Funciones exponenciales

Funciones de potencias

Funciones trigonométricas

Funciones hiperbólicas

Funciones de error y gamma

Operaciones de punto flotante del entero más cercano

Funciones de manipulación de punto flotante

Clasificación y comparación

Funciones matemáticas especiales special functions

Sinopsis

Navegación

Herramientas