8. 双精度数学函数

本节介绍双精度数学函数。

要使用这些函数，您无需在程序中包含任何额外的头文件。

Functions

__device__ double acos(double x)

计算输入参数的反正弦值。

__device__ double acosh(double x)

计算输入参数的非负反双曲余弦值。

__device__ double asin(double x)

计算输入参数的反正弦值。

__device__ double asinh(double x)

计算输入参数的反双曲正弦值。

__device__ double atan(double x)

计算输入参数的反正切值。

__device__ double atan2(double y, double x)

计算第一个和第二个输入参数比值的反正切值。

__device__ double atanh(double x)

计算输入参数的反双曲正切值。

__device__ double cbrt(double x)

计算输入参数的立方根。

__device__ double ceil(double x)

计算输入参数的上限值。

__device__ double copysign(double x, double y)

根据第二个值的符号创建指定大小的值。

__device__ double cos(double x)

计算输入参数的余弦值。

__device__ double cosh(double x)

计算输入参数的双曲余弦值。

__device__ double cospi(double x)

计算输入参数 \(\times \pi\) 的余弦值。

__device__ double cyl_bessel_i0(double x)

计算输入参数对应的0阶正则修正圆柱贝塞尔函数值。

__device__ double cyl_bessel_i1(double x)

计算输入参数的一阶正则修正圆柱贝塞尔函数值。

__device__ double erf(double x)

计算输入参数的误差函数。

__device__ double erfc(double x)

计算输入参数的互补误差函数。

__device__ double erfcinv(double x)

计算输入参数的反补误差函数。

__device__ double erfcx(double x)

计算输入参数的缩放互补误差函数。

__device__ double erfinv(double x)

计算输入参数的反误差函数。

__device__ double exp(double x)

计算输入参数的以\(e\)为底的指数。

__device__ double exp10(double x)

计算输入参数的以10为底的指数。

__device__ double exp2(double x)

计算输入参数的以2为底的指数。

__device__ double expm1(double x)

计算输入参数以\(e\)为底的指数，再减去1。

__device__ double fabs(double x)

计算输入参数的绝对值。

__device__ double fdim(double x, double y)

计算 x 和 y 之间的正差值。

__device__ double floor(double x)

计算小于或等于 x 的最大整数。

__device__ double fma(double x, double y, double z)

将\(x \times y + z\)作为单一运算进行计算。

__device__ double fmax(double, double)

确定参数中的最大数值。

__device__ double fmin(double x, double y)

确定参数中的最小数值。

__device__ double fmod(double x, double y)

计算 x / y 的双精度浮点余数。

__device__ double frexp(double x, int *nptr)

提取浮点数值的尾数和指数部分。

__device__ double hypot(double x, double y)

计算两个参数平方和的平方根。

__device__ int ilogb(double x)

计算参数的无偏整数指数。

__device__ __RETURN_TYPE isfinite(double a)

判断参数是否为有限值。

__device__ __RETURN_TYPE isinf(double a)

判断参数是否为无限值。

__device__ __RETURN_TYPE isnan(double a)

判断参数是否为NaN。

__device__ double j0(double x)

计算输入参数的第一类零阶贝塞尔函数值。

__device__ double j1(double x)

计算输入参数的一阶第一类贝塞尔函数值。

__device__ double jn(int n, double x)

计算输入参数的第一类n阶贝塞尔函数值。

__device__ double ldexp(double x, int exp)

计算 \(x\cdot 2^{exp}\) 的值。

__device__ double lgamma(double x)

计算输入参数伽玛函数绝对值的自然对数。

__device__ long long int llrint(double x)

将输入四舍五入到最接近的整数值。

__device__ long long int llround(double x)

四舍五入到最接近的整数值。

__device__ double log(double x)

计算输入参数以\(e\)为底的对数。

__device__ double log10(double x)

计算输入参数的以10为底的对数。

__device__ double log1p(double x)

计算 \(\log_{e}(1+x)\) 的值。

__device__ double log2(double x)

计算输入参数的以2为底的对数。

__device__ double logb(double x)

计算输入参数的指数部分的浮点数表示。

__device__ long int lrint(double x)

将输入四舍五入到最接近的整数值。

__device__ long int lround(double x)

四舍五入到最接近的整数值。

__device__ double max(const float a, const double b)

计算输入float和double参数的最大值。

__device__ double max(const double a, const float b)

计算输入double和float参数的最大值。

__device__ double max(const double a, const double b)

计算输入float参数的最大值。

__device__ double min(const float a, const double b)

计算输入float和double参数的最小值。

__device__ double min(const double a, const double b)

计算输入float参数的最小值。

__device__ double min(const double a, const float b)

计算输入的double和float参数的最小值。

__device__ double modf(double x, double *iptr)

将输入参数分解为小数部分和整数部分。

__device__ double nan(const char *tagp)

返回"非数字"值。

__device__ double nearbyint(double x)

将输入参数四舍五入到最接近的整数。

__device__ double nextafter(double x, double y)

返回参数 x 在 y 方向上的下一个可表示的双精度浮点数值。

__device__ double norm(int dim, double const *p)

计算任意数量坐标的平方和的平方根。

__device__ double norm3d(double a, double b, double c)

计算参数三个坐标平方和的平方根。

__device__ double norm4d(double a, double b, double c, double d)

计算参数四个坐标平方和的平方根。

__device__ double normcdf(double x)

计算标准正态累积分布函数。

__device__ double normcdfinv(double x)

计算标准正态累积分布函数的逆函数。

__device__ double pow(double x, double y)

计算第一个参数的第二个参数次幂的值。

__device__ double rcbrt(double x)

计算倒数立方根函数。

__device__ double remainder(double x, double y)

计算双精度浮点余数。

__device__ double remquo(double x, double y, int *quo)

计算双精度浮点余数和部分商。

__device__ double rhypot(double x, double y)

计算两个参数平方和的平方根的倒数。

__device__ double rint(double x)

将浮点数四舍五入到最接近的整数值。

__device__ double rnorm(int dim, double const *p)

计算任意数量坐标平方和的平方根的倒数。

__device__ double rnorm3d(double a, double b, double c)

计算三个坐标平方和的平方根的倒数。

__device__ double rnorm4d(double a, double b, double c, double d)

计算四个坐标平方和的平方根的倒数。

__device__ double round(double x)

将浮点数四舍五入到最接近的整数值。

__device__ double rsqrt(double x)

计算输入参数的平方根的倒数。

__device__ double scalbln(double x, long int n)

将浮点输入按2的整数次幂进行缩放。

__device__ double scalbn(double x, int n)

将浮点输入按2的整数次幂进行缩放。

__device__ __RETURN_TYPE signbit(double a)

返回输入的符号位。

__device__ double sin(double x)

计算输入参数的正弦值。

__device__ void sincos(double x, double *sptr, double *cptr)

计算第一个输入参数的正弦和余弦值。

__device__ void sincospi(double x, double *sptr, double *cptr)

计算第一个输入参数的正弦和余弦值 \(\times \pi\) 。

__device__ double sinh(double x)

计算输入参数的双曲正弦值。

__device__ double sinpi(double x)

计算输入参数的正弦值 \(\times \pi\) 。

__device__ double sqrt(double x)

计算输入参数的平方根。

__device__ double tan(double x)

计算输入参数的正切值。

__device__ double tanh(double x)

计算输入参数的双曲正切值。

__device__ double tgamma(double x)

计算输入参数的伽玛函数。

__device__ double trunc(double x)

将输入参数截断为整数部分。

__device__ double y0(double x)

计算输入参数对应的第二类零阶贝塞尔函数值。

__device__ double y1(double x)

计算输入参数的第二类一阶贝塞尔函数值。

__device__ double yn(int n, double x)

计算输入参数对应的第二类n阶贝塞尔函数值。

8.1. 函数

__device__ double acos(double x)

计算输入参数的反正弦值。

计算输入参数 x 的反余弦主值。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

结果将以弧度表示，当x在[-1, +1]区间内时，结果范围在[0, \( \pi \) ]之间。

• acos(1) 返回 +0。

• 当x超出[-1, +1]范围时，acos(x)返回NaN。

• acos(NaN) 返回 NaN。

__device__ double acosh(double x)

计算输入参数的非负反双曲余弦值。

计算输入参数 x 的非负反双曲余弦值。

注意

有关精度信息，请参阅《CUDA C++编程指南》数学函数附录中的双精度浮点函数章节。

Returns

结果将在区间 [0, \( +\infty \) ] 内。

• acosh(1) 返回 0。

• 对于区间 [ \( -\infty \) , 1) 内的 x，acosh(x) 返回 NaN。

• acosh( \( +\infty \) ) 返回 \( +\infty \)。

• acosh(NaN) 返回 NaN。

__device__ double asin(double x)

计算输入参数的反正弦值。

计算输入参数 x 的反正弦主值。

注意

有关精度信息，请参阅CUDA C++编程指南中的数学函数附录双精度浮点函数部分。

Returns

结果将以弧度表示，当x在[-1, +1]区间内时，结果范围在[-\( \pi \)/2, +\( \pi \)/2]之间。

• asin( \( \pm 0 \) ) 返回 \( \pm 0 \)。

• 当x超出[-1, +1]范围时，asin(x)返回NaN。

• asin(NaN) 返回 NaN。

__device__ double asinh(double x)

计算输入参数的反双曲正弦值。

计算输入参数 x 的反双曲正弦值。

注意

有关精度信息，请参阅CUDA C++编程指南中的数学函数附录双精度浮点函数部分。

Returns

• asinh( \( \pm 0 \) ) 返回 \( \pm 0 \)。

• asinh( \( \pm \infty \) ) 返回 \( \pm \infty \)。

• asinh(NaN) 返回 NaN。

__device__ double atan(double x)

计算输入参数的反正切值。

计算输入参数 x 的反正切主值。

注意

有关精度信息，请参阅《CUDA C++编程指南》数学函数附录中的双精度浮点函数章节。

Returns

结果将以弧度表示，范围在[-\( \pi \)/2, +\( \pi \)/2]区间内。

• atan( \( \pm 0 \) ) 返回 \( \pm 0 \)。

• atan( \( \pm \infty \) ) 返回 \( \pm \pi \) /2。

• atan(NaN) 返回 NaN。

__device__ double atan2(double y, double x)

计算第一个和第二个输入参数比值的反正切值。

计算第一个输入参数y与第二个输入参数x比值的反正切主值。结果的象限由输入参数y和x的符号决定。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

结果将以弧度表示，范围在[- \( \pi \) , + \( \pi \) ]区间内。

• atan2( \( \pm 0 \) , -0) 返回 \( \pm \pi \)。

• atan2( \( \pm 0 \) , +0) 返回 \( \pm 0 \)。

• atan2( \( \pm 0 \) , x) 当 x < 0 时返回 \( \pm \pi \)。

• atan2( \( \pm 0 \) , x) 当 x > 0 时返回 \( \pm 0 \)。

• atan2(y, \( \pm 0 \) ) 当 y < 0 时返回 \( -\pi \) /2。

• atan2(y, \( \pm 0 \) ) 当 y > 0 时返回 \( \pi \) /2。

• atan2( \( \pm y \) , \( -\infty \) ) 对于有限值 y > 0 返回 \( \pm \pi \)。

• atan2( \( \pm y \) , \( +\infty \) ) 对于有限值 y > 0 返回 \( \pm 0 \)。

• atan2( \( \pm \infty \) , x) 对于有限值 x 返回 \( \pm \pi \) /2。

• atan2( \( \pm \infty \) , \( -\infty \) ) 返回 \( \pm 3\pi \) /4。

• atan2( \( \pm \infty \) , \( +\infty \) ) 返回 \( \pm \pi \) /4。

• 如果任一参数为NaN，则返回NaN。

__device__ double atanh(double x)

计算输入参数的反双曲正切值。

计算输入参数 x 的反双曲正切值。

注意

有关精度信息，请参阅《CUDA C++编程指南》数学函数附录中的双精度浮点函数章节。

Returns

• atanh( \( \pm 0 \) ) 返回 \( \pm 0 \)。

• atanh( \( \pm 1 \) ) 返回 \( \pm \infty \)。

• 当 x 超出区间 [-1, 1] 时，atanh(x) 返回 NaN。

• atanh(NaN) 返回 NaN。

__device__ double cbrt(double x)

计算输入参数的立方根。

计算 x 的立方根，\( x^{1/3} \)。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

返回 \( x^{1/3} \)。

• cbrt( \( \pm 0 \) ) 返回 \( \pm 0 \)。

• cbrt( \( \pm \infty \) ) 返回 \( \pm \infty \)。

• cbrt(NaN) 返回 NaN。

__device__ double ceil(double x)

计算输入参数的向上取整值。

计算不小于x的最小整数值。

Returns

返回以浮点数表示的\( \lceil x \rceil \)（向上取整值）。

• ceil( \( \pm 0 \) ) 返回 \( \pm 0 \)。

• ceil( \( \pm \infty \) ) 返回 \( \pm \infty \)。

• ceil(NaN) 返回 NaN。

__device__ double copysign(double x, double y)

根据第二个值的符号创建指定大小的值。

创建一个浮点数值，其大小为x，符号与y相同。

Returns

• 一个数值，其大小为x，符号与y相同。

• copysign(NaN, y) 返回一个带有y符号的NaN。

__device__ double cos(double x)

计算输入参数的余弦值。

计算输入参数 x 的余弦值（以弧度为单位）。

注意

有关精度信息，请参阅CUDA C++编程指南中的数学函数附录双精度浮点函数部分。

Returns

• cos( \( \pm 0 \) ) 返回 1。

• cos( \( \pm \infty \) ) 返回 NaN。

• cos(NaN) 返回 NaN。

__device__ double cosh(double x)

计算输入参数的双曲余弦值。

计算输入参数 x 的双曲余弦值。

注意

有关精度信息，请参阅CUDA C++编程指南中的数学函数附录双精度浮点函数部分。

Returns

• cosh( \( \pm 0 \) ) 返回 1。

• cosh( \( \pm \infty \) ) 返回 \( +\infty \)。

• cosh(NaN) 返回 NaN。

__device__ double cospi(double x)

计算输入参数 \( \times \pi \) 的余弦值。

计算x \( \times \pi \)的余弦值（以弧度为单位），其中x是输入参数。

注意

有关精度信息，请参阅CUDA C++编程指南中的数学函数附录双精度浮点函数部分。

Returns

• cospi( \( \pm 0 \) ) 返回 1。

• cospi( \( \pm \infty \) ) 返回 NaN。

• cospi(NaN) 返回 NaN。

__device__ double cyl_bessel_i0(double x)

计算输入参数对应的0阶正则修正圆柱贝塞尔函数值。

计算输入参数x的0阶修正贝塞尔函数值\( I_0(x) \)。

注意

有关精度信息，请参阅CUDA C++编程指南中的数学函数附录双精度浮点函数部分。

Returns

返回0阶正则修正圆柱贝塞尔函数的值。

• cyl_bessel_i0( \( \pm 0 \)) 返回 +1。

• cyl_bessel_i0( \( \pm\infty \)) 返回 \( +\infty \).

• cyl_bessel_i0(NaN) 返回 NaN。

__device__ double cyl_bessel_i1(double x)

计算输入参数的一阶正则修正圆柱贝塞尔函数值。

计算输入参数x的一阶正则修正圆柱贝塞尔函数值\( I_1(x) \)。

注意

有关精度信息，请参阅CUDA C++编程指南中的数学函数附录双精度浮点函数部分。

Returns

返回一阶正则修正圆柱贝塞尔函数的值。

• cyl_bessel_i1( \( \pm 0 \)) 返回 \( \pm 0 \).

• cyl_bessel_i1( \( \pm\infty \)) 返回 \( \pm\infty \).

• cyl_bessel_i1(NaN) 返回 NaN。

__device__ double erf(double x)

计算输入参数的误差函数。

计算输入参数 x 的误差函数值，\( \frac{2}{\sqrt \pi} \int_0^x e^{-t^2} dt \)。

注意

有关精度信息，请参阅CUDA C++编程指南中的数学函数附录双精度浮点函数部分。

Returns

• erf( \( \pm 0 \) ) 返回 \( \pm 0 \)。

• erf( \( \pm \infty \) ) 返回 \( \pm 1 \)。

• erf(NaN) 返回 NaN。

__device__ double erfc(double x)

计算输入参数的互补误差函数。

计算输入参数x的互补误差函数，即1 - erf(x)。

注意

有关精度信息，请参阅CUDA C++编程指南中的数学函数附录双精度浮点函数部分。

Returns

• erfc( \( -\infty \) ) 返回 2。

• erfc( \( +\infty \) ) 返回 +0。

• erfc(NaN) 返回 NaN。

__device__ double erfcinv(double x)

计算输入参数的反补误差函数。

计算输入参数 x 在区间 [0, 2] 内的逆互补误差函数 \( \operatorname{erfc}^{-1} \) (x)。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• erfcinv( \( \pm 0 \) ) 返回 \( +\infty \)。

• erfcinv(2) 返回 \( -\infty \)。

• 当x超出[0, 2]范围时，erfcinv(x)会返回NaN。

• erfcinv(NaN) 返回 NaN。

__device__ double erfcx(double x)

计算输入参数的缩放互补误差函数。

计算输入参数x的缩放互补误差函数，\( e^{x^2}\cdot \operatorname{erfc}(x) \)。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• erfcx( \( -\infty \) ) 返回 \( +\infty \)。

• erfcx( \( +\infty \) ) 返回 +0。

• erfcx(NaN) 返回 NaN。

__device__ double erfinv(double x)

计算输入参数的反误差函数。

计算输入参数 x 在区间 [-1, 1] 内的反误差函数 \( \operatorname{erf}^{-1} \) (x)。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• erfinv( \( \pm 0 \) ) 返回 \( \pm 0 \)。

• erfinv(1) 返回 \( +\infty \)。

• erfinv(-1) 返回 \( -\infty \)。

• erfinv(x) 当 x 超出 [-1, +1] 范围时返回 NaN。

• erfinv(NaN) 返回 NaN。

__device__ double exp(double x)

计算输入参数以\( e \)为底的指数。

计算 \( e^x \)，即输入参数 x 的以自然常数 \( e \) 为底的指数函数值。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• exp( \( \pm 0 \) ) 返回 1。

• exp( \( -\infty \) ) 返回 +0。

• exp( \( +\infty \) ) 返回 \( +\infty \).

• exp(NaN) 返回 NaN。

__device__ double exp10(double x)

计算输入参数的以10为底的指数。

计算 \( 10^x \)，即输入参数 x 的以10为底的指数函数。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• exp10( \( \pm 0 \) ) 返回 1。

• exp10( \( -\infty \) ) 返回 +0。

• exp10( \( +\infty \) ) 返回 \( +\infty \)。

• exp10(NaN) 返回 NaN。

__device__ double exp2(double x)

计算输入参数的以2为底的指数。

计算 \( 2^x \)，即输入参数 x 的以2为底的指数。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• exp2( \( \pm 0 \) ) 返回 1。

• exp2( \( -\infty \) ) 返回 +0。

• exp2( \( +\infty \) ) 返回 \( +\infty \)。

• exp2(NaN) 返回 NaN。

__device__ double expm1(double x)

计算输入参数以\( e \)为底的指数，再减去1。

计算输入参数 x 以自然常数 \( e \) 为底的指数值减1，即 \( e^x \) -1。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• expm1( \( \pm 0 \) ) 返回 \( \pm 0 \)。

• expm1( \( -\infty \) ) 返回 -1。

• expm1( \( +\infty \) ) 返回 \( +\infty \)。

• expm1(NaN) 返回 NaN。

__device__ double fabs(double x)

计算输入参数的绝对值。

计算输入参数 x 的绝对值。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

返回输入参数的绝对值。

• fabs( \( \pm \infty \) ) 返回 \( +\infty \)。

• fabs( \( \pm 0 \) ) 返回 +0。

• fabs(NaN) 返回一个未指定的NaN值。

__device__ double fdim(double x, double y)

计算 x 和 y 之间的正差值。

计算x和y之间的正差值。当x大于y时，正差值为x减去y，否则为+0。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

返回x和y之间的正差值。

• fdim(x, y) 当 x 大于 y 时返回 x - y。

• fdim(x, y) 当 x \( \leq \) y 时返回 +0。

• 如果任一参数为NaN，则返回NaN。

__device__ double floor(double x)

计算小于或等于x的最大整数。

计算小于或等于x的最大整数值。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

返回以浮点数表示的\( \lfloor x \rfloor \)。

• floor( \( \pm \infty \) ) 返回 \( \pm \infty \)。

• floor( \( \pm 0 \) ) 返回 \( \pm 0 \)。

• floor(NaN) 返回 NaN。

__device__ double fma(double x, double y, double z)

将 \( x \times y + z \) 作为单一运算进行计算。

将\( x \times y + z \)作为三元运算计算其值。在无限精度计算后，使用"就近舍入-偶数优先"舍入模式对结果进行一次舍入。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

返回\( x \times y + z \)作为单次运算的舍入值。

• fma( \( \pm \infty \) , \( \pm 0 \) , z) 返回 NaN。

• fma( \( \pm 0 \) , \( \pm \infty \) , z) 返回NaN。

• fma(x, y, \( -\infty \) ) 如果 \( x \times y \) 是精确的 \( +\infty \) 则返回 NaN。

• fma(x, y, \( +\infty \) ) 当\( x \times y \)是精确的\( -\infty \)时返回NaN。

• fma(x, y, \( \pm 0 \)) 当 \( x \times y \) 精确等于 \( \pm 0 \) 时返回 \( \pm 0 \)。

• fma(x, y, \( \mp 0 \)) 当 \( x \times y \) 精确等于 \( \pm 0 \) 时返回 \( +0 \)。

• fma(x, y, z) 当\( x \times y + z \)精确等于零且\( z \neq 0 \)时返回\( +0 \)。

• 如果任一参数为NaN，则返回NaN。

__device__ double fmax(double, double)

确定参数的最大数值。

确定参数x和y中的最大数值。将NaN参数视为缺失数据。如果一个参数是NaN而另一个是有效的数值，则选择该数值。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

返回参数x和y中的最大数值。

• 如果两个参数都是NaN，则返回NaN。

• 如果其中一个参数是NaN，则返回数值参数。

__device__ double fmin(double x, double y)

确定参数的最小数值。

确定参数x和y中的最小数值。将NaN参数视为缺失数据。如果一个参数是NaN而另一个是合法的数值，则选择该数值。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

返回参数x和y中的最小数值。

• 如果两个参数都是NaN，则返回NaN。

• 如果其中一个参数是NaN，则返回数值参数。

__device__ double fmod(double x, double y)

计算x / y的双精度浮点余数。

计算x除以y的双精度浮点余数。该函数计算的除法运算x/y的浮点余数精确等于x - n*y的值，其中n是x/y截断小数部分后的整数。计算结果将与x具有相同的符号，且其绝对值将小于y的绝对值。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• 返回 x / y 的浮点余数。

• fmod( \( \pm 0 \) , y) 当 y 不为零时返回 \( \pm 0 \)。

• fmod(x, \( \pm \infty \) ) 当 x 为有限值时返回 x。

• 如果x是\( \pm\infty \)或y为零，fmod(x, y)将返回NaN。

• 如果任一参数为NaN，则返回NaN。

__device__ double frexp(double x, int *nptr)

提取浮点数值的尾数和指数。

将浮点值x分解为归一化小数部分m和指数部分n。m的绝对值将大于等于0.5且小于1.0，或者等于0；\( x = m\cdot 2^n \)。整数指数n将被存储在nptr指针所指向的位置。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

返回小数部分 m。

• frexp( \( \pm 0 \) , nptr) 返回 \( \pm 0 \) 并在 nptr 指向的位置存储零值。

• frexp( \( \pm \infty \) , nptr) 返回 \( \pm \infty \) 并在nptr指向的位置存储一个未指定的值。

• frexp(NaN, y) 返回一个NaN值，并在nptr指针指向的位置存储一个未指定的值。

__device__ double hypot(double x, double y)

计算两个参数平方和的平方根。

计算一个直角三角形的斜边长度，该三角形的两条直角边长度分别为 x 和 y，且不会出现过度溢出或下溢。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

返回斜边的长度 \( \sqrt{x^2+y^2} \)。

• hypot(x,y)、hypot(y,x)和hypot(x, -y)是等价的。

• hypot(x, \( \pm 0 \) ) 等价于 fabs(x)。

• hypot( \( \pm \infty \) ,y) 返回 \( +\infty \) ，即使 y 是一个NaN。

• 当 y 不是 \( \pm\infty \) 时，hypot(NaN, y) 返回 NaN。

__device__ int ilogb(double x)

计算参数的无偏整数指数。

计算输入参数 x 的无偏整数指数。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• 如果成功，返回参数的无偏指数。

• ilogb( \( \pm 0 \) ) 返回 INT_MIN。

• ilogb(NaN) 返回 INT_MIN。

• ilogb( \( \pm \infty \) ) 返回 INT_MAX。

• 注意：上述行为未考虑FP_ILOGB0和FP_ILOGBNAN。

__device__ __RETURN_TYPE isfinite(double a)

判断参数是否为有限值。

判断浮点数值a是否为有限值（零、次正规数、正规数且非无穷大或非数字）。

Returns

• 使用Visual Studio 2013主机编译器时：__RETURN_TYPE为'bool'。当且仅当a为有限值时返回true。

• 使用其他主机编译器时：__RETURN_TYPE 为 'int'。当且仅当 a 为有限值时返回非零值。

__device__ __RETURN_TYPE isinf(double a)

判断参数是否为无限值。

判断浮点数值a是否为无限值（正或负）。

Returns

• 使用Visual Studio 2013主机编译器：当且仅当a为无限值时返回true。

• 使用其他主机编译器时：当且仅当a为无限值时返回非零值。

__device__ __RETURN_TYPE isnan(double a)

判断参数是否为NaN。

判断浮点数值 a 是否为 NaN。

Returns

• 使用Visual Studio 2013主机编译器时：__RETURN_TYPE为'bool'。当且仅当a是NaN值时返回true。

• 使用其他主机编译器时：__RETURN_TYPE 为 'int'。当且仅当 a 是 NaN 值时返回非零值。

__device__ double j0(double x)

计算输入参数的第一类零阶贝塞尔函数值。

计算输入参数x的第一类零阶贝塞尔函数值\( J_0(x) \)。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

返回第一类零阶贝塞尔函数的值。

• j0( \( \pm \infty \) ) 返回 +0。

• j0(NaN) 返回 NaN。

__device__ double j1(double x)

计算输入参数的一阶第一类贝塞尔函数值。

计算输入参数x的一阶第一类贝塞尔函数值\( J_1(x) \)。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

返回第一类1阶贝塞尔函数的值。

• j1( \( \pm 0 \) ) 返回 \( \pm 0 \)。

• j1( \( \pm \infty \) ) 返回 \( \pm 0 \).

• j1(NaN) 返回 NaN。

__device__ double jn(int n, double x)

计算输入参数的第一类n阶贝塞尔函数值。

计算第一类贝塞尔函数在阶数n下对输入参数x的值，\( J_n(x) \)。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

返回第一类贝塞尔函数在阶数为n时的值。

• jn(n, NaN) 返回 NaN。

• 当 n < 0 时，jn(n, x) 返回 NaN。

• jn(n, \( +\infty \) ) 返回 +0。

__device__ double ldexp(double x, int exp)

计算 \( x\cdot 2^{exp} \) 的值。

计算输入参数 x 和 exp 的 \( x\cdot 2^{exp} \) 值。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• ldexp(x, exp) 等价于 scalbn(x, exp)。

__device__ double lgamma(double x)

计算输入参数伽玛函数绝对值的自然对数。

计算输入参数x的伽马函数绝对值的自然对数，即\( \log_{e}\left|\Gamma(x)\right| \)的值

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• lgamma(1) 返回 +0。

• lgamma(2) 返回 +0。

• lgamma(x) 当 x \( \leq \) 0 且 x 为整数时返回 \( +\infty \)。

• lgamma( \( -\infty \) ) 返回 \( +\infty \)。

• lgamma( \( +\infty \) ) 返回 \( +\infty \)。

• lgamma(NaN) 返回 NaN。

__device__ long long int llrint(double x)

将输入四舍五入到最接近的整数值。

将 x 四舍五入到最接近的整数值，中间值情况会舍入到最接近的偶数整数值。如果结果超出返回类型的范围，则行为未定义。

Returns

返回四舍五入后的整数值。

__device__ long long int llround(double x)

四舍五入到最接近的整数值。

将 x 四舍五入到最接近的整数值，中间值（0.5）向远离零的方向舍入。如果结果超出返回类型的范围，则行为未定义。

注意

此函数可能比其他舍入方法更慢。参见llrint()。

Returns

返回四舍五入后的整数值。

__device__ double log(double x)

计算输入参数以\( e \)为底的对数。

计算输入参数 x 以 \( e \) 为底的对数。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• log( \( \pm 0 \) ) 返回 \( -\infty \).

• log(1) 返回 +0。

• 当 x 小于 0 时，log(x) 返回 NaN。

• log( \( +\infty \) ) 返回 \( +\infty \)。

• log(NaN) 返回 NaN。

__device__ double log10(double x)

计算输入参数的以10为底的对数。

计算输入参数 x 的以10为底的对数。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• log10( \( \pm 0 \) ) 返回 \( -\infty \)。

• log10(1) 返回 +0。

• 当 x 小于 0 时，log10(x) 返回 NaN。

• log10( \( +\infty \) ) 返回 \( +\infty \)。

• log10(NaN) 返回 NaN。

__device__ double log1p(double x)

计算 \( \log_{e}(1+x) \) 的值。

计算输入参数 x 的 \( \log_{e}(1+x) \) 值。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• log1p( \( \pm 0 \) ) 返回 \( \pm 0 \)。

• log1p(-1) 返回 \( -\infty \)。

• 当x小于-1时，log1p函数返回NaN值。

• log1p( \( +\infty \) ) 返回 \( +\infty \)。

• log1p(NaN) 返回 NaN。

__device__ double log2(double x)

计算输入参数的以2为底的对数。

计算输入参数 x 的以2为底的对数。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• log2( \( \pm 0 \) ) 返回 \( -\infty \)。

• log2(1) 返回 +0。

• 当 x 小于 0 时，log2(x) 返回 NaN。

• log2( \( +\infty \) ) 返回 \( +\infty \)。

• log2(NaN) 返回 NaN。

__device__ double logb(double x)

计算输入参数的指数部分的浮点数表示。

计算输入参数 x 的指数部分的浮点数表示。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• logb( \( \pm 0 \) ) 返回 \( -\infty \)。

• logb( \( \pm \infty \) ) 返回 \( +\infty \).

• logb(NaN) 返回 NaN。

__device__ long int lrint(double x)

将输入四舍五入到最接近的整数值。

将 x 四舍五入到最接近的整数值，中间值情况会舍入到最接近的偶数整数值。如果结果超出返回类型的范围，则行为未定义。

Returns

返回四舍五入后的整数值。

__device__ long int lround(double x)

四舍五入到最接近的整数值。

将 x 四舍五入到最接近的整数值，中间值（0.5）向远离零的方向舍入。如果结果超出返回类型的范围，则行为未定义。

注意

此函数可能比其他舍入方法更慢。参见lrint()。

Returns

返回四舍五入后的整数值。

__device__ double max(const float a, const double b)

计算输入float和double参数的最大值。

将float类型参数a转换为double类型，然后执行fmax()。

注意，这与std:规范不同

__device__ double max(const double a, const float b)

计算输入double和float参数的最大值。

将float类型参数b转换为double类型，然后调用fmax()函数。

注意，这与std:规范不同

__device__ double max(const double a, const double b)

计算输入float参数的最大值。

计算参数a和b的最大值。功能等同于fmax()函数。

注意，这与std:规范不同

__device__ double min(const float a, const double b)

计算输入float和double参数的最小值。

将float参数a转换为double，然后执行fmin()。

注意，这与std:规范不同

__device__ double min(const double a, const double b)

计算输入float参数的最小值。

计算参数a和b的最小值。该行为等同于fmin()函数。

注意，这与std:规范不同

__device__ double min(const double a, const float b)

计算输入double和float参数的最小值。

将float参数b转换为double，然后调用fmin()。

注意，这与std:规范不同

__device__ double modf(double x, double *iptr)

将输入参数分解为小数部分和整数部分。

将参数 x 分解为小数部分和整数部分。整数部分存储在参数 iptr 中。小数部分和整数部分的符号与参数 x 相同。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• modf( \( \pm x \) , iptr) 返回一个与 x 符号相同的结果。

• modf( \( \pm \infty \) , iptr) 返回 \( \pm 0 \) 并将 \( \pm \infty \) 存储到 iptr 所指向的对象中。

• modf(NaN, iptr) 在iptr指向的对象中存储一个NaN并返回一个NaN。

__device__ double nan(const char *tagp)

返回“非数字”值。

返回一个静默NaN的表示形式。参数tagp用于选择可能的表示形式之一。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• nan(tagp) 返回NaN。

__device__ double nearbyint(double x)

将输入参数四舍五入到最接近的整数。

将参数 x 四舍五入为双精度浮点格式的整数值。使用就近舍入法，当处于中间值时向偶数舍入。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• nearbyint( \( \pm 0 \) ) 返回 \( \pm 0 \)。

• nearbyint( \( \pm \infty \) ) 返回 \( \pm \infty \)。

• nearbyint(NaN) 返回 NaN。

__device__ double nextafter(double x, double y)

返回参数 x 之后在 y 方向上的下一个可表示的双精度浮点数值。

计算在y方向上紧随x的下一个可表示的双精度浮点值。例如，如果y大于x，nextafter()将返回大于x的最小可表示数值。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• nextafter(x, y) = y 当 x 等于 y 时。

• 如果x或y是NaN，则nextafter(x, y) = NaN。

__device__ double norm(int dim, double const *p)

计算任意数量坐标的平方和的平方根。

计算向量p的长度，其维度作为参数传递，不会出现不必要的上溢或下溢。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

返回dim维向量的长度\( \sqrt{\sum_{i=0}^{dim-1} p_i^2} \)。

• 当存在一个精确的无限坐标时，即使存在NaN值，也会返回\( +\infty \)。

• 当所有坐标均为 \( \pm 0 \) 时，返回 +0。

• 当至少一个坐标是NaN且没有无限值时，返回NaN。

__device__ double norm3d(double a, double b, double c)

计算参数三个坐标平方和的平方根。

计算欧几里得空间中三维向量的长度，避免不必要的溢出或下溢。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

返回3D向量的长度 \( \sqrt{a^2+b^2+c^2} \)。

• 当存在一个精确的无限坐标时，即使存在NaN值，也会返回\( +\infty \)。

• 当所有坐标均为 \( \pm 0 \) 时，返回 +0。

• 当至少一个坐标是NaN且没有无限值时，返回NaN。

__device__ double norm4d(double a, double b, double c, double d)

计算参数四个坐标的平方和的平方根。

计算四维向量在欧几里得空间中的长度，避免不必要的溢出或下溢。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

返回4D向量的长度 \( \sqrt{a^2+b^2+c^2+d^2} \)。

• 当存在一个精确的无限坐标时，即使存在NaN值，也会返回\( +\infty \)。

• 当所有坐标均为 \( \pm 0 \) 时，返回 +0。

• 当至少一个坐标是NaN且没有无限值时，返回NaN。

__device__ double normcdf(double x)

计算标准正态累积分布函数。

计算标准正态分布的累积分布函数，输入参数为x，\( \Phi(x) \)。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• normcdf( \( +\infty \) ) 返回 1。

• normcdf( \( -\infty \) ) 返回 +0。

• normcdf(NaN) 返回 NaN。

__device__ double normcdfinv(double x)

计算标准正态累积分布函数的逆函数。

计算输入参数x的标准正态累积分布函数的反函数，即\( \Phi^{-1}(x) \)。该函数定义在区间\( (0, 1) \)内的输入值。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• normcdfinv( \( \pm 0 \) ) 返回 \( -\infty \).

• normcdfinv(1) 返回 \( +\infty \)。

• 如果x不在区间[0,1]内，normcdfinv(x)将返回NaN。

• normcdfinv(NaN) 返回 NaN。

__device__ double pow(double x, double y)

计算第一个参数的值为第二个参数的幂次方。

计算 x 的 y 次幂。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• pow( \( \pm 0 \) , y) 当 y 为小于0的奇数时返回 \( \pm \infty \)。

• pow( \( \pm 0 \) , y) 当 y 小于0且不是奇数时返回 \( +\infty \)。

• pow( \( \pm 0 \) , y) 当 y 为大于0的奇数时返回 \( \pm 0 \)。

• pow( \( \pm 0 \) , y) 当 y > 0 且不是奇数时返回 +0。

• pow(-1, \( \pm \infty \) ) 返回 1。

• 对于任何 y（包括 NaN），pow(+1, y) 都返回 1。

• pow(x, \( \pm 0 \) ) 对于任何x都返回1，即使x是NaN。

• pow(x, y) 对于有限负数 x 和有限非整数 y 会返回 NaN。

• pow(x, \( -\infty \) ) 当 \( | x | < 1 \) 时返回 \( +\infty \)。

• pow(x, \( -\infty \) ) 当 \( | x | > 1 \) 时返回 +0。

• pow(x, \( +\infty \) ) 当 \( | x | < 1 \) 时返回 +0。

• pow(x, \( +\infty \) ) 当 \( | x | > 1 \) 时返回 \( +\infty \)。

• pow( \( -\infty \) , y) 当 y 为小于0的奇数时返回-0。

• 当 y 小于 0 且不是奇数时，pow( \( -\infty \) , y) 返回 +0。

• pow( \( -\infty \) , y) 当 y 为大于0的奇数时返回 \( -\infty \)。

• pow( \( -\infty \) , y) 当 y > 0 且不是奇数时返回 \( +\infty \)。

• 当 y < 0 时，pow( \( +\infty \) , y) 返回 +0。

• pow( \( +\infty \) , y) 当 y > 0 时返回 \( +\infty \)。

• 如果x或y或两者都是NaN，且x \( \neq \) +1且y \( \neq\pm 0 \)，pow(x, y)将返回NaN。

__device__ double rcbrt(double x)

计算倒数立方根函数。

计算x的倒数立方根函数。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• rcbrt( \( \pm 0 \) ) 返回 \( \pm \infty \)。

• rcbrt( \( \pm \infty \) ) 返回 \( \pm 0 \)。

• rcbrt(NaN) 返回 NaN。

__device__ double remainder(double x, double y)

计算双精度浮点余数。

计算非零y情况下，x除以y的双精度浮点余数r。即\( r = x - n y \)。其中n是最接近\( \frac{x}{y} \)的整数值。当\( | n -\frac{x}{y} | = \frac{1}{2} \)时，将选择偶数值n。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• remainder(x, \( \pm 0 \) ) 返回 NaN。

• remainder( \( \pm \infty \) , y) 返回 NaN。

• remainder(x, \( \pm \infty \) ) 对于有限值 x 返回 x。

• 如果任一参数为NaN，则返回NaN。

__device__ double remquo(double x, double y, int *quo)

计算双精度浮点余数及部分商。

计算双精度浮点余数，方法与remainder()函数相同。参数quo返回x除以y时的部分商值。quo值的符号与\( \frac{x}{y} \)相同，可能不是精确的商值，但在低3位与精确商值一致。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

返回余数。

• remquo(x, \( \pm 0 \) , quo) 返回NaN并在quo指向的位置存储一个未指定的值。

• remquo( \( \pm \infty \) , y, quo) 返回 NaN 并将未指定的值存储到 quo 所指向的位置。

• remquo(x, y, quo) 当x或y为NaN时，返回NaN并在quo指向的位置存储一个未指定的值。

• remquo(x, \( \pm \infty \) , quo) 返回 x 并将零存储到 quo 所指向的位置（当 x 为有限值时）。

__device__ double rhypot(double x, double y)

计算两个参数平方和的平方根的倒数。

计算一个直角三角形斜边长度的倒数，该直角三角形的两条直角边长度分别为x和y，且不会出现过度溢出或下溢。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

返回斜边长度的倒数 \( \frac{1}{\sqrt{x^2+y^2}} \)。

• rhypot(x,y)、rhypot(y,x)和rhypot(x, -y)是等价的。

• rhypot( \( \pm \infty \) ,y) 返回 +0，即使 y 是一个 NaN。

• rhypot( \( \pm 0, \pm 0 \)) 返回 \( +\infty \).

• 当y不是\( \pm\infty \)时，rhypot(NaN, y)返回NaN。

__device__ double rint(double x)

将浮点数四舍五入到最接近的整数值。

将 x 四舍五入为最接近的浮点格式整数值，中间值则舍入到最接近的偶数整数值。

Returns

返回四舍五入后的整数值。

• rint( \( \pm 0 \) ) 返回 \( \pm 0 \)。

• rint( \( \pm \infty \) ) 返回 \( \pm \infty \)。

• rint(NaN) 返回 NaN。

__device__ double rnorm(int dim, double const *p)

计算任意数量坐标的平方和平方根的倒数。

计算向量p在欧几里得空间中的长度的倒数，其维度作为参数传入，避免不必要的溢出或下溢。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

返回向量长度的倒数 \( \frac{1}{\sqrt{\sum_{i=0}^{dim-1} p_i^2}} \)。

• 即使存在NaN值，当坐标精确无限时，仍会返回\( +0 \)。

• 当所有坐标均为 \( \pm 0 \) 时，返回 \( +\infty \)。

• 当至少一个坐标是NaN且没有无限值时，返回NaN。

__device__ double rnorm3d(double a, double b, double c)

计算三个坐标平方和的平方根的倒数。

计算三维向量在欧几里得空间中的长度的倒数，避免不必要的溢出或下溢。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

返回3D向量长度的倒数\( \frac{1}{\sqrt{a^2+b^2+c^2}} \)。

• 即使存在NaN值，当坐标精确无限时，仍会返回\( +0 \)。

• 当所有坐标均为 \( \pm 0 \) 时，返回 \( +\infty \)。

• 当至少一个坐标是NaN且没有无限值时，返回NaN。

__device__ double rnorm4d(double a, double b, double c, double d)

计算四个坐标平方和的平方根的倒数。

计算四维欧几里得空间向量的长度的倒数，避免不必要的溢出或下溢。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

返回3D向量长度的倒数\( \frac{1}{\sqrt{a^2+b^2+c^2+d^2}} \)。

• 即使存在NaN值，当坐标精确无限时，仍会返回\( +0 \)。

• 当所有坐标均为 \( \pm 0 \) 时，返回 \( +\infty \)。

• 当至少一个坐标是NaN且没有无限值时，返回NaN。

__device__ double round(double x)

将浮点数四舍五入到最接近的整数值。

将 x 四舍五入为最接近的浮点格式整数值，中间值（0.5）向远离零的方向舍入。

注意

此函数可能比其他舍入方法更慢。请参阅rint()。

Returns

返回四舍五入后的整数值。

• round( \( \pm 0 \) ) 返回 \( \pm 0 \)。

• round( \( \pm \infty \) ) 返回 \( \pm \infty \)。

• round(NaN) 返回 NaN。

__device__ double rsqrt(double x)

计算输入参数的平方根的倒数。

计算x的非负平方根的倒数，\( 1/\sqrt{x} \)。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

返回 \( 1/\sqrt{x} \)。

• rsqrt( \( +\infty \) ) 返回 +0。

• rsqrt( \( \pm 0 \) ) 返回 \( \pm \infty \)。

• 如果 x 小于 0，rsqrt(x) 将返回 NaN。

• rsqrt(NaN) 返回 NaN。

__device__ double scalbln(double x, long int n)

将浮点输入按2的整数次幂进行缩放。

通过高效操作浮点指数，将x缩放\( 2^n \)倍。

Returns

返回 x * \( 2^n \)。

• scalbln( \( \pm 0 \) , n) 返回 \( \pm 0 \)。

• scalbln(x, 0) 返回 x。

• scalbln( \( \pm \infty \) , n) 返回 \( \pm \infty \)。

• scalbln(NaN, n) 返回 NaN。

__device__ double scalbn(double x, int n)

将浮点输入按2的整数次幂进行缩放。

通过高效操作浮点指数，将x缩放\( 2^n \)倍。

Returns

返回 x * \( 2^n \)。

• scalbn( \( \pm 0 \) , n) 返回 \( \pm 0 \)。

• scalbn(x, 0) 返回 x。

• scalbn( \( \pm \infty \) , n) 返回 \( \pm \infty \)。

• scalbn(NaN, n) 返回 NaN。

__device__ __RETURN_TYPE signbit(double a)

返回输入的符号位。

判断浮点数值 a 是否为负数。

Returns

报告所有值的符号位，包括无穷大、零和NaN。

• 使用Visual Studio 2013主机编译器：__RETURN_TYPE为'bool'。当且仅当a为负数时返回true。

• 使用其他主机编译器时：__RETURN_TYPE 为 'int'。当且仅当 a 为负数时返回非零值。

__device__ double sin(double x)

计算输入参数的正弦值。

计算输入参数 x 的正弦值（以弧度为单位）。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• sin( \( \pm 0 \) ) 返回 \( \pm 0 \)。

• sin( \( \pm \infty \) ) 返回 NaN。

• sin(NaN) 返回 NaN。

__device__ void sincos(double x, double *sptr, double *cptr)

计算第一个输入参数的正弦和余弦值。

计算第一个输入参数x(以弧度为单位)的正弦和余弦值。正弦和余弦的结果分别写入第二个参数sptr和第三个参数cptr。

另请参阅

sin() 和 cos()。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

__device__ void sincospi(double x, double *sptr, double *cptr)

计算第一个输入参数\( \times \pi \)的正弦和余弦值。

计算第一个输入参数x（以弧度为单位）的正弦和余弦值，\( \times \pi \)。正弦和余弦的结果分别写入第二个参数sptr和第三个参数cptr。

另请参阅

sinpi() 和 cospi()。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

__device__ double sinh(double x)

计算输入参数的双曲正弦值。

计算输入参数 x 的双曲正弦值。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• sinh( \( \pm 0 \) ) 返回 \( \pm 0 \)。

• sinh( \( \pm \infty \) ) 返回 \( \pm \infty \)。

• sinh(NaN) 返回 NaN。

__device__ double sinpi(double x)

计算输入参数 \( \times \pi \) 的正弦值。

计算x \( \times \pi \)的正弦值（以弧度为单位），其中x是输入参数。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• sinpi( \( \pm 0 \) ) 返回 \( \pm 0 \)。

• sinpi( \( \pm \infty \) ) 返回 NaN。

• sinpi(NaN) 返回 NaN。

__device__ double sqrt(double x)

计算输入参数的平方根。

计算x的非负平方根，\( \sqrt{x} \)。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

返回 \( \sqrt{x} \)。

• sqrt( \( \pm 0 \) ) 返回 \( \pm 0 \)。

• sqrt( \( +\infty \) ) 返回 \( +\infty \)。

• 如果 x 小于 0，sqrt(x) 将返回 NaN。

• sqrt(NaN) 返回 NaN。

__device__ double tan(double x)

计算输入参数的正切值。

计算输入参数 x 的正切值（以弧度为单位）。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• tan( \( \pm 0 \) ) 返回 \( \pm 0 \)。

• tan( \( \pm \infty \) ) 返回 NaN。

• tan(NaN) 返回 NaN。

__device__ double tanh(double x)

计算输入参数的双曲正切值。

计算输入参数 x 的双曲正切值。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• tanh( \( \pm 0 \) ) 返回 \( \pm 0 \)。

• tanh( \( \pm \infty \) ) 返回 \( \pm 1 \)。

• tanh(NaN) 返回 NaN。

__device__ double tgamma(double x)

计算输入参数的伽玛函数。

计算输入参数 x 的伽马函数值，即 \( \Gamma(x) \) 的值。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

• tgamma( \( \pm 0 \) ) 返回 \( \pm \infty \)。

• 如果x小于0且x为整数，tgamma(x)将返回NaN。

• tgamma( \( -\infty \) ) 返回 NaN。

• tgamma( \( +\infty \) ) 返回 \( +\infty \)。

• tgamma(NaN) 返回 NaN。

__device__ double trunc(double x)

将输入参数截断为整数部分。

将x四舍五入到最接近但不大于x绝对值的整数值。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

返回截断后的整数值。

• trunc( \( \pm 0 \) ) 返回 \( \pm 0 \)。

• trunc( \( \pm \infty \) ) 返回 \( \pm \infty \)。

• trunc(NaN) 返回 NaN。

__device__ double y0(double x)

计算输入参数对应的第二类零阶贝塞尔函数值。

计算输入参数x的第二类零阶贝塞尔函数值\( Y_0(x) \)。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

返回第二类零阶贝塞尔函数的值。

• y0( \( \pm 0 \) ) 返回 \( -\infty \).

• 当 x < 0 时，y0(x) 返回 NaN。

• y0( \( +\infty \) ) 返回 +0。

• y0(NaN) 返回 NaN。

__device__ double y1(double x)

计算输入参数的第二类一阶贝塞尔函数值。

计算输入参数x的第二类1阶贝塞尔函数值\( Y_1(x) \)。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

返回第二类一阶贝塞尔函数的值。

• y1( \( \pm 0 \) ) 返回 \( -\infty \).

• 当 x < 0 时，y1(x) 返回 NaN。

• y1( \( +\infty \) ) 返回 +0。

• y1(NaN) 返回 NaN。

__device__ double yn(int n, double x)

计算输入参数对应的第二类n阶贝塞尔函数值。

计算输入参数x的第二类贝塞尔函数值，阶数为n，即\( Y_n(x) \)。

注意

有关精度信息，请参阅《CUDA C++编程指南》的数学函数附录中的双精度浮点函数章节。

Returns

返回第二类贝塞尔函数在阶数n处的值。

• 当 n < 0 时，yn(n, x) 返回 NaN。

• yn(n, \( \pm 0 \) ) 返回 \( -\infty \)。

• 当 x 小于 0 时，yn(n, x) 返回 NaN。

• yn(n, \( +\infty \) ) 返回 +0。

• yn(n, NaN) 返回 NaN。