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

`public interface RealFieldElement<T>extends FieldElement<T>`

Interface representing a real field.

Since:
3.2
Version:
\$Id: RealFieldElement.html 860130 2013-04-27 21:11:39Z luc \$
`FieldElement`

Method Summary
` 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)`
'÷s;' 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

`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)`
'÷s;' 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
`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
`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
`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
`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
`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
`linearCombination(double, Object, double, Object)`, `linearCombination(double, Object, double, Object, double, Object)`