public final class Math extends Object
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.

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 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 which is greater than 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 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 which is less than the argument.

static int 
getExponent(double d)
Returns the unbiased base2 exponent of double
d . 
static int 
getExponent(float f)
Returns the unbiased base2 exponent of float
f . 
static double 
hypot(double x,
double y)
Returns
sqrt( x ^{2}+
y ^{2}) . 
static double 
IEEEremainder(double x,
double y)
Returns the remainder of dividing
x by y using the IEEE
754 rules. 
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 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 
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 pseudorandom double
n , where n >= 0.0 && n < 1.0 . 
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 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 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 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).

public static final double E
public static final double PI
public static double abs(double d)
Special cases:
abs(0.0) = +0.0
abs(+infinity) = +infinity
abs(infinity) = +infinity
abs(NaN) = NaN
public static float abs(float f)
Special cases:
abs(0.0) = +0.0
abs(+infinity) = +infinity
abs(infinity) = +infinity
abs(NaN) = NaN
public static int abs(int i)
If the argument is Integer.MIN_VALUE
, Integer.MIN_VALUE
is returned.
public static long abs(long l)
Long.MIN_VALUE
, Long.MIN_VALUE
is returned.public static double acos(double d)
[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
d
 the value to compute arc cosine of.public static double asin(double d)
[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
d
 the value whose arc sine has to be computed.public static double atan(double d)
[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
d
 the value whose arc tangent has to be computed.public static double atan2(double y, double x)
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
y
 the numerator of the value whose atan has to be computed.x
 the denominator of the value whose atan has to be computed.y/x
.public static double cbrt(double d)
Special cases:
cbrt(+0.0) = +0.0
cbrt(0.0) = 0.0
cbrt(+infinity) = +infinity
cbrt(infinity) = infinity
cbrt(NaN) = NaN
d
 the value whose cube root has to be computed.public static double ceil(double d)
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
d
 the value whose closest integer value has to be computed.public static double cos(double d)
Special cases:
cos(+infinity) = NaN
cos(infinity) = NaN
cos(NaN) = NaN
d
 the angle whose cosine has to be computed, in radians.public static double cosh(double d)
Special cases:
cosh(+infinity) = +infinity
cosh(infinity) = +infinity
cosh(NaN) = NaN
d
 the value whose hyperbolic cosine has to be computed.public static double exp(double d)
Special cases:
exp(+infinity) = +infinity
exp(infinity) = +0.0
exp(NaN) = NaN
d
 the value whose exponential has to be computed.public static double expm1(double d)
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
d
 the value to compute the e
^{d }
 1
of.e
^{d} 1
value of the
argument.public static double floor(double d)
Special cases:
floor(+0.0) = +0.0
floor(0.0) = 0.0
floor(+infinity) = +infinity
floor(infinity) = infinity
floor(NaN) = NaN
d
 the value whose closest integer value has to be computed.public static double hypot(double x, double y)
sqrt(
x
^{2}+
y
^{2})
. 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 semimonotonic.
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
x
 a double number.y
 a double number.sqrt(
x
^{2}+
y
^{2})
value of the
arguments.public static double IEEEremainder(double x, double y)
x
by y
using the IEEE
754 rules. The result is xround(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
+/infinityIEEEremainder(x, infinity) = x
where x is anything but
+/infinityx
 the numerator of the operation.y
 the denominator of the operation.x/y
.public static double log(double d)
Special cases:
log(+0.0) = infinity
log(0.0) = infinity
log((anything < 0) = NaN
log(+infinity) = +infinity
log(infinity) = NaN
log(NaN) = NaN
d
 the value whose log has to be computed.public static double log10(double d)
Special cases:
log10(+0.0) = infinity
log10(0.0) = infinity
log10((anything < 0) = NaN
log10(+infinity) = +infinity
log10(infinity) = NaN
log10(NaN) = NaN
d
 the value whose base 10 log has to be computed.public static double log1p(double d)
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 semimonotonic.
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
d
 the value to compute the ln(1+d)
of.public static double max(double d1, double d2)
Special cases:
max(NaN, (anything)) = NaN
max((anything), NaN) = NaN
max(+0.0, 0.0) = +0.0
max(0.0, +0.0) = +0.0
public static float max(float f1, float f2)
Special cases:
max(NaN, (anything)) = NaN
max((anything), NaN) = NaN
max(+0.0, 0.0) = +0.0
max(0.0, +0.0) = +0.0
public static int max(int i1, int i2)
public static long max(long l1, long l2)
public static double min(double d1, double d2)
Special cases:
min(NaN, (anything)) = NaN
min((anything), NaN) = NaN
min(+0.0, 0.0) = 0.0
min(0.0, +0.0) = 0.0
public static float min(float f1, float f2)
Special cases:
min(NaN, (anything)) = NaN
min((anything), NaN) = NaN
min(+0.0, 0.0) = 0.0
min(0.0, +0.0) = 0.0
public static int min(int i1, int i2)
public static long min(long l1, long l2)
public static double pow(double x, double y)
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), (noninteger)) = NAN
x
 the base of the operation.y
 the exponent of the operation.x
to the power of y
.public static double rint(double d)
Special cases:
rint(+0.0) = +0.0
rint(0.0) = 0.0
rint(+infinity) = +infinity
rint(infinity) = infinity
rint(NaN) = NaN
d
 the value to be rounded.public static long round(double d)
(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
d
 the value to be rounded.public static int round(float f)
(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
f
 the value to be rounded.public static double signum(double d)
Special cases:
signum(+0.0) = +0.0
signum(0.0) = 0.0
signum(+infinity) = +1.0
signum(infinity) = 1.0
signum(NaN) = NaN
d
 the value whose signum has to be computed.public static float signum(float f)
Special cases:
signum(+0.0) = +0.0
signum(0.0) = 0.0
signum(+infinity) = +1.0
signum(infinity) = 1.0
signum(NaN) = NaN
f
 the value whose signum has to be computed.public static double sin(double d)
Special cases:
sin(+0.0) = +0.0
sin(0.0) = 0.0
sin(+infinity) = NaN
sin(infinity) = NaN
sin(NaN) = NaN
d
 the angle whose sin has to be computed, in radians.public static double sinh(double d)
Special cases:
sinh(+0.0) = +0.0
sinh(0.0) = 0.0
sinh(+infinity) = +infinity
sinh(infinity) = infinity
sinh(NaN) = NaN
d
 the value whose hyperbolic sine has to be computed.public static double sqrt(double d)
Special cases:
sqrt(+0.0) = +0.0
sqrt(0.0) = 0.0
sqrt( (anything < 0) ) = NaN
sqrt(+infinity) = +infinity
sqrt(NaN) = NaN
public static double tan(double d)
Special cases:
tan(+0.0) = +0.0
tan(0.0) = 0.0
tan(+infinity) = NaN
tan(infinity) = NaN
tan(NaN) = NaN
d
 the angle whose tangent has to be computed, in radians.public static double tanh(double d)
Special cases:
tanh(+0.0) = +0.0
tanh(0.0) = 0.0
tanh(+infinity) = +1.0
tanh(infinity) = 1.0
tanh(NaN) = NaN
d
 the value whose hyperbolic tangent has to be computed.public static double random()
n
, where n >= 0.0 && n < 1.0
.
This method reuses a single instance of Random
.
This method is threadsafe 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.public static double toRadians(double angdeg)
angdeg / 180 * pi
.
Special cases:
toRadians(+0.0) = +0.0
toRadians(0.0) = 0.0
toRadians(+infinity) = +infinity
toRadians(infinity) = infinity
toRadians(NaN) = NaN
angdeg
 an angle in degrees.public static double toDegrees(double angrad)
angrad * 180 / pi
.
Special cases:
toDegrees(+0.0) = +0.0
toDegrees(0.0) = 0.0
toDegrees(+infinity) = +infinity
toDegrees(infinity) = infinity
toDegrees(NaN) = NaN
angrad
 an angle in radians.public static double ulp(double d)
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
d
 the floatingpoint value to compute ulp of.public static float ulp(float f)
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
f
 the floatingpoint value to compute ulp of.public static double copySign(double magnitude, double sign)
sign
.
If sign
is NaN, the sign of the result is arbitrary.
If you need a determinate sign in such cases, use StrictMath.copySign
.public static float copySign(float magnitude, float sign)
sign
.
If sign
is NaN, the sign of the result is arbitrary.
If you need a determinate sign in such cases, use StrictMath.copySign
.public static int getExponent(float f)
f
.public static int getExponent(double d)
d
.public static double nextAfter(double start, double direction)
start
in the given direction
.public static float nextAfter(float start, double direction)
start
in the given direction
.public static double nextUp(double d)
d
.public static float nextUp(float f)
f
.public static double scalb(double d, int scaleFactor)
d
* 2^scaleFactor
. The result may be rounded.public static float scalb(float d, int scaleFactor)
d
* 2^scaleFactor
. The result may be rounded.