

PREV CLASS NEXT CLASS  FRAMES NO FRAMES  
SUMMARY: NESTED  FIELD  CONSTR  METHOD  DETAIL: FIELD  CONSTR  METHOD 
java.lang.Object  +java.lang.Number  +java.lang.Double
Safe: The Double
class wraps a value of the primitive type
double
in an object. An object of type
Double
contains a single field whose type is
double
.
In addition, this class provides several methods for converting a
double
to a String
and a
String
to a double
, as well as other
constants and methods useful when dealing with a
double
.
Field Summary  
static double 
MAX_VALUE
Enabled: A constant holding the largest positive finite value of type double , (22^{52})·2^{1023}. 
static double 
MIN_VALUE
Enabled: A constant holding the smallest positive nonzero value of type double , 2^{1074}. 
static double 
NaN
Enabled: A constant holding a NotaNumber (NaN) value of type double . 
static double 
NEGATIVE_INFINITY
Enabled: A constant holding the negative infinity of type double . 
static double 
POSITIVE_INFINITY
Enabled: A constant holding the positive infinity of type double . 
private static long 
serialVersionUID
use serialVersionUID from JDK 1.0.2 for interoperability 
static Class 
TYPE
Enabled: The Class instance representing the primitive type
double . 
private double 
value
The value of the Double. 
Constructor Summary  
Double(double value)
Enabled: Constructs a newly allocated Double object that
represents the primitive double argument. 

Double(String s)
Enabled: Constructs a newly allocated Double object that
represents the floatingpoint value of type double
represented by the string. 
Method Summary  
boolean 
aboveZero()
Added: Used in the expansion of E's ">" operator. 
double 
abs()
Added: 
double 
acos()
Added: 
double 
add(double arg)
Added: 
double 
approxDivide(double arg)
Added: Always gives back a double This corresponds to the Java floatingpoint "/" operator and the E "/" operator. 
double 
asin()
Added: 
double 
atan()
Added: 
double 
atan2(double arg)
Added: 
boolean 
atLeastZero()
Added: Used in the expansion of E's ">=" operator. 
boolean 
atMostZero()
Added: Used in the expansion of E's "<=" operator. 
boolean 
belowZero()
Added: Used in the expansion of E's "<" operator. 
byte 
byteValue()
Enabled: Returns the value of this Double as a byte (by
casting to a byte ). 
BigInteger 
ceil()
Added: 
static int 
compare(double d1,
double d2)
Suppressed: Compares the two specified double values. 
int 
compareTo(Double anotherDouble)
Suppressed: Compares two Double objects numerically. 
int 
compareTo(Object o)
Enabled: Compares this Double object to another object. 
double 
compareTo(Object o)
Added: Used in the expansion of E's comparison operators. 
double 
cos()
Added: 
static long 
doubleToLongBits(double value)
Enabled: Returns a representation of the specified floatingpoint value according to the IEEE 754 floatingpoint "double format" bit layout. 
static long 
doubleToRawLongBits(double value)
Enabled: Returns a representation of the specified floatingpoint value according to the IEEE 754 floatingpoint "double format" bit layout, preserving NotaNumber (NaN) values. 
double 
doubleValue()
Enabled: Returns the double value of this
Double object. 
boolean 
equals(Object obj)
Suppressed: Compares this object against the specified object. 
double 
exp()
Added: 
float 
floatValue()
Enabled: Returns the float value of this
Double object. 
BigInteger 
floor()
Added: 
BigInteger 
floorDivide(double arg)
Added: Always gives an integer, resulting from rounding towards negative infinity, ie, flooring. 
int 
hashCode()
Suppressed: Returns a hash code for this Double object. 
int 
intValue()
Enabled: Returns the value of this Double as an
int (by casting to type int ). 
boolean 
isInfinite()
Enabled: Returns true if this Double value is
infinitely large in magnitude, false otherwise. 
static boolean 
isInfinite(double v)
Enabled: Returns true if the specified number is infinitely
large in magnitude, false otherwise. 
boolean 
isNaN()
Enabled: Returns true if this Double value is
a NotaNumber (NaN), false otherwise. 
static boolean 
isNaN(double v)
Enabled: Returns true if the specified number is a
NotaNumber (NaN) value, false otherwise. 
boolean 
isZero()
Added: Used for arithmetic equality. 
double 
log()
Added: 
static double 
longBitsToDouble(long bits)
Enabled: Returns the double value corresponding to a given
bit representation. 
long 
longValue()
Enabled: Returns the value of this Double as a
long (by casting to type long ). 
double 
max(double arg)
Added: 
double 
min(double arg)
Added: 
double 
mod(double arg)
Added: Remainder from the floorDivide operation. 
double 
modPow(double exp,
double modulus)
Added: 
double 
multiply(double arg)
Added: 
double 
negate()
Added: 
double 
next()
Added: Infinity.next() == Infinity 
static double 
parseDouble(String s)
Enabled: Returns a new double initialized to the value
represented by the specified String , as performed
by the valueOf method of class
Double . 
double 
pow(double arg)
Added: 
double 
previous()
Added: (Infinity).previous() == Infinity 
double 
random()
Added: A number randomly chosen between 0 and this number. 
double 
remainder(double arg)
Added: Remainder from truncDivide operation. 
BigInteger 
round()
Added: 
short 
shortValue()
Enabled: Returns the value of this Double as a
short (by casting to a short ). 
double 
sin()
Added: 
double 
sqrt()
Added: 
double 
subtract(double arg)
Added: 
double 
tan()
Added: 
String 
toString()
Suppressed: Returns a string representation of this Double object. 
static String 
toString(double d)
Enabled: Returns a string representation of the double
argument. 
BigInteger 
truncate()
Added: 
long 
truncDivide(double arg)
Added: Always gives an integer resulting from rounding towards zero, ie, truncating. 
static Double 
valueOf(String s)
Enabled: Returns a Double object holding the
double value represented by the argument string
s . 
Methods inherited from class java.lang.Object 
clone, finalize, getClass, notify, notifyAll, wait, wait, wait 
Field Detail 
public static final double POSITIVE_INFINITY
double
. It is equal to the value returned by
Double.longBitsToDouble(0x7ff0000000000000L)
.
public static final double NEGATIVE_INFINITY
double
. It is equal to the value returned by
Double.longBitsToDouble(0xfff0000000000000L)
.
public static final double NaN
double
. It is equivalent to the value returned by
Double.longBitsToDouble(0x7ff8000000000000L)
.
public static final double MAX_VALUE
double
, (22^{52})·2^{1023}.
It is equal to the value returned by:
Double.longBitsToDouble(0x7fefffffffffffffL)
.
public static final double MIN_VALUE
double
, 2^{1074}. It is equal to the
value returned by Double.longBitsToDouble(0x1L)
.
public static final Class TYPE
Class
instance representing the primitive type
double
.
private double value
private static final long serialVersionUID
Constructor Detail 
public Double(double value)
Double
object that
represents the primitive double
argument.
value
 the value to be represented by the Double
.public Double(String s) throws NumberFormatException
Double
object that
represents the floatingpoint value of type double
represented by the string. The string is converted to a
double
value as if by the valueOf
method.
s
 a string to be converted to a Double
.java.lang.Double#valueOf(java.lang.String)
Method Detail 
public static String toString(double d)
double
argument. All characters mentioned below are ASCII characters.
NaN
".

'
('\u002D'
); if the sign is positive, no sign character
appears in the result. As for the magnitude m:
"Infinity"
; thus, positive infinity produces the result
"Infinity"
and negative infinity produces the result
"Infinity"
.
"0.0"
; thus, negative zero produces the result
"0.0"
and positive zero produces the result
"0.0"
.
.
' ('\u002E'
), followed by one or
more decimal digits representing the fractional part of m.
.
'
('\u002E'
), followed by decimal digits
representing the fractional part of a, followed by the
letter 'E
' ('\u0045'
), followed
by a representation of n as a decimal integer, as
produced by the method Integer.toString(int)
.
double
. That is, suppose that
x is the exact mathematical value represented by the decimal
representation produced by this method for a finite nonzero argument
d. Then d must be the double
value nearest
to x; or if two double
values are equally close
to x, then d must be one of them and the least
significant bit of the significand of d must be 0
.
To create localized string representations of a floatingpoint
value, use subclasses of java.text.NumberFormat
.
d
 the double
to be converted.
public static Double valueOf(String s) throws NumberFormatException
Double
object holding the
double
value represented by the argument string
s
.
If s
is null
, then a
NullPointerException
is thrown.
Leading and trailing whitespace characters in s
are ignored. The rest of s
should constitute a
FloatValue as described by the lexical rule:
where Sign and FloatingPointLiteral are as defined in §3.10.2 of the Java Language Specification. If
 FloatValue:
 Sign_{opt}
NaN
 Sign_{opt}
Infinity
 Sign_{opt} FloatingPointLiteral
s
does not have the
form of a FloatValue, then a NumberFormatException
is thrown. Otherwise, s
is regarded as
representing an exact decimal value in the usual "computerized
scientific notation"; this exact decimal value is then
conceptually converted to an "infinitely precise" binary value
that is then rounded to type double
by the usual
roundtonearest rule of IEEE 754 floatingpoint arithmetic,
which includes preserving the sign of a zero value. Finally, a
Double
object representing this
double
value is returned.
To interpret localized string representations of a
floatingpoint value, use subclasses of java.text.NumberFormat
.
s
 the string to be parsed.
Double
object holding the value
represented by the String
argument.
NumberFormatException
public static double parseDouble(String s) throws NumberFormatException
double
initialized to the value
represented by the specified String
, as performed
by the valueOf
method of class
Double
.
s
 the string to be parsed.
double
value represented by the string
argument.
NumberFormatException
java.lang.Double#valueOf(String)
public static boolean isNaN(double v)
true
if the specified number is a
NotaNumber (NaN) value, false
otherwise.
v
 the value to be tested.
true
if the value of the argument is NaN;
false
otherwise.public static boolean isInfinite(double v)
true
if the specified number is infinitely
large in magnitude, false
otherwise.
v
 the value to be tested.
true
if the value of the argument is positive
infinity or negative infinity; false
otherwise.public boolean isNaN()
true
if this Double
value is
a NotaNumber (NaN), false
otherwise.
true
if the value represented by this object is
NaN; false
otherwise.public boolean isInfinite()
true
if this Double
value is
infinitely large in magnitude, false
otherwise.
true
if the value represented by this object is
positive infinity or negative infinity;
false
otherwise.public String toString()
Double
object.
The primitive double
value represented by this
object is converted to a string exactly as if by the method
toString
of one argument.
toString
in class Object
String
representation of this object.java.lang.Double#toString(double)
public byte byteValue()
Double
as a byte
(by
casting to a byte
).
byteValue
in class Number
double
value represented by this object
converted to type byte
public short shortValue()
Double
as a
short
(by casting to a short
).
shortValue
in class Number
double
value represented by this object
converted to type short
public int intValue()
Double
as an
int
(by casting to type int
).
intValue
in class Number
double
value represented by this object
converted to type int
public long longValue()
Double
as a
long
(by casting to type long
).
longValue
in class Number
double
value represented by this object
converted to type long
public float floatValue()
float
value of this
Double
object.
floatValue
in class Number
double
value represented by this object
converted to type float
public double doubleValue()
double
value of this
Double
object.
doubleValue
in class Number
double
value represented by this objectpublic int hashCode()
Double
object. The
result is the exclusive OR of the two halves of the
long
integer bit representation, exactly as
produced by the method doubleToLongBits(double)
, of
the primitive double
value represented by this
Double
object. That is, the hash code is the value
of the expression:
where(int)(v^(v>>>32))
v
is defined by:
long v = Double.doubleToLongBits(this.doubleValue());
hashCode
in class Object
hash code
value for this object.java.lang.Object#equals(java.lang.Object)
,
java.util.Hashtable
public boolean equals(Object obj)
true
if and only if the argument is not
null
and is a Double
object that
represents a double
that has the same value as the
double
represented by this object. For this
purpose, two double
values are considered to be
the same if and only if the method doubleToLongBits(double)
returns the identical
long
value when applied to each.
Note that in most cases, for two instances of class
Double
, d1
and d2
, the
value of d1.equals(d2)
is true
if and
only if
d1.doubleValue() == d2.doubleValue()
also has the value true
. However, there are two
exceptions:
d1
and d2
both represent
Double.NaN
, then the equals
method
returns true
, even though
Double.NaN==Double.NaN
has the value
false
.
d1
represents +0.0
while
d2
represents 0.0
, or vice versa,
the equal
test has the value false
,
even though +0.0==0.0
has the value true
.
equals
in class Object
obj
 the object to compare with.
true
if the objects are the same;
false
otherwise.java.lang.Double#doubleToLongBits(double)
public static long doubleToLongBits(double value)
Bit 63 (the bit that is selected by the mask
0x8000000000000000L
) represents the sign of the
floatingpoint number. Bits
6252 (the bits that are selected by the mask
0x7ff0000000000000L
) represent the exponent. Bits 510
(the bits that are selected by the mask
0x000fffffffffffffL
) represent the significand
(sometimes called the mantissa) of the floatingpoint number.
If the argument is positive infinity, the result is
0x7ff0000000000000L
.
If the argument is negative infinity, the result is
0xfff0000000000000L
.
If the argument is NaN, the result is
0x7ff8000000000000L
.
In all cases, the result is a long
integer that, when
given to the longBitsToDouble(long)
method, will produce a
floatingpoint value the same as the argument to
doubleToLongBits
(except all NaN values are
collapsed to a single "canonical" NaN value).
value
 a double
precision floatingpoint number.
public static long doubleToRawLongBits(double value)
Bit 63 (the bit that is selected by the mask
0x8000000000000000L
) represents the sign of the
floatingpoint number. Bits
6252 (the bits that are selected by the mask
0x7ff0000000000000L
) represent the exponent. Bits 510
(the bits that are selected by the mask
0x000fffffffffffffL
) represent the significand
(sometimes called the mantissa) of the floatingpoint number.
If the argument is positive infinity, the result is
0x7ff0000000000000L
.
If the argument is negative infinity, the result is
0xfff0000000000000L
.
If the argument is NaN, the result is the long
integer representing the actual NaN value. Unlike the
doubleToLongBits
method,
doubleToRawLongBits
does not collapse all the bit
patterns encoding a NaN to a single "canonical" NaN
value.
In all cases, the result is a long
integer that,
when given to the longBitsToDouble(long)
method, will
produce a floatingpoint value the same as the argument to
doubleToRawLongBits
.
value
 a double
precision floatingpoint number.
public static double longBitsToDouble(long bits)
double
value corresponding to a given
bit representation.
The argument is considered to be a representation of a
floatingpoint value according to the IEEE 754 floatingpoint
"double format" bit layout.
If the argument is 0x7ff0000000000000L
, the result
is positive infinity.
If the argument is 0xfff0000000000000L
, the result
is negative infinity.
If the argument is any value in the range
0x7ff0000000000001L
through
0x7fffffffffffffffL
or in the range
0xfff0000000000001L
through
0xffffffffffffffffL
, the result is a NaN. No IEEE
754 floatingpoint operation provided by Java can distinguish
between two NaN values of the same type with different bit
patterns. Distinct values of NaN are only distinguishable by
use of the Double.doubleToRawLongBits
method.
In all other cases, let s, e, and m be three values that can be computed from the argument:
Then the floatingpoint result equals the value of the mathematical expression s·m·2^{e1075}.int s = ((bits >> 63) == 0) ? 1 : 1; int e = (int)((bits >> 52) & 0x7ffL); long m = (e == 0) ? (bits & 0xfffffffffffffL) << 1 : (bits & 0xfffffffffffffL)  0x10000000000000L;
Note that this method may not be able to return a
double
NaN with exactly same bit pattern as the
long
argument. IEEE 754 distinguishes between two
kinds of NaNs, quiet NaNs and signaling NaNs. The
differences between the two kinds of NaN are generally not
visible in Java. Arithmetic operations on signaling NaNs turn
them into quiet NaNs with a different, but often similar, bit
pattern. However, on some processors merely copying a
signaling NaN also performs that conversion. In particular,
copying a signaling NaN to return it to the calling method
may perform this conversion. So longBitsToDouble
may not be able to return a double
with a
signaling NaN bit pattern. Consequently, for some
long
values,
doubleToRawLongBits(longBitsToDouble(start))
may
not equal start
. Moreover, which
particular bit patterns represent signaling NaNs is platform
dependent; although all NaN bit patterns, quiet or signaling,
must be in the NaN range identified above.
bits
 any long
integer.
double
floatingpoint value with the same
bit pattern.public int compareTo(Double anotherDouble)
Double
objects numerically. There
are two ways in which comparisons performed by this method
differ from those performed by the Java language numerical
comparison operators (<, <=, ==, >= >
)
when applied to primitive double
values:
Double.NaN
is considered by this method
to be equal to itself and greater than all other
double
values (including
Double.POSITIVE_INFINITY
).
0.0d
is considered by this method to be greater
than 0.0d
.
Double.compareTo(Object)
(which
forwards its behavior to this method) obeys the general
contract for Comparable.compareTo
, and that the
natural order on Double
s is consistent
with equals.
anotherDouble
 the Double
to be compared.
0
if anotherDouble
is
numerically equal to this Double
; a value
less than 0
if this Double
is numerically less than anotherDouble
;
and a value greater than 0
if this
Double
is numerically greater than
anotherDouble
.Comparable.compareTo(Object)
public int compareTo(Object o)
Double
object to another object. If
the object is a Double
, this function behaves like
compareTo(Double)
. Otherwise, it throws a
ClassCastException
(as Double
objects
are comparable only to other Double
objects).
compareTo
in interface Comparable
o
 the Object
to be compared.
0
if the argument is a
Double
numerically equal to this
Double
; a value less than 0
if the argument is a Double
numerically
greater than this Double
; and a value
greater than 0
if the argument is a
Double
numerically less than this
Double
.java.lang.Comparable
public static int compare(double d1, double d2)
double
values. The sign
of the integer value returned is the same as that of the
integer that would be returned by the call:
new Double(d1).compareTo(new Double(d2))
d1
 the first double
to compared2
 the second double
to compare
0
if d1
is
numerically equal to d2
; a value less than
0
if d1
is numerically less than
d2
; and a value greater than 0
if d1
is numerically greater than
d2
.public double sin()
public double cos()
public double tan()
public double atan2(double arg)
public double sqrt()
public double pow(double arg)
public double compareTo(Object o)
compareTo
in interface Comparable
o
 the Object to be compared.
public double min(double arg)
public double add(double arg)
public double next()
NaN.next() == NaN
Double.getMAX_VALUE().next() == Infinity
(Infinity).next() == (Double.getMAX_VALUE())
otherwise, *num*.next() == *next representable number*
public double max(double arg)
public double previous()
NaN.previous() == NaN
(Double.getMAX_VALUE()).previous() == Infinity
Infinity.previous() == Double.getMAX_VALUE()
otherwise, *num*.previous() == *previous representable number*
public double asin()
public double acos()
public double atan()
public double exp()
public double log()
public BigInteger ceil()
public BigInteger floor()
public BigInteger round()
public double random()
public double abs()
public double multiply(double arg)
public double subtract(double arg)
public double remainder(double arg)
(a truncDivide b)*b + (a remainder b) == a [ 5, 3]: ( 1* 3) + 2 == 5 [ 5,3]: (1*3) + 2 == 5 [5, 3]: (1* 3) + 2 == 5 [5,3]: ( 1*3) + 2 == 5
Therefore, if the result is nonzero, the sign of the result must be the same as the sign of a. This corresponds to the Java and E "%" operator.
public double negate()
public double mod(double arg)
(a floorDivide b)*b + (a modulo b) == a [ 5, 3]: ( 1* 3) + 2 == 5 [ 5,3]: (2*3) + 1 == 5 [5, 3]: (2* 3) + 1 == 5 [5,3]: ( 1*3) + 2 == 5
Therefore, if the result is nonzero, the sign of the result must be the same as the sign of b, and so the result ranges from 0 inclusive to b exclusive. This corresponds to the E "%%" operator. When b >= 0, it also corresponds to Java's BigInteger.mod().
public double modPow(double exp, double modulus)
public boolean isZero()
public BigInteger truncate()
public double approxDivide(double arg)
public boolean aboveZero()
public boolean atLeastZero()
public boolean atMostZero()
public boolean belowZero()
public BigInteger floorDivide(double arg)
public long truncDivide(double arg)


PREV CLASS NEXT CLASS  FRAMES NO FRAMES  
SUMMARY: NESTED  FIELD  CONSTR  METHOD  DETAIL: FIELD  CONSTR  METHOD 