# 标准库头文件 <cmath>

< cpp‎ | header

此头文件原作为 `<math.h>` 存在于 C 标准库。

此头文件是数值库的一部分。

### 类型
float_t (C++11) | 至少和 float 一样宽的最高效浮点类型 (typedef)
double_t (C++11) | 至少和 double 一样宽的最高效浮点类型 (typedef)
### 宏
HUGE_VALF HUGE_VAL HUGE_VALL (C++11)(C++11) | 分别指出 float、double 和 long double 的上溢值 (宏常量)
INFINITY (C++11) | 求值为正无穷大或保证使 float 上溢的值 (宏常量)
NAN (C++11) | 求值为 float 类型的静默 NAN (宏常量)
math_errhandling MATH_ERRNO MATH_ERREXCEPT (C++11)(C++11)(C++11) | 定义常用数学函数所用的错误处理机制 (宏常量)
##### 分类
FP_NORMAL FP_SUBNORMAL FP_ZERO FP_INFINITE FP_NAN (C++11)(C++11)(C++11)(C++11)(C++11) | 指示浮点类别 (宏常量)
### 函数
##### 基本运算
abs(float)fabs fabsf fabsl (C++11)(C++11) | 浮点值的绝对值（ \(\small{|x|}\)|x| ） (函数)
fmod fmodf fmodl (C++11)(C++11) | 浮点除法运算的余数 (函数)
remainder remainderf remainderl (C++11)(C++11)(C++11) | 除法运算的有符号余数 (函数)
remquo remquof remquol (C++11)(C++11)(C++11) | 除法运算的有符号余数和最后三个二进制位 (函数)
fma fmaf fmal (C++11)(C++11)(C++11) | 混合的乘加运算 (函数)
fmax fmaxf fmaxl (C++11)(C++11)(C++11) | 两个浮点值的较大者 (函数)
fmin fminf fminl (C++11)(C++11)(C++11) | 两个浮点值的较小者 (函数)
fdim fdimf fdiml (C++11)(C++11)(C++11) | 两个浮点值的正数差（ \({\small\max{(0, x-y)} }\)max(0, x-y) ） (函数)
nan nanf nanl (C++11)(C++11)(C++11) | 非数（NaN） (函数)
##### 线性插值
lerp (C++20) | 线性插值函数 (函数)
##### 指数函数
exp expf expl (C++11)(C++11) | 返回 e 的给定次幂（ \({\small e^x}\)ex ） (函数)
exp2 exp2f exp2l (C++11)(C++11)(C++11) | 返回 2 的给定次幂（ \({\small 2^x}\)2x ） (函数)
expm1 expm1f expm1l (C++11)(C++11)(C++11) | 返回 e 的给定次幂减一（ \({\small e^x-1}\)ex-1 ） (函数)
log logf logl (C++11)(C++11) | 计算自然（以 e 为底）对数（ \({\small \ln{x} }\)ln(x) ） (函数)
log10 log10f log10l (C++11)(C++11) | 计算常用（以 10 为底）对数（ \({\small \log_{10}{x} }\)log10(x) ） (函数)
log2 log2f log2l (C++11)(C++11)(C++11) | 给定数值的以 2 为底的对数（ \({\small \log_{2}{x} }\)log2(x) ） (函数)
log1p log1pf log1pl (C++11)(C++11)(C++11) | 1 加上给定数值的自然（以 e 为底）对数（ \({\small \ln{(1+x)} }\)ln(1+x) ） (函数)
##### 幂函数
pow powf powl (C++11)(C++11) | 求某数的给定次幂（ \(\small{x^y}\)xy ） (函数)
sqrt sqrtf sqrtl (C++11)(C++11) | 计算平方根（ \(\small{\sqrt{x} }\)√x ） (函数)
cbrt cbrtf cbrtl (C++11)(C++11)(C++11) | 计算立方根（ \(\small{\sqrt[3]{x} }\)3√x ） (函数)
hypot hypotf hypotl (C++11)(C++11)(C++11) | 计算两个给定数的平方和的平方根（ \(\scriptsize{\sqrt{x^2+y^2} }\)√x2 +y2 ） (函数)
##### 三角函数
sin sinf sinl (C++11)(C++11) | 计算正弦（ \({\small\sin{x} }\)sin(x) ） (函数)
cos cosf cosl (C++11)(C++11) | 计算余弦（ \({\small\cos{x} }\)cos(x) ） (函数)
tan tanf tanl (C++11)(C++11) | 计算正切（ \({\small\tan{x} }\)tan(x) ） (函数)
asin asinf asinl (C++11)(C++11) | 计算反正弦（ \({\small\arcsin{x} }\)arcsin(x) ） (函数)
acos acosf acosl (C++11)(C++11) | 计算反余弦（ \({\small\arccos{x} }\)arccos(x) ） (函数)
atan atanf atanl (C++11)(C++11) | 计算反正切（ \({\small\arctan{x} }\)arctan(x) ） (函数)
atan2 atan2f atan2l (C++11)(C++11) | 反正切，用符号确定象限 (函数)
##### 双曲函数
sinh sinhf sinhl (C++11)(C++11) | 计算双曲正弦（ \({\small\sinh{x} }\)sinh(x) ） (函数)
cosh coshf coshl (C++11)(C++11) | 计算双曲余弦（ \({\small\cosh{x} }\)cosh(x) ） (函数)
tanh tanhf tanhl (C++11)(C++11) | 计算双曲正切（ \({\small\tanh{x} }\)tanh(x) ） (函数)
asinh asinhf asinhl (C++11)(C++11)(C++11) | 计算反双曲正弦（ \({\small\operatorname{arsinh}{x} }\)arsinh(x) ） (函数)
acosh acoshf acoshl (C++11)(C++11)(C++11) | 计算反双曲余弦（ \({\small\operatorname{arcosh}{x} }\)arcosh(x) ） (函数)
atanh atanhf atanhl (C++11)(C++11)(C++11) | 计算反双曲正切（ \({\small\operatorname{artanh}{x} }\)artanh(x) ） (函数)
##### 误差与伽马函数
erf erff erfl (C++11)(C++11)(C++11) | 误差函数 (函数)
erfc erfcf erfcl (C++11)(C++11)(C++11) | 补误差函数 (函数)
tgamma tgammaf tgammal (C++11)(C++11)(C++11) | gamma 函数 (函数)
lgamma lgammaf lgammal (C++11)(C++11)(C++11) | gamma 函数的自然对数 (函数)
##### 临近整数的浮点运算
ceil ceilf ceill (C++11)(C++11) | 不小于给定值的最接近整数值 (函数)
floor floorf floorl (C++11)(C++11) | 不大于给定值的最接近整数 (函数)
trunc truncf truncl (C++11)(C++11)(C++11) | 绝对值不大于给定值的最接近整数 (函数)
round roundf roundl lround lroundf lroundl llround llroundf llroundl (C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11) | 最接近整数，中间情况下向远离零舍入 (函数)
nearbyint nearbyintf nearbyintl (C++11)(C++11)(C++11) | 使用当前舍入模式的最接近整数 (函数)
rint rintf rintl lrint lrintf lrintl llrint llrintf llrintl (C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11) | 使用当前舍入模式的最接近整数 若结果有别则有异常 (函数)
##### 浮点操纵函数
frexp frexpf frexpl (C++11)(C++11) | 将数分解为有效数字和 2 的幂次 (函数)
ldexp ldexpf ldexpl (C++11)(C++11) | 将数乘以 2 的幂次 (函数)
modf modff modfl (C++11)(C++11) | 分解数为整数和小数部分 (函数)
scalbn scalbnf scalbnl scalbln scalblnf scalblnl (C++11)(C++11)(C++11)(C++11)(C++11)(C++11) | 将数乘以 FLT_RADIX 的幂次 (函数)
ilogb ilogbf ilogbl (C++11)(C++11)(C++11) | 提取数的指数 (函数)
logb logbf logbl (C++11)(C++11)(C++11) | 提取数的指数 (函数)
nextafter nextafterf nextafterl nexttoward nexttowardf nexttowardl (C++11)(C++11) (C++11)(C++11)(C++11)(C++11) | 趋向给定值的下个可表示浮点值 (函数)
copysign copysignf copysignl (C++11)(C++11)(C++11) | 复制浮点值的符号 (函数)
##### 分类与比较
fpclassify (C++11) | 归类给定的浮点值 (函数)
isfinite (C++11) | 检查给定数是否拥有有限值 (函数)
isinf (C++11) | 检查给定数是否为无限 (函数)
isnan (C++11) | 检查给定的数是否 NaN (函数)
isnormal (C++11) | 检查给定数是否正规 (函数)
signbit (C++11) | 检查给定数是否为负 (函数)
isgreater (C++11) | 检查第一个浮点实参是否大于第二个 (函数)
isgreaterequal (C++11) | 检查第一个浮点实参是否大于或等于第二个 (函数)
isless (C++11) | 检查第一个浮点实参是否小于第二个 (函数)
islessequal (C++11) | 检查第一个浮点实参是否小于或等于第二个 (函数)
islessgreater (C++11) | 检查第一个浮点实参是否小于或大于第二个 (函数)
isunordered (C++11) | 检查两个浮点值是否无顺序 (函数)
##### 数学特殊函数
assoc_laguerre assoc_laguerref assoc_laguerrel (C++17)(C++17)(C++17) | 连带拉盖尔多项式 (函数)
assoc_legendre assoc_legendref assoc_legendrel (C++17)(C++17)(C++17) | 连带勒让德多项式 (函数)
beta betaf betal (C++17)(C++17)(C++17) | beta 函数 (函数)
comp_ellint_1 comp_ellint_1f comp_ellint_1l (C++17)(C++17)(C++17) | 第一类（完全）椭圆积分 (函数)
comp_ellint_2 comp_ellint_2f comp_ellint_2l (C++17)(C++17)(C++17) | 第二类（完全）椭圆积分 (函数)
comp_ellint_3 comp_ellint_3f comp_ellint_3l (C++17)(C++17)(C++17) | 第三类（完全）椭圆积分 (函数)
cyl_bessel_i cyl_bessel_if cyl_bessel_il (C++17)(C++17)(C++17) | 规则变形圆柱贝塞尔函数 (函数)
cyl_bessel_j cyl_bessel_jf cyl_bessel_jl (C++17)(C++17)(C++17) | （第一类）圆柱贝塞尔函数 (函数)
cyl_bessel_k cyl_bessel_kf cyl_bessel_kl (C++17)(C++17)(C++17) | 不规则变形圆柱贝塞尔函数 (函数)
cyl_neumann cyl_neumannf cyl_neumannl (C++17)(C++17)(C++17) | 圆柱诺依曼函数 (函数)
ellint_1 ellint_1f ellint_1l (C++17)(C++17)(C++17) | 第一类（不完全）椭圆积分 (函数)
ellint_2 ellint_2f ellint_2l (C++17)(C++17)(C++17) | 第二类（不完全）椭圆积分 (函数)
ellint_3 ellint_3f ellint_3l (C++17)(C++17)(C++17) | 第三类（不完全）椭圆积分 (函数)
expint expintf expintl (C++17)(C++17)(C++17) | 指数积分 (函数)
hermite hermitef hermitel (C++17)(C++17)(C++17) | 埃尔米特多项式 (函数)
legendre legendref legendrel (C++17)(C++17)(C++17) | 勒让德多项式 (函数)
laguerre laguerref laguerrel (C++17)(C++17)(C++17) | 拉盖尔多项式 (函数)
riemann_zeta riemann_zetaf riemann_zetal (C++17)(C++17)(C++17) | 黎曼 zeta 函数 (函数)
sph_bessel sph_besself sph_bessell (C++17)(C++17)(C++17) | （第一类）球面贝塞尔函数 (函数)
sph_legendre sph_legendref sph_legendrel (C++17)(C++17)(C++17) | 球面连带勒让德函数 (函数)
sph_neumann sph_neumannf sph_neumannl (C++17)(C++17)(C++17) | 球面诺依曼函数 (函数)

### 概要

    namespace std {
      using float_t = /* 见描述 */;
      using double_t = /* 见描述 */;
    }

    #define HUGE_VAL /* 见描述 */
    #define HUGE_VALF /* 见描述 */
    #define HUGE_VALL /* 见描述 */
    #define INFINITY /* 见描述 */
    #define NAN /* 见描述 */
    #define FP_INFINITE /* 见描述 */
    #define FP_NAN /* 见描述 */
    #define FP_NORMAL /* 见描述 */
    #define FP_SUBNORMAL /* 见描述 */
    #define FP_ZERO /* 见描述 */
    #define FP_FAST_FMA /* 见描述 */
    #define FP_FAST_FMAF /* 见描述 */
    #define FP_FAST_FMAL /* 见描述 */
    #define FP_ILOGB0 /* 见描述 */
    #define FP_ILOGBNAN /* 见描述 */
    #define MATH_ERRNO /* 见描述 */
    #define MATH_ERREXCEPT /* 见描述 */

    #define math_errhandling /* 见描述 */

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

      // 绝对值
      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);

      // 三维斜边
      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);

      // 线性插值
      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;

      // 分类/比较函数
      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);

      // 数学特殊函数

      // 连带拉盖尔多项式
      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);

      // 连带勒让德多项式
      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 函数
      double       beta(double x, double y);
      float        betaf(float x, float y);
      long double  betal(long double x, long double y);

      // 第一类完全椭圆积分
      double       comp_ellint_1(double k);
      float        comp_ellint_1f(float k);
      long double  comp_ellint_1l(long double k);

      // 第二类完全椭圆积分
      double       comp_ellint_2(double k);
      float        comp_ellint_2f(float k);
      long double  comp_ellint_2l(long double k);

      // 第三类完全椭圆积分
      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);

      // 规则变形圆柱贝塞尔函数
      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);

      // 第一类圆柱贝塞尔函数
      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);

      // 不规则变形圆柱贝塞尔函数
      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);

      // 圆柱诺伊曼函数；
      // 第二类圆柱贝塞尔函数
      double       cyl_neumann(double nu, double x);
      float        cyl_neumannf(float nu, float x);
      long double  cyl_neumannl(long double nu, long double x);

      // 第一类不完全椭圆积分
      double       ellint_1(double k, double phi);
      float        ellint_1f(float k, float phi);
      long double  ellint_1l(long double k, long double phi);

      // 第二类不完全椭圆积分
      double       ellint_2(double k, double phi);
      float        ellint_2f(float k, float phi);
      long double  ellint_2l(long double k, long double phi);

      // 第三类不完全椭圆积分
      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);

      // 指数积分
      double       expint(double x);
      float        expintf(float x);
      long double  expintl(long double x);

      // 埃尔米特多项式
      double       hermite(unsigned n, double x);
      float        hermitef(unsigned n, float x);
      long double  hermitel(unsigned n, long double x);

      // 拉盖尔多项式
      double       laguerre(unsigned n, double x);
      float        laguerref(unsigned n, float x);
      long double  laguerrel(unsigned n, long double x);

      // 勒让德多项式
      double       legendre(unsigned l, double x);
      float        legendref(unsigned l, float x);
      long double  legendrel(unsigned l, long double x);

      // 黎曼 zeta 函数
      double       riemann_zeta(double x);
      float        riemann_zetaf(float x);
      long double  riemann_zetal(long double x);

      // 第一类球面贝塞尔函数
      double       sph_bessel(unsigned n, double x);
      float        sph_besself(unsigned n, float x);
      long double  sph_bessell(unsigned n, long double x);

      // 球面连带勒让德函数
      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);

      // 球面诺依曼函数；
      // 第二类球面贝塞尔函数
      double       sph_neumann(unsigned n, double x);
      float        sph_neumannf(unsigned n, float x);
      long double  sph_neumannl(unsigned n, long double x);
    }