/**@class java.lang.Math
@extends java.lang.Object

 Class Math provides basic math constants and operations such as trigonometric
 functions, hyperbolic functions, exponential, logarithms, etc.
*/
var Math = {

/** The double value closest to e, the base of the natural logarithm.
*/
E : "2.718281828459045",
/** The double value closest to pi, the ratio of a circle's circumference to
 its diameter.
*/
PI : "3.141592653589793",
/**Returns the absolute value of the argument.
 <p>
 Special cases:
 <ul>
 <li>{@code abs(-0.0) = +0.0}</li>
 <li>{@code abs(+infinity) = +infinity}</li>
 <li>{@code abs(-infinity) = +infinity}</li>
 <li>{@code abs(NaN) = NaN}</li>
 </ul>
*/
abs : function(  ) {},

/**Returns the absolute value of the argument.
 <p>
 Special cases:
 <ul>
 <li>{@code abs(-0.0) = +0.0}</li>
 <li>{@code abs(+infinity) = +infinity}</li>
 <li>{@code abs(-infinity) = +infinity}</li>
 <li>{@code abs(NaN) = NaN}</li>
 </ul>
*/
abs : function(  ) {},

/**Returns the absolute value of the argument.
 <p>
 If the argument is {@code Integer.MIN_VALUE}, {@code Integer.MIN_VALUE}
 is returned.
*/
abs : function(  ) {},

/**Returns the absolute value of the argument. If the argument is {@code
 Long.MIN_VALUE}, {@code Long.MIN_VALUE} is returned.
*/
abs : function(  ) {},

/**Returns the closest double approximation of the arc cosine of the
 argument within the range {@code [0..pi]}. The returned result is within
 1 ulp (unit in the last place) of the real result.
 <p>
 Special cases:
 <ul>
 <li>{@code acos((anything > 1) = NaN}</li>
 <li>{@code acos((anything < -1) = NaN}</li>
 <li>{@code acos(NaN) = NaN}</li>
 </ul>
@param {Number} d
            the value to compute arc cosine of.
@return {Number} the arc cosine of the argument.
*/
acos : function(  ) {},

/**Returns the closest double approximation of the arc sine of the argument
 within the range {@code [-pi/2..pi/2]}. The returned result is within 1
 ulp (unit in the last place) of the real result.
 <p>
 Special cases:
 <ul>
 <li>{@code asin((anything > 1)) = NaN}</li>
 <li>{@code asin((anything < -1)) = NaN}</li>
 <li>{@code asin(NaN) = NaN}</li>
 </ul>
@param {Number} d
            the value whose arc sine has to be computed.
@return {Number} the arc sine of the argument.
*/
asin : function(  ) {},

/**Returns the closest double approximation of the arc tangent of the
 argument within the range {@code [-pi/2..pi/2]}. The returned result is
 within 1 ulp (unit in the last place) of the real result.
 <p>
 Special cases:
 <ul>
 <li>{@code atan(+0.0) = +0.0}</li>
 <li>{@code atan(-0.0) = -0.0}</li>
 <li>{@code atan(+infinity) = +pi/2}</li>
 <li>{@code atan(-infinity) = -pi/2}</li>
 <li>{@code atan(NaN) = NaN}</li>
 </ul>
@param {Number} d
            the value whose arc tangent has to be computed.
@return {Number} the arc tangent of the argument.
*/
atan : function(  ) {},

/**Returns the closest double approximation of the arc tangent of {@code
 y/x} within the range {@code [-pi..pi]}. This is the angle of the polar
 representation of the rectangular coordinates (x,y). The returned result
 is within 2 ulps (units in the last place) of the real result.
 <p>
 Special cases:
 <ul>
 <li>{@code atan2((anything), NaN ) = NaN;}</li>
 <li>{@code atan2(NaN , (anything) ) = NaN;}</li>
 <li>{@code atan2(+0.0, +(anything but NaN)) = +0.0}</li>
 <li>{@code atan2(-0.0, +(anything but NaN)) = -0.0}</li>
 <li>{@code atan2(+0.0, -(anything but NaN)) = +pi}</li>
 <li>{@code atan2(-0.0, -(anything but NaN)) = -pi}</li>
 <li>{@code atan2(+(anything but 0 and NaN), 0) = +pi/2}</li>
 <li>{@code atan2(-(anything but 0 and NaN), 0) = -pi/2}</li>
 <li>{@code atan2(+(anything but infinity and NaN), +infinity)} {@code =}
 {@code +0.0}</li>
 <li>{@code atan2(-(anything but infinity and NaN), +infinity)} {@code =}
 {@code -0.0}</li>
 <li>{@code atan2(+(anything but infinity and NaN), -infinity) = +pi}</li>
 <li>{@code atan2(-(anything but infinity and NaN), -infinity) = -pi}</li>
 <li>{@code atan2(+infinity, +infinity ) = +pi/4}</li>
 <li>{@code atan2(-infinity, +infinity ) = -pi/4}</li>
 <li>{@code atan2(+infinity, -infinity ) = +3pi/4}</li>
 <li>{@code atan2(-infinity, -infinity ) = -3pi/4}</li>
 <li>{@code atan2(+infinity, (anything but,0, NaN, and infinity))} {@code
 =} {@code +pi/2}</li>
 <li>{@code atan2(-infinity, (anything but,0, NaN, and infinity))} {@code
 =} {@code -pi/2}</li>
 </ul>
@param {Number} y
            the numerator of the value whose atan has to be computed.
@param {Number} x
            the denominator of the value whose atan has to be computed.
@return {Number} the arc tangent of {@code y/x}.
*/
atan2 : function(  ) {},

/**Returns the closest double approximation of the cube root of the
 argument.
 <p>
 Special cases:
 <ul>
 <li>{@code cbrt(+0.0) = +0.0}</li>
 <li>{@code cbrt(-0.0) = -0.0}</li>
 <li>{@code cbrt(+infinity) = +infinity}</li>
 <li>{@code cbrt(-infinity) = -infinity}</li>
 <li>{@code cbrt(NaN) = NaN}</li>
 </ul>
@param {Number} d
            the value whose cube root has to be computed.
@return {Number} the cube root of the argument.
*/
cbrt : function(  ) {},

/**Returns the double conversion of the most negative (closest to negative
 infinity) integer value greater than or equal to the argument.
 <p>
 Special cases:
 <ul>
 <li>{@code ceil(+0.0) = +0.0}</li>
 <li>{@code ceil(-0.0) = -0.0}</li>
 <li>{@code ceil((anything in range (-1,0)) = -0.0}</li>
 <li>{@code ceil(+infinity) = +infinity}</li>
 <li>{@code ceil(-infinity) = -infinity}</li>
 <li>{@code ceil(NaN) = NaN}</li>
 </ul>
*/
ceil : function(  ) {},

/**Returns the closest double approximation of the cosine of the argument.
 The returned result is within 1 ulp (unit in the last place) of the real
 result.
 <p>
 Special cases:
 <ul>
 <li>{@code cos(+infinity) = NaN}</li>
 <li>{@code cos(-infinity) = NaN}</li>
 <li>{@code cos(NaN) = NaN}</li>
 </ul>
@param {Number} d
            the angle whose cosine has to be computed, in radians.
@return {Number} the cosine of the argument.
*/
cos : function(  ) {},

/**Returns the closest double approximation of the hyperbolic cosine of the
 argument. The returned result is within 2.5 ulps (units in the last
 place) of the real result.
 <p>
 Special cases:
 <ul>
 <li>{@code cosh(+infinity) = +infinity}</li>
 <li>{@code cosh(-infinity) = +infinity}</li>
 <li>{@code cosh(NaN) = NaN}</li>
 </ul>
@param {Number} d
            the value whose hyperbolic cosine has to be computed.
@return {Number} the hyperbolic cosine of the argument.
*/
cosh : function(  ) {},

/**Returns the closest double approximation of the raising "e" to the power
 of the argument. The returned result is within 1 ulp (unit in the last
 place) of the real result.
 <p>
 Special cases:
 <ul>
 <li>{@code exp(+infinity) = +infinity}</li>
 <li>{@code exp(-infinity) = +0.0}</li>
 <li>{@code exp(NaN) = NaN}</li>
 </ul>
@param {Number} d
            the value whose exponential has to be computed.
@return {Number} the exponential of the argument.
*/
exp : function(  ) {},

/**Returns the closest double approximation of <i>{@code e}</i><sup> {@code
 d}</sup>{@code - 1}. If the argument is very close to 0, it is much more
 accurate to use {@code expm1(d)+1} than {@code exp(d)} (due to
 cancellation of significant digits). The returned result is within 1 ulp
 (unit in the last place) of the real result.
 <p>
 For any finite input, the result is not less than -1.0. If the real
 result is within 0.5 ulp of -1, -1.0 is returned.
 <p>
 Special cases:
 <ul>
 <li>{@code expm1(+0.0) = +0.0}</li>
 <li>{@code expm1(-0.0) = -0.0}</li>
 <li>{@code expm1(+infinity) = +infinity}</li>
 <li>{@code expm1(-infinity) = -1.0}</li>
 <li>{@code expm1(NaN) = NaN}</li>
 </ul>
@param {Number} d
            the value to compute the <i>{@code e}</i><sup>{@code d} </sup>
            {@code - 1} of.
@return {Number} the <i>{@code e}</i><sup>{@code d}</sup>{@code - 1} value of the
         argument.
*/
expm1 : function(  ) {},

/**Returns the double conversion of the most positive (closest to positive
 infinity) integer value less than or equal to the argument.
 <p>
 Special cases:
 <ul>
 <li>{@code floor(+0.0) = +0.0}</li>
 <li>{@code floor(-0.0) = -0.0}</li>
 <li>{@code floor(+infinity) = +infinity}</li>
 <li>{@code floor(-infinity) = -infinity}</li>
 <li>{@code floor(NaN) = NaN}</li>
 </ul>
*/
floor : function(  ) {},

/**Returns {@code sqrt(}<i>{@code x}</i><sup>{@code 2}</sup>{@code +} <i>
 {@code y}</i><sup>{@code 2}</sup>{@code )}. The final result is without
 medium underflow or overflow. The returned result is within 1 ulp (unit
 in the last place) of the real result. If one parameter remains constant,
 the result should be semi-monotonic.
 <p>
 Special cases:
 <ul>
 <li>{@code hypot(+infinity, (anything including NaN)) = +infinity}</li>
 <li>{@code hypot(-infinity, (anything including NaN)) = +infinity}</li>
 <li>{@code hypot((anything including NaN), +infinity) = +infinity}</li>
 <li>{@code hypot((anything including NaN), -infinity) = +infinity}</li>
 <li>{@code hypot(NaN, NaN) = NaN}</li>
 </ul>
@param {Number} x
            a double number.
@param {Number} y
            a double number.
@return {Number} the {@code sqrt(}<i>{@code x}</i><sup>{@code 2}</sup>{@code +}
         <i> {@code y}</i><sup>{@code 2}</sup>{@code )} value of the
         arguments.
*/
hypot : function(  ) {},

/**Returns the remainder of dividing {@code x} by {@code y} using the IEEE
 754 rules. The result is {@code x-round(x/p)*p} where {@code round(x/p)}
 is the nearest integer (rounded to even), but without numerical
 cancellation problems.
 <p>
 Special cases:
 <ul>
 <li>{@code IEEEremainder((anything), 0) = NaN}</li>
 <li>{@code IEEEremainder(+infinity, (anything)) = NaN}</li>
 <li>{@code IEEEremainder(-infinity, (anything)) = NaN}</li>
 <li>{@code IEEEremainder(NaN, (anything)) = NaN}</li>
 <li>{@code IEEEremainder((anything), NaN) = NaN}</li>
 <li>{@code IEEEremainder(x, +infinity) = x } where x is anything but
 +/-infinity</li>
 <li>{@code IEEEremainder(x, -infinity) = x } where x is anything but
 +/-infinity</li>
 </ul>
@param {Number} x
            the numerator of the operation.
@param {Number} y
            the denominator of the operation.
@return {Number} the IEEE754 floating point reminder of of {@code x/y}.
*/
IEEEremainder : function(  ) {},

/**Returns the closest double approximation of the natural logarithm of the
 argument. The returned result is within 1 ulp (unit in the last place) of
 the real result.
 <p>
 Special cases:
 <ul>
 <li>{@code log(+0.0) = -infinity}</li>
 <li>{@code log(-0.0) = -infinity}</li>
 <li>{@code log((anything < 0) = NaN}</li>
 <li>{@code log(+infinity) = +infinity}</li>
 <li>{@code log(-infinity) = NaN}</li>
 <li>{@code log(NaN) = NaN}</li>
 </ul>
@param {Number} d
            the value whose log has to be computed.
@return {Number} the natural logarithm of the argument.
*/
log : function(  ) {},

/**Returns the closest double approximation of the base 10 logarithm of the
 argument. The returned result is within 1 ulp (unit in the last place) of
 the real result.
 <p>
 Special cases:
 <ul>
 <li>{@code log10(+0.0) = -infinity}</li>
 <li>{@code log10(-0.0) = -infinity}</li>
 <li>{@code log10((anything < 0) = NaN}</li>
 <li>{@code log10(+infinity) = +infinity}</li>
 <li>{@code log10(-infinity) = NaN}</li>
 <li>{@code log10(NaN) = NaN}</li>
 </ul>
@param {Number} d
            the value whose base 10 log has to be computed.
@return {Number} the natural logarithm of the argument.
*/
log10 : function(  ) {},

/**Returns the closest double approximation of the natural logarithm of the
 sum of the argument and 1. If the argument is very close to 0, it is much
 more accurate to use {@code log1p(d)} than {@code log(1.0+d)} (due to
 numerical cancellation). The returned result is within 1 ulp (unit in the
 last place) of the real result and is semi-monotonic.
 <p>
 Special cases:
 <ul>
 <li>{@code log1p(+0.0) = +0.0}</li>
 <li>{@code log1p(-0.0) = -0.0}</li>
 <li>{@code log1p((anything < 1)) = NaN}</li>
 <li>{@code log1p(-1.0) = -infinity}</li>
 <li>{@code log1p(+infinity) = +infinity}</li>
 <li>{@code log1p(-infinity) = NaN}</li>
 <li>{@code log1p(NaN) = NaN}</li>
 </ul>
@param {Number} d
            the value to compute the {@code ln(1+d)} of.
@return {Number} the natural logarithm of the sum of the argument and 1.
*/
log1p : function(  ) {},

/**Returns the most positive (closest to positive infinity) of the two
 arguments.
 <p>
 Special cases:
 <ul>
 <li>{@code max(NaN, (anything)) = NaN}</li>
 <li>{@code max((anything), NaN) = NaN}</li>
 <li>{@code max(+0.0, -0.0) = +0.0}</li>
 <li>{@code max(-0.0, +0.0) = +0.0}</li>
 </ul>
*/
max : function(  ) {},

/**Returns the most positive (closest to positive infinity) of the two
 arguments.
 <p>
 Special cases:
 <ul>
 <li>{@code max(NaN, (anything)) = NaN}</li>
 <li>{@code max((anything), NaN) = NaN}</li>
 <li>{@code max(+0.0, -0.0) = +0.0}</li>
 <li>{@code max(-0.0, +0.0) = +0.0}</li>
 </ul>
*/
max : function(  ) {},

/**Returns the most positive (closest to positive infinity) of the two
 arguments.
*/
max : function(  ) {},

/**Returns the most positive (closest to positive infinity) of the two
 arguments.
*/
max : function(  ) {},

/**Returns the most negative (closest to negative infinity) of the two
 arguments.
 <p>
 Special cases:
 <ul>
 <li>{@code min(NaN, (anything)) = NaN}</li>
 <li>{@code min((anything), NaN) = NaN}</li>
 <li>{@code min(+0.0, -0.0) = -0.0}</li>
 <li>{@code min(-0.0, +0.0) = -0.0}</li>
 </ul>
*/
min : function(  ) {},

/**Returns the most negative (closest to negative infinity) of the two
 arguments.
 <p>
 Special cases:
 <ul>
 <li>{@code min(NaN, (anything)) = NaN}</li>
 <li>{@code min((anything), NaN) = NaN}</li>
 <li>{@code min(+0.0, -0.0) = -0.0}</li>
 <li>{@code min(-0.0, +0.0) = -0.0}</li>
 </ul>
*/
min : function(  ) {},

/**Returns the most negative (closest to negative infinity) of the two
 arguments.
*/
min : function(  ) {},

/**Returns the most negative (closest to negative infinity) of the two
 arguments.
*/
min : function(  ) {},

/**Returns the closest double approximation of the result of raising {@code
 x} to the power of {@code y}.
 <p>
 Special cases:
 <ul>
 <li>{@code pow((anything), +0.0) = 1.0}</li>
 <li>{@code pow((anything), -0.0) = 1.0}</li>
 <li>{@code pow(x, 1.0) = x}</li>
 <li>{@code pow((anything), NaN) = NaN}</li>
 <li>{@code pow(NaN, (anything except 0)) = NaN}</li>
 <li>{@code pow(+/-(|x| > 1), +infinity) = +infinity}</li>
 <li>{@code pow(+/-(|x| > 1), -infinity) = +0.0}</li>
 <li>{@code pow(+/-(|x| < 1), +infinity) = +0.0}</li>
 <li>{@code pow(+/-(|x| < 1), -infinity) = +infinity}</li>
 <li>{@code pow(+/-1.0 , +infinity) = NaN}</li>
 <li>{@code pow(+/-1.0 , -infinity) = NaN}</li>
 <li>{@code pow(+0.0, (+anything except 0, NaN)) = +0.0}</li>
 <li>{@code pow(-0.0, (+anything except 0, NaN, odd integer)) = +0.0}</li>
 <li>{@code pow(+0.0, (-anything except 0, NaN)) = +infinity}</li>
 <li>{@code pow(-0.0, (-anything except 0, NAN, odd integer))} {@code =}
 {@code +infinity}</li>
 <li>{@code pow(-0.0, (odd integer)) = -pow( +0 , (odd integer) )}</li>
 <li>{@code pow(+infinity, (+anything except 0, NaN)) = +infinity}</li>
 <li>{@code pow(+infinity, (-anything except 0, NaN)) = +0.0}</li>
 <li>{@code pow(-infinity, (anything)) = -pow(0, (-anything))}</li>
 <li>{@code pow((-anything), (integer))} {@code =} {@code
 pow(-1,(integer))*pow(+anything,integer) }</li>
 <li>{@code pow((-anything except 0 and inf), (non-integer)) = NAN}</li>
 </ul>
@param {Number} x
            the base of the operation.
@param {Number} y
            the exponent of the operation.
@return {Number} {@code x} to the power of {@code y}.
*/
pow : function(  ) {},

/**Returns the double conversion of the result of rounding the argument to
 an integer. Tie breaks are rounded towards even.
 <p>
 Special cases:
 <ul>
 <li>{@code rint(+0.0) = +0.0}</li>
 <li>{@code rint(-0.0) = -0.0}</li>
 <li>{@code rint(+infinity) = +infinity}</li>
 <li>{@code rint(-infinity) = -infinity}</li>
 <li>{@code rint(NaN) = NaN}</li>
 </ul>
@param {Number} d
            the value to be rounded.
@return {Number} the closest integer to the argument (as a double).
*/
rint : function(  ) {},

/**Returns the result of rounding the argument to an integer. The result is
 equivalent to {@code (long) Math.floor(d+0.5)}.
 <p>
 Special cases:
 <ul>
 <li>{@code round(+0.0) = +0.0}</li>
 <li>{@code round(-0.0) = +0.0}</li>
 <li>{@code round((anything > Long.MAX_VALUE) = Long.MAX_VALUE}</li>
 <li>{@code round((anything < Long.MIN_VALUE) = Long.MIN_VALUE}</li>
 <li>{@code round(+infinity) = Long.MAX_VALUE}</li>
 <li>{@code round(-infinity) = Long.MIN_VALUE}</li>
 <li>{@code round(NaN) = +0.0}</li>
 </ul>
@param {Number} d
            the value to be rounded.
@return {Number} the closest integer to the argument.
*/
round : function(  ) {},

/**Returns the result of rounding the argument to an integer. The result is
 equivalent to {@code (int) Math.floor(f+0.5)}.
 <p>
 Special cases:
 <ul>
 <li>{@code round(+0.0) = +0.0}</li>
 <li>{@code round(-0.0) = +0.0}</li>
 <li>{@code round((anything > Integer.MAX_VALUE) = Integer.MAX_VALUE}</li>
 <li>{@code round((anything < Integer.MIN_VALUE) = Integer.MIN_VALUE}</li>
 <li>{@code round(+infinity) = Integer.MAX_VALUE}</li>
 <li>{@code round(-infinity) = Integer.MIN_VALUE}</li>
 <li>{@code round(NaN) = +0.0}</li>
 </ul>
@param {Number} f
            the value to be rounded.
@return {Number} the closest integer to the argument.
*/
round : function(  ) {},

/**Returns the signum function of the argument. If the argument is less than
 zero, it returns -1.0. If the argument is greater than zero, 1.0 is
 returned. If the argument is either positive or negative zero, the
 argument is returned as result.
 <p>
 Special cases:
 <ul>
 <li>{@code signum(+0.0) = +0.0}</li>
 <li>{@code signum(-0.0) = -0.0}</li>
 <li>{@code signum(+infinity) = +1.0}</li>
 <li>{@code signum(-infinity) = -1.0}</li>
 <li>{@code signum(NaN) = NaN}</li>
 </ul>
@param {Number} d
            the value whose signum has to be computed.
@return {Number} the value of the signum function.
*/
signum : function(  ) {},

/**Returns the signum function of the argument. If the argument is less than
 zero, it returns -1.0. If the argument is greater than zero, 1.0 is
 returned. If the argument is either positive or negative zero, the
 argument is returned as result.
 <p>
 Special cases:
 <ul>
 <li>{@code signum(+0.0) = +0.0}</li>
 <li>{@code signum(-0.0) = -0.0}</li>
 <li>{@code signum(+infinity) = +1.0}</li>
 <li>{@code signum(-infinity) = -1.0}</li>
 <li>{@code signum(NaN) = NaN}</li>
 </ul>
@param {Number} f
            the value whose signum has to be computed.
@return {Number} the value of the signum function.
*/
signum : function(  ) {},

/**Returns the closest double approximation of the sine of the argument. The
 returned result is within 1 ulp (unit in the last place) of the real
 result.
 <p>
 Special cases:
 <ul>
 <li>{@code sin(+0.0) = +0.0}</li>
 <li>{@code sin(-0.0) = -0.0}</li>
 <li>{@code sin(+infinity) = NaN}</li>
 <li>{@code sin(-infinity) = NaN}</li>
 <li>{@code sin(NaN) = NaN}</li>
 </ul>
@param {Number} d
            the angle whose sin has to be computed, in radians.
@return {Number} the sine of the argument.
*/
sin : function(  ) {},

/**Returns the closest double approximation of the hyperbolic sine of the
 argument. The returned result is within 2.5 ulps (units in the last
 place) of the real result.
 <p>
 Special cases:
 <ul>
 <li>{@code sinh(+0.0) = +0.0}</li>
 <li>{@code sinh(-0.0) = -0.0}</li>
 <li>{@code sinh(+infinity) = +infinity}</li>
 <li>{@code sinh(-infinity) = -infinity}</li>
 <li>{@code sinh(NaN) = NaN}</li>
 </ul>
@param {Number} d
            the value whose hyperbolic sine has to be computed.
@return {Number} the hyperbolic sine of the argument.
*/
sinh : function(  ) {},

/**Returns the closest double approximation of the square root of the
 argument.
 <p>
 Special cases:
 <ul>
 <li>{@code sqrt(+0.0) = +0.0}</li>
 <li>{@code sqrt(-0.0) = -0.0}</li>
 <li>{@code sqrt( (anything < 0) ) = NaN}</li>
 <li>{@code sqrt(+infinity) = +infinity}</li>
 <li>{@code sqrt(NaN) = NaN}</li>
 </ul>
*/
sqrt : function(  ) {},

/**Returns the closest double approximation of the tangent of the argument.
 The returned result is within 1 ulp (unit in the last place) of the real
 result.
 <p>
 Special cases:
 <ul>
 <li>{@code tan(+0.0) = +0.0}</li>
 <li>{@code tan(-0.0) = -0.0}</li>
 <li>{@code tan(+infinity) = NaN}</li>
 <li>{@code tan(-infinity) = NaN}</li>
 <li>{@code tan(NaN) = NaN}</li>
 </ul>
@param {Number} d
            the angle whose tangent has to be computed, in radians.
@return {Number} the tangent of the argument.
*/
tan : function(  ) {},

/**Returns the closest double approximation of the hyperbolic tangent of the
 argument. The absolute value is always less than 1. The returned result
 is within 2.5 ulps (units in the last place) of the real result. If the
 real result is within 0.5ulp of 1 or -1, it should return exactly +1 or
 -1.
 <p>
 Special cases:
 <ul>
 <li>{@code tanh(+0.0) = +0.0}</li>
 <li>{@code tanh(-0.0) = -0.0}</li>
 <li>{@code tanh(+infinity) = +1.0}</li>
 <li>{@code tanh(-infinity) = -1.0}</li>
 <li>{@code tanh(NaN) = NaN}</li>
 </ul>
@param {Number} d
            the value whose hyperbolic tangent has to be computed.
@return {Number} the hyperbolic tangent of the argument.
*/
tanh : function(  ) {},

/**Returns a pseudo-random double {@code n}, where {@code n >= 0.0 && n < 1.0}.
 This method reuses a single instance of {@link java.util.Random}.
 This method is thread-safe because access to the {@code Random} is synchronized,
 but this harms scalability. Applications may find a performance benefit from
 allocating a {@code Random} for each of their threads.
@return {Number} a pseudo-random number.
*/
random : function(  ) {},

/**Set the seed for the pseudo random generator used by {@link #random}()
 and {@link #randomIntInternal}().
@hide for internal use only.
*/
setRandomSeedInternal : function(  ) {},

/**
@hide for internal use only.
*/
randomIntInternal : function(  ) {},

/**Returns the measure in radians of the supplied degree angle. The result
 is {@code angdeg / 180 * pi}.
 <p>
 Special cases:
 <ul>
 <li>{@code toRadians(+0.0) = +0.0}</li>
 <li>{@code toRadians(-0.0) = -0.0}</li>
 <li>{@code toRadians(+infinity) = +infinity}</li>
 <li>{@code toRadians(-infinity) = -infinity}</li>
 <li>{@code toRadians(NaN) = NaN}</li>
 </ul>
@param {Number} angdeg
            an angle in degrees.
@return {Number} the radian measure of the angle.
*/
toRadians : function(  ) {},

/**Returns the measure in degrees of the supplied radian angle. The result
 is {@code angrad * 180 / pi}.
 <p>
 Special cases:
 <ul>
 <li>{@code toDegrees(+0.0) = +0.0}</li>
 <li>{@code toDegrees(-0.0) = -0.0}</li>
 <li>{@code toDegrees(+infinity) = +infinity}</li>
 <li>{@code toDegrees(-infinity) = -infinity}</li>
 <li>{@code toDegrees(NaN) = NaN}</li>
 </ul>
@param {Number} angrad
            an angle in radians.
@return {Number} the degree measure of the angle.
*/
toDegrees : function(  ) {},

/**Returns the argument's ulp (unit in the last place). The size of a ulp of
 a double value is the positive distance between this value and the double
 value next larger in magnitude. For non-NaN {@code x}, {@code ulp(-x) ==
 ulp(x)}.
 <p>
 Special cases:
 <ul>
 <li>{@code ulp(+0.0) = Double.MIN_VALUE}</li>
 <li>{@code ulp(-0.0) = Double.MIN_VALUE}</li>
 <li>{@code ulp(+infinity) = infinity}</li>
 <li>{@code ulp(-infinity) = infinity}</li>
 <li>{@code ulp(NaN) = NaN}</li>
 </ul>
@param {Number} d
            the floating-point value to compute ulp of.
@return {Number} the size of a ulp of the argument.
*/
ulp : function(  ) {},

/**Returns the argument's ulp (unit in the last place). The size of a ulp of
 a float value is the positive distance between this value and the float
 value next larger in magnitude. For non-NaN {@code x}, {@code ulp(-x) ==
 ulp(x)}.
 <p>
 Special cases:
 <ul>
 <li>{@code ulp(+0.0) = Float.MIN_VALUE}</li>
 <li>{@code ulp(-0.0) = Float.MIN_VALUE}</li>
 <li>{@code ulp(+infinity) = infinity}</li>
 <li>{@code ulp(-infinity) = infinity}</li>
 <li>{@code ulp(NaN) = NaN}</li>
 </ul>
@param {Number} f
            the floating-point value to compute ulp of.
@return {Number} the size of a ulp of the argument.
*/
ulp : function(  ) {},

/**Returns a double with the given magnitude and the sign of {@code sign}.
 If {@code sign} is NaN, the sign of the result is arbitrary.
 If you need a determinate sign in such cases, use {@code StrictMath.copySign}.
@since 1.6
*/
copySign : function(  ) {},

/**Returns a float with the given magnitude and the sign of {@code sign}.
 If {@code sign} is NaN, the sign of the result is arbitrary.
 If you need a determinate sign in such cases, use {@code StrictMath.copySign}.
@since 1.6
*/
copySign : function(  ) {},

/**Returns the unbiased base-2 exponent of float {@code f}.
@since 1.6
*/
getExponent : function(  ) {},

/**Returns the unbiased base-2 exponent of double {@code d}.
@since 1.6
*/
getExponent : function(  ) {},

/**Returns the next double after {@code start} in the given {@code direction}.
@since 1.6
*/
nextAfter : function(  ) {},

/**Returns the next float after {@code start} in the given {@code direction}.
@since 1.6
*/
nextAfter : function(  ) {},

/**Returns the next double larger than {@code d}.
@since 1.6
*/
nextUp : function(  ) {},

/**Returns the next float larger than {@code f}.
@since 1.6
*/
nextUp : function(  ) {},

/**Returns {@code d} * 2^{@code scaleFactor}. The result may be rounded.
@since 1.6
*/
scalb : function(  ) {},

/**Returns {@code d} * 2^{@code scaleFactor}. The result may be rounded.
@since 1.6
*/
scalb : function(  ) {},


};