/**@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( ) {}, };