org.apache.commons.math3

## Interface RealFieldElement<T>

- 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
  Version:
    $Id: RealFieldElement.java 1591835 2014-05-02 09:04:01Z tn $
  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(this2 +y2) 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` | `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)` Nth 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.math3.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 × 2n

    - #### hypot

          T hypot(T y)
                  throws DimensionMismatchException

      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.
      Parameters:
        `y` - a value
      Returns:
        sqrt(this2 +y2)
      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)

      Nth root.
      Parameters:
        `n` - order of the root
      Returns:
        nth root of the instance

    - #### pow

          T pow(double p)

      Power operation.
      Parameters:
        `p` - power to apply
      Returns:
        thisp

    - #### pow

          T pow(int n)

      Integer power operation.
      Parameters:
        `n` - power to apply
      Returns:
        thisn

    - #### pow

          T pow(T e)
                throws DimensionMismatchException

      Power operation.
      Parameters:
        `e` - exponent
      Returns:
        thise
      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

    - #### 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 ai bi`.
      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 ai bi`.
      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:
        a1×b1 + a2×b2
      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:
        a1×b1 + a2×b2
      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:
        a1×b1 + a2×b2 + a3×b3
      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:
        a1×b1 + a2×b2 + a3×b3
      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:
        a1×b1 + a2×b2 + a3×b3 + a4×b4
      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:
        a1×b1 + a2×b2 + a3×b3 + a4×b4
      Since:
        3.2
      See Also:
        `linearCombination(double, Object, double, Object)`, `linearCombination(double, Object, double, Object, double, Object)`

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