FileDocCategorySizeDatePackage
Math.javaAPI DocJ2ME CLDC 1.115203Wed Feb 05 15:56:00 GMT 2003java.lang

# Math

public final class Math extends Object
 The class `Math` contains methods for performing basic numeric operations.
 authorunascribedversion12/17/01 (CLDC 1.1)sinceJDK1.0, CLDC 1.0

Fields Summary
public static final double
E
The `double` value that is closer than any other to `e`, the base of the natural logarithms.
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.
private static long
negativeZeroFloatBits
private static long
negativeZeroDoubleBits
Constructors Summary
private Math()
Don't let anyone instantiate this class.

Methods Summary
public static intabs(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.

 parama an `int` value.returnthe absolute value of the argument.seejava.lang.Integer#MIN_VALUE

``````        return (a < 0) ? -a : a;
``````
public static longabs(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.

 parama a `long` value.returnthe absolute value of the argument.seejava.lang.Long#MIN_VALUE

``````        return (a < 0) ? -a : a;
``````
public static floatabs(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))`

 parama a `float` value.returnthe absolute value of the argument.sinceCLDC 1.1

``````        return (a <= 0.0F) ? 0.0F - a : a;
``````
public static doubleabs(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)>>>1)`

 parama a `double` value.returnthe absolute value of the argument.sinceCLDC 1.1

``````        return (a <= 0.0D) ? 0.0D - a : a;
``````
public static native doubleceil(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)`.

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

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

 parama an angle, in radians.returnthe cosine of the argument.sinceCLDC 1.1

public static native doublefloor(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.

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

public static intmax(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.

 parama an `int` value.paramb an `int` value.returnthe larger of `a` and `b`.seejava.lang.Long#MAX_VALUE

``````        return (a >= b) ? a : b;
``````
public static longmax(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.

 parama a `long` value.paramb a `long` value.returnthe larger of `a` and `b`.seejava.lang.Long#MAX_VALUE

``````        return (a >= b) ? a : b;
``````
public static floatmax(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.

 parama a `float` value.paramb a `float` value.returnthe larger of `a` and `b`.

``````

if (a != a) return a; // a is NaN
if ((a == 0.0f) && (b == 0.0f)
&& (Float.floatToIntBits(a) == negativeZeroFloatBits)) {
return b;
}
return (a >= b) ? a : b;
``````
public static doublemax(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.

 parama a `double` value.paramb a `double` value.returnthe larger of `a` and `b`.

``````        if (a != a) return a; // a is NaN
if ((a == 0.0d) && (b == 0.0d)
&& (Double.doubleToLongBits(a) == negativeZeroDoubleBits)) {
return b;
}
return (a >= b) ? a : b;
``````
public static intmin(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.

 parama an `int` value.paramb an `int` value.returnthe smaller of `a` and `b`.seejava.lang.Long#MIN_VALUE

``````        return (a <= b) ? a : b;
``````
public static longmin(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.

 parama a `long` value.paramb a `long` value.returnthe smaller of `a` and `b`.seejava.lang.Long#MIN_VALUE

``````        return (a <= b) ? a : b;
``````
public static floatmin(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.

 parama a `float` value.paramb a `float` value.returnthe smaller of `a` and `b.`sinceCLDC 1.1

``````        if (a != a) return a; // a is NaN
if ((a == 0.0f) && (b == 0.0f)
&& (Float.floatToIntBits(b) == negativeZeroFloatBits)) {
return b;
}
return (a <= b) ? a : b;
``````
public static doublemin(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.

 parama a `double` value.paramb a `double` value.returnthe smaller of `a` and `b`.sinceCLDC 1.1

``````        if (a != a) return a; // a is NaN
if ((a == 0.0d) && (b == 0.0d)
&& (Double.doubleToLongBits(b) == negativeZeroDoubleBits)) {
return b;
}
return (a <= b) ? a : b;
``````
public static native doublesin(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.

 parama an angle, in radians.returnthe sine of the argument.sinceCLDC 1.1

public static native doublesqrt(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.

 parama a `double` value.returnthe positive square root of `a`. If the argument is NaN or less than zero, the result is NaN.sinceCLDC 1.1

public static native doubletan(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

 parama an angle, in radians.returnthe tangent of the argument.sinceCLDC 1.1

Converts an angle measured in radians to the equivalent angle measured in degrees.

 paramangrad an angle, in radiansreturnthe measurement of the angle `angrad` in degrees.sinceCLDC 1.1

``````        return angrad * 180.0 / PI;
``````
Converts an angle measured in degrees to the equivalent angle measured in radians.

 paramangdeg an angle, in degreesreturnthe measurement of the angle `angdeg` in radians.sinceCLDC 1.1

``````

return angdeg / 180.0 * PI;
``````