RealFieldElement (Apache Commons Math 4.0-SNAPSHOT API)

Type Parameters:
T - the type of the field elements

All Superinterfaces:

FieldElement<T>

All Known Implementing Classes:

Decimal64, DerivativeStructure, Dfp, DfpDec, SparseGradient
```
public interface RealFieldElement<T>
extends FieldElement<T>
```
Interface representing a real field.

Since:

3.2

See Also:
FieldElement

Method Summary

Methods
Modifier and Type	Method and Description
`T`	`abs()` absolute value.
`T`	`acos()` Arc cosine operation.
`T`	`acosh()` Inverse hyperbolic cosine operation.
`T`	`add(double a)` '+' operator.
`T`	`asin()` Arc sine operation.
`T`	`asinh()` Inverse hyperbolic sine operation.
`T`	`atan()` Arc tangent operation.
`T`	`atan2(T x)` Two arguments arc tangent operation.
`T`	`atanh()` Inverse hyperbolic tangent operation.
`T`	`cbrt()` Cubic root.
`T`	`ceil()` Get the smallest whole number larger than instance.
`T`	`copySign(double sign)` Returns the instance with the sign of the argument.
`T`	`copySign(T sign)` Returns the instance with the sign of the argument.
`T`	`cos()` Cosine operation.
`T`	`cosh()` Hyperbolic cosine operation.
`T`	`divide(double a)` '÷' operator.
`T`	`exp()` Exponential.
`T`	`expm1()` Exponential minus 1.
`T`	`floor()` Get the largest whole number smaller than instance.
`double`	`getReal()` Get the real value of the number.
`T`	`hypot(T y)` Returns the hypotenuse of a triangle with sides `this` and `y` - sqrt(this² +y²) avoiding intermediate overflow or underflow.
`T`	`linearCombination(double[] a, T[] b)` Compute a linear combination.
`T`	`linearCombination(double a1, T b1, double a2, T b2)` Compute a linear combination.
`T`	`linearCombination(double a1, T b1, double a2, T b2, double a3, T b3)` Compute a linear combination.
`T`	`linearCombination(double a1, T b1, double a2, T b2, double a3, T b3, double a4, T b4)` Compute a linear combination.
`T`	`linearCombination(T[] a, T[] b)` Compute a linear combination.
`T`	`linearCombination(T a1, T b1, T a2, T b2)` Compute a linear combination.
`T`	`linearCombination(T a1, T b1, T a2, T b2, T a3, T b3)` Compute a linear combination.
`T`	`linearCombination(T a1, T b1, T a2, T b2, T a3, T b3, T a4, T b4)` Compute a linear combination.
`T`	`log()` Natural logarithm.
`T`	`log10()` Base 10 logarithm.
`T`	`log1p()` Shifted natural logarithm.
`T`	`multiply(double a)` '×' operator.
`T`	`pow(double p)` Power operation.
`T`	`pow(int n)` Integer power operation.
`T`	`pow(T e)` Power operation.
`T`	`reciprocal()` Returns the multiplicative inverse of `this` element.
`T`	`remainder(double a)` IEEE remainder operator.
`T`	`remainder(T a)` IEEE remainder operator.
`T`	`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.
`T`	`rootN(int n)` N^th root.
`long`	`round()` Get the closest long to instance value.
`T`	`scalb(int n)` Multiply the instance by a power of 2.
`T`	`signum()` Compute the signum of the instance.
`T`	`sin()` Sine operation.
`T`	`sinh()` Hyperbolic sine operation.
`T`	`sqrt()` Square root.
`T`	`subtract(double a)` '-' operator.
`T`	`tan()` Tangent operation.
`T`	`tanh()` Hyperbolic tangent operation.

Methods inherited from interface org.apache.commons.math4.FieldElement
add, divide, getField, multiply, multiply, negate, subtract

- Method Detail
  - getReal
```
double getReal()
```
    Get the real value of the number.
    
    Returns:
    real value
  - add
```
T add(double a)
```
    '+' operator.
    
    Parameters:
    a - right hand side parameter of the operator
    
    Returns:
    this+a
  - subtract
```
T subtract(double a)
```
    '-' operator.
    
    Parameters:
    a - right hand side parameter of the operator
    
    Returns:
    this-a
  - multiply
```
T multiply(double a)
```
    '×' operator.
    
    Parameters:
    a - right hand side parameter of the operator
    
    Returns:
    this×a
  - divide
```
T divide(double a)
```
    '÷' operator.
    
    Parameters:
    a - right hand side parameter of the operator
    
    Returns:
    this÷s;a
  - remainder
```
T remainder(double a)
```
    IEEE remainder operator.
    
    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)
  - remainder
```
T remainder(T a)
            throws DimensionMismatchException
```
    IEEE remainder operator.
    
    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)
    
    Throws:
    
    DimensionMismatchException - if number of free parameters or orders are inconsistent
  - abs
```
T abs()
```
    absolute value.
    
    Returns:
    abs(this)
  - ceil
```
T ceil()
```
    Get the smallest whole number larger than instance.
    
    Returns:
    ceil(this)
  - floor
```
T floor()
```
    Get the largest whole number smaller than instance.
    
    Returns:
    floor(this)
  - rint
```
T 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.
    
    Returns:
    a double number r such that r is an integer r - 0.5 <= this <= r + 0.5
  - round
```
long round()
```
    Get the closest long to instance value.
    
    Returns:
    closest long to getReal()
  - signum
```
T signum()
```
    Compute the signum of the instance. The signum is -1 for negative numbers, +1 for positive numbers and 0 otherwise
    
    Returns:
    -1.0, -0.0, +0.0, +1.0 or NaN depending on sign of a
  - copySign
```
T copySign(T sign)
```
    Returns the instance with the sign of the argument. A NaN sign argument is treated as positive.
    
    Parameters:
    sign - the sign for the returned value
    
    Returns:
    the instance with the same sign as the sign argument
  - copySign
```
T copySign(double sign)
```
    Returns the instance with the sign of the argument. A NaN sign argument is treated as positive.
    
    Parameters:
    sign - the sign for the returned value
    
    Returns:
    the instance with the same sign as the sign argument
  - scalb
```
T scalb(int n)
```
    Multiply the instance by a power of 2.
    
    Parameters:
    n - power of 2
    
    Returns:
    this × 2ⁿ
  - hypot
```
T hypot(T y)
        throws DimensionMismatchException
```
    Returns the hypotenuse of a triangle with sides this and y - sqrt(this² +y²)
    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.
    Parameters:
    y - a value
    
    Returns:
    sqrt(this² +y²)
    
    Throws:
    
    DimensionMismatchException - if number of free parameters or orders are inconsistent
  - reciprocal
```
T reciprocal()
```
    Returns the multiplicative inverse of this element.
    
    Specified by:
    
    reciprocal in interface FieldElement<T>
    
    Returns:
    the inverse of this.
  - sqrt
```
T sqrt()
```
    Square root.
    
    Returns:
    square root of the instance
  - cbrt
```
T cbrt()
```
    Cubic root.
    
    Returns:
    cubic root of the instance
  - rootN
```
T rootN(int n)
```
    N^th root.
    
    Parameters:
    n - order of the root
    
    Returns:
    n^th root of the instance
  - pow
```
T pow(double p)
```
    Power operation.
    
    Parameters:
    p - power to apply
    
    Returns:
    this^p
  - pow
```
T pow(int n)
```
    Integer power operation.
    
    Parameters:
    n - power to apply
    
    Returns:
    thisⁿ
  - pow
```
T pow(T e)
      throws DimensionMismatchException
```
    Power operation.
    
    Parameters:
    e - exponent
    
    Returns:
    this^e
    
    Throws:
    
    DimensionMismatchException - if number of free parameters or orders are inconsistent
  - exp
```
T exp()
```
    Exponential.
    
    Returns:
    exponential of the instance
  - expm1
```
T expm1()
```
    Exponential minus 1.
    
    Returns:
    exponential minus one of the instance
  - log
```
T log()
```
    Natural logarithm.
    
    Returns:
    logarithm of the instance
  - log1p
```
T log1p()
```
    Shifted natural logarithm.
    
    Returns:
    logarithm of one plus the instance
  - log10
```
T log10()
```
    Base 10 logarithm.
    
    Returns:
    base 10 logarithm of the instance
    Since:
    
    4.0
  - cos
```
T cos()
```
    Cosine operation.
    
    Returns:
    cos(this)
  - sin
```
T sin()
```
    Sine operation.
    
    Returns:
    sin(this)
  - tan
```
T tan()
```
    Tangent operation.
    
    Returns:
    tan(this)
  - acos
```
T acos()
```
    Arc cosine operation.
    
    Returns:
    acos(this)
  - asin
```
T asin()
```
    Arc sine operation.
    
    Returns:
    asin(this)
  - atan
```
T atan()
```
    Arc tangent operation.
    
    Returns:
    atan(this)
  - atan2
```
T atan2(T x)
        throws DimensionMismatchException
```
    Two arguments arc tangent operation.
    
    Parameters:
    x - second argument of the arc tangent
    
    Returns:
    atan2(this, x)
    
    Throws:
    
    DimensionMismatchException - if number of free parameters or orders are inconsistent
  - cosh
```
T cosh()
```
    Hyperbolic cosine operation.
    
    Returns:
    cosh(this)
  - sinh
```
T sinh()
```
    Hyperbolic sine operation.
    
    Returns:
    sinh(this)
  - tanh
```
T tanh()
```
    Hyperbolic tangent operation.
    
    Returns:
    tanh(this)
  - acosh
```
T acosh()
```
    Inverse hyperbolic cosine operation.
    
    Returns:
    acosh(this)
  - asinh
```
T asinh()
```
    Inverse hyperbolic sine operation.
    
    Returns:
    asin(this)
  - atanh
```
T atanh()
```
    Inverse hyperbolic tangent operation.
    
    Returns:
    atanh(this)
  - linearCombination
```
T linearCombination(T[] a,
                  T[] b)
                    throws DimensionMismatchException
```
    Compute a linear combination.
    
    Parameters:
    a - Factors.
    b - Factors.
    
    Returns:
    Σ_i a_i b_i.
    
    Throws:
    
    DimensionMismatchException - if arrays dimensions don't match
    Since:
    
    3.2
  - linearCombination
```
T linearCombination(double[] a,
                  T[] b)
                    throws DimensionMismatchException
```
    Compute a linear combination.
    
    Parameters:
    a - Factors.
    b - Factors.
    
    Returns:
    Σ_i a_i b_i.
    
    Throws:
    
    DimensionMismatchException - if arrays dimensions don't match
    Since:
    
    3.2
  - linearCombination
```
T linearCombination(T a1,
                  T b1,
                  T a2,
                  T b2)
```
    Compute a linear combination.
    
    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:
    a₁×b₁ + a₂×b₂
    Since:
    
    3.2
    
    See Also:
    linearCombination(Object, Object, Object, Object, Object, Object), linearCombination(Object, Object, Object, Object, Object, Object, Object, Object)
  - linearCombination
```
T linearCombination(double a1,
                  T b1,
                  double a2,
                  T b2)
```
    Compute a linear combination.
    
    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:
    a₁×b₁ + a₂×b₂
    Since:
    
    3.2
    
    See Also:
    linearCombination(double, Object, double, Object, double, Object), linearCombination(double, Object, double, Object, double, Object, double, Object)
  - linearCombination
```
T linearCombination(T a1,
                  T b1,
                  T a2,
                  T b2,
                  T a3,
                  T b3)
```
    Compute a linear combination.
    
    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:
    a₁×b₁ + a₂×b₂ + a₃×b₃
    Since:
    
    3.2
    
    See Also:
    linearCombination(Object, Object, Object, Object), linearCombination(Object, Object, Object, Object, Object, Object, Object, Object)
  - linearCombination
```
T linearCombination(double a1,
                  T b1,
                  double a2,
                  T b2,
                  double a3,
                  T b3)
```
    Compute a linear combination.
    
    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:
    a₁×b₁ + a₂×b₂ + a₃×b₃
    Since:
    
    3.2
    
    See Also:
    linearCombination(double, Object, double, Object), linearCombination(double, Object, double, Object, double, Object, double, Object)
  - linearCombination
```
T linearCombination(T a1,
                  T b1,
                  T a2,
                  T b2,
                  T a3,
                  T b3,
                  T a4,
                  T b4)
```
    Compute a linear combination.
    
    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:
    a₁×b₁ + a₂×b₂ + a₃×b₃ + a₄×b₄
    Since:
    
    3.2
    
    See Also:
    linearCombination(Object, Object, Object, Object), linearCombination(Object, Object, Object, Object, Object, Object)
  - linearCombination
```
T linearCombination(double a1,
                  T b1,
                  double a2,
                  T b2,
                  double a3,
                  T b3,
                  double a4,
                  T b4)
```
    Compute a linear combination.
    
    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:
    a₁×b₁ + a₂×b₂ + a₃×b₃ + a₄×b₄
    Since:
    
    3.2
    
    See Also:
    linearCombination(double, Object, double, Object), linearCombination(double, Object, double, Object, double, Object)

Interface RealFieldElement<T>

Method Summary

Methods inherited from interface org.apache.commons.math4.FieldElement

Method Detail

getReal

add

subtract

multiply

divide

remainder

remainder

abs

ceil

floor

rint

round

signum

copySign

copySign

scalb

hypot

reciprocal

sqrt

cbrt

rootN

pow

pow

pow

exp

expm1

log

log1p

log10

cos

sin

tan

acos

asin

atan

atan2

cosh

sinh

tanh

acosh

asinh

atanh

linearCombination

linearCombination

linearCombination

linearCombination

linearCombination

linearCombination

linearCombination

linearCombination