命名空间
变体
操作

标准库头文件 <cmath>

来自 cppreference.com
< cpp‎ | header
 
C++
 
标准库头文件
语言支持
概念
<concepts> (C++20)
诊断
<system_error> (C++11)

内存管理
<memory_resource> (C++17)  
元编程
<type_traits> (C++11)
<ratio> (C++11)
通用实用工具
<utility>
<tuple> (C++11)
<optional> (C++17)
<variant> (C++17)
<any> (C++17)
<debugging> (C++26)
<expected> (C++23)
<bitset>
<charconv> (C++17)
<format> (C++20)
<bit> (C++20)

字符串
<cuchar> (C++11)

容器
<flat_set> (C++23)
<span> (C++20)
<mdspan> (C++23)
<inplace_vector> (C++26)
迭代器
<iterator>
范围
<ranges> (C++20)
<generator> (C++23)
算法
数值
<cfenv> (C++11)
<complex>
<cmath>
<linalg> (C++26)
<numbers> (C++20)

时间
<chrono> (C++11)
本地化
<codecvt> (C++11/17/26*)
<text_encoding> (C++26)
输入/输出
<filesystem> (C++17)
<cstdio>
<cinttypes> (C++11)
<strstream> (C++98/26*)
正则表达式
<regex> (C++11)
并发支持
<stop_token> (C++20)
<thread> (C++11)
<atomic> (C++11)
<rcu> (C++26)
<stdatomic.h> (C++23)
<mutex> (C++11)
<shared_mutex> (C++14)

<condition_variable> (C++11)  
<semaphore> (C++20)
<latch> (C++20)

<barrier> (C++20)
<future> (C++11)
<hazard_pointer> (C++26)

C 兼容性
<cstdbool> (C++11/17/20*)  
<ccomplex> (C++11/17/20*)
<ctgmath> (C++11/17/20*)

<cstdalign> (C++11/17/20*)

<ciso646> (直到 C++20)

 

这个头文件最初在 C 标准库中，名为 <math.h>.

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

内容

类型

float_t
(C++11)
 至少与 float 一样宽的最高效浮点类型
(typedef) [编辑]
double_t
(C++11)
 至少与 double 一样宽的最高效浮点类型
(typedef) [编辑]

宏

(C++11)(C++11)
 分别表示 float、double 和 long double 的溢出值
(宏常量) [编辑]
(C++11)
 计算结果为正无穷大，或者保证会使 float 溢出的值
(宏常量) [编辑]
(C++11)
 计算结果为类型为 float 的静默 NaN
(宏常量) [编辑]
(C++11)(C++11)(C++11)
 定义通用数学函数使用的错误处理机制
(宏常量) [编辑]
分类
(C++11)(C++11)(C++11)(C++11)(C++11)
 表示浮点类别
(宏常量) [编辑]

函数

基本运算
(C++11)(C++11)
 浮点值的绝对值 (|x|)
(函数) [编辑]
(C++11)(C++11)
 浮点除法运算的余数
(函数) [编辑]
(C++11)(C++11)(C++11)
 除法运算的有符号余数
(函数) [编辑]
(C++11)(C++11)(C++11)
 有符号余数以及除法运算的最后三位
(函数) [编辑]
(C++11)(C++11)(C++11)
 融合乘加运算
(函数) [编辑]
(C++11)(C++11)(C++11)
 两个浮点值中较大的一个
(函数) [编辑]
(C++11)(C++11)(C++11)
 两个浮点值中较小的一个
(函数) [编辑]
(C++11)(C++11)(C++11)
 两个浮点值的正差 (max(0, x-y))
(函数) [编辑]
(C++11)(C++11)(C++11)
 非数字 (NaN)
(函数) [编辑]
线性插值
(C++20)
 线性插值函数
(函数) [编辑]
指数函数
(C++11)(C++11)
 返回 e 的给定次幂 (ex)
(函数) [编辑]
(C++11)(C++11)(C++11)
 返回 2 的给定次幂 (2x)
(函数) [编辑]
(C++11)(C++11)(C++11)
 返回 e 的给定次幂减 1 (ex-1)
(函数) [编辑]
(C++11)(C++11)
 计算自然对数 (以 e 为底) (ln(x))
(函数) [编辑]
(C++11)(C++11)
 计算常用对数 (以 10 为底) (log10(x))
(函数) [编辑]
(C++11)(C++11)(C++11)
 给定数字的以 2 为底的对数 (log2(x))
(函数) [编辑]
(C++11)(C++11)(C++11)
 给定数字加 1 的自然对数 (以 e 为底) (ln(1+x))
(函数) [编辑]
幂函数
(C++11)(C++11)
 将一个数字提升到给定次幂 (xy)
(函数) [编辑]
(C++11)(C++11)
 计算平方根 (√x)
(函数) [编辑]
(C++11)(C++11)(C++11)
 计算立方根 (3√x)
(函数) [编辑]
(C++11)(C++11)(C++11)
 计算两个或三个(自 C++17 起)给定数字的平方和的平方根 (√x2
+y2
), (√x2
+y2
+z2
)(自 C++17 起)
(函数) [编辑]
三角函数
(C++11)(C++11)
 计算正弦 (sin(x))
(函数) [编辑]
(C++11)(C++11)
 计算余弦 (cos(x))
(函数) [编辑]
(C++11)(C++11)
 计算正切 (tan(x))
(函数) [编辑]
(C++11)(C++11)
 计算反正弦 (arcsin(x))
(函数) [编辑]
(C++11)(C++11)
 计算反余弦 (arccos(x))
(函数) [编辑]
(C++11)(C++11)
 计算反正切 (arctan(x))
(函数) [编辑]
(C++11)(C++11)
 反正切，使用符号确定象限
(函数) [编辑]
双曲函数
(C++11)(C++11)
 计算双曲正弦 (sinh(x))
(函数) [编辑]
(C++11)(C++11)
 计算双曲余弦 (cosh(x))
(函数) [编辑]
(C++11)(C++11)
 计算双曲正切 (tanh(x))
(函数) [编辑]
(C++11)(C++11)(C++11)
 计算反双曲正弦 (arsinh(x))
(函数) [编辑]
(C++11)(C++11)(C++11)
 计算反双曲余弦 (arcosh(x))
(函数) [编辑]
(C++11)(C++11)(C++11)
 计算反双曲正切 (artanh(x))
(函数) [编辑]
误差和伽马函数
(C++11)(C++11)(C++11)
 误差函数
(函数) [编辑]
(C++11)(C++11)(C++11)
 余误差函数
(函数) [编辑]
(C++11)(C++11)(C++11)
 伽马函数
(函数) [编辑]
(C++11)(C++11)(C++11)
 伽马函数的自然对数
(函数) [编辑]
最接近整数的浮点数运算
(C++11)(C++11)
 最接近且不小于给定值的整数
(函数) [编辑]
(C++11)(C++11)
 最接近且不大于给定值的整数
(函数) [编辑]
(C++11)(C++11)(C++11)
 最接近且大小不超过给定值的整数
(函数) [编辑]
(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)
 最接近的整数，在半途情况中远离零舍入
(函数) [编辑]
(C++11)(C++11)(C++11)
 使用当前舍入模式最接近的整数
(函数) [编辑]
(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)
 使用当前舍入模式最接近的整数，如果结果不同则
抛出异常
(函数) [编辑]
浮点数操作函数
(C++11)(C++11)
 将数字分解为有效数和以 2 为底的指数
(函数) [编辑]
(C++11)(C++11)
 将数字乘以 2 的整数次方
(函数) [编辑]
(C++11)(C++11)
 将数字分解为整数部分和小数部分
(函数) [编辑]
(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)
 将数字乘以 FLT_RADIX 的幂
(函数) [编辑]
(C++11)(C++11)(C++11)
 提取数字的指数
(函数) [编辑]
(C++11)(C++11)(C++11)
 提取数字的指数
(函数) [编辑]
(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)
 下一个可表示的浮点数，朝向给定值
(函数) [编辑]
(C++11)(C++11)(C++11)
 复制浮点数的符号
(函数) [编辑]
分类和比较
(C++11)
 对给定的浮点数进行分类
(函数) [编辑]
(C++11)
 检查给定的数字是否为有限值
(函数) [编辑]
(C++11)
 检查给定的数字是否为无穷大
(函数) [编辑]
(C++11)
 检查给定的数字是否为 NaN
(函数) [编辑]
(C++11)
 检查给定的数字是否为正规数
(函数) [编辑]
(C++11)
 检查给定的数字是否为负数
(函数) [编辑]
(C++11)
 检查第一个浮点参数是否大于第二个
(函数) [编辑]
(C++11)
 检查第一个浮点参数是否大于或等于第二个
(函数) [编辑]
(C++11)
 检查第一个浮点参数是否小于第二个
(函数) [编辑]
(C++11)
 检查第一个浮点参数是否小于或等于第二个
(函数) [编辑]
(C++11)
 检查第一个浮点参数是否小于或大于第二个参数
(函数) [编辑]
(C++11)
 检查两个浮点值是否无序
(函数) [编辑]
数学特殊函数
(C++17)(C++17)(C++17)
 缔合拉盖尔多项式
(函数) [编辑]
(C++17)(C++17)(C++17)
 缔合勒让德多项式
(函数) [编辑]
(C++17)(C++17)(C++17)
 贝塔函数
(函数) [编辑]
(C++17)(C++17)(C++17)
 (完全) 第一类椭圆积分
(函数) [编辑]
(C++17)(C++17)(C++17)
 (完全) 第二类椭圆积分
(函数) [编辑]
(C++17)(C++17)(C++17)
 (完全) 第三类椭圆积分
(函数) [编辑]
(C++17)(C++17)(C++17)
 正则修正的圆柱贝塞尔函数
(函数) [编辑]
(C++17)(C++17)(C++17)
 圆柱贝塞尔函数（第一类）
(函数) [编辑]
(C++17)(C++17)(C++17)
 非正则修正的圆柱贝塞尔函数
(函数) [编辑]
(C++17)(C++17)(C++17)
 圆柱诺伊曼函数
(函数) [编辑]
(C++17)(C++17)(C++17)
 (不完全) 第一类椭圆积分
(函数) [编辑]
(C++17)(C++17)(C++17)
 (不完全) 第二类椭圆积分
(函数) [编辑]
(C++17)(C++17)(C++17)
 (不完全) 第三类椭圆积分
(函数) [编辑]
(C++17)(C++17)(C++17)
 指数积分
(函数) [编辑]
(C++17)(C++17)(C++17)
 厄米特多项式
(函数) [编辑]
(C++17)(C++17)(C++17)
 勒让德多项式
(函数) [编辑]
(C++17)(C++17)(C++17)
 拉盖尔多项式
(函数) [编辑]
(C++17)(C++17)(C++17)
 黎曼ζ函数
(函数) [编辑]
(C++17)(C++17)(C++17)
 球面贝塞尔函数（第一类）
(函数) [编辑]
(C++17)(C++17)(C++17)
 球面缔合勒让德函数
(函数) [编辑]
(C++17)(C++17)(C++17)
 球面诺伊曼函数
(函数) [编辑]

[编辑] 摘要

对于每个至少有一个类型为/* 浮点类型 */的参数的函数，提供针对每个 cv 无限定浮点类型的重载，其中函数签名中的所有 /* 浮点类型 */ 用该浮点类型替换。

对于每个至少有一个类型为 /* 浮点类型 */ 的参数的函数（除了 std::abs），还提供额外的重载以确保，如果每个与 /* 浮点类型 */ 参数对应的参数都具有算术类型，那么每个此类参数将有效地转换为所有此类参数的类型中具有最大 浮点转换等级 和最大 浮点转换次等级 的浮点类型，其中整型参数被认为具有与 double 相同的浮点转换等级。如果没有这样的具有最大等级和次等级的浮点类型，那么重载解析不会从提供的重载中产生可用的候选。

namespace std {
  using float_t = /* see description */;
  using double_t = /* see description */;
}
 
#define HUGE_VAL /* see description */
#define HUGE_VALF /* see description */
#define HUGE_VALL /* see description */
#define INFINITY /* see description */
#define NAN /* see description */
#define FP_INFINITE /* see description */
#define FP_NAN /* see description */
#define FP_NORMAL /* see description */
#define FP_SUBNORMAL /* see description */
#define FP_ZERO /* see description */
#define FP_FAST_FMA /* see description */
#define FP_FAST_FMAF /* see description */
#define FP_FAST_FMAL /* see description */
#define FP_ILOGB0 /* see description */
#define FP_ILOGBNAN /* see description */
#define MATH_ERRNO /* see description */
#define MATH_ERREXCEPT /* see description */
 
#define math_errhandling /* see description */
 
namespace std {
  /* floating-point-type */ acos(/* floating-point-type */ x);
  float acosf(float x);
  long double acosl(long double x);
 
  /* floating-point-type */ asin(/* floating-point-type */ x);
  float asinf(float x);
  long double asinl(long double x);
 
  /* floating-point-type */ atan(/* floating-point-type */ x);
  float atanf(float x);
  long double atanl(long double x);
 
  /* floating-point-type */ atan2(/* floating-point-type */ y,
                                  /* floating-point-type */ x);
  float atan2f(float y, float x);
  long double atan2l(long double y, long double x);
 
  /* floating-point-type */ cos(/* floating-point-type */e x);
  float cosf(float x);
  long double cosl(long double x);
 
  /* floating-point-type */ sin(/* floating-point-type */ x);
  float sinf(float x);
  long double sinl(long double x);
 
  /* floating-point-type */ tan(/* floating-point-type */ x);
  float tanf(float x);
  long double tanl(long double x);
 
  /* floating-point-type */ acosh(/* floating-point-type */ x);
  float acoshf(float x);
  long double acoshl(long double x);
 
  /* floating-point-type */ asinh(/* floating-point-type */ x);
  float asinhf(float x);
  long double asinhl(long double x);
 
  /* floating-point-type */ atanh(/* floating-point-type */ x);
  float atanhf(float x);
  long double atanhl(long double x);
 
  /* floating-point-type */ cosh(/* floating-point-type */ x);
  float coshf(float x);
  long double coshl(long double x);
 
  /* floating-point-type */ sinh(/* floating-point-type */ x);
  float sinhf(float x);
  long double sinhl(long double x);
 
  /* floating-point-type */ tanh(/* floating-point-type */ x);
  float tanhf(float x);
  long double tanhl(long double x);
 
  /* floating-point-type */ exp(/* floating-point-type */ x);
  float expf(float x);
  long double expl(long double x);
 
  /* floating-point-type */ exp2(/* floating-point-type */ x);
  float exp2f(float x);
  long double exp2l(long double x);
 
  /* floating-point-type */ expm1(/* floating-point-type */ x);
  float expm1f(float x);
  long double expm1l(long double x);
 
  constexpr /* floating-point-type */ frexp(/* floating-point-type */ value, int* exp);
  constexpr float frexpf(float value, int* exp);
  constexpr long double frexpl(long double value, int* exp);
 
  constexpr int ilogb(/* floating-point-type */ x);
  constexpr int ilogbf(float x);
  constexpr int ilogbl(long double x);
 
  constexpr /* floating-point-type */ ldexp(/* floating-point-type */ x, int exp);
  constexpr float ldexpf(float x, int exp);
  constexpr long double ldexpl(long double x, int exp);
 
  /* floating-point-type */ log(/* floating-point-type */ x);
  float logf(float x);
  long double logl(long double x);
 
  /* floating-point-type */ log10(/* floating-point-type */ x);
  float log10f(float x);
  long double log10l(long double x);
 
  /* floating-point-type */ log1p(/* floating-point-type */ x);
  float log1pf(float x);
  long double log1pl(long double x);
 
  /* floating-point-type */ log2(/* floating-point-type */ x);
  float log2f(float x);
  long double log2l(long double x);
 
  constexpr /* floating-point-type */ logb(/* floating-point-type */ x);
  constexpr float logbf(float x);
  constexpr long double logbl(long double x);
 
  constexpr /* floating-point-type */ modf(/* floating-point-type */ value,
                                           /* floating-point-type */* iptr);
  constexpr float modff(float value, float* iptr);
  constexpr long double modfl(long double value, long double* iptr);
 
  constexpr /* floating-point-type */ scalbn(/* floating-point-type */ x, int n);
  constexpr float scalbnf(float x, int n);
  constexpr long double scalbnl(long double x, int n);
 
  constexpr /* floating-point-type */ scalbln(/* floating-point-type */ x, long int n);
  constexpr float scalblnf(float x, long int n);
  constexpr long double scalblnl(long double x, long int n);
 
  /* floating-point-type */ cbrt(/* floating-point-type */ x);
  float cbrtf(float x);
  long double cbrtl(long double x);
 
  // absolute values
  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 /* floating-point-type */
    abs(/* floating-point-type */ j);           // freestanding-deleted
 
  constexpr /* floating-point-type */ fabs(/* floating-point-type */ x);
  constexpr float fabsf(float x);
  constexpr long double fabsl(long double x);
 
  /* floating-point-type */ hypot(/* floating-point-type */ x,
                                  /* floating-point-type */ y);
  float hypotf(float x, float y);
  long double hypotl(long double x, long double y);
 
  // three-dimensional hypotenuse
  float hypot(/* floating-point-type */ x,
              /* floating-point-type */ y,
              /* floating-point-type */ z);
 
  /* floating-point-type */ pow(/* floating-point-type */ x,
                                /* floating-point-type */ y);
  float powf(float x, float y);
  long double powl(long double x, long double y);
 
  /* floating-point-type */ sqrt(/* floating-point-type */ x);
  float sqrtf(float x);
  long double sqrtl(long double x);
 
  /* floating-point-type */ erf(/* floating-point-type */ x);
  float erff(float x);
  long double erfl(long double x);
 
  /* floating-point-type */ erfc(/* floating-point-type */ x);
  float erfcf(float x);
  long double erfcl(long double x);
 
  /* floating-point-type */ lgamma(/* floating-point-type */ x);
  float lgammaf(float x);
  long double lgammal(long double x);
 
  /* floating-point-type */ tgamma(/* floating-point-type */ x);
  float tgammaf(float x);
  long double tgammal(long double x);
 
  constexpr /* floating-point-type */ ceil(/* floating-point-type */ x);
  constexpr float ceilf(float x);
  constexpr long double ceill(long double x);
 
  constexpr /* floating-point-type */ floor(/* floating-point-type */ x);
  constexpr float floorf(float x);
  constexpr long double floorl(long double x);
 
  /* floating-point-type */ nearbyint(/* floating-point-type */ x);
  float nearbyintf(float x);
  long double nearbyintl(long double x);
 
  /* floating-point-type */ rint(/* floating-point-type */ x);
  float rintf(float x);
  long double rintl(long double x);
 
  long int lrint(/* floating-point-type */ x);
  long int lrintf(float x);
  long int lrintl(long double x);
 
  long long int llrint(/* floating-point-type */ x);
  long long int llrintf(float x);
  long long int llrintl(long double x);
 
  constexpr /* floating-point-type */ round(/* floating-point-type */ x);
  constexpr float roundf(float x);
  constexpr long double roundl(long double x);
 
  constexpr long int lround(/* floating-point-type */ x);
  constexpr long int lroundf(float x);
  constexpr long int lroundl(long double x);
 
  constexpr long long int llround(/* floating-point-type */ x);
  constexpr long long int llroundf(float x);
  constexpr long long int llroundl(long double x);
 
  constexpr /* floating-point-type */ trunc(/* floating-point-type */ x);
  constexpr float truncf(float x);
  constexpr long double truncl(long double x);
 
  constexpr /* floating-point-type */ fmod(/* floating-point-type */ x,
                                           /* floating-point-type */ y);
  constexpr float fmodf(float x, float y);
  constexpr long double fmodl(long double x, long double y);
 
  constexpr /* floating-point-type */ remainder(/* floating-point-type */ x,
                                                /* floating-point-type */ y);
  constexpr float remainderf(float x, float y);
  constexpr long double remainderl(long double x, long double y);
 
  constexpr /* floating-point-type */ remquo(/* floating-point-type */ x,
                                             /* floating-point-type */ 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 /* floating-point-type */ copysign(/* floating-point-type */ x,
                                               /* floating-point-type */ 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 /* floating-point-type */ nextafter(/* floating-point-type */ x,
                                                /* floating-point-type */ y);
  constexpr float nextafterf(float x, float y);
  constexpr long double nextafterl(long double x, long double y);
 
  constexpr /* floating-point-type */ nexttoward(/* floating-point-type */ x,
                                                 long double y);
  constexpr float nexttowardf(float x, long double y);
  constexpr long double nexttowardl(long double x, long double y);
 
  constexpr /* floating-point-type */ fdim(/* floating-point-type */ x,
                                           /* floating-point-type */ y);
  constexpr float fdimf(float x, float y);
  constexpr long double fdiml(long double x, long double y);
 
  constexpr /* floating-point-type */ fmax(/* floating-point-type */ x,
                                           /* floating-point-type */ y);
  constexpr float fmaxf(float x, float y);
  constexpr long double fmaxl(long double x, long double y);
 
  constexpr /* floating-point-type */ fmin(/* floating-point-type */ x,
                                           /* floating-point-type */ y);
  constexpr float fminf(float x, float y);
  constexpr long double fminl(long double x, long double y);
 
  constexpr /* floating-point-type */ fma(/* floating-point-type */ x,
                                          /* floating-point-type */ y,
                                          /* floating-point-type */ z);
  constexpr float fmaf(float x, float y, float z);
  constexpr long double fmal(long double x, long double y, long double z);
 
  // linear interpolation
  constexpr /* floating-point-type */ lerp(/* floating-point-type */ a,
                                           /* floating-point-type */ b,
                                           /* floating-point-type */ t) noexcept;
 
  // classification / comparison functions
  constexpr int fpclassify(/* floating-point-type */ x);
 
  constexpr bool isfinite(/* floating-point-type */ x);
 
  constexpr bool isinf(/* floating-point-type */ x);
 
  constexpr bool isnan(/* floating-point-type */ x);
 
  constexpr bool isnormal(/* floating-point-type */ x);
 
  constexpr bool signbit(/* floating-point-type */ x);
 
  constexpr bool isgreater(/* floating-point-type */ x,
                           /* floating-point-type */ y);
 
  constexpr bool isgreaterequal(/* floating-point-type */ x,
                                /* floating-point-type */ y);
 
  constexpr bool isless(/* floating-point-type */ x,
                        /* floating-point-type */ y);
 
  constexpr bool islessequal(/* floating-point-type */ x,
                             /* floating-point-type */ y);
 
  constexpr bool islessgreater(/* floating-point-type */ x,
                               /* floating-point-type */ y);
 
  constexpr bool isunordered(/* floating-point-type */ x,
                             /* floating-point-type */ y);
 
  // mathematical special functions
 
  // associated Laguerre polynomials
  /* floating-point-type */ assoc_laguerre(unsigned n, unsigned m,
                                           /* floating-point-type */ x);
  float assoc_laguerref(unsigned n, unsigned m, float x);
  long double assoc_laguerrel(unsigned n, unsigned m, long double x);
 
  // associated Legendre functions
  /* floating-point-type */ assoc_legendre(unsigned l, unsigned m,
                                           /* floating-point-type */ x);
  float assoc_legendref(unsigned l, unsigned m, float x);
  long double assoc_legendrel(unsigned l, unsigned m, long double x);
 
  // beta function
  /* floating-point-type */ beta(/* floating-point-type */ x,
                                 /* floating-point-type */ y);
  float betaf(float x, float y);
  long double betal(long double x, long double y);
 
  // complete elliptic integral of the first kind
  /* floating-point-type */ comp_ellint_1(/* floating-point-type */ k);
  float comp_ellint_1f(float k);
  long double comp_ellint_1l(long double k);
 
  // complete elliptic integral of the second kind
  /* floating-point-type */ comp_ellint_2(/* floating-point-type */ k);
  float comp_ellint_2f(float k);
  long double comp_ellint_2l(long double k);
 
  // complete elliptic integral of the third kind
  /* floating-point-type */ comp_ellint_3(/* floating-point-type */ k,
                                          /* floating-point-type */ 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
  /* floating-point-type */ cyl_bessel_i(/* floating-point-type */ nu,
                                         /* floating-point-type */ 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
  /* floating-point-type */ cyl_bessel_j(/* floating-point-type */ nu,
                                         /* floating-point-type */ 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
  /* floating-point-type */ cyl_bessel_k(/* floating-point-type */ nu,
                                         /* floating-point-type */ 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
  /* floating-point-type */ cyl_neumann(/* floating-point-type */ nu,
                                        /* floating-point-type */ 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
  /* floating-point-type */ ellint_1(/* floating-point-type */ k,
                                     /* floating-point-type */ 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
  /* floating-point-type */ ellint_2(/* floating-point-type */ k,
                                     /* floating-point-type */ 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
  /* floating-point-type */ ellint_3(/* floating-point-type */ k,
                                     /* floating-point-type */ nu,
                                     /* floating-point-type */ 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
  /* floating-point-type */ expint(/* floating-point-type */ x);
  float expintf(float x);
  long double expintl(long double x);
 
  // Hermite polynomials
  /* floating-point-type */ hermite(unsigned n, /* floating-point-type */ x);
  float hermitef(unsigned n, float x);
  long double hermitel(unsigned n, long double x);
 
  // Laguerre polynomials
  /* floating-point-type */ laguerre(unsigned n, /* floating-point-type */ x);
  float laguerref(unsigned n, float x);
  long double laguerrel(unsigned n, long double x);
 
  // Legendre polynomials
  /* floating-point-type */ legendre(unsigned l, /* floating-point-type */ x);
  float legendref(unsigned l, float x);
  long double legendrel(unsigned l, long double x);
 
  // Riemann zeta function
  /* floating-point-type */ riemann_zeta(/* floating-point-type */ x);
  float riemann_zetaf(float x);
  long double riemann_zetal(long double x);
 
  // spherical Bessel functions of the first kind
  /* floating-point-type */ sph_bessel(unsigned n, /* floating-point-type */ x);
  float sph_besself(unsigned n, float x);
  long double sph_bessell(unsigned n, long double x);
 
  // spherical associated Legendre functions
  /* floating-point-type */ sph_legendre(unsigned l, unsigned m,
                                         /* floating-point-type */ 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
  /* floating-point-type */ sph_neumann(unsigned n, /* floating-point-type */ x);
  float sph_neumannf(unsigned n, float x);
  long double sph_neumannl(unsigned n, long double x);
}
检索自 "https://cppreference.cn/mwiki/index.php?title=cpp/header/cmath&oldid=166000"