8. 双精度数学函数

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

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

函数

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

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

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

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

__device__ double j1(double x)

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

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

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

__device__ double y1(double x)

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

__device__ double yn(int n, double x)

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

8.1. 函数

__device__ double acos(double x)

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

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

注意

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

返回值

结果将以弧度为单位，对于 [-1, +1] 范围内的 x，结果在 [0, \( \pi \) ] 区间内。

• acos(1) 返回 +0。

• 对于 [-1, +1] 范围外的 x，acos(x) 返回 NaN。

• acos(NaN) 返回 NaN。

__device__ double acosh(double x)

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

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

注意

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

返回值

结果将在 [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++ 编程指南的“数学函数附录”中的“双精度浮点函数”部分。

返回值

对于 [-1, +1] 范围内的 x，结果将以弧度为单位，在 [- \( \pi \) /2, + \( \pi \) /2] 区间内。

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

• 对于 [-1, +1] 范围外的 x，asin(x) 返回 NaN。

• asin(NaN) 返回 NaN。

__device__ double asinh(double x)

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

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

注意

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

返回值

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

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

• asinh(NaN) 返回 NaN。

__device__ double atan(double x)

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

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

注意

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

返回值

结果将以弧度为单位，在 [- \( \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++ 编程指南的“数学函数附录”中的“双精度浮点函数”部分。

返回值

结果将以弧度为单位，在 [- \( \pi \) , + \( \pi \) ] 区间内。

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

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

• 对于 x < 0，atan2( \( \pm 0 \) , x) 返回 \( \pm \pi \)。

• 对于 x > 0，atan2( \( \pm 0 \) , x) 返回 \( \pm 0 \)。

• 对于 y < 0，atan2(y, \( \pm 0 \) ) 返回 \( -\pi \) /2。

• 对于 y > 0，atan2(y, \( \pm 0 \) ) 返回 \( \pi \) /2。

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

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

• 对于有限的 x，atan2( \( \pm \infty \) , 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++ 编程指南的“数学函数附录”中的“双精度浮点函数”部分。

返回值

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

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

• 对于区间 [-1, 1] 之外的 x，atanh(x) 返回 NaN。

• atanh(NaN) 返回 NaN。

__device__ double cbrt(double x)

计算输入参数的立方根。

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

注意

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

返回值

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

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

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

• cbrt(NaN) 返回 NaN。

__device__ double ceil(double x)

计算输入参数的上限值（天花板值）。

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

返回值

返回表示为浮点数的 \( \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 相同。

返回值

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

• copysign(NaN, y) 返回一个符号与 y 相同的 NaN。

__device__ double cos(double x)

计算输入参数的余弦值。

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

注意

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

返回值

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

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

• cos(NaN) 返回 NaN。

__device__ double cosh(double x)

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

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

注意

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

返回值

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

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

• cosh(NaN) 返回 NaN。

__device__ double cospi(double x)

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

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

注意

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

返回值

• 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++ 编程指南的“数学函数附录”中的“双精度浮点函数”部分。

返回值

返回 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)

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

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

注意

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

返回值

返回 1 阶正则修正柱贝塞尔函数值。

• 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++ 编程指南的“数学函数附录”中的“双精度浮点函数”部分。

返回值

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

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

• erf(NaN) 返回 NaN。

__device__ double erfc(double x)

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

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

注意

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

返回值

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

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

• erfc(NaN) 返回 NaN。

__device__ double erfcinv(double x)

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

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

注意

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

返回值

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

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

• 对于 [0, 2] 之外的 x，erfcinv(x) 返回 NaN。

• erfcinv(NaN) 返回 NaN。

__device__ double erfcx(double x)

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

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

注意

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

返回值

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

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

• erfcx(NaN) 返回 NaN。

__device__ double erfinv(double x)

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

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

注意

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

返回值

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

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

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

• 对于 [-1, +1] 之外的 x，erfinv(x) 返回 NaN。

• erfinv(NaN) 返回 NaN。

__device__ double exp(double x)

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

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

注意

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

返回值

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

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

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

• exp(NaN) 返回 NaN。

__device__ double exp10(double x)

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

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

注意

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

返回值

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

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

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

• exp10(NaN) 返回 NaN。

__device__ double exp2(double x)

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

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

注意

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

返回值

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

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

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

• exp2(NaN) 返回 NaN。

__device__ double expm1(double x)

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

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

注意

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

返回值

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

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

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

• expm1(NaN) 返回 NaN。

__device__ double fabs(double x)

计算输入参数的绝对值。

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

注意

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

返回值

返回输入参数的绝对值。

• 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++ 编程指南的“数学函数附录”中的“双精度浮点函数”部分。

返回值

返回 x 和 y 之间的正差。

• 如果 x > y，则 fdim(x, y) 返回 x - y。

• 如果 x \( \leq \) y，则 fdim(x, y) 返回 +0。

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

__device__ double floor(double x)

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

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

注意

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

返回值

返回表示为浮点数的 \( \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++ 编程指南的“数学函数附录”中的“双精度浮点函数”部分。

返回值

返回作为单个操作的 \( x \times y + z \) 的舍入值。

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

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

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

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

• 如果 \( x \times y \) 是精确的 \( \pm 0 \)，则 fma(x, y, \( \pm 0 \)) 返回 \( \pm 0 \)。

• 如果 \( x \times y \) 是精确的 \( \pm 0 \)，则 fma(x, y, \( \mp 0 \)) 返回 \( +0 \)。

• 如果 \( x \times y + z \) 正好为零且 \( z \neq 0 \)，则 fma(x, y, z) 返回 \( +0 \)。

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

__device__ double fmax(double, double)

确定参数的最大数值。

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

注意

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

返回值

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

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

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

__device__ double fmin(double x, double y)

确定参数的最小数值。

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

注意

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

返回值

返回参数 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++ 编程指南的“数学函数附录”中的“双精度浮点函数”部分。

返回值

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

• fmod( \( \pm 0 \) , y) 在 y 非零时返回 \( \pm 0 \)。

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

• fmod(x, y) 在 x 为 \( \pm\infty \) 或 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++ 编程指南的“数学函数附录”中的“双精度浮点函数”部分。

返回值

返回分量 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++ 编程指南的“数学函数附录”中的“双精度浮点函数”部分。

返回值

返回斜边长度 \( \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。

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

__device__ int ilogb(double x)

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

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

注意

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

返回值

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

• 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 是否为有限值（零、次正规、或正规且非无穷大或 NaN）。

返回值

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

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

__device__ __RETURN_TYPE isinf(double a)

确定参数是否为无穷大。

确定浮点值 a 是否为无穷大值（正或负）。

返回值

• 使用 Visual Studio 2013 主机编译器：当且仅当 a 是无穷大值时，返回 true。

• 使用其他主机编译器：当且仅当 a 是无穷大值时，返回非零值。

__device__ __RETURN_TYPE isnan(double a)

确定参数是否为 NaN（非数字）。

确定浮点值 a 是否为 NaN。

返回值

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

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

__device__ double j0(double x)

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

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

注意

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

返回值

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

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

• j0(NaN) 返回 NaN。

__device__ double j1(double x)

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

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

注意

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

返回值

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

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

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

• j1(NaN) 返回 NaN。

__device__ double jn(int n, double x)

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

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

注意

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

返回值

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

• jn(n, NaN) 返回 NaN。

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

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

__device__ double ldexp(double x, int exp)

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

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

注意

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

返回值

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

__device__ double lgamma(double x)

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

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

注意

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

返回值

• 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 舍入到最接近的整数值，中间情况舍入到最接近的偶数整数值。如果结果超出返回类型的范围，则行为未定义。

返回值

返回舍入后的整数值。

__device__ long long int llround(double x)

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

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

注意

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

返回值

返回舍入后的整数值。

__device__ double log(double x)

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

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

注意

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

返回值

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

• log(1) 返回 +0。

• log(x) 在 x < 0 时返回 NaN。

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

• log(NaN) 返回 NaN。

__device__ double log10(double x)

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

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

注意

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

返回值

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

• log10(1) 返回 +0。

• log10(x) 在 x < 0 时返回 NaN。

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

• log10(NaN) 返回 NaN。

__device__ double log1p(double x)

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

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

注意

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

返回值

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

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

• log1p(x) 在 x < -1 时返回 NaN。

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

• log1p(NaN) 返回 NaN。

__device__ double log2(double x)

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

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

注意

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

返回值

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

• log2(1) 返回 +0。

• log2(x) 在 x < 0 时返回 NaN。

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

• log2(NaN) 返回 NaN。

__device__ double logb(double x)

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

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

注意

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

返回值

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

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

• logb(NaN) 返回 NaN。

__device__ long int lrint(double x)

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

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

返回值

返回舍入后的整数值。

__device__ long int lround(double x)

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

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

注意

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

返回值

返回舍入后的整数值。

__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++ 编程指南的“数学函数附录”中的“双精度浮点函数”部分。

返回值

• 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)” 值。

返回 quiet NaN 的表示。参数 tagp 选择可能的表示之一。

注意

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

返回值

• nan(tagp) 返回 NaN。

__device__ double nearbyint(double x)

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

将参数 x 舍入为双精度浮点格式的整数值。使用舍入到最接近的舍入方式， ties 舍入到偶数。

注意

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

返回值

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

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

• nearbyint(NaN) 返回 NaN。

__device__ double nextafter(double x, double y)

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

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

注意

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

返回值

• 如果 x 等于 y，则 nextafter(x, y) = y。

• 如果 x 或 y 中任一为 NaN，则 nextafter(x, y) = NaN。

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

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

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

注意

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

返回值

返回 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++ 编程指南的“数学函数附录”中的“双精度浮点函数”部分。

返回值

返回三维向量 \( \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++ 编程指南的“数学函数附录”中的“双精度浮点函数”部分。

返回值

返回四维向量 \( \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++ 编程指南的“数学函数附录”中的“双精度浮点函数”部分。

返回值

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

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

• normcdf(NaN) 返回 NaN。

__device__ double normcdfinv(double x)

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

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

注意

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

返回值

• 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++ 编程指南的“数学函数附录”中的“双精度浮点函数”部分。

返回值

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

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

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

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

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

• 对于任何 y，即使是 NaN，pow(+1, y) 都返回 1。

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

• 对于有限的 x < 0 和有限的非整数 y，pow(x, y) 返回 NaN。

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

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

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

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

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

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

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

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

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

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

• 如果 x 或 y 或两者均为 NaN，且 x \( \neq \) +1 和 y \( \neq\pm 0 \)，则 pow(x, y) 返回 NaN。

__device__ double rcbrt(double x)

计算倒数立方根函数。

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

注意

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

返回值

• 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++ 编程指南的“数学函数附录”中的“双精度浮点函数”部分。

返回值

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

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

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

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

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

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

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

注意

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

返回值

返回余数。

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

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

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

• 对于有限的 x，remquo(x, \( \pm \infty \) , quo) 返回 x，并在 quo 指向的位置存储零。

__device__ double rhypot(double x, double y)

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

计算直角三角形斜边长度的倒数，该直角三角形的两条边长分别为 x 和 y，没有不必要的溢出或下溢。

注意

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

返回值

返回斜边长度的倒数 \( \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 舍入为浮点格式的最接近的整数值，对于中间情况，舍入到最接近的偶数整数值。

返回值

返回舍入后的整数值。

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

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

• rint(NaN) 返回 NaN。

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

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

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

注意

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

返回值

返回向量长度的倒数 \( \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++ 编程指南的“数学函数附录”中的“双精度浮点函数”部分。

返回值

返回三维向量长度的倒数 \( \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++ 编程指南的“数学函数附录”中的“双精度浮点函数”部分。

返回值

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

• 如果存在精确的无穷坐标，即使有 NaN，也会返回 \( +0 \)。

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

• 当至少一个坐标为 NaN 且没有无穷坐标时，返回 NaN。

__device__ double round(double x)

以浮点形式四舍五入到最接近的整数值。

将 x 四舍五入到最接近的浮点格式整数值，对于中间值情况，远离零进行舍入。

注意

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

返回值

返回舍入后的整数值。

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

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

• round(NaN) 返回 NaN。

__device__ double rsqrt(double x)

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

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

注意

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

返回值

返回 \( 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 \) 倍。

返回值

返回 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 \) 倍。

返回值

返回 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 是否为负数。

返回值

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

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

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

__device__ double sin(double x)

计算输入参数的正弦值。

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

注意

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

返回值

• 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++ 编程指南的“数学函数附录”中的“双精度浮点函数”部分。

返回值

• 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++ 编程指南的“数学函数附录”中的“双精度浮点函数”部分。

返回值

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

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

• sinpi(NaN) 返回 NaN。

__device__ double sqrt(double x)

计算输入参数的平方根。

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

注意

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

返回值

返回 \( \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++ 编程指南的“数学函数附录”中的“双精度浮点函数”部分。

返回值

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

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

• tan(NaN) 返回 NaN。

__device__ double tanh(double x)

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

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

注意

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

返回值

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

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

• tanh(NaN) 返回 NaN。

__device__ double tgamma(double x)

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

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

注意

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

返回值

• 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++ 编程指南的“数学函数附录”中的“双精度浮点函数”部分。

返回值

返回截断的整数值。

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

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

• trunc(NaN) 返回 NaN。

__device__ double y0(double x)

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

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

注意

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

返回值

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

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

• 如果 x < 0，则 y0(x) 返回 NaN。

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

• y0(NaN) 返回 NaN。

__device__ double y1(double x)

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

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

注意

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

返回值

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

• 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++ 编程指南的“数学函数附录”中的“双精度浮点函数”部分。

返回值

返回第二类 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。