标准库头文件 <cmath>

来自cppreference.com
< cpp‎ | header
 
 
 

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

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

目录

[编辑] 宏常量

分别指示 floatdoublelong double 的上溢值
(宏常量) [编辑]
(C++11)
求值为正无穷大或保证上溢 float 的值
(宏常量) [编辑]
(C++11)
求值为 float 类型的安静 NAN
(宏常量) [编辑]
定义常用数学函数所用的错误处理机制
(宏常量) [编辑]
分类
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
指示浮点类别
(宏常量) [编辑]

[编辑] 类型

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

[编辑] 函数

基本运算
浮点值的绝对值( |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++11)
(C++11)
返回 e 的给定次幂( ex
(函数) [编辑]
(C++11)
(C++11)
(C++11)
返回 2 的给定次幂( 2x
(函数) [编辑]
(C++11)
(C++11)
(C++11)
返回 e 的给定次幂减一( 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)
给定数的自然(底 e )对数加 1 ( ln(1+x)
(函数) [编辑]
幂函数

(C++11)
(C++11)
求某数的给定次幂( xy
(函数) [编辑]

(C++11)
(C++11)
计算平方根( x
(函数) [编辑]
(C++11)
(C++11)
(C++11)
计算立方根( 3x
(函数) [编辑]
(C++11)
(C++11)
(C++11)
计算二个给定数平方和的平方根( x2
+y2

(函数) [编辑]
三角函数

(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)
计算双曲正弦( sh(x)
(函数) [编辑]

(C++11)
(C++11)
计算双曲余弦( ch(x)
(函数) [编辑]

(C++11)
(C++11)
双曲正切
(函数) [编辑]
(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)
gamma 函数
(函数) [编辑]
(C++11)
(C++11)
(C++11)
gamma 函数的自然对数
(函数) [编辑]
临近整数的浮点运算

(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)
检查给定的数是否 NaN
(函数) [编辑]
(C++11)
检查给定数是否正规
(函数) [编辑]
(C++11)
检查给定数是否为负
(函数) [编辑]
(C++11)
检查第一浮点参数是否大于第二个
(函数) [编辑]
检查第一浮点参数是否大于或等于第二个
(函数) [编辑]
(C++11)
检查第一浮点参数是否小于第二个
(函数) [编辑]
检查第一浮点参数是否小于或等于第二个
(函数) [编辑]
检查第一浮点参数是否小于或大于第二个
(函数) [编辑]
检查二个浮点值是否无顺序
(函数) [编辑]
特殊数学函数
关联拉盖尔多项式
(函数) [编辑]
关联勒让德多项式
(函数) [编辑]
(C++17)
(C++17)
(C++17)
beta 函数
(函数) [编辑]
第一类完全椭圆积分
(函数) [编辑]
第二类完全椭圆积分
(函数) [编辑]
第三类完全椭圆积分
(函数) [编辑]
常规修正柱贝塞尔函数
(函数) [编辑]
第一类柱贝塞尔函数
(函数) [编辑]
非常规修正柱贝塞尔函数
(函数) [编辑]
柱诺依曼函数
(函数) [编辑]
(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)
拉盖尔多项式
(函数) [编辑]
黎曼 zeta 函数
(函数) [编辑]
第一类球贝塞尔函数
(函数) [编辑]
球关联勒让德函数
(函数) [编辑]
球诺依曼函数
(函数) [编辑]

[编辑] 概要

namespace std {
  using float_t = /*see definition*/;
  using double_t = /*see definition*/;
}
 
#define HUGE_VAL /*see definition*/
#define HUGE_VALF /*see definition*/
#define HUGE_VALL /*see definition*/
#define INFINITY /*see definition*/
#define NAN /*see definition*/
#define FP_INFINITE /*see definition*/
#define FP_NAN /*see definition*/
#define FP_NORMAL /*see definition*/
#define FP_SUBNORMAL /*see definition*/
#define FP_ZERO /*see definition*/
#define FP_FAST_FMA /*see definition*/
#define FP_FAST_FMAF /*see definition*/
#define FP_FAST_FMAL /*see definition*/
#define FP_ILOGB0 /*see definition*/
#define FP_ILOGBNAN /*see definition*/
#define MATH_ERRNO /*see definition*/
#define MATH_ERREXCEPT /*see definition*/
 
#define math_errhandling /*see definition*/
 
namespace std {
  float acos(float x);
  double acos(double x);
  long double acos(long double x);
  float acosf(float x);
  long double acosl(long double x);
 
  float asin(float x);
  double asin(double x);
  long double asin(long double x);
  float asinf(float x);
  long double asinl(long double x);
 
  float atan(float x);
  double atan(double x);
  long double atan(long double x);
  float atanf(float x);
  long double atanl(long double x);
 
  float atan2(float y, float x);
  double atan2(double y, double x);
  long double atan2(long double y, long double x);
  float atan2f(float y, float x);
  long double atan2l(long double y, long double x);
 
  float cos(float x);
  double cos(double x);
  long double cos(long double x);
  float cosf(float x);
  long double cosl(long double x);
 
  float sin(float x);
  double sin(double x);
  long double sin(long double x);
  float sinf(float x);
  long double sinl(long double x);
 
  float tan(float x);
  double tan(double x);
  long double tan(long double x);
  float tanf(float x);
  long double tanl(long double x);
 
  float acosh(float x);
  double acosh(double x);
  long double acosh(long double x);
  float acoshf(float x);
  long double acoshl(long double x);
 
  float asinh(float x);
  double asinh(double x);
  long double asinh(long double x);
  float asinhf(float x);
  long double asinhl(long double x);
 
  float atanh(float x);
  double atanh(double x);
  long double atanh(long double x);
  float atanhf(float x);
  long double atanhl(long double x);
 
  float cosh(float x);
  double cosh(double x);
  long double cosh(long double x);
  float coshf(float x);
  long double coshl(long double x);
 
  float sinh(float x);
  double sinh(double x);
  long double sinh(long double x);
  float sinhf(float x);
  long double sinhl(long double x);
 
  float tanh(float x);
  double tanh(double x);
  long double tanh(long double x);
  float tanhf(float x);
  long double tanhl(long double x);
 
  float exp(float x);
  double exp(double x);
  long double exp(long double x);
  float expf(float x);
  long double expl(long double x);
 
  float exp2(float x);
  double exp2(double x);
  long double exp2(long double x);
  float exp2f(float x);
  long double exp2l(long double x);
 
  float expm1(float x);
  double expm1(double x);
  long double expm1(long double x);
  float expm1f(float x);
  long double expm1l(long double x);
 
  float frexp(float value, int* exp);
  double frexp(double value, int* exp);
  long double frexp(long double value, int* exp);
  float frexpf(float value, int* exp);
  long double frexpl(long double value, int* exp);
 
  int ilogb(float x);
  int ilogb(double x);
  int ilogb(long double x);
  int ilogbf(float x);
  int ilogbl(long double x);
 
  float ldexp(float x, int exp);
  double ldexp(double x, int exp);
  long double ldexp(long double x, int exp);
  float ldexpf(float x, int exp);
  long double ldexpl(long double x, int exp);
 
  float log(float x);
  double log(double x);
  long double log(long double x);
  float logf(float x);
  long double logl(long double x);
 
  float log10(float x);
  double log10(double x);
  long double log10(long double x);
  float log10f(float x);
  long double log10l(long double x);
 
  float log1p(float x);
  double log1p(double x);
  long double log1p(long double x);
  float log1pf(float x);
  long double log1pl(long double x);
 
  float log2(float x);
  double log2(double x);
  long double log2(long double x);
  float log2f(float x);
  long double log2l(long double x);
 
  float logb(float x);
  double logb(double x);
  long double logb(long double x);
  float logbf(float x);
  long double logbl(long double x);
 
  float modf(float value, float* iptr);
  double modf(double value, double* iptr);
  long double modf(long double value, long double* iptr);
  float modff(float value, float* iptr);
  long double modfl(long double value, long double* iptr);
 
  float scalbn(float x, int n);
  double scalbn(double x, int n);
  long double scalbn(long double x, int n);
  float scalbnf(float x, int n);
  long double scalbnl(long double x, int n);
 
  float scalbln(float x, long int n);
  double scalbln(double x, long int n);
  long double scalbln(long double x, long int n);
  float scalblnf(float x, long int n);
  long double scalblnl(long double x, long int n);
 
  float cbrt(float x);
  double cbrt(double x);
  long double cbrt(long double x);
  float cbrtf(float x);
  long double cbrtl(long double x);
 
  // 绝对值
  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);
 
  // 分类/比较函数
  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);
}