6. 单精度数学函数

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

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

函数

__device__ float acosf(float x): 计算输入参数的反余弦值。
__device__ float acoshf(float x): 计算输入参数的非负反双曲余弦值。
__device__ float asinf(float x): 计算输入参数的反正弦值。
__device__ float asinhf(float x): 计算输入参数的反双曲正弦值。
__device__ float atan2f(float y, float x): 计算第一个和第二个输入参数之比的反正切值。
__device__ float atanf(float x): 计算输入参数的反正切值。
__device__ float atanhf(float x): 计算输入参数的反双曲正切值。
__device__ float cbrtf(float x): 计算输入参数的立方根。
__device__ float ceilf(float x): 计算输入参数的上限值。
__device__ float copysignf(float x, float y): 创建具有给定大小的值，复制第二个值的符号。
__device__ float cosf(float x): 计算输入参数的余弦值。
__device__ float coshf(float x): 计算输入参数的双曲余弦值。
__device__ float cospif(float x): 计算输入参数 \(\times \pi\) 的余弦值。
__device__ float cyl_bessel_i0f(float x): 计算输入参数的 0 阶正则修正柱贝塞尔函数值。
__device__ float cyl_bessel_i1f(float x): 计算输入参数的 1 阶正则修正柱贝塞尔函数值。
__device__ float erfcf(float x): 计算输入参数的互补误差函数。
__device__ float erfcinvf(float x): 计算输入参数的反互补误差函数。
__device__ float erfcxf(float x): 计算输入参数的比例互补误差函数。
__device__ float erff(float x): 计算输入参数的误差函数。
__device__ float erfinvf(float x): 计算输入参数的反误差函数。
__device__ float exp10f(float x): 计算输入参数的以 10 为底的指数。
__device__ float exp2f(float x): 计算输入参数的以 2 为底的指数。
__device__ float expf(float x): 计算输入参数的以 \(e\) 为底的指数。
__device__ float expm1f(float x): 计算输入参数的以 \(e\) 为底的指数，减 1。
__device__ float fabsf(float x): 计算其参数的绝对值。
__device__ float fdimf(float x, float y): 计算 x 和 y 之间的正差。
__device__ float fdividef(float x, float y): 除以两个浮点值。
__device__ float floorf(float x): 计算小于或等于 x 的最大整数。
__device__ float fmaf(float x, float y, float z): 将 \(x \times y + z\) 计算为单个操作。
__device__ float fmaxf(float x, float y): 确定参数的最大数值。
__device__ float fminf(float x, float y): 确定参数的最小数值。
__device__ float fmodf(float x, float y): 计算 x / y 的浮点余数。
__device__ float frexpf(float x, int *nptr): 提取浮点值的尾数和指数。
__device__ float hypotf(float x, float y): 计算两个参数的平方和的平方根。
__device__ int ilogbf(float x): 计算参数的无偏整数指数。
__device__ __RETURN_TYPE isfinite(float a): 确定参数是否为有限数。
__device__ __RETURN_TYPE isinf(float a): 确定参数是否为无穷大。
__device__ __RETURN_TYPE isnan(float a): 确定参数是否为 NaN。
__device__ float j0f(float x): 计算输入参数的 0 阶第一类贝塞尔函数值。
__device__ float j1f(float x): 计算输入参数的 1 阶第一类贝塞尔函数值。
__device__ float jnf(int n, float x): 计算输入参数的 n 阶第一类贝塞尔函数值。
__device__ float ldexpf(float x, int exp): 计算 \(x\cdot 2^{exp}\) 的值。
__device__ float lgammaf(float x): 计算输入参数的伽马函数绝对值的自然对数。
__device__ long long int llrintf(float x): 将输入四舍五入到最接近的整数值。
__device__ long long int llroundf(float x): 四舍五入到最接近的整数值。
__device__ float log10f(float x): 计算输入参数的以 10 为底的对数。
__device__ float log1pf(float x): 计算 \(\log_{e}(1+x)\) 的值。
__device__ float log2f(float x): 计算输入参数的以 2 为底的对数。
__device__ float logbf(float x): 计算输入参数的指数的浮点表示。
__device__ float logf(float x): 计算输入参数的自然对数。
__device__ long int lrintf(float x): 将输入四舍五入到最接近的整数值。
__device__ long int lroundf(float x): 四舍五入到最接近的整数值。
__device__ float max(const float a, const float b): 计算输入 float 参数的最大值。
__device__ float min(const float a, const float b): 计算输入 float 参数的最小值。
__device__ float modff(float x, float *iptr): 将输入参数分解为小数部分和整数部分。
__device__ float nanf(const char *tagp): 返回“非数字”值。
__device__ float nearbyintf(float x): 将输入参数四舍五入到最接近的整数。
__device__ float nextafterf(float x, float y): 返回参数 x 之后，朝 y 方向的下一个可表示的单精度浮点值。
__device__ float norm3df(float a, float b, float c): 计算参数的三个坐标平方和的平方根。
__device__ float norm4df(float a, float b, float c, float d): 计算参数的四个坐标平方和的平方根。
__device__ float normcdff(float x): 计算标准正态累积分布函数。
__device__ float normcdfinvf(float x): 计算标准正态累积分布函数的反函数。
__device__ float normf(int dim, float const *p): 计算任意数量坐标的平方和的平方根。
__device__ float powf(float x, float y): 计算第一个参数的第二个参数次幂的值。
__device__ float rcbrtf(float x): 计算倒数立方根函数。
__device__ float remainderf(float x, float y): 计算单精度浮点余数。
__device__ float remquof(float x, float y, int *quo): 计算单精度浮点余数和部分商。
__device__ float rhypotf(float x, float y): 计算两个参数的平方和的平方根的倒数。
__device__ float rintf(float x): 将输入四舍五入到最接近的整数值（浮点数）。
__device__ float rnorm3df(float a, float b, float c): 计算三个坐标平方和的平方根的倒数。
__device__ float rnorm4df(float a, float b, float c, float d): 计算四个坐标平方和的平方根的倒数。
__device__ float rnormf(int dim, float const *p): 计算任意数量坐标的平方和的平方根的倒数。
__device__ float roundf(float x): 四舍五入到最接近的整数值（浮点数）。
__device__ float rsqrtf(float x): 计算输入参数的平方根的倒数。
__device__ float scalblnf(float x, long int n): 按 2 的整数次幂缩放浮点输入。
__device__ float scalbnf(float x, int n): 按 2 的整数次幂缩放浮点输入。
__device__ __RETURN_TYPE signbit(float a): 返回输入的符号位。
__device__ void sincosf(float x, float *sptr, float *cptr): 计算第一个输入参数的正弦值和余弦值。
__device__ void sincospif(float x, float *sptr, float *cptr): 计算第一个输入参数 \(\times \pi\) 的正弦值和余弦值。
__device__ float sinf(float x): 计算输入参数的正弦值。
__device__ float sinhf(float x): 计算输入参数的双曲正弦值。
__device__ float sinpif(float x): 计算输入参数 \(\times \pi\) 的正弦值。
__device__ float sqrtf(float x): 计算输入参数的平方根。
__device__ float tanf(float x): 计算输入参数的正切值。
__device__ float tanhf(float x): 计算输入参数的双曲正切值。
__device__ float tgammaf(float x): 计算输入参数的伽马函数。
__device__ float truncf(float x): 将输入参数截断为整数部分。
__device__ float y0f(float x): 计算输入参数的 0 阶第二类贝塞尔函数值。
__device__ float y1f(float x): 计算输入参数的 1 阶第二类贝塞尔函数值。
__device__ float ynf(int n, float x): 计算输入参数的 n 阶第二类贝塞尔函数值。

6.1. 函数

__device__ float acosf(float x)

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

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

注意

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

返回值

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

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

__device__ float acoshf(float x)

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

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

注意

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

返回值

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

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

__device__ float asinf(float x)

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

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

注意

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

返回值

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

asinf( \( \pm 0 \) ) 返回 \( \pm 0 \)。
对于 [-1, +1] 之外的 x，asinf(x) 返回 NaN。
asinf(NaN) 返回 NaN。

__device__ float asinhf(float x)

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

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

注意

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

返回值

asinhf( \( \pm 0 \) ) 返回 \( \pm 0 \)。
asinhf( \( \pm \infty \) ) 返回 \( \pm \infty \)。
asinhf(NaN) 返回 NaN。

__device__ float atan2f(float y, float x)

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

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

注意

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

返回值

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

atan2f( \( \pm 0 \) , -0) 返回 \( \pm \pi \)。
atan2f( \( \pm 0 \) , +0) 返回 \( \pm 0 \)。
atan2f( \( \pm 0 \) , x) 对于 x < 0 返回 \( \pm \pi \)。
atan2f( \( \pm 0 \) , x) 对于 x > 0 返回 \( \pm 0 \)。
atan2f(y, \( \pm 0 \) ) 对于 y < 0 返回 \( -\pi \) /2。
atan2f(y, \( \pm 0 \) ) 对于 y > 0 返回 \( \pi \) /2。
atan2f( \( \pm y \) , \( -\infty \) ) 对于有限 y > 0 返回 \( \pm \pi \)。
atan2f( \( \pm y \) , \( +\infty \) ) 对于有限 y > 0 返回 \( \pm 0 \)。
atan2f( \( \pm \infty \) , x) 对于有限 x 返回 \( \pm \pi \) /2。
atan2f( \( \pm \infty \) , \( -\infty \) ) 返回 \( \pm 3\pi \) /4。
atan2f( \( \pm \infty \) , \( +\infty \) ) 返回 \( \pm \pi \) /4。
如果任一参数为 NaN，则返回 NaN。

__device__ float atanf(float x)

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

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

注意

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

返回值

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

atanf( \( \pm 0 \) ) 返回 \( \pm 0 \)。
atanf( \( \pm \infty \) ) 返回 \( \pm \pi \) /2。
atanf(NaN) 返回 NaN。

__device__ float atanhf(float x)

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

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

注意

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

返回值

atanhf( \( \pm 0 \) ) 返回 \( \pm 0 \)。
atanhf( \( \pm 1 \) ) 返回 \( \pm \infty \)。
对于区间 [-1, 1] 之外的 x，atanhf(x) 返回 NaN。
atanhf(NaN) 返回 NaN。

__device__ float cbrtf(float x)

计算输入参数的立方根。

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

注意

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

返回值

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

cbrtf( \( \pm 0 \) ) 返回 \( \pm 0 \)。
cbrtf( \( \pm \infty \) ) 返回 \( \pm \infty \)。
cbrtf(NaN) 返回 NaN。

__device__ float ceilf(float x)

计算输入参数的上限值。

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

注意

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

返回值

返回以浮点数表示的 \( \lceil x \rceil \)。

ceilf( \( \pm 0 \) ) 返回 \( \pm 0 \)。
ceilf( \( \pm \infty \) ) 返回 \( \pm \infty \)。
ceilf(NaN) 返回 NaN。

__device__ float copysignf(float x, float y)

创建具有给定大小的值，复制第二个值的符号。

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

返回值

一个数值，其大小与 x 相同，符号与 y 相同。
copysignf(NaN, y) 返回一个 NaN，其符号与 y 相同。

__device__ float cosf(float x)

计算输入参数的余弦值。

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

注意

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

注意

此函数受 use_fast_math 编译器标志的影响。有关受影响函数的完整列表，请参阅 CUDA C++ 编程指南的“数学函数附录”中的“Intrinsic Functions”部分。

返回值

cosf( \( \pm 0 \) ) 返回 1。
cosf( \( \pm \infty \) ) 返回 NaN。
cosf(NaN) 返回 NaN。

__device__ float coshf(float x)

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

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

注意

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

返回值

coshf( \( \pm 0 \) ) 返回 1。
coshf( \( \pm \infty \) ) 返回 \( +\infty \)。
coshf(NaN) 返回 NaN。

__device__ float cospif(float x)

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

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

注意

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

返回值

cospif( \( \pm 0 \) ) 返回 1。
cospif( \( \pm \infty \) ) 返回 NaN。
cospif(NaN) 返回 NaN。

__device__ float cyl_bessel_i0f(float x)

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

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

注意

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

返回值

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

cyl_bessel_i0f( \( \pm 0 \)) 返回 +1。
cyl_bessel_i0f( \( \pm\infty \)) 返回 \( +\infty \)。
cyl_bessel_i0f(NaN) 返回 NaN。

__device__ float cyl_bessel_i1f(float x)

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

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

注意

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

返回值

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

cyl_bessel_i1f( \( \pm 0 \)) 返回 \( \pm 0 \)。
cyl_bessel_i1f( \( \pm\infty \)) 返回 \( \pm\infty \)。
cyl_bessel_i1f(NaN) 返回 NaN。

__device__ float erfcf(float x)

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

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

注意

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

返回值

erfcf( \( -\infty \) ) 返回 2。
erfcf( \( +\infty \) ) 返回 +0。
erfcf(NaN) 返回 NaN。

__device__ float erfcinvf(float x)

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

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

注意

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

返回值

erfcinvf( \( \pm 0 \) ) 返回 \( +\infty \)。
erfcinvf(2) 返回 \( -\infty \)。
对于 [0, 2] 之外的 x，erfcinvf(x) 返回 NaN。
erfcinvf(NaN) 返回 NaN。

__device__ float erfcxf(float x)

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

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

注意

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

返回值

erfcxf( \( -\infty \) ) 返回 \( +\infty \)。
erfcxf( \( +\infty \) ) 返回 +0。
erfcxf(NaN) 返回 NaN。

__device__ float erff(float x)

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

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

注意

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

返回值

erff( \( \pm 0 \) ) 返回 \( \pm 0 \)。
erff( \( \pm \infty \) ) 返回 \( \pm 1 \)。
erff(NaN) 返回 NaN。

__device__ float erfinvf(float x)

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

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

注意

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

返回值

erfinvf( \( \pm 0 \) ) 返回 \( \pm 0 \)。
erfinvf(1) 返回 \( +\infty \)。
erfinvf(-1) 返回 \( -\infty \)。
对于 [-1, +1] 之外的 x，erfinvf(x) 返回 NaN。
erfinvf(NaN) 返回 NaN。

__device__ float exp10f(float x)

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

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

注意

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

注意

此函数受 use_fast_math 编译器标志的影响。有关受影响函数的完整列表，请参阅 CUDA C++ 编程指南的“数学函数附录”中的“Intrinsic Functions”部分。

返回值

exp10f( \( \pm 0 \) ) 返回 1。
exp10f( \( -\infty \) ) 返回 +0。
exp10f( \( +\infty \) ) 返回 \( +\infty \)。
exp10f(NaN) 返回 NaN。

__device__ float exp2f(float x)

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

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

注意

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

返回值

exp2f( \( \pm 0 \) ) 返回 1。
exp2f( \( -\infty \) ) 返回 +0。
exp2f( \( +\infty \) ) 返回 \( +\infty \)。
exp2f(NaN) 返回 NaN。

__device__ float expf(float x)

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

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

注意

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

注意

此函数受 use_fast_math 编译器标志的影响。有关受影响函数的完整列表，请参阅 CUDA C++ 编程指南的“数学函数附录”中的“Intrinsic Functions”部分。

返回值

expf( \( \pm 0 \) ) 返回 1。
expf( \( -\infty \) ) 返回 +0。
expf( \( +\infty \) ) 返回 \( +\infty \)。
expf(NaN) 返回 NaN。

__device__ float expm1f(float x)

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

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

注意

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

返回值

expm1f( \( \pm 0 \) ) 返回 \( \pm 0 \)。
expm1f( \( -\infty \) ) 返回 -1。
expm1f( \( +\infty \) ) 返回 \( +\infty \)。
expm1f(NaN) 返回 NaN。

__device__ float fabsf(float x)

计算其参数的绝对值。

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

注意

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

返回值

返回其参数的绝对值。

fabsf( \( \pm \infty \) ) 返回 \( +\infty \)。
fabsf( \( \pm 0 \) ) 返回 +0。
fabsf(NaN) 返回一个未指定的 NaN。

__device__ float fdimf(float x, float y)

计算 x 和 y 之间的正差。

计算 x 和 y 之间的正差。当 x > y 时，正差为 x - y；否则为 +0。

注意

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

返回值

返回 x 和 y 之间的正差。

如果 x > y，则 fdimf(x, y) 返回 x - y。
如果 x \( \leq \) y，则 fdimf(x, y) 返回 +0。
如果任一参数为 NaN，则返回 NaN。

__device__ float fdividef(float x, float y)

除以两个浮点值。

计算 x 除以 y 的结果。

注意

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

注意

此函数受 use_fast_math 编译器标志的影响。有关受影响函数的完整列表，请参阅 CUDA C++ 编程指南的“数学函数附录”中的“Intrinsic Functions”部分。

返回值

返回 x / y。

默认情况下，遵循常规除法运算行为。
如果指定了 -use_fast_math 且未被显式的 -prec_div=true 修改，则使用 __fdividef() 以获得更高的性能

__device__ float floorf(float x)

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

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

注意

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

返回值

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

floorf( \( \pm \infty \) ) 返回 \( \pm \infty \)。
floorf( \( \pm 0 \) ) 返回 \( \pm 0 \)。
floorf(NaN) 返回 NaN。

__device__ float fmaf(float x, float y, float z)

将 \( x \times y + z \) 作为单个操作计算。

将 \( x \times y + z \) 的值作为单个三元运算计算。在以无限精度计算该值后，使用舍入到最近偶数的舍入模式对该值进行一次舍入。

注意

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

返回值

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

fmaf( \( \pm \infty \) , \( \pm 0 \) , z) 返回 NaN。
fmaf( \( \pm 0 \) , \( \pm \infty \) , z) 返回 NaN。
如果 \( x \times y \) 是精确的 \( +\infty \)，则 fmaf(x, y, \( -\infty \) ) 返回 NaN。
如果 \( x \times y \) 是精确的 \( -\infty \)，则 fmaf(x, y, \( +\infty \) ) 返回 NaN。
如果 \( x \times y \) 是精确的 \( \pm 0 \)，则 fmaf(x, y, \( \pm 0 \)) 返回 \( \pm 0 \)。
如果 \( x \times y \) 是精确的 \( \pm 0 \)，则 fmaf(x, y, \( \mp 0 \)) 返回 \( +0 \)。
如果 \( x \times y + z \) 恰好为零且 \( z \neq 0 \)，则 fmaf(x, y, z) 返回 \( +0 \)。
如果任一参数为 NaN，则返回 NaN。

__device__ float fmaxf(float x, float y)

确定参数的最大数值。

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

注意

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

返回值

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

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

__device__ float fminf(float x, float y)

确定参数的最小数值。

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

注意

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

返回值

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

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

__device__ float fmodf(float x, float y)

计算 x / y 的浮点余数。

计算 x / y 的浮点余数。此函数计算的除法运算 x / y 的浮点余数正好是值 x - n*y，其中 n 是 x / y，其小数部分被截断。计算出的值将与 x 具有相同的符号，并且其幅度将小于 y 的幅度。

注意

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

返回值

返回 x / y 的浮点余数。
如果 y 不为零，则 fmodf( \( \pm 0 \) , y) 返回 \( \pm 0 \)。
如果 x 是有限值，则 fmodf(x, \( \pm \infty \) ) 返回 x。
如果 x 是 \( \pm\infty \) 或 y 是零，则 fmodf(x, y) 返回 NaN。
如果任一参数为 NaN，则返回 NaN。

__device__ float frexpf(float x, int *nptr)

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

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

注意

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

返回值

返回分数部分 m。

frexpf( \( \pm 0 \) , nptr) 返回 \( \pm 0 \)，并在 nptr 指向的位置存储零。
frexpf( \( \pm \infty \) , nptr) 返回 \( \pm \infty \)，并在 nptr 指向的位置存储一个未指定的值。
frexpf(NaN, y) 返回 NaN，并在 nptr 指向的位置存储一个未指定的值。

__device__ float hypotf(float x, float y)

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

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

注意

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

返回值

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

hypotf(x,y)、hypotf(y,x) 和 hypotf(x, -y) 是等价的。
hypotf(x, \( \pm 0 \) ) 等价于 fabsf(x)。
即使 y 是 NaN，hypotf( \( \pm \infty \) ,y) 也返回 \( +\infty \)。
当 y 不是 \( \pm\infty \) 时，hypotf(NaN, y) 返回 NaN。

__device__ int ilogbf(float x)

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

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

注意

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

返回值

如果成功，则返回参数的无偏指数。
ilogbf( \( \pm 0 \) ) 返回 INT_MIN。
ilogbf(NaN) 返回 INT_MIN。
ilogbf( \( \pm \infty \) ) 返回 INT_MAX。
注意：以上行为未考虑 FP_ILOGB0 和 FP_ILOGBNAN。

__device__ __RETURN_TYPE isfinite(float a)

确定参数是否为有限数。

确定浮点值 a 是否为有限值（零、次正规数或正规数，而非无穷大或 NaN）。

返回值

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

__device__ __RETURN_TYPE isinf(float a)

确定参数是否为无穷大。

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

返回值

使用 Visual Studio 2013 主机编译器：__RETURN_TYPE 为 ‘bool’。当且仅当 a 是无穷值时返回 true。
使用其他主机编译器：__RETURN_TYPE 为 ‘int’。当且仅当 a 是无穷值时返回非零值。

__device__ __RETURN_TYPE isnan(float a)

确定参数是否为 NaN。

确定浮点值 a 是否为 NaN。

返回值

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

__device__ float j0f(float x)

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

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

注意

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

返回值

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

j0f( \( \pm \infty \) ) 返回 +0。
j0f(NaN) 返回 NaN。

__device__ float j1f(float x)

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

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

注意

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

返回值

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

j1f( \( \pm 0 \) ) 返回 \( \pm 0 \)。
j1f( \( \pm \infty \) ) 返回 \( \pm 0 \)。
j1f(NaN) 返回 NaN。

__device__ float jnf(int n, float x)

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

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

注意

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

返回值

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

jnf(n, NaN) 返回 NaN。
当 n < 0 时，jnf(n, x) 返回 NaN。
jnf(n, \( +\infty \) ) 返回 +0。

__device__ float ldexpf(float x, int exp)

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

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

注意

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

返回值

ldexpf(x, exp) 等价于 scalbnf(x, exp)。

__device__ float lgammaf(float x)

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

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

注意

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

返回值

lgammaf(1) 返回 +0。
lgammaf(2) 返回 +0。
如果 x \( \leq \) 0 且 x 是整数，则 lgammaf(x) 返回 \( +\infty \)。
lgammaf( \( -\infty \) ) 返回 \( +\infty \)。
lgammaf( \( +\infty \) ) 返回 \( +\infty \)。
lgammaf(NaN) 返回 NaN。

__device__ long long int llrintf(float x)

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

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

返回值: 返回舍入后的整数值。

__device__ long long int llroundf(float x)

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

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

注意

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

返回值: 返回舍入后的整数值。

__device__ float log10f(float x)

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

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

注意

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

注意

此函数受 use_fast_math 编译器标志的影响。有关受影响函数的完整列表，请参阅 CUDA C++ 编程指南的“数学函数附录”中的“Intrinsic Functions”部分。

返回值

log10f( \( \pm 0 \) ) 返回 \( -\infty \)。
log10f(1) 返回 +0。
当 x < 0 时，log10f(x) 返回 NaN。
log10f( \( +\infty \) ) 返回 \( +\infty \)。
log10f(NaN) 返回 NaN。

__device__ float log1pf(float x)

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

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

注意

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

返回值

log1pf( \( \pm 0 \) ) 返回 \( \pm 0 \)。
log1pf(-1) 返回 \( -\infty \)。
当 x < -1 时，log1pf(x) 返回 NaN。
log1pf( \( +\infty \) ) 返回 \( +\infty \)。
log1pf(NaN) 返回 NaN。

__device__ float log2f(float x)

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

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

注意

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

注意

此函数受 use_fast_math 编译器标志的影响。有关受影响函数的完整列表，请参阅 CUDA C++ 编程指南的“数学函数附录”中的“Intrinsic Functions”部分。

返回值

log2f( \( \pm 0 \) ) 返回 \( -\infty \)。
log2f(1) 返回 +0。
当 x < 0 时，log2f(x) 返回 NaN。
log2f( \( +\infty \) ) 返回 \( +\infty \)。
log2f(NaN) 返回 NaN。

__device__ float logbf(float x)

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

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

注意

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

返回值

logbf( \( \pm 0 \) ) 返回 \( -\infty \)。
logbf( \( \pm \infty \) ) 返回 \( +\infty \)。
logbf(NaN) 返回 NaN。

__device__ float logf(float x)

计算输入参数的自然对数。

计算输入参数 x 的自然对数。

注意

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

注意

此函数受 use_fast_math 编译器标志的影响。有关受影响函数的完整列表，请参阅 CUDA C++ 编程指南的“数学函数附录”中的“Intrinsic Functions”部分。

返回值

logf( \( \pm 0 \) ) 返回 \( -\infty \)。
logf(1) 返回 +0。
当 x < 0 时，logf(x) 返回 NaN。
logf( \( +\infty \) ) 返回 \( +\infty \)。
logf(NaN) 返回 NaN。

__device__ long int lrintf(float x)

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

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

返回值: 返回舍入后的整数值。

__device__ long int lroundf(float x)

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

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

注意

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

返回值: 返回舍入后的整数值。

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

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

计算参数 a 和 b 的最大值。行为等同于 fmaxf() 函数。

注意，这与 std:: 规范不同。

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

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

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

注意，这与 std:: 规范不同。

__device__ float modff(float x, float *iptr)

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

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

注意

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

返回值

modff( \( \pm x \) , iptr) 返回与 x 符号相同的结果。
modff( \( \pm \infty \) , iptr) 返回 \( \pm 0 \)，并在 iptr 指向的对象中存储 \( \pm \infty \)。
modff(NaN, iptr) 在 iptr 指向的对象中存储 NaN，并返回 NaN。

__device__ float nanf(const char *tagp)

返回 “非数字 (NaN)” 值。

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

注意

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

返回值

nanf(tagp) 返回 NaN。

__device__ float nearbyintf(float x)

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

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

注意

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

返回值

nearbyintf( \( \pm 0 \) ) 返回 \( \pm 0 \)。
nearbyintf( \( \pm \infty \) ) 返回 \( \pm \infty \)。
nearbyintf(NaN) 返回 NaN。

__device__ float nextafterf(float x, float y)

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

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

注意

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

返回值

如果 x 等于 y，则 nextafterf(x, y) = y。
如果 x 或 y 中任一者为 NaN，则 nextafterf(x, y) = NaN。

__device__ float norm3df(float a, float b, float c)

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

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

注意

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

返回值

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

如果存在精确的无穷坐标，即使存在 NaN，也返回 \( +\infty \)。
当所有坐标均为 \( \pm 0 \) 时，返回 +0。
当至少一个坐标为 NaN 且没有坐标为无穷大时，返回 NaN。

__device__ float norm4df(float a, float b, float c, float d)

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

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

注意

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

返回值

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

如果存在精确的无穷坐标，即使存在 NaN，也返回 \( +\infty \)。
当所有坐标均为 \( \pm 0 \) 时，返回 +0。
当至少一个坐标为 NaN 且没有坐标为无穷大时，返回 NaN。

__device__ float normcdff(float x)

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

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

注意

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

返回值

normcdff( \( +\infty \) ) 返回 1。
normcdff( \( -\infty \) ) 返回 +0
normcdff(NaN) 返回 NaN。

__device__ float normcdfinvf(float x)

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

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

注意

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

返回值

normcdfinvf( \( \pm 0 \) ) 返回 \( -\infty \)。
normcdfinvf(1) 返回 \( +\infty \)。
如果 x 不在区间 [0,1] 内，则 normcdfinvf(x) 返回 NaN。
normcdfinvf(NaN) 返回 NaN。

__device__ float normf(int dim, float const *p)

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

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

注意

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

返回值

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

如果存在精确的无穷坐标，即使存在 NaN，也返回 \( +\infty \)。
当所有坐标均为 \( \pm 0 \) 时，返回 +0。
当至少一个坐标为 NaN 且没有坐标为无穷大时，返回 NaN。

__device__ float powf(float x, float y)

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

计算 x 的 y 次方的值。

注意

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

注意

此函数受 use_fast_math 编译器标志的影响。有关受影响函数的完整列表，请参阅 CUDA C++ 编程指南的“数学函数附录”中的“Intrinsic Functions”部分。

返回值

powf( \( \pm 0 \) , y) 对于 y 是小于 0 的奇数整数时，返回 \( \pm \infty \)。
powf( \( \pm 0 \) , y) 对于 y 小于 0 且不是奇数整数时，返回 \( +\infty \)。
powf( \( \pm 0 \) , y) 对于 y 是大于 0 的奇数整数时，返回 \( \pm 0 \)。
powf( \( \pm 0 \) , y) 对于 y > 0 且不是奇数整数时，返回 +0。
powf(-1, \( \pm \infty \) ) 返回 1。
powf(+1, y) 对于任何 y，甚至包括 NaN，都返回 1。
powf(x, \( \pm 0 \) ) 对于任何 x，甚至包括 NaN，都返回 1。
对于有限的 x < 0 和有限的非整数 y，powf(x, y) 返回 NaN。
对于 \( | x | < 1 \)，powf(x, \( -\infty \) ) 返回 \( +\infty \)。
对于 \( | x | > 1 \)，powf(x, \( -\infty \) ) 返回 +0。
对于 \( | x | < 1 \)，powf(x, \( +\infty \) ) 返回 +0。
对于 \( | x | > 1 \)，powf(x, \( +\infty \) ) 返回 \( +\infty \)。
powf( \( -\infty \) , y) 对于 y 是小于 0 的奇数整数时，返回 -0。
powf( \( -\infty \) , y) 对于 y < 0 且不是奇数整数时，返回 +0。
powf( \( -\infty \) , y) 对于 y 是大于 0 的奇数整数时，返回 \( -\infty \)。
powf( \( -\infty \) , y) 对于 y > 0 且不是奇数整数时，返回 \( +\infty \)。
powf( \( +\infty \) , y) 对于 y < 0 时，返回 +0。
powf( \( +\infty \) , y) 对于 y > 0 时，返回 \( +\infty \)。
如果 x 或 y 或两者都是 NaN，且 x \( \neq \) +1 且 y \( \neq\pm 0 \)，则 powf(x, y) 返回 NaN。

__device__ float rcbrtf(float x)

计算倒数立方根函数。

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

注意

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

返回值

rcbrtf( \( \pm 0 \) ) 返回 \( \pm \infty \)。
rcbrtf( \( \pm \infty \) ) 返回 \( \pm 0 \)。
rcbrtf(NaN) 返回 NaN。

__device__ float remainderf(float x, float y)

计算单精度浮点余数。

对于非零 y，计算 x 除以 y 的单精度浮点余数 r。因此，\( r = x - n y \)。值 n 是最接近 \( \frac{x}{y} \) 的整数值。当 \( | n -\frac{x}{y} | = \frac{1}{2} \) 时，选择偶数 n 值。

注意

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

返回值

remainderf(x, \( \pm 0 \) ) 返回 NaN。
remainderf( \( \pm \infty \) , y) 返回 NaN。
对于有限的 x，remainderf(x, \( \pm \infty \) ) 返回 x。
如果任一参数为 NaN，则返回 NaN。

__device__ float remquof(float x, float y, int *quo)

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

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

注意

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

返回值

返回余数。

remquof(x, \( \pm 0 \) , quo) 返回 NaN，并在 quo 指向的位置存储未指定的值。
remquof( \( \pm \infty \) , y, quo) 返回 NaN，并在 quo 指向的位置存储未指定的值。
如果 x 或 y 中的任何一个是 NaN，则 remquof(x, y, quo) 返回 NaN，并在 quo 指向的位置存储未指定的值。
对于有限的 x，remquof(x, \( \pm \infty \) , quo) 返回 x，并在 quo 指向的位置存储零。

__device__ float rhypotf(float x, float y)

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

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

注意

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

返回值

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

rhypotf(x,y), rhypotf(y,x), 和 rhypotf(x, -y) 是等价的。
rhypotf( \( \pm \infty \) ,y) 返回 +0，即使 y 是 NaN。
rhypotf( \( \pm 0, \pm 0 \)) 返回 \( +\infty \)。
当 y 不是 \( \pm\infty \) 时，rhypotf(NaN, y) 返回 NaN。

__device__ float rintf(float x)

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

将 x 舍入为最接近的整数值（浮点格式），对于中间情况，舍入到最接近的偶数整数值。

返回值

返回舍入后的整数值。

rintf( \( \pm 0 \) ) 返回 \( \pm 0 \)。
rintf( \( \pm \infty \) ) 返回 \( \pm \infty \)。
rintf(NaN) 返回 NaN。

__device__ float rnorm3df(float a, float b, float c)

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

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

注意

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

返回值

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

在存在精确无穷坐标的情况下，即使存在 NaN，也返回 \( +0 \)。
当所有坐标都为 \( \pm 0 \) 时，返回 \( +\infty \)。
当至少一个坐标为 NaN 且没有坐标为无穷大时，返回 NaN。

__device__ float rnorm4df(float a, float b, float c, float d)

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

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

注意

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

返回值

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

在存在精确无穷坐标的情况下，即使存在 NaN，也返回 \( +0 \)。
当所有坐标都为 \( \pm 0 \) 时，返回 \( +\infty \)。
当至少一个坐标为 NaN 且没有坐标为无穷大时，返回 NaN。

__device__ float rnormf(int dim, float const *p)

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

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

注意

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

返回值

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

在存在精确无穷坐标的情况下，即使存在 NaN，也返回 \( +0 \)。
当所有坐标都为 \( \pm 0 \) 时，返回 \( +\infty \)。
当至少一个坐标为 NaN 且没有坐标为无穷大时，返回 NaN。

__device__ float roundf(float x)

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

将 x 舍入为最接近的整数值（浮点格式），对于中间情况，远离零舍入。

注意

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

返回值

返回舍入后的整数值。

roundf( \( \pm 0 \) ) 返回 \( \pm 0 \)。
roundf( \( \pm \infty \) ) 返回 \( \pm \infty \)。
roundf(NaN) 返回 NaN。

__device__ float rsqrtf(float x)

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

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

注意

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

返回值

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

rsqrtf( \( +\infty \) ) 返回 +0。
rsqrtf( \( \pm 0 \) ) 返回 \( \pm \infty \)。
如果 x 小于 0，则 rsqrtf(x) 返回 NaN。
rsqrtf(NaN) 返回 NaN。

__device__ float scalblnf(float x, long int n)

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

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

返回值

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

scalblnf( \( \pm 0 \) , n) 返回 \( \pm 0 \)。
scalblnf(x, 0) 返回 x。
scalblnf( \( \pm \infty \) , n) 返回 \( \pm \infty \)。
scalblnf(NaN, n) 返回 NaN。

__device__ float scalbnf(float x, int n)

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

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

返回值

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

scalbnf( \( \pm 0 \) , n) 返回 \( \pm 0 \)。
scalbnf(x, 0) 返回 x。
scalbnf( \( \pm \infty \) , n) 返回 \( \pm \infty \)。
scalbnf(NaN, n) 返回 NaN。

__device__ __RETURN_TYPE signbit(float a)

返回输入的符号位。

确定浮点值 a 是否为负数。

返回值

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

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

__device__ void sincosf(float x, float *sptr, float *cptr)

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

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

另请参阅

sinf() 和 cosf()。

注意

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

注意

此函数受 use_fast_math 编译器标志的影响。有关受影响函数的完整列表，请参阅 CUDA C++ 编程指南的“数学函数附录”中的“Intrinsic Functions”部分。

__device__ void sincospif(float x, float *sptr, float *cptr)

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

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

另请参阅

sinpif() 和 cospif()。

注意

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

__device__ float sinf(float x)

计算输入参数的正弦值。

计算输入参数 x (以弧度为单位) 的正弦。

注意

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

注意

此函数受 use_fast_math 编译器标志的影响。有关受影响函数的完整列表，请参阅 CUDA C++ 编程指南的“数学函数附录”中的“Intrinsic Functions”部分。

返回值

sinf( \( \pm 0 \) ) 返回 \( \pm 0 \)。
sinf( \( \pm \infty \) ) 返回 NaN。
sinf(NaN) 返回 NaN。

__device__ float sinhf(float x)

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

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

注意

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

返回值

sinhf( \( \pm 0 \) ) 返回 \( \pm 0 \)。
sinhf( \( \pm \infty \) ) 返回 \( \pm \infty \)。
sinhf(NaN) 返回 NaN。

__device__ float sinpif(float x)

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

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

注意

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

返回值

sinpif( \( \pm 0 \) ) 返回 \( \pm 0 \)。
sinpif( \( \pm \infty \) ) 返回 NaN。
sinpif(NaN) 返回 NaN。

__device__ float sqrtf(float x)

计算输入参数的平方根。

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

注意

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

返回值

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

sqrtf( \( \pm 0 \) ) 返回 \( \pm 0 \)。
sqrtf( \( +\infty \) ) 返回 \( +\infty \)。
如果 x 小于 0，则 sqrtf(``x``) 返回 NaN。
sqrtf(NaN) 返回 NaN。

__device__ float tanf(float x)

计算输入参数的正切值。

计算输入参数 x (以弧度为单位) 的正切。

注意

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

注意

此函数受 use_fast_math 编译器标志的影响。有关受影响函数的完整列表，请参阅 CUDA C++ 编程指南的“数学函数附录”中的“Intrinsic Functions”部分。

返回值

tanf( \( \pm 0 \) ) 返回 \( \pm 0 \)。
tanf( \( \pm \infty \) ) 返回 NaN。
tanf(NaN) 返回 NaN。

__device__ float tanhf(float x)

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

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

注意

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

返回值

tanhf( \( \pm 0 \) ) 返回 \( \pm 0 \)。
tanhf( \( \pm \infty \) ) 返回 \( \pm 1 \)。
tanhf(NaN) 返回 NaN。

__device__ float tgammaf(float x)

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

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

注意

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

返回值

tgammaf( \( \pm 0 \) ) 返回 \( \pm \infty \)。
如果 x < 0 且 x 是整数，则 tgammaf(``x``) 返回 NaN。
tgammaf( \( -\infty \) ) 返回 NaN。
tgammaf( \( +\infty \) ) 返回 \( +\infty \)。
tgammaf(NaN) 返回 NaN。

__device__ float truncf(float x)

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

将 x 舍入为最接近的整数值，该值的大小不超过 x。

注意

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

返回值

返回截断的整数值。

truncf( \( \pm 0 \) ) 返回 \( \pm 0 \)。
truncf( \( \pm \infty \) ) 返回 \( \pm \infty \)。
truncf(NaN) 返回 NaN。

__device__ float y0f(float x)

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

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

注意

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

返回值

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

y0f( \( \pm 0 \) ) 返回 \( -\infty \)。
如果 x < 0，则 y0f(``x``) 返回 NaN。
y0f( \( +\infty \) ) 返回 +0。
y0f(NaN) 返回 NaN。

__device__ float y1f(float x)

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

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

注意

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

返回值

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

y1f( \( \pm 0 \) ) 返回 \( -\infty \)。
如果 x < 0，则 y1f(``x``) 返回 NaN。
y1f( \( +\infty \) ) 返回 +0。
y1f(NaN) 返回 NaN。

__device__ float ynf(int n, float x)

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

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

注意

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

返回值

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

如果 n < 0，则 ynf(``n``, ``x``) 返回 NaN。
ynf(``n``, \( \pm 0 \) ) 返回 \( -\infty \)。
如果 x < 0，则 ynf(``n``, ``x``) 返回 NaN。
ynf(``n``, \( +\infty \) ) 返回 +0。
ynf(``n``, NaN) 返回 NaN。