Package 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
Description
`static final Decimal64`
`NAN`
The constant value of `Double.NaN` as a `Decimal64`.
`static final Decimal64`
`NEGATIVE_INFINITY`
The constant value of `Double.NEGATIVE_INFINITY` as a `Decimal64`.
`static final Decimal64`
`ONE`
The constant value of `1d` as a `Decimal64`.
`static final Decimal64`
`POSITIVE_INFINITY`
The constant value of `Double.POSITIVE_INFINITY` as a `Decimal64`.
`static final Decimal64`
`ZERO`
The constant value of `0d` as a `Decimal64`.

## Constructor Summary

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

## Method Summary

Modifier and Type
Method
Description
`Decimal64`
`abs()`
absolute value.
`Decimal64`
`acos()`
Arc cosine operation.
`Decimal64`
`acosh()`
Inverse hyperbolic cosine operation.
`Decimal64`
`add(double a)`
'+' operator.
`Decimal64`
`add(Decimal64 a)`
Compute this + a.
`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(double sign)`
Returns the instance with the sign of the argument.
`Decimal64`
`copySign(Decimal64 sign)`
Returns the instance with the sign of the argument.
`Decimal64`
`cos()`
Cosine operation.
`Decimal64`
`cosh()`
Hyperbolic cosine operation.
`Decimal64`
`divide(double a)`
'÷' operator.
`Decimal64`
`divide(Decimal64 a)`
Compute this ÷ a.
`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(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`
`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`
`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(double a)`
'×' operator.
`Decimal64`
`multiply(int n)`
Compute n × this.
`Decimal64`
`multiply(Decimal64 a)`
Compute this × a.
`Decimal64`
`negate()`
Returns the additive inverse of `this` element.
`Decimal64`
`pow(double p)`
Power operation.
`Decimal64`
`pow(int n)`
Integer power operation.
`Decimal64`
`pow(Decimal64 e)`
Power operation.
`Decimal64`
`reciprocal()`
Returns the multiplicative inverse of `this` element.
`Decimal64`
`remainder(double a)`
IEEE remainder operator.
`Decimal64`
`remainder(Decimal64 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(double a)`
'-' operator.
`Decimal64`
`subtract(Decimal64 a)`
Compute this - a.
`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 Details

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

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

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