Double represent primitive
* double values.
*
* Additionally, this class provides various helper functions and variables
* related to doubles.
*
* @author Paul Fisher
* @author Andrew Haley (aph@cygnus.com)
* @author Eric Blake (ebb9@email.byu.edu)
* @author Tom Tromey (tromey@redhat.com)
* @author Andrew John Hughes (gnu_andrew@member.fsf.org)
* @since 1.0
* @status partly updated to 1.5
*/
public final class Double extends Number implements Comparabledouble may represent
* is 1.7976931348623157e+308.
*/
public static final double MAX_VALUE = 1.7976931348623157e+308;
/**
* The minimum positive value a double may represent
* is 5e-324.
*/
public static final double MIN_VALUE = 5e-324;
/**
* The value of a double representation -1.0/0.0, negative
* infinity.
*/
public static final double NEGATIVE_INFINITY = -1.0 / 0.0;
/**
* The value of a double representing 1.0/0.0, positive infinity.
*/
public static final double POSITIVE_INFINITY = 1.0 / 0.0;
/**
* All IEEE 754 values of NaN have the same value in Java.
*/
public static final double NaN = 0.0 / 0.0;
/**
* The number of bits needed to represent a double.
* @since 1.5
*/
public static final int SIZE = 64;
/**
* The primitive type double is represented by this
* Class object.
* @since 1.1
*/
public static final ClassDouble from the primitive double
* specified.
*
* @param value the double argument
*/
public Double(double value)
{
this.value = value;
}
/**
* Create a Double from the specified String.
* This method calls Double.parseDouble().
*
* @param s the String to convert
* @throws NumberFormatException if s cannot be parsed as a
* double
* @throws NullPointerException if s is null
* @see #parseDouble(String)
*/
public Double(String s)
{
value = parseDouble(s);
}
/**
* Convert the double to a String.
* Floating-point string representation is fairly complex: here is a
* rundown of the possible values. "[-]" indicates that a
* negative sign will be printed if the value (or exponent) is negative.
* "<number>" means a string of digits ('0' to '9').
* "<digit>" means a single digit ('0' to '9').| Value of Double | String Representation |
|---|---|
| [+-] 0 | [-]0.0 |
| Between [+-] 10-3 and 107, exclusive | *[-]number.number |
| Other numeric value | *[-]<digit>.<number>
* E[-]<number> |
| [+-] infinity | [-]Infinity |
| NaN | NaN |
. and at least one digit printed after
* it: even if the number is 3, it will be printed as 3.0.
* After the ".", all digits will be printed except trailing zeros. The
* result is rounded to the shortest decimal number which will parse back
* to the same double.
*
* To create other output formats, use {@link java.text.NumberFormat}.
*
* @XXX specify where we are not in accord with the spec.
*
* @param d the double to convert
* @return the String representing the double
*/
public static String toString(double d)
{
return VMDouble.toString(d, false);
}
/**
* Convert a double value to a hexadecimal string. This converts as
* follows:
*
Double object wrapping the value.
* In contrast to the Double constructor, this method
* may cache some values. It is used by boxing conversion.
*
* @param val the value to wrap
* @return the Double
* @since 1.5
*/
public static Double valueOf(double val)
{
// We don't actually cache, but we could.
return new Double(val);
}
/**
* Create a new Double object using the String.
*
* @param s the String to convert
* @return the new Double
* @throws NumberFormatException if s cannot be parsed as a
* double
* @throws NullPointerException if s is null.
* @see #parseDouble(String)
*/
public static Double valueOf(String s)
{
return new Double(parseDouble(s));
}
/**
* Parse the specified String as a double. The
* extended BNF grammar is as follows:* DecodableString: * ( [* *-|+]NaN) * | ( [-|+]Infinity) * | ( [-|+] FloatingPoint * [f|F|d* |D] ) * FloatingPoint: * ( { Digit }+ [.{ Digit } ] * [ Exponent ] ) * | (.{ Digit }+ [ Exponent ] ) * Exponent: * ( (e|E) * [-|+] { Digit }+ ) * Digit:'0'through'9'*
NaN and infinity are special cases, to allow parsing of the output * of toString. Otherwise, the result is determined by calculating * n * 10exponent to infinite precision, then rounding * to the nearest double. Remember that many numbers cannot be precisely * represented in floating point. In case of overflow, infinity is used, * and in case of underflow, signed zero is used. Unlike Integer.parseInt, * this does not accept Unicode digits outside the ASCII range. * *
If an unexpected character is found in the String, a
* NumberFormatException will be thrown. Leading and trailing
* 'whitespace' is ignored via String.trim(), but spaces
* internal to the actual number are not allowed.
*
*
To parse numbers according to another format, consider using
* {@link java.text.NumberFormat}.
*
* @XXX specify where/how we are not in accord with the spec.
*
* @param str the String to convert
* @return the double value of s
* @throws NumberFormatException if s cannot be parsed as a
* double
* @throws NullPointerException if s is null
* @see #MIN_VALUE
* @see #MAX_VALUE
* @see #POSITIVE_INFINITY
* @see #NEGATIVE_INFINITY
* @since 1.2
*/
public static double parseDouble(String str)
{
return VMDouble.parseDouble(str);
}
/**
* Return true if the double has the same
* value as NaN, otherwise return false.
*
* @param v the double to compare
* @return whether the argument is NaN.
*/
public static boolean isNaN(double v)
{
// This works since NaN != NaN is the only reflexive inequality
// comparison which returns true.
return v != v;
}
/**
* Return true if the double has a value
* equal to either NEGATIVE_INFINITY or
* POSITIVE_INFINITY, otherwise return false.
*
* @param v the double to compare
* @return whether the argument is (-/+) infinity.
*/
public static boolean isInfinite(double v)
{
return v == POSITIVE_INFINITY || v == NEGATIVE_INFINITY;
}
/**
* Return true if the value of this Double
* is the same as NaN, otherwise return false.
*
* @return whether this Double is NaN
*/
public boolean isNaN()
{
return isNaN(value);
}
/**
* Return true if the value of this Double
* is the same as NEGATIVE_INFINITY or
* POSITIVE_INFINITY, otherwise return false.
*
* @return whether this Double is (-/+) infinity
*/
public boolean isInfinite()
{
return isInfinite(value);
}
/**
* Convert the double value of this Double
* to a String. This method calls
* Double.toString(double) to do its dirty work.
*
* @return the String representation
* @see #toString(double)
*/
public String toString()
{
return toString(value);
}
/**
* Return the value of this Double as a byte.
*
* @return the byte value
* @since 1.1
*/
public byte byteValue()
{
return (byte) value;
}
/**
* Return the value of this Double as a short.
*
* @return the short value
* @since 1.1
*/
public short shortValue()
{
return (short) value;
}
/**
* Return the value of this Double as an int.
*
* @return the int value
*/
public int intValue()
{
return (int) value;
}
/**
* Return the value of this Double as a long.
*
* @return the long value
*/
public long longValue()
{
return (long) value;
}
/**
* Return the value of this Double as a float.
*
* @return the float value
*/
public float floatValue()
{
return (float) value;
}
/**
* Return the value of this Double.
*
* @return the double value
*/
public double doubleValue()
{
return value;
}
/**
* Return a hashcode representing this Object. Double's hash
* code is calculated by:
* long v = Double.doubleToLongBits(doubleValue());.
*
* @return this Object's hash code
* @see #doubleToLongBits(double)
*/
public int hashCode()
{
long v = doubleToLongBits(value);
return (int) (v ^ (v >>> 32));
}
/**
* Returns
* int hash = (int)(v^(v>>32))true if obj is an instance of
* Double and represents the same double value. Unlike comparing
* two doubles with ==, this treats two instances of
* Double.NaN as equal, but treats 0.0 and
* -0.0 as unequal.
*
*
Note that d1.equals(d2) is identical to
* doubleToLongBits(d1.doubleValue()) ==
* doubleToLongBits(d2.doubleValue()).
*
* @param obj the object to compare
* @return whether the objects are semantically equal
*/
public boolean equals(Object obj)
{
if (! (obj instanceof Double))
return false;
double d = ((Double) obj).value;
// Avoid call to native method. However, some implementations, like gcj,
// are better off using floatToIntBits(value) == floatToIntBits(f).
// Check common case first, then check NaN and 0.
if (value == d)
return (value != 0) || (1 / value == 1 / d);
return isNaN(value) && isNaN(d);
}
/**
* Convert the double to the IEEE 754 floating-point "double format" bit
* layout. Bit 63 (the most significant) is the sign bit, bits 62-52
* (masked by 0x7ff0000000000000L) represent the exponent, and bits 51-0
* (masked by 0x000fffffffffffffL) are the mantissa. This function
* collapses all versions of NaN to 0x7ff8000000000000L. The result of this
* function can be used as the argument to
* Double.longBitsToDouble(long) to obtain the original
* double value.
*
* @param value the double to convert
* @return the bits of the double
* @see #longBitsToDouble(long)
*/
public static long doubleToLongBits(double value)
{
return VMDouble.doubleToLongBits(value);
}
/**
* Convert the double to the IEEE 754 floating-point "double format" bit
* layout. Bit 63 (the most significant) is the sign bit, bits 62-52
* (masked by 0x7ff0000000000000L) represent the exponent, and bits 51-0
* (masked by 0x000fffffffffffffL) are the mantissa. This function
* leaves NaN alone, rather than collapsing to a canonical value. The
* result of this function can be used as the argument to
* Double.longBitsToDouble(long) to obtain the original
* double value.
*
* @param value the double to convert
* @return the bits of the double
* @see #longBitsToDouble(long)
*/
public static long doubleToRawLongBits(double value)
{
return VMDouble.doubleToRawLongBits(value);
}
/**
* Convert the argument in IEEE 754 floating-point "double format" bit
* layout to the corresponding float. Bit 63 (the most significant) is the
* sign bit, bits 62-52 (masked by 0x7ff0000000000000L) represent the
* exponent, and bits 51-0 (masked by 0x000fffffffffffffL) are the mantissa.
* This function leaves NaN alone, so that you can recover the bit pattern
* with Double.doubleToRawLongBits(double).
*
* @param bits the bits to convert
* @return the double represented by the bits
* @see #doubleToLongBits(double)
* @see #doubleToRawLongBits(double)
*/
public static double longBitsToDouble(long bits)
{
return VMDouble.longBitsToDouble(bits);
}
/**
* Compare two Doubles numerically by comparing their double
* values. The result is positive if the first is greater, negative if the
* second is greater, and 0 if the two are equal. However, this special
* cases NaN and signed zero as follows: NaN is considered greater than
* all other doubles, including POSITIVE_INFINITY, and positive
* zero is considered greater than negative zero.
*
* @param d the Double to compare
* @return the comparison
* @since 1.2
*/
public int compareTo(Double d)
{
return compare(value, d.value);
}
/**
* Behaves like new Double(x).compareTo(new Double(y)); in
* other words this compares two doubles, special casing NaN and zero,
* without the overhead of objects.
*
* @param x the first double to compare
* @param y the second double to compare
* @return the comparison
* @since 1.4
*/
public static int compare(double x, double y)
{
if (isNaN(x))
return isNaN(y) ? 0 : 1;
if (isNaN(y))
return -1;
// recall that 0.0 == -0.0, so we convert to infinites and try again
if (x == 0 && y == 0)
return (int) (1 / x - 1 / y);
if (x == y)
return 0;
return x > y ? 1 : -1;
}
}