Methods Summary 

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

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

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))
return (a <= 0.0F) ? 0.0F  a : a;

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)>>>1)
return (a <= 0.0D) ? 0.0D  a : a;

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

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

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

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

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

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

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

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

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

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

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

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