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