7. 单精度内置函数

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

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

Functions

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

在向下舍入模式下计算向量融合乘加运算 \(x \times y + z\)。

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

在四舍五入到最近偶数模式下计算向量融合乘加运算 \(x \times y + z\)。

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

在向上舍入模式下计算向量融合乘加运算 \(x \times y + z\)。

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

在向零舍入模式下计算向量融合乘加运算 \(x \times y + z\)。

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

在向下舍入模式下计算融合乘加运算，忽略-ftz=true编译器标志。

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

在四舍五入到最近偶数模式下计算融合乘加运算，忽略-ftz=true编译器标志。

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

在向上舍入模式下计算融合乘加运算，忽略-ftz=true编译器标志。

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

在向零舍入模式下计算融合乘加运算，忽略-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++编程指南》的数学函数附录中的内建函数章节。

Returns

返回 x 的近似余弦值。

__device__ float __exp10f(float x)

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

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

另请参阅

exp10f() 的更多特殊用例行为规范。

注意

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

Returns

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

__device__ float __expf(float x)

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

计算输入参数 x 的快速近似自然指数函数值 \( e^x \)。

另请参阅

expf() 用于进一步的特殊情况行为规范。

注意

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

Returns

返回\( 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++编程指南》的数学函数附录中的内建函数章节。

注意

此操作永远不会被合并为单一的乘加指令。

Returns

返回 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++编程指南的数学函数附录中的内建函数部分。

注意

此操作永远不会被合并为单一的乘加指令。

Returns

返回 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 返回 \( +0 \)，包括 \( \pm 0 \)。

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

__device__ float __fadd_ru(float x, float y)

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

以向上取整（向正无穷方向）模式计算x和y的和。

注意

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

注意

此操作永远不会被合并为单一的乘加指令。

Returns

返回 x + y。

• __fadd_ru(x, y) 等价于 __fadd_ru(y, x)。

• __fadd_ru(x, \( \pm\infty \)) 对于有限值 x 返回 \( \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 \).

• __fadd_ru(x, -x) 对于有限值 x（包括 \( \pm 0 \)）返回 \( +0 \)。

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

__device__ float __fadd_rz(float x, float y)

在向零舍入模式下添加两个浮点数值。

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

注意

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

注意

此操作永远不会被合并为单一的乘加指令。

Returns

返回 x + y。

• __fadd_rz(x, y) 等价于 __fadd_rz(y, x)。

• __fadd_rz(x, \( \pm\infty \)) 对于有限值 x 返回 \( \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 \)。

• __fadd_rz(x, -x) 对于有限值 x 返回 \( +0 \)，包括 \( \pm 0 \)。

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

__device__ float __fdiv_rd(float x, float y)

以向下取整模式对两个浮点数值进行除法运算。

将两个浮点数值 x 除以 y，采用向下取整（趋向负无穷）模式。

注意

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

Returns

返回 x / y。

• 当输入和结果都不是NaN时，商数x / y的符号是x和y符号的异或结果。

• __fdiv_rd( \( \pm 0 \), \( \pm 0 \)) 返回 NaN。

• __fdiv_rd( \( \pm\infty \), \( \pm\infty \)) 返回 NaN。

• __fdiv_rd(x, \( \pm\infty \)) 对于有限值的 x 返回适当符号的 \( 0 \)。

• __fdiv_rd( \( \pm\infty \), y) 对于有限的y返回适当符号的\( \infty \)。

• __fdiv_rd(x, \( \pm 0 \)) 对于非零的 x 返回适当符号的 \( \infty \)。

• __fdiv_rd( \( \pm 0 \), y) 当 y \( \neq 0 \) 时返回适当符号的 \( 0 \)。

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

__device__ float __fdiv_rn(float x, float y)

以四舍五入到最接近的偶数模式对两个浮点值进行除法运算。

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

注意

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

Returns

返回 x / y。

• 当输入和结果都不是NaN时，商数x / y的符号是x和y符号的异或结果。

• __fdiv_rn( \( \pm 0 \), \( \pm 0 \)) 返回 NaN。

• __fdiv_rn( \( \pm\infty \), \( \pm\infty \)) 返回 NaN。

• __fdiv_rn(x, \( \pm\infty \)) 对于有限值 x 返回具有适当符号的 \( 0 \)。

• __fdiv_rn( \( \pm\infty \), y) 对于有限的 y 返回适当符号的 \( \infty \)。

• __fdiv_rn(x, \( \pm 0 \)) 对于非零的x返回相应符号的\( \infty \)。

• __fdiv_rn( \( \pm 0 \), y) 当 y \( \neq 0 \) 时返回适当符号的 \( 0 \)。

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

__device__ float __fdiv_ru(float x, float y)

以向上取整模式对两个浮点数值进行除法运算。

将两个浮点数值 x 除以 y，采用向上取整（向正无穷大）模式。

注意

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

Returns

返回 x / y。

• 当输入和结果都不是NaN时，商数x / y的符号是x和y符号的异或结果。

• __fdiv_ru( \( \pm 0 \), \( \pm 0 \)) 返回 NaN。

• __fdiv_ru( \( \pm\infty \), \( \pm\infty \)) 返回 NaN。

• __fdiv_ru(x, \( \pm\infty \)) 对于有限值的 x 返回适当符号的 \( 0 \)。

• __fdiv_ru( \( \pm\infty \), y) 对于有限的 y 返回适当符号的 \( \infty \)。

• __fdiv_ru(x, \( \pm 0 \)) 对于非零的x返回适当符号的\( \infty \)。

• __fdiv_ru( \( \pm 0 \), y) 当 y \( \neq 0 \) 时返回适当符号的 \( 0 \)。

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

__device__ float __fdiv_rz(float x, float y)

以向零舍入模式对两个浮点值进行除法运算。

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

注意

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

Returns

返回 x / y。

• 当输入和结果都不是NaN时，商数x / y的符号是x和y符号的异或结果。

• __fdiv_rz( \( \pm 0 \), \( \pm 0 \)) 返回 NaN。

• __fdiv_rz( \( \pm\infty \), \( \pm\infty \)) 返回 NaN。

• __fdiv_rz(x, \( \pm\infty \)) 对于有限值 x 返回符号正确的 \( 0 \)。

• __fdiv_rz( \( \pm\infty \), y) 对于有限的 y 返回适当符号的 \( \infty \)。

• __fdiv_rz(x, \( \pm 0 \)) 对于非零的x返回相应符号的\( \infty \)。

• __fdiv_rz( \( \pm 0 \), y) 当 y \( \neq 0 \) 时返回适当符号的 \( 0 \)。

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

__device__ float __fdividef(float x, float y)

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

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

另请参阅

__fdiv_rn() 了解更多特殊情况的详细行为规范。

注意

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

Returns

返回 x / y。

• __fdividef( \( \infty \) , y) 当 \( 2^{126} < |y| < 2^{128} \) 时返回 NaN。

• __fdividef(x, y) 当 \( 2^{126} < |y| < 2^{128} \) 且 \( x \) 为有限值时返回0。

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

在向下舍入模式下计算向量融合乘加运算 \( x \times y + z \)。

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

注意

此功能要求计算能力 >= 10.0。

注意

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

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

在四舍五入到最近偶数模式下计算向量融合乘加运算 \( x \times y + z \)。

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

注意

此功能要求计算能力 >= 10.0。

注意

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

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

在向上取整模式下计算向量融合乘加运算 \( x \times y + z \)。

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

注意

此功能要求计算能力 >= 10.0。

注意

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

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

在向零舍入模式下计算向量融合乘加运算 \( x \times y + z \)。

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

注意

此功能要求计算能力 >= 10.0。

注意

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

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

在向下舍入模式下计算融合乘加运算，忽略-ftz=true编译器标志。

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

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

在四舍五入到最近偶数模式下计算融合乘加运算，忽略-ftz=true编译器标志。

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

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

在向上取整模式下计算融合乘加运算，忽略-ftz=true编译器标志。

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

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

在向零舍入模式下计算融合乘加运算，忽略-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++编程指南》的数学函数附录中的内建函数章节。

Returns

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

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

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

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

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

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

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

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

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

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

以四舍五入到最近偶数模式，将\( x \times y + z \)作为单次运算计算。

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

注意

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

Returns

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

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

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

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

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

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

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

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

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

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

以向上取整模式，将\( x \times y + z \)作为单一运算进行计算。

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

注意

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

Returns

返回\( 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 \)) 当 \( x \times y \) 精确等于 \( \pm 0 \) 时返回 \( \pm 0 \)。

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

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

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

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

以向零舍入模式计算 \( x \times y + z \) 作为单次运算。

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

注意

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

Returns

返回\( 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 \)) 当 \( x \times y \) 精确等于 \( \pm 0 \) 时返回 \( \pm 0 \)。

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

• __fmaf_rz(x, y, z) 当\( x \times y + z \)精确等于零且\( z \neq 0 \)时返回\( +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++编程指南》的数学函数附录中的内建函数章节。

注意

此操作永远不会被合并为单一的乘加指令。

Returns

返回 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++编程指南》的数学函数附录中的内建函数章节。

注意

此操作永远不会被合并为单一的乘加指令。

Returns

返回 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++编程指南》的数学函数附录中的内建函数章节。

注意

此操作永远不会被合并为单一的乘加指令。

Returns

返回 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++编程指南》的数学函数附录中的内建函数章节。

注意

此操作永远不会被合并为单一的乘加指令。

Returns

返回 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++编程指南》的数学函数附录中的内建函数章节。

Returns

返回 \( \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++编程指南》的数学函数附录中的内建函数章节。

Returns

返回 \( \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++编程指南》的数学函数附录中的内建函数章节。

Returns

返回 \( \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++编程指南》的数学函数附录中的内建函数章节。

Returns

返回 \( \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++编程指南》的数学函数附录中的内建函数章节。

Returns

返回 \( 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++编程指南》的数学函数附录中的内建函数章节。

Returns

返回 \( \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++编程指南》的数学函数附录中的内建函数章节。

Returns

返回 \( \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++编程指南》的数学函数附录中的内建函数章节。

Returns

返回 \( \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++编程指南》的数学函数附录中的内建函数章节。

Returns

返回 \( \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++编程指南》的数学函数附录中的内建函数章节。

注意

此操作永远不会被合并为单一的乘加指令。

Returns

返回 x 减去 y。

• __fsub_rd( \( \pm\infty \), y) 对于有限的 y 返回 \( \pm\infty \)。

• 对于有限值x，__fsub_rd(x, \( \pm\infty \))返回\( \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返回\( -0 \)，包括\( \pm 0 \)。

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

__device__ float __fsub_rn(float x, float y)

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

在四舍五入到最接近偶数的舍入模式下计算x和y的差值。

注意

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

注意

此操作永远不会被合并为单一的乘加指令。

Returns

返回 x 减去 y。

• __fsub_rn( \( \pm\infty \), y) 对于有限值的 y 返回 \( \pm\infty \)。

• 对于有限值x，__fsub_rn(x, \( \pm\infty \))返回\( \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 返回 \( +0 \)，包括 \( \pm 0 \)。

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

__device__ float __fsub_ru(float x, float y)

在向上舍入模式下减去两个浮点数值。

计算x和y在向上取整(到正无穷大)模式下的差值。

注意

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

注意

此操作永远不会被合并为单一的乘加指令。

Returns

返回 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 返回 \( +0 \)，包括 \( \pm 0 \)。

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

__device__ float __fsub_rz(float x, float y)

在向零舍入模式下减去两个浮点数值。

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

注意

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

注意

此操作永远不会被合并为单一的乘加指令。

Returns

返回 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 返回 \( +0 \)，包括 \( \pm 0 \)。

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

__device__ float __log10f(float x)

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

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

另请参阅

log10f() 的更多特殊案例行为规范。

注意

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

Returns

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

__device__ float __log2f(float x)

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

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

另请参阅

log2f() 用于进一步定义特殊情况的处理行为。

注意

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

Returns

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

__device__ float __logf(float x)

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

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

另请参阅

logf() 用于进一步指定特殊场景的行为。

注意

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

Returns

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

__device__ float __powf(float x, float y)

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

计算第一个输入参数 x 的快速近似值，将其提升至第二个输入参数 y 的幂次方，即 \( x^y \)。

注意

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

Returns

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

__device__ float __saturatef(float x)

将输入参数限制在 [+0.0, 1.0] 范围内。

将输入参数 x 限制在区间 [+0.0, 1.0] 内。

Returns

• __saturatef(x) 当 \( x \le 0 \) 时返回 +0。

• __saturatef(x) 当\( x \ge 1 \)时返回1。

• __saturatef(x) 如果 \( 0 < x < 1 \) 则返回 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。

Returns

返回 x 的近似正弦值。

__device__ float __tanf(float x)

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

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

注意

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

注意

计算结果是通过将__sinf()快速除以__cosf()得到的。非规格化输出会被刷新为保留符号的0.0。

Returns

返回 x 的近似正切值。

__device__ float __tanhf(float x)

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

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

另请参阅

tanhf() 用于进一步指定特殊情况的行为。

注意

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

Returns

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