/**@class java.lang.Float
 implements java.lang.Comparable

@extends java.lang.Number

 The wrapper for the primitive type {@code float}.

 @see java.lang.Number
 @since 1.0
*/
var Float = {

/** Constant for the maximum {@code float} value, (2 - 2<sup>-23</sup>) * 2<sup>127</sup>.
*/
MAX_VALUE : "3.4028235E38",
/** Constant for the minimum {@code float} value, 2<sup>-149</sup>.
*/
MIN_VALUE : "1.4E-45",
/** Constant for the Not-a-Number (NaN) value of the {@code float} type.
*/
NaN : "NaN",
/** Constant for the positive infinity value of the {@code float} type.
*/
POSITIVE_INFINITY : "Infinity",
/** Constant for the negative infinity value of the {@code float} type.
*/
NEGATIVE_INFINITY : "-Infinity",
/** Constant for the smallest positive normal value of the {@code float} type.

 @since 1.6
*/
MIN_NORMAL : "1.17549435E-38",
/** Maximum base-2 exponent that a finite value of the {@code float} type may have.
 Equal to {@code Math.getExponent(Float.MAX_VALUE)}.

 @since 1.6
*/
MAX_EXPONENT : "127",
/** Minimum base-2 exponent that a normal value of the {@code float} type may have.
 Equal to {@code Math.getExponent(Float.MIN_NORMAL)}.

 @since 1.6
*/
MIN_EXPONENT : "-126",
/** The {@link java.lang.Class} object that represents the primitive type {@code
 float}.

 @since 1.1
*/
TYPE : "null",
/** Constant for the number of bits needed to represent a {@code float} in
 two's complement form.

 @since 1.5
*/
SIZE : "32",
/**Compares this object to the specified float object to determine their
 relative order. There are two special cases:
 <ul>
 <li>{@code Float.NaN} is equal to {@code Float.NaN} and it is greater
 than any other float value, including {@code Float.POSITIVE_INFINITY};</li>
 <li>+0.0f is greater than -0.0f</li>
 </ul>
@param {Number} object
            the float object to compare this object to.
@return {Number} a negative value if the value of this float is less than the
         value of {@code object}; 0 if the value of this float and the
         value of {@code object} are equal; a positive value if the value
         of this float is greater than the value of {@code object}.
@see java.lang.Comparable
@since 1.2
*/
compareTo : function(  ) {},

/**
*/
byteValue : function(  ) {},

/**
*/
doubleValue : function(  ) {},

/**Tests this double for equality with {@code object}.
 To be equal, {@code object} must be an instance of {@code Float} and
 {@code floatToIntBits} 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 float with.
@return {Boolean} {@code true} if the specified object is equal to this
         {@code Float}; {@code false} otherwise.
*/
equals : function(  ) {},

/**Returns an integer corresponding to the bits of the given
 <a href="http://en.wikipedia.org/wiki/IEEE_754-1985">IEEE 754</a> single precision
 float {@code value}. All <em>Not-a-Number (NaN)</em> values are converted to a single NaN
 representation ({@code 0x7fc00000}) (compare to {@link #floatToRawIntBits}).
*/
floatToIntBits : function(  ) {},

/**Returns an integer corresponding to the bits of the given
 <a href="http://en.wikipedia.org/wiki/IEEE_754-1985">IEEE 754</a> single precision
 float {@code value}. <em>Not-a-Number (NaN)</em> values are preserved (compare
 to {@link #floatToIntBits}).
*/
floatToRawIntBits : function(  ) {},

/**Gets the primitive value of this float.
@return {Number} this object's primitive value.
*/
floatValue : function(  ) {},

/**
*/
hashCode : function(  ) {},

/**Returns the <a href="http://en.wikipedia.org/wiki/IEEE_754-1985">IEEE 754</a>
 single precision float corresponding to the given {@code bits}.
*/
intBitsToFloat : function(  ) {},

/**
*/
intValue : function(  ) {},

/**Indicates whether this object represents an infinite value.
@return {Boolean} {@code true} if the value of this float is positive or negative
         infinity; {@code false} otherwise.
*/
isInfinite : function(  ) {},

/**Indicates whether the specified float represents an infinite value.
@param {Number} f
            the float to check.
@return {Boolean} {@code true} if the value of {@code f} 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 float is <em>Not-a-Number</em>;
         {@code false} if it is a (potentially infinite) float number.
*/
isNaN : function(  ) {},

/**Indicates whether the specified float is a <em>Not-a-Number (NaN)</em>
 value.
@param {Number} f
            the float value to check.
@return {Boolean} {@code true} if {@code f} is <em>Not-a-Number</em>;
         {@code false} if it is a (potentially infinite) float number.
*/
isNaN : function(  ) {},

/**
*/
longValue : function(  ) {},

/**Parses the specified string as a float value.
@param {String} string
            the string representation of a float value.
@return {Number} the primitive float value represented by {@code string}.
@throws NumberFormatException
             if {@code string} can not be parsed as a float value.
@see #valueOf(String)
@since 1.2
*/
parseFloat : function(  ) {},

/**
*/
shortValue : function(  ) {},

/**
*/
toString : function(  ) {},

/**Returns a string containing a concise, human-readable description of the
 specified float value.
@param {Number} f
             the float to convert to a string.
@return {String} a printable representation of {@code f}.
*/
toString : function(  ) {},

/**Parses the specified string as a float value.
@param {String} string
            the string representation of a float value.
@return {Number} a {@code Float} instance containing the float value represented
         by {@code string}.
@throws NumberFormatException
             if {@code string} can not be parsed as a float value.
@see #parseFloat(String)
*/
valueOf : function(  ) {},

/**Compares the two specified float values. There are two special cases:
 <ul>
 <li>{@code Float.NaN} is equal to {@code Float.NaN} and it is greater
 than any other float value, including {@code Float.POSITIVE_INFINITY};</li>
 <li>+0.0f is greater than -0.0f</li>
 </ul>
@param {Number} float1
            the first value to compare.
@param {Number} float2
            the second value to compare.
@return {Number} a negative value if {@code float1} is less than {@code float2};
         0 if {@code float1} and {@code float2} are equal; a positive
         value if {@code float1} is greater than {@code float2}.
@since 1.4
*/
compare : function(  ) {},

/**Returns a {@code Float} instance for the specified float value.
@param {Number} f
            the float value to store in the instance.
@return {Number} a {@code Float} instance containing {@code f}.
@since 1.5
*/
valueOf : function(  ) {},

/**Converts the specified float into its hexadecimal string representation.
@param {Number} f
            the float to convert.
@return {String} the hexadecimal string representation of {@code f}.
@since 1.5
*/
toHexString : function(  ) {},


};