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)
*/
public final class Double
{
/**
* The maximum positive value a 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 immutable value of this Double.
*
* @serial the wrapped double
*/
private final double value;
/**
* Create a Double from the primitive double
* specified.
*
* @param value the double argument
*/
public Double(double value)
{
this.value = value;
}
/**
* 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.
*
* @param d the double to convert
* @return the String representing the double
*/
public native static String toString(double d);
/**
* 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)
throws NumberFormatException, NullPointerException
{
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.
*
* @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
*/
public static double parseDouble(String str)
throws NumberFormatException, NullPointerException
{
String tmp = str.trim(); // Trim all whitespace & control characters
long res, sign = 0;
int i = 0, length = tmp.length();
if (length == 0) {
throw new NumberFormatException();
}
char c = tmp.charAt(0);
// Detect the sign
if (c == '-') {
sign = 0x8000000000000000L;
i++;
} else if (c == '+') {
i++;
}
tmp = tmp.substring(i);
i = 0;
if (tmp.equals("NaN")) {
res = 0x7ff8000000000000L;
} else if (tmp.equals("Infinity")) {
res = 0x7ff0000000000000L;
} else {
length = tmp.length();
if (length == 0) {
throw new NumberFormatException();
}
// Parse the integral part (if present)
double value = 0.0;
while ((i < length) && Character.isDigit(tmp.charAt(i))) {
value = (value * 10.0)
+ (double) Character.digit(tmp.charAt(i), 10);
i++;
}
// Skip the dot (if present)
if ((i < length) && tmp.charAt(i) == '.') {
i++;
}
// Parse the fractional part (if present)
double div = 10.0;
while ((i < length) && Character.isDigit(tmp.charAt(i))) {
value += ((double) Character.digit(tmp.charAt(i), 10)) / div;
div *= 10.0;
i++;
}
// Parse the exponent
int exponent = 0;
boolean exp_pos = true;
if ((i < length) && (Character.toLowerCase(tmp.charAt(i)) == 'e')) {
i++;
if (i < length) {
c = tmp.charAt(i);
if (c == '-') {
i++;
exp_pos = false;
} else if (c == '+') {
i++;
}
}
int j = i;
while ((i < length) && Character.isDigit(tmp.charAt(i))) {
exponent = (exponent * 10)
+ Character.digit(tmp.charAt(i), 10);
i++;
}
if (i == j) {
// After the e/E character there must be an exponent
throw new NumberFormatException();
}
if (!exp_pos) {
exponent = -exponent;
}
}
// Parse the float/double specifier (if present)
if (i < length) {
c = Character.toLowerCase(tmp.charAt(i));
i++;
if (c != 'f' && c != 'd') {
throw new NumberFormatException();
}
}
// Ensure that there are no more characters
if (i != length) {
throw new NumberFormatException();
}
// Encode the actual number
value *= Math.pow(10.0, exponent);
res = Double.doubleToLongBits(value);
}
return Double.longBitsToDouble(res | sign);
}
/**
* 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;
}
/**
* 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 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);
}
/**
* Return the value of this Double as a byte.
*
* @return the byte value
*/
public byte byteValue()
{
return (byte) value;
}
/**
* Return the value of this Double as a short.
*
* @return the short value
*/
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 native static long doubleToLongBits(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
*/
public native static double longBitsToDouble(long bits);
}