java.lang
类 Math

java.lang.Object
  java.lang.Math

public final class Math
extends Object

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

与 StrictMath 类的某些数学方法不同，并非 Math 类所有等价函数的实现都定义为返回逐位相同的结果。此类在不需要严格重复的地方可以得到更好的执行。

默认情况下，很多 Math 方法仅调用 StrictMath 中的等价方法来完成它们的实现。建议代码生成器使用特定于平台的本机库或者微处理器指令（可用时）来提供 Math 方法更高性能的实现。这种更高性能的实现仍然必须遵守 Math 的规范。

实现规范的质量涉及到两种属性，即返回结果的准确性和方法的单调性。浮点 Math 方法的准确性根据 ulp（units in the last place，最后一位的进退位）来衡量。对于给定的浮点格式，特定实数值的 ulp 是包括该数值的两个浮点值的差。当作为一个整体而不是针对具体参数讨论方法的准确性时，引入的 ulp 数用于任何参数最差情况下的误差。如果一个方法的误差总是小于 0.5 ulp，那么该方法始终返回最接近准确结果的浮点数；这种方法就是正确舍入。一个正确舍入的方法通常能得到最佳的浮点近似值；然而，对于许多浮点方法，进行正确舍入有些不切实际。相反，对于 Math 类，某些方法允许误差在 1 或 2 ulp 的范围内。非正式地，对于 1 ulp 的误差范围，当准确结果是可表示的数值时，应该按照计算结果返回准确结果；否则，返回包括准确结果的两个浮点值中的一个。对于值很大的准确结果，括号的一端可以是无穷大。除了个别参数的准确性之外，维护不同参数的方法之间的正确关系也很重要。因此，大多数误差大于 0.5 ulp 的方法都要求是半单调的：只要数学函数是非递减的，浮点近似值就是非递减的；同样，只要数学函数是非递增的，浮点近似值就是非递增的。并非所有准确性为 1 ulp 的近似值都能自动满足单调性要求。

从以下版本开始：

JDK1.0

E

public static final double E

比任何其他值都更接近 e（即自然对数的底数）的 double 值。

另请参见：

常量字段值

PI

public static final double PI

比任何其他值都更接近 pi（即圆的周长与直径之比）的 double 值。

另请参见：

常量字段值

sin

public static double sin(double a)

返回角的三角正弦。特殊情况如下：

• 如果参数为 NaN 或无穷大，那么结果为 NaN。
• 如果参数为 0，那么结果为 0，符号与参数符号相同。

计算结果必须在准确结果的 1 ulp 范围内。结果必须具有半单调性。

参数：

a - 以弧度表示的角。

返回：

参数的正弦。

cos

public static double cos(double a)

返回角的三角余弦。特殊情况如下：

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

计算结果必须在准确结果的 1 ulp 范围内。结果必须具有半单调性。

参数：

a - 以弧度表示的角。

返回：

参数的余弦。

tan

public static double tan(double a)

返回角的三角正切。特殊情况如下：

• 如果参数为 NaN 或无穷大，那么结果为 NaN。
• 如果参数为 0，那么结果为 0，符号与参数符号相同。

计算结果必须在准确结果的 1 ulp 范围内。结果必须具有半单调性。

参数：

a - 以弧度表示的角。

返回：

参数的正切。

asin

public static double asin(double a)

返回一个值的反正弦；返回的角度范围在 -pi/2 到 pi/2 之间。特殊情况如下：

• 如果参数为 NaN 或它的绝对值大于 1，那么结果为 NaN。
• 如果参数为 0，那么结果为 0，符号与参数符号相同。

计算结果必须在准确结果的 1 ulp 范围内。结果必须具有半单调性。

参数：

a - 要返回其反正弦的值。

返回：

参数的反正弦。

acos

public static double acos(double a)

返回一个值的反余弦；返回的角度范围在 0.0 到 pi 之间。特殊情况如下：

• 如果参数为 NaN 或它的绝对值大于 1，那么结果为 NaN。

计算结果必须在准确结果的 1 ulp 范围内。结果必须具有半单调性。

参数：

a - 要返回其反余弦的值。

返回：

参数的反余弦。

atan

public static double atan(double a)

返回一个值的反正切；返回的角度范围在 -pi/2 到 pi/2 之间。特殊情况如下：

• 如果参数为 NaN，那么结果为 NaN。
• 如果参数为 0，那么结果为 0，符号与参数符号相同。

计算结果必须在准确结果的 1 ulp 范围内。结果必须具有半单调性。

参数：

a - 要返回其反正切的值。

返回：

参数的反正切。

toRadians

public static double toRadians(double angdeg)

将用角度表示的角转换为近似相等的用弧度表示的角。从角度到弧度的转换通常是不精确的。

参数：

angdeg - 用角度表示的角

返回：

角 angrad 用弧度表示的值。

从以下版本开始：

1.2

toDegrees

public static double toDegrees(double angrad)

将用弧度表示的角转换为近似相等的用角度表示的角。从弧度到角度的转换通常是不精确的；用户不 应该期望 cos(toRadians(90.0)) 与 0.0 完全相等。

参数：

angrad - 用弧度表示的角。

返回：

角 angrad 用角度表示的值。

从以下版本开始：

1.2

exp

public static double exp(double a)

返回欧拉数 e 的 double 次幂的值。特殊情况如下：

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

计算结果必须在准确结果的 1 ulp 范围内。结果必须具有半单调性。

参数：

a - e 的指数。

返回：

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

log

public static double log(double a)

返回 double 值的自然对数（底数是 e）。特殊情况如下：

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

计算结果必须在准确结果的 1 ulp 范围内。结果必须具有半单调性。

参数：

a - 一个值

返回：

ln a 的值，即 a 的自然对数。

log10

public static double log10(double a)

返回 double 值的底数为 10 的对数。特殊情况如下：

• 如果参数为 NaN 或小于 0，那么结果为 NaN。
• 如果参数为正无穷大，那么结果为正无穷大。
• 如果参数为正 0 或负 0，那么结果为负无穷大。
• 如果参数等于 10 ⁿ（n 为整数），那么结果为 n。

计算结果必须在准确结果的 1 ulp 范围内。结果必须具有半单调性。

参数：

a - 一个值

返回：

a 的底数为 10 的对数。

从以下版本开始：

1.5

sqrt

public static double sqrt(double a)

返回正确舍入的 double 值的正平方根。特殊情况如下：

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

否则，结果为最接近该参数值的实际数学平方根的 double 值。

参数：

a - 一个值。

返回：

a 的正平方根。 如果参数为 NaN 或小于 0，那么结果为 NaN。

cbrt

public static double cbrt(double a)

返回 double 值的立方根。对于正的有限值 x，cbrt(-x) == -cbrt(x)；也就是说，负值的立方根是该值数值的负立方根。特殊情况如下：

• 如果参数为 NaN，那么结果为 NaN。
• 如果参数为无穷大，那么结果为无穷大，符号与参数符号相同。
• 如果参数为 0，那么结果为 0，符号与参数符号相同。

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

参数：

a - 一个值。

返回：

a 的立方根。

从以下版本开始：

1.5

IEEEremainder

public static double IEEEremainder(double f1,
                                   double f2)

按照 IEEE 754 标准的规定，对两个参数进行余数运算。余数的算术值等于 f1 - f2 × n，其中 n 是最接近商 f1/f2 准确算术值的整数，如果两个整数都同样接近 f1/f2，那么 n 是其中的偶数。如果余数是 0，那么它的符号与第一个参数的符号相同。特殊情况如下：

• 如果两个参数都为 NaN，或者第一个参数为无穷大，或者第二个参数为正 0 或负 0，那么结果为 NaN。
• 如果第一个参数为有限值，第二个参数为无穷大，那么结果与第一个参数相同。

参数：

f1 - 被除数。

f2 - 除数。

返回：

f1 除以 f2 的余数。

ceil

public static double ceil(double a)

返回最小的（最接近负无穷大）double 值，该值大于等于参数，并等于某个整数。特殊情况如下：

• 如果参数值已经等于某个整数，那么结果与该参数相同。
• 如果参数为 NaN、无穷大、正 0 或负 0，那么结果与参数相同。
• 如果参数值小于 0，但是大于 -1.0，那么结果为负 0。

注意，Math.ceil(x) 的值与 -Math.floor(-x) 的值完全相同。

参数：

a - 一个值。

返回：

最小（最接近负无穷大）浮点值，该值大于等于该参数，并等于某个整数。

floor

public static double floor(double a)

返回最大的（最接近正无穷大）double 值，该值小于等于参数，并等于某个整数。特殊情况如下：

• 如果参数值已经等于某个整数，那么结果与该参数相同。
• 如果参数为 NaN、无穷大、正 0 或负 0，那么结果与参数相同。

参数：

a - 一个值。

返回：

最大（最接近正无穷大）浮点值，该值小于等于该参数，并等于某个整数。

rint

public static double rint(double a)

返回最接近参数并等于某一整数的 double 值。如果两个同为整数的 double 值都同样接近，那么结果取偶数。特殊情况如下：

• 如果参数值已经是整数，那么结果与参数相同。
• 如果参数为 NaN、无穷大、正 0 或负 0，那么结果与参数相同。

参数：

a - double 值。

返回：

最接近 a 的整数浮点值。

atan2

public static double atan2(double y,
                           double x)

将矩形坐标 (x, y) 转换成极坐标 (r, theta)，返回所得角 theta。该方法通过计算 y/x 的反正切值来计算相角 theta，范围为从 -pi 到 pi。特殊情况如下：

• 如果任一参数为 NaN，那么结果为 NaN。
• 如果第一个参数为正 0，第二个参数为正数；或者第一个参数为正的有限值，第二个参数为正无穷大，那么结果为正 0。
• 如果第一个参数为负 0，第二个参数为正数；或者第一个参数为负的有限值，第二个参数为正无穷大，那么结果为负 0。
• 如果第一个参数为正 0，第二个参数为负数；或者第一个参数为正的有限值，第二个参数为负无穷大，那么结果为最接近 pi 的 double 值。
• 如果第一个参数为负 0，第二个参数为负数；或者第一个参数为负的有限值，第二个参数为负无穷大，那么结果为最接近 pi 的 double 值。
• 如果第一个参数为正数，第二个参数为正 0 或负 0；或者第一个参数为正无穷大，第二个参数为有限值，那么结果为最接近 pi/2 的 double 值。
• 如果第一个参数为负数，第二个参数为正 0 或负 0；或者第一个参数为负无穷大，第二个参数为有限值，那么结果为最接近 -pi/2 的 double 值。
• 如果两个参数都为正无穷大，那么结果为最接近 pi/4 的 double 值。
• 如果第一个参数为正无穷大，第二个参数为负无穷大，那么结果为最接近 3*pi/4 的 double 值。
• 如果第一个参数为负无穷大，第二个参数为正无穷大，那么结果为最接近 -pi/4 的 double 值。
• 如果两个参数都为负无穷大，那么结果为最接近 -3*pi/4 的 double 值。

计算结果必须在准确结果的 2 ulp 范围内。结果必须具有半单调性。

参数：

y - 纵坐标

x - 横坐标

返回：

与笛卡儿坐标中点 (x, y) 对应的极坐标中点 (r, theta) 的 theta 组件。

pow

public static double pow(double a,
                         double b)

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

• 如果第二个参数为正 0 或负 0，那么结果为 1.0。
• 如果第二个参数为 1.0，那么结果与第一个参数相同。
• 如果第二个参数为 NaN，那么结果为 NaN。
• 如果第一个参数为 NaN，第二个参数非 0，那么结果为 NaN。
• 如果
  • 第一个参数的绝对值大于 1，并且第二个参数为正无穷大，或者
  • 第一个参数的绝对值小于 1，并且第二个参数为负无穷大，
  那么结果为正无穷大。
• 如果
  • 第一个参数的绝对值大于 1，并且第二个参数为负无穷大，或者
  • 第一个参数的绝对值小于 1，并且第二个参数为正无穷大，
  那么结果为正 0。
• 如果第一个参数的绝对值等于1，并且第二个参数为无穷大，那么结果为 NaN。
• 如果
  • 第一个参数为正 0，并且第二个参数大于 0，或者
  • 第一个参数为正无穷大，并且第二个参数小于 0，
  那么结果为正 0。
• 如果
  • 第一个参数为正 0，并且第二个参数小于 0，或者
  • 第一个参数为正无穷大，并且第二个参数大于 0，
  那么结果为正无穷大。
• 如果
  • 如果第一个参数为负 0，并且第二个参数大于 0 但不是有限的奇数整数，或者
  • 第一个参数为负无穷大，并且第二个参数小于 0 但不是有限的奇数整数，
  那么结果为正 0。
• 如果
  • 第一个参数为负 0，并且第二个参数为正的有限奇数整数，或者
  • 第一个参数为负无穷大，并且第二个参数为负的有限奇数整数，
  那么结果为负 0。
• 如果
  • 如果第一个参数为负 0，并且第二个参数小于 0 但不是有限的奇数整数，或者
  • 第一个参数为负无穷大，并且第二个参数大于 0 但不是有限的奇数整数，
  那么结果为正无穷大。
• 如果
  • 第一个参数为负 0，并且第二个参数为负的有限奇数整数，或者
  • 第一个参数为负无穷大，并且第二个参数为正的有限奇数整数，
  那么结果为负无穷大。
• 如果第一个参数为小于 0 的有限值，
  • 如果第二个参数为有限的偶数整数，那么结果等于第一个参数绝对值的第二个参数次幂的结果。
  • 如果第二个参数为有限的奇数整数，那么结果等于负的第一个参数绝对值的第二个参数次幂的结果。
  • 如果第二个参数为有限的非整数值，那么结果为 NaN。
• 如果两个参数都为整数，并且结果恰好可以表示为一个 double 值，那么该结果恰好等于第一个参数的第二个参数次幂的算术结果。

（在前面的描述中，当且仅当浮点数为有限值并且是方法 ceil 的定点数，或者是方法 floor 的定点数时，才可以认为浮点值是整数。当且仅当将某个单参数方法应用到某个值的结果等于该值时，该值才是这个方法的定点值。）

计算结果必须在准确结果的 1 ulp 范围内。结果必须具有半单调性。

参数：

a - 底数。

b - 指数。

返回：

值 ab。

round

public static int round(float a)

返回最接近参数的 int。结果将舍入为整数：加上 1/2，对结果调用 floor 并将所得结果强制转换为 int 类型。换句话说，结果等于以下表达式的值：

(int)Math.floor(a + 0.5f)

特殊情况如下：

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

参数：

a - 要舍入为整数的浮点值。

返回：

舍入为最接近的 int 值的参数值。

另请参见：

Integer.MAX_VALUE, Integer.MIN_VALUE

round

public static long round(double a)

返回最接近参数的 long。结果将舍入为整数：加上 1/2，对结果调用 floor 并将所得结果强制转换为 long 类型。换句话说，结果等于以下表达式的值：

(long)Math.floor(a + 0.5d)

特殊情况如下：

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

参数：

a - 舍入为 long 的浮点值。

返回：

舍入为最接近的 long 值的参数值。

另请参见：

Long.MAX_VALUE, Long.MIN_VALUE

random

public static double random()

返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。返回值是一个伪随机选择的数，在该范围内（近似）均匀分布。

第一次调用该方法时，它将创建一个新的伪随机数生成器，与以下表达式完全相同

new java.util.Random

之后，新的伪随机数生成器可用于此方法的所有调用，但不能用于其他地方。

此方法是完全同步的，可允许多个线程使用而不出现错误。但是，如果许多线程需要以极高的速率生成伪随机数，那么这可能会减少每个线程对拥有自己伪随机数生成器的争用。

返回：

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

另请参见：

Random.nextDouble()

abs

public static int abs(int a)

返回 int 值的绝对值。如果参数为非负数，则返回该参数。如果参数为负数，则返回该参数的相反数。

注意，如果参数等于 Integer.MIN_VALUE 的值（即能够表示的最小负 int 值），那么结果与该值相同且为负。

参数：

a - 要确定绝对值的参数。

返回：

参数的绝对值。

另请参见：

Integer.MIN_VALUE

abs

public static long abs(long a)

返回 long 值的绝对值。如果参数为非负数，则返回该参数。如果参数为负数，则返回该参数的相反数。

注意，如果参数等于 Long.MIN_VALUE 的值（即能够表示的最小负 long 值），则结果与该值相同且为负。

参数：

a - 要确定绝对值的参数。

返回：

参数的绝对值。

另请参见：

Long.MIN_VALUE

abs

public static float abs(float a)

返回 float 值的绝对值。如果参数为非负数，则返回该参数。如果参数为负数，则返回该参数的相反数。特殊情况如下：

• 如果参数为正 0 或负 0，那么结果为正 0。
• 如果参数为无穷大，那么结果为正无穷大。
• 如果参数为 NaN，那么结果为 NaN。

换句话说，结果等于以下表达式的值：

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

参数：

a - 要确定绝对值的参数。

返回：

参数的绝对值。

abs

public static double abs(double a)

返回 double 值的绝对值。如果参数为非负数，则返回该参数。如果参数为负数，则返回该参数的相反数。特殊情况如下：

• 如果参数为正 0 或负 0，那么结果为正 0。
• 如果参数为无穷大，那么结果为正无穷大。
• 如果参数为 NaN，那么结果为 NaN。

换句话说，结果等于以下表达式的值：

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

参数：

a - 要确定绝对值的参数。

返回：

参数的绝对值。

max

public static int max(int a,
                      int b)

返回两个 int 值中较大的一个。也就是说，结果为更接近 Integer.MAX_VALUE 值的参数。如果参数值相同，那么结果也是同一个值。

参数：

a - 参数。

b - 另一个参数。

返回：

a 和 b 中的较大者。

另请参见：

Long.MAX_VALUE

max

public static long max(long a,
                       long b)

返回两个 long 值中较大的一个。也就是说，结果为更接近 Long.MAX_VALUE 值的参数。如果参数值相同，那么结果也是同一个值。

参数：

a - 参数。

b - 另一个参数。

返回：

a 和 b 中的较大者。

另请参见：

Long.MAX_VALUE

max

public static float max(float a,
                        float b)

返回两个 float 值中较大的一个。也就是说，结果为更接近正无穷大的参数。如果参数值相同，那么结果也是同一个值。如果任一值为 NaN，那么结果为 NaN。与数值比较运算不同，此方法认为负 0 严格小于正 0。如果一个参数为正 0，另一个参数为负 0，那么结果为正 0。

参数：

a - 参数。

b - 另一个参数。

返回：

a 和 b 中的较大者。

max

public static double max(double a,
                         double b)

返回两个 double 值中较大的一个。也就是说，结果为更接近正无穷大的参数。如果参数值相同，那么结果也是同一个值。如果任一值为 NaN，那么结果为 NaN。与数值比较运算不同，该方法认为负 0 严格小于正 0。如果一个参数为正 0，另一个参数为负 0，那么结果为正 0。

参数：

a - 参数。

b - 另一个参数。

返回：

a 和 b 中的较大者。

min

public static int min(int a,
                      int b)

返回两个 int 值中较小的一个。也就是说，结果为更接近 Integer.MIN_VALUE 值的参数。如果参数值相同，那么结果也是同一个值。

参数：

a - 参数。

b - 另一个参数。

返回：

a 和 b 中的较小者。

另请参见：

Long.MIN_VALUE

min

public static long min(long a,
                       long b)

返回两个 long 值中较小的一个。也就是说，结果为更接近 Long.MIN_VALUE 值的参数。如果参数值相同，那么结果也是同一个值。

参数：

a - 参数。

b - 另一个参数。

返回：

a 和 b 中的较小者。

另请参见：

Long.MIN_VALUE

min

public static float min(float a,
                        float b)

返回两个 float 值中较小的一个。也就是说，结果为更接近负无穷大的值。如果参数值相同，那么结果也是同一个值。如果任一值为 NaN，那么结果为 NaN。与数值比较运算不同，该方法认为负 0 严格小于正 0。如果一个参数为正 0，另一个参数为负 0，那么结果为负 0。

参数：

a - 参数。

b - 另一个参数。

返回：

a 和 b 中的较小者。

min

public static double min(double a,
                         double b)

返回两个 double 值中较小的一个。也就是说，结果为更接近负无穷大的值。如果参数值相同，那么结果也是同一个值。如果任一值为 NaN，那么结果为 NaN。与数值比较运算不同，该方法认为负 0 严格小于正 0。如果一个参数为正 0，另一个参数为负 0，那么结果为负 0。

参数：

a - 参数。

b - 另一个参数。

返回：

a 和 b 中的较小者。

ulp

public static double ulp(double d)

返回参数的 ulp 大小。double 值的 ulp 是此浮点值与下一个数值较大的 double 值之间的正距离。注意，对于非 NaN x，ulp(-x) == ulp(x)。

特殊情况如下：

• 如果参数为 NaN，那么结果为 NaN。
• 如果参数为正的或负的无穷大，那么结果为正无穷大。
• 如果参数为正 0 或负 0，那么结果为 Double.MIN_VALUE。
• 如果参数为 ±Double.MAX_VALUE，那么结果等于 2⁹⁷¹。

参数：

d - 要返回 ulp 的浮点值

返回：

参数的 ulp 大小

从以下版本开始：

1.5

ulp

public static float ulp(float f)

返回参数的 ulp 大小。float 值的 ulp 是该浮点值与下一个数值较大的 float 值之间的正距离。注意，对于非 NaN x，ulp(-x) == ulp(x)。

特殊情况如下：

• 如果参数为 NaN，那么结果为 NaN。
• 如果参数为正的或负的无穷大，那么结果为正无穷大。
• 如果参数为正 0 或负 0，那么结果为 Float.MIN_VALUE。
• 如果参数为 ±Float.MAX_VALUE，那么结果等于 2¹⁰⁴。

参数：

f - 要返回 ulp 的浮点值

返回：

参数的 ulp 大小

从以下版本开始：

1.5

signum

public static double signum(double d)

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

特殊情况如下：

• 如果参数为 NaN，那么结果为 NaN。
• 如果参数为正 0 或负 0，那么结果与参数相同。

参数：

d - 要返回符号函数的浮点值

返回：

参数的符号函数

从以下版本开始：

1.5

signum

public static float signum(float f)

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

特殊情况如下：

• 如果参数为 NaN，那么结果为 NaN。
• 如果参数为正 0 或负 0，那么结果与参数相同。

参数：

f - 要返回符号函数的浮点值

返回：

参数的符号函数

从以下版本开始：

1.5

sinh

public static double sinh(double x)

返回 double 值的双曲线正弦。x 双曲线正弦的定义是 (e^x - e^-x)/2，其中 e 是欧拉数。

特殊情况如下：

• 如果参数为 NaN，那么结果为 NaN。
• 如果参数为无穷大，那么结果为无穷大，符号与参数符号相同。
• 如果参数为 0，那么结果为 0，符号与参数符号相同。

计算结果必须在准确结果的 2.5 ulp 范围内。

参数：

x - 要返回其双曲线正弦的数字。

返回：

x 的双曲线正弦。

从以下版本开始：

1.5

cosh

public static double cosh(double x)

返回 double 值的双曲线余弦。x 的双曲线余弦的定义是 (e^x + e^-x)/2，其中 e 是欧拉数。

特殊情况如下：

• 如果参数为 NaN，那么结果为 NaN。
• 如果参数为无穷大，那么结果为正无穷大。
• 如果参数为 0，那么结果为 1.0。

计算结果必须在准确结果的 2.5 ulp 范围内。

参数：

x - 要返回其双曲线余弦的数字。

返回：

x 的双曲线余弦。

从以下版本开始：

1.5

tanh

public static double tanh(double x)

返回 double 值的双曲线余弦。x 的双曲线正切的定义是 (e^x - e^-x)/(e^x + e^-x)，即 sinh(x)/cosh(x)。注意，准确的 tanh 绝对值始终小于 1。

特殊情况如下：

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

计算结果必须在准确结果的 2.5 ulp 范围内。任何有限输入值的 tanh 结果的绝对值必定小于等于 1。注意，一旦准确的 tanh 结果在极限值 ±1 的 1/2 ulp 内，则应该返回有正确符号的 ±1.0。

参数：

x - 要返回其双曲线正切的数字。

返回：

x 的双曲线正切。

从以下版本开始：

1.5

hypot

public static double hypot(double x,
                           double y)

返回 sqrt(x² +y²)，没有中间溢出或下溢。

特殊情况如下：

• 如果两个参数都为无穷大，那么结果为正无穷大。
• 如果两个参数都为 NaN 且都不是无穷大，那么结果为 NaN。

计算结果必须在准确结果的 1 ulp 范围内。如果一个参数保持常量，那么在另一个参数中，结果必须具有半单调性。

参数：

x - 一个值

y - 一个值

返回：

没有中间溢出或下溢的 sqrt(x² +y²)

从以下版本开始：

1.5

expm1

public static double expm1(double x)

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

特殊情况如下：

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

计算结果必须在准确结果的 1 ulp 范围内。结果必须具有半单调性。任何有限输入值的 expm1 的结果一定大于或等于 -1.0。注意，一旦 e^x - 1 的准确结果在极限值 -1 的 1/2 ulp 范围内，则应该返回 -1.0。

参数：

x - 在 e^x -1 的计算中 e 的指数。

返回：

值 e^x - 1。

从以下版本开始：

1.5

log1p

public static double log1p(double x)

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

特殊情况如下：

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

计算结果必须在准确结果的 1 ulp 范围内。结果必须具有半单调性。

参数：

x - 一个值

返回：

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

从以下版本开始：

1.5

copySign

public static double copySign(double magnitude,
                              double sign)

返回带有第二个浮点参数符号的第一个浮点参数。注意，与 StrictMath.copySign 方法不同，此方法不要求将 NaN sign 参数视为正值；允许实现将某些 NaN 参数视为正，将另一些视为负，以获得更好的性能。

参数：

magnitude - 提供结果数值的参数

sign - 提供结果符号的参数

返回：

一个值，带有 magnitude 的数值，sign 的符号。

从以下版本开始：

1.6

copySign

public static float copySign(float magnitude,
                             float sign)

返回带有第二个浮点参数符号的第一个浮点参数。注意，与 StrictMath.copySign 方法不同，此方法不要求将 NaN sign 参数视为正值；允许实现将某些 NaN 参数视为正，将另一些视为负，以获得更好的性能。

参数：

magnitude - 提供结果数值的参数

sign - 提供结果符号的参数

返回：

一个值，带有 magnitude 的数值，sign 的符号。

从以下版本开始：

1.6

getExponent

public static int getExponent(float f)

返回 float 表示形式中使用的无偏指数。特殊情况如下：

• 如果参数为 NaN 或无穷大，那么结果为 Float.MAX_EXPONENT + 1。
• 如果参数为 0 或 subnormal，那么结果为 Float.MIN_EXPONENT -1。

参数：

f - 一个 float 值

返回：

参数的无偏指数

从以下版本开始：

1.6

getExponent

public static int getExponent(double d)

返回 double 表示形式中使用的无偏指数。特殊情况如下：

• 如果参数为 NaN 或无穷大，那么结果为 Double.MAX_EXPONENT + 1。
• 如果参数为 0 或 subnormal，那么结果为 Double.MIN_EXPONENT -1。

参数：

d - double 值

返回：

参数的无偏指数

从以下版本开始：

1.6

nextAfter

public static double nextAfter(double start,
                               double direction)

返回第一个参数和第二个参数之间与第一个参数相邻的浮点数。如果两个参数比较起来相等，则返回第二个参数。

特殊情况如下：

• 如果任一参数为 NaN，则返回 NaN。
• 如果两个参数都为有符号的 0，则不做更改地返回 direction（根据要求，如果参数比较起来相等，将返回第二个参数）。
• 如果 start 为 ±Double.MIN_VALUE，而 direction 的值要求结果为一个比 start 小的数值，那么将返回 0，并带有与 start 相同的符号。
• 如果 start 为无穷大，而 direction 的值要求结果为一个比 start 小的数值，则返回 Double.MAX_VALUE，并带有与 start 相同的符号。
• 如果 start 等于 ±Double.MAX_VALUE，而 direction 的值要求结果为一个比 start 大的数值，则返回无穷大，并带有与 start 相同的符号。

参数：

start - 起始浮点值。

direction - 一个值，指示应返回 start 的某个邻数还是 start。

返回：

start 和 direction 之间与 start 相邻的浮点数。

从以下版本开始：

1.6

nextAfter

public static float nextAfter(float start,
                              double direction)

返回第一个参数和第二个参数之间与第一个参数相邻的浮点数。如果两个参数比较起来相等，则返回一个与第二个参数相等的值。

特殊情况如下：

• 如果任一参数为 NaN，则返回 NaN。
• 如果两个参数都为有符号的 0，则返回等于 direction 的值。
• 如果 start 为 ±Float.MIN_VALUE，而 direction 的值要求结果为一个比 start 小的数值，那么将返回 0，并带有与 start 相同的符号。
• 如果 start 为无穷大，而 direction 的值要求结果为一个比 start 小的数值，则返回 Float.MAX_VALUE，并带有与 start 相同的符号。
• 如果 start 等于 ±Float.MAX_VALUE，而 direction 的值要求结果为一个比 start 大的数值，则返回无穷大，并带有与 start 相同的符号。

参数：

start - 起始浮点值。

direction - 一个值，指示应返回 start 的某个邻数还是 start。

返回：

start 和 direction 之间与 start 相邻的浮点数。

从以下版本开始：

1.6

nextUp

public static double nextUp(double d)

返回 d 和正无穷大之间与 d 相邻的浮点值。此方法在语义上等同于 nextAfter(d, Double.POSITIVE_INFINITY)；但是，nextUp 实现的返回速度可能比其等价 nextAfter 调用快。

特殊情况如下：

• 如果参数为 NaN，那么结果为 NaN。
• 如果参数为正无穷大，那么结果为正无穷大。
• 如果参数为 0，那么结果为 Double.MIN_VALUE。

参数：

d - 起始浮点值。

返回：

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

从以下版本开始：

1.6

nextUp

public static float nextUp(float f)

返回 f 和正无穷大之间与 f 相邻的浮点值。此方法在语义上等同于 nextAfter(f, Float.POSITIVE_INFINITY)；但是，nextUp 实现的返回速度可能比其等价 nextAfter 调用快。

特殊情况如下：

• 如果参数为 NaN，那么结果为 NaN。
• 如果参数为正无穷大，那么结果为正无穷大。
• 如果参数为 0，那么结果为 Float.MIN_VALUE

参数：

f - 起始浮点值

返回：

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

从以下版本开始：

1.6

scalb

public static double scalb(double d,
                           int scaleFactor)

返回 d × 2^scaleFactor，其舍入方式如同将一个正确舍入的浮点值乘以 double 值集合中的一个值。有关浮点值集合的讨论，请参阅 Java 语言规范。如果结果的指数在 Double.MIN_EXPONENT 和 Double.MAX_EXPONENT 之间，则可以正确地计算答案；如果结果的指数大于 Double.MAX_EXPONENT，则返回无穷大。注意，如果结果为 subnormal，则可能丢失精度；也就是说，scalb(x, n) 为 subnormal 时，scalb(scalb(x, n), -n) 可能不等于 x。结果为非 NaN 时，结果的符号将与 d 相同。

特殊情况如下：

• 如果第一个参数为 NaN，则返回 NaN。
• 如果第一个参数为无穷大，则返回带有相同符号的无穷大。
• 如果第一个参数为 0，则返回带有相同符号的 0。

参数：

d - 要使用 2 的次幂缩放的数。

scaleFactor - 用来缩放 d 的 2 的次幂

返回：

d × 2^scaleFactor

从以下版本开始：

1.6

scalb

public static float scalb(float f,
                          int scaleFactor)

返回 f × 2^scaleFactor，其舍入方式如同将一个正确舍入的浮点值乘以 float 值集合中的一个值。有关浮点值集合的讨论，请参阅 Java 语言规范。如果结果的指数在 Float.MIN_EXPONENT 和 Float.MAX_EXPONENT 之间，则可以正确地计算答案；如果结果的指数大于 Float.MAX_EXPONENT，则返回无穷大。注意，如果结果为 subnormal，则可能丢失精度；也就是说，scalb(x, n) 为 subnormal 时，scalb(scalb(x, n), -n) 可能不等于 x。结果为非 NaN 时，结果的符号将与 f 相同。

特殊情况如下：

• 如果第一个参数为 NaN，则返回 NaN。
• 如果第一个参数为无穷大，则返回带有相同符号的无穷大。
• 如果第一个参数为 0，则返回带有相同符号的 0。

参数：

f - 要使用 2 的次幂缩放的数。

scaleFactor - 用来缩放 f 的 2 的次幂

返回：

f × 2^scaleFactor

从以下版本开始：

1.6

版权所有 2007 Sun Microsystems, Inc. 保留所有权利。 请遵守许可证条款。另请参阅文档重新分发政策。