7. 单精度内函数

本节介绍仅在设备代码中支持的单精度内联函数。

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

函数

__device__ float __cosf(float x): 计算输入参数的快速近似余弦值。
__device__ float __exp10f(float x): 计算输入参数的快速近似以 10 为底的指数。
__device__ float __expf(float x): 计算输入参数的快速近似以 \(e\) 为底的指数。
__device__ float2 __fadd2_rd(float2 x, float2 y): 以向下舍入模式计算向量加法运算 \(x + y\) 。
__device__ float2 __fadd2_rn(float2 x, float2 y): 以舍入到最接近的偶数模式计算向量加法运算 \(x + y\) 。
__device__ float2 __fadd2_ru(float2 x, float2 y): 以向上舍入模式计算向量加法运算 \(x + y\) 。
__device__ float2 __fadd2_rz(float2 x, float2 y): 以向零舍入模式计算向量加法运算 \(x + y\) 。
__device__ float __fadd_rd(float x, float y): 以向下舍入模式添加两个浮点值。
__device__ float __fadd_rn(float x, float y): 以舍入到最接近的偶数模式添加两个浮点值。
__device__ float __fadd_ru(float x, float y): 以向上舍入模式添加两个浮点值。
__device__ float __fadd_rz(float x, float y): 以向零舍入模式添加两个浮点值。
__device__ float __fdiv_rd(float x, float y): 以向下舍入模式除以两个浮点值。
__device__ float __fdiv_rn(float x, float y): 以舍入到最接近的偶数模式除以两个浮点值。
__device__ float __fdiv_ru(float x, float y): 以向上舍入模式除以两个浮点值。
__device__ float __fdiv_rz(float x, float y): 以向零舍入模式除以两个浮点值。
__device__ float __fdividef(float x, float y): 计算输入参数的快速近似除法。
__device__ float2 __ffma2_rd(float2 x, float2 y, float2 z): 以向下舍入模式计算向量 fused multiply-add 运算 \(x \times y + z\) 。
__device__ float2 __ffma2_rn(float2 x, float2 y, float2 z): 以舍入到最接近的偶数模式计算向量 fused multiply-add 运算 \(x \times y + z\) 。
__device__ float2 __ffma2_ru(float2 x, float2 y, float2 z): 以向上舍入模式计算向量 fused multiply-add 运算 \(x \times y + z\) 。
__device__ float2 __ffma2_rz(float2 x, float2 y, float2 z): 以向零舍入模式计算向量 fused multiply-add 运算 \(x \times y + z\) 。
__device__ float __fmaf_ieee_rd(float x, float y, float z): 以向下舍入模式计算 fused multiply-add 运算，忽略 -ftz=true 编译器标志。
__device__ float __fmaf_ieee_rn(float x, float y, float z): 以舍入到最接近的偶数模式计算 fused multiply-add 运算，忽略 -ftz=true 编译器标志。
__device__ float __fmaf_ieee_ru(float x, float y, float z): 以向上舍入模式计算 fused multiply-add 运算，忽略 -ftz=true 编译器标志。
__device__ float __fmaf_ieee_rz(float x, float y, float z): 以向零舍入模式计算 fused multiply-add 运算，忽略 -ftz=true 编译器标志。
__device__ float __fmaf_rd(float x, float y, float z): 将 \(x \times y + z\) 作为单个运算以向下舍入模式计算。
__device__ float __fmaf_rn(float x, float y, float z): 将 \(x \times y + z\) 作为单个运算以舍入到最接近的偶数模式计算。
__device__ float __fmaf_ru(float x, float y, float z): 将 \(x \times y + z\) 作为单个运算以向上舍入模式计算。
__device__ float __fmaf_rz(float x, float y, float z): 将 \(x \times y + z\) 作为单个运算以向零舍入模式计算。
__device__ float2 __fmul2_rd(float2 x, float2 y): 以向下舍入模式计算向量乘法运算 \(x \times y\) 。
__device__ float2 __fmul2_rn(float2 x, float2 y): 以舍入到最接近的偶数模式计算向量乘法运算 \(x \times y\) 。
__device__ float2 __fmul2_ru(float2 x, float2 y): 以向上舍入模式计算向量乘法运算 \(x \times y\) 。
__device__ float2 __fmul2_rz(float2 x, float2 y): 以向零舍入模式计算向量乘法运算 \(x \times y\) 。
__device__ float __fmul_rd(float x, float y): 以向下舍入模式乘以两个浮点值。
__device__ float __fmul_rn(float x, float y): 以舍入到最接近的偶数模式乘以两个浮点值。
__device__ float __fmul_ru(float x, float y): 以向上舍入模式乘以两个浮点值。
__device__ float __fmul_rz(float x, float y): 以向零舍入模式乘以两个浮点值。
__device__ float __frcp_rd(float x): 以向下舍入模式计算 \(\frac{1}{x}\) 。
__device__ float __frcp_rn(float x): 以舍入到最接近的偶数模式计算 \(\frac{1}{x}\) 。
__device__ float __frcp_ru(float x): 以向上舍入模式计算 \(\frac{1}{x}\) 。
__device__ float __frcp_rz(float x): 以向零舍入模式计算 \(\frac{1}{x}\) 。
__device__ float __frsqrt_rn(float x): 以舍入到最接近的偶数模式计算 \(1/\sqrt{x}\) 。
__device__ float __fsqrt_rd(float x): 以向下舍入模式计算 \(\sqrt{x}\) 。
__device__ float __fsqrt_rn(float x): 以舍入到最接近的偶数模式计算 \(\sqrt{x}\) 。
__device__ float __fsqrt_ru(float x): 以向上舍入模式计算 \(\sqrt{x}\) 。
__device__ float __fsqrt_rz(float x): 以向零舍入模式计算 \(\sqrt{x}\) 。
__device__ float __fsub_rd(float x, float y): 以向下舍入模式减去两个浮点值。
__device__ float __fsub_rn(float x, float y): 以舍入到最接近的偶数模式减去两个浮点值。
__device__ float __fsub_ru(float x, float y): 以向上舍入模式减去两个浮点值。
__device__ float __fsub_rz(float x, float y): 以向零舍入模式减去两个浮点值。
__device__ float __log10f(float x): 计算输入参数的快速近似以 10 为底的对数。
__device__ float __log2f(float x): 计算输入参数的快速近似以 2 为底的对数。
__device__ float __logf(float x): 计算输入参数的快速近似以 \(e\) 为底的对数。
__device__ float __powf(float x, float y): 计算 \(x^y\) 的快速近似值。
__device__ float __saturatef(float x): 将输入参数钳位到 [+0.0, 1.0]。
__device__ void __sincosf(float x, float *sptr, float *cptr): 计算第一个输入参数的正弦和余弦的快速近似值。
__device__ float __sinf(float x): 计算输入参数的快速近似正弦值。
__device__ float __tanf(float x): 计算输入参数的快速近似正切值。
__device__ float __tanhf(float x): 计算输入参数的快速近似双曲正切值。

7.1. 函数

__device__ float __cosf(float x)

计算输入参数的快速近似余弦值。

计算以弧度为单位的输入参数 x 的快速近似余弦值。

另请参阅

cosf() 以了解更多特殊情况行为规范。

注意

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

返回值: 返回 x 的近似余弦值。

__device__ float __exp10f(float x)

计算输入参数的快速近似以 10 为底的指数。

计算输入参数 x 的快速近似以 10 为底的指数 \( 10^x \)。

另请参阅

exp10f() 以了解更多特殊情况行为规范。

注意

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

返回值: 返回 \( 10^x \) 的近似值。

__device__ float __expf(float x)

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

计算输入参数 x 的快速近似以 \( e \) 为底的指数 \( e^x \)。

另请参阅

expf() 以了解更多特殊情况行为规范。

注意

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

返回值: 返回 \( e^x \) 的近似值。

__device__ float2 __fadd2_rd(float2 x, float2 y)

以向下舍入模式计算向量加法运算 \( x + y \) 。

每个分量的数值行为与 __fadd_rd() 相同。

注意

此内联函数需要计算能力 >= 10.0。

注意

向量变体可能并不总是提供更好的性能。

__device__ float2 __fadd2_rn(float2 x, float2 y)

以舍入到最接近的偶数模式计算向量加法运算 \( x + y \) 。

每个分量的数值行为与 __fadd_rn() 相同。

注意

此内联函数需要计算能力 >= 10.0。

注意

向量变体可能并不总是提供更好的性能。

__device__ float2 __fadd2_ru(float2 x, float2 y)

以向上舍入模式计算向量加法运算 \( x + y \) 。

每个分量的数值行为与 __fadd_ru() 相同。

注意

此内联函数需要计算能力 >= 10.0。

注意

向量变体可能并不总是提供更好的性能。

__device__ float2 __fadd2_rz(float2 x, float2 y)

以向零舍入模式计算向量加法运算 \( x + y \) 。

每个分量的数值行为与 __fadd_rz() 相同。

注意

此内联函数需要计算能力 >= 10.0。

注意

向量变体可能并不总是提供更好的性能。

__device__ float __fadd_rd(float x, float y)

以向下舍入模式添加两个浮点值。

以向下舍入（向负无穷大舍入）模式计算 x 和 y 的和。

注意

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

注意

此操作永远不会合并为单个 multiply-add 指令。

返回值

返回 x + y。

__fadd_rd(x, y) 等效于 __fadd_rd(y, x)。
__fadd_rd(x, \( \pm\infty \)) 对于有限的 x 返回 \( \pm\infty \)。
__fadd_rd( \( \pm\infty \), \( \pm\infty \)) 返回 \( \pm\infty \)。
__fadd_rd( \( \pm\infty \), \( \mp\infty \)) 返回 NaN。
__fadd_rd( \( \pm 0 \), \( \pm 0 \)) 返回 \( \pm 0 \)。
__fadd_rd(x, -x) 对于有限的 x （包括 \( \pm 0 \)）返回 \( -0 \)。
如果任一参数为 NaN，则返回 NaN。

__device__ float __fadd_rn(float x, float y)

以舍入到最接近的偶数模式添加两个浮点值。

以舍入到最接近的偶数舍入模式计算 x 和 y 的和。

注意

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

注意

此操作永远不会合并为单个 multiply-add 指令。

返回值

返回 x + y。

__fadd_rn(x, y) 等效于 __fadd_rn(y, x)。
__fadd_rn(x, \( \pm\infty \)) 对于有限的 x 返回 \( \pm\infty \)。
__fadd_rn( \( \pm\infty \), \( \pm\infty \)) 返回 \( \pm\infty \)。
__fadd_rn( \( \pm\infty \), \( \mp\infty \)) 返回 NaN。
__fadd_rn( \( \pm 0 \), \( \pm 0 \)) 返回 \( \pm 0 \)。
__fadd_rn(x, -x) 对于有限的 x （包括 \( \pm 0 \)）返回 \( +0 \)。
如果任一参数为 NaN，则返回 NaN。

__device__ float __fadd_ru(float x, float y)

以向上舍入模式添加两个浮点值。

以向上舍入（向正无穷大舍入）模式计算 x 和 y 的和。

注意

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

注意

此操作永远不会合并为单个 multiply-add 指令。

返回值

返回 x + y。

__fadd_ru(x, y) 等价于 __fadd_ru(y, x)。
对于有限的 x，__fadd_ru(x, \( \pm\infty \)) 返回 \( \pm\infty \)。
__fadd_ru( \( \pm\infty \), \( \pm\infty \)) 返回 \( \pm\infty \)。
__fadd_ru( \( \pm\infty \), \( \mp\infty \)) 返回 NaN。
__fadd_ru( \( \pm 0 \), \( \pm 0 \)) 返回 \( \pm 0 \)。
对于有限的 x，包括 \( \pm 0 \)，__fadd_ru(x, -x) 返回 \( +0 \)。
如果任一参数为 NaN，则返回 NaN。

__device__ float __fadd_rz(float x, float y)

以向零舍入模式添加两个浮点值。

在向零舍入模式下计算 x 和 y 的和。

注意

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

注意

此操作永远不会合并为单个 multiply-add 指令。

返回值

返回 x + y。

__fadd_rz(x, y) 等价于 __fadd_rz(y, x)。
对于有限的 x，__fadd_rz(x, \( \pm\infty \)) 返回 \( \pm\infty \)。
__fadd_rz( \( \pm\infty \), \( \pm\infty \)) 返回 \( \pm\infty \)。
__fadd_rz( \( \pm\infty \), \( \mp\infty \)) 返回 NaN。
__fadd_rz( \( \pm 0 \), \( \pm 0 \)) 返回 \( \pm 0 \)。
对于有限的 x，包括 \( \pm 0 \)，__fadd_rz(x, -x) 返回 \( +0 \)。
如果任一参数为 NaN，则返回 NaN。

__device__ float __fdiv_rd(float x, float y)

以向下舍入模式除以两个浮点值。

在向下舍入（趋向负无穷）模式下，将两个浮点值 x 除以 y。

注意

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

返回值

返回 x / y。

当输入和结果都不是 NaN 时，商 x / y 的符号是 x 和 y 符号的异或结果。
__fdiv_rd( \( \pm 0 \), \( \pm 0 \)) 返回 NaN。
__fdiv_rd( \( \pm\infty \), \( \pm\infty \)) 返回 NaN。
对于有限的 x，__fdiv_rd(x, \( \pm\infty \)) 返回符号正确的 \( 0 \)。
对于有限的 y，__fdiv_rd( \( \pm\infty \), y) 返回符号正确的 \( \infty \)。
对于 x \( \neq 0 \)，__fdiv_rd(x, \( \pm 0 \)) 返回符号正确的 \( \infty \)。
对于 y \( \neq 0 \)，__fdiv_rd( \( \pm 0 \), y) 返回符号正确的 \( 0 \)。
如果任一参数为 NaN，则返回 NaN。

__device__ float __fdiv_rn(float x, float y)

以舍入到最接近的偶数模式除以两个浮点值。

在舍入到最接近的偶数模式下，将两个浮点值 x 除以 y。

注意

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

返回值

返回 x / y。

当输入和结果都不是 NaN 时，商 x / y 的符号是 x 和 y 符号的异或结果。
__fdiv_rn( \( \pm 0 \), \( \pm 0 \)) 返回 NaN。
__fdiv_rn( \( \pm\infty \), \( \pm\infty \)) 返回 NaN。
对于有限的 x，__fdiv_rn(x, \( \pm\infty \)) 返回符号正确的 \( 0 \)。
对于有限的 y，__fdiv_rn( \( \pm\infty \), y) 返回符号正确的 \( \infty \)。
对于 x \( \neq 0 \)，__fdiv_rn(x, \( \pm 0 \)) 返回符号正确的 \( \infty \)。
对于 y \( \neq 0 \)，__fdiv_rn( \( \pm 0 \), y) 返回符号正确的 \( 0 \)。
如果任一参数为 NaN，则返回 NaN。

__device__ float __fdiv_ru(float x, float y)

以向上舍入模式除以两个浮点值。

在向上舍入（趋向正无穷）模式下，将两个浮点值 x 除以 y。

注意

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

返回值

返回 x / y。

当输入和结果都不是 NaN 时，商 x / y 的符号是 x 和 y 符号的异或结果。
__fdiv_ru( \( \pm 0 \), \( \pm 0 \)) 返回 NaN。
__fdiv_ru( \( \pm\infty \), \( \pm\infty \)) 返回 NaN。
对于有限的 x，__fdiv_ru(x, \( \pm\infty \)) 返回符号正确的 \( 0 \)。
对于有限的 y，__fdiv_ru( \( \pm\infty \), y) 返回符号正确的 \( \infty \)。
对于 x \( \neq 0 \)，__fdiv_ru(x, \( \pm 0 \)) 返回符号正确的 \( \infty \)。
对于 y \( \neq 0 \)，__fdiv_ru( \( \pm 0 \), y) 返回符号正确的 \( 0 \)。
如果任一参数为 NaN，则返回 NaN。

__device__ float __fdiv_rz(float x, float y)

以向零舍入模式除以两个浮点值。

在向零舍入模式下，将两个浮点值 x 除以 y。

注意

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

返回值

返回 x / y。

当输入和结果都不是 NaN 时，商 x / y 的符号是 x 和 y 符号的异或结果。
__fdiv_rz( \( \pm 0 \), \( \pm 0 \)) 返回 NaN。
__fdiv_rz( \( \pm\infty \), \( \pm\infty \)) 返回 NaN。
对于有限的 x，__fdiv_rz(x, \( \pm\infty \)) 返回符号正确的 \( 0 \)。
对于有限的 y，__fdiv_rz( \( \pm\infty \), y) 返回符号正确的 \( \infty \)。
对于 x \( \neq 0 \)，__fdiv_rz(x, \( \pm 0 \)) 返回符号正确的 \( \infty \)。
对于 y \( \neq 0 \)，__fdiv_rz( \( \pm 0 \), y) 返回符号正确的 \( 0 \)。
如果任一参数为 NaN，则返回 NaN。

__device__ float __fdividef(float x, float y)

计算输入参数的快速近似除法。

计算 x 除以 y 的快速近似除法。

另请参阅

有关进一步的特殊情况行为规范，请参考 __fdiv_rn()。

注意

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

返回值

返回 x / y。

对于 \( 2^{126} < |y| < 2^{128} \)，__fdividef( \( \infty \) , y) 返回 NaN。
对于 \( 2^{126} < |y| < 2^{128} \) 和有限的 \( x \)，__fdividef(x, y) 返回 0。

__device__ float2 __ffma2_rd(float2 x, float2 y, float2 z)

在向下舍入模式下计算向量 fused multiply-add 操作 \( x \times y + z \)。

每个分量的数值行为与 __fmaf_rd() 相同。

注意

此内联函数需要计算能力 >= 10.0。

注意

向量变体可能并不总是提供更好的性能。

__device__ float2 __ffma2_rn(float2 x, float2 y, float2 z)

在舍入到最接近的偶数模式下计算向量 fused multiply-add 操作 \( x \times y + z \)。

每个分量的数值行为与 __fmaf_rn() 相同。

注意

此内联函数需要计算能力 >= 10.0。

注意

向量变体可能并不总是提供更好的性能。

__device__ float2 __ffma2_ru(float2 x, float2 y, float2 z)

在向上舍入模式下计算向量 fused multiply-add 操作 \( x \times y + z \)。

每个分量的数值行为与 __fmaf_ru() 相同。

注意

此内联函数需要计算能力 >= 10.0。

注意

向量变体可能并不总是提供更好的性能。

__device__ float2 __ffma2_rz(float2 x, float2 y, float2 z)

在向零舍入模式下计算向量 fused multiply-add 操作 \( x \times y + z \)。

每个分量的数值行为与 __fmaf_rz() 相同。

注意

此内联函数需要计算能力 >= 10.0。

注意

向量变体可能并不总是提供更好的性能。

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

以向下舍入模式计算 fused multiply-add 运算，忽略 -ftz=true 编译器标志。

行为与 __fmaf_rd(x, y, z) 相同，区别在于处理非规范化输入和输出：-ftz 编译器标志无效。

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

以舍入到最接近的偶数模式计算 fused multiply-add 运算，忽略 -ftz=true 编译器标志。

行为与 __fmaf_rn(x, y, z) 相同，区别在于处理非规范化输入和输出：-ftz 编译器标志无效。

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

以向上舍入模式计算 fused multiply-add 运算，忽略 -ftz=true 编译器标志。

行为与 __fmaf_ru(x, y, z) 相同，区别在于处理非规范化输入和输出：-ftz 编译器标志无效。

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

以向零舍入模式计算 fused multiply-add 运算，忽略 -ftz=true 编译器标志。

行为与 __fmaf_rz(x, y, z) 相同，区别在于处理非规范化输入和输出：-ftz 编译器标志无效。

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

在向下舍入模式下，将 \( x \times y + z \) 计算为单个操作。

将 \( x \times y + z \) 的值计算为单个三元运算，并在向下舍入（趋向负无穷）模式下对结果进行一次舍入。

注意

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

返回值

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

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

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

在舍入到最接近的偶数模式下，将 \( x \times y + z \) 计算为单个操作。

将 \( x \times y + z \) 的值计算为单个三元运算，并在舍入到最接近的偶数模式下对结果进行一次舍入。

注意

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

返回值

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

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

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

计算 \( x \times y + z \) 作为单个操作，在向上舍入模式中。

计算 \( x \times y + z \) 的值作为单个三元运算，在向上（向正无穷大）舍入模式中对结果进行一次舍入。

注意

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

返回值

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

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

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

计算 \( x \times y + z \) 作为单个操作，在向零舍入模式中。

计算 \( x \times y + z \) 的值作为单个三元运算，在向零舍入模式中对结果进行一次舍入。

注意

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

返回值

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

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

__device__ float2 __fmul2_rd(float2 x, float2 y)

计算向量乘法运算 \( x \times y \)，在向下舍入模式中。

每个组件的数值行为与 __fmul_rd() 相同。

注意

此内联函数需要计算能力 >= 10.0。

注意

向量变体可能并不总是提供更好的性能。

__device__ float2 __fmul2_rn(float2 x, float2 y)

计算向量乘法运算 \( x \times y \)，在舍入到最接近的偶数模式中。

每个组件的数值行为与 __fmul_rn() 相同。

注意

此内联函数需要计算能力 >= 10.0。

注意

向量变体可能并不总是提供更好的性能。

__device__ float2 __fmul2_ru(float2 x, float2 y)

计算向量乘法运算 \( x \times y \)，在向上舍入模式中。

每个组件的数值行为与 __fmul_ru() 相同。

注意

此内联函数需要计算能力 >= 10.0。

注意

向量变体可能并不总是提供更好的性能。

__device__ float2 __fmul2_rz(float2 x, float2 y)

计算向量乘法运算 \( x \times y \)，在向零舍入模式中。

每个组件的数值行为与 __fmul_rz() 相同。

注意

此内联函数需要计算能力 >= 10.0。

注意

向量变体可能并不总是提供更好的性能。

__device__ float __fmul_rd(float x, float y)

以向下舍入模式乘以两个浮点值。

在向下（向负无穷大）舍入模式中计算 x 和 y 的乘积。

注意

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

注意

此操作永远不会合并为单个 multiply-add 指令。

返回值

返回 x * y。

当输入和结果都不是 NaN 时，乘积 x * y 的符号是 x 和 y 符号的异或。
__fmul_rd(x, y) 等价于 __fmul_rd(y, x)。
__fmul_rd(x, \( \pm\infty \)) 对于 x \( \neq 0 \) 返回具有适当符号的 \( \infty \)。
__fmul_rd( \( \pm 0 \), \( \pm\infty \)) 返回 NaN。
__fmul_rd( \( \pm 0 \), y) 对于有限的 y 返回具有适当符号的 \( 0 \)。
如果任一参数为 NaN，则返回 NaN。

__device__ float __fmul_rn(float x, float y)

以舍入到最接近的偶数模式乘以两个浮点值。

在舍入到最接近的偶数模式中计算 x 和 y 的乘积。

注意

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

注意

此操作永远不会合并为单个 multiply-add 指令。

返回值

返回 x * y。

当输入和结果都不是 NaN 时，乘积 x * y 的符号是 x 和 y 符号的异或。
__fmul_rn(x, y) 等价于 __fmul_rn(y, x)。
__fmul_rn(x, \( \pm\infty \)) 对于 x \( \neq 0 \) 返回具有适当符号的 \( \infty \)。
__fmul_rn( \( \pm 0 \), \( \pm\infty \)) 返回 NaN。
__fmul_rn( \( \pm 0 \), y) 对于有限的 y 返回具有适当符号的 \( 0 \)。
如果任一参数为 NaN，则返回 NaN。

__device__ float __fmul_ru(float x, float y)

以向上舍入模式乘以两个浮点值。

在向上（向正无穷大）舍入模式中计算 x 和 y 的乘积。

注意

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

注意

此操作永远不会合并为单个 multiply-add 指令。

返回值

返回 x * y。

当输入和结果都不是 NaN 时，乘积 x * y 的符号是 x 和 y 符号的异或。
__fmul_ru(x, y) 等价于 __fmul_ru(y, x)。
__fmul_ru(x, \( \pm\infty \)) 对于 x \( \neq 0 \) 返回具有适当符号的 \( \infty \)。
__fmul_ru( \( \pm 0 \), \( \pm\infty \)) 返回 NaN。
__fmul_ru( \( \pm 0 \), y) 对于有限的 y 返回具有适当符号的 \( 0 \)。
如果任一参数为 NaN，则返回 NaN。

__device__ float __fmul_rz(float x, float y)

以向零舍入模式乘以两个浮点值。

在向零舍入模式中计算 x 和 y 的乘积。

注意

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

注意

此操作永远不会合并为单个 multiply-add 指令。

返回值

返回 x * y。

当输入和结果都不是 NaN 时，乘积 x * y 的符号是 x 和 y 符号的异或。
__fmul_rz(x, y) 等价于 __fmul_rz(y, x)。
__fmul_rz(x, \( \pm\infty \)) 对于 x \( \neq 0 \) 返回具有适当符号的 \( \infty \)。
__fmul_rz( \( \pm 0 \), \( \pm\infty \)) 返回 NaN。
__fmul_rz( \( \pm 0 \), y) 对于有限的 y 返回具有适当符号的 \( 0 \)。
如果任一参数为 NaN，则返回 NaN。

__device__ float __frcp_rd(float x)

在向下舍入模式中计算 \( \frac{1}{x} \)。

在向下（向负无穷大）舍入模式中计算 x 的倒数。

注意

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

返回值

返回 \( \frac{1}{x} \)。

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

__device__ float __frcp_rn(float x)

在舍入到最接近的偶数模式中计算 \( \frac{1}{x} \)。

在舍入到最接近的偶数模式中计算 x 的倒数。

注意

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

返回值

返回 \( \frac{1}{x} \)。

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

__device__ float __frcp_ru(float x)

在向上舍入模式中计算 \( \frac{1}{x} \)。

在向上（向正无穷大）舍入模式中计算 x 的倒数。

注意

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

返回值

返回 \( \frac{1}{x} \)。

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

__device__ float __frcp_rz(float x)

在向零舍入模式中计算 \( \frac{1}{x} \)。

在向零舍入模式中计算 x 的倒数。

注意

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

返回值

返回 \( \frac{1}{x} \)。

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

__device__ float __frsqrt_rn(float x)

在舍入到最接近的偶数模式中计算 \( 1/\sqrt{x} \)。

在舍入到最接近的偶数模式中计算 x 的倒数平方根。

注意

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

返回值

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

__frsqrt_rn( \( \pm 0 \)) 返回 \( \pm\infty \)。
__frsqrt_rn( \( +\infty \)) 返回 \( +0 \)。
__frsqrt_rn(x) 对于 x < 0 返回 NaN。
__frsqrt_rn(NaN) 返回 NaN。

__device__ float __fsqrt_rd(float x)

在向下舍入模式中计算 \( \sqrt{x} \)。

在向下（向负无穷大）舍入模式中计算 x 的平方根。

注意

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

返回值

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

__fsqrt_rd( \( \pm 0 \)) 返回 \( \pm 0 \)。
__fsqrt_rd( \( +\infty \)) 返回 \( +\infty \)。
__fsqrt_rd(x) 对于 x < 0 返回 NaN。
__fsqrt_rd(NaN) 返回 NaN。

__device__ float __fsqrt_rn(float x)

在舍入到最接近的偶数模式中计算 \( \sqrt{x} \)。

在舍入到最接近的偶数模式中计算 x 的平方根。

注意

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

返回值

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

__fsqrt_rn( \( \pm 0 \)) 返回 \( \pm 0 \)。
__fsqrt_rn( \( +\infty \)) 返回 \( +\infty \)。
__fsqrt_rn(x) 对于 x < 0 返回 NaN。
__fsqrt_rn(NaN) 返回 NaN。

__device__ float __fsqrt_ru(float x)

在向上舍入模式中计算 \( \sqrt{x} \)。

在向上（向正无穷大）舍入模式中计算 x 的平方根。

注意

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

返回值

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

__fsqrt_ru( \( \pm 0 \)) 返回 \( \pm 0 \)。
__fsqrt_ru( \( +\infty \)) 返回 \( +\infty \)。
__fsqrt_ru(x) 对于 x < 0 返回 NaN。
__fsqrt_ru(NaN) 返回 NaN。

__device__ float __fsqrt_rz(float x)

在向零舍入模式中计算 \( \sqrt{x} \)。

在向零舍入模式中计算 x 的平方根。

注意

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

返回值

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

__fsqrt_rz( \( \pm 0 \)) 返回 \( \pm 0 \)。
__fsqrt_rz( \( +\infty \)) 返回 \( +\infty \)。
__fsqrt_rz(x) 对于 x < 0 返回 NaN。
__fsqrt_rz(NaN) 返回 NaN。

__device__ float __fsub_rd(float x, float y)

以向下舍入模式减去两个浮点值。

在向下（向负无穷大）舍入模式中计算 x 和 y 的差。

注意

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

注意

此操作永远不会合并为单个 multiply-add 指令。

返回值

返回 x - y。

__fsub_rd( \( \pm\infty \), y) 对于有限的 y 返回 \( \pm\infty \)。
__fsub_rd(x, \( \pm\infty \)) 对于有限的 x 返回 \( \mp\infty \)。
__fsub_rd( \( \pm\infty \), \( \pm\infty \)) 返回 NaN。
__fsub_rd( \( \pm\infty \), \( \mp\infty \)) 返回 \( \pm\infty \)。
__fsub_rd( \( \pm 0 \), \( \mp 0 \)) 返回 \( \pm 0 \)。
__fsub_rd(x, x) 对于有限的 x （包括 \( \pm 0 \)）返回 \( -0 \)。
如果任一参数为 NaN，则返回 NaN。

__device__ float __fsub_rn(float x, float y)

以舍入到最接近的偶数模式减去两个浮点值。

在舍入到最接近的偶数舍入模式中计算 x 和 y 的差。

注意

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

注意

此操作永远不会合并为单个 multiply-add 指令。

返回值

返回 x - y。

__fsub_rn( \( \pm\infty \), y) 对于有限的 y 返回 \( \pm\infty \)。
__fsub_rn(x, \( \pm\infty \)) 对于有限的 x 返回 \( \mp\infty \)。
__fsub_rn( \( \pm\infty \), \( \pm\infty \)) 返回 NaN。
__fsub_rn( \( \pm\infty \), \( \mp\infty \)) 返回 \( \pm\infty \)。
__fsub_rn( \( \pm 0 \), \( \mp 0 \)) 返回 \( \pm 0 \)。
__fsub_rn(x, x) 对于有限的 x （包括 \( \pm 0 \)）返回 \( +0 \)。
如果任一参数为 NaN，则返回 NaN。

__device__ float __fsub_ru(float x, float y)

以向上舍入模式减去两个浮点值。

在向上（向正无穷大）舍入模式中计算 x 和 y 的差。

注意

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

注意

此操作永远不会合并为单个 multiply-add 指令。

返回值

返回 x - y。

__fsub_ru( \( \pm\infty \), y) 对于有限的 y 返回 \( \pm\infty \)。
__fsub_ru(x, \( \pm\infty \)) 对于有限的 x 返回 \( \mp\infty \)。
__fsub_ru( \( \pm\infty \), \( \pm\infty \)) 返回 NaN。
__fsub_ru( \( \pm\infty \), \( \mp\infty \)) 返回 \( \pm\infty \)。
__fsub_ru( \( \pm 0 \), \( \mp 0 \)) 返回 \( \pm 0 \)。
__fsub_ru(x, x) 对于有限的 x（包括 \( \pm 0 \)）返回 \( +0 \)。
如果任一参数为 NaN，则返回 NaN。

__device__ float __fsub_rz(float x, float y)

以向零舍入模式减去两个浮点值。

以向零舍入模式计算 x 和 y 的差值。

注意

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

注意

此操作永远不会合并为单个 multiply-add 指令。

返回值

返回 x - y。

__fsub_rz( \( \pm\infty \), y) 对于有限的 y 返回 \( \pm\infty \)。
__fsub_rz(x, \( \pm\infty \)) 对于有限的 x 返回 \( \mp\infty \)。
__fsub_rz( \( \pm\infty \), \( \pm\infty \)) 返回 NaN。
__fsub_rz( \( \pm\infty \), \( \mp\infty \)) 返回 \( \pm\infty \)。
__fsub_rz( \( \pm 0 \), \( \mp 0 \)) 返回 \( \pm 0 \)。
__fsub_rz(x, x) 对于有限的 x（包括 \( \pm 0 \)）返回 \( +0 \)。
如果任一参数为 NaN，则返回 NaN。

__device__ float __log10f(float x)

计算输入参数的快速近似以 10 为底的对数。

计算输入参数 x 的快速近似以 10 为底的对数。

另请参阅

log10f() 有关更详细的特殊情况行为规范，请参阅。

注意

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

返回值: 返回 \( \log_{10}(x) \) 的近似值。

__device__ float __log2f(float x)

计算输入参数的快速近似以 2 为底的对数。

计算输入参数 x 的快速近似以 2 为底的对数。

另请参阅

log2f() 有关更详细的特殊情况行为规范，请参阅。

注意

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

返回值: 返回 \( \log_2(x) \) 的近似值。

__device__ float __logf(float x)

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

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

另请参阅

logf() 有关更详细的特殊情况行为规范，请参阅。

注意

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

返回值: 返回 \( \log_e(x) \) 的近似值。

__device__ float __powf(float x, float y)

计算 \( x^y \) 的快速近似值。

计算第一个输入参数 x 的快速近似值，该值是第二个输入参数 y 的幂，即 \( x^y \)。

注意

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

返回值: 返回 \( x^y \) 的近似值。

__device__ float __saturatef(float x)

将输入参数钳位到 [+0.0, 1.0]。

将输入参数 x 钳位到 [+0.0, 1.0] 区间内。

返回值

如果 \( x \le 0 \)，则 __saturatef(x) 返回 +0。
如果 \( x \ge 1 \)，则 __saturatef(x) 返回 1。
如果 \( 0 < x < 1 \)，则 __saturatef(x) 返回 x。
__saturatef(NaN) 返回 +0。

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

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

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

另请参阅

__sinf() 和 __cosf()。

注意

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

注意

反常值输入/输出被刷新为保留符号的 0.0。

__device__ float __sinf(float x)

计算输入参数的快速近似正弦值。

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

另请参阅

sinf() 有关更详细的特殊情况行为规范，请参阅。

注意

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

注意

反常值范围内的输出被刷新为保留符号的 0.0。

返回值: 返回 x 的近似正弦值。

__device__ float __tanf(float x)

计算输入参数的快速近似正切值。

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

注意

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

注意

结果通过 __sinf() 除以 __cosf() 的快速除法计算得出。反常值输出被刷新为保留符号的 0.0。

返回值: 返回 x 的近似正切值。

__device__ float __tanhf(float x)

计算输入参数的快速近似双曲正切值。

计算输入参数 x（以弧度为单位）的快速近似双曲正切值。

另请参阅

tanhf() 有关更详细的特殊情况行为规范，请参阅。

注意

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

返回值: 返回 x 的近似双曲正切值。