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 ("double");
/**
* 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.
*
* @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;
return doubleToLongBits (value) == doubleToLongBits (d.doubleValue ());
}
/**
* The hashcode is the value of the expression: (int)(v^(v>>>32))
long v = Double.doubleToLongBits(this.longValue());
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
{
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)
{
long bits = doubleToLongBits (v);
long e = bits & 0x7ff0000000000000L;
long f = bits & 0x000fffffffffffffL;
return e == 0x7ff0000000000000L && f != 0L;
}
/**
* 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)
{
long bits = doubleToLongBits (v);
long f = bits & 0x7fffffffffffffffL;
return f == 0x7ff0000000000000L;
}
/**
* 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 Double
s 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;
if (x == 0.0d && y == -0.0d)
return 1;
if (x == -0.0d && y == 0.0d)
return -1;
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 Double
s 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 native static double parseDouble (String s)
throws NumberFormatException;
/**
* Initialize JNI cache. This method is called only by the
* static initializer when using JNI.
*/
private static void initIDs () { /* Not used in libgcj */ };
}