Namespaces
Variants

Standard library header <cmath>

From cppreference.net
C++
Standard library headers

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

Este encabezado es parte de la biblioteca numérica .

Contenidos

Tipos

float_t
(C++11)
tipo de punto flotante más eficiente al menos tan ancho como float
(typedef)
double_t
(C++11)
tipo de punto flotante más eficiente con al menos el mismo ancho que double
(typedef)

Macros

(C++11) (C++11)
indica el valor de desbordamiento para float , double y long double respectivamente
(constante macro)
(C++11)
evalúa a infinito positivo o el valor garantizado para desbordar un float
(constante macro)
(C++11)
evalúa a un NaN silencioso de tipo float
(constante macro)
(C++11) (C++11) (C++11)
define el mecanismo de manejo de errores utilizado por las funciones matemáticas comunes
(constante macro)
Clasificación
(C++11) (C++11) (C++11) (C++11) (C++11)
indica una categoría de punto flotante
(constante macro)

Funciones

Operaciones básicas
(C++11) (C++11)
valor absoluto de un valor de punto flotante ( |x| )
(función)
(C++11) (C++11)
resto de la operación de división de punto flotante
(función)
(C++11) (C++11) (C++11)
resto con signo de la operación de división
(función)
(C++11) (C++11) (C++11)
resto con signo así como los tres últimos bits de la operación de división
(función)
(C++11) (C++11) (C++11)
operación de multiplicación-acumulación fusionada
(función)
(C++11) (C++11) (C++11)
mayor de dos valores de punto flotante
(función)
(C++11) (C++11) (C++11)
menor de dos valores de punto flotante
(función)
(C++11) (C++11) (C++11)
diferencia positiva de dos valores de punto flotante ( max(0, x-y) )
(función)
(C++11) (C++11) (C++11)
no es un número (NaN)
(función)
Interpolación lineal
(C++20)
función de interpolación lineal
(función)
Funciones exponenciales
(C++11) (C++11)
devuelve e elevado a la potencia dada ( e x )
(función)
(C++11) (C++11) (C++11)
devuelve 2 elevado a la potencia dada ( 2 x )
(función)
(C++11) (C++11) (C++11)
devuelve e elevado a la potencia dada, menos 1 ( e x -1 )
(función)
(C++11) (C++11)
calcula el logaritmo natural (base e ) ( ln(x) )
(función)
(C++11) (C++11)
calcula el logaritmo común (base 10 ) ( log 10 (x) )
(función)
(C++11) (C++11) (C++11)
logaritmo en base 2 del número dado ( log 2 (x) )
(función)
(C++11) (C++11) (C++11)
logaritmo natural (en base e ) de 1 más el número dado ( ln(1+x) )
(función)
Funciones de potencia
(C++11) (C++11)
eleva un número a la potencia dada ( x y )
(función)
(C++11) (C++11)
calcula la raíz cuadrada ( √ x )
(función)
(C++11) (C++11) (C++11)
calcula la raíz cúbica ( 3 √ x )
(función)
(C++11) (C++11) (C++11)
calcula la hipotenusa √ x 2
+y 2
y √ x 2
+y 2
+z 2
(desde C++17)
(función)
Funciones trigonométricas
(C++11) (C++11)
calcula el seno ( sin(x) )
(función)
(C++11) (C++11)
calcula el coseno ( cos(x) )
(función)
(C++11) (C++11)
calcula la tangente ( tan(x) )
(función)
(C++11) (C++11)
calcula el arco seno ( arcsin(x) )
(función)
(C++11) (C++11)
calcula el arco coseno ( arccos(x) )
(función)
(C++11) (C++11)
calcula la tangente arco ( arctan(x) )
(función)
(C++11) (C++11)
arco tangente, usando signos para determinar cuadrantes
(función)
Funciones hiperbólicas
(C++11) (C++11)
calcula el seno hiperbólico ( sinh(x) )
(función)
(C++11) (C++11)
calcula el coseno hiperbólico ( cosh(x) )
(función)
(C++11) (C++11)
calcula la tangente hiperbólica ( tanh(x) )
(función)
(C++11) (C++11) (C++11)
calcula el seno hiperbólico inverso ( arsinh(x) )
(función)
(C++11) (C++11) (C++11)
calcula el coseno hiperbólico inverso ( arcosh(x) )
(función)
(C++11) (C++11) (C++11)
calcula la tangente hiperbólica inversa ( artanh(x) )
(función)
Funciones error y gamma
(C++11) (C++11) (C++11)
función de error
(función)
(C++11) (C++11) (C++11)
función de error complementaria
(función)
(C++11) (C++11) (C++11)
función gamma
(función)
(C++11) (C++11) (C++11)
logaritmo natural de la función gamma
(función)
Operaciones de punto flotante con enteros más cercanos
(C++11) (C++11)
entero más cercano no menor que el valor dado
(función)
(C++11) (C++11)
entero más cercano no mayor que el valor dado
(función)
(C++11) (C++11) (C++11)
entero más cercano no mayor en magnitud que el valor dado
(función)
(C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11) (C++11)
entero más cercano, redondeando lejos de cero en casos intermedios
(función)
(C++11) (C++11) (C++11)
entero más cercano usando el modo de redondeo actual
(función)
(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)
Funciones de manipulación de punto flotante
(C++11) (C++11)
descompone un número en significando y exponente base- 2
(función)
(C++11) (C++11)
multiplica un número por 2 elevado a una potencia entera
(función)
(C++11) (C++11)
descompone un número en partes entera y fraccionaria
(función)
(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)
(C++11) (C++11) (C++11)
extrae el exponente del número
(función)
(C++11) (C++11) (C++11)
extrae el exponente del número
(función)
(C++11) (C++11) (C++11) (C++11) (C++11) (C++11)
siguiente valor representable de punto flotante hacia el valor dado
(función)
(C++11) (C++11) (C++11)
copia el signo de un valor de punto flotante
(función)
Clasificación y comparación
(C++11)
clasifica el valor de punto flotante dado
(función)
(C++11)
comprueba si el número dado tiene un valor finito
(función)
(C++11)
comprueba si el número dado es infinito
(función)
(C++11)
verifica si el número dado es NaN
(función)
(C++11)
verifica si el número dado es normal
(función)
(C++11)
comprueba si el número dado es negativo
(función)
(C++11)
verifica si el primer argumento de punto flotante es mayor que el segundo
(función)
(C++11)
comprueba si el primer argumento de punto flotante es mayor o igual que el segundo
(función)
(C++11)
comprueba si el primer argumento de punto flotante es menor que el segundo
(función)
(C++11)
comprueba si el primer argumento de punto flotante es menor o igual que el segundo
(función)
(C++11)
comprueba si el primer argumento de punto flotante es menor o mayor que el segundo
(función)
(C++11)
verifica si dos valores de punto flotante están desordenados
(función)
Funciones matemáticas especiales
(C++17) (C++17) (C++17)
polinomios asociados de Laguerre
(función)
(C++17) (C++17) (C++17)
polinomios asociados de Legendre
(función)
(C++17) (C++17) (C++17)
función beta
(función)
(C++17) (C++17) (C++17)
integral elíptica completa de primera especie
(función)
(C++17) (C++17) (C++17)
integral elíptica completa de segunda clase
(función)
(C++17) (C++17) (C++17)
integral elíptica completa de tercera especie
(función)
(C++17) (C++17) (C++17)
funciones cilíndricas de Bessel modificadas regulares
(función)
(C++17) (C++17) (C++17)
funciones cilíndricas de Bessel (de primera especie)
(función)
(C++17) (C++17) (C++17)
funciones de Bessel cilíndricas modificadas irregulares
(función)
(C++17) (C++17) (C++17)
funciones cilíndricas de Neumann
(función)
(C++17) (C++17) (C++17)
integral elíptica incompleta de primera clase
(función)
(C++17) (C++17) (C++17)
integral elíptica incompleta de segunda clase
(función)
(C++17) (C++17) (C++17)
integral elíptica incompleta del tercer tipo
(función)
(C++17) (C++17) (C++17)
integral exponencial
(función)
(C++17) (C++17) (C++17)
Polinomios de Hermite
(función)
(C++17) (C++17) (C++17)
Polinomios de Legendre
(función)
(C++17) (C++17) (C++17)
Polinomios de Laguerre
(función)
(C++17) (C++17) (C++17)
Función zeta de Riemann
(función)
(C++17) (C++17) (C++17)
funciones de Bessel esféricas (de primera clase)
(función)
(C++17) (C++17) (C++17)
funciones esféricas asociadas de Legendre
(función)
(C++17) (C++17) (C++17)
funciones de Neumann esféricas
(función)

Sinopsis

Para cada función con al menos un parámetro de tipo /* floating-point-type */ , se proporciona una sobrecarga para cada tipo de punto flotante sin calificadores cv donde todos los usos de /* floating-point-type */ en la firma de la función son reemplazados por ese tipo de punto flotante.

Para cada función con al menos un parámetro de tipo /* floating-point-type */ distinto de std::abs , se proporcionan sobrecargas adicionales para garantizar que, si cada argumento correspondiente a un parámetro de tipo /* floating-point-type */ tiene tipo aritmético, entonces cada uno de dichos argumentos se convierte efectivamente al tipo de punto flotante con el mayor rango de conversión de punto flotante y mayor subrango de conversión de punto flotante entre los tipos de todos estos argumentos, donde los argumentos de tipo entero se consideran con el mismo rango de conversión de punto flotante que double . Si no existe tal tipo de punto flotante con el mayor rango y subrango, entonces la resolución de sobrecarga no produce un candidato utilizable a partir de las sobrecargas proporcionadas. 

namespace std {
  using float_t = /* ver descripción */;
  using double_t = /* ver descripción */;
}
#define HUGE_VAL /* ver descripción */
#define HUGE_VALF /* ver descripción */
#define HUGE_VALL /* ver descripción */
#define INFINITY /* ver descripción */
#define NAN /* ver descripción */
#define FP_INFINITE /* ver descripción */
#define FP_NAN /* ver descripción */
#define FP_NORMAL /* ver descripción */
#define FP_SUBNORMAL /* ver descripción */
#define FP_ZERO /* ver descripción */
#define FP_FAST_FMA /* ver descripción */
#define FP_FAST_FMAF /* ver descripción */
#define FP_FAST_FMAL /* ver descripción */
#define FP_ILOGB0 /* ver descripción */
#define FP_ILOGBNAN /* ver descripción */
#define MATH_ERRNO /* ver descripción */
#define MATH_ERREXCEPT /* ver descripción */
#define math_errhandling /* ver descripción */
namespace std {
  /* tipo de punto flotante */ acos(/* tipo de punto flotante */ x);
  float acosf(float x);
  long double acosl(long double x);
  /* tipo de punto flotante */ asin(/* tipo de punto flotante */ x);
  float asinf(float x);
  long double asinl(long double x);
  /* tipo de punto flotante */ atan(/* tipo de punto flotante */ x);
  float atanf(float x);
  long double atanl(long double x);
  /* tipo de punto flotante */ atan2(/* tipo de punto flotante */ y,
                                  /* tipo de punto flotante */ x);
  float atan2f(float y, float x);
  long double atan2l(long double y, long double x);
  /* tipo de punto flotante */ cos(/* tipo de punto flotante */e x);
  float cosf(float x);
  long double cosl(long double x);
  /* tipo de punto flotante */ sin(/* tipo de punto flotante */ x);
  float sinf(float x);
  long double sinl(long double x);
  /* tipo de punto flotante */ tan(/* tipo de punto flotante */ x);
  float tanf(float x);
  long double tanl(long double x);
  /* tipo de punto flotante */ acosh(/* tipo de punto flotante */ x);
  float acoshf(float x);
  long double acoshl(long double x);
  /* tipo de punto flotante */ asinh(/* tipo de punto flotante */ x);
  float asinhf(float x);
  long double asinhl(long double x);
  /* tipo de punto flotante */ atanh(/* tipo de punto flotante */ x);
  float atanhf(float x);
  long double atanhl(long double x);
  /* tipo de punto flotante */ cosh(/* tipo de punto flotante */ x);
  float coshf(float x);
  long double coshl(long double x);
  /* tipo de punto flotante */ sinh(/* tipo de punto flotante */ x);
  float sinhf(float x);
  long double sinhl(long double x);
  /* tipo de punto flotante */ tanh(/* tipo de punto flotante */ x);
  float tanhf(float x);
  long double tanhl(long double x);
  /* tipo de punto flotante */ exp(/* tipo de punto flotante */ x);
  float expf(float x);
  long double expl(long double x);
  /* tipo de punto flotante */ exp2(/* tipo de punto flotante */ x);
  float exp2f(float x);
  long double exp2l(long double x);
  /* tipo de punto flotante */ expm1(/* tipo de punto flotante */ x);
  float expm1f(float x);
  long double expm1l(long double x);
  constexpr /* tipo de punto flotante */ frexp(/* tipo de punto flotante */ value, int* exp);
  constexpr float frexpf(float value, int* exp);
  constexpr long double frexpl(long double value, int* exp);
  constexpr int ilogb(/* tipo de punto flotante */ x);
  constexpr int ilogbf(float x);
  constexpr int ilogbl(long double x);
  constexpr /* tipo de punto flotante */ ldexp(/* tipo de punto flotante */ x, int exp);
  constexpr float ldexpf(float x, int exp);
  constexpr long double ldexpl(long double x, int exp);
  /* tipo de punto flotante */ log(/* tipo de punto flotante */ x);
  float logf(float x);
  long double logl(long double x);
  /* tipo de punto flotante */ log10(/* tipo de punto flotante */ x);
  float log10f(float x);
  long double log10l(long double x);
  /* tipo de punto flotante */ log1p(/* tipo de punto flotante */ x);
  float log1pf(float x);
  long double log1pl(long double x);
  /* tipo de punto flotante */ log2(/* tipo de punto flotante */ x);
  float log2f(float x);
  long double log2l(long double x);
  constexpr /* tipo de punto flotante */ logb(/* tipo de punto flotante */ x);
  constexpr float logbf(float x);
  constexpr long double logbl(long double x);
  constexpr /* tipo de punto flotante */ modf(/* tipo de punto flotante */ value,
                                           /* tipo de punto flotante */* iptr);
  constexpr float modff(float value, float* iptr);
  constexpr long double modfl(long double value, long double* iptr);
  constexpr /* tipo de punto flotante */ scalbn(/* tipo de punto flotante */ x, int n);
  constexpr float scalbnf(float x, int n);
  constexpr long double scalbnl(long double x, int n);
  constexpr /* tipo de punto flotante */ scalbln(/* tipo de punto flotante */ x, long int n);
  constexpr float scalblnf(float x, long int n);
  constexpr long double scalblnl(long double x, long int n);
  /* tipo de punto flotante */ cbrt(/* tipo de punto flotante */ x);
  float cbrtf(float x);
  long double cbrtl(long double x);
  // valores absolutos
  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 /* tipo de punto flotante */
    abs(/* tipo de punto flotante */ j);           // freestanding-deleted
  constexpr /* tipo de punto flotante */ fabs(/* tipo de punto flotante */ x);
  constexpr float fabsf(float x);
  constexpr long double fabsl(long double x);
  /* tipo de punto flotante */ hypot(/* tipo de punto flotante */ x,
                                  /* tipo de punto flotante */ y);
  float hypotf(float x, float y);
  long double hypotl(long double x, long double y);
  // hipotenusa tridimensional
  float hypot(/* tipo de punto flotante */ x,
              /* tipo de punto flotante */ y,
              /* tipo de punto flotante */ z);
  /* tipo de punto flotante */ pow(/* tipo de punto flotante */ x,
                                /* tipo de punto flotante */ y);
  float powf(float x, float y);
  long double powl(long double x, long double y);
  /* tipo de punto flotante */ sqrt(/* tipo de punto flotante */ x);
  float sqrtf(float x);
  long double sqrtl(long double x);
  /* tipo de punto flotante */ erf(/* tipo de punto flotante */ x);
  float erff(float x);
  long double erfl(long double x);
  /* tipo de punto flotante */ erfc(/* tipo de punto flotante */ x);
  float erfcf(float x);
  long double erfcl(long double x);
  /* tipo de punto flotante */ lgamma(/* tipo de punto flotante */ x);
  float lgammaf(float x);
  long double lgammal(long double x);
  /* tipo de punto flotante */ tgamma(/* tipo de punto flotante */ x);
  float tgammaf(float x);
  long double tgammal(long double x);
  constexpr /* tipo de punto flotante */ ceil(/* tipo de punto flotante */ x);
  constexpr float ceilf(float x);
  constexpr long double ceill(long double x);
  constexpr /* tipo de punto flotante */ floor(/* tipo de punto flotante */ x);
  constexpr float floorf(float x);
  constexpr long double floorl(long double x);
  /* tipo de punto flotante */ nearbyint(/* tipo de punto flotante */ x);
  float nearbyintf(float x);
  long double nearbyintl(long double x);
  /* tipo de punto flotante */ rint(/* tipo de punto flotante */ x);
  float rintf(float x);
  long double rintl(long double x);
  long int lrint(/* tipo de punto flotante */ x);
  long int lrintf(float x);
  long int lrintl(long double x);
  long long int llrint(/* tipo de punto flotante */ x);
  long long int llrintf(float x);
  long long int llrintl(long double x);
  constexpr /* tipo de punto flotante */ round(/* tipo de punto flotante */ x);
  constexpr float roundf(float x);
  constexpr long double roundl(long double x);
  constexpr long int lround(/* tipo de punto flotante */ x);
  constexpr long int lroundf(float x);
  constexpr long int lroundl(long double x);
  constexpr long long int llround(/* tipo de punto flotante */ x);
  constexpr long long int llroundf(float x);
  constexpr long long int llroundl(long double x);
  constexpr /* tipo de punto flotante */ trunc(/* tipo de punto flotante */ x);
  constexpr float truncf(float x);
  constexpr long double truncl(long double x);
  constexpr /* tipo de punto flotante */ fmod(/* tipo de punto flotante */ x,
                                           /* tipo de punto flotante */ y);
  constexpr float fmodf(float x, float y);
  constexpr long double fmodl(long double x, long double y);
  constexpr /* tipo de punto flotante */ remainder(/* tipo de punto flotante */ x,
                                                /* tipo de punto flotante */ y);
  constexpr float remainderf(float x, float y);
  constexpr long double remainderl(long double x, long double y);
  constexpr /* tipo de punto flotante */ remquo(/* tipo de punto flotante */ x,
                                             /* tipo de punto flotante */ 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 /* tipo de punto flotante */ copysign(/* tipo de punto flotante */ x,
                                               /* tipo de punto flotante */ 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 /* tipo de punto flotante */ nextafter(/* tipo de punto flotante */ x,
                                                /* tipo de punto flotante */ y);
  constexpr float nextafterf(float x, float y);
  constexpr long double nextafterl(long double x, long double y);
  constexpr /* tipo de punto flotante */ nexttoward(/* tipo de punto flotante */ x,
                                                 long double y);
  constexpr float nexttowardf(float x, long double y);
  constexpr long double nexttowardl(long double x, long double y);
  constexpr /* tipo de punto flotante */ fdim(/* tipo de punto flotante */ x,
                                           /* tipo de punto flotante */ y);
  constexpr float fdimf(float x, float y);
  constexpr long double fdiml(long double x, long double y);
  constexpr /* tipo de punto flotante */ fmax(/* tipo de punto flotante */ x,
                                           /* tipo de punto flotante */ y);
  constexpr float fmaxf(float x, float y);
  constexpr long double fmaxl(long double x, long double y);
  constexpr /* tipo de punto flotante */ fmin(/* tipo de punto flotante */ x,
                                           /* tipo de punto flotante */ y);
  constexpr float fminf(float x, float y);
  constexpr long double fminl(long double x, long double y);
  constexpr /* tipo de punto flotante */ fma(/* tipo de punto flotante */ x,
                                          /* tipo de punto flotante */ y,
                                          /* tipo de punto flotante */ z);
  constexpr float fmaf(float x, float y, float z);
  constexpr long double fmal(long double x, long double y, long double z);
  // interpolación lineal
  constexpr /* tipo de punto flotante */ lerp(/* tipo de punto flotante */ a,
                                           /* tipo de punto flotante */ b,
                                           /* tipo de punto flotante */ t) noexcept;
  // funciones de clasificación / comparación
  constexpr int fpclassify(/* tipo de punto flotante */ x);
  constexpr bool isfinite(/* tipo de punto flotante */ x);
  constexpr bool isinf(/* tipo de punto flotante */ x);
  constexpr bool isnan(/* tipo de punto flotante */ x);
  constexpr bool isnormal(/* tipo de punto flotante */ x);
  constexpr bool signbit(/* tipo de punto flotante */ x);
  constexpr bool isgreater(/* tipo de punto flotante */ x,
                           /* tipo de punto flotante */ y);
  constexpr bool isgreaterequal(/* tipo de punto flotante */ x,
                                /* tipo de punto flotante */ y);
  constexpr bool isless(/* tipo de punto flotante */ x,
                        /* tipo de punto flotante */ y);
  constexpr bool islessequal(/* tipo de punto flotante */ x,
                             /* tipo de punto flotante */ y);
  constexpr bool islessgreater(/* tipo de punto flotante */ x,
                               /* tipo de punto flotante */ y);
  constexpr bool isunordered(/* tipo de punto flotante */ x,
                             /* tipo de punto flotante */ y);
  // funciones matemáticas especiales
  // polinomios asociados de Laguerre
  /* tipo de punto flotante */ assoc_laguerre(unsigned n, unsigned m,
                                           /* tipo de punto flotante */ 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
  /* tipo de punto flotante */ assoc_legendre(unsigned l, unsigned m,
                                           /* tipo de punto flotante */ x);
  float assoc_legendref(unsigned l, unsigned m, float x);
  long double assoc_legendrel(unsigned l, unsigned m, long double x);
  // función beta
  /* tipo de punto flotante */ beta(/* tipo de punto flotante */ x,
                                 /* tipo de punto flotante */ y);
  float betaf(float x, float y);
  long double betal(long double x, long double y);
  // integral elíptica completa de primera especie
  /* tipo de punto flotante */ comp_ellint_1(/* tipo de punto flotante */ k);
  float comp_ellint_1f(float k);
  long double comp_ellint_1l(long double k);
  // integral elíptica completa de segunda especie
  /* tipo de punto flotante */ comp_ellint_2(/* tipo de punto flotante */ k);
  float comp_ellint_2f(float k);
  long double comp_ellint_2l(long double k);
  // integral elíptica completa de tercera especie
  /* tipo de punto flotante */ comp_ellint_3(/* tipo de punto flotante */ k,
                                          /* tipo de punto flotante */ nu);
  float comp_ellint_3f(float k, float nu);
  long double comp_ellint_3l(long double k, long double nu);
  // funciones de Bessel cilíndricas modificadas regulares
  /* tipo de punto flotante */ cyl_bessel_i(/* tipo de punto flotante */ nu,
                                         /* tipo de punto flotante */ x);
  float cyl_bessel_if(float nu, float x);
  long double cyl_bessel_il(long double nu, long double x);
  // funciones de Bessel cilíndricas de primera especie
  /* tipo de punto flotante */ cyl_bessel_j(/* tipo de punto flotante */ nu,
                                         /* tipo de punto flotante */ x);
  float cyl_bessel_jf(float nu, float x);
  long double cyl_bessel_jl(long double nu, long double x);
  // funciones de Bessel cilíndricas modificadas irregulares
  /* tipo de punto flotante */ cyl_bessel_k(/* tipo de punto flotante */ nu,
                                         /* tipo de punto flotante */ 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 de Bessel cilíndricas del segundo tipo
  /* tipo de punto flotante */ cyl_neumann(/* tipo de punto flotante */ nu,
                                        /* tipo de punto flotante */ 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
  /* tipo de punto flotante */ ellint_1(/* tipo de punto flotante */ k,
                                     /* tipo de punto flotante */ 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
  /* tipo de punto flotante */ ellint_2(/* tipo de punto flotante */ k,
                                     /* tipo de punto flotante */ 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
  /* tipo de punto flotante */ ellint_3(/* tipo de punto flotante */ k,
                                     /* tipo de punto flotante */ nu,
                                     /* tipo de punto flotante */ 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
  /* tipo de punto flotante */ expint(/* tipo de punto flotante */ x);
  float expintf(float x);
  long double expintl(long double x);
  // Polinomios de Hermite
  /* tipo de punto flotante */ hermite(unsigned n, /* tipo de punto flotante */ x);
  float hermitef(unsigned n, float x);
  long double hermitel(unsigned n, long double x);
  // Polinomios de Laguerre
  /* tipo de punto flotante */ laguerre(unsigned n, /* tipo de punto flotante */ x);
  float laguerref(unsigned n, float x);
  long double laguerrel(unsigned n, long double x);
  // Polinomios de Legendre
  /* tipo de punto flotante */ legendre(unsigned l, /* tipo de punto flotante */ x);
  float legendref(unsigned l, float x);
  long double legendrel(unsigned l, long double x);
  // Función zeta de Riemann
  /* tipo de punto flotante */ riemann_zeta(/* tipo de punto flotante */ x);
  float riemann_zetaf(float x);
  long double riemann_zetal(long double x);
  // funciones de Bessel esféricas de primera especie
  /* tipo de punto flotante */ sph_bessel(unsigned n, /* tipo de punto flotante */ x);
  float sph_besself(unsigned n, float x);
  long double sph_bessell(unsigned n, long double x);
  // funciones asociadas de Legendre esféricas
  /* tipo de punto flotante */ sph_legendre(unsigned l, unsigned m,
                                         /* tipo de punto flotante */ 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 de Bessel esféricas de segunda clase
  /* tipo de punto flotante */ sph_neumann(unsigned n, /* tipo de punto flotante */ x);
  float sph_neumannf(unsigned n, float x);
  long double sph_neumannl(unsigned n, long double x);
}