java.lang
Class Math

java.lang.Object
  java.lang.Math

public final class Math
extends Object

Helper class containing useful mathematical functions and constants.

Note that angles are specified in radians. Conversion functions are provided for your convenience.

Since:

1.0

Field Summary

static double	E The most accurate approximation to the mathematical constant e: 2.718281828459045.
static double	PI The most accurate approximation to the mathematical constant pi: 3.141592653589793.

Method Summary

static double	abs(double d) Take the absolute value of the argument.
static float	abs(float f) Take the absolute value of the argument.
static int	abs(int i) Take the absolute value of the argument.
static long	abs(long l) Take the absolute value of the argument.
static double	acos(double a) The trigonometric function arccos.
static double	asin(double a) The trigonometric function arcsin.
static double	atan(double a) The trigonometric function arcsin.
static double	atan2(double y, double x) A special version of the trigonometric function arctan, for converting rectangular coordinates (x, y) to polar (r, theta).
static double	ceil(double a) Take the nearest integer that is that is greater than or equal to the argument.
static double	cos(double a) The trigonometric function cos.
static double	exp(double a) Take ea.
static double	floor(double a) Take the nearest integer that is that is less than or equal to the argument.
static double	log(double a) Take ln(a) (the natural log).
static double	max(double a, double b) Return whichever argument is larger.
static float	max(float a, float b) Return whichever argument is larger.
static int	max(int a, int b) Return whichever argument is larger.
static long	max(long a, long b) Return whichever argument is larger.
static double	min(double a, double b) Return whichever argument is smaller.
static float	min(float a, float b) Return whichever argument is smaller.
static int	min(int a, int b) Return whichever argument is smaller.
static long	min(long a, long b) Return whichever argument is smaller.
static double	pow(double a, double b) Raise a number to a power.
static double	random() Get a random number.
static double	rint(double a) Take the nearest integer to the argument.
static long	round(double a) Take the nearest long to the argument.
static int	round(float a) Take the nearest integer to the argument.
static double	sin(double a) The trigonometric function sin.
static double	sqrt(double a) Take a square root.
static double	tan(double a) The trigonometric function tan.
static double	toDegrees(double rads) Convert from radians to degrees.
static double	toRadians(double degrees) Convert from degrees to radians.

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 most accurate approximation to the mathematical constant e: 2.718281828459045. Used in natural log and exp.

See Also:

log(double), exp(double), Constant Field Values

PI

public static final double PI

The most accurate approximation to the mathematical constant pi: 3.141592653589793. This is the ratio of a circle's diameter to its circumference.

See Also:

Constant Field Values

Method Detail

abs

public static int abs(int i)

Take the absolute value of the argument. (Absolute value means make it positive.)

Note that the the largest negative value (Integer.MIN_VALUE) cannot be made positive. In this case, because of the rules of negation in a computer, MIN_VALUE is what will be returned. This is a negative value. You have been warned.

Parameters:

i - the number to take the absolute value of

Returns:

the absolute value

See Also:

Integer.MIN_VALUE

abs

public static long abs(long l)

Take the absolute value of the argument. (Absolute value means make it positive.)

Note that the the largest negative value (Long.MIN_VALUE) cannot be made positive. In this case, because of the rules of negation in a computer, MIN_VALUE is what will be returned. This is a negative value. You have been warned.

Parameters:

l - the number to take the absolute value of

Returns:

the absolute value

See Also:

Long.MIN_VALUE

abs

public static float abs(float f)

Take the absolute value of the argument. (Absolute value means make it positive.)

This is equivalent, but faster than, calling Float.intBitsToFloat(0x7fffffff & Float.floatToIntBits(a)).

Parameters:

f - the number to take the absolute value of

Returns:

the absolute value

abs

public static double abs(double d)

Take the absolute value of the argument. (Absolute value means make it positive.) This is equivalent, but faster than, calling Double.longBitsToDouble(Double.doubleToLongBits(a) << 1) >>> 1);.

Parameters:

d - the number to take the absolute value of

Returns:

the absolute value

min

public static int min(int a,
                      int b)

Return whichever argument is smaller.

Parameters:

a - the first number

b - a second number

Returns:

the smaller of the two numbers

min

public static long min(long a,
                       long b)

Return whichever argument is smaller.

Parameters:

a - the first number

b - a second number

Returns:

the smaller of the two numbers

min

public static float min(float a,
                        float b)

Return whichever argument is smaller. If either argument is NaN, the result is NaN, and when comparing 0 and -0, -0 is always smaller.

Parameters:

a - the first number

b - a second number

Returns:

the smaller of the two numbers

min

public static double min(double a,
                         double b)

Return whichever argument is smaller. If either argument is NaN, the result is NaN, and when comparing 0 and -0, -0 is always smaller.

Parameters:

a - the first number

b - a second number

Returns:

the smaller of the two numbers

max

public static int max(int a,
                      int b)

Return whichever argument is larger.

Parameters:

a - the first number

b - a second number

Returns:

the larger of the two numbers

max

public static long max(long a,
                       long b)

Return whichever argument is larger.

Parameters:

a - the first number

b - a second number

Returns:

the larger of the two numbers

max

public static float max(float a,
                        float b)

Return whichever argument is larger. If either argument is NaN, the result is NaN, and when comparing 0 and -0, 0 is always larger.

Parameters:

a - the first number

b - a second number

Returns:

the larger of the two numbers

max

public static double max(double a,
                         double b)

Return whichever argument is larger. If either argument is NaN, the result is NaN, and when comparing 0 and -0, 0 is always larger.

Parameters:

a - the first number

b - a second number

Returns:

the larger of the two numbers

sin

public static double sin(double a)

The trigonometric function sin. The sine of NaN or infinity is NaN, and the sine of 0 retains its sign. This is accurate within 1 ulp, and is semi-monotonic.

Parameters:

a - the angle (in radians)

Returns:

sin(a)

cos

public static double cos(double a)

The trigonometric function cos. The cosine of NaN or infinity is NaN. This is accurate within 1 ulp, and is semi-monotonic.

Parameters:

a - the angle (in radians)

Returns:

cos(a)

tan

public static double tan(double a)

The trigonometric function tan. The tangent of NaN or infinity is NaN, and the tangent of 0 retains its sign. This is accurate within 1 ulp, and is semi-monotonic.

Parameters:

a - the angle (in radians)

Returns:

tan(a)

asin

public static double asin(double a)

The trigonometric function arcsin. The range of angles returned is -pi/2 to pi/2 radians (-90 to 90 degrees). If the argument is NaN or its absolute value is beyond 1, the result is NaN; and the arcsine of 0 retains its sign. This is accurate within 1 ulp, and is semi-monotonic.

Parameters:

a - the sin to turn back into an angle

Returns:

arcsin(a)

acos

public static double acos(double a)

The trigonometric function arccos. The range of angles returned is 0 to pi radians (0 to 180 degrees). If the argument is NaN or its absolute value is beyond 1, the result is NaN. This is accurate within 1 ulp, and is semi-monotonic.

Parameters:

a - the cos to turn back into an angle

Returns:

arccos(a)

atan

public static double atan(double a)

The trigonometric function arcsin. The range of angles returned is -pi/2 to pi/2 radians (-90 to 90 degrees). If the argument is NaN, the result is NaN; and the arctangent of 0 retains its sign. This is accurate within 1 ulp, and is semi-monotonic.

Parameters:

a - the tan to turn back into an angle

Returns:

arcsin(a)

See Also:

atan2(double, double)

atan2

public static double atan2(double y,
                           double x)

A special version of the trigonometric function arctan, for converting rectangular coordinates (x, y) to polar (r, theta). This computes the arctangent of x/y in the range of -pi to pi radians (-180 to 180 degrees). Special cases:

• If either argument is NaN, the result is NaN.
• If the first argument is positive zero and the second argument is positive, or the first argument is positive and finite and the second argument is positive infinity, then the result is positive zero.
• If the first argument is negative zero and the second argument is positive, or the first argument is negative and finite and the second argument is positive infinity, then the result is negative zero.
• If the first argument is positive zero and the second argument is negative, or the first argument is positive and finite and the second argument is negative infinity, then the result is the double value closest to pi.
• If the first argument is negative zero and the second argument is negative, or the first argument is negative and finite and the second argument is negative infinity, then the result is the double value closest to -pi.
• If the first argument is positive and the second argument is positive zero or negative zero, or the first argument is positive infinity and the second argument is finite, then the result is the double value closest to pi/2.
• If the first argument is negative and the second argument is positive zero or negative zero, or the first argument is negative infinity and the second argument is finite, then the result is the double value closest to -pi/2.
• If both arguments are positive infinity, then the result is the double value closest to pi/4.
• If the first argument is positive infinity and the second argument is negative infinity, then the result is the double value closest to 3*pi/4.
• If the first argument is negative infinity and the second argument is positive infinity, then the result is the double value closest to -pi/4.
• If both arguments are negative infinity, then the result is the double value closest to -3*pi/4.

This is accurate within 2 ulps, and is semi-monotonic. To get r, use sqrt(x*x+y*y).

Parameters:

y - the y position

x - the x position

Returns:

theta in the conversion of (x, y) to (r, theta)

See Also:

atan(double)

exp

public static double exp(double a)

Take e^a. The opposite of log(). If the argument is NaN, the result is NaN; if the argument is positive infinity, the result is positive infinity; and if the argument is negative infinity, the result is positive zero. This is accurate within 1 ulp, and is semi-monotonic.

Parameters:

a - the number to raise to the power

Returns:

the number raised to the power of e

See Also:

log(double), pow(double, double)

log

public static double log(double a)

Take ln(a) (the natural log). The opposite of exp(). If the argument is NaN or negative, the result is NaN; if the argument is positive infinity, the result is positive infinity; and if the argument is either zero, the result is negative infinity. This is accurate within 1 ulp, and is semi-monotonic.

Note that the way to get log_b(a) is to do this: ln(a) / ln(b).

Parameters:

a - the number to take the natural log of

Returns:

the natural log of a

See Also:

exp(double)

sqrt

public static double sqrt(double a)

Take a square root. If the argument is NaN or negative, the result is NaN; if the argument is positive infinity, the result is positive infinity; and if the result is either zero, the result is the same. This is accurate within the limits of doubles.

For other roots, use pow(a, 1 / rootNumber).

Parameters:

a - the numeric argument

Returns:

the square root of the argument

See Also:

pow(double, double)

pow

public static double pow(double a,
                         double b)

Raise a number to a power. Special cases:

• If the second argument is positive or negative zero, then the result is 1.0.
• If the second argument is 1.0, then the result is the same as the first argument.
• If the second argument is NaN, then the result is NaN.
• If the first argument is NaN and the second argument is nonzero, then the result is NaN.
• If the absolute value of the first argument is greater than 1 and the second argument is positive infinity, or the absolute value of the first argument is less than 1 and the second argument is negative infinity, then the result is positive infinity.
• If the absolute value of the first argument is greater than 1 and the second argument is negative infinity, or the absolute value of the first argument is less than 1 and the second argument is positive infinity, then the result is positive zero.
• If the absolute value of the first argument equals 1 and the second argument is infinite, then the result is NaN.
• If the first argument is positive zero and the second argument is greater than zero, or the first argument is positive infinity and the second argument is less than zero, then the result is positive zero.
• If the first argument is positive zero and the second argument is less than zero, or the first argument is positive infinity and the second argument is greater than zero, then the result is positive infinity.
• If the first argument is negative zero and the second argument is greater than zero but not a finite odd integer, or the first argument is negative infinity and the second argument is less than zero but not a finite odd integer, then the result is positive zero.
• If the first argument is negative zero and the second argument is a positive finite odd integer, or the first argument is negative infinity and the second argument is a negative finite odd integer, then the result is negative zero.
• If the first argument is negative zero and the second argument is less than zero but not a finite odd integer, or the first argument is negative infinity and the second argument is greater than zero but not a finite odd integer, then the result is positive infinity.
• If the first argument is negative zero and the second argument is a negative finite odd integer, or the first argument is negative infinity and the second argument is a positive finite odd integer, then the result is negative infinity.
• If the first argument is less than zero and the second argument is a finite even integer, then the result is equal to the result of raising the absolute value of the first argument to the power of the second argument.
• If the first argument is less than zero and the second argument is a finite odd integer, then the result is equal to the negative of the result of raising the absolute value of the first argument to the power of the second argument.
• If the first argument is finite and less than zero and the second argument is finite and not an integer, then the result is NaN.
• If both arguments are integers, then the result is exactly equal to the mathematical result of raising the first argument to the power of the second argument if that result can in fact be represented exactly as a double value.

(In the foregoing descriptions, a floating-point value is considered to be an integer if and only if it is a fixed point of the method ceil(double) or, equivalently, a fixed point of the method floor(double). A value is a fixed point of a one-argument method if and only if the result of applying the method to the value is equal to the value.) This is accurate within 1 ulp, and is semi-monotonic.

Parameters:

a - the number to raise

b - the power to raise it to

Returns:

a^b

ceil

public static double ceil(double a)

Take the nearest integer that is that is greater than or equal to the argument. If the argument is NaN, infinite, or zero, the result is the same; if the argument is between -1 and 0, the result is negative zero. Note that Math.ceil(x) == -Math.floor(-x).

Parameters:

a - the value to act upon

Returns:

the nearest integer >= a

floor

public static double floor(double a)

Take the nearest integer that is that is less than or equal to the argument. If the argument is NaN, infinite, or zero, the result is the same. Note that Math.ceil(x) == -Math.floor(-x).

Parameters:

a - the value to act upon

Returns:

the nearest integer <= a

rint

public static double rint(double a)

Take the nearest integer to the argument. If it is exactly between two integers, the even integer is taken. If the argument is NaN, infinite, or zero, the result is the same.

Parameters:

a - the value to act upon

Returns:

the nearest integer to a

round

public static int round(float a)

Take the nearest integer to the argument. This is equivalent to (int) Math.floor(a + 0.5f). If the argument is NaN, the result is 0; otherwise if the argument is outside the range of int, the result will be Integer.MIN_VALUE or Integer.MAX_VALUE, as appropriate.

Parameters:

a - the argument to round

Returns:

the nearest integer to the argument

See Also:

Integer.MIN_VALUE, Integer.MAX_VALUE

round

public static long round(double a)

Take the nearest long to the argument. This is equivalent to (long) Math.floor(a + 0.5). If the argument is NaN, the result is 0; otherwise if the argument is outside the range of long, the result will be Long.MIN_VALUE or Long.MAX_VALUE, as appropriate.

Parameters:

a - the argument to round

Returns:

the nearest long to the argument

See Also:

Long.MIN_VALUE, Long.MAX_VALUE

random

public static double random()

Get a random number. This behaves like Random.nextDouble(), seeded by System.currentTimeMillis() when first called. In other words, the number is from a pseudorandom sequence, and lies in the range [+0.0, 1.0). This random sequence is only used by this method, and is threadsafe, although you may want your own random number generator if it is shared among threads.

Returns:

a random number

See Also:

Random#nextDouble(), System.currentTimeMillis()

toRadians

public static double toRadians(double degrees)

Convert from degrees to radians. The formula for this is radians = degrees * (pi/180); however it is not always exact given the limitations of floating point numbers.

Parameters:

degrees - an angle in degrees

Returns:

the angle in radians

Since:

1.2

toDegrees

public static double toDegrees(double rads)

Convert from radians to degrees. The formula for this is degrees = radians * (180/pi); however it is not always exact given the limitations of floating point numbers.

Parameters:

rads - an angle in radians

Returns:

the angle in degrees

Since:

1.2