#include <src/main/decaf/lang/Double.h>

Inheritance diagram for decaf::lang::Double:

Public Member Functions
	Double (double value)
	Constructs a new instance of a Double object and assigns it the given value.
	Double (const std::string &value)
	Constructs a new Double and attempts to convert the given string to a double value, assigning it to the new object is successful or throwing a NumberFormatException if the string is not a properly formatted double.
virtual	~Double ()
virtual int	compareTo (const Double &d) const
	Compares this Double instance with another.
bool	equals (const Double &d) const
virtual bool	operator== (const Double &d) const
	Compares equality between this object and the one passed.
virtual bool	operator< (const Double &d) const
	Compares this object to another and returns true if this object is considered to be less than the one passed.
virtual int	compareTo (const double &d) const
	Compares this Double instance with another.
bool	equals (const double &d) const
virtual bool	operator== (const double &d) const
	Compares equality between this object and the one passed.
virtual bool	operator< (const double &d) const
	Compares this object to another and returns true if this object is considered to be less than the one passed.
std::string	toString () const
virtual double	doubleValue () const
	Answers the double value which the receiver represents.
virtual float	floatValue () const
	Answers the float value which the receiver represents.
virtual unsigned char	byteValue () const
	Answers the byte value which the receiver represents.
virtual short	shortValue () const
	Answers the short value which the receiver represents.
virtual int	intValue () const
	Answers the int value which the receiver represents.
virtual long long	longValue () const
	Answers the long value which the receiver represents.
bool	isInfinite () const
bool	isNaN () const
Public Member Functions inherited from decaf::lang::Number
virtual	~Number ()
Public Member Functions inherited from decaf::lang::Comparable< Double >
virtual	~Comparable ()
Public Member Functions inherited from decaf::lang::Comparable< double >
virtual	~Comparable ()

Static Public Member Functions
static int	compare (double d1, double d2)
	Compares the two specified double values.
static long long	doubleToLongBits (double value)
	Returns a representation of the specified floating-point value according to the IEEE 754 floating-point "double format" bit layout.
static long long	doubleToRawLongBits (double value)
	Returns a representation of the specified floating-point value according to the IEEE 754 floating-point "double format" bit layout, preserving Not-a-Number (NaN) values.
static bool	isInfinite (double value)
static bool	isNaN (double value)
static double	longBitsToDouble (long long bits)
	Returns the double value corresponding to a given bit representation.
static double	parseDouble (const std::string value)
	Returns a new double initialized to the value represented by the specified string, as performed by the valueOf method of class Double.
static std::string	toHexString (double value)
	Returns a hexadecimal string representation of the double argument.
static std::string	toString (double value)
	Returns a string representation of the double argument.
static Double	valueOf (double value)
	Returns a Double instance representing the specified double value.
static Double	valueOf (const std::string &value)
	Returns a Double instance that wraps a primtive double which is parsed from the string value passed.

Static Public Attributes
static const int	SIZE = 64
	The size in bits of the primitive int type.
static const double	MAX_VALUE
	The maximum value that the primitive type can hold.
static const double	MIN_VALUE
	The minimum value that the primitive type can hold.
static const double	NaN
	Constant for the Not a Number Value.
static const double	POSITIVE_INFINITY
	Constant for Positive Infinity.
static const double	NEGATIVE_INFINITY
	Constant for Negative Infinitiy.

Constructor & Destructor Documentation

decaf::lang::Double::Double ( double value )

Constructs a new instance of a Double object and assigns it the given value.

Parameters

value The primitive type to wrap.

decaf::lang::Double::Double ( const std::string & value )

Constructs a new Double and attempts to convert the given string to a double value, assigning it to the new object is successful or throwing a NumberFormatException if the string is not a properly formatted double.

Parameters

value The string to convert to a primitive type to wrap.

Exceptions

NumberFormatException if the string is not a a valid double.

virtual decaf::lang::Double::~Double ( )

inlinevirtual

Member Function Documentation

virtual unsigned char decaf::lang::Double::byteValue ( ) const

inlinevirtual

Answers the byte value which the receiver represents.

Returns: byte the value of the receiver.

Reimplemented from decaf::lang::Number.

static int decaf::lang::Double::compare	(	double	d1,
		double	d2
	)

static

Compares the two specified 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))

Parameters

d1	- the first double to compare
d2	- the second double to compare

Returns: the value 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.

virtual int decaf::lang::Double::compareTo ( const Double & d ) const

virtual

Compares this Double instance with another.

Parameters

d	- the Double instance to be compared

Returns: zero if this object represents the same integer value as the argument; a positive value if this object represents a value greater than the passed in value, and -1 if this object repesents a value less than the passed in value.

Implements decaf::lang::Comparable< Double >.

virtual int decaf::lang::Double::compareTo ( const double & d ) const

virtual

Compares this Double instance with another.

Parameters

d	- the Double instance to be compared

Returns: zero if this object represents the same integer value as the argument; a positive value if this object represents a value greater than the passed in value, and -1 if this object represents a value less than the passed in value.

Implements decaf::lang::Comparable< double >.

static long long decaf::lang::Double::doubleToLongBits ( double value )

static

Returns a representation of the specified floating-point value according to the IEEE 754 floating-point "double format" bit layout.

Bit 63 (the bit that is selected by the mask 0x8000000000000000L) represents the sign of the floating-point number. Bits 62-52 (the bits that are selected by the mask 0x7ff0000000000000L) represent the exponent. Bits 51-0 (the bits that are selected by the mask 0x000fffffffffffffL) represent the significand (sometimes called the mantissa) of the floating-point 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 floating-point value the same as the argument to doubleToLongBits (except all NaN values are collapsed to a single "canonical" NaN value).

Parameters

value - double to be converted

Returns: the long long bits that make up the double

Referenced by decaf::util::HashCode< double >::operator()().

static long long decaf::lang::Double::doubleToRawLongBits ( double value )

static

Returns a representation of the specified floating-point value according to the IEEE 754 floating-point "double format" bit layout, preserving Not-a-Number (NaN) values.

Bit 63 (the bit that is selected by the mask 0x8000000000000000LL) represents the sign of the floating-point number. Bits 62-52 (the bits that are selected by the mask 0x7ff0000000000000L) represent the exponent. Bits 51-0 (the bits that are selected by the mask 0x000fffffffffffffL) represent the significand (sometimes called the mantissa) of the floating-point number.

If the argument is positive infinity, the result is 0x7ff0000000000000LL. If the argument is negative infinity, the result is 0xfff0000000000000LL. 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 floating-point value the same as the argument to doubleToRawLongBits.

Parameters

value - double to be converted

Returns: the long long bits that make up the double

virtual double decaf::lang::Double::doubleValue ( ) const

inlinevirtual

Answers the double value which the receiver represents.

Returns: double the value of the receiver.

Implements decaf::lang::Number.

bool decaf::lang::Double::equals ( const Double & d ) const

inlinevirtual

Parameters

d	- the Double object to compare against.

Returns: true if the two Double Objects have the same value.

Implements decaf::lang::Comparable< Double >.

bool decaf::lang::Double::equals ( const double & d ) const

inlinevirtual

Parameters

d	- the Double object to compare against.

Returns: true if the two Double Objects have the same value.

Implements decaf::lang::Comparable< double >.

virtual float decaf::lang::Double::floatValue ( ) const

inlinevirtual

Answers the float value which the receiver represents.

Returns: float the value of the receiver.

Implements decaf::lang::Number.

virtual int decaf::lang::Double::intValue ( ) const

inlinevirtual

Answers the int value which the receiver represents.

Returns: int the value of the receiver.

Implements decaf::lang::Number.

bool decaf::lang::Double::isInfinite ( ) const

Returns: true if the double is equal to positive infinity.

static bool decaf::lang::Double::isInfinite ( double value )

static

Parameters

value - The double to check.

Returns: true if the double is equal to infinity.

bool decaf::lang::Double::isNaN ( ) const

Returns: true if the double is equal to NaN.

static bool decaf::lang::Double::isNaN ( double value )

static

Parameters

value - The double to check.

Returns: true if the double is equal to NaN.

static double decaf::lang::Double::longBitsToDouble ( long long bits )

static

Returns the double value corresponding to a given bit representation.

The argument is considered to be a representation of a floating-point value according to the IEEE 754 floating-point "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 floating-point operation provided by C++ 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.

Parameters

bits	- the long long bits to convert to double

Returns: the double converted from the bits

virtual long long decaf::lang::Double::longValue ( ) const

inlinevirtual

Answers the long value which the receiver represents.

Returns: long the value of the receiver.

Implements decaf::lang::Number.

virtual bool decaf::lang::Double::operator< ( const Double & d ) const

inlinevirtual

Compares this object to another and returns true if this object is considered to be less than the one passed.

This

Parameters

d	- the value to be compared to this one.

Returns: true if this object is equal to the one passed.

Implements decaf::lang::Comparable< Double >.

virtual bool decaf::lang::Double::operator< ( const double & d ) const

inlinevirtual

Compares this object to another and returns true if this object is considered to be less than the one passed.

This

Parameters

d	- the value to be compared to this one.

Returns: true if this object is equal to the one passed.

Implements decaf::lang::Comparable< double >.

virtual bool decaf::lang::Double::operator== ( const Double & d ) const

inlinevirtual

Compares equality between this object and the one passed.

Parameters

d	- the value to be compared to this one.

Returns: true if this object is equal to the one passed.

Implements decaf::lang::Comparable< Double >.

virtual bool decaf::lang::Double::operator== ( const double & d ) const

inlinevirtual

Compares equality between this object and the one passed.

Parameters

d	- the value to be compared to this one.

Returns: true if this object is equal to the one passed.

Implements decaf::lang::Comparable< double >.

static double decaf::lang::Double::parseDouble ( const std::string value )

static

Returns a new double initialized to the value represented by the specified string, as performed by the valueOf method of class Double.

Parameters

value - The string to parse to an double

Returns: a double parsed from the passed string

Exceptions

NumberFormatException

virtual short decaf::lang::Double::shortValue ( ) const

inlinevirtual

Answers the short value which the receiver represents.

Returns: short the value of the receiver.

Reimplemented from decaf::lang::Number.

static std::string decaf::lang::Double::toHexString ( double value )

static

Returns a hexadecimal string representation of the double argument.

All characters mentioned below are ASCII characters.

If the argument is NaN, the result is the string "NaN".
Otherwise, the result is a string that represents the sign and magnitude (absolute value) of the argument. If the sign is negative, the first character of the result is '-'; if the sign is positive, no sign character appears in the result. As for the magnitude m: o If m is infinity, it is represented by the string "Infinity"; thus, positive infinity produces the result "Infinity" and negative infinity produces the result "-Infinity". o If m is zero, it is represented by the string "0x0.0p0"; thus, negative zero produces the result "-0x0.0p0" and positive zero produces the result "0x0.0p0". o If m is a double value with a normalized representation, substrings are used to represent the significand and exponent fields. The significand is represented by the characters "0x1." followed by a lowercase hexadecimal representation of the rest of the significand as a fraction. Trailing zeros in the hexadecimal representation are removed unless all the digits are zero, in which case a single zero is used. Next, the exponent is represented by "p" followed by a decimal string of the unbiased exponent as if produced by a call to Integer.toString on the exponent value. o If m is a double value with a subnormal representation, the significand is represented by the characters "0x0." followed by a hexadecimal representation of the rest of the significand as a fraction. Trailing zeros in the hexadecimal representation are removed. Next, the exponent is represented by "p-126". Note that there must be at least one nonzero digit in a subnormal significand.

Parameters

value - The double to convert to a string

Returns: the Hex formatted double string.

std::string decaf::lang::Double::toString ( ) const

Returns: this Double Object as a String Representation

static std::string decaf::lang::Double::toString ( double value )

static

Returns a string representation of the double argument.

All characters mentioned below are ASCII characters.

If the argument is NaN, the result is the string "NaN". Otherwise, the result is a string that represents the sign and magnitude (absolute value) of the argument. If the sign is negative, the first character of the result is '-'; if the sign is positive, no sign character appears in the result. As for the magnitude m: o If m is infinity, it is represented by the characters "Infinity"; thus, positive infinity produces the result "Infinity" and negative infinity produces the result "-Infinity". o If m is zero, it is represented by the characters "0.0"; thus, negative zero produces the result "-0.0" and positive zero produces the result "0.0". o If m is greater than or equal to 10-3 but less than 107, then it is represented as the integer part of m, in decimal form with no leading zeroes, followed by '.', followed by one or more decimal digits representing the fractional part of m. o If m is less than 10-3 or greater than or equal to 107, then it is represented in so-called "computerized scientific notation." Let n be the unique integer such that 10n <= m < 10n+1; then let a be the mathematically exact quotient of m and 10n so that 1 <= a < 10. The magnitude is then represented as the integer part of a, as a single decimal digit, followed by '.', followed by decimal digits representing the fractional part of a, followed by the letter 'E', followed by a representation of n as a decimal integer, as produced by the method Integer.toString(int).

Parameters

value - The double to convert to a string

Returns: the formatted double string.

static Double decaf::lang::Double::valueOf ( double value )

static

Returns a Double instance representing the specified double value.

Parameters

value - double to wrap

Returns: new Double instance wrapping the primitive value

static Double decaf::lang::Double::valueOf ( const std::string & value )

static

Returns a Double instance that wraps a primtive double which is parsed from the string value passed.

Parameters

value - the string to parse

Returns: a new Double instance wrapping the double parsed from value

Exceptions

NumberFormatException on error.

Field Documentation

const double decaf::lang::Double::MAX_VALUE

static

The maximum value that the primitive type can hold.

const double decaf::lang::Double::MIN_VALUE

static

The minimum value that the primitive type can hold.

const double decaf::lang::Double::NaN

static

Constant for the Not a Number Value.

const double decaf::lang::Double::NEGATIVE_INFINITY

static

Constant for Negative Infinitiy.

const double decaf::lang::Double::POSITIVE_INFINITY

static

Constant for Positive Infinity.

const int decaf::lang::Double::SIZE = 64

static

The size in bits of the primitive int type.

The documentation for this class was generated from the following file:

src/main/decaf/lang/Double.h

Public Member Functions

Static Public Member Functions

Static Public Attributes

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation