FieldUnivariateDerivative1.java
/*
* Licensed to the Hipparchus project under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The Hipparchus project licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.hipparchus.analysis.differentiation;
import org.hipparchus.CalculusFieldElement;
import org.hipparchus.Field;
import org.hipparchus.exception.LocalizedCoreFormats;
import org.hipparchus.exception.MathIllegalArgumentException;
import org.hipparchus.util.FastMath;
import org.hipparchus.util.MathArrays;
import org.hipparchus.util.MathUtils;
/** Class representing both the value and the differentials of a function.
* <p>This class is a stripped-down version of {@link FieldDerivativeStructure}
* with only one {@link FieldDerivativeStructure#getFreeParameters() free parameter}
* and {@link FieldDerivativeStructure#getOrder() derivation order} also limited to one.
* It should have less overhead than {@link FieldDerivativeStructure} in its domain.</p>
* <p>This class is an implementation of Rall's numbers. Rall's numbers are an
* extension to the real numbers used throughout mathematical expressions; they hold
* the derivative together with the value of a function.</p>
* <p>{@link FieldUnivariateDerivative1} instances can be used directly thanks to
* the arithmetic operators to the mathematical functions provided as
* methods by this class (+, -, *, /, %, sin, cos ...).</p>
* <p>Implementing complex expressions by hand using these classes is
* a tedious and error-prone task but has the advantage of having no limitation
* on the derivation order despite not requiring users to compute the derivatives by
* themselves.</p>
* <p>Instances of this class are guaranteed to be immutable.</p>
* @param <T> the type of the function parameters and value
* @see DerivativeStructure
* @see UnivariateDerivative1
* @see UnivariateDerivative2
* @see Gradient
* @see FieldDerivativeStructure
* @see FieldUnivariateDerivative2
* @see FieldGradient
* @since 1.7
*/
public class FieldUnivariateDerivative1<T extends CalculusFieldElement<T>>
extends FieldUnivariateDerivative<T, FieldUnivariateDerivative1<T>>
implements FieldDerivative1<T, FieldUnivariateDerivative1<T>> {
/** Value of the function. */
private final T f0;
/** First derivative of the function. */
private final T f1;
/** Build an instance with values and derivative.
* @param f0 value of the function
* @param f1 first derivative of the function
*/
public FieldUnivariateDerivative1(final T f0, final T f1) {
this.f0 = f0;
this.f1 = f1;
}
/** Build an instance from a {@link DerivativeStructure}.
* @param ds derivative structure
* @exception MathIllegalArgumentException if either {@code ds} parameters
* is not 1 or {@code ds} order is not 1
*/
public FieldUnivariateDerivative1(final FieldDerivativeStructure<T> ds) throws MathIllegalArgumentException {
MathUtils.checkDimension(ds.getFreeParameters(), 1);
MathUtils.checkDimension(ds.getOrder(), 1);
this.f0 = ds.getValue();
this.f1 = ds.getPartialDerivative(1);
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> newInstance(final double value) {
final T zero = f0.getField().getZero();
return new FieldUnivariateDerivative1<>(zero.newInstance(value), zero);
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> newInstance(final T value) {
final T zero = f0.getField().getZero();
return new FieldUnivariateDerivative1<>(value, zero);
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> withValue(final T value) {
return new FieldUnivariateDerivative1<>(value, f1);
}
/** Get the value part of the univariate derivative.
* @return value part of the univariate derivative
*/
@Override
public T getValue() {
return f0;
}
/** Get a derivative from the univariate derivative.
* @param n derivation order (must be between 0 and {@link #getOrder()}, both inclusive)
* @return n<sup>th</sup> derivative, or {@code NaN} if n is
* either negative or strictly larger than {@link #getOrder()}
*/
@Override
public T getDerivative(final int n) {
switch (n) {
case 0 :
return f0;
case 1 :
return f1;
default :
throw new MathIllegalArgumentException(LocalizedCoreFormats.DERIVATION_ORDER_NOT_ALLOWED, n);
}
}
/** Get the first derivative.
* @return first derivative
* @see #getValue()
*/
public T getFirstDerivative() {
return f1;
}
/** Get the {@link Field} the value and parameters of the function belongs to.
* @return {@link Field} the value and parameters of the function belongs to
*/
public Field<T> getValueField() {
return f0.getField();
}
/** Convert the instance to a {@link FieldDerivativeStructure}.
* @return derivative structure with same value and derivative as the instance
*/
@Override
public FieldDerivativeStructure<T> toDerivativeStructure() {
return getField().getConversionFactory().build(f0, f1);
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> add(final double a) {
return new FieldUnivariateDerivative1<>(f0.add(a), f1);
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> add(final FieldUnivariateDerivative1<T> a) {
return new FieldUnivariateDerivative1<>(f0.add(a.f0), f1.add(a.f1));
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> subtract(final double a) {
return new FieldUnivariateDerivative1<>(f0.subtract(a), f1);
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> subtract(final FieldUnivariateDerivative1<T> a) {
return new FieldUnivariateDerivative1<>(f0.subtract(a.f0), f1.subtract(a.f1));
}
/** '×' operator.
* @param a right hand side parameter of the operator
* @return this×a
*/
public FieldUnivariateDerivative1<T> multiply(final T a) {
return new FieldUnivariateDerivative1<>(f0.multiply(a), f1.multiply(a));
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> multiply(final int n) {
return new FieldUnivariateDerivative1<>(f0.multiply(n), f1.multiply(n));
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> multiply(final double a) {
return new FieldUnivariateDerivative1<>(f0.multiply(a), f1.multiply(a));
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> multiply(final FieldUnivariateDerivative1<T> a) {
return new FieldUnivariateDerivative1<>(f0.multiply(a.f0),
a.f0.linearCombination(f1, a.f0, f0, a.f1));
}
/** '÷' operator.
* @param a right hand side parameter of the operator
* @return this÷a
*/
public FieldUnivariateDerivative1<T> divide(final T a) {
final T inv1 = a.reciprocal();
return new FieldUnivariateDerivative1<>(f0.multiply(inv1), f1.multiply(inv1));
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> divide(final double a) {
final double inv1 = 1.0 / a;
return new FieldUnivariateDerivative1<>(f0.multiply(inv1), f1.multiply(inv1));
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> divide(final FieldUnivariateDerivative1<T> a) {
final T inv1 = a.f0.reciprocal();
final T inv2 = inv1.multiply(inv1);
return new FieldUnivariateDerivative1<>(f0.multiply(inv1),
a.f0.linearCombination(f1, a.f0, f0.negate(), a.f1).multiply(inv2));
}
/** IEEE remainder operator.
* @param a right hand side parameter of the operator
* @return 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)
*/
public FieldUnivariateDerivative1<T> remainder(final T a) {
return new FieldUnivariateDerivative1<>(FastMath.IEEEremainder(f0, a), f1);
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> remainder(final double a) {
return new FieldUnivariateDerivative1<>(FastMath.IEEEremainder(f0, a), f1);
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> remainder(final FieldUnivariateDerivative1<T> a) {
// compute k such that lhs % rhs = lhs - k rhs
final T rem = FastMath.IEEEremainder(f0, a.f0);
final T k = FastMath.rint(f0.subtract(rem).divide(a.f0));
return new FieldUnivariateDerivative1<>(rem, f1.subtract(k.multiply(a.f1)));
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> negate() {
return new FieldUnivariateDerivative1<>(f0.negate(), f1.negate());
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> abs() {
if (Double.doubleToLongBits(f0.getReal()) < 0) {
// we use the bits representation to also handle -0.0
return negate();
} else {
return this;
}
}
/**
* Returns the instance with the sign of the argument.
* A NaN {@code sign} argument is treated as positive.
*
* @param sign the sign for the returned value
* @return the instance with the same sign as the {@code sign} argument
*/
public FieldUnivariateDerivative1<T> copySign(final T sign) {
long m = Double.doubleToLongBits(f0.getReal());
long s = Double.doubleToLongBits(sign.getReal());
if ((m >= 0 && s >= 0) || (m < 0 && s < 0)) { // Sign is currently OK
return this;
}
return negate(); // flip sign
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> copySign(final FieldUnivariateDerivative1<T> sign) {
long m = Double.doubleToLongBits(f0.getReal());
long s = Double.doubleToLongBits(sign.f0.getReal());
if ((m >= 0 && s >= 0) || (m < 0 && s < 0)) { // Sign is currently OK
return this;
}
return negate(); // flip sign
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> copySign(final double sign) {
long m = Double.doubleToLongBits(f0.getReal());
long s = Double.doubleToLongBits(sign);
if ((m >= 0 && s >= 0) || (m < 0 && s < 0)) { // Sign is currently OK
return this;
}
return negate(); // flip sign
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> scalb(final int n) {
return new FieldUnivariateDerivative1<>(FastMath.scalb(f0, n), FastMath.scalb(f1, n));
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> hypot(final FieldUnivariateDerivative1<T> y) {
if (Double.isInfinite(f0.getReal()) || Double.isInfinite(y.f0.getReal())) {
return new FieldUnivariateDerivative1<>(f0.newInstance(Double.POSITIVE_INFINITY),
f0.getField().getZero());
} else if (Double.isNaN(f0.getReal()) || Double.isNaN(y.f0.getReal())) {
return new FieldUnivariateDerivative1<>(f0.newInstance(Double.NaN),
f0.getField().getZero());
} else {
final int expX = getExponent();
final int expY = y.getExponent();
if (expX > expY + 27) {
// y is negligible with respect to x
return abs();
} else if (expY > expX + 27) {
// x is negligible with respect to y
return y.abs();
} else {
// find an intermediate scale to avoid both overflow and underflow
final int middleExp = (expX + expY) / 2;
// scale parameters without losing precision
final FieldUnivariateDerivative1<T> scaledX = scalb(-middleExp);
final FieldUnivariateDerivative1<T> scaledY = y.scalb(-middleExp);
// compute scaled hypotenuse
final FieldUnivariateDerivative1<T> scaledH =
scaledX.multiply(scaledX).add(scaledY.multiply(scaledY)).sqrt();
// remove scaling
return scaledH.scalb(middleExp);
}
}
}
/** Compute composition of the instance by a function.
* @param g0 value of the function at the current point (i.e. at {@code g(getValue())})
* @param g1 first derivative of the function at the current point (i.e. at {@code g'(getValue())})
* @return g(this)
*/
@Override
public FieldUnivariateDerivative1<T> compose(final T g0, final T g1) {
return new FieldUnivariateDerivative1<>(g0, g1.multiply(f1));
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> rootN(final int n) {
if (n == 2) {
return sqrt();
} else if (n == 3) {
return cbrt();
} else {
final T r = FastMath.pow(f0, 1.0 / n);
return compose(r, FastMath.pow(r, n - 1).multiply(n).reciprocal());
}
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1Field<T> getField() {
return FieldUnivariateDerivative1Field.getUnivariateDerivative1Field(f0.getField());
}
/** Compute a<sup>x</sup> where a is a double and x a {@link FieldUnivariateDerivative1}
* @param a number to exponentiate
* @param x power to apply
* @param <T> the type of the function parameters and value
* @return a<sup>x</sup>
*/
public static <T extends CalculusFieldElement<T>> FieldUnivariateDerivative1<T> pow(final double a, final FieldUnivariateDerivative1<T> x) {
if (a == 0) {
return x.getField().getZero();
} else {
final T aX = FastMath.pow(x.f0.newInstance(a), x.f0);
return new FieldUnivariateDerivative1<>(aX, aX.multiply(FastMath.log(a)).multiply(x.f1));
}
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> pow(final double p) {
if (p == 0) {
return getField().getOne();
} else {
final T f0Pm1 = FastMath.pow(f0, p - 1);
return compose(f0Pm1.multiply(f0), f0Pm1.multiply(p));
}
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> pow(final int n) {
if (n == 0) {
return getField().getOne();
} else {
final T f0Nm1 = FastMath.pow(f0, n - 1);
return compose(f0Nm1.multiply(f0), f0Nm1.multiply(n));
}
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> atan2(final FieldUnivariateDerivative1<T> x) {
final T inv = f0.square().add(x.f0.multiply(x.f0)).reciprocal();
return new FieldUnivariateDerivative1<>(FastMath.atan2(f0, x.f0),
f0.linearCombination(x.f0, f1, x.f1.negate(), f0).multiply(inv));
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> toDegrees() {
return new FieldUnivariateDerivative1<>(FastMath.toDegrees(f0), FastMath.toDegrees(f1));
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> toRadians() {
return new FieldUnivariateDerivative1<>(FastMath.toRadians(f0), FastMath.toRadians(f1));
}
/** Evaluate Taylor expansion of a univariate derivative.
* @param delta parameter offset Δx
* @return value of the Taylor expansion at x + Δx
*/
public T taylor(final double delta) {
return f0.add(f1.multiply(delta));
}
/** Evaluate Taylor expansion of a univariate derivative.
* @param delta parameter offset Δx
* @return value of the Taylor expansion at x + Δx
*/
public T taylor(final T delta) {
return f0.add(f1.multiply(delta));
}
/**
* Compute a linear combination.
* @param a Factors.
* @param b Factors.
* @return <code>Σ<sub>i</sub> a<sub>i</sub> b<sub>i</sub></code>.
* @throws MathIllegalArgumentException if arrays dimensions don't match
*/
public FieldUnivariateDerivative1<T> linearCombination(final T[] a, final FieldUnivariateDerivative1<T>[] b) {
// extract values and first derivatives
final Field<T> field = b[0].f0.getField();
final int n = b.length;
final T[] b0 = MathArrays.buildArray(field, n);
final T[] b1 = MathArrays.buildArray(field, n);
for (int i = 0; i < n; ++i) {
b0[i] = b[i].f0;
b1[i] = b[i].f1;
}
return new FieldUnivariateDerivative1<>(b[0].f0.linearCombination(a, b0),
b[0].f0.linearCombination(a, b1));
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> linearCombination(final FieldUnivariateDerivative1<T>[] a,
final FieldUnivariateDerivative1<T>[] b) {
// extract values and first derivatives
final Field<T> field = a[0].f0.getField();
final int n = a.length;
final T[] a0 = MathArrays.buildArray(field, n);
final T[] b0 = MathArrays.buildArray(field, n);
final T[] a1 = MathArrays.buildArray(field, 2 * n);
final T[] b1 = MathArrays.buildArray(field, 2 * n);
for (int i = 0; i < n; ++i) {
final FieldUnivariateDerivative1<T> ai = a[i];
final FieldUnivariateDerivative1<T> bi = b[i];
a0[i] = ai.f0;
b0[i] = bi.f0;
a1[2 * i] = ai.f0;
a1[2 * i + 1] = ai.f1;
b1[2 * i] = bi.f1;
b1[2 * i + 1] = bi.f0;
}
return new FieldUnivariateDerivative1<>(a[0].f0.linearCombination(a0, b0),
a[0].f0.linearCombination(a1, b1));
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> linearCombination(final double[] a, final FieldUnivariateDerivative1<T>[] b) {
// extract values and first derivatives
final Field<T> field = b[0].f0.getField();
final int n = b.length;
final T[] b0 = MathArrays.buildArray(field, n);
final T[] b1 = MathArrays.buildArray(field, n);
for (int i = 0; i < n; ++i) {
b0[i] = b[i].f0;
b1[i] = b[i].f1;
}
return new FieldUnivariateDerivative1<>(b[0].f0.linearCombination(a, b0),
b[0].f0.linearCombination(a, b1));
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> linearCombination(final FieldUnivariateDerivative1<T> a1, final FieldUnivariateDerivative1<T> b1,
final FieldUnivariateDerivative1<T> a2, final FieldUnivariateDerivative1<T> b2) {
return new FieldUnivariateDerivative1<>(a1.f0.linearCombination(a1.f0, b1.f0,
a2.f0, b2.f0),
a1.f0.linearCombination(a1.f0, b1.f1,
a1.f1, b1.f0,
a2.f0, b2.f1,
a2.f1, b2.f0));
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> linearCombination(final double a1, final FieldUnivariateDerivative1<T> b1,
final double a2, final FieldUnivariateDerivative1<T> b2) {
return new FieldUnivariateDerivative1<>(b1.f0.linearCombination(a1, b1.f0,
a2, b2.f0),
b1.f0.linearCombination(a1, b1.f1,
a2, b2.f1));
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> linearCombination(final FieldUnivariateDerivative1<T> a1, final FieldUnivariateDerivative1<T> b1,
final FieldUnivariateDerivative1<T> a2, final FieldUnivariateDerivative1<T> b2,
final FieldUnivariateDerivative1<T> a3, final FieldUnivariateDerivative1<T> b3) {
final Field<T> field = a1.f0.getField();
final T[] a = MathArrays.buildArray(field, 6);
final T[] b = MathArrays.buildArray(field, 6);
a[0] = a1.f0;
a[1] = a1.f1;
a[2] = a2.f0;
a[3] = a2.f1;
a[4] = a3.f0;
a[5] = a3.f1;
b[0] = b1.f1;
b[1] = b1.f0;
b[2] = b2.f1;
b[3] = b2.f0;
b[4] = b3.f1;
b[5] = b3.f0;
return new FieldUnivariateDerivative1<>(a1.f0.linearCombination(a1.f0, b1.f0,
a2.f0, b2.f0,
a3.f0, b3.f0),
a1.f0.linearCombination(a, b));
}
/**
* Compute a linear combination.
* @param a1 first factor of the first term
* @param b1 second factor of the first term
* @param a2 first factor of the second term
* @param b2 second factor of the second term
* @param a3 first factor of the third term
* @param b3 second factor of the third term
* @return a<sub>1</sub>×b<sub>1</sub> +
* a<sub>2</sub>×b<sub>2</sub> + a<sub>3</sub>×b<sub>3</sub>
* @see #linearCombination(double, FieldUnivariateDerivative1, double, FieldUnivariateDerivative1)
* @see #linearCombination(double, FieldUnivariateDerivative1, double, FieldUnivariateDerivative1, double, FieldUnivariateDerivative1, double, FieldUnivariateDerivative1)
* @exception MathIllegalArgumentException if number of free parameters or orders are inconsistent
*/
public FieldUnivariateDerivative1<T> linearCombination(final T a1, final FieldUnivariateDerivative1<T> b1,
final T a2, final FieldUnivariateDerivative1<T> b2,
final T a3, final FieldUnivariateDerivative1<T> b3) {
return new FieldUnivariateDerivative1<>(b1.f0.linearCombination(a1, b1.f0,
a2, b2.f0,
a3, b3.f0),
b1.f0.linearCombination(a1, b1.f1,
a2, b2.f1,
a3, b3.f1));
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> linearCombination(final double a1, final FieldUnivariateDerivative1<T> b1,
final double a2, final FieldUnivariateDerivative1<T> b2,
final double a3, final FieldUnivariateDerivative1<T> b3) {
return new FieldUnivariateDerivative1<>(b1.f0.linearCombination(a1, b1.f0,
a2, b2.f0,
a3, b3.f0),
b1.f0.linearCombination(a1, b1.f1,
a2, b2.f1,
a3, b3.f1));
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> linearCombination(final FieldUnivariateDerivative1<T> a1, final FieldUnivariateDerivative1<T> b1,
final FieldUnivariateDerivative1<T> a2, final FieldUnivariateDerivative1<T> b2,
final FieldUnivariateDerivative1<T> a3, final FieldUnivariateDerivative1<T> b3,
final FieldUnivariateDerivative1<T> a4, final FieldUnivariateDerivative1<T> b4) {
final Field<T> field = a1.f0.getField();
final T[] a = MathArrays.buildArray(field, 8);
final T[] b = MathArrays.buildArray(field, 8);
a[0] = a1.f0;
a[1] = a1.f1;
a[2] = a2.f0;
a[3] = a2.f1;
a[4] = a3.f0;
a[5] = a3.f1;
a[6] = a4.f0;
a[7] = a4.f1;
b[0] = b1.f1;
b[1] = b1.f0;
b[2] = b2.f1;
b[3] = b2.f0;
b[4] = b3.f1;
b[5] = b3.f0;
b[6] = b4.f1;
b[7] = b4.f0;
return new FieldUnivariateDerivative1<>(a1.f0.linearCombination(a1.f0, b1.f0,
a2.f0, b2.f0,
a3.f0, b3.f0,
a4.f0, b4.f0),
a1.f0.linearCombination(a, b));
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> linearCombination(final double a1, final FieldUnivariateDerivative1<T> b1,
final double a2, final FieldUnivariateDerivative1<T> b2,
final double a3, final FieldUnivariateDerivative1<T> b3,
final double a4, final FieldUnivariateDerivative1<T> b4) {
return new FieldUnivariateDerivative1<>(b1.f0.linearCombination(a1, b1.f0,
a2, b2.f0,
a3, b3.f0,
a4, b4.f0),
b1.f0.linearCombination(a1, b1.f1,
a2, b2.f1,
a3, b3.f1,
a4, b4.f1));
}
/** {@inheritDoc} */
@Override
public FieldUnivariateDerivative1<T> getPi() {
final T zero = getValueField().getZero();
return new FieldUnivariateDerivative1<>(zero.getPi(), zero);
}
/** Test for the equality of two univariate derivatives.
* <p>
* univariate derivatives are considered equal if they have the same derivatives.
* </p>
* @param other Object to test for equality to this
* @return true if two univariate derivatives are equal
*/
@Override
public boolean equals(Object other) {
if (this == other) {
return true;
}
if (other instanceof FieldUnivariateDerivative1) {
@SuppressWarnings("unchecked")
final FieldUnivariateDerivative1<T> rhs = (FieldUnivariateDerivative1<T>) other;
return f0.equals(rhs.f0) && f1.equals(rhs.f1);
}
return false;
}
/** Get a hashCode for the univariate derivative.
* @return a hash code value for this object
*/
@Override
public int hashCode() {
return 453 - 19 * f0.hashCode() + 37 * f1.hashCode();
}
}