| Fields Summary |
|---|
| private static final long | serialVersionUID |
| private final double | valueThe value which the receiver represents. |
| public static final double | MAX_VALUEConstant for the maximum {@code double} value, (2 - 2-52) *
21023. |
| public static final double | MIN_VALUEConstant for the minimum {@code double} value, 2-1074. |
| public static final double | NaNConstant for the Not-a-Number (NaN) value of the {@code double} type. |
| public static final double | POSITIVE_INFINITYConstant for the Positive Infinity value of the {@code double} type. |
| public static final double | NEGATIVE_INFINITYConstant for the Negative Infinity value of the {@code double} type. |
| public static final Class | TYPEThe {@link Class} object that represents the primitive type {@code
double}. |
| public static final int | SIZEConstant for the number of bits needed to represent a {@code double} in
two's complement form. |
| Methods Summary |
|---|
| public byte | byteValue()
return (byte) value;
|
| public static int | compare(double double1, double double2)Compares the two specified double values. There are two special cases:
- {@code Double.NaN} is equal to {@code Double.NaN} and it is greater
than any other double value, including {@code Double.POSITIVE_INFINITY};
- +0.0d is greater than -0.0d
long d1, d2;
long NaNbits = Double.doubleToLongBits(Double.NaN);
if ((d1 = Double.doubleToLongBits(double1)) == NaNbits) {
if (Double.doubleToLongBits(double2) == NaNbits) {
return 0;
}
return 1;
}
if ((d2 = Double.doubleToLongBits(double2)) == NaNbits) {
return -1;
}
if (double1 == double2) {
if (d1 == d2) {
return 0;
}
// check for -0
return d1 > d2 ? 1 : -1;
}
return double1 > double2 ? 1 : -1;
|
| public int | compareTo(java.lang.Double object)Compares this object to the specified double object to determine their
relative order. There are two special cases:
- {@code Double.NaN} is equal to {@code Double.NaN} and it is greater
than any other double value, including {@code Double.POSITIVE_INFINITY};
- +0.0d is greater than -0.0d
long d1, d2;
long NaNbits = Double.doubleToLongBits(Double.NaN);
if ((d1 = Double.doubleToLongBits(value)) == NaNbits) {
if (Double.doubleToLongBits(object.value) == NaNbits) {
return 0;
}
return 1;
}
if ((d2 = Double.doubleToLongBits(object.value)) == NaNbits) {
return -1;
}
if (value == object.value) {
if (d1 == d2) {
return 0;
}
// check for -0
return d1 > d2 ? 1 : -1;
}
return value > object.value ? 1 : -1;
|
| public static native long | doubleToLongBits(double value)Converts the specified double value to a binary representation conforming
to the IEEE 754 floating-point double precision bit layout. All
Not-a-Number (NaN) values are converted to a single NaN
representation ({@code 0x7ff8000000000000L}).
|
| public static native long | doubleToRawLongBits(double value)Converts the specified double value to a binary representation conforming
to the IEEE 754 floating-point double precision bit layout.
Not-a-Number (NaN) values are preserved.
|
| public double | doubleValue()Gets the primitive value of this double.
return value;
|
| public boolean | equals(java.lang.Object object)Compares this object with the specified object and indicates if they are
equal. In order to be equal, {@code object} must be an instance of
{@code Double} and the bit pattern of its double value is the same as
this object's.
return (object == this)
|| (object instanceof Double)
&& (doubleToLongBits(this.value) == doubleToLongBits(((Double) object).value));
|
| public float | floatValue()
return (float) value;
|
| public int | hashCode()
long v = doubleToLongBits(value);
return (int) (v ^ (v >>> 32));
|
| public int | intValue()
return (int) value;
|
| public boolean | isInfinite()Indicates whether this object represents an infinite value.
return isInfinite(value);
|
| public static boolean | isInfinite(double d)Indicates whether the specified double represents an infinite value.
return (d == POSITIVE_INFINITY) || (d == NEGATIVE_INFINITY);
|
| public boolean | isNaN()Indicates whether this object is a Not-a-Number (NaN) value.
return isNaN(value);
|
| public static boolean | isNaN(double d)Indicates whether the specified double is a Not-a-Number (NaN)
value.
return d != d;
|
| public static native double | longBitsToDouble(long bits)Converts the specified IEEE 754 floating-point double precision bit
pattern to a Java double value.
|
| public long | longValue()
return (long) value;
|
| public static double | parseDouble(java.lang.String string)Parses the specified string as a double value.
return org.apache.harmony.luni.util.FloatingPointParser
.parseDouble(string);
|
| public short | shortValue()
return (short) value;
|
| public static java.lang.String | toHexString(double d)Converts the specified double into its hexadecimal string representation.
/*
* Reference: http://en.wikipedia.org/wiki/IEEE_754
*/
if (d != d) {
return "NaN"; //$NON-NLS-1$
}
if (d == POSITIVE_INFINITY) {
return "Infinity"; //$NON-NLS-1$
}
if (d == NEGATIVE_INFINITY) {
return "-Infinity"; //$NON-NLS-1$
}
long bitValue = doubleToLongBits(d);
boolean negative = (bitValue & 0x8000000000000000L) != 0;
// mask exponent bits and shift down
long exponent = (bitValue & 0x7FF0000000000000L) >>> 52;
// mask significand bits and shift up
long significand = bitValue & 0x000FFFFFFFFFFFFFL;
if (exponent == 0 && significand == 0) {
return (negative ? "-0x0.0p0" : "0x0.0p0"); //$NON-NLS-1$ //$NON-NLS-2$
}
StringBuilder hexString = new StringBuilder(10);
if (negative) {
hexString.append("-0x"); //$NON-NLS-1$
} else {
hexString.append("0x"); //$NON-NLS-1$
}
if (exponent == 0) { // denormal (subnormal) value
hexString.append("0."); //$NON-NLS-1$
// significand is 52-bits, so there can be 13 hex digits
int fractionDigits = 13;
// remove trailing hex zeros, so Integer.toHexString() won't print
// them
while ((significand != 0) && ((significand & 0xF) == 0)) {
significand >>>= 4;
fractionDigits--;
}
// this assumes Integer.toHexString() returns lowercase characters
String hexSignificand = Long.toHexString(significand);
// if there are digits left, then insert some '0' chars first
if (significand != 0 && fractionDigits > hexSignificand.length()) {
int digitDiff = fractionDigits - hexSignificand.length();
while (digitDiff-- != 0) {
hexString.append('0");
}
}
hexString.append(hexSignificand);
hexString.append("p-1022"); //$NON-NLS-1$
} else { // normal value
hexString.append("1."); //$NON-NLS-1$
// significand is 52-bits, so there can be 13 hex digits
int fractionDigits = 13;
// remove trailing hex zeros, so Integer.toHexString() won't print
// them
while ((significand != 0) && ((significand & 0xF) == 0)) {
significand >>>= 4;
fractionDigits--;
}
// this assumes Integer.toHexString() returns lowercase characters
String hexSignificand = Long.toHexString(significand);
// if there are digits left, then insert some '0' chars first
if (significand != 0 && fractionDigits > hexSignificand.length()) {
int digitDiff = fractionDigits - hexSignificand.length();
while (digitDiff-- != 0) {
hexString.append('0");
}
}
hexString.append(hexSignificand);
hexString.append('p");
// remove exponent's 'bias' and convert to a string
hexString.append(Long.toString(exponent - 1023));
}
return hexString.toString();
|
| public java.lang.String | toString()
return Double.toString(value);
|
| public static java.lang.String | toString(double d)Returns a string containing a concise, human-readable description of the
specified double value.
return org.apache.harmony.luni.util.NumberConverter.convert(d);
|
| public static java.lang.Double | valueOf(java.lang.String string)Parses the specified string as a double value.
return new Double(parseDouble(string));
|
| public static java.lang.Double | valueOf(double d)Returns a {@code Double} instance for the specified double value.
return new Double(d);
|
