Math (moe.ios.core API)

java.lang.Object
- java.lang.Math

```
public final class Math
extends Object
```
Class Math provides basic math constants and operations such as trigonometric functions, hyperbolic functions, exponential, logarithms, etc.

Field Summary

Fields
Modifier and Type	Field and Description
`static double`	`E` The double value closest to e, the base of the natural logarithm.
`static double`	`PI` The double value closest to pi, the ratio of a circle's circumference to its diameter.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static double`	`abs(double d)` Returns the absolute value of the argument.
`static float`	`abs(float f)` Returns the absolute value of the argument.
`static int`	`abs(int i)` Returns the absolute value of the argument.
`static long`	`abs(long l)` Returns the absolute value of the argument.
`static double`	`acos(double d)` Returns the closest double approximation of the arc cosine of the argument within the range `[0..pi]`.
`static int`	`addExact(int x, int y)` Returns the sum of its arguments, throwing an exception if the result overflows an `int`.
`static long`	`addExact(long x, long y)` Returns the sum of its arguments, throwing an exception if the result overflows a `long`.
`static double`	`asin(double d)` Returns the closest double approximation of the arc sine of the argument within the range `[-pi/2..pi/2]`.
`static double`	`atan(double d)` Returns the closest double approximation of the arc tangent of the argument within the range `[-pi/2..pi/2]`.
`static double`	`atan2(double y, double x)` Returns the closest double approximation of the arc tangent of `y/x` within the range `[-pi..pi]`.
`static double`	`cbrt(double d)` Returns the closest double approximation of the cube root of the argument.
`static double`	`ceil(double d)` Returns the double conversion of the most negative (closest to negative infinity) integer value greater than or equal to the argument.
`static double`	`copySign(double magnitude, double sign)` Returns a double with the given magnitude and the sign of `sign`.
`static float`	`copySign(float magnitude, float sign)` Returns a float with the given magnitude and the sign of `sign`.
`static double`	`cos(double d)` Returns the closest double approximation of the cosine of the argument.
`static double`	`cosh(double d)` Returns the closest double approximation of the hyperbolic cosine of the argument.
`static int`	`decrementExact(int a)` Returns the argument decremented by one, throwing an exception if the result overflows an `int`.
`static long`	`decrementExact(long a)` Returns the argument decremented by one, throwing an exception if the result overflows a `long`.
`static double`	`exp(double d)` Returns the closest double approximation of the raising "e" to the power of the argument.
`static double`	`expm1(double d)` Returns the closest double approximation of `e`^d`- 1`.
`static double`	`floor(double d)` Returns the double conversion of the most positive (closest to positive infinity) integer value less than or equal to the argument.
`static int`	`floorDiv(int x, int y)` Returns the largest (closest to positive infinity) `int` value that is less than or equal to the algebraic quotient.
`static long`	`floorDiv(long x, int y)` Returns the largest (closest to positive infinity) `long` value that is less than or equal to the algebraic quotient.
`static long`	`floorDiv(long x, long y)` Returns the largest (closest to positive infinity) `long` value that is less than or equal to the algebraic quotient.
`static int`	`floorMod(int x, int y)` Returns the floor modulus of the `int` arguments.
`static int`	`floorMod(long x, int y)` Returns the floor modulus of the `long` and `int` arguments.
`static long`	`floorMod(long x, long y)` Returns the floor modulus of the `long` arguments.
`static double`	`fma(double a, double b, double c)` Returns the fused multiply add of the three arguments; that is, returns the exact product of the first two arguments summed with the third argument and then rounded once to the nearest `double`.
`static float`	`fma(float a, float b, float c)` Returns the fused multiply add of the three arguments; that is, returns the exact product of the first two arguments summed with the third argument and then rounded once to the nearest `float`.
`static int`	`getExponent(double d)` Returns the unbiased base-2 exponent of double `d`.
`static int`	`getExponent(float f)` Returns the unbiased base-2 exponent of float `f`.
`static double`	`hypot(double x, double y)` Returns `sqrt(``x`²`+` `y`²`)`.
`static double`	`IEEEremainder(double x, double y)` Returns the remainder of dividing `x` by `y` using the IEEE 754 rules.
`static int`	`incrementExact(int a)` Returns the argument incremented by one, throwing an exception if the result overflows an `int`.
`static long`	`incrementExact(long a)` Returns the argument incremented by one, throwing an exception if the result overflows a `long`.
`static double`	`log(double d)` Returns the closest double approximation of the natural logarithm of the argument.
`static double`	`log10(double d)` Returns the closest double approximation of the base 10 logarithm of the argument.
`static double`	`log1p(double d)` Returns the closest double approximation of the natural logarithm of the sum of the argument and 1.
`static double`	`max(double d1, double d2)` Returns the most positive (closest to positive infinity) of the two arguments.
`static float`	`max(float f1, float f2)` Returns the most positive (closest to positive infinity) of the two arguments.
`static int`	`max(int i1, int i2)` Returns the most positive (closest to positive infinity) of the two arguments.
`static long`	`max(long l1, long l2)` Returns the most positive (closest to positive infinity) of the two arguments.
`static double`	`min(double d1, double d2)` Returns the most negative (closest to negative infinity) of the two arguments.
`static float`	`min(float f1, float f2)` Returns the most negative (closest to negative infinity) of the two arguments.
`static int`	`min(int i1, int i2)` Returns the most negative (closest to negative infinity) of the two arguments.
`static long`	`min(long l1, long l2)` Returns the most negative (closest to negative infinity) of the two arguments.
`static int`	`multiplyExact(int x, int y)` Returns the product of the arguments, throwing an exception if the result overflows an `int`.
`static long`	`multiplyExact(long x, int y)` Returns the product of the arguments, throwing an exception if the result overflows a `long`.
`static long`	`multiplyExact(long x, long y)` Returns the product of the arguments, throwing an exception if the result overflows a `long`.
`static long`	`multiplyFull(int x, int y)` Returns the exact mathematical product of the arguments.
`static long`	`multiplyHigh(long x, long y)` Returns as a `long` the most significant 64 bits of the 128-bit product of two 64-bit factors.
`static int`	`negateExact(int a)` Returns the negation of the argument, throwing an exception if the result overflows an `int`.
`static long`	`negateExact(long a)` Returns the negation of the argument, throwing an exception if the result overflows a `long`.
`static double`	`nextAfter(double start, double direction)` Returns the next double after `start` in the given `direction`.
`static float`	`nextAfter(float start, double direction)` Returns the next float after `start` in the given `direction`.
`static double`	`nextDown(double d)` Returns the floating-point value adjacent to `d` in the direction of negative infinity.
`static float`	`nextDown(float f)` Returns the floating-point value adjacent to `f` in the direction of negative infinity.
`static double`	`nextUp(double d)` Returns the next double larger than `d`.
`static float`	`nextUp(float f)` Returns the next float larger than `f`.
`static double`	`pow(double x, double y)` Returns the closest double approximation of the result of raising `x` to the power of `y`.
`static double`	`random()` Returns a pseudo-random double `n`, where `n >= 0.0 && n < 1.0`.
`static int`	`randomIntInternal()`
`static double`	`rint(double d)` Returns the double conversion of the result of rounding the argument to an integer.
`static long`	`round(double d)` Returns the result of rounding the argument to an integer.
`static int`	`round(float f)` Returns the result of rounding the argument to an integer.
`static double`	`scalb(double d, int scaleFactor)` Returns `d` * 2^`scaleFactor`.
`static float`	`scalb(float d, int scaleFactor)` Returns `d` * 2^`scaleFactor`.
`static void`	`setRandomSeedInternal(long seed)` Set the seed for the pseudo random generator used by `random()` and `randomIntInternal()`.
`static double`	`signum(double d)` Returns the signum function of the argument.
`static float`	`signum(float f)` Returns the signum function of the argument.
`static double`	`sin(double d)` Returns the closest double approximation of the sine of the argument.
`static double`	`sinh(double d)` Returns the closest double approximation of the hyperbolic sine of the argument.
`static double`	`sqrt(double d)` Returns the closest double approximation of the square root of the argument.
`static int`	`subtractExact(int x, int y)` Returns the difference of the arguments, throwing an exception if the result overflows an `int`.
`static long`	`subtractExact(long x, long y)` Returns the difference of the arguments, throwing an exception if the result overflows a `long`.
`static double`	`tan(double d)` Returns the closest double approximation of the tangent of the argument.
`static double`	`tanh(double d)` Returns the closest double approximation of the hyperbolic tangent of the argument.
`static double`	`toDegrees(double angrad)` Returns the measure in degrees of the supplied radian angle.
`static int`	`toIntExact(long value)` Returns the value of the `long` argument; throwing an exception if the value overflows an `int`.
`static double`	`toRadians(double angdeg)` Returns the measure in radians of the supplied degree angle.
`static double`	`ulp(double d)` Returns the argument's ulp (unit in the last place).
`static float`	`ulp(float f)` Returns the argument's ulp (unit in the last place).

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - E
```
public static final double E
```
    The double value closest to e, the base of the natural logarithm.
    
    See Also:
    
    Constant Field Values
  - PI
```
public static final double PI
```
    The double value closest to pi, the ratio of a circle's circumference to its diameter.
    
    See Also:
    
    Constant Field Values
- Method Detail
  - abs
```
public static double abs(double d)
```
    Returns the absolute value of the argument.
    Special cases:
    - abs(-0.0) = +0.0
    - abs(+infinity) = +infinity
    - abs(-infinity) = +infinity
    - abs(NaN) = NaN
  - abs
```
public static float abs(float f)
```
    Returns the absolute value of the argument.
    Special cases:
    - abs(-0.0) = +0.0
    - abs(+infinity) = +infinity
    - abs(-infinity) = +infinity
    - abs(NaN) = NaN
  - abs
```
public static int abs(int i)
```
    Returns the absolute value of the argument.
    If the argument is Integer.MIN_VALUE, Integer.MIN_VALUE is returned.
  - abs
```
public static long abs(long l)
```
    Returns the absolute value of the argument. If the argument is Long.MIN_VALUE, Long.MIN_VALUE is returned.
  - acos
```
public static double acos(double d)
```
    Returns the closest double approximation of the arc cosine of the argument within the range [0..pi]. The returned result is within 1 ulp (unit in the last place) of the real result.
    Special cases:
    - acos((anything > 1) = NaN
    - acos((anything < -1) = NaN
    - acos(NaN) = NaN
    Parameters:
    
    d - the value to compute arc cosine of.
    
    Returns:
    
    the arc cosine of the argument.
  - asin
```
public static double asin(double d)
```
    Returns the closest double approximation of the arc sine of the argument within the range [-pi/2..pi/2]. The returned result is within 1 ulp (unit in the last place) of the real result.
    Special cases:
    - asin((anything > 1)) = NaN
    - asin((anything < -1)) = NaN
    - asin(NaN) = NaN
    Parameters:
    
    d - the value whose arc sine has to be computed.
    
    Returns:
    
    the arc sine of the argument.
  - atan
```
public static double atan(double d)
```
    Returns the closest double approximation of the arc tangent of the argument within the range [-pi/2..pi/2]. The returned result is within 1 ulp (unit in the last place) of the real result.
    Special cases:
    - atan(+0.0) = +0.0
    - atan(-0.0) = -0.0
    - atan(+infinity) = +pi/2
    - atan(-infinity) = -pi/2
    - atan(NaN) = NaN
    Parameters:
    
    d - the value whose arc tangent has to be computed.
    
    Returns:
    
    the arc tangent of the argument.
  - atan2
```
public static double atan2(double y,
                           double x)
```
    Returns the closest double approximation of the arc tangent of y/x within the range [-pi..pi]. This is the angle of the polar representation of the rectangular coordinates (x,y). The returned result is within 2 ulps (units in the last place) of the real result.
    Special cases:
    - atan2((anything), NaN ) = NaN;
    - atan2(NaN , (anything) ) = NaN;
    - atan2(+0.0, +(anything but NaN)) = +0.0
    - atan2(-0.0, +(anything but NaN)) = -0.0
    - atan2(+0.0, -(anything but NaN)) = +pi
    - atan2(-0.0, -(anything but NaN)) = -pi
    - atan2(+(anything but 0 and NaN), 0) = +pi/2
    - atan2(-(anything but 0 and NaN), 0) = -pi/2
    - atan2(+(anything but infinity and NaN), +infinity) = +0.0
    - atan2(-(anything but infinity and NaN), +infinity) = -0.0
    - atan2(+(anything but infinity and NaN), -infinity) = +pi
    - atan2(-(anything but infinity and NaN), -infinity) = -pi
    - atan2(+infinity, +infinity ) = +pi/4
    - atan2(-infinity, +infinity ) = -pi/4
    - atan2(+infinity, -infinity ) = +3pi/4
    - atan2(-infinity, -infinity ) = -3pi/4
    - atan2(+infinity, (anything but,0, NaN, and infinity)) = +pi/2
    - atan2(-infinity, (anything but,0, NaN, and infinity)) = -pi/2
    Parameters:
    
    y - the numerator of the value whose atan has to be computed.
    
    x - the denominator of the value whose atan has to be computed.
    
    Returns:
    
    the arc tangent of y/x.
  - cbrt
```
public static double cbrt(double d)
```
    Returns the closest double approximation of the cube root of the argument.
    Special cases:
    - cbrt(+0.0) = +0.0
    - cbrt(-0.0) = -0.0
    - cbrt(+infinity) = +infinity
    - cbrt(-infinity) = -infinity
    - cbrt(NaN) = NaN
    Parameters:
    
    d - the value whose cube root has to be computed.
    
    Returns:
    
    the cube root of the argument.
  - ceil
```
public static double ceil(double d)
```
    Returns the double conversion of the most negative (closest to negative infinity) integer value greater than or equal to the argument.
    Special cases:
    - ceil(+0.0) = +0.0
    - ceil(-0.0) = -0.0
    - ceil((anything in range (-1,0)) = -0.0
    - ceil(+infinity) = +infinity
    - ceil(-infinity) = -infinity
    - ceil(NaN) = NaN
  - cos
```
public static double cos(double d)
```
    Returns the closest double approximation of the cosine of the argument. The returned result is within 1 ulp (unit in the last place) of the real result.
    Special cases:
    - cos(+infinity) = NaN
    - cos(-infinity) = NaN
    - cos(NaN) = NaN
    Parameters:
    
    d - the angle whose cosine has to be computed, in radians.
    
    Returns:
    
    the cosine of the argument.
  - cosh
```
public static double cosh(double d)
```
    Returns the closest double approximation of the hyperbolic cosine of the argument. The returned result is within 2.5 ulps (units in the last place) of the real result.
    Special cases:
    - cosh(+infinity) = +infinity
    - cosh(-infinity) = +infinity
    - cosh(NaN) = NaN
    Parameters:
    
    d - the value whose hyperbolic cosine has to be computed.
    
    Returns:
    
    the hyperbolic cosine of the argument.
  - exp
```
public static double exp(double d)
```
    Returns the closest double approximation of the raising "e" to the power of the argument. The returned result is within 1 ulp (unit in the last place) of the real result.
    Special cases:
    - exp(+infinity) = +infinity
    - exp(-infinity) = +0.0
    - exp(NaN) = NaN
    Parameters:
    
    d - the value whose exponential has to be computed.
    
    Returns:
    
    the exponential of the argument.
  - expm1
```
public static double expm1(double d)
```
    Returns the closest double approximation of e^d- 1. If the argument is very close to 0, it is much more accurate to use expm1(d)+1 than exp(d) (due to cancellation of significant digits). The returned result is within 1 ulp (unit in the last place) of the real result.
    For any finite input, the result is not less than -1.0. If the real result is within 0.5 ulp of -1, -1.0 is returned.
    Special cases:
    - expm1(+0.0) = +0.0
    - expm1(-0.0) = -0.0
    - expm1(+infinity) = +infinity
    - expm1(-infinity) = -1.0
    - expm1(NaN) = NaN
    Parameters:
    
    d - the value to compute the e^d - 1 of.
    
    Returns:
    
    the e^d- 1 value of the argument.
  - floor
```
public static double floor(double d)
```
    Returns the double conversion of the most positive (closest to positive infinity) integer value less than or equal to the argument.
    Special cases:
    - floor(+0.0) = +0.0
    - floor(-0.0) = -0.0
    - floor(+infinity) = +infinity
    - floor(-infinity) = -infinity
    - floor(NaN) = NaN
  - hypot
```
public static double hypot(double x,
                           double y)
```
    Returns sqrt(x²+ y²). The final result is without medium underflow or overflow. The returned result is within 1 ulp (unit in the last place) of the real result. If one parameter remains constant, the result should be semi-monotonic.
    Special cases:
    - hypot(+infinity, (anything including NaN)) = +infinity
    - hypot(-infinity, (anything including NaN)) = +infinity
    - hypot((anything including NaN), +infinity) = +infinity
    - hypot((anything including NaN), -infinity) = +infinity
    - hypot(NaN, NaN) = NaN
    Parameters:
    
    x - a double number.
    
    y - a double number.
    
    Returns:
    
    the sqrt(x²+ y²) value of the arguments.
  - IEEEremainder
```
public static double IEEEremainder(double x,
                                   double y)
```
    Returns the remainder of dividing x by y using the IEEE 754 rules. The result is x-round(x/p)*p where round(x/p) is the nearest integer (rounded to even), but without numerical cancellation problems.
    Special cases:
    - IEEEremainder((anything), 0) = NaN
    - IEEEremainder(+infinity, (anything)) = NaN
    - IEEEremainder(-infinity, (anything)) = NaN
    - IEEEremainder(NaN, (anything)) = NaN
    - IEEEremainder((anything), NaN) = NaN
    - IEEEremainder(x, +infinity) = x where x is anything but +/-infinity
    - IEEEremainder(x, -infinity) = x where x is anything but +/-infinity
    Parameters:
    
    x - the numerator of the operation.
    
    y - the denominator of the operation.
    
    Returns:
    
    the IEEE754 floating point reminder of of x/y.
  - log
```
public static double log(double d)
```
    Returns the closest double approximation of the natural logarithm of the argument. The returned result is within 1 ulp (unit in the last place) of the real result.
    Special cases:
    - log(+0.0) = -infinity
    - log(-0.0) = -infinity
    - log((anything < 0) = NaN
    - log(+infinity) = +infinity
    - log(-infinity) = NaN
    - log(NaN) = NaN
    Parameters:
    
    d - the value whose log has to be computed.
    
    Returns:
    
    the natural logarithm of the argument.
  - log10
```
public static double log10(double d)
```
    Returns the closest double approximation of the base 10 logarithm of the argument. The returned result is within 1 ulp (unit in the last place) of the real result.
    Special cases:
    - log10(+0.0) = -infinity
    - log10(-0.0) = -infinity
    - log10((anything < 0) = NaN
    - log10(+infinity) = +infinity
    - log10(-infinity) = NaN
    - log10(NaN) = NaN
    Parameters:
    
    d - the value whose base 10 log has to be computed.
    
    Returns:
    
    the natural logarithm of the argument.
  - log1p
```
public static double log1p(double d)
```
    Returns the closest double approximation of the natural logarithm of the sum of the argument and 1. If the argument is very close to 0, it is much more accurate to use log1p(d) than log(1.0+d) (due to numerical cancellation). The returned result is within 1 ulp (unit in the last place) of the real result and is semi-monotonic.
    Special cases:
    - log1p(+0.0) = +0.0
    - log1p(-0.0) = -0.0
    - log1p((anything < 1)) = NaN
    - log1p(-1.0) = -infinity
    - log1p(+infinity) = +infinity
    - log1p(-infinity) = NaN
    - log1p(NaN) = NaN
    Parameters:
    
    d - the value to compute the ln(1+d) of.
    
    Returns:
    
    the natural logarithm of the sum of the argument and 1.
  - max
```
public static double max(double d1,
                         double d2)
```
    Returns the most positive (closest to positive infinity) of the two arguments.
    Special cases:
    - max(NaN, (anything)) = NaN
    - max((anything), NaN) = NaN
    - max(+0.0, -0.0) = +0.0
    - max(-0.0, +0.0) = +0.0
  - max
```
public static float max(float f1,
                        float f2)
```
    Returns the most positive (closest to positive infinity) of the two arguments.
    Special cases:
    - max(NaN, (anything)) = NaN
    - max((anything), NaN) = NaN
    - max(+0.0, -0.0) = +0.0
    - max(-0.0, +0.0) = +0.0
  - max
```
public static int max(int i1,
                      int i2)
```
    Returns the most positive (closest to positive infinity) of the two arguments.
  - max
```
public static long max(long l1,
                       long l2)
```
    Returns the most positive (closest to positive infinity) of the two arguments.
  - min
```
public static double min(double d1,
                         double d2)
```
    Returns the most negative (closest to negative infinity) of the two arguments.
    Special cases:
    - min(NaN, (anything)) = NaN
    - min((anything), NaN) = NaN
    - min(+0.0, -0.0) = -0.0
    - min(-0.0, +0.0) = -0.0
  - min
```
public static float min(float f1,
                        float f2)
```
    Returns the most negative (closest to negative infinity) of the two arguments.
    Special cases:
    - min(NaN, (anything)) = NaN
    - min((anything), NaN) = NaN
    - min(+0.0, -0.0) = -0.0
    - min(-0.0, +0.0) = -0.0
  - min
```
public static int min(int i1,
                      int i2)
```
    Returns the most negative (closest to negative infinity) of the two arguments.
  - min
```
public static long min(long l1,
                       long l2)
```
    Returns the most negative (closest to negative infinity) of the two arguments.
  - pow
```
public static double pow(double x,
                         double y)
```
    Returns the closest double approximation of the result of raising x to the power of y.
    Special cases:
    - pow((anything), +0.0) = 1.0
    - pow((anything), -0.0) = 1.0
    - pow(x, 1.0) = x
    - pow((anything), NaN) = NaN
    - pow(NaN, (anything except 0)) = NaN
    - pow(+/-(|x| > 1), +infinity) = +infinity
    - pow(+/-(|x| > 1), -infinity) = +0.0
    - pow(+/-(|x| < 1), +infinity) = +0.0
    - pow(+/-(|x| < 1), -infinity) = +infinity
    - pow(+/-1.0 , +infinity) = NaN
    - pow(+/-1.0 , -infinity) = NaN
    - pow(+0.0, (+anything except 0, NaN)) = +0.0
    - pow(-0.0, (+anything except 0, NaN, odd integer)) = +0.0
    - pow(+0.0, (-anything except 0, NaN)) = +infinity
    - pow(-0.0, (-anything except 0, NAN, odd integer)) = +infinity
    - pow(-0.0, (odd integer)) = -pow( +0 , (odd integer) )
    - pow(+infinity, (+anything except 0, NaN)) = +infinity
    - pow(+infinity, (-anything except 0, NaN)) = +0.0
    - pow(-infinity, (anything)) = -pow(0, (-anything))
    - pow((-anything), (integer)) = pow(-1,(integer))*pow(+anything,integer)
    - pow((-anything except 0 and inf), (non-integer)) = NAN
    Parameters:
    
    x - the base of the operation.
    
    y - the exponent of the operation.
    
    Returns:
    
    x to the power of y.
  - rint
```
public static double rint(double d)
```
    Returns the double conversion of the result of rounding the argument to an integer. Tie breaks are rounded towards even.
    Special cases:
    - rint(+0.0) = +0.0
    - rint(-0.0) = -0.0
    - rint(+infinity) = +infinity
    - rint(-infinity) = -infinity
    - rint(NaN) = NaN
    Parameters:
    
    d - the value to be rounded.
    
    Returns:
    
    the closest integer to the argument (as a double).
  - round
```
public static long round(double d)
```
    Returns the result of rounding the argument to an integer. The result is equivalent to (long) Math.floor(d+0.5).
    Special cases:
    - round(+0.0) = +0.0
    - round(-0.0) = +0.0
    - round((anything > Long.MAX_VALUE) = Long.MAX_VALUE
    - round((anything < Long.MIN_VALUE) = Long.MIN_VALUE
    - round(+infinity) = Long.MAX_VALUE
    - round(-infinity) = Long.MIN_VALUE
    - round(NaN) = +0.0
    Parameters:
    
    d - the value to be rounded.
    
    Returns:
    
    the closest integer to the argument.
  - round
```
public static int round(float f)
```
    Returns the result of rounding the argument to an integer. The result is equivalent to (int) Math.floor(f+0.5).
    Special cases:
    - round(+0.0) = +0.0
    - round(-0.0) = +0.0
    - round((anything > Integer.MAX_VALUE) = Integer.MAX_VALUE
    - round((anything < Integer.MIN_VALUE) = Integer.MIN_VALUE
    - round(+infinity) = Integer.MAX_VALUE
    - round(-infinity) = Integer.MIN_VALUE
    - round(NaN) = +0.0
    Parameters:
    
    f - the value to be rounded.
    
    Returns:
    
    the closest integer to the argument.
  - signum
```
public static double signum(double d)
```
    Returns the signum function of the argument. If the argument is less than zero, it returns -1.0. If the argument is greater than zero, 1.0 is returned. If the argument is either positive or negative zero, the argument is returned as result.
    Special cases:
    - signum(+0.0) = +0.0
    - signum(-0.0) = -0.0
    - signum(+infinity) = +1.0
    - signum(-infinity) = -1.0
    - signum(NaN) = NaN
    Parameters:
    
    d - the value whose signum has to be computed.
    
    Returns:
    
    the value of the signum function.
  - signum
```
public static float signum(float f)
```
    Returns the signum function of the argument. If the argument is less than zero, it returns -1.0. If the argument is greater than zero, 1.0 is returned. If the argument is either positive or negative zero, the argument is returned as result.
    Special cases:
    - signum(+0.0) = +0.0
    - signum(-0.0) = -0.0
    - signum(+infinity) = +1.0
    - signum(-infinity) = -1.0
    - signum(NaN) = NaN
    Parameters:
    
    f - the value whose signum has to be computed.
    
    Returns:
    
    the value of the signum function.
  - sin
```
public static double sin(double d)
```
    Returns the closest double approximation of the sine of the argument. The returned result is within 1 ulp (unit in the last place) of the real result.
    Special cases:
    - sin(+0.0) = +0.0
    - sin(-0.0) = -0.0
    - sin(+infinity) = NaN
    - sin(-infinity) = NaN
    - sin(NaN) = NaN
    Parameters:
    
    d - the angle whose sin has to be computed, in radians.
    
    Returns:
    
    the sine of the argument.
  - sinh
```
public static double sinh(double d)
```
    Returns the closest double approximation of the hyperbolic sine of the argument. The returned result is within 2.5 ulps (units in the last place) of the real result.
    Special cases:
    - sinh(+0.0) = +0.0
    - sinh(-0.0) = -0.0
    - sinh(+infinity) = +infinity
    - sinh(-infinity) = -infinity
    - sinh(NaN) = NaN
    Parameters:
    
    d - the value whose hyperbolic sine has to be computed.
    
    Returns:
    
    the hyperbolic sine of the argument.
  - sqrt
```
public static double sqrt(double d)
```
    Returns the closest double approximation of the square root of the argument.
    Special cases:
    - sqrt(+0.0) = +0.0
    - sqrt(-0.0) = -0.0
    - sqrt( (anything < 0) ) = NaN
    - sqrt(+infinity) = +infinity
    - sqrt(NaN) = NaN
  - tan
```
public static double tan(double d)
```
    Returns the closest double approximation of the tangent of the argument. The returned result is within 1 ulp (unit in the last place) of the real result.
    Special cases:
    - tan(+0.0) = +0.0
    - tan(-0.0) = -0.0
    - tan(+infinity) = NaN
    - tan(-infinity) = NaN
    - tan(NaN) = NaN
    Parameters:
    
    d - the angle whose tangent has to be computed, in radians.
    
    Returns:
    
    the tangent of the argument.
  - tanh
```
public static double tanh(double d)
```
    Returns the closest double approximation of the hyperbolic tangent of the argument. The absolute value is always less than 1. The returned result is within 2.5 ulps (units in the last place) of the real result. If the real result is within 0.5ulp of 1 or -1, it should return exactly +1 or -1.
    Special cases:
    - tanh(+0.0) = +0.0
    - tanh(-0.0) = -0.0
    - tanh(+infinity) = +1.0
    - tanh(-infinity) = -1.0
    - tanh(NaN) = NaN
    Parameters:
    
    d - the value whose hyperbolic tangent has to be computed.
    
    Returns:
    
    the hyperbolic tangent of the argument.
  - random
```
public static double random()
```
    Returns a pseudo-random double n, where n >= 0.0 && n < 1.0. This method reuses a single instance of Random. This method is thread-safe because access to the Random is synchronized, but this harms scalability. Applications may find a performance benefit from allocating a Random for each of their threads.
    
    Returns:
    
    a pseudo-random number.
  - setRandomSeedInternal
```
public static void setRandomSeedInternal(long seed)
```
    Set the seed for the pseudo random generator used by random() and randomIntInternal().
  - randomIntInternal
```
public static int randomIntInternal()
```
  - toRadians
```
public static double toRadians(double angdeg)
```
    Returns the measure in radians of the supplied degree angle. The result is angdeg / 180 * pi.
    Special cases:
    - toRadians(+0.0) = +0.0
    - toRadians(-0.0) = -0.0
    - toRadians(+infinity) = +infinity
    - toRadians(-infinity) = -infinity
    - toRadians(NaN) = NaN
    Parameters:
    
    angdeg - an angle in degrees.
    
    Returns:
    
    the radian measure of the angle.
  - toDegrees
```
public static double toDegrees(double angrad)
```
    Returns the measure in degrees of the supplied radian angle. The result is angrad * 180 / pi.
    Special cases:
    - toDegrees(+0.0) = +0.0
    - toDegrees(-0.0) = -0.0
    - toDegrees(+infinity) = +infinity
    - toDegrees(-infinity) = -infinity
    - toDegrees(NaN) = NaN
    Parameters:
    
    angrad - an angle in radians.
    
    Returns:
    
    the degree measure of the angle.
  - fma
```
public static double fma(double a,
                         double b,
                         double c)
```
    Returns the fused multiply add of the three arguments; that is, returns the exact product of the first two arguments summed with the third argument and then rounded once to the nearest double. The rounding is done using the round to nearest even rounding mode. In contrast, if a * b + c is evaluated as a regular floating-point expression, two rounding errors are involved, the first for the multiply operation, the second for the addition operation.
    Special cases:
    - If any argument is NaN, the result is NaN.
    - If one of the first two arguments is infinite and the other is zero, the result is NaN.
    - If the exact product of the first two arguments is infinite (in other words, at least one of the arguments is infinite and the other is neither zero nor NaN) and the third argument is an infinity of the opposite sign, the result is NaN.
    Note that fma(a, 1.0, c) returns the same result as (a + c). However, fma(a, b, +0.0) does not always return the same result as (a * b) since fma(-0.0, +0.0, +0.0) is +0.0 while (-0.0 * +0.0) is -0.0; fma(a, b, -0.0) is equivalent to (a * b) however.
    Parameters:
    
    a - a value
    
    b - a value
    
    c - a value
    
    Returns:
    
    (a × b + c) computed, as if with unlimited range and precision, and rounded once to the nearest double value
    
    Since:
    
    9
  - fma
```
public static float fma(float a,
                        float b,
                        float c)
```
    Returns the fused multiply add of the three arguments; that is, returns the exact product of the first two arguments summed with the third argument and then rounded once to the nearest float. The rounding is done using the round to nearest even rounding mode. In contrast, if a * b + c is evaluated as a regular floating-point expression, two rounding errors are involved, the first for the multiply operation, the second for the addition operation.
    Special cases:
    - If any argument is NaN, the result is NaN.
    - If one of the first two arguments is infinite and the other is zero, the result is NaN.
    - If the exact product of the first two arguments is infinite (in other words, at least one of the arguments is infinite and the other is neither zero nor NaN) and the third argument is an infinity of the opposite sign, the result is NaN.
    Note that fma(a, 1.0f, c) returns the same result as (a + c). However, fma(a, b, +0.0f) does not always return the same result as (a * b) since fma(-0.0f, +0.0f, +0.0f) is +0.0f while (-0.0f * +0.0f) is -0.0f; fma(a, b, -0.0f) is equivalent to (a * b) however.
    Parameters:
    
    a - a value
    
    b - a value
    
    c - a value
    
    Returns:
    
    (a × b + c) computed, as if with unlimited range and precision, and rounded once to the nearest float value
    
    Since:
    
    9
  - ulp
```
public static double ulp(double d)
```
    Returns the argument's ulp (unit in the last place). The size of a ulp of a double value is the positive distance between this value and the double value next larger in magnitude. For non-NaN x, ulp(-x) == ulp(x).
    Special cases:
    - ulp(+0.0) = Double.MIN_VALUE
    - ulp(-0.0) = Double.MIN_VALUE
    - ulp(+infinity) = infinity
    - ulp(-infinity) = infinity
    - ulp(NaN) = NaN
    Parameters:
    
    d - the floating-point value to compute ulp of.
    
    Returns:
    
    the size of a ulp of the argument.
  - ulp
```
public static float ulp(float f)
```
    Returns the argument's ulp (unit in the last place). The size of a ulp of a float value is the positive distance between this value and the float value next larger in magnitude. For non-NaN x, ulp(-x) == ulp(x).
    Special cases:
    - ulp(+0.0) = Float.MIN_VALUE
    - ulp(-0.0) = Float.MIN_VALUE
    - ulp(+infinity) = infinity
    - ulp(-infinity) = infinity
    - ulp(NaN) = NaN
    Parameters:
    
    f - the floating-point value to compute ulp of.
    
    Returns:
    
    the size of a ulp of the argument.
  - copySign
```
public static double copySign(double magnitude,
                              double sign)
```
    Returns a double with the given magnitude and the sign of sign. If sign is NaN, the sign of the result is arbitrary. If you need a determinate sign in such cases, use StrictMath.copySign.
    
    Since:
    
    1.6
  - copySign
```
public static float copySign(float magnitude,
                             float sign)
```
    Returns a float with the given magnitude and the sign of sign. If sign is NaN, the sign of the result is arbitrary. If you need a determinate sign in such cases, use StrictMath.copySign.
    
    Since:
    
    1.6
  - getExponent
```
public static int getExponent(float f)
```
    Returns the unbiased base-2 exponent of float f.
    
    Since:
    
    1.6
  - getExponent
```
public static int getExponent(double d)
```
    Returns the unbiased base-2 exponent of double d.
    
    Since:
    
    1.6
  - nextAfter
```
public static double nextAfter(double start,
                               double direction)
```
    Returns the next double after start in the given direction.
    
    Since:
    
    1.6
  - nextAfter
```
public static float nextAfter(float start,
                              double direction)
```
    Returns the next float after start in the given direction.
    
    Since:
    
    1.6
  - nextUp
```
public static double nextUp(double d)
```
    Returns the next double larger than d.
    
    Since:
    
    1.6
  - nextUp
```
public static float nextUp(float f)
```
    Returns the next float larger than f.
    
    Since:
    
    1.6
  - scalb
```
public static double scalb(double d,
                           int scaleFactor)
```
    Returns d * 2^scaleFactor. The result may be rounded.
    
    Since:
    
    1.6
  - scalb
```
public static float scalb(float d,
                          int scaleFactor)
```
    Returns d * 2^scaleFactor. The result may be rounded.
    
    Since:
    
    1.6
  - addExact
```
public static int addExact(int x,
                           int y)
```
    Returns the sum of its arguments, throwing an exception if the result overflows an int.
    
    Parameters:
    
    x - the first value
    
    y - the second value
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows an int
    
    Since:
    
    1.8
  - addExact
```
public static long addExact(long x,
                            long y)
```
    Returns the sum of its arguments, throwing an exception if the result overflows a long.
    
    Parameters:
    
    x - the first value
    
    y - the second value
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows a long
    
    Since:
    
    1.8
  - subtractExact
```
public static int subtractExact(int x,
                                int y)
```
    Returns the difference of the arguments, throwing an exception if the result overflows an int.
    
    Parameters:
    
    x - the first value
    
    y - the second value to subtract from the first
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows an int
    
    Since:
    
    1.8
  - subtractExact
```
public static long subtractExact(long x,
                                 long y)
```
    Returns the difference of the arguments, throwing an exception if the result overflows a long.
    
    Parameters:
    
    x - the first value
    
    y - the second value to subtract from the first
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows a long
    
    Since:
    
    1.8
  - multiplyExact
```
public static int multiplyExact(int x,
                                int y)
```
    Returns the product of the arguments, throwing an exception if the result overflows an int.
    
    Parameters:
    
    x - the first value
    
    y - the second value
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows an int
    
    Since:
    
    1.8
  - multiplyExact
```
public static long multiplyExact(long x,
                                 int y)
```
    Returns the product of the arguments, throwing an exception if the result overflows a long.
    
    Parameters:
    
    x - the first value
    
    y - the second value
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows a long
    
    Since:
    
    9
  - multiplyExact
```
public static long multiplyExact(long x,
                                 long y)
```
    Returns the product of the arguments, throwing an exception if the result overflows a long.
    
    Parameters:
    
    x - the first value
    
    y - the second value
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows a long
    
    Since:
    
    1.8
  - incrementExact
```
public static int incrementExact(int a)
```
    Returns the argument incremented by one, throwing an exception if the result overflows an int.
    
    Parameters:
    
    a - the value to increment
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows an int
    
    Since:
    
    1.8
  - incrementExact
```
public static long incrementExact(long a)
```
    Returns the argument incremented by one, throwing an exception if the result overflows a long.
    
    Parameters:
    
    a - the value to increment
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows a long
    
    Since:
    
    1.8
  - decrementExact
```
public static int decrementExact(int a)
```
    Returns the argument decremented by one, throwing an exception if the result overflows an int.
    
    Parameters:
    
    a - the value to decrement
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows an int
    
    Since:
    
    1.8
  - decrementExact
```
public static long decrementExact(long a)
```
    Returns the argument decremented by one, throwing an exception if the result overflows a long.
    
    Parameters:
    
    a - the value to decrement
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows a long
    
    Since:
    
    1.8
  - negateExact
```
public static int negateExact(int a)
```
    Returns the negation of the argument, throwing an exception if the result overflows an int.
    
    Parameters:
    
    a - the value to negate
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows an int
    
    Since:
    
    1.8
  - negateExact
```
public static long negateExact(long a)
```
    Returns the negation of the argument, throwing an exception if the result overflows a long.
    
    Parameters:
    
    a - the value to negate
    
    Returns:
    
    the result
    
    Throws:
    
    ArithmeticException - if the result overflows a long
    
    Since:
    
    1.8
  - toIntExact
```
public static int toIntExact(long value)
```
    Returns the value of the long argument; throwing an exception if the value overflows an int.
    
    Parameters:
    
    value - the long value
    
    Returns:
    
    the argument as an int
    
    Throws:
    
    ArithmeticException - if the argument overflows an int
    
    Since:
    
    1.8
  - multiplyFull
```
public static long multiplyFull(int x,
                                int y)
```
    Returns the exact mathematical product of the arguments.
    
    Parameters:
    
    x - the first value
    
    y - the second value
    
    Returns:
    
    the result
    
    Since:
    
    9
  - multiplyHigh
```
public static long multiplyHigh(long x,
                                long y)
```
    Returns as a long the most significant 64 bits of the 128-bit product of two 64-bit factors.
    
    Parameters:
    
    x - the first value
    
    y - the second value
    
    Returns:
    
    the result
    
    Since:
    
    9
  - floorDiv
```
public static int floorDiv(int x,
                           int y)
```
    Returns the largest (closest to positive infinity) int value that is less than or equal to the algebraic quotient. There is one special case, if the dividend is the Integer.MIN_VALUE and the divisor is -1, then integer overflow occurs and the result is equal to the Integer.MIN_VALUE.
    Normal integer division operates under the round to zero rounding mode (truncation). This operation instead acts under the round toward negative infinity (floor) rounding mode. The floor rounding mode gives different results than truncation when the exact result is negative.
    - If the signs of the arguments are the same, the results of floorDiv and the / operator are the same.
      For example, floorDiv(4, 3) == 1 and (4 / 3) == 1.
    - If the signs of the arguments are different, the quotient is negative and floorDiv returns the integer less than or equal to the quotient and the / operator returns the integer closest to zero.
      For example, floorDiv(-4, 3) == -2, whereas (-4 / 3) == -1.
    Parameters:
    
    x - the dividend
    
    y - the divisor
    
    Returns:
    
    the largest (closest to positive infinity) int value that is less than or equal to the algebraic quotient.
    
    Throws:
    
    ArithmeticException - if the divisor y is zero
    
    Since:
    
    1.8
    
    See Also:
    
    floorMod(int, int), floor(double)
  - floorDiv
```
public static long floorDiv(long x,
                            int y)
```
    Returns the largest (closest to positive infinity) long value that is less than or equal to the algebraic quotient. There is one special case, if the dividend is the Long.MIN_VALUE and the divisor is -1, then integer overflow occurs and the result is equal to Long.MIN_VALUE.
    Normal integer division operates under the round to zero rounding mode (truncation). This operation instead acts under the round toward negative infinity (floor) rounding mode. The floor rounding mode gives different results from truncation when the exact result is negative.
    For examples, see floorDiv(int, int).
    
    Parameters:
    
    x - the dividend
    
    y - the divisor
    
    Returns:
    
    the largest (closest to positive infinity) int value that is less than or equal to the algebraic quotient.
    
    Throws:
    
    ArithmeticException - if the divisor y is zero
    
    Since:
    
    9
    
    See Also:
    
    floorMod(long, int), floor(double)
  - floorDiv
```
public static long floorDiv(long x,
                            long y)
```
    Returns the largest (closest to positive infinity) long value that is less than or equal to the algebraic quotient. There is one special case, if the dividend is the Long.MIN_VALUE and the divisor is -1, then integer overflow occurs and the result is equal to the Long.MIN_VALUE.
    Normal integer division operates under the round to zero rounding mode (truncation). This operation instead acts under the round toward negative infinity (floor) rounding mode. The floor rounding mode gives different results than truncation when the exact result is negative.
    For examples, see floorDiv(int, int).
    
    Parameters:
    
    x - the dividend
    
    y - the divisor
    
    Returns:
    
    the largest (closest to positive infinity) long value that is less than or equal to the algebraic quotient.
    
    Throws:
    
    ArithmeticException - if the divisor y is zero
    
    Since:
    
    1.8
    
    See Also:
    
    floorMod(long, long), floor(double)
  - floorMod
```
public static int floorMod(int x,
                           int y)
```
    Returns the floor modulus of the int arguments.
    The floor modulus is x - (floorDiv(x, y) * y), has the same sign as the divisor y, and is in the range of -abs(y) < r < +abs(y).
    The relationship between floorDiv and floorMod is such that:
    - floorDiv(x, y) * y + floorMod(x, y) == x
    The difference in values between floorMod and the % operator is due to the difference between floorDiv that returns the integer less than or equal to the quotient and the / operator that returns the integer closest to zero.
    Examples:
    - If the signs of the arguments are the same, the results of floorMod and the % operator are the same.
      
      floorMod(4, 3) == 1; and (4 % 3) == 1
    - If the signs of the arguments are different, the results differ from the % operator.
      
      floorMod(+4, -3) == -2; and (+4 % -3) == +1
      
      floorMod(-4, +3) == +2; and (-4 % +3) == -1
      
      floorMod(-4, -3) == -1; and (-4 % -3) == -1
    If the signs of arguments are unknown and a positive modulus is needed it can be computed as (floorMod(x, y) + abs(y)) % abs(y).
    Parameters:
    
    x - the dividend
    
    y - the divisor
    
    Returns:
    
    the floor modulus x - (floorDiv(x, y) * y)
    
    Throws:
    
    ArithmeticException - if the divisor y is zero
    
    Since:
    
    1.8
    
    See Also:
    
    floorDiv(int, int)
  - floorMod
```
public static int floorMod(long x,
                           int y)
```
    Returns the floor modulus of the long and int arguments.
    The floor modulus is x - (floorDiv(x, y) * y), has the same sign as the divisor y, and is in the range of -abs(y) < r < +abs(y).
    The relationship between floorDiv and floorMod is such that:
    - floorDiv(x, y) * y + floorMod(x, y) == x
    For examples, see floorMod(int, int).
    Parameters:
    
    x - the dividend
    
    y - the divisor
    
    Returns:
    
    the floor modulus x - (floorDiv(x, y) * y)
    
    Throws:
    
    ArithmeticException - if the divisor y is zero
    
    Since:
    
    9
    
    See Also:
    
    floorDiv(long, int)
  - floorMod
```
public static long floorMod(long x,
                            long y)
```
    Returns the floor modulus of the long arguments.
    The floor modulus is x - (floorDiv(x, y) * y), has the same sign as the divisor y, and is in the range of -abs(y) < r < +abs(y).
    The relationship between floorDiv and floorMod is such that:
    - floorDiv(x, y) * y + floorMod(x, y) == x
    For examples, see floorMod(int, int).
    Parameters:
    
    x - the dividend
    
    y - the divisor
    
    Returns:
    
    the floor modulus x - (floorDiv(x, y) * y)
    
    Throws:
    
    ArithmeticException - if the divisor y is zero
    
    Since:
    
    1.8
    
    See Also:
    
    floorDiv(long, long)
  - nextDown
```
public static double nextDown(double d)
```
    Returns the floating-point value adjacent to d in the direction of negative infinity. This method is semantically equivalent to nextAfter(d, Double.NEGATIVE_INFINITY); however, a nextDown implementation may run faster than its equivalent nextAfter call.
    Special Cases:
    - If the argument is NaN, the result is NaN.
    - If the argument is negative infinity, the result is negative infinity.
    - If the argument is zero, the result is -Double.MIN_VALUE
    Parameters:
    
    d - starting floating-point value
    
    Returns:
    
    The adjacent floating-point value closer to negative infinity.
    
    Since:
    
    1.8
  - nextDown
```
public static float nextDown(float f)
```
    Returns the floating-point value adjacent to f in the direction of negative infinity. This method is semantically equivalent to nextAfter(f, Float.NEGATIVE_INFINITY); however, a nextDown implementation may run faster than its equivalent nextAfter call.
    Special Cases:
    - If the argument is NaN, the result is NaN.
    - If the argument is negative infinity, the result is negative infinity.
    - If the argument is zero, the result is -Float.MIN_VALUE
    Parameters:
    
    f - starting floating-point value
    
    Returns:
    
    The adjacent floating-point value closer to negative infinity.
    
    Since:
    
    1.8

Class Math

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

E

PI

Method Detail

abs

abs

abs

abs

acos

asin

atan

atan2

cbrt

ceil

cos

cosh

exp

expm1

floor

hypot

IEEEremainder

log

log10

log1p

max

max

max

max

min

min

min

min

pow

rint

round

round

signum

signum

sin

sinh

sqrt

tan

tanh

random

setRandomSeedInternal

randomIntInternal

toRadians

toDegrees

fma

fma

ulp

ulp

copySign

copySign

getExponent

getExponent

nextAfter

nextAfter

nextUp

nextUp

scalb

scalb

addExact

addExact

subtractExact

subtractExact

multiplyExact

multiplyExact

multiplyExact

incrementExact

incrementExact

decrementExact

decrementExact

negateExact

negateExact

toIntExact