Class Math

java.lang.Object
java.lang.Math
public final class Math extends Object
The class Math contains methods for performing basic numeric operations. Since: JDK1.0, CLDC 1.0

  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    static final double
    E
    The double value that is closer than any other to e, the base of the natural logarithms.
    static final double
    PI
    The double value that is closer than any other to , the ratio of the circumference of a circle to its diameter.
    static final double
    TAU
    Twice pi, the ratio of a circle's circumference to its radius.

  • Constructor Summary

    Constructors
    Constructor
    Description
    Math()
     

  • Method Summary

    Modifier and Type
    Method
    Description
    static double
    abs(double a)
    Returns the absolute value of a double value.
    static float
    abs(float a)
    Returns the absolute value of a float value.
    static int
    abs(int a)
    Returns the absolute value of an int value.
    static long
    abs(long a)
    Returns the absolute value of a long value.
    static int
    absExact(int a)
    The absolute value, throwing for Integer.MIN_VALUE, which has none.
    static long
    absExact(long a)
    The absolute value, throwing for Long.MIN_VALUE, which has none.
    static int
    addExact(int x, int y)
    x + y, throwing when it overflows.
    static long
    addExact(long x, long y)
    x + y, throwing when it overflows.
    static double
    cbrt(double a)
    The cube root of a.
    static 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.
    static int
    ceilDiv(int x, int y)
    The smallest int not less than x / y.
    static long
    ceilDiv(long x, int y)
    The smallest long not less than x / y.
    static long
    ceilDiv(long x, long y)
    The smallest long not less than x / y.
    static int
    ceilDivExact(int x, int y)
    ceilDiv(x, y), throwing on the one quotient that overflows.
    static long
    ceilDivExact(long x, long y)
    ceilDiv(x, y), throwing on the one quotient that overflows.
    static int
    ceilMod(int x, int y)
    x - ceilDiv(x, y) * y.
    static int
    ceilMod(long x, int y)
    x - ceilDiv(x, y) * y.
    static long
    ceilMod(long x, long y)
    x - ceilDiv(x, y) * y.
    static double
    clamp(double value, double min, double max)
    value clamped to [min, max].
    static float
    clamp(float value, float min, float max)
    value clamped to [min, max].
    static int
    clamp(long value, int min, int max)
    value clamped to [min, max], as an int.
    static long
    clamp(long value, long min, long max)
    value clamped to [min, max].
    static double
    copySign(double magnitude, double sign)
    magnitude with the sign bit of sign.
    static float
    copySign(float magnitude, float sign)
    magnitude with the sign bit of sign.
    static double
    cos(double a)
    Returns the trigonometric cosine of an angle.
    static double
    cosh(double x)
    The hyperbolic cosine of x.
    static int
    decrementExact(int a)
    a - 1, throwing when it overflows.
    static long
    decrementExact(long a)
    a - 1, throwing when it overflows.
    static int
    divideExact(int x, int y)
    x / y, throwing on the one quotient that overflows.
    static long
    divideExact(long x, long y)
    x / y, throwing on the one quotient that overflows.
    static 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.
    static int
    floorDiv(int x, int y)
    The largest int not greater than x / y.
    static long
    floorDiv(long x, int y)
    The largest long not greater than x / y.
    static long
    floorDiv(long x, long y)
    The largest long not greater than x / y.
    static int
    floorDivExact(int x, int y)
    floorDiv(x, y), throwing on the one quotient that overflows.
    static long
    floorDivExact(long x, long y)
    floorDiv(x, y), throwing on the one quotient that overflows.
    static int
    floorMod(int x, int y)
    x - floorDiv(x, y) * y: the remainder with the sign of y.
    static int
    floorMod(long x, int y)
    x - floorDiv(x, y) * y: the remainder with the sign of y.
    static long
    floorMod(long x, long y)
    x - floorDiv(x, y) * y: the remainder with the sign of y.
    static int
    getExponent(double d)
    The unbiased exponent of d: 1024 for NaN and the infinities, -1023 for zero and the subnormals.
    static int
    getExponent(float f)
    The unbiased exponent of f: 128 for NaN and the infinities, -127 for zero and the subnormals.
    static double
    hypot(double x, double y)
    The square root of x * x + y * y, without overflow in between.
    static int
    incrementExact(int a)
    a + 1, throwing when it overflows.
    static long
    incrementExact(long a)
    a + 1, throwing when it overflows.
    static double
    max(double a, double b)
    Returns the greater of two double values.
    static float
    max(float a, float b)
    Returns the greater of two float values.
    static int
    max(int a, int b)
    Returns the greater of two int values.
    static long
    max(long a, long b)
    Returns the greater of two long values.
    static double
    min(double a, double b)
    Returns the smaller of two double values.
    static float
    min(float a, float b)
    Returns the smaller of two float values.
    static int
    min(int a, int b)
    Returns the smaller of two int values.
    static long
    min(long a, long b)
    Returns the smaller of two long values.
    static int
    multiplyExact(int x, int y)
    x * y, throwing when it overflows.
    static long
    multiplyExact(long x, int y)
    x * y, throwing when it overflows.
    static long
    multiplyExact(long x, long y)
    x * y, throwing when it overflows.
    static long
    multiplyFull(int x, int y)
    The exact product of two ints.
    static long
    multiplyHigh(long x, long y)
    The high 64 bits of the 128-bit product of two signed longs.
    static int
    negateExact(int a)
    -a, throwing when it overflows.
    static long
    negateExact(long a)
    -a, throwing when it overflows.
    static double
    nextAfter(double start, double direction)
     
    static float
    nextAfter(float start, double direction)
     
    static double
    nextDown(double d)
     
    static float
    nextDown(float f)
    The float next to f towards negative infinity.
    static double
    nextUp(double d)
    The double next to d towards positive infinity.
    static float
    nextUp(float f)
    The float next to f towards positive infinity.
    static double
    random()
    A pseudo-random double in [0, 1).
    static double
    rint(double a)
    The whole number nearest a; a tie goes to the even one.
    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)
    d times 2 to the power scaleFactor, rounded once.
    static float
    scalb(float f, int scaleFactor)
    f times 2 to the power scaleFactor, rounded once.
    static double
    signum(double d)
    -1.0, 0.0 or 1.0 by the sign of d; a zero or NaN is returned as it is.
    static float
    signum(float f)
    -1.0f, 0.0f or 1.0f by the sign of f; a zero or NaN is returned as it is.
    static double
    sin(double a)
    Returns the trigonometric sine of an angle.
    static double
    sinh(double x)
    The hyperbolic sine of x.
    static double
    sqrt(double a)
    Returns the correctly rounded positive square root of a double value.
    static int
    subtractExact(int x, int y)
    x - y, throwing when it overflows.
    static long
    subtractExact(long x, long y)
    x - y, throwing when it overflows.
    static double
    tan(double a)
    Returns the trigonometric tangent of an angle.
    static double
    tanh(double x)
    The hyperbolic tangent of x.
    static double
    toDegrees(double angrad)
    Converts an angle measured in radians to the equivalent angle measured in degrees.
    static int
    toIntExact(long value)
    The value as an int, throwing when it does not fit.
    static double
    toRadians(double angdeg)
    Converts an angle measured in degrees to the equivalent angle measured in radians.
    static double
    ulp(double d)
    The distance from d to the next double of larger magnitude.
    static float
    ulp(float f)
    The distance from f to the next float of larger magnitude.
    static long
    unsignedMultiplyHigh(long x, long y)
    The high 64 bits of the 128-bit product of two unsigned longs.

    Methods inherited from class Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

  • Field Details

    • E

      public static final double E
      The double value that is closer than any other to e, the base of the natural logarithms. Since: CLDC 1.1 See Also:Constant Field Values
      See Also:

    • PI

      public static final double PI
      The double value that is closer than any other to , the ratio of the circumference of a circle to its diameter. Since: CLDC 1.1 See Also:Constant Field Values
      See Also:

    • TAU

      public static final double TAU
      Twice pi, the ratio of a circle's circumference to its radius.
      See Also:

  • Constructor Details

    • Math

      public Math()

  • Method Details

    • 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. Special cases: If the argument is positive zero or negative zero, the result is positive zero. If the argument is infinite, the result is positive infinity. If the argument is NaN, the result is NaN. In other words, the result is equal to the value of the expression: Double.longBitsToDouble((Double.doubleToLongBits(a)>>1)

    • 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. Special cases: If the argument is positive zero or negative zero, the result is positive zero. If the argument is infinite, the result is positive infinity. If the argument is NaN, the result is NaN. In other words, the result is equal to the value of the expression: Float.intBitsToFloat(0x7fffffff & Float.floatToIntBits(a))

    • 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.

    • 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.

    • ceil

      public static 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. Special cases: If the argument value is already equal to a mathematical integer, then the result is the same as the argument. If the argument is NaN or an infinity or positive zero or negative zero, then the result is the same as the argument. If the argument value is less than zero but greater than -1.0, then the result is negative zero. Note that the value of Math.ceil(x) is exactly the value of -Math.floor(-x).

    • cos

      public static double cos(double a)
      Returns the trigonometric cosine of an angle. Special case: If the argument is NaN or an infinity, then the result is NaN.

    • floor

      public static 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. Special cases: If the argument value is already equal to a mathematical integer, then the result is the same as the argument. If the argument is NaN or an infinity or positive zero or negative zero, then the result is the same as the argument.

    • max

      public static double max(double a, double b)
      Returns the greater of two double values. That is, the result is the argument closer to positive infinity. If the arguments have the same value, the result is that same value. 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. If one argument is positive zero and the other negative zero, the result is positive zero.

    • max

      public static float max(float a, float b)
      Returns the greater of two float values. That is, the result is the argument closer to positive infinity. If the arguments have the same value, the result is that same value. 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. If one argument is positive zero and the other negative zero, the result is positive zero.

    • max

      public static int max(int a, int b)
      Returns the greater of two int values. That is, the result is the argument closer to the value of Integer.MAX_VALUE. If the arguments have the same value, the result is that same value.

    • max

      public static long max(long a, long b)
      Returns the greater of two long values. That is, the result is the argument closer to the value of Long.MAX_VALUE. If the arguments have the same value, the result is that same value.

    • min

      public static double min(double a, double b)
      Returns the smaller of two double values. That is, the result is the value closer to negative infinity. If the arguments have the same value, the result is that same value. 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. If one argument is positive zero and the other is negative zero, the result is negative zero.

    • min

      public static float min(float a, float b)
      Returns the smaller of two float values. That is, the result is the value closer to negative infinity. If the arguments have the same value, the result is that same value. 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. If one argument is positive zero and the other is negative zero, the result is negative zero.

    • min

      public static int min(int a, int b)
      Returns the smaller of two int values. That is, the result the argument closer to the value of Integer.MIN_VALUE. If the arguments have the same value, the result is that same value.

    • min

      public static long min(long a, long b)
      Returns the smaller of two long values. That is, the result is the argument closer to the value of Long.MIN_VALUE. If the arguments have the same value, the result is that same value.

    • sin

      public static double sin(double a)
      Returns the trigonometric sine of an angle. Special cases: If the argument is NaN or an infinity, then the result is NaN. If the argument is positive zero, then the result is positive zero; if the argument is negative zero, then the result is negative zero.

    • sqrt

      public static double sqrt(double a)
      Returns the correctly rounded positive square root of a double value. Special cases: If the argument is NaN or less than zero, then the result is NaN. If the argument is positive infinity, then the result is positive infinity. If the argument is positive zero or negative zero, then the result is the same as the argument.

    • tan

      public static double tan(double a)
      Returns the trigonometric tangent of an angle. Special cases: If the argument is NaN or an infinity, then the result is NaN. If the argument is positive zero, then the result is positive zero; if the argument is negative zero, then the result is negative zero

    • toDegrees

      public static double toDegrees(double angrad)
      Converts an angle measured in radians to the equivalent angle measured in degrees.

    • toRadians

      public static double toRadians(double angdeg)
      Converts an angle measured in degrees to the equivalent angle measured in radians.

    • 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) = (long) +0.0

      • round(-0.0) = (long) +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) = (long) +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) = (int) +0.0

      • round(-0.0) = (int) +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) = (int) +0.0

      Parameters
      • f: the value to be rounded.
      Returns

      the closest integer to the argument.

    • nextDown

      public static double nextDown(double d)

    • nextAfter

      public static double nextAfter(double start, double direction)

    • nextAfter

      public static float nextAfter(float start, double direction)

    • random

      public static double random()
      A pseudo-random double in [0, 1).

    • signum

      public static double signum(double d)
      -1.0, 0.0 or 1.0 by the sign of d; a zero or NaN is returned as it is.

    • signum

      public static float signum(float f)
      -1.0f, 0.0f or 1.0f by the sign of f; a zero or NaN is returned as it is.

    • copySign

      public static double copySign(double magnitude, double sign)
      magnitude with the sign bit of sign.

    • copySign

      public static float copySign(float magnitude, float sign)
      magnitude with the sign bit of sign.

    • getExponent

      public static int getExponent(double d)
      The unbiased exponent of d: 1024 for NaN and the infinities, -1023 for zero and the subnormals.

    • getExponent

      public static int getExponent(float f)
      The unbiased exponent of f: 128 for NaN and the infinities, -127 for zero and the subnormals.

    • ulp

      public static double ulp(double d)
      The distance from d to the next double of larger magnitude.

    • ulp

      public static float ulp(float f)
      The distance from f to the next float of larger magnitude.

    • nextUp

      public static double nextUp(double d)
      The double next to d towards positive infinity.

    • nextUp

      public static float nextUp(float f)
      The float next to f towards positive infinity.

    • nextDown

      public static float nextDown(float f)
      The float next to f towards negative infinity.

    • scalb

      public static double scalb(double d, int scaleFactor)
      d times 2 to the power scaleFactor, rounded once.

    • scalb

      public static float scalb(float f, int scaleFactor)
      f times 2 to the power scaleFactor, rounded once.

    • hypot

      public static double hypot(double x, double y)
      The square root of x * x + y * y, without overflow in between.

    • cbrt

      public static double cbrt(double a)
      The cube root of a.

    • rint

      public static double rint(double a)
      The whole number nearest a; a tie goes to the even one.

    • sinh

      public static double sinh(double x)
      The hyperbolic sine of x.

    • cosh

      public static double cosh(double x)
      The hyperbolic cosine of x.

    • tanh

      public static double tanh(double x)
      The hyperbolic tangent of x.

    • floorDiv

      public static int floorDiv(int x, int y)
      The largest int not greater than x / y.

    • floorDiv

      public static long floorDiv(long x, int y)
      The largest long not greater than x / y.

    • floorDiv

      public static long floorDiv(long x, long y)
      The largest long not greater than x / y.

    • floorMod

      public static int floorMod(int x, int y)
      x - floorDiv(x, y) * y: the remainder with the sign of y.

    • floorMod

      public static int floorMod(long x, int y)
      x - floorDiv(x, y) * y: the remainder with the sign of y.

    • floorMod

      public static long floorMod(long x, long y)
      x - floorDiv(x, y) * y: the remainder with the sign of y.

    • ceilDiv

      public static int ceilDiv(int x, int y)
      The smallest int not less than x / y.

    • ceilDiv

      public static long ceilDiv(long x, int y)
      The smallest long not less than x / y.

    • ceilDiv

      public static long ceilDiv(long x, long y)
      The smallest long not less than x / y.

    • ceilMod

      public static int ceilMod(int x, int y)
      x - ceilDiv(x, y) * y.

    • ceilMod

      public static int ceilMod(long x, int y)
      x - ceilDiv(x, y) * y.

    • ceilMod

      public static long ceilMod(long x, long y)
      x - ceilDiv(x, y) * y.

    • divideExact

      public static int divideExact(int x, int y)
      x / y, throwing on the one quotient that overflows.

    • divideExact

      public static long divideExact(long x, long y)
      x / y, throwing on the one quotient that overflows.

    • floorDivExact

      public static int floorDivExact(int x, int y)
      floorDiv(x, y), throwing on the one quotient that overflows.

    • floorDivExact

      public static long floorDivExact(long x, long y)
      floorDiv(x, y), throwing on the one quotient that overflows.

    • ceilDivExact

      public static int ceilDivExact(int x, int y)
      ceilDiv(x, y), throwing on the one quotient that overflows.

    • ceilDivExact

      public static long ceilDivExact(long x, long y)
      ceilDiv(x, y), throwing on the one quotient that overflows.

    • addExact

      public static int addExact(int x, int y)
      x + y, throwing when it overflows.

    • addExact

      public static long addExact(long x, long y)
      x + y, throwing when it overflows.

    • subtractExact

      public static int subtractExact(int x, int y)
      x - y, throwing when it overflows.

    • subtractExact

      public static long subtractExact(long x, long y)
      x - y, throwing when it overflows.

    • multiplyExact

      public static int multiplyExact(int x, int y)
      x * y, throwing when it overflows.

    • multiplyExact

      public static long multiplyExact(long x, int y)
      x * y, throwing when it overflows.

    • multiplyExact

      public static long multiplyExact(long x, long y)
      x * y, throwing when it overflows.

    • multiplyFull

      public static long multiplyFull(int x, int y)
      The exact product of two ints.

    • multiplyHigh

      public static long multiplyHigh(long x, long y)
      The high 64 bits of the 128-bit product of two signed longs.

    • unsignedMultiplyHigh

      public static long unsignedMultiplyHigh(long x, long y)
      The high 64 bits of the 128-bit product of two unsigned longs.

    • incrementExact

      public static int incrementExact(int a)
      a + 1, throwing when it overflows.

    • incrementExact

      public static long incrementExact(long a)
      a + 1, throwing when it overflows.

    • decrementExact

      public static int decrementExact(int a)
      a - 1, throwing when it overflows.

    • decrementExact

      public static long decrementExact(long a)
      a - 1, throwing when it overflows.

    • negateExact

      public static int negateExact(int a)
      -a, throwing when it overflows.

    • negateExact

      public static long negateExact(long a)
      -a, throwing when it overflows.

    • toIntExact

      public static int toIntExact(long value)
      The value as an int, throwing when it does not fit.

    • absExact

      public static int absExact(int a)
      The absolute value, throwing for Integer.MIN_VALUE, which has none.

    • absExact

      public static long absExact(long a)
      The absolute value, throwing for Long.MIN_VALUE, which has none.

    • clamp

      public static int clamp(long value, int min, int max)
      value clamped to [min, max], as an int.

    • clamp

      public static long clamp(long value, long min, long max)
      value clamped to [min, max].

    • clamp

      public static double clamp(double value, double min, double max)
      value clamped to [min, max].

    • clamp

      public static float clamp(float value, float min, float max)
      value clamped to [min, max].