java.lang.Object
- org.hipparchus.analysis.differentiation.FieldDerivativeStructure<T>

Type Parameters:

T - the type of the field elements

All Implemented Interfaces:

FieldElement<FieldDerivativeStructure<T>>, RealFieldElement<FieldDerivativeStructure<T>>
```
public class FieldDerivativeStructure<T extends RealFieldElement<T>>
extends Object
implements RealFieldElement<FieldDerivativeStructure<T>>
```
Class representing both the value and the differentials of a function.
This class is similar to DerivativeStructure except function parameters and value can be any RealFieldElement.

Instances of this class are guaranteed to be immutable.

See Also:

DerivativeStructure, FDSFactory, DSCompiler

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`FieldDerivativeStructure<T>`	`abs()`	absolute value.
`FieldDerivativeStructure<T>`	`acos()`	Arc cosine operation.
`FieldDerivativeStructure<T>`	`acosh()`	Inverse hyperbolic cosine operation.
`FieldDerivativeStructure<T>`	`add(double a)`	'+' operator.
`FieldDerivativeStructure<T>`	`add(FieldDerivativeStructure<T> a)`	Compute this + a.
`FieldDerivativeStructure<T>`	`add(T a)`	'+' operator.
`FieldDerivativeStructure<T>`	`asin()`	Arc sine operation.
`FieldDerivativeStructure<T>`	`asinh()`	Inverse hyperbolic sine operation.
`FieldDerivativeStructure<T>`	`atan()`	Arc tangent operation.
`FieldDerivativeStructure<T>`	`atan2(FieldDerivativeStructure<T> x)`	Two arguments arc tangent operation.
`static <T extends RealFieldElement<T>> FieldDerivativeStructure<T>`	`atan2(FieldDerivativeStructure<T> y, FieldDerivativeStructure<T> x)`	Two arguments arc tangent operation.
`FieldDerivativeStructure<T>`	`atanh()`	Inverse hyperbolic tangent operation.
`FieldDerivativeStructure<T>`	`cbrt()`	Cubic root.
`FieldDerivativeStructure<T>`	`ceil()`	Get the smallest whole number larger than instance.
`FieldDerivativeStructure<T>`	`compose(double... f)`	Compute composition of the instance by a univariate function.
`FieldDerivativeStructure<T>`	`compose(T... f)`	Compute composition of the instance by a univariate function.
`FieldDerivativeStructure<T>`	`copySign(double sign)`	Returns the instance with the sign of the argument.
`FieldDerivativeStructure<T>`	`copySign(FieldDerivativeStructure<T> sign)`	Returns the instance with the sign of the argument.
`FieldDerivativeStructure<T>`	`copySign(T sign)`	Returns the instance with the sign of the argument.
`FieldDerivativeStructure<T>`	`cos()`	Cosine operation.
`FieldDerivativeStructure<T>`	`cosh()`	Hyperbolic cosine operation.
`FieldDerivativeStructure<T>`	`divide(double a)`	'÷' operator.
`FieldDerivativeStructure<T>`	`divide(FieldDerivativeStructure<T> a)`	Compute this ÷ a.
`FieldDerivativeStructure<T>`	`divide(T a)`	'÷' operator.
`FieldDerivativeStructure<T>`	`exp()`	Exponential.
`FieldDerivativeStructure<T>`	`expm1()`	Exponential minus 1.
`FieldDerivativeStructure<T>`	`floor()`	Get the largest whole number smaller than instance.
`T[]`	`getAllDerivatives()`	Get all partial derivatives.
`int`	`getExponent()`	Return the exponent of the instance value, removing the bias.
`FDSFactory<T>`	`getFactory()`	Get the factory that built the instance.
`Field<FieldDerivativeStructure<T>>`	`getField()`	Get the `Field` to which the instance belongs.
`int`	`getFreeParameters()`	Get the number of free parameters.
`int`	`getOrder()`	Get the derivation order.
`T`	`getPartialDerivative(int... orders)`	Get a partial derivative.
`double`	`getReal()`	Get the real value of the number.
`T`	`getValue()`	Get the value part of the derivative structure.
`FieldDerivativeStructure<T>`	`hypot(FieldDerivativeStructure<T> y)`	Returns the hypotenuse of a triangle with sides `this` and `y` - sqrt(this² +y²) avoiding intermediate overflow or underflow.
`static <T extends RealFieldElement<T>> FieldDerivativeStructure<T>`	`hypot(FieldDerivativeStructure<T> x, FieldDerivativeStructure<T> y)`	Returns the hypotenuse of a triangle with sides `x` and `y` - sqrt(x² +y²) avoiding intermediate overflow or underflow.
`FieldDerivativeStructure<T>`	`linearCombination(double[] a, FieldDerivativeStructure<T>[] b)`	Compute a linear combination.
`FieldDerivativeStructure<T>`	`linearCombination(double a1, FieldDerivativeStructure<T> b1, double a2, FieldDerivativeStructure<T> b2)`	Compute a linear combination.
`FieldDerivativeStructure<T>`	`linearCombination(double a1, FieldDerivativeStructure<T> b1, double a2, FieldDerivativeStructure<T> b2, double a3, FieldDerivativeStructure<T> b3)`	Compute a linear combination.
`FieldDerivativeStructure<T>`	`linearCombination(double a1, FieldDerivativeStructure<T> b1, double a2, FieldDerivativeStructure<T> b2, double a3, FieldDerivativeStructure<T> b3, double a4, FieldDerivativeStructure<T> b4)`	Compute a linear combination.
`FieldDerivativeStructure<T>`	`linearCombination(FieldDerivativeStructure<T>[] a, FieldDerivativeStructure<T>[] b)`	Compute a linear combination.
`FieldDerivativeStructure<T>`	`linearCombination(FieldDerivativeStructure<T> a1, FieldDerivativeStructure<T> b1, FieldDerivativeStructure<T> a2, FieldDerivativeStructure<T> b2)`	Compute a linear combination.
`FieldDerivativeStructure<T>`	`linearCombination(FieldDerivativeStructure<T> a1, FieldDerivativeStructure<T> b1, FieldDerivativeStructure<T> a2, FieldDerivativeStructure<T> b2, FieldDerivativeStructure<T> a3, FieldDerivativeStructure<T> b3)`	Compute a linear combination.
`FieldDerivativeStructure<T>`	`linearCombination(FieldDerivativeStructure<T> a1, FieldDerivativeStructure<T> b1, FieldDerivativeStructure<T> a2, FieldDerivativeStructure<T> b2, FieldDerivativeStructure<T> a3, FieldDerivativeStructure<T> b3, FieldDerivativeStructure<T> a4, FieldDerivativeStructure<T> b4)`	Compute a linear combination.
`FieldDerivativeStructure<T>`	`linearCombination(T[] a, FieldDerivativeStructure<T>[] b)`	Compute a linear combination.
`FieldDerivativeStructure<T>`	`linearCombination(T a1, FieldDerivativeStructure<T> b1, T a2, FieldDerivativeStructure<T> b2)`	Compute a linear combination.
`FieldDerivativeStructure<T>`	`linearCombination(T a1, FieldDerivativeStructure<T> b1, T a2, FieldDerivativeStructure<T> b2, T a3, FieldDerivativeStructure<T> b3)`	Compute a linear combination.
`FieldDerivativeStructure<T>`	`linearCombination(T a1, FieldDerivativeStructure<T> b1, T a2, FieldDerivativeStructure<T> b2, T a3, FieldDerivativeStructure<T> b3, T a4, FieldDerivativeStructure<T> b4)`	Compute a linear combination.
`FieldDerivativeStructure<T>`	`log()`	Natural logarithm.
`FieldDerivativeStructure<T>`	`log10()`	Base 10 logarithm.
`FieldDerivativeStructure<T>`	`log1p()`	Shifted natural logarithm.
`FieldDerivativeStructure<T>`	`multiply(double a)`	'×' operator.
`FieldDerivativeStructure<T>`	`multiply(int n)`	Compute n × this.
`FieldDerivativeStructure<T>`	`multiply(FieldDerivativeStructure<T> a)`	Compute this × a.
`FieldDerivativeStructure<T>`	`multiply(T a)`	'×' operator.
`FieldDerivativeStructure<T>`	`negate()`	Returns the additive inverse of `this` element.
`FieldDerivativeStructure<T>`	`pow(double p)`	Power operation.
`static <T extends RealFieldElement<T>> FieldDerivativeStructure<T>`	`pow(double a, FieldDerivativeStructure<T> x)`	Compute a^x where a is a double and x a `FieldDerivativeStructure`
`FieldDerivativeStructure<T>`	`pow(int n)`	Integer power operation.
`FieldDerivativeStructure<T>`	`pow(FieldDerivativeStructure<T> e)`	Power operation.
`FieldDerivativeStructure<T>`	`reciprocal()`	Returns the multiplicative inverse of `this` element.
`FieldDerivativeStructure<T>`	`remainder(double a)`	IEEE remainder operator.
`FieldDerivativeStructure<T>`	`remainder(FieldDerivativeStructure<T> a)`	IEEE remainder operator.
`FieldDerivativeStructure<T>`	`remainder(T a)`	IEEE remainder operator.
`FieldDerivativeStructure<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.
`FieldDerivativeStructure<T>`	`rootN(int n)`	N^th root.
`long`	`round()`	Get the closest long to instance value.
`FieldDerivativeStructure<T>`	`scalb(int n)`	Multiply the instance by a power of 2.
`FieldDerivativeStructure<T>`	`signum()`	Compute the signum of the instance.
`FieldDerivativeStructure<T>`	`sin()`	Sine operation.
`FieldSinCos<FieldDerivativeStructure<T>>`	`sinCos()`	Combined Sine and Cosine operation.
`FieldDerivativeStructure<T>`	`sinh()`	Hyperbolic sine operation.
`FieldDerivativeStructure<T>`	`sqrt()`	Square root.
`FieldDerivativeStructure<T>`	`subtract(double a)`	'-' operator.
`FieldDerivativeStructure<T>`	`subtract(FieldDerivativeStructure<T> a)`	Compute this - a.
`FieldDerivativeStructure<T>`	`subtract(T a)`	'-' operator.
`FieldDerivativeStructure<T>`	`tan()`	Tangent operation.
`FieldDerivativeStructure<T>`	`tanh()`	Hyperbolic tangent operation.
`T`	`taylor(double... delta)`	Evaluate Taylor expansion of a derivative structure.
`T`	`taylor(T... delta)`	Evaluate Taylor expansion of a derivative structure.
`FieldDerivativeStructure<T>`	`toDegrees()`	Convert radians to degrees, with error of less than 0.5 ULP
`FieldDerivativeStructure<T>`	`toRadians()`	Convert degrees to radians, with error of less than 0.5 ULP

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - getFactory
```
public FDSFactory<T> getFactory()
```
    Get the factory that built the instance.
    
    Returns:
    
    factory that built the instance
  - getFreeParameters
```
public int getFreeParameters()
```
    Get the number of free parameters.
    
    Returns:
    
    number of free parameters
  - getOrder
```
public int getOrder()
```
    Get the derivation order.
    
    Returns:
    
    derivation order
  - getReal
```
public double getReal()
```
    Get the real value of the number.
    
    Specified by:
    
    getReal in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    real value
  - getValue
```
public T getValue()
```
    Get the value part of the derivative structure.
    
    Returns:
    
    value part of the derivative structure
    
    See Also:
    
    getPartialDerivative(int...)
  - getPartialDerivative
```
public T getPartialDerivative(int... orders)
                       throws MathIllegalArgumentException
```
    Get a partial derivative.
    
    Parameters:
    
    orders - derivation orders with respect to each variable (if all orders are 0, the value is returned)
    
    Returns:
    
    partial derivative
    
    Throws:
    
    MathIllegalArgumentException - if the numbers of variables does not match the instance
    
    MathIllegalArgumentException - if sum of derivation orders is larger than the instance limits
    
    See Also:
    
    getValue()
  - getAllDerivatives
```
public T[] getAllDerivatives()
```
    Get all partial derivatives.
    
    Returns:
    
    a fresh copy of partial derivatives, in an array sorted according to DSCompiler.getPartialDerivativeIndex(int...)
  - add
```
public FieldDerivativeStructure<T> add(T a)
```
    '+' operator.
    
    Parameters:
    
    a - right hand side parameter of the operator
    
    Returns:
    
    this+a
  - add
```
public FieldDerivativeStructure<T> add(double a)
```
    '+' operator.
    
    Specified by:
    
    add in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Parameters:
    
    a - right hand side parameter of the operator
    
    Returns:
    
    this+a
  - add
```
public FieldDerivativeStructure<T> add(FieldDerivativeStructure<T> a)
                                throws MathIllegalArgumentException
```
    Compute this + a.
    
    Specified by:
    
    add in interface FieldElement<T extends RealFieldElement<T>>
    
    Parameters:
    
    a - element to add
    
    Returns:
    
    a new element representing this + a
    
    Throws:
    
    MathIllegalArgumentException - if number of free parameters or orders do not match
  - subtract
```
public FieldDerivativeStructure<T> subtract(T a)
```
    '-' operator.
    
    Parameters:
    
    a - right hand side parameter of the operator
    
    Returns:
    
    this-a
  - subtract
```
public FieldDerivativeStructure<T> subtract(double a)
```
    '-' operator.
    
    Specified by:
    
    subtract in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Parameters:
    
    a - right hand side parameter of the operator
    
    Returns:
    
    this-a
  - subtract
```
public FieldDerivativeStructure<T> subtract(FieldDerivativeStructure<T> a)
                                     throws MathIllegalArgumentException
```
    Compute this - a.
    
    Specified by:
    
    subtract in interface FieldElement<T extends RealFieldElement<T>>
    
    Parameters:
    
    a - element to subtract
    
    Returns:
    
    a new element representing this - a
    
    Throws:
    
    MathIllegalArgumentException - if number of free parameters or orders do not match
  - multiply
```
public FieldDerivativeStructure<T> multiply(T a)
```
    '×' operator.
    
    Parameters:
    
    a - right hand side parameter of the operator
    
    Returns:
    
    this×a
  - multiply
```
public FieldDerivativeStructure<T> multiply(int n)
```
    Compute n × this. Multiplication by an integer number is defined as the following sum n × this = ∑_i=1ⁿ this.
    
    Specified by:
    
    multiply in interface FieldElement<T extends RealFieldElement<T>>
    
    Parameters:
    
    n - Number of times this must be added to itself.
    
    Returns:
    
    A new element representing n × this.
  - multiply
```
public FieldDerivativeStructure<T> multiply(double a)
```
    '×' operator.
    
    Specified by:
    
    multiply in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Parameters:
    
    a - right hand side parameter of the operator
    
    Returns:
    
    this×a
  - multiply
```
public FieldDerivativeStructure<T> multiply(FieldDerivativeStructure<T> a)
                                     throws MathIllegalArgumentException
```
    Compute this × a.
    
    Specified by:
    
    multiply in interface FieldElement<T extends RealFieldElement<T>>
    
    Parameters:
    
    a - element to multiply
    
    Returns:
    
    a new element representing this × a
    
    Throws:
    
    MathIllegalArgumentException - if number of free parameters or orders do not match
  - divide
```
public FieldDerivativeStructure<T> divide(T a)
```
    '÷' operator.
    
    Parameters:
    
    a - right hand side parameter of the operator
    
    Returns:
    
    this÷a
  - divide
```
public FieldDerivativeStructure<T> divide(double a)
```
    '÷' operator.
    
    Specified by:
    
    divide in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Parameters:
    
    a - right hand side parameter of the operator
    
    Returns:
    
    this÷a
  - divide
```
public FieldDerivativeStructure<T> divide(FieldDerivativeStructure<T> a)
                                   throws MathIllegalArgumentException
```
    Compute this ÷ a.
    
    Specified by:
    
    divide in interface FieldElement<T extends RealFieldElement<T>>
    
    Parameters:
    
    a - element to divide by
    
    Returns:
    
    a new element representing this ÷ a
    
    Throws:
    
    MathIllegalArgumentException - if number of free parameters or orders do not match
  - remainder
```
public FieldDerivativeStructure<T> remainder(T 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
```
public FieldDerivativeStructure<T> remainder(double a)
```
    IEEE remainder operator.
    
    Specified by:
    
    remainder in interface RealFieldElement<T extends RealFieldElement<T>>
    
    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
```
public FieldDerivativeStructure<T> remainder(FieldDerivativeStructure<T> a)
                                      throws MathIllegalArgumentException
```
    IEEE remainder operator.
    
    Specified by:
    
    remainder in interface RealFieldElement<T extends RealFieldElement<T>>
    
    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:
    
    MathIllegalArgumentException - if number of free parameters or orders do not match
  - negate
```
public FieldDerivativeStructure<T> negate()
```
    Returns the additive inverse of this element.
    
    Specified by:
    
    negate in interface FieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    the opposite of this.
  - abs
```
public FieldDerivativeStructure<T> abs()
```
    absolute value.
    
    Specified by:
    
    abs in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    abs(this)
  - ceil
```
public FieldDerivativeStructure<T> ceil()
```
    Get the smallest whole number larger than instance.
    
    Specified by:
    
    ceil in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    ceil(this)
  - floor
```
public FieldDerivativeStructure<T> floor()
```
    Get the largest whole number smaller than instance.
    
    Specified by:
    
    floor in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    floor(this)
  - rint
```
public FieldDerivativeStructure<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.
    
    Specified by:
    
    rint in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    a double number r such that r is an integer r - 0.5 ≤ this ≤ r + 0.5
  - round
```
public long round()
```
    Get the closest long to instance value.
    
    Specified by:
    
    round in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    closest long to RealFieldElement.getReal()
  - signum
```
public FieldDerivativeStructure<T> 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<T extends RealFieldElement<T>>
    
    Returns:
    
    -1.0, -0.0, +0.0, +1.0 or NaN depending on sign of a
  - copySign
```
public FieldDerivativeStructure<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
```
public FieldDerivativeStructure<T> 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<T extends RealFieldElement<T>>
    
    Parameters:
    
    sign - the sign for the returned value
    
    Returns:
    
    the instance with the same sign as the sign argument
  - copySign
```
public FieldDerivativeStructure<T> copySign(FieldDerivativeStructure<T> sign)
```
    Returns the instance with the sign of the argument. A NaN sign argument is treated as positive.
    
    Specified by:
    
    copySign in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Parameters:
    
    sign - the sign for the returned value
    
    Returns:
    
    the instance with the same sign as the sign argument
  - getExponent
```
public int getExponent()
```
    Return the exponent of the instance value, removing the bias.
    For double numbers of the form 2^x, the unbiased exponent is exactly x.
    
    Returns:
    
    exponent for instance in IEEE754 representation, without bias
  - scalb
```
public FieldDerivativeStructure<T> scalb(int n)
```
    Multiply the instance by a power of 2.
    
    Specified by:
    
    scalb in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Parameters:
    
    n - power of 2
    
    Returns:
    
    this × 2ⁿ
  - hypot
```
public FieldDerivativeStructure<T> hypot(FieldDerivativeStructure<T> y)
                                  throws MathIllegalArgumentException
```
    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.
    Specified by:
    
    hypot in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Parameters:
    
    y - a value
    
    Returns:
    
    sqrt(this² +y²)
    
    Throws:
    
    MathIllegalArgumentException - if number of free parameters or orders do not match
  - hypot
```
public static <T extends RealFieldElement<T>> FieldDerivativeStructure<T> hypot(FieldDerivativeStructure<T> x,
                                                                                FieldDerivativeStructure<T> y)
                                                                         throws MathIllegalArgumentException
```
    Returns the hypotenuse of a triangle with sides x and y - sqrt(x² +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.
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    x - a value
    
    y - a value
    
    Returns:
    
    sqrt(x² +y²)
    
    Throws:
    
    MathIllegalArgumentException - if number of free parameters or orders do not match
  - compose
```
@SafeVarargs
public final FieldDerivativeStructure<T> compose(T... f)
                                          throws MathIllegalArgumentException
```
    Compute composition of the instance by a univariate function.
    
    Parameters:
    
    f - array of value and derivatives of the function at the current point (i.e. [f(getValue()), f'(getValue()), f''(getValue())...]).
    
    Returns:
    
    f(this)
    
    Throws:
    
    MathIllegalArgumentException - if the number of derivatives in the array is not equal to order + 1
  - compose
```
public FieldDerivativeStructure<T> compose(double... f)
                                    throws MathIllegalArgumentException
```
    Compute composition of the instance by a univariate function.
    
    Parameters:
    
    f - array of value and derivatives of the function at the current point (i.e. [f(getValue()), f'(getValue()), f''(getValue())...]).
    
    Returns:
    
    f(this)
    
    Throws:
    
    MathIllegalArgumentException - if the number of derivatives in the array is not equal to order + 1
  - reciprocal
```
public FieldDerivativeStructure<T> reciprocal()
```
    Returns the multiplicative inverse of this element.
    
    Specified by:
    
    reciprocal in interface FieldElement<T extends RealFieldElement<T>>
    
    Specified by:
    
    reciprocal in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    the inverse of this.
  - sqrt
```
public FieldDerivativeStructure<T> sqrt()
```
    Square root.
    
    Specified by:
    
    sqrt in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    square root of the instance
  - cbrt
```
public FieldDerivativeStructure<T> cbrt()
```
    Cubic root.
    
    Specified by:
    
    cbrt in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    cubic root of the instance
  - rootN
```
public FieldDerivativeStructure<T> rootN(int n)
```
    N^th root.
    
    Specified by:
    
    rootN in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Parameters:
    
    n - order of the root
    
    Returns:
    
    n^th root of the instance
  - getField
```
public Field<FieldDerivativeStructure<T>> getField()
```
    Get the Field to which the instance belongs.
    
    Specified by:
    
    getField in interface FieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    Field to which the instance belongs
  - pow
```
public static <T extends RealFieldElement<T>> FieldDerivativeStructure<T> pow(double a,
                                                                              FieldDerivativeStructure<T> x)
```
    Compute a^x where a is a double and x a FieldDerivativeStructure
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    a - number to exponentiate
    
    x - power to apply
    
    Returns:
    
    a^x
  - pow
```
public FieldDerivativeStructure<T> pow(double p)
```
    Power operation.
    
    Specified by:
    
    pow in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Parameters:
    
    p - power to apply
    
    Returns:
    
    this^p
  - pow
```
public FieldDerivativeStructure<T> pow(int n)
```
    Integer power operation.
    
    Specified by:
    
    pow in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Parameters:
    
    n - power to apply
    
    Returns:
    
    thisⁿ
  - pow
```
public FieldDerivativeStructure<T> pow(FieldDerivativeStructure<T> e)
                                throws MathIllegalArgumentException
```
    Power operation.
    
    Specified by:
    
    pow in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Parameters:
    
    e - exponent
    
    Returns:
    
    this^e
    
    Throws:
    
    MathIllegalArgumentException - if number of free parameters or orders do not match
  - exp
```
public FieldDerivativeStructure<T> exp()
```
    Exponential.
    
    Specified by:
    
    exp in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    exponential of the instance
  - expm1
```
public FieldDerivativeStructure<T> expm1()
```
    Exponential minus 1.
    
    Specified by:
    
    expm1 in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    exponential minus one of the instance
  - log
```
public FieldDerivativeStructure<T> log()
```
    Natural logarithm.
    
    Specified by:
    
    log in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    logarithm of the instance
  - log1p
```
public FieldDerivativeStructure<T> log1p()
```
    Shifted natural logarithm.
    
    Specified by:
    
    log1p in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    logarithm of one plus the instance
  - log10
```
public FieldDerivativeStructure<T> log10()
```
    Base 10 logarithm.
    
    Specified by:
    
    log10 in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    base 10 logarithm of the instance
  - cos
```
public FieldDerivativeStructure<T> cos()
```
    Cosine operation.
    
    Specified by:
    
    cos in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    cos(this)
  - sin
```
public FieldDerivativeStructure<T> sin()
```
    Sine operation.
    
    Specified by:
    
    sin in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    sin(this)
  - sinCos
```
public FieldSinCos<FieldDerivativeStructure<T>> sinCos()
```
    Combined Sine and Cosine operation.
    
    Specified by:
    
    sinCos in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    [sin(this), cos(this)]
  - tan
```
public FieldDerivativeStructure<T> tan()
```
    Tangent operation.
    
    Specified by:
    
    tan in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    tan(this)
  - acos
```
public FieldDerivativeStructure<T> acos()
```
    Arc cosine operation.
    
    Specified by:
    
    acos in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    acos(this)
  - asin
```
public FieldDerivativeStructure<T> asin()
```
    Arc sine operation.
    
    Specified by:
    
    asin in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    asin(this)
  - atan
```
public FieldDerivativeStructure<T> atan()
```
    Arc tangent operation.
    
    Specified by:
    
    atan in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    atan(this)
  - atan2
```
public FieldDerivativeStructure<T> atan2(FieldDerivativeStructure<T> x)
                                  throws MathIllegalArgumentException
```
    Two arguments arc tangent operation.
    
    Specified by:
    
    atan2 in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Parameters:
    
    x - second argument of the arc tangent
    
    Returns:
    
    atan2(this, x)
    
    Throws:
    
    MathIllegalArgumentException - if number of free parameters or orders are inconsistent
  - atan2
```
public static <T extends RealFieldElement<T>> FieldDerivativeStructure<T> atan2(FieldDerivativeStructure<T> y,
                                                                                FieldDerivativeStructure<T> x)
                                                                         throws MathIllegalArgumentException
```
    Two arguments arc tangent operation.
    
    Type Parameters:
    
    T - the type of the field elements
    
    Parameters:
    
    y - first argument of the arc tangent
    
    x - second argument of the arc tangent
    
    Returns:
    
    atan2(y, x)
    
    Throws:
    
    MathIllegalArgumentException - if number of free parameters or orders do not match
  - cosh
```
public FieldDerivativeStructure<T> cosh()
```
    Hyperbolic cosine operation.
    
    Specified by:
    
    cosh in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    cosh(this)
  - sinh
```
public FieldDerivativeStructure<T> sinh()
```
    Hyperbolic sine operation.
    
    Specified by:
    
    sinh in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    sinh(this)
  - tanh
```
public FieldDerivativeStructure<T> tanh()
```
    Hyperbolic tangent operation.
    
    Specified by:
    
    tanh in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    tanh(this)
  - acosh
```
public FieldDerivativeStructure<T> acosh()
```
    Inverse hyperbolic cosine operation.
    
    Specified by:
    
    acosh in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    acosh(this)
  - asinh
```
public FieldDerivativeStructure<T> asinh()
```
    Inverse hyperbolic sine operation.
    
    Specified by:
    
    asinh in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    asin(this)
  - atanh
```
public FieldDerivativeStructure<T> atanh()
```
    Inverse hyperbolic tangent operation.
    
    Specified by:
    
    atanh in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Returns:
    
    atanh(this)
  - toDegrees
```
public FieldDerivativeStructure<T> toDegrees()
```
    Convert radians to degrees, with error of less than 0.5 ULP
    
    Returns:
    
    instance converted into degrees
  - toRadians
```
public FieldDerivativeStructure<T> toRadians()
```
    Convert degrees to radians, with error of less than 0.5 ULP
    
    Returns:
    
    instance converted into radians
  - taylor
```
@SafeVarargs
public final T taylor(T... delta)
               throws MathRuntimeException
```
    Evaluate Taylor expansion of a derivative structure.
    
    Parameters:
    
    delta - parameters offsets (Δx, Δy, ...)
    
    Returns:
    
    value of the Taylor expansion at x + Δx, y + Δy, ...
    
    Throws:
    
    MathRuntimeException - if factorials becomes too large
  - taylor
```
public T taylor(double... delta)
         throws MathRuntimeException
```
    Evaluate Taylor expansion of a derivative structure.
    
    Parameters:
    
    delta - parameters offsets (Δx, Δy, ...)
    
    Returns:
    
    value of the Taylor expansion at x + Δx, y + Δy, ...
    
    Throws:
    
    MathRuntimeException - if factorials becomes too large
  - linearCombination
```
public FieldDerivativeStructure<T> linearCombination(FieldDerivativeStructure<T>[] a,
                                                     FieldDerivativeStructure<T>[] b)
                                              throws MathIllegalArgumentException
```
    Compute a linear combination.
    
    Specified by:
    
    linearCombination in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Parameters:
    
    a - Factors.
    
    b - Factors.
    
    Returns:
    
    Σ_i a_i b_i.
    
    Throws:
    
    MathIllegalArgumentException - if number of free parameters or orders do not match
  - linearCombination
```
public FieldDerivativeStructure<T> linearCombination(T[] a,
                                                     FieldDerivativeStructure<T>[] b)
                                              throws MathIllegalArgumentException
```
    Compute a linear combination.
    
    Parameters:
    
    a - Factors.
    
    b - Factors.
    
    Returns:
    
    Σ_i a_i b_i.
    
    Throws:
    
    MathIllegalArgumentException - if arrays dimensions don't match
  - linearCombination
```
public FieldDerivativeStructure<T> linearCombination(double[] a,
                                                     FieldDerivativeStructure<T>[] b)
                                              throws MathIllegalArgumentException
```
    Compute a linear combination.
    
    Specified by:
    
    linearCombination in interface RealFieldElement<T extends RealFieldElement<T>>
    
    Parameters:
    
    a - Factors.
    
    b - Factors.
    
    Returns:
    
    Σ_i a_i b_i.
    
    Throws:
    
    MathIllegalArgumentException - if number of free parameters or orders do not match
  - linearCombination
```
public FieldDerivativeStructure<T> linearCombination(FieldDerivativeStructure<T> a1,
                                                     FieldDerivativeStructure<T> b1,
                                                     FieldDerivativeStructure<T> a2,
                                                     FieldDerivativeStructure<T> b2)
                                              throws MathIllegalArgumentException
```
    Compute a linear combination.
    
    Specified by:
    
    linearCombination in interface RealFieldElement<T extends RealFieldElement<T>>
    
    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₂
    
    Throws:
    
    MathIllegalArgumentException - if number of free parameters or orders do not match
    
    See Also:
    
    RealFieldElement.linearCombination(Object, Object, Object, Object, Object, Object), RealFieldElement.linearCombination(Object, Object, Object, Object, Object, Object, Object, Object)
  - linearCombination
```
public FieldDerivativeStructure<T> linearCombination(T a1,
                                                     FieldDerivativeStructure<T> b1,
                                                     T a2,
                                                     FieldDerivativeStructure<T> b2)
                                              throws MathIllegalArgumentException
```
    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₂
    
    Throws:
    
    MathIllegalArgumentException - if number of free parameters or orders are inconsistent
    
    See Also:
    
    RealFieldElement.linearCombination(double, Object, double, Object, double, Object), RealFieldElement.linearCombination(double, Object, double, Object, double, Object, double, Object)
  - linearCombination
```
public FieldDerivativeStructure<T> linearCombination(double a1,
                                                     FieldDerivativeStructure<T> b1,
                                                     double a2,
                                                     FieldDerivativeStructure<T> b2)
                                              throws MathIllegalArgumentException
```
    Compute a linear combination.
    
    Specified by:
    
    linearCombination in interface RealFieldElement<T extends RealFieldElement<T>>
    
    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₂
    
    Throws:
    
    MathIllegalArgumentException - if number of free parameters or orders do not match
    
    See Also:
    
    RealFieldElement.linearCombination(double, Object, double, Object, double, Object), RealFieldElement.linearCombination(double, Object, double, Object, double, Object, double, Object)
  - linearCombination
```
public FieldDerivativeStructure<T> linearCombination(FieldDerivativeStructure<T> a1,
                                                     FieldDerivativeStructure<T> b1,
                                                     FieldDerivativeStructure<T> a2,
                                                     FieldDerivativeStructure<T> b2,
                                                     FieldDerivativeStructure<T> a3,
                                                     FieldDerivativeStructure<T> b3)
                                              throws MathIllegalArgumentException
```
    Compute a linear combination.
    
    Specified by:
    
    linearCombination in interface RealFieldElement<T extends RealFieldElement<T>>
    
    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₃
    
    Throws:
    
    MathIllegalArgumentException - if number of free parameters or orders do not match
    
    See Also:
    
    RealFieldElement.linearCombination(Object, Object, Object, Object), RealFieldElement.linearCombination(Object, Object, Object, Object, Object, Object, Object, Object)
  - linearCombination
```
public FieldDerivativeStructure<T> linearCombination(T a1,
                                                     FieldDerivativeStructure<T> b1,
                                                     T a2,
                                                     FieldDerivativeStructure<T> b2,
                                                     T a3,
                                                     FieldDerivativeStructure<T> b3)
                                              throws MathIllegalArgumentException
```
    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₃
    
    Throws:
    
    MathIllegalArgumentException - if number of free parameters or orders are inconsistent
    
    See Also:
    
    RealFieldElement.linearCombination(double, Object, double, Object), RealFieldElement.linearCombination(double, Object, double, Object, double, Object, double, Object)
  - linearCombination
```
public FieldDerivativeStructure<T> linearCombination(double a1,
                                                     FieldDerivativeStructure<T> b1,
                                                     double a2,
                                                     FieldDerivativeStructure<T> b2,
                                                     double a3,
                                                     FieldDerivativeStructure<T> b3)
                                              throws MathIllegalArgumentException
```
    Compute a linear combination.
    
    Specified by:
    
    linearCombination in interface RealFieldElement<T extends RealFieldElement<T>>
    
    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₃
    
    Throws:
    
    MathIllegalArgumentException - if number of free parameters or orders do not match
    
    See Also:
    
    RealFieldElement.linearCombination(double, Object, double, Object), RealFieldElement.linearCombination(double, Object, double, Object, double, Object, double, Object)
  - linearCombination
```
public FieldDerivativeStructure<T> linearCombination(FieldDerivativeStructure<T> a1,
                                                     FieldDerivativeStructure<T> b1,
                                                     FieldDerivativeStructure<T> a2,
                                                     FieldDerivativeStructure<T> b2,
                                                     FieldDerivativeStructure<T> a3,
                                                     FieldDerivativeStructure<T> b3,
                                                     FieldDerivativeStructure<T> a4,
                                                     FieldDerivativeStructure<T> b4)
                                              throws MathIllegalArgumentException
```
    Compute a linear combination.
    
    Specified by:
    
    linearCombination in interface RealFieldElement<T extends RealFieldElement<T>>
    
    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 fourth term
    
    b4 - second factor of the fourth term
    
    Returns:
    
    a₁×b₁ + a₂×b₂ + a₃×b₃ + a₄×b₄
    
    Throws:
    
    MathIllegalArgumentException - if number of free parameters or orders do not match
    
    See Also:
    
    RealFieldElement.linearCombination(Object, Object, Object, Object), RealFieldElement.linearCombination(Object, Object, Object, Object, Object, Object)
  - linearCombination
```
public FieldDerivativeStructure<T> linearCombination(T a1,
                                                     FieldDerivativeStructure<T> b1,
                                                     T a2,
                                                     FieldDerivativeStructure<T> b2,
                                                     T a3,
                                                     FieldDerivativeStructure<T> b3,
                                                     T a4,
                                                     FieldDerivativeStructure<T> b4)
                                              throws MathIllegalArgumentException
```
    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₄
    
    Throws:
    
    MathIllegalArgumentException - if number of free parameters or orders are inconsistent
    
    See Also:
    
    RealFieldElement.linearCombination(double, Object, double, Object), RealFieldElement.linearCombination(double, Object, double, Object, double, Object)
  - linearCombination
```
public FieldDerivativeStructure<T> linearCombination(double a1,
                                                     FieldDerivativeStructure<T> b1,
                                                     double a2,
                                                     FieldDerivativeStructure<T> b2,
                                                     double a3,
                                                     FieldDerivativeStructure<T> b3,
                                                     double a4,
                                                     FieldDerivativeStructure<T> b4)
                                              throws MathIllegalArgumentException
```
    Compute a linear combination.
    
    Specified by:
    
    linearCombination in interface RealFieldElement<T extends RealFieldElement<T>>
    
    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 fourth term
    
    b4 - second factor of the fourth term
    
    Returns:
    
    a₁×b₁ + a₂×b₂ + a₃×b₃ + a₄×b₄
    
    Throws:
    
    MathIllegalArgumentException - if number of free parameters or orders do not match
    
    See Also:
    
    RealFieldElement.linearCombination(double, Object, double, Object), RealFieldElement.linearCombination(double, Object, double, Object, double, Object)

Class FieldDerivativeStructure<T extends RealFieldElement<T>>

Method Summary

Methods inherited from class java.lang.Object

Method Detail

getFactory

getFreeParameters

getOrder

getReal

getValue

getPartialDerivative

getAllDerivatives

add

add

add

subtract

subtract

subtract

multiply

multiply

multiply

multiply

divide

divide

divide

remainder

remainder

remainder

negate

abs

ceil

floor

rint

round

signum

copySign

copySign

copySign

getExponent

scalb

hypot

hypot

compose

compose

reciprocal

sqrt

cbrt

rootN

getField

pow

pow

pow

pow

exp

expm1

log

log1p

log10

cos

sin

sinCos

tan

acos

asin

atan

atan2

atan2

cosh

sinh

tanh

acosh

asinh

atanh

toDegrees

toRadians

taylor

taylor

linearCombination

linearCombination

linearCombination

linearCombination