    All Packages  Class Hierarchy  This Package  Previous  Next  Index

# Class java.lang.Math

    java.lang.Object
       |
       +----java.lang.Math

public final class Math
extends Object

The class `Math` contains methods for performing basic numeric operations such as the elementary exponential, logarithm, square root, and trigonometric functions.

To help ensure portability of Java programs, the definitions of many of the numeric functions in this package require that they produce the same results as certain published algorithms. These algorithms are available from the well-known network library `netlib` as the package "Freely Distributable Math Library" (`fdlibm`). These algorithms, which are written in the C programming language, are then to be understood as executed with all floating-point operations following the rules of Java floating-point arithmetic.

The network library may be found on the World Wide Web at

`http://netlib.att.com/`

then perform a keyword search for "`fdlibm`".

The Java math library is defined with respect to the version of `fdlibm` dated January 4, 1995. Where `fdlibm` provides more than one definition for a function (such as `acos`), use the "IEEE 754 core function" version (residing in a file whose name begins with the letter `e`).

##

E
  The `double` value that is closer than any other to `e`, the base of the natural logarithms.
PI
  The `double` value that is closer than any other to pi, the ratio of the circumference of a circle to its diameter.

##

abs(double)
  Returns the absolute value of a `double` value.
abs(float)
  Returns the absolute value of a `float` value.
abs(int)
  Returns the absolute value of an `int` value.
abs(long)
  Returns the absolute value of a `long` value.
acos(double)
  Returns the arc cosine of an angle, in the range of 0.0 through pi.
asin(double)
  Returns the arc sine of an angle, in the range of -pi/2 through pi/2.
atan(double)
  Returns the arc tangent of an angle, in the range of -pi/2 through pi/2.
atan2(double, double)
  Converts rectangular coordinates (`b`, `a`) to polar (r, theta).
ceil(double)
  Returns the smallest (closest to negative infinity) `double` value that is not less than the argument and is equal to a mathematical integer.
cos(double)
  Returns the trigonometric cosine of an angle.
exp(double)
  Returns the exponential number e (i.e., 2.718...) raised to the power of a `double` value.
floor(double)
  Returns the largest (closest to positive infinity) `double` value that is not greater than the argument and is equal to a mathematical integer.
IEEEremainder(double, double)
  Computes the remainder operation on two arguments as prescribed by the IEEE 754 standard.
log(double)
  Returns the natural logarithm (base e) of a `double` value.
max(double, double)
  Returns the greater of two `double` values.
max(float, float)
  Returns the greater of two `float` values.
max(int, int)
  Returns the greater of two `int` values.
max(long, long)
  Returns the greater of two `long` values.
min(double, double)
  Returns the smaller of two `double` values.
min(float, float)
  Returns the smaller of two `float` values.
min(int, int)
  Returns the smaller of two `int` values.
min(long, long)
  Returns the smaller of two `long` values.
pow(double, double)
  Returns of value of the first argument raised to the power of the second argument.
random()
  Returns a random number between `0.0` and `1.0`.
rint(double)
  returns the closest integer to the argument.
round(double)
  Returns the closest `long` to the argument.
round(float)
  Returns the closest `int` to the argument.
sin(double)
  Returns the trigonometric sine of an angle.
sqrt(double)
  Returns the square root of a `double` value.
tan(double)
  Returns the trigonometric tangent of an angle.

##

E

     public static final double E

  The `double` value that is closer than any other to `e`, the base of the natural logarithms.

PI

     public static final double PI

  The `double` value that is closer than any other to pi, the ratio of the circumference of a circle to its diameter.

##

sin

     public static native double sin(double a)

  Returns the trigonometric sine of an angle.

  Parameters:
    a - an angle, in radians.
  Returns:
    the sine of the argument.

cos

     public static native double cos(double a)

  Returns the trigonometric cosine of an angle.

  Parameters:
    a - an angle, in radians.
  Returns:
    the cosine of the argument.

tan

     public static native double tan(double a)

  Returns the trigonometric tangent of an angle.

  Parameters:
    a - an angle, in radians.
  Returns:
    the tangent of the argument.

asin

     public static native double asin(double a)

  Returns the arc sine of an angle, in the range of -pi/2 through pi/2.

  Parameters:
    a - an angle, in radians.
  Returns:
    the arc sine of the argument.

acos

     public static native double acos(double a)

  Returns the arc cosine of an angle, in the range of 0.0 through pi.

  Parameters:
    a - an angle, in radians.
  Returns:
    the arc cosine of the argument.

atan

     public static native double atan(double a)

  Returns the arc tangent of an angle, in the range of -pi/2 through pi/2.

  Parameters:
    a - an angle, in radians.
  Returns:
    the arc tangent of the argument.

exp

     public static native double exp(double a)

  Returns the exponential number e (i.e., 2.718...) raised to the power of a `double` value.

  Parameters:
    a - a `double` value.
  Returns:
    the value ea, where e is the base of the natural logarithms.

log

     public static native double log(double a)

  Returns the natural logarithm (base e) of a `double` value.

  Parameters:
    a - a number greater than `0.0`.
  Returns:
    the value ln `a`, the natural logarithm of `a`.

sqrt

     public static native double sqrt(double a)

  Returns the square root of a `double` value.

  Parameters:
    a - a `double` value.
  Returns:
    the square root of `a`. If the argument is NaN or less than zero, the result is NaN.

IEEEremainder

     public static native double IEEEremainder(double f1,
                                               double f2)

  Computes the remainder operation on two arguments as prescribed by the IEEE 754 standard. The remainder value is mathematically equal to `f1 - f2` × n, where n is the mathematical integer closest to the exact mathematical value of the quotient `f1/f2`, and if two mathematical integers are equally close to `f1/f2`, then n is the integer that is even. If the remainder is zero, its sign is the same as the sign of the first argument.

  Parameters:
    f1 - the dividend.
    f2 - the divisor.
  Returns:
    the remainder when `f1` is divided by `f2`.

ceil

     public static native double ceil(double a)

  Returns the smallest (closest to negative infinity) `double` value that is not less than the argument and is equal to a mathematical integer.

  Parameters:
    a - a `double` value.
  Returns:
    the smallest (closest to negative infinity) `double` value that is not less than the argument and is equal to a mathematical integer.

floor

     public static native double floor(double a)

  Returns the largest (closest to positive infinity) `double` value that is not greater than the argument and is equal to a mathematical integer.

  Parameters:
    a - a `double` value.
    a - an assigned value.
  Returns:
    the largest (closest to positive infinity) `double` value that is not greater than the argument and is equal to a mathematical integer.

rint

     public static native double rint(double a)

  returns the closest integer to the argument.

  Parameters:
    a - a `double` value.
  Returns:
    the closest `double` value to `a` that is equal to a mathematical integer. If two `double` values that are mathematical integers are equally close to the value of the argument, the result is the integer value that is even.

atan2

     public static native double atan2(double a,
                                       double b)

  Converts rectangular coordinates (`b`, `a`) to polar (r, theta). This method computes the phase theta by computing an arc tangent of `b/a` in the range of -pi to pi.

  Parameters:
    a - a `double` value.
    b - a `double` value.
  Returns:
    the theta component of the point (r, theta) in polar coordinates that corresponds to the point (b, a) in Cartesian coordinates.

pow

     public static native double pow(double a,
                                     double b)

  Returns of value of the first argument raised to the power of the second argument.

  If (`a == 0.0`), then `b` must be greater than `0.0`; otherwise an exception is thrown. An exception also will occur if (`a <= 0.0`) and `b` is not equal to a whole number.

  Parameters:
    a - a `double` value.
    b - a `double` value.
  Returns:
    the value `ab`.
  Throws: ArithmeticException
    if (`a == 0.0`) and (`b <= 0.0`), or if (`a <= 0.0`) and `b` is not equal to a whole number.

round

     public static int round(float a)

  Returns the closest `int` to the argument.

  If the argument is negative infinity or any value less than or equal to the value of `Integer.MIN_VALUE`, the result is equal to the value of `Integer.MIN_VALUE`.

  If the argument is positive infinity or any value greater than or equal to the value of `Integer.MAX_VALUE`, the result is equal to the value of `Integer.MAX_VALUE`.

  Parameters:
    a - a `float` value.
  Returns:
    the value of the argument rounded to the nearest `int` value.
  See Also:
    MAX_VALUE, MIN_VALUE

round

     public static long round(double a)

  Returns the closest `long` to the argument.

  If the argument is negative infinity or any value less than or equal to the value of `Long.MIN_VALUE`, the result is equal to the value of `Long.MIN_VALUE`.

  If the argument is positive infinity or any value greater than or equal to the value of `Long.MAX_VALUE`, the result is equal to the value of `Long.MAX_VALUE`.

  Parameters:
    a - a `double` value.
  Returns:
    the value of the argument rounded to the nearest `long` value.
  See Also:
    MAX_VALUE, MIN_VALUE

random

     public static synchronized double random()

  Returns a random number between `0.0` and `1.0`. Random number generators are often referred to as pseudorandom number generators because the numbers produced tend to repeat themselves after a period of time.

  Returns:
    a pseudorandom `double` between `0.0` and `1.0`.
  See Also:
    nextDouble

abs

     public static int abs(int a)

  Returns the absolute value of an `int` value. If the argument is not negative, the argument is returned. If the argument is negative, the negation of the argument is returned.

  Note that if the argument is equal to the value of `Integer.MIN_VALUE`, the most negative representable `int` value, the result is that same value, which is negative.

  Parameters:
    a - an `int` value.
  Returns:
    the absolute value of the argument.
  See Also:
    MIN_VALUE

abs

     public static long abs(long a)

  Returns the absolute value of a `long` value. If the argument is not negative, the argument is returned. If the argument is negative, the negation of the argument is returned.

  Note that if the argument is equal to the value of `Long.MIN_VALUE`, the most negative representable `long` value, the result is that same value, which is negative.

  Parameters:
    a - a `long` value.
  Returns:
    the absolute value of the argument.
  See Also:
    MIN_VALUE

abs

     public static float abs(float a)

  Returns the absolute value of a `float` value. If the argument is not negative, the argument is returned. If the argument is negative, the negation of the argument is returned.

  Parameters:
    a - a `float` value.
  Returns:
    the absolute value of the argument.

abs

     public static double abs(double a)

  Returns the absolute value of a `double` value. If the argument is not negative, the argument is returned. If the argument is negative, the negation of the argument is returned.

  Parameters:
    a - a `double` value.
  Returns:
    the absolute value of the argument.

max

     public static int max(int a,
                           int b)

  Returns the greater of two `int` values.

  Parameters:
    a - an `int` value.
    b - an `int` value.
  Returns:
    the larger of `a` and `b`.

max

     public static long max(long a,
                            long b)

  Returns the greater of two `long` values.

  Parameters:
    a - a `long` value.
    b - a `long` value.
  Returns:
    the larger of `a` and `b`.

max

     public static float max(float a,
                             float b)

  Returns the greater of two `float` values. If either value is `NaN`, then the result is `NaN`. Unlike the the numerical comparison operators, this method considers negative zero to be strictly smaller than positive zero.

  Parameters:
    a - a `float` value.
    b - a `float` value.
  Returns:
    the larger of `a` and `b`.

max

     public static double max(double a,
                              double b)

  Returns the greater of two `double` values. If either value is `NaN`, then the result is `NaN`. Unlike the the numerical comparison operators, this method considers negative zero to be strictly smaller than positive zero.

  Parameters:
    a - a `double` value.
    b - a `double` value.
  Returns:
    the larger of `a` and `b`.

min

     public static int min(int a,
                           int b)

  Returns the smaller of two `int` values.

  Parameters:
    a - an `int` value.
    b - an `int` value.
  Returns:
    the smaller of `a` and `b`.

min

     public static long min(long a,
                            long b)

  Returns the smaller of two `long` values.

  Parameters:
    a - a `long` value.
    b - a `long` value.
  Returns:
    the smaller of `a` and `b`.

min

     public static float min(float a,
                             float b)

  Returns the smaller of two `float` values. If either value is `NaN`, then the result is `NaN`. Unlike the the numerical comparison operators, this method considers negative zero to be strictly smaller than positive zero.

  Parameters:
    a - a `float` value.
    b - a `float` value.
  Returns:
    the smaller of `a` and `b.`

min

     public static double min(double a,
                              double b)

  Returns the smaller of two `double` values. If either value is `NaN`, then the result is `NaN`. Unlike the the numerical comparison operators, this method considers negative zero to be strictly smaller than positive zero.

  Parameters:
    a - a `double` value.
    b - a `double` value.
  Returns:
    the smaller of `a` and `b`.

    All Packages  Class Hierarchy  This Package  Previous  Next  Index