Double represent primitive
* double values.
*
* Additionally, this class provides various helper functions and variables
* related to doubles.
*
* @author Paul Fisher
* @author Andrew Haley double 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 primitive type double is represented by this
* Class object.
* @since 1.1
*/
public static final Class TYPE = VMClassLoader.getPrimitiveClass('D');
/**
* The immutable value of this Double.
*
* @serial the wrapped double
*/
private final double value;
/**
* Load native routines necessary for this class.
*/
static
{
if (Configuration.INIT_LOAD_LIBRARY)
{
System.loadLibrary("javalang");
initIDs();
}
}
/**
* Create a Double 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 toString(d, false);
}
/**
* 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 native double parseDouble(String s);
/**
* 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 native long doubleToLongBits(double 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 native long doubleToRawLongBits(double 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 native double longBitsToDouble(long 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 compareTo(Double) unless the Object
* is not an Double.
*
* @param o the object to compare
* @return the comparison
* @throws ClassCastException if the argument is not a Double
* @see #compareTo(Double)
* @see Comparable
* @since 1.2
*/
public int compareTo(Object o)
{
return compare(value, ((Double) o).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;
}
/**
* Helper method to convert to string.
*
* @param d the double to convert
* @param isFloat true if the conversion is requested by Float (results in
* fewer digits)
*/
// Package visible for use by Float.
static native String toString(double d, boolean isFloat);
/**
* Initialize JNI cache. This method is called only by the
* static initializer when using JNI.
*/
private static native void initIDs();
}