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.
author
unascribed
version
12/17/01 (CLDC 1.1)
since
JDK1.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.

param
a an int value.
return
the absolute value of the argument.
see
java.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.

param
a a long value.
return
the absolute value of the argument.
see
java.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))

param
a a float value.
return
the absolute value of the argument.
since
CLDC 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)

param
a a double value.
return
the absolute value of the argument.
since
CLDC 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).

param
a a double value.
return
the smallest (closest to negative infinity) double value that is not less than the argument and is equal to a mathematical integer.
since
CLDC 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.

param
a an angle, in radians.
return
the cosine of the argument.
since
CLDC 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.

param
a a double value.
return
the largest (closest to positive infinity) double value that is not greater than the argument and is equal to a mathematical integer.
since
CLDC 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.

param
a an int value.
param
b an int value.
return
the larger of a and b.
see
java.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.

param
a a long value.
param
b a long value.
return
the larger of a and b.
see
java.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.

param
a a float value.
param
b a float value.
return
the 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.

param
a a double value.
param
b a double value.
return
the 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.

param
a an int value.
param
b an int value.
return
the smaller of a and b.
see
java.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.

param
a a long value.
param
b a long value.
return
the smaller of a and b.
see
java.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.

param
a a float value.
param
b a float value.
return
the smaller of a and b.
since
CLDC 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.

param
a a double value.
param
b a double value.
return
the smaller of a and b.
since
CLDC 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.

param
a an angle, in radians.
return
the sine of the argument.
since
CLDC 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.

param
a a double value.
return
the positive square root of a. If the argument is NaN or less than zero, the result is NaN.
since
CLDC 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

param
a an angle, in radians.
return
the tangent of the argument.
since
CLDC 1.1

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

param
angrad an angle, in radians
return
the measurement of the angle angrad in degrees.
since
CLDC 1.1

        return angrad * 180.0 / PI;
    
public static doubletoRadians(double angdeg)
Converts an angle measured in degrees to the equivalent angle measured in radians.

param
angdeg an angle, in degrees
return
the measurement of the angle angdeg in radians.
since
CLDC 1.1


                                                                                 
          

                                                      
          

                                                                                 
         

                                                        
         
        return angdeg / 180.0 * PI;