java.lang.Float Maven / Gradle / Ivy
/*
This is not an official specification document, and usage is restricted.
NOTICE
(c) 2005-2007 Sun Microsystems, Inc. All Rights Reserved.
Neither this file nor any files generated from it describe a complete
specification, and they may only be used as described below. For
example, no permission is given for you to incorporate this file, in
whole or in part, in an implementation of a Java specification.
Sun Microsystems Inc. owns the copyright in this file and it is provided
to you for informative, as opposed to normative, use. The file and any
files generated from it may be used to generate other informative
documentation, such as a unified set of documents of API signatures for
a platform that includes technologies expressed as Java APIs. The file
may also be used to produce "compilation stubs," which allow
applications to be compiled and validated for such platforms.
Any work generated from this file, such as unified javadocs or compiled
stub files, must be accompanied by this notice in its entirety.
This work corresponds to the API signatures of JSR 219: Foundation
Profile 1.1. In the event of a discrepency between this work and the
JSR 219 specification, which is available at
http://www.jcp.org/en/jsr/detail?id=219, the latter takes precedence.
*/
package java.lang;
/**
* The Float class wraps a value of primitive type
* float in an object. An object of type
* Float contains a single field whose type is
* float.
*
* In addition, this class provides several methods for converting a
* float to a String and a
* String to a float, as well as other
* constants and methods useful when dealing with a
* float.
*
* @author Lee Boynton
* @author Arthur van Hoff
* @version 1.80, 01/23/03
* @since JDK1.0
*/
public final class Float extends java.lang.Number
implements java.lang.Comparable
{
/**
* A constant holding the positive infinity of type
* float. It is equal to the value returned by
* Float.intBitsToFloat(0x7f800000).
*/
public static final float POSITIVE_INFINITY = 1f/0f;
/**
* A constant holding the negative infinity of type
* float. It is equal to the value returned by
* Float.intBitsToFloat(0xff800000).
*/
public static final float NEGATIVE_INFINITY = -1f/0f;
/**
* A constant holding a Not-a-Number (NaN) value of type
* float. It is equivalent to the value returned by
* Float.intBitsToFloat(0x7fc00000).
*/
public static final float NaN = 0f/0f;
/**
* A constant holding the largest positive finite value of type
* float, (2-2-23)·2127.
* It is equal to the value returned by
* Float.intBitsToFloat(0x7f7fffff).
*/
public static final float MAX_VALUE = 3.4028234663852886E38f;
/**
* A constant holding the smallest positive nonzero value of type
* float, 2-149. It is equal to the value
* returned by Float.intBitsToFloat(0x1).
*/
public static final float MIN_VALUE = 1.401298464324817E-45f;
/**
* The Class instance representing the primitive type
* float.
*
* @since JDK1.1
*/
public static final java.lang.Class TYPE = null;
/**
* The value of the Float.
*
* @serial
*/
private float value;
/**
* Constructs a newly allocated Float object that
* represents the primitive float argument.
*
* @param value the value to be represented by the Float.
*/
public Float(float value) { }
/**
* Constructs a newly allocated Float object that
* represents the argument converted to type float.
*
* @param value the value to be represented by the Float.
*/
public Float(double value) { }
/**
* Constructs a newly allocated Float object that
* represents the floating-point value of type float
* represented by the string. The string is converted to a
* float value as if by the valueOf method.
*
* @param s a string to be converted to a Float.
* @exception NumberFormatException if the string does not contain a
* parsable number.
* @see java.lang.Float#valueOf(java.lang.String)
*/
public Float(java.lang.String s) throws java.lang.NumberFormatException { }
/**
* Returns a string representation of the float
* argument. All characters mentioned below are ASCII characters.
*
* - If the argument is NaN, the result is the string
* "
NaN".
* - Otherwise, the result is a string that represents the sign and
* magnitude (absolute value) of the argument. If the sign is
* negative, the first character of the result is
* '
-' ('\u002D'); if the sign is
* positive, no sign character appears in the result. As for
* the magnitude m:
*
* - If m is infinity, it is represented by the characters
*
"Infinity"; thus, positive infinity produces
* the result "Infinity" and negative infinity
* produces the result "-Infinity".
* - If m is zero, it is represented by the characters
*
"0.0"; thus, negative zero produces the result
* "-0.0" and positive zero produces the result
* "0.0".
* - If m is greater than or equal to 10-3 but
* less than 107, then it is represented as the
* integer part of m, in decimal form with no leading
* zeroes, followed by '
.'
* ('\u002E'), followed by one or more
* decimal digits representing the fractional part of
* m.
* - If m is less than 10-3 or greater than or
* equal to 107, then it is represented in
* so-called "computerized scientific notation." Let n
* be the unique integer such that 10n <=
* m < 10n+1; then let a
* be the mathematically exact quotient of m and
* 10n so that 1 <= a < 10.
* The magnitude is then represented as the integer part of
* a, as a single decimal digit, followed by
* '
.' ('\u002E'), followed by
* decimal digits representing the fractional part of
* a, followed by the letter 'E'
* ('\u0045'), followed by a representation
* of n as a decimal integer, as produced by the
* method {@link
* java.lang.Integer#toString(int)}.
*
*
* How many digits must be printed for the fractional part of
* m or a? There must be at least one digit
* to represent the fractional part, and beyond that as many, but
* only as many, more digits as are needed to uniquely distinguish
* the argument value from adjacent values of type
* float. That is, suppose that x is the
* exact mathematical value represented by the decimal
* representation produced by this method for a finite nonzero
* argument f. Then f must be the float
* value nearest to x; or, if two float values are
* equally close to x, then f must be one of
* them and the least significant bit of the significand of
* f must be 0.
*
* To create localized string representations of a floating-point
* value, use subclasses of {@link java.text.NumberFormat}.
*
* @param f the float to be converted.
* @return a string representation of the argument.
*/
public static java.lang.String toString(float f) {
return null;
}
/**
* Returns a Float object holding the
* float value represented by the argument string
* s.
*
* If s is null, then a
* NullPointerException is thrown.
*
* Leading and trailing whitespace characters in s
* are ignored. The rest of s should constitute a
* FloatValue as described by the lexical syntax rules:
*
*
* - FloatValue:
*
- Signopt
NaN
* - Signopt
Infinity
* - Signopt FloatingPointLiteral
*
*
* where Sign and FloatingPointLiteral are as
* defined in §3.10.2
* of the Java
* Language Specification. If s does not have the
* form of a FloatValue, then a
* NumberFormatException is thrown. Otherwise,
* s is regarded as representing an exact decimal
* value in the usual "computerized scientific notation"; this
* exact decimal value is then conceptually converted to an
* "infinitely precise" binary value that is then rounded to type
* float by the usual round-to-nearest rule of IEEE
* 754 floating-point arithmetic, which includes preserving the
* sign of a zero value. Finally, a Float object
* representing this float value is returned.
*
* To interpret localized string representations of a
* floating-point value, use subclasses of {@link
* java.text.NumberFormat}.
*
*
Note that trailing format specifiers, specifiers that
* determine the type of a floating-point literal
* (1.0f is a float value;
* 1.0d is a double value), do
* not influence the results of this method. In other
* words, the numerical value of the input string is converted
* directly to the target floating-point type. In general, the
* two-step sequence of conversions, string to double
* followed by double to float, is
* not equivalent to converting a string directly to
* float. For example, if first converted to an
* intermediate double and then to
* float, the string
* "1.00000017881393421514957253748434595763683319091796875001d"
* results in the float value
* 1.0000002f; if the string is converted directly to
* float, 1.0000001f results.
*
* @param s the string to be parsed.
* @return a Float object holding the value
* represented by the String argument.
* @exception NumberFormatException if the string does not contain a
* parsable number.
*/
public static java.lang.Float valueOf(java.lang.String s)
throws java.lang.NumberFormatException
{
return null;
}
/**
* Returns a new float initialized to the value
* represented by the specified String, as performed
* by the valueOf method of class Float.
*
* @param s the string to be parsed.
* @return the float value represented by the string
* argument.
* @exception NumberFormatException if the string does not contain a
* parsable float.
* @see java.lang.Float#valueOf(String)
* @since 1.2
*/
public static float parseFloat(java.lang.String s)
throws java.lang.NumberFormatException
{
return 0.0f;
}
/**
* Returns true if the specified number is a
* Not-a-Number (NaN) value, false otherwise.
*
* @param v the value to be tested.
* @return true if the argument is NaN;
* false otherwise.
*/
public static boolean isNaN(float v) {
return false;
}
/**
* Returns true if the specified number is infinitely
* large in magnitude, false otherwise.
*
* @param v the value to be tested.
* @return true if the argument is positive infinity or
* negative infinity; false otherwise.
*/
public static boolean isInfinite(float v) {
return false;
}
/**
* Returns true if this Float value is a
* Not-a-Number (NaN), false otherwise.
*
* @return true if the value represented by this object is
* NaN; false otherwise.
*/
public boolean isNaN() {
return false;
}
/**
* Returns true if this Float value is
* infinitely large in magnitude, false otherwise.
*
* @return true if the value represented by this object is
* positive infinity or negative infinity;
* false otherwise.
*/
public boolean isInfinite() {
return false;
}
/**
* Returns a string representation of this Float object.
* The primitive float value represented by this object
* is converted to a String exactly as if by the method
* toString of one argument.
*
* @return a String representation of this object.
* @see java.lang.Float#toString(float)
*/
public java.lang.String toString() {
return null;
}
/**
* Returns the value of this Float as a
* byte (by casting to a byte).
*
* @return the float value represented by this object
* converted to type byte
*/
public byte byteValue() {
return ' ';
}
/**
* Returns the value of this Float as a
* short (by casting to a short).
*
* @return the float value represented by this object
* converted to type short
* @since JDK1.1
*/
public short shortValue() {
return -1;
}
/**
* Returns the value of this Float as an
* int (by casting to type int).
*
* @return the float value represented by this object
* converted to type int
*/
public int intValue() {
return 0;
}
/**
* Returns value of this Float as a long
* (by casting to type long).
*
* @return the float value represented by this object
* converted to type long
*/
public long longValue() {
return -1;
}
/**
* Returns the float value of this Float
* object.
*
* @return the float value represented by this object
*/
public float floatValue() {
return 0.0f;
}
/**
* Returns the double value of this
* Float object.
*
* @return the float value represented by this
* object is converted to type double and the
* result of the conversion is returned.
*/
public double doubleValue() {
return 0.0d;
}
/**
* Returns a hash code for this Float object. The
* result is the integer bit representation, exactly as produced
* by the method {@link #floatToIntBits(float)}, of the primitive
* float value represented by this Float
* object.
*
* @return a hash code value for this object.
*/
public int hashCode() {
return 0;
}
/**
* Compares this object against the specified object. The result
* is true if and only if the argument is not
* null and is a Float object that
* represents a float with the same value as the
* float represented by this object. For this
* purpose, two float values are considered to be the
* same if and only if the method {@link #floatToIntBits(float)}
* returns the identical int value when applied to
* each.
*
* Note that in most cases, for two instances of class
* Float, f1 and f2, the value
* of f1.equals(f2) is true if and only if
*
* f1.floatValue() == f2.floatValue()
*
*
* also has the value true. However, there are two exceptions:
*
* - If
f1 and f2 both represent
* Float.NaN, then the equals method returns
* true, even though Float.NaN==Float.NaN
* has the value false.
* - If
f1 represents +0.0f while
* f2 represents -0.0f, or vice
* versa, the equal test has the value
* false, even though 0.0f==-0.0f
* has the value true.
*
* This definition allows hash tables to operate properly.
*
* @param obj the object to be compared
* @return true if the objects are the same;
* false otherwise.
* @see java.lang.Float#floatToIntBits(float)
*/
public boolean equals(java.lang.Object obj) {
return false;
}
/**
* Returns a representation of the specified floating-point value
* according to the IEEE 754 floating-point "single format" bit
* layout.
*
* Bit 31 (the bit that is selected by the mask
* 0x80000000) represents the sign of the floating-point
* number.
* Bits 30-23 (the bits that are selected by the mask
* 0x7f800000) represent the exponent.
* Bits 22-0 (the bits that are selected by the mask
* 0x007fffff) represent the significand (sometimes called
* the mantissa) of the floating-point number.
*
If the argument is positive infinity, the result is
* 0x7f800000.
*
If the argument is negative infinity, the result is
* 0xff800000.
*
If the argument is NaN, the result is 0x7fc00000.
*
* In all cases, the result is an integer that, when given to the
* {@link #intBitsToFloat(int)} method, will produce a floating-point
* value the same as the argument to floatToIntBits
* (except all NaN values are collapsed to a single
* "canonical" NaN value).
*
* @param value a floating-point number.
* @return the bits that represent the floating-point number.
*/
public static int floatToIntBits(float value) {
return 0;
}
/**
* Returns a representation of the specified floating-point value
* according to the IEEE 754 floating-point "single format" bit
* layout, preserving Not-a-Number (NaN) values.
*
* Bit 31 (the bit that is selected by the mask
* 0x80000000) represents the sign of the floating-point
* number.
* Bits 30-23 (the bits that are selected by the mask
* 0x7f800000) represent the exponent.
* Bits 22-0 (the bits that are selected by the mask
* 0x007fffff) represent the significand (sometimes called
* the mantissa) of the floating-point number.
*
If the argument is positive infinity, the result is
* 0x7f800000.
*
If the argument is negative infinity, the result is
* 0xff800000.
*
* If the argument is NaN, the result is the integer representing
* the actual NaN value. Unlike the floatToIntBits
* method, intToRawIntBits does not collapse all the
* bit patterns encoding a NaN to a single "canonical"
* NaN value.
*
* In all cases, the result is an integer that, when given to the
* {@link #intBitsToFloat(int)} method, will produce a
* floating-point value the same as the argument to
* floatToRawIntBits.
* @param value a floating-point number.
* @return the bits that represent the floating-point number.
*/
public static int floatToRawIntBits(float value) {
return 0;
}
/**
* Returns the float value corresponding to a given
* bit represention.
* The argument is considered to be a representation of a
* floating-point value according to the IEEE 754 floating-point
* "single format" bit layout.
*
* If the argument is 0x7f800000, the result is positive
* infinity.
*
* If the argument is 0xff800000, the result is negative
* infinity.
*
* If the argument is any value in the range
* 0x7f800001 through 0x7fffffff or in
* the range 0xff800001 through
* 0xffffffff, the result is a NaN. No IEEE 754
* floating-point operation provided by Java can distinguish
* between two NaN values of the same type with different bit
* patterns. Distinct values of NaN are only distinguishable by
* use of the Float.floatToRawIntBits method.
*
* In all other cases, let s, e, and m be three
* values that can be computed from the argument:
*
* int s = ((bits >> 31) == 0) ? 1 : -1;
* int e = ((bits >> 23) & 0xff);
* int m = (e == 0) ?
* (bits & 0x7fffff) << 1 :
* (bits & 0x7fffff) | 0x800000;
*
* Then the floating-point result equals the value of the mathematical
* expression s·m·2e-150.
*
* Note that this method may not be able to return a
* float NaN with exactly same bit pattern as the
* int argument. IEEE 754 distinguishes between two
* kinds of NaNs, quiet NaNs and signaling NaNs. The
* differences between the two kinds of NaN are generally not
* visible in Java. Arithmetic operations on signaling NaNs turn
* them into quiet NaNs with a different, but often similar, bit
* pattern. However, on some processors merely copying a
* signaling NaN also performs that conversion. In particular,
* copying a signaling NaN to return it to the calling method may
* perform this conversion. So intBitsToFloat may
* not be able to return a float with a signaling NaN
* bit pattern. Consequently, for some int values,
* floatToRawIntBits(intBitsToFloat(start)) may
* not equal start. Moreover, which
* particular bit patterns represent signaling NaNs is platform
* dependent; although all NaN bit patterns, quiet or signaling,
* must be in the NaN range identified above.
*
* @param bits an integer.
* @return the float floating-point value with the same bit
* pattern.
*/
public static float intBitsToFloat(int bits) {
return 0.0f;
}
/**
* Compares two Float objects numerically. There are
* two ways in which comparisons performed by this method differ
* from those performed by the Java language numerical comparison
* operators (<, <=, ==, >= >) when
* applied to primitive float values:
*
-
*
Float.NaN is considered by this method to
* be equal to itself and greater than all other
* float values
* (including Float.POSITIVE_INFINITY).
* -
*
0.0f is considered by this method to be greater
* than -0.0f.
*
* This ensures that Float.compareTo(Object) (which
* forwards its behavior to this method) obeys the general
* contract for Comparable.compareTo, and that the
* natural order on Floats is consistent
* with equals.
*
* @param anotherFloat the Float to be compared.
* @return the value 0 if anotherFloat is
* numerically equal to this Float; a value
* less than 0 if this Float
* is numerically less than anotherFloat;
* and a value greater than 0 if this
* Float is numerically greater than
* anotherFloat.
*
* @since 1.2
* @see Comparable#compareTo(Object)
*/
public int compareTo(java.lang.Float anotherFloat) {
return 0;
}
/**
* Compares this Float object to another object. If
* the object is a Float, this function behaves like
* compareTo(Float). Otherwise, it throws a
* ClassCastException (as Float objects
* are comparable only to other Float objects).
*
* @param o the Object to be compared.
* @return the value 0 if the argument is a
* Float numerically equal to this
* Float; a value less than 0
* if the argument is a Float numerically
* greater than this Float; and a value
* greater than 0 if the argument is a
* Float numerically less than this
* Float .
* @exception ClassCastException if the argument is not a
* Float.
* @see java.lang.Comparable
* @since 1.2
*/
public int compareTo(java.lang.Object o) {
return 0;
}
/**
* Compares the two specified float values. The sign
* of the integer value returned is the same as that of the
* integer that would be returned by the call:
*
* new Float(f1).compareTo(new Float(f2))
*
*
* @param f1 the first float to compare.
* @param f2 the second float to compare.
* @return the value 0 if f1 is
* numerically equal to f2; a value less than
* 0 if f1 is numerically less than
* f2; and a value greater than 0
* if f1 is numerically greater than
* f2.
* @since 1.4
*/
public static int compare(float f1, float f2) {
return 0;
}
/** use serialVersionUID from JDK 1.0.2 for interoperability */
private static final long serialVersionUID = -2671257302660747028L;
}