鸿蒙OS Math

Math

java.lang.Object

|—java.lang.Math

public final class Math
extends Object

Math 类包含执行基本数值运算的方法，例如初等指数、对数、平方根和三角函数。

与 StrictMath 类的一些数值方法不同，Math 类的等效函数的所有实现都未定义为返回逐位相同的结果。这种放松允许在不需要严格的再现性的情况下实现更好的性能。

默认情况下，许多 Math 方法只是简单地调用 StrictMath 中的等效方法来实现它们。鼓励代码生成器在可用的情况下使用特定于平台的本机库或微处理器指令，以提供更高性能的数学方法实现。这种更高性能的实现仍然必须符合 Math.xml 的规范。

实现规范的质量涉及两个属性，返回结果的准确性和方法的单调性。浮点数学方法的准确性以 ulps 为单位，最后的单位。对于给定的浮点格式，特定实数值的 ulp 是包围该数值的两个浮点值之间的距离。当讨论一个方法作为一个整体而不是一个特定参数的准确性时，引用的 ulp 数量是针对任何参数的最坏情况错误。如果一个方法的误差总是小于 0.5 ulps，该方法总是返回最接近精确结果的浮点数；这种方法是正确四舍五入的。正确舍入的方法通常是浮点近似的最佳方法；但是，正确舍入许多浮点方法是不切实际的。相反，对于 Math 类，某些方法允许更大的误差范围为 1 或 2 ulps。非正式地，在 1 ulp 误差范围内，当精确结果是可表示的数字时，精确结果应作为计算结果返回；否则，可以返回包含确切结果的两个浮点值中的任何一个。对于数量级较大的精确结果，括号的端点之一可能是无限的。除了个别论点的准确性外，保持不同论点的方法之间的适当关系也很重要。因此，大多数 ulp 误差大于 0.5 的方法都要求是半单调的：只要数学函数不减，浮点逼近也是如此，同样，只要数学函数不增，浮点逼近也是点近似。并非所有具有 1 ulp 精度的近似值都会自动满足单调性要求。

该平台使用带有 int 和 long 原始类型的带符号二进制补码整数算术。开发人员应选择原始类型以确保算术运算始终产生正确的结果，这在某些情况下意味着运算不会溢出计算值的范围。最佳实践是选择原始类型和算法以避免溢出。在大小为 int 或 long 且需要检测溢出错误的情况下，方法 addExact、subtractExact、multiplyExact 和 toIntExact 在结果溢出时抛出 ArithmeticException。对于其他算术运算，例如除法、绝对值、递增、递减和求反，溢出仅发生在特定的最小值或最大值时，应根据需要检查最小值或最大值。

字段摘要

方法总结

字段详细信息

E

public static final double E

比任何其他值更接近 e（自然对数的底）的双精度值。

PI

public static final double PI

比任何其他值更接近 pi 的双精度值，即圆的周长与其直径的比率。

方法详情

sin

public static double sin(double a)

返回角度的三角正弦值。 特别案例：

• 如果参数为 NaN 或无穷大，则结果为 NaN。
• 如果参数为零，则结果为零，符号与参数相同。

计算结果必须在精确结果的 1 ulp 范围内。 结果必须是半单调的。

参数：

返回：

论证的正弦。

cos

public static double cos(double a)

返回角度的三角余弦值。 特别案例：

• 如果参数为 NaN 或无穷大，则结果为 NaN。

计算结果必须在精确结果的 1 ulp 范围内。 结果必须是半单调的。

参数：

返回：

参数的余弦。

tan

public static double tan(double a)

返回角度的三角正切。 特别案例：

• 如果参数为 NaN 或无穷大，则结果为 NaN。
• 如果参数为零，则结果为零，符号与参数相同。

计算结果必须在精确结果的 1 ulp 范围内。 结果必须是半单调的。

参数：

返回：

论点的切线。

asin

public static double asin(double a)

返回一个值的反正弦； 返回的角度在 –pi/2 到 pi/2 的范围内。 特别案例：

• 如果参数为 NaN 或其绝对值大于 1，则结果为 NaN。
• 如果参数为零，则结果为零，符号与参数相同。

计算结果必须在精确结果的 1 ulp 范围内。 结果必须是半单调的。

参数：

返回：

参数的反正弦。

acos

public static double acos(double a)

返回一个值的反余弦值； 返回的角度在 0.0 到 pi 的范围内。 特例：

• 如果参数为 NaN 或其绝对值大于 1，则结果为 NaN。

计算结果必须在精确结果的 1 ulp 范围内。 结果必须是半单调的。

参数：

返回：

参数的反余弦。

atan

public static double atan(double a)

返回值的反正切； 返回的角度在 –pi/2 到 pi/2 的范围内。 特别案例：

• 如果参数为 NaN，则结果为 NaN。
• 如果参数为零，则结果为零，符号与参数相同。

计算结果必须在精确结果的 1 ulp 范围内。 结果必须是半单调的。

参数：

返回：

参数的反正切。

toRadians

public static double toRadians(double angdeg)

将以度为单位的角度转换为以弧度为单位的大致等效角度。 从度数到弧度的转换通常是不精确的。

参数：

返回：

以弧度为单位的角度 angdeg 的测量值。

toDegrees

public static double toDegrees(double angrad)

将以弧度测量的角度转换为以度为单位测量的大致等效角度。 从弧度到度数的转换通常是不精确的； 用户不应该*期望 cos(toRadians(90.0)) 完全等于 0.0。

参数：

返回：

以度为单位的角度 angrad 的测量值。

exp

public static double exp(double a)

返回欧拉数 e 的双精度次方。 特别情况：

• 如果参数为 NaN，则结果为 NaN。
• 如果参数是正无穷大，那么结果是正无穷大。
• 如果参数为负无穷大，则结果为正零。

计算结果必须在精确结果的 1 ulp 范围内。 结果必须是半单调的。

参数：

返回：

值 ea，其中 e 是自然对数的底。

log

public static double log(double a)

返回双精度值的自然对数（底数 e）。 特别情况：

• 如果参数为 NaN 或小于零，则结果为 NaN。
• 如果参数是正无穷大，那么结果是正无穷大。
• 如果参数为正零或负零，则结果为负无穷大。

计算结果必须在精确结果的 1 ulp 范围内。 结果必须是半单调的。

参数：

返回：

a中的值，a的自然对数。

log10

public static double log10(double a)

返回双精度值的以 10 为底的对数。 特别情况：

• 如果参数为 NaN 或小于零，则结果为 NaN。
• 如果参数是正无穷大，那么结果是正无穷大。
• 如果参数为正零或负零，则结果为负无穷大。
• 如果参数等于整数 n 的 10n，则结果为 n。

计算结果必须在精确结果的 1 ulp 范围内。 结果必须是半单调的。

参数：

返回：

a 的以 10 为底的对数。

sqrt

public static double sqrt(double a)

返回双精度值的正确舍入正平方根。 特别情况：

• 如果参数为 NaN 或小于零，则结果为 NaN。
• 如果参数是正无穷大，那么结果是正无穷大。
• 如果参数是正零或负零，则结果与参数相同。

否则，结果是最接近参数值的真正数学平方根的双精度值。

参数：

返回：

a 的正平方根。 如果参数为 NaN 或小于零，则结果为 NaN。

cbrt

public static double cbrt(double a)

返回双精度值的立方根。 对于正有限 x，cbrt(-x) == -cbrt(x); 也就是说，负值的立方根是该值大小的立方根的负数。 特别情况：

• 如果参数为 NaN，则结果为 NaN。
• 如果参数是无限的，则结果是与参数相同符号的无穷大。
• 如果参数为零，则结果为零，符号与参数相同。

计算结果必须在精确结果的 1 ulp 范围内。

参数:

返回：

a的立方根。

IEEEremainder

public static double IEEEremainder(double f1, double f2)

计算 IEEE 754 标准规定的两个参数的余数运算。 余数值在数学上等于 f1 – f2 × n，其中 n 是最接近商 f1/f2 的精确数学值的数学整数，如果两个数学整数同样接近 f1/f2，则 n 是偶数整数。 如果余数为零，则其符号与第一个参数的符号相同。 特别案例：

• 如果任一参数为 NaN，或第一个参数为无穷大，或第二个参数为正零或负零，则结果为 NaN。
• 如果第一个参数是有限的，而第二个参数是无限的，那么结果与第一个参数相同。

参数：

返回：

f1 除以 f2 的余数。

ceil

public static double ceil(double a)

返回大于或等于参数且等于数学整数的最小（最接近负无穷大）双精度值。 特别案例：

• 如果参数值已经等于数学整数，则结果与参数相同。
• 如果参数是 NaN 或无穷大或正零或负零，则结果与参数相同。
• 如果参数值小于零但大于 -1.0，则结果为负零。

请注意，Math.ceil(x) 的值正是 -Math.floor(-x) 的值。

参数：

返回：

大于或等于参数且等于数学整数的最小（最接近负无穷大）浮点值。

floor

public static double floor(double a)

返回小于或等于参数且等于数学整数的最大（最接近正无穷大）双精度值。 特别情况：

• 如果参数值已经等于数学整数，则结果与参数相同。
• 如果参数是 NaN 或无穷大或正零或负零，则结果与参数相同。

参数：

返回：

小于或等于参数且等于数学整数的最大（最接近正无穷大）浮点值。

rint

public static double rint(double a)

返回与参数值最接近且等于数学整数的双精度值。 如果两个作为数学整数的双精度值同样接近，则结果是偶数的整数值。 特别案例：

• 如果参数值已经等于数学整数，则结果与参数相同。
• 如果参数是 NaN 或无穷大或正零或负零，则结果与参数相同。

参数：

返回：

最接近等于数学整数的 a 的浮点值。

atan2

public static double atan2(double y, double x)

从直角坐标 (x, y) 到极坐标 (r, theta) 的转换中返回角度 theta。此方法通过计算 –pi 到 pi 范围内的 y/x 的反正切来计算相位 theta。特别案例：

• 如果任一参数为 NaN，则结果为 NaN。
• 如果第一个参数为正零且第二个参数为正，或者第一个参数为正且有限且第二个参数为正无穷，则结果为正零。
• 如果第一个参数为负零，第二个参数为正，或者第一个参数为负且有限，而第二个参数为正无穷，则结果为负零。
• 如果第一个参数为正零，第二个参数为负，或者第一个参数为正且有限，第二个参数为负无穷，则结果是最接近 pi 的双精度值。
• 如果第一个参数为负零且第二个参数为负，或者第一个参数为负且有限且第二个参数为负无穷，则结果是最接近 –pi 的双精度值。
• 如果第一个参数为正，第二个参数为正零或负零，或者第一个参数为正无穷大，第二个参数为有限，则结果是最接近 pi/2 的双精度值。
• 如果第一个参数是负数，第二个参数是正零或负零，或者第一个参数是负无穷大，第二个参数是有限的，那么结果是最接近 –pi/2 的双精度值。
• 如果两个参数都是正无穷大，那么结果是最接近 pi/4 的双精度值。
• 如果第一个参数是正无穷大，第二个参数是负无穷大，那么结果是最接近 3*pi/4 的双精度值。
• 如果第一个参数是负无穷大，第二个参数是正无穷大，则结果是最接近 –pi/4 的双精度值。
• 如果两个参数都是负无穷大，则结果是最接近 -3*pi/4 的双精度值。

计算结果必须在精确结果的 2 ulps 范围内。结果必须是半单调的。

参数：

返回：

极坐标中点 (r, theta) 的 theta 分量，对应于笛卡尔坐标中的点 (x, y)。

pow

public static double pow(double a, double b)

返回第一个参数的第二个参数次幂的值。 特别情况：

• 如果第二个参数是正零或负零，则结果为 1.0。
• 如果第二个参数为 1.0，则结果与第一个参数相同。
• 如果第二个参数是 NaN，那么结果是 NaN。
• 如果第一个参数为 NaN，第二个参数为非零，则结果为 NaN。
• 如果
  • 第一个参数的绝对值大于 1，第二个参数为正无穷大，或
  • 第一个参数的绝对值小于 1，第二个参数为负无穷大，那么结果是正无穷大。
• 如果
  • 第一个参数的绝对值大于 1，第二个参数为负无穷大，或
  • 第一个参数的绝对值小于 1，第二个参数为正无穷大，那么结果是正零。
• 如果第一个参数的绝对值等于 1，而第二个参数是无限的，则结果为 NaN。
• 如果
  • 第一个参数为正零，第二个参数大于零，或
  • 第一个参数是正无穷大，第二个参数小于零，那么结果是正零。
• 如果
  • 第一个参数为正零，第二个参数小于零，或
  • 第一个参数是正无穷大，第二个参数大于零，那么结果是正无穷大。
• 如果
  • 第一个参数为负零，第二个参数大于零但不是有限奇数，或
  • 第一个参数是负无穷大，第二个参数小于零但不是有限奇数，那么结果是正零。
• 如果
  • 第一个参数是负零，第二个参数是一个正有限奇整数，或者
  • 第一个参数是负无穷大，第二个参数是一个负有限奇整数，那么结果是负零。
• 如果
  • 第一个参数为负零，第二个参数小于零但不是有限奇数，或
  • 第一个参数是负无穷大，第二个参数大于零但不是有限奇数，那么结果是正无穷大。
• 如果
  • 第一个参数是负零，第二个参数是一个负有限奇整数，或者
  • 第一个参数是负无穷大，第二个参数是一个正有限奇整数，那么结果是负无穷大。
• 如果第一个参数是有限的并且小于零
  • 如果第二个参数是有限偶整数，则结果等于将第一个参数的绝对值提高到第二个参数的幂的结果
  • 如果第二个参数是有限奇整数，则结果等于将第一个参数的绝对值提高到第二个参数的幂的结果的负数
  • 如果第二个参数是有限的而不是整数，则结果为 NaN。
• 如果两个参数都是整数，则结果完全等于将第一个参数提升到第二个参数的幂的数学结果，如果该结果实际上可以精确地表示为双精度值。

（在前面的描述中，浮点值被认为是整数当且仅当它是有限的并且是方法 ceil 的不动点，或者等效地，方法层的不动点。一个值是一个不动点 当且仅当将方法应用于值的结果等于该值时，才属于单参数方法。）

计算结果必须在精确结果的 1 ulp 范围内。 结果必须是半单调的。

参数:

返回：

值 ab。

round

public static int round(float a)

返回最接近参数的 int，并舍入为正无穷大。

特别案例：

• 如果参数为 NaN，则结果为 0。
• 如果参数为负无穷大或任何小于或等于 Integer.MIN_VALUE 的值，则结果等于 Integer.MIN_VALUE 的值。
• 如果参数为正无穷大或任何大于或等于 Integer.MAX_VALUE 的值，则结果等于 Integer.MAX_VALUE 的值。

参数：

返回：

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

round

public static long round(double a)

返回最接近参数的长整数，并舍入为正无穷大。

特别情况：

• 如果参数为 NaN，则结果为 0。
• 如果参数为负无穷大或任何小于或等于 Long.MIN_VALUE 的值，则结果等于 Long.MIN_VALUE 的值。
• 如果参数为正无穷大或任何大于或等于 Long.MAX_VALUE 的值，则结果等于 Long.MAX_VALUE 的值。

参数：

返回：

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

random

public static double random()

返回一个带正号的双精度值，大于或等于 0.0 且小于 1.0。 返回值是伪随机选择的，从该范围（近似）均匀分布。

当这个方法第一次被调用时，它会创建一个新的伪随机数生成器，就像通过表达式一样

new java.util.Random()

这个新的伪随机数生成器随后用于对该方法的所有调用，并且不会在其他任何地方使用。

此方法已正确同步，以允许多个线程正确使用。 但是，如果许多线程需要以很高的速率生成伪随机数，则可能会减少每个线程对拥有自己的伪随机数生成器的争用。

返回：

大于或等于 0.0 且小于 1.0 的伪随机 double。

addExact

public static int addExact(int x, int y)

返回其参数的总和，如果结果溢出 int，则抛出异常。

参数：

返回:

结果

Throws:

addExact

public static long addExact(long x, long y)

返回其参数的总和，如果结果溢出 long 则抛出异常。

参数：

返回:

结果

Throws:

subtractExact

public static int subtractExact(int x, int y)

返回参数的差异，如果结果溢出 int，则抛出异常。

参数：

返回：

结果

Throws:

subtractExact

public static long subtractExact(long x, long y)

返回参数的差异，如果结果溢出 long 则抛出异常。

参数：

返回：

结果

Throws:

multiplyExact

public static int multiplyExact(int x, int y)

返回参数的乘积，如果结果溢出 int，则抛出异常。

参数：

返回：

结果

Throws:

multiplyExact

public static long multiplyExact(long x, long y)

返回参数的乘积，如果结果溢出 long 则抛出异常。

参数：

返回：

结果

Throws:

incrementExact

public static int incrementExact(int a)

返回加一的参数，如果结果溢出 int 则抛出异常。

参数：

返回：

结果

Throws:

incrementExact

public static long incrementExact(long a)

返回加一的参数，如果结果溢出 long 则抛出异常。

参数：

返回：

结果

Throws:

decrementExact

public static int decrementExact(int a)

返回减一的参数，如果结果溢出 int，则抛出异常。

参数：

返回：

结果

Throws:

decrementExact

public static long decrementExact(long a)

返回减一的参数，如果结果溢出 long 则抛出异常。

参数：

返回：

结果

Throws:

negateExact

public static int negateExact(int a)

返回参数的否定，如果结果溢出 int 则抛出异常。

参数：

返回:

j结果

Throws:

negateExact

public static long negateExact(long a)

返回参数的否定，如果结果溢出 long 则抛出异常。

参数：

返回：

结果

Throws:

toIntExact

public static int toIntExact(long value)

返回long参数的值； 如果值溢出 int，则抛出异常。

参数：

返回：

作为 int 的参数

Throws:

floorDiv

public static int floorDiv(int x, int y)

返回小于或等于代数商的最大（最接近正无穷大）int 值。 有一种特殊情况，如果被除数是 Integer#MIN_VALUE 而除数是 -1，则发生整数溢出，结果等于 Integer.MIN_VALUE。

正常整数除法在舍入到零舍入模式（截断）下运行。 此操作改为在朝负无穷大（下限）舍入模式下进行。 当精确结果为负时，下舍入模式给出的结果与截断不同。

• 如果参数的符号相同，则 floorDiv 和 / 运算符的结果相同。 例如， floorDiv(4, 3) == 1 和 (4 / 3) == 1。
• 如果参数的符号不同，则商为负，floorDiv 返回小于或等于商的整数，/ 运算符返回最接近零的整数。 例如， floorDiv(-4, 3) == -2，而 (-4 / 3) == -1。

参数：

返回：

小于或等于代数商的最大（最接近正无穷大）int 值。

Throws:

floorDiv

public static long floorDiv(long x, long y)

返回小于或等于代数商的最大（最接近正无穷大）long 值。 有一种特殊情况，如果被除数是 Long#MIN_VALUE 而除数是 -1，则发生整数溢出，结果等于 Long.MIN_VALUE。

正常整数除法在舍入到零舍入模式（截断）下运行。 此操作改为在朝负无穷大（下限）舍入模式下进行。 当精确结果为负时，下舍入模式给出的结果与截断不同。

参数:

返回:

小于或等于代数商的最大（最接近正无穷大）long 值。

Throws:

floorMod

public static int floorMod(int x, int y)

返回 int 参数的底模。

底模为 x – (floorDiv(x, y) * y)，与除数 y 具有相同的符号，并且在 -abs(y) < r < +abs(y) 的范围内。

floorDiv 和 floorMod 之间的关系是这样的：

• floorDiv(x, y) * y + floorMod(x, y) == x

floorMod 和 % 运算符之间的值差异是由于 floorDiv 返回小于或等于商的整数与返回最接近零的整数的 / 运算符之间的差异。

例如：

• 如果参数的符号相同，则 floorMod 和 % 运算符的结果相同。
  • floorMod(4, 3) == 1; and (4 % 3) == 1
• 如果参数的符号不同，则结果与 % 运算符不同。
  • floorMod(+4, -3) == -2; and (+4 % -3) == +1
  • floorMod(-4, +3) == +2; and (-4 % +3) == -1
  • floorMod(-4, -3) == -1; and (-4 % -3) == -1

如果参数的符号未知并且需要正模数，则可以将其计算为 (floorMod(x, y) + abs(y)) % abs(y)。

参数:

返回：

底模 x – (floorDiv(x, y) * y)

Throws:

floorMod

public static long floorMod(long x, long y)

返回long参数的底模。

底模为 x – (floorDiv(x, y) * y)，与除数 y 具有相同的符号，并且在 -abs(y) < r < +abs(y) 的范围内。

floorDiv 和 floorMod 之间的关系是这样的：

• floorDiv(x, y) * y + floorMod(x, y) == x

参数:

返回：

底模 x – (floorDiv(x, y) * y)

Throws:

abs

public static int abs(int a)

返回 int 值的绝对值。 如果参数不是负数，则返回参数。 如果参数是否定的，则返回参数的否定。

请注意，如果参数等于 Integer#MIN_VALUE 的值，即最负的可表示 int 值，则结果是相同的值，即为负。

参数：

返回：

参数的绝对值。

abs

public static long abs(long a)

返回一个 long 值的绝对值。 如果参数不是负数，则返回参数。 如果参数是否定的，则返回参数的否定。

请注意，如果参数等于 Long#MIN_VALUE 的值（可表示的最负的 long 值），则结果是相同的值，即为负。

参数：

返回：

参数的绝对值。

abs

public static float abs(float a)

返回浮点值的绝对值。 如果参数不是负数，则返回参数。 如果参数是否定的，则返回参数的否定。 特别案例：

• 如果参数为正零或负零，则结果为正零。
• 如果参数是无限的，则结果是正无穷大。
• 如果参数为 NaN，则结果为 NaN。

换句话说，结果与表达式的值相同：

Float.intBitsToFloat(0x7fffffff & Float.floatToIntBits(a))

参数:

返回：

参数的绝对值。

abs

public static double abs(double a)

返回双精度值的绝对值。 如果参数不是负数，则返回参数。 如果参数是否定的，则返回参数的否定。 特别案例：

• 如果参数为正零或负零，则结果为正零。
• 如果参数是无限的，则结果是正无穷大。
• 如果参数为 NaN，则结果为 NaN。

换句话说，结果与表达式的值相同：

Double.longBitsToDouble((Double.doubleToLongBits(a)<<1)>>>1)

参数:

返回：

参数的绝对值。

max

public static int max(int a, int b)

返回两个 int 值中的较大者。 也就是说，结果是更接近 Integer#MAX_VALUE 值的参数。 如果参数具有相同的值，则结果是相同的值。

参数:

返回:

a 和 b 中的较大者。

max

public static long max(long a, long b)

返回两个 long 值中的较大者。 也就是说，结果是参数更接近 Long#MAX_VALUE 的值。 如果参数具有相同的值，则结果是相同的值。

参数：

返回：

a 和 b 中的较大者。

max

public static float max(float a, float b)

返回两个浮点值中的较大者。 也就是说，结果是更接近正无穷大的参数。 如果参数具有相同的值，则结果是相同的值。 如果任一值为 NaN，则结果为 NaN。 与数值比较运算符不同，此方法认为负零严格小于正零。 如果一个参数为正零而另一个为负零，则结果为正零。

参数：

返回：

a 和 b 中的较大者。

max

public static double max(double a, double b)

返回两个双精度值中的较大者。 也就是说，结果是更接近正无穷大的参数。 如果参数具有相同的值，则结果是相同的值。 如果任一值为 NaN，则结果为 NaN。 与数值比较运算符不同，此方法认为负零严格小于正零。 如果一个参数为正零而另一个为负零，则结果为正零。

参数：

返回：

a 和 b 中的较大者。

min

public static int min(int a, int b)

返回两个 int 值中较小的一个。 也就是说，参数的结果更接近 Integer#MIN_VALUE 的值。 如果参数具有相同的值，则结果是相同的值。

参数：

返回：

a 和 b 中较小的一个。

min

public static long min(long a, long b)

返回两个 long 值中较小的一个。 也就是说，结果是参数更接近 Long#MIN_VALUE 的值。 如果参数具有相同的值，则结果是相同的值。

参数：

返回：

a 和 b 中较小的一个。

min

public static float min(float a, float b)

返回两个浮点值中较小的一个。 也就是说，结果是更接近负无穷大的值。 如果参数具有相同的值，则结果是相同的值。 如果任一值为 NaN，则结果为 NaN。 与数值比较运算符不同，此方法认为负零严格小于正零。 如果一个参数为正零而另一个为负零，则结果为负零。

参数：

返回：

a 和 b 中较小的一个。

min

public static double min(double a, double b)

返回两个双精度值中较小的一个。 也就是说，结果是更接近负无穷大的值。 如果参数具有相同的值，则结果是相同的值。 如果任一值为 NaN，则结果为 NaN。 与数值比较运算符不同，此方法认为负零严格小于正零。 如果一个参数为正零而另一个为负零，则结果为负零。

参数：

返回：

a 和 b 中较小的一个。

ulp

public static double ulp(double d)

返回参数的 ulp 的大小。 double 值的最后一个单位 ulp 是该浮点值与幅度下一个更大的 double 值之间的正距离。 请注意，对于非 NaN x，ulp(-x) == ulp(x)。

特别情况：

• 如果参数为 NaN，则结果为 NaN。
• 如果参数是正无穷或负无穷，则结果是正无穷。
• 如果参数为正零或负零，则结果为 Double.MIN_VALUE。
• 如果参数为 ±Double.MAX_VALUE，则结果等于 2971。

参数：

返回：

参数的 ulp 大小

ulp

public static float ulp(float f)

返回参数的 ulp 的大小。 浮点值的最后一个单位 ulp 是该浮点值与幅度下一个更大的浮点值之间的正距离。 请注意，对于非 NaN x，ulp(-x) == ulp(x)。

特别情况：

• 如果参数为 NaN，则结果为 NaN。
• 如果参数是正无穷或负无穷，则结果是正无穷。
• 如果参数为正零或负零，则结果为 Float.MIN_VALUE。
• 如果参数为 ±Float.MAX_VALUE，则结果等于 2104。

参数：

返回：

参数的 ulp 大小

signum

public static double signum(double d)

返回参数的符号函数； 如果参数为零，则为零，如果参数大于零，则为 1.0，如果参数小于零，则为 -1.0。

特别情况：

• 如果参数为 NaN，则结果为 NaN。
• 如果参数是正零或负零，则结果与参数相同。

参数：

返回：

参数的符号函数

signum

public static float signum(float f)

返回参数的符号函数； 如果参数为零，则为零，如果参数大于零，则为 1.0f，如果参数小于零，则为 -1.0f。

特别情况：

• 如果参数为 NaN，则结果为 NaN。
• 如果参数是正零或负零，则结果与参数相同。

参数：

返回：

参数的符号函数

sinh

public static double sinh(double x)

返回 double 值的双曲正弦值。 x 的双曲正弦定义为 (ex – e-x)/2，其中 e 是 Math#E。

特别情况：

• 如果参数为 NaN，则结果为 NaN。
• 如果参数是无限的，则结果是与参数相同符号的无穷大。
• 如果参数为零，则结果为零，符号与参数相同。

计算结果必须在精确结果的 2.5 ulps 范围内。

参数：

返回：

x 的双曲正弦。

cosh

public static double cosh(double x)

返回 double 值的双曲余弦值。 x 的双曲余弦定义为 (ex + e-x)/2，其中 e 是 Math#E。

特别情况：

• 如果参数为 NaN，则结果为 NaN。
• 如果参数是无限的，那么结果是正无穷大。
• 如果参数为零，则结果为 1.0。

计算结果必须在精确结果的 2.5 ulps 范围内。

参数：

返回：

x 的双曲余弦。

tanh

public static double tanh(double x)

返回 double 值的双曲正切值。 x 的双曲正切定义为 (ex – e-x)/(ex + e-x)，换言之，Math#sinh/Math#cosh。 请注意，精确 tanh 的绝对值始终小于 1。

特别情况：

• 如果参数为 NaN，则结果为 NaN。
• 如果参数为零，则结果为零，符号与参数相同。
• 如果参数为正无穷大，则结果为 +1.0。
• 如果参数为负无穷大，则结果为 -1.0。

计算结果必须在精确结果的 2.5 ulps 范围内。 对于任何有限输入，tanh 的结果必须具有小于或等于 1 的绝对值。请注意，一旦 tanh 的精确结果在 ±1 的极限值的 ulp 的 1/2 以内，正确符号的 ±1.0 应该是 回来。

参数：

返回：

x 的双曲正切。

hypot

public static double hypot(double x, double y)

返回 sqrt(x2 +y2) 没有中间溢出或下溢。

特别情况：

• 如果任一参数是无限的，则结果是正无穷大。
• 如果任一参数为 NaN 且两个参数都不是无限的，则结果为 NaN。

计算结果必须在精确结果的 1 ulp 范围内。 如果一个参数保持不变，则另一个参数的结果必须是半单调的。

参数：

返回：

sqrt(x2 +y2) 没有中间溢出或下溢

expm1

public static double expm1(double x)

返回 ex -1。 请注意，对于接近 0 的 x 值，expm1(x) + 1 的精确总和比 exp(x) 更接近 ex 的真实结果。

特别情况：

• 如果参数为 NaN，则结果为 NaN。
• 如果参数是正无穷大，那么结果是正无穷大。
• 如果参数为负无穷大，则结果为 -1.0。
• 如果参数为零，则结果为零，符号与参数相同。

计算结果必须在精确结果的 1 ulp 范围内。 结果必须是半单调的。 任何有限输入的 expm1 的结果必须大于或等于 -1.0。 请注意，一旦 ex – 1 的确切结果在限制值 -1 的 1/2 ulp 范围内，则应返回 -1.0。

参数：

返回：

值 ex – 1。

log1p

public static double log1p(double x)

返回参数和 1 之和的自然对数。请注意，对于较小的值 x，log1p(x) 的结果比 log( 的浮点计算更接近 ln(1 + x) 的真实结果 1.0+x)。

特别情况：

• 如果参数为 NaN 或小于 -1，则结果为 NaN。
• 如果参数是正无穷大，那么结果是正无穷大。
• 如果参数是负数，那么结果是负无穷大。
• 如果参数为零，则结果为零，符号与参数相同。

计算结果必须在精确结果的 1 ulp 范围内。 结果必须是半单调的。

参数：

返回：

ln(x + 1) 的值，x + 1 的自然对数

copySign

public static double copySign(double magnitude, double sign)

返回带有第二个浮点参数符号的第一个浮点参数。 请注意，与 StrictMath#copySign(double, double) 方法不同，此方法不需要将 NaN 符号参数视为正值； 允许实现将某些 NaN 参数视为正数，将其他 NaN 参数视为负数，以提高性能。

参数：

返回：

具有大小和符号符号的值。

copySign

public static float copySign(float magnitude, float sign)

返回带有第二个浮点参数符号的第一个浮点参数。 请注意，与 StrictMath#copySign(float, float) 方法不同，此方法不需要将 NaN 符号参数视为正值； 允许实现将某些 NaN 参数视为正数，将其他 NaN 参数视为负数，以提高性能。

参数：

返回：

具有大小和符号符号的值。

getExponent

public static int getExponent(float f)

返回浮点数表示中使用的无偏指数。 特别情况：

• 如果参数为 NaN 或无穷大，则结果为 Float#MAX_EXPONENT + 1。
• 如果参数为零或次正规，则结果为 Float#MIN_EXPONENT -1。

参数：

返回:

参数的无偏指数

getExponent

public static int getExponent(double d)

返回用于表示双精度的无偏指数。 特别情况：

• 如果参数为 NaN 或无穷大，则结果为 Double#MAX_EXPONENT + 1。
• 如果参数为零或次正规，则结果为 Double#MIN_EXPONENT -1。

参数：

返回:

参数的无偏指数

nextAfter

public static double nextAfter(double start, double direction)

返回第二个参数方向上与第一个参数相邻的浮点数。 如果两个参数比较相等，则返回第二个参数。

特别情况：

• 如果任一参数是 NaN，则返回 NaN。
• 如果两个参数都是带符号的零，则返回方向不变（如果参数比较相等，则返回第二个参数的要求暗示了这一点）。
• 如果 start 是 ±Double#MIN_VALUE 并且 direction 的值使得结果应该具有较小的幅度，则返回与 start 具有相同符号的零。
• 如果 start 是无限的，并且 direction 的值使得结果应该具有较小的幅度，则返回与 start 具有相同符号的 Double#MAX_VALUE。
• 如果 start 等于 ± Double#MAX_VALUE 并且 direction 的值使得结果应该具有更大的量级，则返回与 start 符号相同的无穷大。

参数：

返回：

以方向相邻的浮点数开始的方向。

nextAfter

public static float nextAfter(float start, double direction)

返回第二个参数方向上与第一个参数相邻的浮点数。 如果两个参数比较相等，则返回与第二个参数等效的值。

特别情况：

• 如果任一参数是 NaN，则返回 NaN。
• 如果两个参数都是带符号的零，则返回与方向等效的值。
• 如果 start 是 ±Float#MIN_VALUE 并且 direction 的值使得结果应该具有较小的幅度，则返回与 start 具有相同符号的零。
• 如果 start 是无限的，并且 direction 的值使得结果应该具有较小的幅度，则返回与 start 具有相同符号的 Float#MAX_VALUE。
• 如果 start 等于 ± Float#MAX_VALUE 并且 direction 的值使得结果应该具有更大的幅度，则返回与 start 符号相同的无穷大。

参数：

返回：

以方向相邻的浮点数开始的方向。

nextUp

public static double nextUp(double d)

返回正无穷方向上与 d 相邻的浮点值。 该方法在语义上等价于 nextAfter(d, Double.POSITIVE_INFINITY); 但是，nextUp 实现可能比其等效的 nextAfter 调用运行得更快。

特别情况：

• 如果参数为 NaN，则结果为 NaN。
• 如果参数是正无穷大，则结果是正无穷大。
• 如果参数为零，则结果为 Double#MIN_VALUE

参数：

返回：

接近正无穷大的相邻浮点值。

nextUp

public static float nextUp(float f)

返回在正无穷大方向上与 f 相邻的浮点值。 这个方法在语义上等价于 nextAfter(f, Float.POSITIVE_INFINITY); 但是，nextUp 实现可能比其等效的 nextAfter 调用运行得更快。

特别情况：

• 如果参数为 NaN，则结果为 NaN。
• 如果参数是正无穷大，则结果是正无穷大。
• 如果参数为零，则结果为 Float#MIN_VALUE

参数：

返回：

接近正无穷大的相邻浮点值。

nextDown

public static double nextDown(double d)

返回在负无穷方向上与 d 相邻的浮点值。 这个方法在语义上等价于 nextAfter(d, Double.NEGATIVE_INFINITY); 但是，nextDown 实现可能比其等效的 nextAfter 调用运行得更快。

特别情况：

• 如果参数为 NaN，则结果为 NaN。
• 如果参数为负无穷大，则结果为负无穷大。
• 如果参数为零，则结果为 -Double.MIN_VALUE

参数：

返回：

接近负无穷大的相邻浮点值。

nextDown

public static float nextDown(float f)

返回在负无穷方向上与 f 相邻的浮点值。 该方法在语义上等价于 nextAfter(f, Float.NEGATIVE_INFINITY); 但是，nextDown 实现可能比其等效的 nextAfter 调用运行得更快。

特别情况：

• 如果参数为 NaN，则结果为 NaN。
• 如果参数为负无穷大，则结果为负无穷大。
• 如果参数为零，则结果为 -Float.MIN_VALUE

参数：

返回：

接近负无穷大的相邻浮点值。

scalb

public static double scalb(double d, int scaleFactor)

返回四舍五入的 d × 2scaleFactor，就像通过单个正确舍入的浮点乘以双精度值集的成员一样。 有关浮点值集的讨论，请参阅 Java 语言规范。 如果结果的指数在 Double#MIN_EXPONENT 和 Double#MAX_EXPONENT 之间，则答案是精确计算的。 如果结果的指数大于 Double.MAX_EXPONENT，则返回无穷大。 请注意，如果结果不正常，则可能会丢失精度； 也就是说，当 scalb(x, n) 为次正规时， scalb(scalb(x, n), -n) 可能不等于 x。 当结果为非 NaN 时，结果的符号与 d 相同。

特别案例：

• 如果第一个参数是 NaN，则返回 NaN。
• 如果第一个参数是无限的，则返回相同符号的无穷大。
• 如果第一个参数为零，则返回相同符号的零。

参数：

返回：

d × 2scaleFactor

scalb

public static float scalb(float f, int scaleFactor)

返回 f × 2scaleFactor 舍入，就好像通过单个正确舍入的浮点乘以浮点值集的成员一样。 有关浮点值集的讨论，请参阅 Java 语言规范。 如果结果的指数介于 Float#MIN_EXPONENT 和 Float#MAX_EXPONENT 之间，则答案是精确计算的。 如果结果的指数大于 Float.MAX_EXPONENT，则返回无穷大。 请注意，如果结果不正常，则可能会丢失精度； 也就是说，当 scalb(x, n) 为次正规时， scalb(scalb(x, n), -n) 可能不等于 x。 当结果为非 NaN 时，结果的符号与 f 相同。

特别情况：

• 如果第一个参数是 NaN，则返回 NaN。
• 如果第一个参数是无限的，则返回相同符号的无穷大。
• 如果第一个参数为零，则返回相同符号的零。

参数：

返回：

f × 2scaleFactor