10. FP128 四倍精度数学函数

本节介绍四倍精度数学函数。

要使用这些函数，请在程序中包含头文件 device_fp128_functions.h。

此处声明的函数具有 __nv_fp128_ 前缀，以区别于其他全局命名空间符号。

请注意，FP128 CUDA 数学函数仅在主机编译器支持基本四倍精度数据类型 __float128 或 _Float128 的平台上才可用于设备程序。

每当类型可用时，每个 FP128 CUDA 数学函数名称都会重载以支持这些特定于主机编译器的类型。例如，请参阅

#ifdef __FLOAT128_CPP_SPELLING_ENABLED__
    __float128 __nv_fp128_sqrt(__float128 x);
#endif
#ifdef __FLOAT128_C_SPELLING_ENABLED__
    _Float128 __nv_fp128_sqrt(_Float128 x);
#endif

注意

FP128 设备计算需要计算能力 >= 10.0。

函数

__device__ __float128 __nv_fp128_acos(__float128 x): 计算 \(\cos^{-1}{x}\) ，输入参数的反余弦值。
__device__ __float128 __nv_fp128_acosh(__float128 x): 计算 \(\cosh^{-1}{x}\) ，输入参数的非负反双曲余弦值。
__device__ __float128 __nv_fp128_add(__float128 x, __float128 y): 计算 \(x + y\) ，使用舍入到最近偶数舍入模式的两个浮点输入的和。
__device__ __float128 __nv_fp128_asin(__float128 x): 计算 \(\sin^{-1}{x}\) ，输入参数的反正弦值。
__device__ __float128 __nv_fp128_asinh(__float128 x): 计算 \(\sinh^{-1}{x}\) ，输入参数的反双曲正弦值。
__device__ __float128 __nv_fp128_atan(__float128 x): 计算 \(\tan^{-1}{x}\) ，输入参数的反正切值。
__device__ __float128 __nv_fp128_atanh(__float128 x): 计算 \(\tanh^{-1}{x}\) ，输入参数的反双曲正切值。
__device__ __float128 __nv_fp128_ceil(__float128 x): 计算 \(\lceil x \rceil\) ，大于或等于 x 的最小整数。
__device__ __float128 __nv_fp128_copysign(__float128 x, __float128 y): 创建具有第一个参数 x 的大小和第二个参数 y 的符号的值。
__device__ __float128 __nv_fp128_cos(__float128 x): 计算 \(\cos{x}\) ，输入参数的余弦值（以弧度为单位）。
__device__ __float128 __nv_fp128_cosh(__float128 x): 计算 \(\cosh{x}\) ，输入参数的双曲余弦值。
__device__ __float128 __nv_fp128_div(__float128 x, __float128 y): 计算 \(\frac{x}{y}\) ，使用舍入到最近偶数舍入模式的两个浮点输入的商。
__device__ __float128 __nv_fp128_exp(__float128 x): 计算 \(e^x\) ，以 \(e\) 为底的输入参数的指数。
__device__ __float128 __nv_fp128_exp10(__float128 x): 计算 \(10^x\) ，以 10 为底的输入参数的指数。
__device__ __float128 __nv_fp128_exp2(__float128 x): 计算 \(2^x\) ，以 2 为底的输入参数的指数。
__device__ __float128 __nv_fp128_expm1(__float128 x): 计算 \(e^x - 1\) ，以 e 为底的输入参数的指数，减 1。
__device__ __float128 __nv_fp128_fabs(__float128 x): 计算 \(|x|\) ，输入参数的绝对值。
__device__ __float128 __nv_fp128_fdim(__float128 x, __float128 y): 计算 x 和 y 之间的正差。
__device__ __float128 __nv_fp128_floor(__float128 x): 计算 \(\lfloor x \rfloor\) ，小于或等于 x 的最大整数。
__device__ __float128 __nv_fp128_fma(__float128 x, __float128 y, __float128 c): 将 \(x \times y + z\) 计算为单个运算，使用舍入到最近偶数舍入模式。
__device__ __float128 __nv_fp128_fmax(__float128 x, __float128 y): 确定参数的最大数值。
__device__ __float128 __nv_fp128_fmin(__float128 x, __float128 y): 确定参数的最小数值。
__device__ __float128 __nv_fp128_fmod(__float128 x, __float128 y): 计算 x / y 的浮点余数。
__device__ __float128 __nv_fp128_frexp(__float128 x, int *nptr): 提取浮点输入参数的尾数和指数。
__device__ __float128 __nv_fp128_hypot(__float128 x, __float128 y): 计算 \(\sqrt{x^2+y^2}\) ，两个参数平方和的平方根。
__device__ int __nv_fp128_ilogb(__float128 x): 计算输入参数的无偏整数指数。
__device__ int __nv_fp128_isnan(__float128 x): 确定输入参数是否为 NaN。
__device__ int __nv_fp128_isunordered(__float128 x, __float128 y): 确定输入对是否无序。
__device__ __float128 __nv_fp128_ldexp(__float128 x, int exp): 计算 \(x\cdot 2^{exp}\) 的值。
__device__ __float128 __nv_fp128_log(__float128 x): 计算 \(\log_{e}{x}\) ，以 \(e\) 为底的输入参数的对数。
__device__ __float128 __nv_fp128_log10(__float128 x): 计算 \(\log_{10}{x}\) ，以 10 为底的输入参数的对数。
__device__ __float128 __nv_fp128_log1p(__float128 x): 计算 \(\log_{e}(1+x)\) 的值。
__device__ __float128 __nv_fp128_log2(__float128 x): 计算 \(\log_{2}{x}\) ，以 2 为底的输入参数的对数。
__device__ __float128 __nv_fp128_modf(__float128 x, __float128 *iptr): 将输入参数分解为小数部分和整数部分。
__device__ __float128 __nv_fp128_mul(__float128 x, __float128 y): 计算 \(x \cdot y\) ，使用舍入到最近偶数舍入模式的两个浮点输入的乘积。
__device__ __float128 __nv_fp128_pow(__float128 x, __float128 y): 计算 \(x^{y}\) 的值，第一个参数的第二个参数次幂。
__device__ __float128 __nv_fp128_remainder(__float128 x, __float128 y): 计算浮点余数函数。
__device__ __float128 __nv_fp128_rint(__float128 x): 以浮点格式舍入到最接近的整数值，中间情况舍入到最接近的偶数整数值。
__device__ __float128 __nv_fp128_round(__float128 x): 以浮点格式舍入到最接近的整数值，中间情况远离零舍入。
__device__ __float128 __nv_fp128_sin(__float128 x): 计算 \(\sin{x}\) ，输入参数的正弦值（以弧度为单位）。
__device__ __float128 __nv_fp128_sinh(__float128 x): 计算 \(\sinh{x}\) ，输入参数的双曲正弦值。
__device__ __float128 __nv_fp128_sqrt(__float128 x): 计算 \(\sqrt{x}\) ，输入参数的平方根。
__device__ __float128 __nv_fp128_sub(__float128 x, __float128 y): 计算 \(x - y\) ，使用舍入到最近偶数舍入模式的两个浮点输入的差。
__device__ __float128 __nv_fp128_tan(__float128 x): 计算 \(\tan{x}\) ，输入参数的正切值（以弧度为单位）。
__device__ __float128 __nv_fp128_tanh(__float128 x): 计算 \(\tanh{x}\) ，输入参数的双曲正切值。
__device__ __float128 __nv_fp128_trunc(__float128 x): 将输入参数截断为整数部分。

10.1. 函数

__device__ __float128 __nv_fp128_acos(__float128 x)

计算 \( \cos^{-1}{x} \), 输入参数的反余弦值。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

输入参数 x 的反余弦主值。对于 [-1, +1] 内的 x，结果将以弧度为单位，在 [0, \( \pi \) ] 区间内。

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

__device__ __float128 __nv_fp128_acosh(__float128 x)

计算 \( \cosh^{-1}{x} \), 输入参数的非负反双曲余弦值。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

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

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

__device__ __float128 __nv_fp128_add(__float128 x, __float128 y)

计算 \( x + y \), 使用舍入到最近偶数舍入模式的两个浮点输入的和。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

返回值 x + y。

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

__device__ __float128 __nv_fp128_asin(__float128 x)

计算 \( \sin^{-1}{x} \), 输入参数的反正弦值。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

输入参数 x 的反正弦主值。对于 [-1, +1] 内的 x，结果将以弧度为单位，在 [- \( \pi/2 \) , + \( \pi/2 \) ] 区间内。

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

__device__ __float128 __nv_fp128_asinh(__float128 x)

计算 \( \sinh^{-1}{x} \), 输入参数的反双曲正弦值。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

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

__device__ __float128 __nv_fp128_atan(__float128 x)

计算 \( \tan^{-1}{x} \), 输入参数的反正切值。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

输入参数 x 的反正切主值。结果将以弧度为单位，在 [- \( \pi/2 \) , + \( \pi/2 \) ] 区间内。

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

__device__ __float128 __nv_fp128_atanh(__float128 x)

计算 \( \tanh^{-1}{x} \), 输入参数的反双曲正切值。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

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

__device__ __float128 __nv_fp128_ceil(__float128 x)

计算 \( \lceil x \rceil \), 大于或等于 x 的最小整数。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

\( \lceil x \rceil \) 表示为浮点数。

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

__device__ __float128 __nv_fp128_copysign(__float128 x, __float128 y)

创建具有第一个参数 x 的大小和第二个参数 y 的符号的值。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

copysign(NaN, y) 返回一个带有 y 符号的 NaN。

__device__ __float128 __nv_fp128_cos(__float128 x)

计算 \( \cos{x} \), 输入参数的余弦值（以弧度为单位）。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

\( \cos{x} \).

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

__device__ __float128 __nv_fp128_cosh(__float128 x)

计算 \( \cosh{x} \), 输入参数的双曲余弦值。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

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

__device__ __float128 __nv_fp128_div(__float128 x, __float128 y)

计算 \( \frac{x}{y} \), 使用舍入到最近偶数舍入模式的两个浮点输入的商。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

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

__device__ __float128 __nv_fp128_exp(__float128 x)

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

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

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

__device__ __float128 __nv_fp128_exp10(__float128 x)

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

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

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

__device__ __float128 __nv_fp128_exp2(__float128 x)

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

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

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

__device__ __float128 __nv_fp128_expm1(__float128 x)

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

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

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

__device__ __float128 __nv_fp128_fabs(__float128 x)

计算 \( |x| \)，即输入参数的绝对值。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

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

__device__ __float128 __nv_fp128_fdim(__float128 x, __float128 y)

计算 x 和 y 之间的正差。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

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

__device__ __float128 __nv_fp128_floor(__float128 x)

计算 \( \lfloor x \rfloor \)，即小于或等于 x 的最大整数。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

\( \lfloor x \rfloor \) 表示为浮点数。

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

__device__ __float128 __nv_fp128_fma(__float128 x, __float128 y, __float128 c)

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

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

\( x \times y + z \) 的值作为一个三元运算，使用舍入到最近， ties-to-even 舍入模式进行一次舍入。

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

__device__ __float128 __nv_fp128_fmax(__float128 x, __float128 y)

确定参数的最大数值。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

参数 x 和 y 的最大数值。将 NaN 参数视为缺失数据。

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

__device__ __float128 __nv_fp128_fmin(__float128 x, __float128 y)

确定参数的最小数值。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

参数 x 和 y 的最小数值。将 NaN 参数视为缺失数据。

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

__device__ __float128 __nv_fp128_fmod(__float128 x, __float128 y)

计算 x / y 的浮点余数。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

此函数计算的除法运算 x / y 的浮点余数正是值 x - n*y，其中 n 是 x / y，其小数部分被截断。

计算出的值将与 x 具有相同的符号，并且其大小将小于 y 的大小。
__nv_fp128_fmod( \( \pm 0 \) , y) 如果 y 不为零，则返回 \( \pm 0 \)。
__nv_fp128_fmod(x, \( \pm \infty \) ) 如果 x 是有限的，则返回 x。
__nv_fp128_fmod(x, y) 如果 x 是 \( \pm\infty \) 或 y 为零，则返回 NaN。
如果任一参数为 NaN，则返回 NaN。

__device__ __float128 __nv_fp128_frexp(__float128 x, int *nptr)

提取浮点输入参数的尾数和指数。

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

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

分数部分 m。

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

__device__ __float128 __nv_fp128_hypot(__float128 x, __float128 y)

计算 \( \sqrt{x^2+y^2} \)，即两个参数平方和的平方根。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

两条边长分别为 \( |x| \) 和 \( |y| \) 的直角三角形的斜边长度，而不会发生不必要的溢出或下溢。

__nv_fp128_hypot(x,y)、__nv_fp128_hypot(y,x) 和 __nv_fp128_hypot(x, -y) 是等效的。
__nv_fp128_hypot(x, \( \pm 0 \) ) 等效于 __nv_fp128_fabs(x)。
__nv_fp128_hypot( \( \pm \infty \) ,y) 返回 \( +\infty \)，即使 y 是 NaN。
__nv_fp128_hypot(NaN, y) 当 y 不是 \( \pm\infty \) 时，返回 NaN。

__device__ int __nv_fp128_ilogb(__float128 x)

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

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

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

__device__ int __nv_fp128_isnan(__float128 x)

确定输入参数是否为 NaN。

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值: 当且仅当 x 是 NaN 值时，返回非零值。

__device__ int __nv_fp128_isunordered(__float128 x, __float128 y)

确定输入对是否无序。

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

如果至少一个输入值是 NaN，则返回非零值。
否则返回零

__device__ __float128 __nv_fp128_ldexp(__float128 x, int exp)

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

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

__nv_fp128_ldexp( \( \pm 0 \) , exp) 返回 \( \pm 0 \)。
__nv_fp128_ldexp(x, 0) 返回 x。
__nv_fp128_ldexp( \( \pm \infty \) , exp) 返回 \( \pm \infty \)。
__nv_fp128_ldexp(NaN, exp) 返回 NaN。

__device__ __float128 __nv_fp128_log(__float128 x)

计算 \( \log_{e}{x} \)，即输入参数的以 \( e \) 为底的对数。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

__nv_fp128_log( \( \pm 0 \) ) 返回 \( -\infty \)。
__nv_fp128_log(1) 返回 +0。
对于 x < 0，__nv_fp128_log(x) 返回 NaN。
__nv_fp128_log( \( +\infty \) ) 返回 \( +\infty \)。
__nv_fp128_log(NaN) 返回 NaN。

__device__ __float128 __nv_fp128_log10(__float128 x)

计算 \( \log_{10}{x} \)，即输入参数的以 10 为底的对数。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

__nv_fp128_log10( \( \pm 0 \) ) 返回 \( -\infty \)。
__nv_fp128_log10(1) 返回 +0。
对于 x < 0，__nv_fp128_log10(x) 返回 NaN。
__nv_fp128_log10( \( +\infty \) ) 返回 \( +\infty \)。
__nv_fp128_log10(NaN) 返回 NaN。

__device__ __float128 __nv_fp128_log1p(__float128 x)

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

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

__nv_fp128_log1p( \( \pm 0 \) ) 返回 \( \pm 0 \)。
__nv_fp128_log1p(-1) 返回 \( -\infty \)。
对于 x < -1，__nv_fp128_log1p(x) 返回 NaN。
__nv_fp128_log1p( \( +\infty \) ) 返回 \( +\infty \)。
__nv_fp128_log1p(NaN) 返回 NaN。

__device__ __float128 __nv_fp128_log2(__float128 x)

计算 \( \log_{2}{x} \)，即输入参数的以 2 为底的对数。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

__nv_fp128_log2( \( \pm 0 \) ) 返回 \( -\infty \)。
__nv_fp128_log2(1) 返回 +0。
对于 x < 0，__nv_fp128_log2(x) 返回 NaN。
__nv_fp128_log2( \( +\infty \) ) 返回 \( +\infty \)。
__nv_fp128_log2(NaN) 返回 NaN。

__device__ __float128 __nv_fp128_modf(__float128 x, __float128 *iptr)

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

将参数 x 分解为小数部分和整数部分。整数部分以浮点格式存储在 iptr 指向的位置。小数部分和整数部分的符号与参数 x 的符号相同。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

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

__device__ __float128 __nv_fp128_mul(__float128 x, __float128 y)

计算 \( x \cdot y \)，即两个浮点输入的乘积，使用舍入到最接近的偶数舍入模式。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

返回 x * y。

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

__device__ __float128 __nv_fp128_pow(__float128 x, __float128 y)

计算 \( x^{y} \) 的值，即第一个参数的第二个参数次幂。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

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

__device__ __float128 __nv_fp128_remainder(__float128 x, __float128 y)

计算浮点余数函数。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

对于非零 y，x 除以 y 的浮点余数 r 定义为 \( r = x - n y \)。值 n 是最接近 \( \frac{x}{y} \) 的整数值。在 \( | n -\frac{x}{y} | = \frac{1}{2} \) 的中间情况下，选择偶数值 n。

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

__device__ __float128 __nv_fp128_rint(__float128 x)

以浮点格式舍入到最接近的整数值，中间情况舍入到最接近的偶数整数值。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

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

__device__ __float128 __nv_fp128_round(__float128 x)

以浮点格式舍入到最接近的整数值，中间情况远离零舍入。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

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

__device__ __float128 __nv_fp128_sin(__float128 x)

计算 \( \sin{x} \)，即输入参数（以弧度为单位）的正弦值。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

\( \sin{x} \).

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

__device__ __float128 __nv_fp128_sinh(__float128 x)

计算 \( \sinh{x} \)，即输入参数的双曲正弦值。

计算 \( \sinh{x} \)，即输入参数 x 的双曲正弦值。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

__nv_fp128_sinhinh( \( \pm 0 \) ) 返回 \( \pm 0 \)。
__nv_fp128_sinh( \( \pm \infty \) ) 返回 \( \pm \infty \)。
__nv_fp128_sinh(NaN) 返回 NaN。

__device__ __float128 __nv_fp128_sqrt(__float128 x)

计算 \( \sqrt{x} \)，即输入参数的平方根。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

\( \sqrt{x} \).

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

__device__ __float128 __nv_fp128_sub(__float128 x, __float128 y)

计算 \( x - y \)，即两个浮点输入的差值，使用舍入到最接近的偶数舍入模式。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

返回 x - y。

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

__device__ __float128 __nv_fp128_tan(__float128 x)

计算 \( \tan{x} \)，即输入参数（以弧度为单位）的正切值。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

\( \tan{x} \).

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

__device__ __float128 __nv_fp128_tanh(__float128 x)

计算 \( \tanh{x} \)，即输入参数的双曲正切值。

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

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

__device__ __float128 __nv_fp128_trunc(__float128 x)

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

注意

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

注意

FP128 设备计算需要计算能力 >= 10.0。

返回值

将 x 舍入为最接近的整数值（浮点格式），该值在幅度上不超过 x。

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