DD (RS Core TRUNK-SNAPSHOT API)

java.lang.Object
- com.revolsys.jts.math.DD

All Implemented Interfaces:

Serializable, Cloneable, Comparable
```
public final class DD
extends Object
implements Serializable, Comparable, Cloneable
```
Implements extended-precision floating-point numbers which maintain 106 bits (approximately 30 decimal digits) of precision.
A DoubleDouble uses a representation containing two double-precision values. A number x is represented as a pair of doubles, x.hi and x.lo, such that the number represented by x is x.hi + x.lo, where
```
    |x.lo| <= 0.5*ulp(x.hi)
 
```
and ulp(y) means "unit in the last place of y". The basic arithmetic operations are implemented using convenient properties of IEEE-754 floating-point arithmetic.
The range of values which can be represented is the same as in IEEE-754. The precision of the representable numbers is twice as great as IEEE-754 double precision.
The correctness of the arithmetic algorithms relies on operations being performed with standard IEEE-754 double precision and rounding. This is the Java standard arithmetic model, but for performance reasons Java implementations are not constrained to using this standard by default. Some processors (notably the Intel Pentium architecure) perform floating point operations in (non-IEEE-754-standard) extended-precision. A JVM implementation may choose to use the non-standard extended-precision as its default arithmetic mode. To prevent this from happening, this code uses the Java strictfp modifier, which forces all operations to take place in the standard IEEE-754 rounding model.
The API provides both a set of value-oriented operations and a set of mutating operations. Value-oriented operations treat DoubleDouble values as immutable; operations on them return new objects carrying the result of the operation. This provides a simple and safe semantics for writing DoubleDouble expressions. However, there is a performance penalty for the object allocations required. The mutable interface updates object values in-place. It provides optimum memory performance, but requires care to ensure that aliasing errors are not created and constant values are not changed.
This implementation uses algorithms originally designed variously by Knuth, Kahan, Dekker, and Linnainmaa. Douglas Priest developed the first C implementation of these techniques. Other more recent C++ implementation are due to Keith M. Briggs and David Bailey et al.
References
- Priest, D., Algorithms for Arbitrary Precision Floating Point Arithmetic, in P. Kornerup and D. Matula, Eds., Proc. 10th Symposium on Computer Arithmetic, IEEE Computer Society Press, Los Alamitos, Calif., 1991.
- Yozo Hida, Xiaoye S. Li and David H. Bailey, Quad-Double Arithmetic: Algorithms, Implementation, and Application, manuscript, Oct 2000; Lawrence Berkeley National Laboratory Report BNL-46996.
- David Bailey, High Precision Software Directory; http://crd.lbl.gov/~dhbailey/mpdist/index.html
Author:

Martin Davis

See Also:
Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static DD`	`E` The value nearest to the constant e (the natural logarithm base).
`static double`	`EPS` The smallest representable relative difference between two {link @ DoubleDouble} values
`static DD`	`NaN` A value representing the result of an operation which does not return a valid number.
`static DD`	`PI` The value nearest to the constant Pi.
`static DD`	`PI_2` The value nearest to the constant Pi / 2.
`static DD`	`TWO_PI` The value nearest to the constant 2 * Pi.

Constructor Summary

Constructors
Constructor and Description
`DD()` Creates a new DoubleDouble with value 0.0.
`DD(DD dd)` Creates a new DoubleDouble with value equal to the argument.
`DD(double x)` Creates a new DoubleDouble with value x.
`DD(double hi, double lo)` Creates a new DoubleDouble with value (hi, lo).
`DD(String str)` Creates a new DoubleDouble with value equal to the argument.

Method Summary

Methods
Modifier and Type	Method and Description
`DD`	`abs()` Returns the absolute value of this value.
`DD`	`add(DD y)` Returns a DoubleDouble whose value is `(this + y)`.
`DD`	`add(double y)` Returns a DoubleDouble whose value is `(this + y)`.
`DD`	`ceil()` Returns the smallest (closest to negative infinity) value that is not less than the argument and is equal to a mathematical integer.
`Object`	`clone()` Creates and returns a copy of this value.
`int`	`compareTo(Object o)` Compares two DoubleDouble objects numerically.
`static DD`	`copy(DD dd)` Creates a new DoubleDouble with the value of the argument.
`DD`	`divide(DD y)` Computes a new DoubleDouble whose value is `(this / y)`.
`DD`	`divide(double y)` Computes a new DoubleDouble whose value is `(this / y)`.
`double`	`doubleValue()` Converts this value to the nearest double-precision number.
`String`	`dump()` Dumps the components of this number to a string.
`boolean`	`equals(DD y)` Tests whether this value is equal to another `DoubleDouble` value.
`DD`	`floor()` Returns the largest (closest to positive infinity) value that is not greater than the argument and is equal to a mathematical integer.
`boolean`	`ge(DD y)` Tests whether this value is greater than or equals to another `DoubleDouble` value.
`boolean`	`gt(DD y)` Tests whether this value is greater than another `DoubleDouble` value.
`int`	`intValue()` Converts this value to the nearest integer.
`boolean`	`isNaN()` Tests whether this value is NaN.
`boolean`	`isNegative()` Tests whether this value is less than 0.
`boolean`	`isPositive()` Tests whether this value is greater than 0.
`boolean`	`isZero()` Tests whether this value is equal to 0.
`boolean`	`le(DD y)` Tests whether this value is less than or equal to another `DoubleDouble` value.
`boolean`	`lt(DD y)` Tests whether this value is less than another `DoubleDouble` value.
`DD`	`max(DD x)` Computes the maximum of this and another DD number.
`DD`	`min(DD x)` Computes the minimum of this and another DD number.
`DD`	`multiply(DD y)` Returns a new DoubleDouble whose value is `(this * y)`.
`DD`	`multiply(double y)` Returns a new DoubleDouble whose value is `(this * y)`.
`DD`	`negate()` Returns a DoubleDouble whose value is `-this`.
`static DD`	`parse(String str)` Converts a string representation of a real number into a DoubleDouble value.
`DD`	`pow(int exp)` Computes the value of this number raised to an integral power.
`DD`	`reciprocal()` Returns a DoubleDouble whose value is `1 / this`.
`DD`	`rint()` Rounds this value to the nearest integer.
`DD`	`selfAdd(DD y)` Adds the argument to the value of `this`.
`DD`	`selfAdd(double y)` Adds the argument to the value of `this`.
`DD`	`selfDivide(DD y)` Divides this object by the argument, returning `this`.
`DD`	`selfDivide(double y)` Divides this object by the argument, returning `this`.
`DD`	`selfMultiply(DD y)` Multiplies this object by the argument, returning `this`.
`DD`	`selfMultiply(double y)` Multiplies this object by the argument, returning `this`.
`DD`	`selfSubtract(DD y)` Subtracts the argument from the value of `this`.
`DD`	`selfSubtract(double y)` Subtracts the argument from the value of `this`.
`int`	`signum()` Returns an integer indicating the sign of this value.
`DD`	`sqr()` Computes the square of this value.
`static DD`	`sqr(double x)` Computes the square of this value.
`DD`	`sqrt()` Computes the positive square root of this value.
`static DD`	`sqrt(double x)`
`DD`	`subtract(DD y)` Computes a new DoubleDouble object whose value is `(this - y)`.
`DD`	`subtract(double y)` Computes a new DoubleDouble object whose value is `(this - y)`.
`String`	`toSciNotation()` Returns the string representation of this value in scientific notation.
`String`	`toStandardNotation()` Returns the string representation of this value in standard notation.
`String`	`toString()` Returns a string representation of this number, in either standard or scientific notation.
`DD`	`trunc()` Returns the integer which is largest in absolute value and not further from zero than this value.
`static DD`	`valueOf(double x)` Converts the `double` argument to a DoubleDouble number.
`static DD`	`valueOf(String str)` Converts the string argument to a DoubleDouble number.

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - PI
```
public static final DD PI
```
    The value nearest to the constant Pi.
  - TWO_PI
```
public static final DD TWO_PI
```
    The value nearest to the constant 2 * Pi.
  - PI_2
```
public static final DD PI_2
```
    The value nearest to the constant Pi / 2.
  - E
```
public static final DD E
```
    The value nearest to the constant e (the natural logarithm base).
  - NaN
```
public static final DD NaN
```
    A value representing the result of an operation which does not return a valid number.
  - EPS
```
public static final double EPS
```
    The smallest representable relative difference between two {link @ DoubleDouble} values
    
    See Also:
    Constant Field Values
- Constructor Detail
  - DD
```
public DD()
```
    Creates a new DoubleDouble with value 0.0.
  - DD
```
public DD(DD dd)
```
    Creates a new DoubleDouble with value equal to the argument.
    
    Parameters:
    dd - the value to initialize
  - DD
```
public DD(double x)
```
    Creates a new DoubleDouble with value x.
    
    Parameters:
    x - the value to initialize
  - DD
```
public DD(double hi,
  double lo)
```
    Creates a new DoubleDouble with value (hi, lo).
    
    Parameters:
    hi - the high-order component
    lo - the high-order component
  - DD
```
public DD(String str)
   throws NumberFormatException
```
    Creates a new DoubleDouble with value equal to the argument.
    
    Parameters:
    str - the value to initialize by
    
    Throws:
    
    NumberFormatException - if str is not a valid representation of a number
- Method Detail
  - copy
```
public static DD copy(DD dd)
```
    Creates a new DoubleDouble with the value of the argument.
    
    Parameters:
    dd - the DoubleDouble value to copy
    
    Returns:
    a copy of the input value
  - parse
```
public static DD parse(String str)
                throws NumberFormatException
```
    Converts a string representation of a real number into a DoubleDouble value. The format accepted is similar to the standard Java real number syntax. It is defined by the following regular expression:
```
 [+|-] {digit} [ . {digit} ] [ ( e | E ) [+|-] {digit}+
 
```
    Parameters:
    str - the string to parse
    
    Returns:
    the value of the parsed number
    
    Throws:
    
    NumberFormatException - if str is not a valid representation of a number
  - sqr
```
public static DD sqr(double x)
```
    Computes the square of this value.
    
    Returns:
    the square of this value.
  - sqrt
```
public static DD sqrt(double x)
```
  - valueOf
```
public static DD valueOf(double x)
```
    Converts the double argument to a DoubleDouble number.
    
    Parameters:
    x - a numeric value
    
    Returns:
    the extended precision version of the value
  - valueOf
```
public static DD valueOf(String str)
                  throws NumberFormatException
```
    Converts the string argument to a DoubleDouble number.
    
    Parameters:
    str - a string containing a representation of a numeric value
    
    Returns:
    the extended precision version of the value
    
    Throws:
    
    NumberFormatException - if s is not a valid representation of a number
  - abs
```
public DD abs()
```
    Returns the absolute value of this value. Special cases:
    - If this value is NaN, it is returned.
    Returns:
    the absolute value of this value
  - add
```
public final DD add(DD y)
```
    Returns a DoubleDouble whose value is (this + y).
    
    Parameters:
    y - the addend
    
    Returns:
    (this + y)
  - add
```
public final DD add(double y)
```
    Returns a DoubleDouble whose value is (this + y).
    
    Parameters:
    y - the addend
    
    Returns:
    (this + y)
  - ceil
```
public DD ceil()
```
    Returns the smallest (closest to negative infinity) value that is not less than the argument and is equal to a mathematical integer. Special cases:
    - If this value is NaN, returns NaN.
    Returns:
    the smallest (closest to negative infinity) value that is not less than the argument and is equal to a mathematical integer.
  - clone
```
public Object clone()
```
    Creates and returns a copy of this value.
    
    Overrides:
    
    clone in class Object
    
    Returns:
    a copy of this value
  - compareTo
```
public int compareTo(Object o)
```
    Compares two DoubleDouble objects numerically.
    
    Specified by:
    
    compareTo in interface Comparable
    
    Returns:
    -1,0 or 1 depending on whether this value is less than, equal to or greater than the value of o
  - divide
```
public final DD divide(DD y)
```
    Computes a new DoubleDouble whose value is (this / y).
    
    Parameters:
    y - the divisor
    
    Returns:
    a new object with the value (this / y)
  - divide
```
public final DD divide(double y)
```
    Computes a new DoubleDouble whose value is (this / y).
    
    Parameters:
    y - the divisor
    
    Returns:
    a new object with the value (this / y)
  - doubleValue
```
public double doubleValue()
```
    Converts this value to the nearest double-precision number.
    
    Returns:
    the nearest double-precision number to this value
  - dump
```
public String dump()
```
    Dumps the components of this number to a string.
    
    Returns:
    a string showing the components of the number
  - equals
```
public boolean equals(DD y)
```
    Tests whether this value is equal to another DoubleDouble value.
    
    Parameters:
    y - a DoubleDouble value
    
    Returns:
    true if this value = y
  - floor
```
public DD floor()
```
    Returns the largest (closest to positive infinity) value that is not greater than the argument and is equal to a mathematical integer. Special cases:
    - If this value is NaN, returns NaN.
    Returns:
    the largest (closest to positive infinity) value that is not greater than the argument and is equal to a mathematical integer.
  - ge
```
public boolean ge(DD y)
```
    Tests whether this value is greater than or equals to another DoubleDouble value.
    
    Parameters:
    y - a DoubleDouble value
    
    Returns:
    true if this value >= y
  - gt
```
public boolean gt(DD y)
```
    Tests whether this value is greater than another DoubleDouble value.
    
    Parameters:
    y - a DoubleDouble value
    
    Returns:
    true if this value > y
  - intValue
```
public int intValue()
```
    Converts this value to the nearest integer.
    
    Returns:
    the nearest integer to this value
  - isNaN
```
public boolean isNaN()
```
    Tests whether this value is NaN.
    
    Returns:
    true if this value is NaN
  - isNegative
```
public boolean isNegative()
```
    Tests whether this value is less than 0.
    
    Returns:
    true if this value is less than 0
  - isPositive
```
public boolean isPositive()
```
    Tests whether this value is greater than 0.
    
    Returns:
    true if this value is greater than 0
  - isZero
```
public boolean isZero()
```
    Tests whether this value is equal to 0.
    
    Returns:
    true if this value is equal to 0
  - le
```
public boolean le(DD y)
```
    Tests whether this value is less than or equal to another DoubleDouble value.
    
    Parameters:
    y - a DoubleDouble value
    
    Returns:
    true if this value <= y
  - lt
```
public boolean lt(DD y)
```
    Tests whether this value is less than another DoubleDouble value.
    
    Parameters:
    y - a DoubleDouble value
    
    Returns:
    true if this value < y
  - max
```
public DD max(DD x)
```
    Computes the maximum of this and another DD number.
    
    Parameters:
    x - a DD number
    
    Returns:
    the maximum of the two numbers
  - min
```
public DD min(DD x)
```
    Computes the minimum of this and another DD number.
    
    Parameters:
    x - a DD number
    
    Returns:
    the minimum of the two numbers
  - multiply
```
public final DD multiply(DD y)
```
    Returns a new DoubleDouble whose value is (this * y).
    
    Parameters:
    y - the multiplicand
    
    Returns:
    (this * y)
  - multiply
```
public final DD multiply(double y)
```
    Returns a new DoubleDouble whose value is (this * y).
    
    Parameters:
    y - the multiplicand
    
    Returns:
    (this * y)
  - negate
```
public final DD negate()
```
    Returns a DoubleDouble whose value is -this.
    
    Returns:
    -this
  - pow
```
public DD pow(int exp)
```
    Computes the value of this number raised to an integral power. Follows semantics of Java Math.pow as closely as possible.
    
    Parameters:
    exp - the integer exponent
    
    Returns:
    x raised to the integral power exp
  - reciprocal
```
public final DD reciprocal()
```
    Returns a DoubleDouble whose value is 1 / this.
    
    Returns:
    the reciprocal of this value
  - rint
```
public DD rint()
```
    Rounds this value to the nearest integer. The value is rounded to an integer by adding 1/2 and taking the floor of the result. Special cases:
    - If this value is NaN, returns NaN.
    Returns:
    this value rounded to the nearest integer
  - selfAdd
```
public final DD selfAdd(DD y)
```
    Adds the argument to the value of this. To prevent altering constants, this method must only be used on values known to be newly created.
    
    Parameters:
    y - the addend
    
    Returns:
    this object, increased by y
  - selfAdd
```
public final DD selfAdd(double y)
```
    Adds the argument to the value of this. To prevent altering constants, this method must only be used on values known to be newly created.
    
    Parameters:
    y - the addend
    
    Returns:
    this object, increased by y
  - selfDivide
```
public final DD selfDivide(DD y)
```
    Divides this object by the argument, returning this. To prevent altering constants, this method must only be used on values known to be newly created.
    
    Parameters:
    y - the value to divide by
    
    Returns:
    this object, divided by y
  - selfDivide
```
public final DD selfDivide(double y)
```
    Divides this object by the argument, returning this. To prevent altering constants, this method must only be used on values known to be newly created.
    
    Parameters:
    y - the value to divide by
    
    Returns:
    this object, divided by y
  - selfMultiply
```
public final DD selfMultiply(DD y)
```
    Multiplies this object by the argument, returning this. To prevent altering constants, this method must only be used on values known to be newly created.
    
    Parameters:
    y - the value to multiply by
    
    Returns:
    this object, multiplied by y
  - selfMultiply
```
public final DD selfMultiply(double y)
```
    Multiplies this object by the argument, returning this. To prevent altering constants, this method must only be used on values known to be newly created.
    
    Parameters:
    y - the value to multiply by
    
    Returns:
    this object, multiplied by y
  - selfSubtract
```
public final DD selfSubtract(DD y)
```
    Subtracts the argument from the value of this. To prevent altering constants, this method must only be used on values known to be newly created.
    
    Parameters:
    y - the addend
    
    Returns:
    this object, decreased by y
  - selfSubtract
```
public final DD selfSubtract(double y)
```
    Subtracts the argument from the value of this. To prevent altering constants, this method must only be used on values known to be newly created.
    
    Parameters:
    y - the addend
    
    Returns:
    this object, decreased by y
  - signum
```
public int signum()
```
    Returns an integer indicating the sign of this value.
    - if this value is > 0, returns 1
    - if this value is < 0, returns -1
    - if this value is = 0, returns 0
    - if this value is NaN, returns 0
    Returns:
    an integer indicating the sign of this value
  - sqr
```
public DD sqr()
```
    Computes the square of this value.
    
    Returns:
    the square of this value.
  - sqrt
```
public DD sqrt()
```
    Computes the positive square root of this value. If the number is NaN or negative, NaN is returned.
    
    Returns:
    the positive square root of this number. If the argument is NaN or less than zero, the result is NaN.
  - subtract
```
public final DD subtract(DD y)
```
    Computes a new DoubleDouble object whose value is (this - y).
    
    Parameters:
    y - the subtrahend
    
    Returns:
    (this - y)
  - subtract
```
public final DD subtract(double y)
```
    Computes a new DoubleDouble object whose value is (this - y).
    
    Parameters:
    y - the subtrahend
    
    Returns:
    (this - y)
  - toSciNotation
```
public String toSciNotation()
```
    Returns the string representation of this value in scientific notation.
    
    Returns:
    the string representation in scientific notation
  - toStandardNotation
```
public String toStandardNotation()
```
    Returns the string representation of this value in standard notation.
    
    Returns:
    the string representation in standard notation
  - toString
```
public String toString()
```
    Returns a string representation of this number, in either standard or scientific notation. If the magnitude of the number is in the range [ 10^-3, 10⁸ ] standard notation will be used. Otherwise, scientific notation will be used.
    
    Overrides:
    
    toString in class Object
    
    Returns:
    a string representation of this number
  - trunc
```
public DD trunc()
```
    Returns the integer which is largest in absolute value and not further from zero than this value. Special cases:
    - If this value is NaN, returns NaN.
    Returns:
    the integer which is largest in absolute value and not further from zero than this value

Class DD

References

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

PI

TWO_PI

PI_2

E

NaN

EPS

Constructor Detail

DD

DD

DD

DD

DD

Method Detail

copy

parse

sqr

sqrt

valueOf

valueOf

abs

add

add

ceil

clone

compareTo

divide

divide

doubleValue

dump

equals

floor

ge

gt

intValue

isNaN

isNegative

isPositive

isZero

le

lt

max

min

multiply

multiply

negate

pow

reciprocal

rint

selfAdd

selfAdd

selfDivide

selfDivide

selfMultiply

selfMultiply

selfSubtract

selfSubtract

signum

sqr

sqrt

subtract

subtract

toSciNotation

toStandardNotation

toString

trunc