Decimal64 (Apache Commons Math 3.6.1 API)

org.apache.commons.math3.util

## Class Decimal64

- java.lang.Object
- - java.lang.Number
  - - org.apache.commons.math3.util.Decimal64

- All Implemented Interfaces:
    Serializable, Comparable<Decimal64>, FieldElement<Decimal64>, RealFieldElement<Decimal64>

      public class Decimal64
      extends Number
      implements RealFieldElement<Decimal64>, Comparable<Decimal64>

  This class wraps a `double` value in an object. It is similar to the standard class `Double`, while also implementing the `RealFieldElement` interface.
  Since:
    3.1
  See Also:
    Serialized Form

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static Decimal64` | `NAN` The constant value of `Double.NaN` as a `Decimal64`.
    `static Decimal64` | `NEGATIVE_INFINITY` The constant value of `Double.NEGATIVE_INFINITY` as a `Decimal64`.
    `static Decimal64` | `ONE` The constant value of `1d` as a `Decimal64`.
    `static Decimal64` | `POSITIVE_INFINITY` The constant value of `Double.POSITIVE_INFINITY` as a `Decimal64`.
    `static Decimal64` | `ZERO` The constant value of `0d` as a `Decimal64`.

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `Decimal64(double x)` Creates a new instance of this class.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `Decimal64` | `abs()` absolute value.
    `Decimal64` | `acos()` Arc cosine operation.
    `Decimal64` | `acosh()` Inverse hyperbolic cosine operation.
    `Decimal64` | `add(Decimal64 a)` Compute this + a.
    `Decimal64` | `add(double a)` '+' operator.
    `Decimal64` | `asin()` Arc sine operation.
    `Decimal64` | `asinh()` Inverse hyperbolic sine operation.
    `Decimal64` | `atan()` Arc tangent operation.
    `Decimal64` | `atan2(Decimal64 x)` Two arguments arc tangent operation.
    `Decimal64` | `atanh()` Inverse hyperbolic tangent operation.
    `byte` | `byteValue()` The current implementation performs casting to a `byte`.
    `Decimal64` | `cbrt()` Cubic root.
    `Decimal64` | `ceil()` Get the smallest whole number larger than instance.
    `int` | `compareTo(Decimal64 o)` The current implementation returns the same value as `new Double(this.doubleValue()).compareTo(new Double(o.doubleValue()))`
    `Decimal64` | `copySign(Decimal64 sign)` Returns the instance with the sign of the argument.
    `Decimal64` | `copySign(double sign)` Returns the instance with the sign of the argument.
    `Decimal64` | `cos()` Cosine operation.
    `Decimal64` | `cosh()` Hyperbolic cosine operation.
    `Decimal64` | `divide(Decimal64 a)` Compute this ÷ a.
    `Decimal64` | `divide(double a)` '÷' operator.
    `double` | `doubleValue()`
    `boolean` | `equals(Object obj)`
    `Decimal64` | `exp()` Exponential.
    `Decimal64` | `expm1()` Exponential minus 1.
    `float` | `floatValue()` The current implementation performs casting to a `float`.
    `Decimal64` | `floor()` Get the largest whole number smaller than instance.
    `Field<Decimal64>` | `getField()` Get the `Field` to which the instance belongs.
    `double` | `getReal()` Get the real value of the number.
    `int` | `hashCode()` The current implementation returns the same value as `new Double(this.doubleValue()).hashCode()`
    `Decimal64` | `hypot(Decimal64 y)` Returns the hypotenuse of a triangle with sides `this` and `y` - sqrt(this2 +y2) avoiding intermediate overflow or underflow.
    `int` | `intValue()` The current implementation performs casting to a `int`.
    `boolean` | `isInfinite()` Returns `true` if `this` double precision number is infinite (`Double.POSITIVE_INFINITY` or `Double.NEGATIVE_INFINITY`).
    `boolean` | `isNaN()` Returns `true` if `this` double precision number is Not-a-Number (`NaN`), false otherwise.
    `Decimal64` | `linearCombination(Decimal64[] a, Decimal64[] b)` Compute a linear combination.
    `Decimal64` | `linearCombination(Decimal64 a1, Decimal64 b1, Decimal64 a2, Decimal64 b2)` Compute a linear combination.
    `Decimal64` | `linearCombination(Decimal64 a1, Decimal64 b1, Decimal64 a2, Decimal64 b2, Decimal64 a3, Decimal64 b3)` Compute a linear combination.
    `Decimal64` | `linearCombination(Decimal64 a1, Decimal64 b1, Decimal64 a2, Decimal64 b2, Decimal64 a3, Decimal64 b3, Decimal64 a4, Decimal64 b4)` Compute a linear combination.
    `Decimal64` | `linearCombination(double[] a, Decimal64[] b)` Compute a linear combination.
    `Decimal64` | `linearCombination(double a1, Decimal64 b1, double a2, Decimal64 b2)` Compute a linear combination.
    `Decimal64` | `linearCombination(double a1, Decimal64 b1, double a2, Decimal64 b2, double a3, Decimal64 b3)` Compute a linear combination.
    `Decimal64` | `linearCombination(double a1, Decimal64 b1, double a2, Decimal64 b2, double a3, Decimal64 b3, double a4, Decimal64 b4)` Compute a linear combination.
    `Decimal64` | `log()` Natural logarithm.
    `Decimal64` | `log10()` Base 10 logarithm.
    `Decimal64` | `log1p()` Shifted natural logarithm.
    `long` | `longValue()` The current implementation performs casting to a `long`.
    `Decimal64` | `multiply(Decimal64 a)` Compute this × a.
    `Decimal64` | `multiply(double a)` '×' operator.
    `Decimal64` | `multiply(int n)` Compute n × this.
    `Decimal64` | `negate()` Returns the additive inverse of `this` element.
    `Decimal64` | `pow(Decimal64 e)` Power operation.
    `Decimal64` | `pow(double p)` Power operation.
    `Decimal64` | `pow(int n)` Integer power operation.
    `Decimal64` | `reciprocal()` Returns the multiplicative inverse of `this` element.
    `Decimal64` | `remainder(Decimal64 a)` IEEE remainder operator.
    `Decimal64` | `remainder(double a)` IEEE remainder operator.
    `Decimal64` | `rint()` Get the whole number that is the nearest to the instance, or the even one if x is exactly half way between two integers.
    `Decimal64` | `rootN(int n)` Nth root.
    `long` | `round()` Get the closest long to instance value.
    `Decimal64` | `scalb(int n)` Multiply the instance by a power of 2.
    `short` | `shortValue()` The current implementation performs casting to a `short`.
    `Decimal64` | `signum()` Compute the signum of the instance.
    `Decimal64` | `sin()` Sine operation.
    `Decimal64` | `sinh()` Hyperbolic sine operation.
    `Decimal64` | `sqrt()` Square root.
    `Decimal64` | `subtract(Decimal64 a)` Compute this - a.
    `Decimal64` | `subtract(double a)` '-' operator.
    `Decimal64` | `tan()` Tangent operation.
    `Decimal64` | `tanh()` Hyperbolic tangent operation.
    `String` | `toString()` The returned `String` is equal to `Double.toString(this.doubleValue())`

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### Field Detail

    - #### ZERO

          public static final Decimal64 ZERO

      The constant value of `0d` as a `Decimal64`.

    - #### ONE

          public static final Decimal64 ONE

      The constant value of `1d` as a `Decimal64`.

    - #### NEGATIVE_INFINITY

          public static final Decimal64 NEGATIVE_INFINITY

      The constant value of `Double.NEGATIVE_INFINITY` as a `Decimal64`.

    - #### POSITIVE_INFINITY

          public static final Decimal64 POSITIVE_INFINITY

      The constant value of `Double.POSITIVE_INFINITY` as a `Decimal64`.

    - #### NAN

          public static final Decimal64 NAN

      The constant value of `Double.NaN` as a `Decimal64`.

  - ### Constructor Detail

    - #### Decimal64

          public Decimal64(double x)

      Creates a new instance of this class.
      Parameters:
        `x` - the primitive `double` value of the object to be created

  - ### Method Detail

    - #### getField

          public Field<Decimal64> getField()

      Get the `Field` to which the instance belongs.
      Specified by:
        `getField` in interface `FieldElement<Decimal64>`
      Returns:
        `Field` to which the instance belongs

    - #### add

          public Decimal64 add(Decimal64 a)

      Compute this + a. The current implementation strictly enforces `this.add(a).equals(new Decimal64(this.doubleValue() + a.doubleValue()))`.
      Specified by:
        `add` in interface `FieldElement<Decimal64>`
      Parameters:
        `a` - element to add
      Returns:
        a new element representing this + a

    - #### subtract

          public Decimal64 subtract(Decimal64 a)

      Compute this - a. The current implementation strictly enforces `this.subtract(a).equals(new Decimal64(this.doubleValue() - a.doubleValue()))`.
      Specified by:
        `subtract` in interface `FieldElement<Decimal64>`
      Parameters:
        `a` - element to subtract
      Returns:
        a new element representing this - a

    - #### negate

          public Decimal64 negate()

      Returns the additive inverse of `this` element. The current implementation strictly enforces `this.negate().equals(new Decimal64(-this.doubleValue()))`.
      Specified by:
        `negate` in interface `FieldElement<Decimal64>`
      Returns:
        the opposite of `this`.

    - #### multiply

          public Decimal64 multiply(Decimal64 a)

      Compute this × a. The current implementation strictly enforces `this.multiply(a).equals(new Decimal64(this.doubleValue() * a.doubleValue()))`.
      Specified by:
        `multiply` in interface `FieldElement<Decimal64>`
      Parameters:
        `a` - element to multiply
      Returns:
        a new element representing this × a

    - #### multiply

          public Decimal64 multiply(int n)

      Compute n × this. Multiplication by an integer number is defined as the following sum
      n × this = ∑i=1n this.
      The current implementation strictly enforces `this.multiply(n).equals(new Decimal64(n * this.doubleValue()))`.
      Specified by:
        `multiply` in interface `FieldElement<Decimal64>`
      Parameters:
        `n` - Number of times `this` must be added to itself.
      Returns:
        A new element representing n × this.

    - #### divide

          public Decimal64 divide(Decimal64 a)

      Compute this ÷ a. The current implementation strictly enforces `this.divide(a).equals(new Decimal64(this.doubleValue() / a.doubleValue()))`.
      Specified by:
        `divide` in interface `FieldElement<Decimal64>`
      Parameters:
        `a` - element to divide by
      Returns:
        a new element representing this ÷ a

    - #### reciprocal

          public Decimal64 reciprocal()

      Returns the multiplicative inverse of `this` element. The current implementation strictly enforces `this.reciprocal().equals(new Decimal64(1.0 / this.doubleValue()))`.
      Specified by:
        `reciprocal` in interface `FieldElement<Decimal64>`
      Specified by:
        `reciprocal` in interface `RealFieldElement<Decimal64>`
      Returns:
        the inverse of `this`.

    - #### byteValue

          public byte byteValue()

      The current implementation performs casting to a `byte`.
      Overrides:
        `byteValue` in class `Number`

    - #### shortValue

          public short shortValue()

      The current implementation performs casting to a `short`.
      Overrides:
        `shortValue` in class `Number`

    - #### intValue

          public int intValue()

      The current implementation performs casting to a `int`.
      Specified by:
        `intValue` in class `Number`

    - #### longValue

          public long longValue()

      The current implementation performs casting to a `long`.
      Specified by:
        `longValue` in class `Number`

    - #### floatValue

          public float floatValue()

      The current implementation performs casting to a `float`.
      Specified by:
        `floatValue` in class `Number`

    - #### doubleValue

          public double doubleValue()

      Specified by:
        `doubleValue` in class `Number`

    - #### compareTo

          public int compareTo(Decimal64 o)

      The current implementation returns the same value as
      `new Double(this.doubleValue()).compareTo(new Double(o.doubleValue()))`
      Specified by:
        `compareTo` in interface `Comparable<Decimal64>`
      See Also:
        `Double.compareTo(Double)`

    - #### equals

          public boolean equals(Object obj)

      Overrides:
        `equals` in class `Object`

    - #### hashCode

          public int hashCode()

      The current implementation returns the same value as `new Double(this.doubleValue()).hashCode()`
      Overrides:
        `hashCode` in class `Object`
      See Also:
        `Double.hashCode()`

    - #### toString

          public String toString()

      The returned `String` is equal to `Double.toString(this.doubleValue())`
      Overrides:
        `toString` in class `Object`
      See Also:
        `Double.toString(double)`

    - #### isInfinite

          public boolean isInfinite()

      Returns `true` if `this` double precision number is infinite (`Double.POSITIVE_INFINITY` or `Double.NEGATIVE_INFINITY`).
      Returns:
        `true` if `this` number is infinite

    - #### isNaN

          public boolean isNaN()

      Returns `true` if `this` double precision number is Not-a-Number (`NaN`), false otherwise.
      Returns:
        `true` if `this` is `NaN`

    - #### getReal

          public double getReal()

      Get the real value of the number.
      Specified by:
        `getReal` in interface `RealFieldElement<Decimal64>`
      Returns:
        real value
      Since:
        3.2

    - #### add

          public Decimal64 add(double a)

      '+' operator.
      Specified by:
        `add` in interface `RealFieldElement<Decimal64>`
      Parameters:
        `a` - right hand side parameter of the operator
      Returns:
        this+a
      Since:
        3.2

    - #### subtract

          public Decimal64 subtract(double a)

      '-' operator.
      Specified by:
        `subtract` in interface `RealFieldElement<Decimal64>`
      Parameters:
        `a` - right hand side parameter of the operator
      Returns:
        this-a
      Since:
        3.2

    - #### multiply

          public Decimal64 multiply(double a)

      '×' operator.
      Specified by:
        `multiply` in interface `RealFieldElement<Decimal64>`
      Parameters:
        `a` - right hand side parameter of the operator
      Returns:
        this×a
      Since:
        3.2

    - #### divide

          public Decimal64 divide(double a)

      '÷' operator.
      Specified by:
        `divide` in interface `RealFieldElement<Decimal64>`
      Parameters:
        `a` - right hand side parameter of the operator
      Returns:
        this÷a
      Since:
        3.2

    - #### remainder

          public Decimal64 remainder(double a)

      IEEE remainder operator.
      Specified by:
        `remainder` in interface `RealFieldElement<Decimal64>`
      Parameters:
        `a` - right hand side parameter of the operator
      Returns:
        this - n × a where n is the closest integer to this/a (the even integer is chosen for n if this/a is halfway between two integers)
      Since:
        3.2

    - #### remainder

          public Decimal64 remainder(Decimal64 a)

      IEEE remainder operator.
      Specified by:
        `remainder` in interface `RealFieldElement<Decimal64>`
      Parameters:
        `a` - right hand side parameter of the operator
      Returns:
        this - n × a where n is the closest integer to this/a (the even integer is chosen for n if this/a is halfway between two integers)
      Since:
        3.2

    - #### abs

          public Decimal64 abs()

      absolute value.
      Specified by:
        `abs` in interface `RealFieldElement<Decimal64>`
      Returns:
        abs(this)
      Since:
        3.2

    - #### ceil

          public Decimal64 ceil()

      Get the smallest whole number larger than instance.
      Specified by:
        `ceil` in interface `RealFieldElement<Decimal64>`
      Returns:
        ceil(this)
      Since:
        3.2

    - #### floor

          public Decimal64 floor()

      Get the largest whole number smaller than instance.
      Specified by:
        `floor` in interface `RealFieldElement<Decimal64>`
      Returns:
        floor(this)
      Since:
        3.2

    - #### rint

          public Decimal64 rint()

      Get the whole number that is the nearest to the instance, or the even one if x is exactly half way between two integers.
      Specified by:
        `rint` in interface `RealFieldElement<Decimal64>`
      Returns:
        a double number r such that r is an integer r - 0.5 ≤ this ≤ r + 0.5
      Since:
        3.2

    - #### round

          public long round()

      Get the closest long to instance value.
      Specified by:
        `round` in interface `RealFieldElement<Decimal64>`
      Returns:
        closest long to `RealFieldElement.getReal()`
      Since:
        3.2

    - #### signum

          public Decimal64 signum()

      Compute the signum of the instance. The signum is -1 for negative numbers, +1 for positive numbers and 0 otherwise
      Specified by:
        `signum` in interface `RealFieldElement<Decimal64>`
      Returns:
        -1.0, -0.0, +0.0, +1.0 or NaN depending on sign of a
      Since:
        3.2

    - #### copySign

          public Decimal64 copySign(Decimal64 sign)

      Returns the instance with the sign of the argument. A NaN `sign` argument is treated as positive.
      Specified by:
        `copySign` in interface `RealFieldElement<Decimal64>`
      Parameters:
        `sign` - the sign for the returned value
      Returns:
        the instance with the same sign as the `sign` argument
      Since:
        3.2

    - #### copySign

          public Decimal64 copySign(double sign)

      Returns the instance with the sign of the argument. A NaN `sign` argument is treated as positive.
      Specified by:
        `copySign` in interface `RealFieldElement<Decimal64>`
      Parameters:
        `sign` - the sign for the returned value
      Returns:
        the instance with the same sign as the `sign` argument
      Since:
        3.2

    - #### scalb

          public Decimal64 scalb(int n)

      Multiply the instance by a power of 2.
      Specified by:
        `scalb` in interface `RealFieldElement<Decimal64>`
      Parameters:
        `n` - power of 2
      Returns:
        this × 2n
      Since:
        3.2

    - #### hypot

          public Decimal64 hypot(Decimal64 y)

      Returns the hypotenuse of a triangle with sides `this` and `y` - sqrt(this2 +y2) avoiding intermediate overflow or underflow.
      - If either argument is infinite, then the result is positive infinity.
      - else, if either argument is NaN then the result is NaN.
      Specified by:
        `hypot` in interface `RealFieldElement<Decimal64>`
      Parameters:
        `y` - a value
      Returns:
        sqrt(this2 +y2)
      Since:
        3.2

    - #### sqrt

          public Decimal64 sqrt()

      Square root.
      Specified by:
        `sqrt` in interface `RealFieldElement<Decimal64>`
      Returns:
        square root of the instance
      Since:
        3.2

    - #### cbrt

          public Decimal64 cbrt()

      Cubic root.
      Specified by:
        `cbrt` in interface `RealFieldElement<Decimal64>`
      Returns:
        cubic root of the instance
      Since:
        3.2

    - #### rootN

          public Decimal64 rootN(int n)

      Nth root.
      Specified by:
        `rootN` in interface `RealFieldElement<Decimal64>`
      Parameters:
        `n` - order of the root
      Returns:
        nth root of the instance
      Since:
        3.2

    - #### pow

          public Decimal64 pow(double p)

      Power operation.
      Specified by:
        `pow` in interface `RealFieldElement<Decimal64>`
      Parameters:
        `p` - power to apply
      Returns:
        thisp
      Since:
        3.2

    - #### pow

          public Decimal64 pow(int n)

      Integer power operation.
      Specified by:
        `pow` in interface `RealFieldElement<Decimal64>`
      Parameters:
        `n` - power to apply
      Returns:
        thisn
      Since:
        3.2

    - #### pow

          public Decimal64 pow(Decimal64 e)

      Power operation.
      Specified by:
        `pow` in interface `RealFieldElement<Decimal64>`
      Parameters:
        `e` - exponent
      Returns:
        thise
      Since:
        3.2

    - #### exp

          public Decimal64 exp()

      Exponential.
      Specified by:
        `exp` in interface `RealFieldElement<Decimal64>`
      Returns:
        exponential of the instance
      Since:
        3.2

    - #### expm1

          public Decimal64 expm1()

      Exponential minus 1.
      Specified by:
        `expm1` in interface `RealFieldElement<Decimal64>`
      Returns:
        exponential minus one of the instance
      Since:
        3.2

    - #### log

          public Decimal64 log()

      Natural logarithm.
      Specified by:
        `log` in interface `RealFieldElement<Decimal64>`
      Returns:
        logarithm of the instance
      Since:
        3.2

    - #### log1p

          public Decimal64 log1p()

      Shifted natural logarithm.
      Specified by:
        `log1p` in interface `RealFieldElement<Decimal64>`
      Returns:
        logarithm of one plus the instance
      Since:
        3.2

    - #### log10

          public Decimal64 log10()

      Base 10 logarithm.
      Returns:
        base 10 logarithm of the instance
      Since:
        3.2

    - #### cos

          public Decimal64 cos()

      Cosine operation.
      Specified by:
        `cos` in interface `RealFieldElement<Decimal64>`
      Returns:
        cos(this)
      Since:
        3.2

    - #### sin

          public Decimal64 sin()

      Sine operation.
      Specified by:
        `sin` in interface `RealFieldElement<Decimal64>`
      Returns:
        sin(this)
      Since:
        3.2

    - #### tan

          public Decimal64 tan()

      Tangent operation.
      Specified by:
        `tan` in interface `RealFieldElement<Decimal64>`
      Returns:
        tan(this)
      Since:
        3.2

    - #### acos

          public Decimal64 acos()

      Arc cosine operation.
      Specified by:
        `acos` in interface `RealFieldElement<Decimal64>`
      Returns:
        acos(this)
      Since:
        3.2

    - #### asin

          public Decimal64 asin()

      Arc sine operation.
      Specified by:
        `asin` in interface `RealFieldElement<Decimal64>`
      Returns:
        asin(this)
      Since:
        3.2

    - #### atan

          public Decimal64 atan()

      Arc tangent operation.
      Specified by:
        `atan` in interface `RealFieldElement<Decimal64>`
      Returns:
        atan(this)
      Since:
        3.2

    - #### atan2

          public Decimal64 atan2(Decimal64 x)

      Two arguments arc tangent operation.
      Specified by:
        `atan2` in interface `RealFieldElement<Decimal64>`
      Parameters:
        `x` - second argument of the arc tangent
      Returns:
        atan2(this, x)
      Since:
        3.2

    - #### cosh

          public Decimal64 cosh()

      Hyperbolic cosine operation.
      Specified by:
        `cosh` in interface `RealFieldElement<Decimal64>`
      Returns:
        cosh(this)
      Since:
        3.2

    - #### sinh

          public Decimal64 sinh()

      Hyperbolic sine operation.
      Specified by:
        `sinh` in interface `RealFieldElement<Decimal64>`
      Returns:
        sinh(this)
      Since:
        3.2

    - #### tanh

          public Decimal64 tanh()

      Hyperbolic tangent operation.
      Specified by:
        `tanh` in interface `RealFieldElement<Decimal64>`
      Returns:
        tanh(this)
      Since:
        3.2

    - #### acosh

          public Decimal64 acosh()

      Inverse hyperbolic cosine operation.
      Specified by:
        `acosh` in interface `RealFieldElement<Decimal64>`
      Returns:
        acosh(this)
      Since:
        3.2

    - #### asinh

          public Decimal64 asinh()

      Inverse hyperbolic sine operation.
      Specified by:
        `asinh` in interface `RealFieldElement<Decimal64>`
      Returns:
        asin(this)
      Since:
        3.2

    - #### atanh

          public Decimal64 atanh()

      Inverse hyperbolic tangent operation.
      Specified by:
        `atanh` in interface `RealFieldElement<Decimal64>`
      Returns:
        atanh(this)
      Since:
        3.2

    - #### linearCombination

          public Decimal64 linearCombination(Decimal64[] a,
                                    Decimal64[] b)
                                      throws DimensionMismatchException

      Compute a linear combination.
      Specified by:
        `linearCombination` in interface `RealFieldElement<Decimal64>`
      Parameters:
        `a` - Factors.
        `b` - Factors.
      Returns:
        `Σi ai bi`.
      Throws:
        `DimensionMismatchException` - if arrays dimensions don't match
      Since:
        3.2

    - #### linearCombination

          public Decimal64 linearCombination(double[] a,
                                    Decimal64[] b)
                                      throws DimensionMismatchException

      Compute a linear combination.
      Specified by:
        `linearCombination` in interface `RealFieldElement<Decimal64>`
      Parameters:
        `a` - Factors.
        `b` - Factors.
      Returns:
        `Σi ai bi`.
      Throws:
        `DimensionMismatchException` - if arrays dimensions don't match
      Since:
        3.2

    - #### linearCombination

          public Decimal64 linearCombination(Decimal64 a1,
                                    Decimal64 b1,
                                    Decimal64 a2,
                                    Decimal64 b2)

      Compute a linear combination.
      Specified by:
        `linearCombination` in interface `RealFieldElement<Decimal64>`
      Parameters:
        `a1` - first factor of the first term
        `b1` - second factor of the first term
        `a2` - first factor of the second term
        `b2` - second factor of the second term
      Returns:
        a1×b1 + a2×b2
      Since:
        3.2
      See Also:
        `RealFieldElement.linearCombination(Object, Object, Object, Object, Object, Object)`, `RealFieldElement.linearCombination(Object, Object, Object, Object, Object, Object, Object, Object)`

    - #### linearCombination

          public Decimal64 linearCombination(double a1,
                                    Decimal64 b1,
                                    double a2,
                                    Decimal64 b2)

      Compute a linear combination.
      Specified by:
        `linearCombination` in interface `RealFieldElement<Decimal64>`
      Parameters:
        `a1` - first factor of the first term
        `b1` - second factor of the first term
        `a2` - first factor of the second term
        `b2` - second factor of the second term
      Returns:
        a1×b1 + a2×b2
      Since:
        3.2
      See Also:
        `RealFieldElement.linearCombination(double, Object, double, Object, double, Object)`, `RealFieldElement.linearCombination(double, Object, double, Object, double, Object, double, Object)`

    - #### linearCombination

          public Decimal64 linearCombination(Decimal64 a1,
                                    Decimal64 b1,
                                    Decimal64 a2,
                                    Decimal64 b2,
                                    Decimal64 a3,
                                    Decimal64 b3)

      Compute a linear combination.
      Specified by:
        `linearCombination` in interface `RealFieldElement<Decimal64>`
      Parameters:
        `a1` - first factor of the first term
        `b1` - second factor of the first term
        `a2` - first factor of the second term
        `b2` - second factor of the second term
        `a3` - first factor of the third term
        `b3` - second factor of the third term
      Returns:
        a1×b1 + a2×b2 + a3×b3
      Since:
        3.2
      See Also:
        `RealFieldElement.linearCombination(Object, Object, Object, Object)`, `RealFieldElement.linearCombination(Object, Object, Object, Object, Object, Object, Object, Object)`

    - #### linearCombination

          public Decimal64 linearCombination(double a1,
                                    Decimal64 b1,
                                    double a2,
                                    Decimal64 b2,
                                    double a3,
                                    Decimal64 b3)

      Compute a linear combination.
      Specified by:
        `linearCombination` in interface `RealFieldElement<Decimal64>`
      Parameters:
        `a1` - first factor of the first term
        `b1` - second factor of the first term
        `a2` - first factor of the second term
        `b2` - second factor of the second term
        `a3` - first factor of the third term
        `b3` - second factor of the third term
      Returns:
        a1×b1 + a2×b2 + a3×b3
      Since:
        3.2
      See Also:
        `RealFieldElement.linearCombination(double, Object, double, Object)`, `RealFieldElement.linearCombination(double, Object, double, Object, double, Object, double, Object)`

    - #### linearCombination

          public Decimal64 linearCombination(Decimal64 a1,
                                    Decimal64 b1,
                                    Decimal64 a2,
                                    Decimal64 b2,
                                    Decimal64 a3,
                                    Decimal64 b3,
                                    Decimal64 a4,
                                    Decimal64 b4)

      Compute a linear combination.
      Specified by:
        `linearCombination` in interface `RealFieldElement<Decimal64>`
      Parameters:
        `a1` - first factor of the first term
        `b1` - second factor of the first term
        `a2` - first factor of the second term
        `b2` - second factor of the second term
        `a3` - first factor of the third term
        `b3` - second factor of the third term
        `a4` - first factor of the third term
        `b4` - second factor of the third term
      Returns:
        a1×b1 + a2×b2 + a3×b3 + a4×b4
      Since:
        3.2
      See Also:
        `RealFieldElement.linearCombination(Object, Object, Object, Object)`, `RealFieldElement.linearCombination(Object, Object, Object, Object, Object, Object)`

    - #### linearCombination

          public Decimal64 linearCombination(double a1,
                                    Decimal64 b1,
                                    double a2,
                                    Decimal64 b2,
                                    double a3,
                                    Decimal64 b3,
                                    double a4,
                                    Decimal64 b4)

      Compute a linear combination.
      Specified by:
        `linearCombination` in interface `RealFieldElement<Decimal64>`
      Parameters:
        `a1` - first factor of the first term
        `b1` - second factor of the first term
        `a2` - first factor of the second term
        `b2` - second factor of the second term
        `a3` - first factor of the third term
        `b3` - second factor of the third term
        `a4` - first factor of the third term
        `b4` - second factor of the third term
      Returns:
        a1×b1 + a2×b2 + a3×b3 + a4×b4
      Since:
        3.2
      See Also:
        `RealFieldElement.linearCombination(double, Object, double, Object)`, `RealFieldElement.linearCombination(double, Object, double, Object, double, Object)`

Copyright © 2003–2016 The Apache Software Foundation. All rights reserved.