www.pudn.com > j2me_cldc-1_1-fcs-src-winunix.rar > Double.java, change:2003-02-05,size:23573b
/* * Copyright © 2003 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * */ package java.lang; /** * The Double class wraps a value of the primitive type *doublein an object. An object of type *Doublecontains a single field whose type is *double. ** In addition, this class provides several methods for converting a *
doubleto aStringand a *Stringto adouble, as well as other * constants and methods useful when dealing with a *double. * * @author Lee Boynton * @author Arthur van Hoff * @version 12/17/01 (CLDC 1.1) * @since JDK1.0, CLDC 1.1 */ public final class Double { /** * The positive infinity of typedouble. * It is equal to the value returned by *Double.longBitsToDouble(0x7ff0000000000000L). */ public static final double POSITIVE_INFINITY = 1.0 / 0.0; /** * The negative infinity of typedouble. * It is equal to the value returned by *Double.longBitsToDouble(0xfff0000000000000L). */ public static final double NEGATIVE_INFINITY = -1.0 / 0.0; /** * A Not-a-Number (NaN) value of typedouble. * It is equal to the value returned by *Double.longBitsToDouble(0x7ff8000000000000L). */ public static final double NaN = 0.0d / 0.0; /** * The largest positive finite value of typedouble. * It is equal to the value returned by **/ public static final double MAX_VALUE = 1.79769313486231570e+308; /** * The smallest positive value of type*Double.longBitsToDouble(0x7fefffffffffffffL)*double. * It is equal to the value returned by *Double.longBitsToDouble(0x1L). */ // public static final double MIN_VALUE = 4.94065645841246544e-324; public static final double MIN_VALUE = longBitsToDouble(1L); /** * Creates a string representation of thedouble* argument. All characters mentioned below are ASCII characters. *
-'
* ('\u002d'); if the sign is positive, no sign character
* appears in the result. As for the magnitude m:
* "Infinity"; thus, positive infinity produces the result
* "Infinity" and negative infinity produces the result
* "-Infinity".
* "0.0"; thus, negative zero produces the result
* "-0.0" and positive zero produces the result
* "0.0".
* '.' (\u002E), followed by one or more decimal
* digits representing the fractional part of m.
* '.' (\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 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 double. That is, suppose that
* x is the exact mathematical value represented by the decimal
* representation produced by this method for a finite nonzero argument
* d. Then d must be the double value nearest
* to x; or if two double values are equally close
* to x, then d must be one of them and the least
* significant bit of the significand of d must be 0.
*
* @param d the double to be converted.
* @return a string representation of the argument.
*/
public static String toString(double d){
return new FloatingDecimal(d).toJavaFormatString();
}
/**
* Returns a new Double object initialized to the value
* represented by the specified string. The string s is
* interpreted as the representation of a floating-point value and a
* Double object representing that value is created and
* returned.
*
* 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 rule:
*
* FloatValue:
*
* Signopt FloatingPointLiteral
* NumberFormatException is
* thrown. Otherwise, it 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 double
* by the usual round-to-nearest rule of IEEE 754 floating-point
* arithmetic. Finally, a new object of class Double is
* created to represent the double value.
*
* @param s the string to be parsed.
* @return a newly constructed Double initialized to the
* value represented by the string argument.
* @exception NumberFormatException if the string does not contain a
* parsable number.
*/
public static Double valueOf(String s) throws NumberFormatException {
return new Double(FloatingDecimal.readJavaFormatString(s).doubleValue());
}
/**
* Returns a new double initialized to the value represented by the
* specified String, as performed by the valueOf
* method of class Double.
*
* @param s the string to be parsed.
* @return the double value represented by the string argument.
* @exception NumberFormatException if the string does not contain a
* parsable double.
* @see java.lang.Double#valueOf(String)
* @since JDK1.2
*/
public static double parseDouble(String s) throws NumberFormatException {
return FloatingDecimal.readJavaFormatString(s).doubleValue();
}
/**
* Returns true if the specified number is the special Not-a-Number (NaN)
* value.
*
* @param v the value to be tested.
* @return true if the value of the argument is NaN;
* false otherwise.
*/
static public boolean isNaN(double v) {
return (v != v);
}
/**
* Returns true if the specified number is infinitely large in magnitude.
*
* @param v the value to be tested.
* @return true if the value of the argument is positive
* infinity or negative infinity; false otherwise.
*/
static public boolean isInfinite(double v) {
return (v == POSITIVE_INFINITY) || (v == NEGATIVE_INFINITY);
}
/**
* The value of the Double.
*/
private double value;
/**
* Constructs a newly allocated Double object that
* represents the primitive double argument.
*
* @param value the value to be represented by the Double.
*/
public Double(double value) {
this.value = value;
}
/**
* Constructs a newly allocated Double object that
* represents the floating-point value of type double
* represented by the string. The string is converted to a
* double value as if by the valueOf method.
*
* @param s a string to be converted to a Double.
* @exception NumberFormatException if the string does not contain a
* parsable number.
* @see java.lang.Double#valueOf(java.lang.String)
*/
/* REMOVED from CLDC
public Double(String s) throws NumberFormatException {
// REMIND: this is inefficient
this(valueOf(s).doubleValue());
}
*/
/**
* Returns true if this Double value is the special Not-a-Number (NaN)
* value.
*
* @return true if the value represented by this object is
* NaN; false otherwise.
*/
public boolean isNaN() {
return isNaN(value);
}
/**
* Returns true if this Double value is infinitely large in magnitude.
*
* @return true if the value represented by this object is
* positive infinity or negative infinity;
* false otherwise.
*/
public boolean isInfinite() {
return isInfinite(value);
}
/**
* Returns a String representation of this Double object.
* The primitive double 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.Double#toString(double)
*/
public String toString() {
return String.valueOf(value);
}
/**
* Returns the value of this Double as a byte (by casting to a byte).
*
* @since JDK1.1
*/
public byte byteValue() {
return (byte)value;
}
/**
* Returns the value of this Double as a short (by casting to a short).
*
* @since JDK1.1
*/
public short shortValue() {
return (short)value;
}
/**
* Returns the integer value of this Double (by casting to an int).
*
* @return the double value represented by this object is
* converted to type int and the result of the
* conversion is returned.
*/
public int intValue() {
return (int)value;
}
/**
* Returns the long value of this Double (by casting to a long).
*
* @return the double value represented by this object is
* converted to type long and the result of the
* conversion is returned.
*/
public long longValue() {
return (long)value;
}
/**
* Returns the float value of this Double.
*
* @return the double value represented by this object is
* converted to type float and the result of the
* conversion is returned.
* @since JDK1.0
*/
public float floatValue() {
return (float)value;
}
/**
* Returns the double value of this Double.
*
* @return the double value represented by this object.
*/
public double doubleValue() {
return (double)value;
}
/**
* Returns a hashcode for this Double object. The result
* is the exclusive OR of the two halves of the long integer bit
* representation, exactly as produced by the method
* {@link #doubleToLongBits(double)}, of the primitive
* double value represented by this Double
* object. That is, the hashcode is the value of the expression:
*
* (int)(v^(v>>>32))
* v is defined by:
*
* long v = Double.doubleToLongBits(this.doubleValue());
* hash code value for this object.
*/
public int hashCode() {
long bits = doubleToLongBits(value);
return (int)(bits ^ (bits >>> 32));
}
/**
* Compares this object against the specified object.
* The result is true if and only if the argument is
* not null and is a Double object that
* represents a double that has the identical bit pattern to the bit
* pattern of the double represented by this object. For this purpose,
* two double values are considered to be the same if and
* only if the method {@link #doubleToLongBits(double)} returns the same
* long value when applied to each.
*
* Note that in most cases, for two instances of class
* Double, d1 and d2, the
* value of d1.equals(d2) is true if and
* only if
*
* d1.doubleValue() == d2.doubleValue()
*
* also has the value true. However, there are two
* exceptions:
*
d1 and d2 both represent
* Double.NaN, then the equals method
* returns true, even though
* Double.NaN==Double.NaN has the value
* false.
* d1 represents +0.0 while
* d2 represents -0.0, or vice versa,
* the equals test has the value false,
* even though +0.0==-0.0 has the value true.
* This allows hashtables to operate properly.
* true if the objects are the same;
* false otherwise.
*/
public boolean equals(Object obj) {
return (obj instanceof Double)
&& (doubleToLongBits(((Double)obj).value) ==
doubleToLongBits(value));
}
/**
* Returns a representation of the specified floating-point value
* according to the IEEE 754 floating-point "double
* format" bit layout.
*
* Bit 63 (the bit that is selected by the mask
* 0x8000000000000000L) represents the sign of the
* floating-point number. Bits
* 62-52 (the bits that are selected by the mask
* 0x7ff0000000000000L) represent the exponent. Bits 51-0
* (the bits that are selected by the mask
* 0x000fffffffffffffL) represent the significand
* (sometimes called the mantissa) of the floating-point number.
*
* If the argument is positive infinity, the result is
* 0x7ff0000000000000L.
*
* If the argument is negative infinity, the result is
* 0xfff0000000000000L.
*
* If the argument is NaN, the result is
* 0x7ff8000000000000L.
*
* In all cases, the result is a long integer that, when
* given to the {@link #longBitsToDouble(long)} method, will produce a
* floating-point value equal to the argument to
* doubleToLongBits.
*
* @param value a double precision floating-point number.
* @return the bits that represent the floating-point number.
*/
public static native long doubleToLongBits(double value);
/**
* Returns a representation of the specified floating-point value
* according to the IEEE 754 floating-point "double
* format" bit layout.
*
* Bit 63 (the bit that is selected by the mask
* 0x8000000000000000L) represents the sign of the
* floating-point number. Bits
* 62-52 (the bits that are selected by the mask
* 0x7ff0000000000000L) represent the exponent. Bits 51-0
* (the bits that are selected by the mask
* 0x000fffffffffffffL) represent the significand
* (sometimes called the mantissa) of the floating-point number.
*
* If the argument is positive infinity, the result is
* 0x7ff0000000000000L.
*
* If the argument is negative infinity, the result is
* 0xfff0000000000000L.
*
* If the argument is NaN, the result is the long integer
* representing the actual NaN value. Unlike the doubleToLongBits
* method, doubleToRawLongBits does not collapse NaN values.
*
* In all cases, the result is a long integer that, when
* given to the {@link #longBitsToDouble(long)} method, will produce a
* floating-point value equal to the argument to
* doubleToRawLongBits.
*
* @param value a double precision floating-point number.
* @return the bits that represent the floating-point number.
*/
/* REMOVED from CLDC
public static native long doubleToRawLongBits(double value);
*/
/**
* Returns the double-float corresponding to a given bit representation.
* The argument is considered to be a representation of a
* floating-point value according to the IEEE 754 floating-point
* "double precision" bit layout. That floating-point
* value is returned as the result.
*
* If the argument is 0x7ff0000000000000L, the result
* is positive infinity.
*
* If the argument is 0xfff0000000000000L, the result
* is negative infinity.
*
* If the argument is any value in the range
* 0x7ff0000000000001L through
* 0x7fffffffffffffffL or in the range
* 0xfff0000000000001L through
* 0xffffffffffffffffL, the result is NaN. All IEEE 754
* NaN values of type double are, in effect, lumped together
* by the Java programming language into a single value called NaN.
*
* In all other cases, let s, e, and m be three * values that can be computed from the argument: *
* int s = ((bits >> 63) == 0) ? 1 : -1;
* int e = (int)((bits >> 52) & 0x7ffL);
* long m = (e == 0) ?
* (bits & 0xfffffffffffffL) << 1 :
* (bits & 0xfffffffffffffL) | 0x10000000000000L;
* long integer.
* @return the double floating-point value with the same
* bit pattern.
*/
public static native double longBitsToDouble(long bits);
/**
* Compares two Doubles 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 doubles:
* Double.NaN is considered by this method to be
* equal to itself and greater than all other double values
* (including Double.POSITIVE_INFINITY).
* 0.0d is considered by this method to be greater
* than -0.0d.
* Double to be compared.
* @return the value 0 if anotherDouble is
* numerically equal to this Double; a value less than
* 0 if this Double is numerically less than
* anotherDouble; and a value greater than
* 0 if this Double is numerically greater than
* anotherDouble.
*
* @since JDK1.2
* @see Comparable#compareTo(Object)
*/
/* REMOVED from CLDC
public int compareTo(Double anotherDouble) {
double thisVal = value;
double anotherVal = anotherDouble.value;
if (thisVal < anotherVal)
return -1; // Neither val is NaN, thisVal is smaller
if (thisVal > anotherVal)
return 1; // Neither val is NaN, thisVal is larger
long thisBits = Double.doubleToLongBits(thisVal);
long anotherBits = Double.doubleToLongBits(anotherVal);
return (thisBits == anotherBits ? 0 : // Values are equal
(thisBits < anotherBits ? -1 : // (-0.0, 0.0) or (!NaN, NaN)
1)); // (0.0, -0.0) or (NaN, !NaN)
}
*/
/**
* Compares this Double to another Object. If the Object is a Double,
* this function behaves like compareTo(Double). Otherwise,
* it throws a ClassCastException (as Doubles are comparable
* only to other Doubles).
*
* @param o the Object to be compared.
* @return the value 0 if the argument is a Double
* numerically equal to this Double; a value less than
* 0 if the argument is a Double numerically
* greater than this Double; and a value greater than
* 0 if the argument is a Double numerically
* less than this Double.
* @exception ClassCastException if the argument is not a
* Double.
* @see java.lang.Comparable
* @since JDK1.2
*/
/* REMOVED from CLDC
public int compareTo(Object o) {
return compareTo((Double)o);
}
*/
}