9. 双精度内建函数

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

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

函数

__device__ double __dadd_rd(double x, double y)

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

__device__ double __dadd_rn(double x, double y)

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

__device__ double __dadd_ru(double x, double y)

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

__device__ double __dadd_rz(double x, double y)

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

__device__ double __ddiv_rd(double x, double y)

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

__device__ double __ddiv_rn(double x, double y)

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

__device__ double __ddiv_ru(double x, double y)

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

__device__ double __ddiv_rz(double x, double y)

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

__device__ double __dmul_rd(double x, double y)

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

__device__ double __dmul_rn(double x, double y)

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

__device__ double __dmul_ru(double x, double y)

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

__device__ double __dmul_rz(double x, double y)

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

__device__ double __drcp_rd(double x)

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

__device__ double __drcp_rn(double x)

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

__device__ double __drcp_ru(double x)

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

__device__ double __drcp_rz(double x)

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

__device__ double __dsqrt_rd(double x)

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

__device__ double __dsqrt_rn(double x)

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

__device__ double __dsqrt_ru(double x)

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

__device__ double __dsqrt_rz(double x)

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

__device__ double __dsub_rd(double x, double y)

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

__device__ double __dsub_rn(double x, double y)

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

__device__ double __dsub_ru(double x, double y)

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

__device__ double __dsub_rz(double x, double y)

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

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

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

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

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

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

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

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

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

9.1. 函数

__device__ double __dadd_rd(double x, double y)

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

以向下舍入（向负无穷大）模式添加两个浮点值 x 和 y。

注意

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

注意

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

返回值

返回 x + y。

• __dadd_rd(x, y) 等效于 __dadd_rd(y, x)。

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

• __dadd_rd( \( \pm\infty \), \( \pm\infty \)) 返回 \( \pm\infty \)。

• __dadd_rd( \( \pm\infty \), \( \mp\infty \)) 返回 NaN。

• __dadd_rd( \( \pm 0 \), \( \pm 0 \)) 返回 \( \pm 0 \)。

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

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

__device__ double __dadd_rn(double x, double y)

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

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

注意

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

注意

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

返回值

返回 x + y。

• __dadd_rn(x, y) 等效于 __dadd_rn(y, x)。

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

• __dadd_rn( \( \pm\infty \), \( \pm\infty \)) 返回 \( \pm\infty \)。

• __dadd_rn( \( \pm\infty \), \( \mp\infty \)) 返回 NaN。

• __dadd_rn( \( \pm 0 \), \( \pm 0 \)) 返回 \( \pm 0 \)。

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

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

__device__ double __dadd_ru(double x, double y)

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

以向上舍入（向正无穷大）模式添加两个浮点值 x 和 y。

注意

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

注意

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

返回值

返回 x + y。

• __dadd_ru(x, y) 等效于 __dadd_ru(y, x)。

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

• __dadd_ru( \( \pm\infty \), \( \pm\infty \)) 返回 \( \pm\infty \)。

• __dadd_ru( \( \pm\infty \), \( \mp\infty \)) 返回 NaN。

• __dadd_ru( \( \pm 0 \), \( \pm 0 \)) 返回 \( \pm 0 \)。

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

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

__device__ double __dadd_rz(double x, double y)

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

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

注意

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

注意

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

返回值

返回 x + y。

• __dadd_rz(x, y) 等效于 __dadd_rz(y, x)。

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

• __dadd_rz( \( \pm\infty \), \( \pm\infty \)) 返回 \( \pm\infty \)。

• __dadd_rz( \( \pm\infty \), \( \mp\infty \)) 返回 NaN。

• __dadd_rz( \( \pm 0 \), \( \pm 0 \)) 返回 \( \pm 0 \)。

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

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

__device__ double __ddiv_rd(double x, double y)

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

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

注意

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

注意

需要计算能力 >= 2.0。

返回值

返回值 x / y。

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

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

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

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

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

• __ddiv_rd(x, \( \pm 0 \)) 对于 x \( \neq 0 \) 返回符号合适的 \( \infty \)。

• __ddiv_rd( \( \pm 0 \), y) 对于 y \( \neq 0 \) 返回符号合适的 \( 0 \)。

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

__device__ double __ddiv_rn(double x, double y)

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

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

注意

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

注意

需要计算能力 >= 2.0。

返回值

返回值 x / y。

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

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

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

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

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

• __ddiv_rn(x, \( \pm 0 \)) 对于 x \( \neq 0 \) 返回符号合适的 \( \infty \)。

• __ddiv_rn( \( \pm 0 \), y) 对于 y \( \neq 0 \) 返回符号合适的 \( 0 \)。

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

__device__ double __ddiv_ru(double x, double y)

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

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

注意

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

注意

需要计算能力 >= 2.0。

返回值

返回值 x / y。

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

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

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

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

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

• __ddiv_ru(x, \( \pm 0 \)) 对于 x \( \neq 0 \) 返回符号合适的 \( \infty \)。

• __ddiv_ru( \( \pm 0 \), y) 对于 y \( \neq 0 \) 返回符号合适的 \( 0 \)。

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

__device__ double __ddiv_rz(double x, double y)

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

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

注意

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

注意

需要计算能力 >= 2.0。

返回值

返回值 x / y。

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

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

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

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

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

• __ddiv_rz(x, \( \pm 0 \)) 对于 x \( \neq 0 \) 返回符号合适的 \( \infty \)。

• __ddiv_rz( \( \pm 0 \), y) 对于 y \( \neq 0 \) 返回符号合适的 \( 0 \)。

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

__device__ double __dmul_rd(double x, double y)

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

在向下舍入（向负无穷大）模式中乘两个浮点值 x 和 y。

注意

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

注意

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

返回值

返回值 x * y。

• 当输入和结果都不是 NaN 时，乘积 x * y 的符号是 x 和 y 符号的 XOR。

• __dmul_rd(x, y) 等效于 __dmul_rd(y, x)。

• __dmul_rd(x, \( \pm\infty \)) 对于 x \( \neq 0 \) 返回符号合适的 \( \infty \)。

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

• __dmul_rd( \( \pm 0 \), y) 对于有限的 y 返回符号合适的 \( 0 \)。

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

__device__ double __dmul_rn(double x, double y)

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

在舍入到最接近的偶数模式中乘两个浮点值 x 和 y。

注意

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

注意

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

返回值

返回值 x * y。

• 当输入和结果都不是 NaN 时，乘积 x * y 的符号是 x 和 y 符号的 XOR。

• __dmul_rn(x, y) 等效于 __dmul_rn(y, x)。

• __dmul_rn(x, \( \pm\infty \)) 对于 x \( \neq 0 \) 返回符号合适的 \( \infty \)。

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

• __dmul_rn( \( \pm 0 \), y) 对于有限的 y 返回符号合适的 \( 0 \)。

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

__device__ double __dmul_ru(double x, double y)

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

将两个浮点数值 x 和 y 以向上舍入（向正无穷大）模式相乘。

注意

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

注意

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

返回值

返回值 x * y。

• 当输入和结果都不是 NaN 时，乘积 x * y 的符号是 x 和 y 符号的 XOR。

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

• __dmul_ru(x, \( \pm\infty \)) 对于 x \( \neq 0 \) 返回符号正确的 \( \infty \)。

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

• __dmul_ru( \( \pm 0 \), y) 对于有限的 y 返回符号正确的 \( 0 \)。

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

__device__ double __dmul_rz(double x, double y)

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

将两个浮点数值 x 和 y 以向零舍入模式相乘。

注意

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

注意

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

返回值

返回值 x * y。

• 当输入和结果都不是 NaN 时，乘积 x * y 的符号是 x 和 y 符号的 XOR。

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

• __dmul_rz(x, \( \pm\infty \)) 对于 x \( \neq 0 \) 返回符号正确的 \( \infty \)。

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

• __dmul_rz( \( \pm 0 \), y) 对于有限的 y 返回符号正确的 \( 0 \)。

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

__device__ double __drcp_rd(double x)

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

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

注意

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

注意

需要计算能力 >= 2.0。

返回值

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

__device__ double __drcp_rn(double x)

以最近偶数舍入模式计算 \( \frac{1}{x} \)。

以最近偶数舍入模式计算 x 的倒数。

注意

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

注意

需要计算能力 >= 2.0。

返回值

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

__device__ double __drcp_ru(double x)

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

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

注意

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

注意

需要计算能力 >= 2.0。

返回值

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

__device__ double __drcp_rz(double x)

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

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

注意

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

注意

需要计算能力 >= 2.0。

返回值

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

__device__ double __dsqrt_rd(double x)

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

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

注意

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

注意

需要计算能力 >= 2.0。

返回值

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

__device__ double __dsqrt_rn(double x)

以最近偶数舍入模式计算 \( \sqrt{x} \)。

以最近偶数舍入模式计算 x 的平方根。

注意

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

注意

需要计算能力 >= 2.0。

返回值

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

__device__ double __dsqrt_ru(double x)

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

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

注意

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

注意

需要计算能力 >= 2.0。

返回值

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

__device__ double __dsqrt_rz(double x)

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

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

注意

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

注意

需要计算能力 >= 2.0。

返回值

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

__device__ double __dsub_rd(double x, double y)

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

将两个浮点数值 x 和 y 以向下舍入（向负无穷大）模式相减。

注意

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

注意

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

返回值

返回 x - y。

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

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

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

• __dsub_rd( \( \pm\infty \), \( \mp\infty \)) 返回 \( \pm\infty \)。

• __dsub_rd( \( \pm 0 \), \( \mp 0 \)) 返回 \( \pm 0 \)。

• __dsub_rd(x, x) 对于有限的 x (包括 \( \pm 0 \)) 返回 \( -0 \)。

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

__device__ double __dsub_rn(double x, double y)

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

将两个浮点数值 x 和 y 以最近偶数舍入模式相减。

注意

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

注意

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

返回值

返回 x - y。

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

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

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

• __dsub_rn( \( \pm\infty \), \( \mp\infty \)) 返回 \( \pm\infty \)。

• __dsub_rn( \( \pm 0 \), \( \mp 0 \)) 返回 \( \pm 0 \)。

• __dsub_rn(x, x) 对于有限的 x (包括 \( \pm 0 \)) 返回 \( +0 \)。

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

__device__ double __dsub_ru(double x, double y)

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

将两个浮点数值 x 和 y 以向上舍入（向正无穷大）模式相减。

注意

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

注意

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

返回值

返回 x - y。

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

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

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

• __dsub_ru( \( \pm\infty \), \( \mp\infty \)) 返回 \( \pm\infty \)。

• __dsub_ru( \( \pm 0 \), \( \mp 0 \)) 返回 \( \pm 0 \)。

• __dsub_ru(x, x) 对于有限的 x (包括 \( \pm 0 \)) 返回 \( +0 \)。

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

__device__ double __dsub_rz(double x, double y)

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

将两个浮点数值 x 和 y 以向零舍入模式相减。

注意

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

注意

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

返回值

返回 x - y。

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

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

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

• __dsub_rz( \( \pm\infty \), \( \mp\infty \)) 返回 \( \pm\infty \)。

• __dsub_rz( \( \pm 0 \), \( \mp 0 \)) 返回 \( \pm 0 \)。

• __dsub_rz(x, x) 对于有限的 x (包括 \( \pm 0 \)) 返回 \( +0 \)。

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

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

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

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

注意

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

返回值

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

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

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

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

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

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

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

• __fma_rd(x, y, z) 如果 \( x \times y + z \) 完全为零且 \( z \neq 0 \)，则返回 \( -0 \)。

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

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

以最近偶数舍入模式将 \( x \times y + z \) 作为单个操作计算。

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

注意

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

返回值

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

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

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

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

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

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

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

• __fma_rn(x, y, z) 如果 \( x \times y + z \) 完全为零且 \( z \neq 0 \)，则返回 \( +0 \)。

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

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

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

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

注意

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

返回值

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

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

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

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

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

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

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

• __fma_ru(x, y, z) 如果 \( x \times y + z \) 完全为零且 \( z \neq 0 \)，则返回 \( +0 \)。

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

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

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

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

注意

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

返回值

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

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

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

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

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

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

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

• __fma_rz(x, y, z) 如果 \( x \times y + z \) 完全为零且 \( z \neq 0 \)，则返回 \( +0 \)。

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