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