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 5e-324.
*/
public static final double MIN_VALUE = 5e-324;
/**
* The maximum positive value a double may represent
* is 1.7976931348623157e+308.
*/
public static final double MAX_VALUE = 1.7976931348623157e+308;
/**
* The value of a double representation -1.0/0.0, negative
* infinity.
*/
public static final double NEGATIVE_INFINITY = -1.0d/0.0d;
/**
* The value of a double representing 1.0/0.0, positive infinity.
*/
public static final double POSITIVE_INFINITY = 1.0d/0.0d;
/**
* All IEEE 754 values of NaN have the same value in Java.
*/
public static final double NaN = 0.0d/0.0d;
/**
* The primitive type double is represented by this
* Class object.
*/
public static final Class TYPE = VMClassLoader.getPrimitiveClass('D');
/**
* The immutable value of this Double.
*/
private final double value;
private static final long serialVersionUID = -9172774392245257468L;
/**
* 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().
*
* @exception NumberFormatException when the String cannot
* be parsed into a Float.
* @param s the String to convert
* @see #parseDouble(java.lang.String)
*/
public Double (String s) throws NumberFormatException
{
value = parseDouble (s);
}
/**
* 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 of this Double.
* @see #toString(double)
*/
public String toString ()
{
return toString (value);
}
/**
* If the Object is not null, is an
* instanceof Double, and represents
* the same primitive double value return
* true. Otherwise false is returned.
*
* Note that there are two differences between == and
* equals(). 0.0d == -0.0d returns true
* but new Double(0.0d).equals(new Double(-0.0d)) returns
* false. And Double.NaN == Double.NaN returns
* false, but
* new Double(Double.NaN).equals(new Double(Double.NaN)) returns
* true.
*
* @param obj the object to compare to
* @return whether the objects are semantically equal.
*/
public boolean equals (Object obj)
{
if (!(obj instanceof Double))
return false;
double d = ((Double) obj).value;
// common case first, then check NaN and 0
if (value == d)
return (value != 0) || (1 / value == 1 / d);
return isNaN(value) && isNaN(d);
}
/**
* The hashcode is the value of the expression:
*
* (int)(v^(v>>>32))
*
* where v is defined by:
* long v = Double.doubleToLongBits(this.longValue());
*/
public int hashCode ()
{
long v = doubleToLongBits (value);
return (int) (v ^ (v >>> 32));
}
/**
* Return the value of this Double when cast to an
* int.
*/
public int intValue ()
{
return (int) value;
}
/**
* Return the value of this Double when cast to a
* long.
*/
public long longValue ()
{
return (long) value;
}
/**
* Return the value of this Double when cast to a
* float.
*/
public float floatValue ()
{
return (float) value;
}
/**
* Return the primitive double value represented by this
* Double.
*/
public double doubleValue ()
{
return value;
}
/**
* Return the result of calling new Double(java.lang.String).
*
* @param s the String to convert to a Double.
* @return a new Double representing the String's
* numeric value.
*
* @exception NullPointerException thrown if String is
* null.
* @exception NumberFormatException thrown if String cannot
* be parsed as a double.
* @see #Double(java.lang.String)
* @see #parseDouble(java.lang.String)
*/
public static Double valueOf (String s) throws NumberFormatException
{
if (s == null)
throw new NullPointerException (s);
return new Double (s);
}
/**
* 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 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 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 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);
}
/**
* Returns 0 if the double value of the argument is
* equal to the value of this Double. Returns a number
* less than zero if the value of this Double is less
* than the double value of the argument, and returns a
* number greater than zero if the value of this Double
* is greater than the double value of the argument.
*
* Double.NaN is greater than any number other than itself,
* even Double.POSITIVE_INFINITY.
*
* 0.0d is greater than -0.0d.
*
* @param d the Double to compare to.
* @return 0 if the Doubles are the same, < 0 if this
* Double is less than the Double in
* in question, or > 0 if it is greater.
* @since 1.2
*/
public int compareTo (Double d)
{
return compare (value, d.value);
}
/**
* Returns 0 if the first argument is equal to the second argument.
* Returns a number less than zero if the first argument is less than the
* second argument, and returns a number greater than zero if the first
* argument is greater than the second argument.
*
* Double.NaN is greater than any number other than itself,
* even Double.POSITIVE_INFINITY.
*
* 0.0d is greater than -0.0d.
*
* @param x the first double to compare.
* @param y the second double to compare.
* @return 0 if the arguments are the same, < 0 if the
* first argument is less than the second argument in
* in question, or > 0 if it is greater.
* @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;
}
/**
* Compares the specified Object to this Double
* if and only if the Object is an instanceof
* Double.
*
* @param o the Object to compare to.
* @return 0 if the Doubles are the same, < 0 if this
* Double is less than the Double in
* in question, or > 0 if it is greater.
* @throws ClassCastException if the argument is not a Double
*/
public int compareTo (Object o)
{
return compareTo ((Double) o);
}
/**
* 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-9).
* "<digit>" means a single digit (0-9).
*
* *
| Value of Float | String Representation |
|---|---|
| [+-] 0 | *[-]0.0 |
*
| Between [+-] 10-3 and 107 | *[-]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. No
* truncation or rounding is done by this function.
*
*
* @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);
}
static native String toString (double d, boolean isFloat);
/**
* Return the long bits of the specified double.
* 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.
*/
public static native long doubleToLongBits (double value);
/**
* Return the long bits of the specified double.
* The result of this function can be used as the argument to
* Double.longBitsToDouble(long) to obtain the
* original double value. This method differs from
* doubleToLongBits in that it does not collapse
* NaN values.
*
* @param value the double to convert
* @return the bits of the double.
*/
public static native long doubleToRawLongBits (double value);
/**
* Return the double represented by the long
* bits specified.
*
* @param bits the long bits representing a double
* @return the double represented by the bits.
*/
public static native double longBitsToDouble (long bits);
/**
* Parse the specified String as a double.
*
* The number is really read as n * 10exponent. The
* first number is n, and if there is an "E"
* ("e" is also acceptable), then the integer after that is
* the exponent.
*
* Here are the possible forms the number can take:
*
*
| Form | Examples |
|---|---|
[+-]<number>[.] | 345., -10, 12 |
[+-]<number>.<number> | 40.2, 80.00, -12.30 |
[+-]<number>[.]E[+-]<number> | 80E12, -12e+7, 4.E-123 |
[+-]<number>.<number>E[+-]<number> | 6.02e-22, -40.2E+6, 12.3e9 |
[+-]" means either a plus or minus sign may go there, or
* neither, in which case + is assumed.
* [.]" means a dot may be placed here, but is optional.
* <number>" means a string of digits (0-9), basically
* an integer. "<number>.<number>" is basically
* a real number, a floating-point value.
*
*
* Remember that a double has a limited range. If the
* number you specify is greater than Double.MAX_VALUE or less
* than -Double.MAX_VALUE, it will be set at
* Double.POSITIVE_INFINITY or
* Double.NEGATIVE_INFINITY, respectively.
*
* Note also that double does not have perfect precision. Many
* numbers cannot be precisely represented. The number you specify
* will be rounded to the nearest representable value.
* Double.MIN_VALUE is the margin of error for
* double values.
*
* If an unexpected character is found in the String, a
* NumberFormatException will be thrown. Spaces are not
* allowed, and will cause the same exception.
*
* @XXX specify where/how we are not in accord with the spec.
*
* @param str the String to convert
* @return the value of the String as a double.
* @exception NumberFormatException when the string cannot be parsed to a
* double.
* @exception NullPointerException when the string is null.
* @see #MIN_VALUE
* @see #MAX_VALUE
* @see #POSITIVE_INFINITY
* @see #NEGATIVE_INFINITY
* @since 1.2
*/
public static native double parseDouble (String s)
throws NumberFormatException;
/**
* Initialize JNI cache. This method is called only by the
* static initializer when using JNI.
*/
private static native void initIDs ();
}