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


};