/**@class java.lang.Double implements java.lang.Comparable @extends java.lang.Number The wrapper for the primitive type {@code double}. @see java.lang.Number @since 1.0 */ var Double = { /** Constant for the maximum {@code double} value, (2 - 2<sup>-52</sup>) * 2<sup>1023</sup>. */ MAX_VALUE : "1.7976931348623157E308", /** Constant for the minimum {@code double} value, 2<sup>-1074</sup>. */ MIN_VALUE : "4.9E-324", /** Constant for the Not-a-Number (NaN) value of the {@code double} type. */ NaN : "NaN", /** Constant for the positive infinity value of the {@code double} type. */ POSITIVE_INFINITY : "Infinity", /** Constant for the negative infinity value of the {@code double} type. */ NEGATIVE_INFINITY : "-Infinity", /** Constant for the smallest positive normal value of the {@code double} type. @since 1.6 */ MIN_NORMAL : "2.2250738585072014E-308", /** Maximum base-2 exponent that a finite value of the {@code double} type may have. Equal to {@code Math.getExponent(Double.MAX_VALUE)}. @since 1.6 */ MAX_EXPONENT : "1023", /** Minimum base-2 exponent that a normal value of the {@code double} type may have. Equal to {@code Math.getExponent(Double.MIN_NORMAL)}. @since 1.6 */ MIN_EXPONENT : "-1022", /** The {@link java.lang.Class} object that represents the primitive type {@code double}. @since 1.1 */ TYPE : "null", /** Constant for the number of bits needed to represent a {@code double} in two's complement form. @since 1.5 */ SIZE : "64", /**Compares this object to the specified double object to determine their relative order. There are two special cases: <ul> <li>{@code Double.NaN} is equal to {@code Double.NaN} and it is greater than any other double value, including {@code Double.POSITIVE_INFINITY};</li> <li>+0.0d is greater than -0.0d</li> </ul> @param {Number} object the double object to compare this object to. @return {Number} a negative value if the value of this double is less than the value of {@code object}; 0 if the value of this double and the value of {@code object} are equal; a positive value if the value of this double is greater than the value of {@code object}. @throws NullPointerException if {@code object} is {@code null}. @see java.lang.Comparable @since 1.2 */ compareTo : function( ) {}, /** */ byteValue : function( ) {}, /**Returns an integer corresponding to the bits of the given <a href="http://en.wikipedia.org/wiki/IEEE_754-1985">IEEE 754</a> double precision {@code value}. All <em>Not-a-Number (NaN)</em> values are converted to a single NaN representation ({@code 0x7ff8000000000000L}) (compare to {@link #doubleToRawLongBits}). */ doubleToLongBits : function( ) {}, /**Returns an integer corresponding to the bits of the given <a href="http://en.wikipedia.org/wiki/IEEE_754-1985">IEEE 754</a> double precision {@code value}. <em>Not-a-Number (NaN)</em> values are preserved (compare to {@link #doubleToLongBits}). */ doubleToRawLongBits : function( ) {}, /**Gets the primitive value of this double. @return {Number} this object's primitive value. */ doubleValue : function( ) {}, /**Tests this double for equality with {@code object}. To be equal, {@code object} must be an instance of {@code Double} and {@code doubleToLongBits} must give the same value for both objects. <p>Note that, unlike {@code ==}, {@code -0.0} and {@code +0.0} compare unequal, and {@code NaN}s compare equal by this method. @param {Object {Object}} object the object to compare this double with. @return {Boolean} {@code true} if the specified object is equal to this {@code Double}; {@code false} otherwise. */ equals : function( ) {}, /** */ floatValue : function( ) {}, /** */ hashCode : function( ) {}, /** */ intValue : function( ) {}, /**Indicates whether this object represents an infinite value. @return {Boolean} {@code true} if the value of this double is positive or negative infinity; {@code false} otherwise. */ isInfinite : function( ) {}, /**Indicates whether the specified double represents an infinite value. @param {Number} d the double to check. @return {Boolean} {@code true} if the value of {@code d} is positive or negative infinity; {@code false} otherwise. */ isInfinite : function( ) {}, /**Indicates whether this object is a <em>Not-a-Number (NaN)</em> value. @return {Boolean} {@code true} if this double is <em>Not-a-Number</em>; {@code false} if it is a (potentially infinite) double number. */ isNaN : function( ) {}, /**Indicates whether the specified double is a <em>Not-a-Number (NaN)</em> value. @param {Number} d the double value to check. @return {Boolean} {@code true} if {@code d} is <em>Not-a-Number</em>; {@code false} if it is a (potentially infinite) double number. */ isNaN : function( ) {}, /**Returns the <a href="http://en.wikipedia.org/wiki/IEEE_754-1985">IEEE 754</a> double precision float corresponding to the given {@code bits}. */ longBitsToDouble : function( ) {}, /** */ longValue : function( ) {}, /**Parses the specified string as a double value. @param {String} string the string representation of a double value. @return {Number} the primitive double value represented by {@code string}. @throws NumberFormatException if {@code string} cannot be parsed as a double value. */ parseDouble : function( ) {}, /** */ shortValue : function( ) {}, /** */ toString : function( ) {}, /**Returns a string containing a concise, human-readable description of the specified double value. @param {Number} d the double to convert to a string. @return {String} a printable representation of {@code d}. */ toString : function( ) {}, /**Parses the specified string as a double value. @param {String} string the string representation of a double value. @return {Number} a {@code Double} instance containing the double value represented by {@code string}. @throws NumberFormatException if {@code string} cannot be parsed as a double value. @see #parseDouble(String) */ valueOf : function( ) {}, /**Compares the two specified double values. There are two special cases: <ul> <li>{@code Double.NaN} is equal to {@code Double.NaN} and it is greater than any other double value, including {@code Double.POSITIVE_INFINITY};</li> <li>+0.0d is greater than -0.0d</li> </ul> @param {Number} double1 the first value to compare. @param {Number} double2 the second value to compare. @return {Number} a negative value if {@code double1} is less than {@code double2}; 0 if {@code double1} and {@code double2} are equal; a positive value if {@code double1} is greater than {@code double2}. */ compare : function( ) {}, /**Returns a {@code Double} instance for the specified double value. @param {Number} d the double value to store in the instance. @return {Number} a {@code Double} instance containing {@code d}. @since 1.5 */ valueOf : function( ) {}, /**Converts the specified double into its hexadecimal string representation. @param {Number} d the double to convert. @return {String} the hexadecimal string representation of {@code d}. @since 1.5 */ toHexString : function( ) {}, };