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

 Class StrictMath provides basic math constants and operations such as
 trigonometric functions, hyperbolic functions, exponential, logarithms, etc.
 <p>
 In contrast to class {@link java.lang.Math}, the methods in this class return exactly
 the same results on all platforms. Algorithms based on these methods thus
 behave the same (e.g. regarding numerical convergence) on all platforms,
 complying with the slogan "write once, run everywhere". On the other side,
 the implementation of class StrictMath may be less efficient than that of
 class Math, as class StrictMath cannot utilize platform specific features
 such as an extended precision math co-processors.
 <p>
 The methods in this class are specified using the "Freely Distributable Math
 Library" (fdlibm), version 5.3.
 <p>
 <a href="http://www.netlib.org/fdlibm/">http://www.netlib.org/fdlibm/</a>
*/
var StrictMath = {

/** 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.
 <p>
 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]}.
 <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} x
            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]}.
 <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} x
            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]}.
 <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} x
            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).
 <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} x
            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 hyperbolic cosine of the
 argument.
 <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} x
            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 cosine of the argument.
 <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 raising "e" to the power
 of the argument.
 <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} x
            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).
 <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} x
            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 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.
 <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.
 <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} x
            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.
 <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} x
            the value whose base 10 log has to be computed.
@return {Number} the the base 10 logarithm of x
*/
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).
 <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} x
            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 infinity), (non-integer))}
 {@code =} {@code 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 a pseudo-random number between 0.0 (inclusive) and 1.0
 (exclusive).
@return {Number} a pseudo-random number.
*/
random : 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 hyperbolic sine of the
 argument.
 <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} x
            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 sine of the argument.
 <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 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.
 <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.
 <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} x
            the value whose hyperbolic tangent has to be computed.
@return {Number} the hyperbolic tangent of the argument
*/
tanh : 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 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 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 positive.
@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 positive.
@since 1.6
*/
copySign : function(  ) {},

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

/**Returns the 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(  ) {},


};