Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## com.vividsolutions.jts.algorithm.math
Class DoubleDouble

    java.lang.Object
      com.vividsolutions.jts.algorithm.math.DoubleDouble

All Implemented Interfaces:
  java.io.Serializable, java.lang.Cloneable, java.lang.Comparable

    public class DoubleDouble

extends java.lang.Object
implements java.io.Serializable, java.lang.Comparable, java.lang.Cloneable

Immutable, 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 a value-oriented interface. DoubleDouble values are immutable; operations on them return new objects carrying the result of the operation. This provides a much simpler semantics for writing DoubleDouble expressions, and Java memory management is efficient enough that this imposes very little performance penalty.

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
`static DoubleDouble` | `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 DoubleDouble` | `NaN` A value representing the result of an operation which does not return a valid number.
`static DoubleDouble` | `PI` The value nearest to the constant Pi.
`static DoubleDouble` | `PI_2` The value nearest to the constant Pi / 2.
`static DoubleDouble` | `TWO_PI` The value nearest to the constant 2 * Pi.

Constructor Summary
`DoubleDouble()` Creates a new DoubleDouble with value 0.0.
`DoubleDouble(double x)` Creates a new DoubleDouble with value x.
`DoubleDouble(DoubleDouble dd)` Creates a new DoubleDouble with value equal to the argument.
`DoubleDouble(double hi, double lo)` Creates a new DoubleDouble with value (hi, lo).
`DoubleDouble(java.lang.String str)` Creates a new DoubleDouble with value equal to the argument.

Method Summary
`DoubleDouble` | `abs()` Returns the absolute value of this value.
`DoubleDouble` | `add(DoubleDouble y)` Returns a DoubleDouble whose value is `(this + y)`.
`DoubleDouble` | `ceil()` Returns the smallest (closest to negative infinity) value that is not less than the argument and is equal to a mathematical integer.
`java.lang.Object` | `clone()` Creates and returns a copy of this value.
`int` | `compareTo(java.lang.Object o)` Compares two DoubleDouble objects numerically.
`DoubleDouble` | `divide(DoubleDouble y)` Returns a DoubleDouble whose value is `(this / y)`.
`double` | `doubleValue()` Converts this value to the nearest double-precision number.
`java.lang.String` | `dump()` Dumps the components of this number to a string.
`boolean` | `equals(DoubleDouble y)` Tests whether this value is equal to another `DoubleDouble` value.
`DoubleDouble` | `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(DoubleDouble y)` Tests whether this value is greater than or equals to another `DoubleDouble` value.
`boolean` | `gt(DoubleDouble 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(DoubleDouble y)` Tests whether this value is less than or equal to another `DoubleDouble` value.
`boolean` | `lt(DoubleDouble y)` Tests whether this value is less than another `DoubleDouble` value.
`DoubleDouble` | `multiply(DoubleDouble y)` Returns a DoubleDouble whose value is `(this * y)`.
`DoubleDouble` | `negate()` Returns a DoubleDouble whose value is `-this`.
`static DoubleDouble` | `parse(java.lang.String str)` Converts a string representation of a real number into a DoubleDouble value.
`DoubleDouble` | `pow(int exp)` Computes the value of this number raised to an integral power.
`DoubleDouble` | `reciprocal()` Returns a DoubleDouble whose value is `1 / this`.
`DoubleDouble` | `rint()` Rounds this value to the nearest integer.
`int` | `signum()` Returns an integer indicating the sign of this value.
`DoubleDouble` | `sqr()` Computes the square of this value.
`DoubleDouble` | `sqrt()` Computes the positive square root of this value.
`DoubleDouble` | `subtract(DoubleDouble y)` Returns a DoubleDouble whose value is `(this - y)`.
`java.lang.String` | `toSciNotation()` Returns the string representation of this value in scientific notation.
`java.lang.String` | `toStandardNotation()` Returns the string representation of this value in standard notation.
`java.lang.String` | `toString()` Returns a string representation of this number, in either standard or scientific notation.
`DoubleDouble` | `trunc()` Returns the integer which is largest in absolute value and not further from zero than this value.
`static DoubleDouble` | `valueOf(double x)` Converts the `double` argument to a DoubleDouble number.
`static DoubleDouble` | `valueOf(java.lang.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 DoubleDouble PI

  The value nearest to the constant Pi.

### TWO_PI

    public static final DoubleDouble TWO_PI

  The value nearest to the constant 2 * Pi.

### PI_2

    public static final DoubleDouble PI_2

  The value nearest to the constant Pi / 2.

### E

    public static final DoubleDouble E

  The value nearest to the constant e (the natural logarithm base).

### NaN

    public static final DoubleDouble 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

### DoubleDouble

    public DoubleDouble()

  Creates a new DoubleDouble with value 0.0.

### DoubleDouble

    public DoubleDouble(double x)

  Creates a new DoubleDouble with value x.

  Parameters:
    `x` - the value to initialize

### DoubleDouble

    public DoubleDouble(double hi,
                        double lo)

  Creates a new DoubleDouble with value (hi, lo).

  Parameters:
    `hi` - the high-order component
    `lo` - the high-order component

### DoubleDouble

    public DoubleDouble(DoubleDouble dd)

  Creates a new DoubleDouble with value equal to the argument.

  Parameters:
    `dd` - the value to initialize

### DoubleDouble

    public DoubleDouble(java.lang.String str)
                 throws java.lang.NumberFormatException

  Creates a new DoubleDouble with value equal to the argument.

  Parameters:
    `str` - the value to initialize by
  Throws:
    `java.lang.NumberFormatException` - if `str` is not a valid representation of a number

Method Detail

### valueOf

    public static DoubleDouble valueOf(java.lang.String str)
                                throws java.lang.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:
    `java.lang.NumberFormatException` - if `s` is not a valid representation of a number

### valueOf

    public static DoubleDouble valueOf(double x)

  Converts the `double` argument to a DoubleDouble number.

  Parameters:
    `x` - a numeric value
  Returns:
    the extended precision version of the value

### clone

    public java.lang.Object clone()

  Creates and returns a copy of this value.

  Overrides:
    `clone` in class `java.lang.Object`
  Returns:
    a copy of this value

### add

    public DoubleDouble add(DoubleDouble y)

  Returns a DoubleDouble whose value is `(this + y)`.

  Parameters:
    `y` - the addend
  Returns:
    `(this + y)`

### subtract

    public DoubleDouble subtract(DoubleDouble y)

  Returns a DoubleDouble whose value is `(this - y)`.

  Parameters:
    `y` - the subtrahend
  Returns:
    `(this - y)`

### negate

    public DoubleDouble negate()

  Returns a DoubleDouble whose value is `-this`.

  Returns:
    `-this`

### multiply

    public DoubleDouble multiply(DoubleDouble y)

  Returns a DoubleDouble whose value is `(this * y)`.

  Parameters:
    `y` - the multiplicand
  Returns:
    `(this * y)`

### divide

    public DoubleDouble divide(DoubleDouble y)

  Returns a DoubleDouble whose value is `(this / y)`.

  Parameters:
    `y` - the divisor
  Returns:
    `(this / y)`

### reciprocal

    public DoubleDouble reciprocal()

  Returns a DoubleDouble whose value is `1 / this`.

  Returns:
    the reciprocal of this value

### floor

    public DoubleDouble 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.

### ceil

    public DoubleDouble 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.

### 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

### rint

    public DoubleDouble 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

### trunc

    public DoubleDouble 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

### abs

    public DoubleDouble 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

### sqr

    public DoubleDouble sqr()

  Computes the square of this value.

  Returns:
    the square of this value.

### sqrt

    public DoubleDouble 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.

### pow

    public DoubleDouble 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

### doubleValue

    public double doubleValue()

  Converts this value to the nearest double-precision number.

  Returns:
    the nearest double-precision number to this value

### intValue

    public int intValue()

  Converts this value to the nearest integer.

  Returns:
    the nearest integer to this value

### isZero

    public boolean isZero()

  Tests whether this value is equal to 0.

  Returns:
    true if this value is equal to 0

### 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

### isNaN

    public boolean isNaN()

  Tests whether this value is NaN.

  Returns:
    true if this value is NaN

### equals

    public boolean equals(DoubleDouble y)

  Tests whether this value is equal to another `DoubleDouble` value.

  Parameters:
    `y` - a DoubleDouble value
  Returns:
    true if this value = y

### gt

    public boolean gt(DoubleDouble y)

  Tests whether this value is greater than another `DoubleDouble` value.

  Parameters:
    `y` - a DoubleDouble value
  Returns:
    true if this value > y

### ge

    public boolean ge(DoubleDouble 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

### lt

    public boolean lt(DoubleDouble y)

  Tests whether this value is less than another `DoubleDouble` value.

  Parameters:
    `y` - a DoubleDouble value
  Returns:
    true if this value < y

### le

    public boolean le(DoubleDouble 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

### compareTo

    public int compareTo(java.lang.Object o)

  Compares two DoubleDouble objects numerically.

  Specified by:
    `compareTo` in interface `java.lang.Comparable`
  Returns:
    -1,0 or 1 depending on whether this value is less than, equal to or greater than the value of `o`

### dump

    public java.lang.String dump()

  Dumps the components of this number to a string.

  Returns:
    a string showing the components of the number

### toString

    public java.lang.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, 108 ] standard notation will be used. Otherwise, scientific notation will be used.

  Overrides:
    `toString` in class `java.lang.Object`
  Returns:
    a string representation of this number

### toStandardNotation

    public java.lang.String toStandardNotation()

  Returns the string representation of this value in standard notation.

  Returns:
    the string representation in standard notation

### toSciNotation

    public java.lang.String toSciNotation()

  Returns the string representation of this value in scientific notation.

  Returns:
    the string representation in scientific notation

### parse

    public static DoubleDouble parse(java.lang.String str)
                              throws java.lang.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:
    `java.lang.NumberFormatException` - if `str` is not a valid representation of a number

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD