diff --git a/hipparchus-core/src/changes/changes.xml b/hipparchus-core/src/changes/changes.xml
index d2f40ba4a..05bccac5b 100644
--- a/hipparchus-core/src/changes/changes.xml
+++ b/hipparchus-core/src/changes/changes.xml
@@ -50,6 +50,9 @@ If the output is not quite correct, check for invisible trailing spaces!
+
+ Add default implementations in CalculusFieldElement.
+
Add square method to FieldElement.
diff --git a/hipparchus-core/src/main/java/org/hipparchus/CalculusFieldElement.java b/hipparchus-core/src/main/java/org/hipparchus/CalculusFieldElement.java
index a7f57eb88..2e2da0dbd 100644
--- a/hipparchus-core/src/main/java/org/hipparchus/CalculusFieldElement.java
+++ b/hipparchus-core/src/main/java/org/hipparchus/CalculusFieldElement.java
@@ -25,6 +25,7 @@
import org.hipparchus.util.FastMath;
import org.hipparchus.util.FieldSinCos;
import org.hipparchus.util.FieldSinhCosh;
+import org.hipparchus.util.MathArrays;
/**
* Interface representing a field
@@ -42,7 +43,9 @@ public interface CalculusFieldElement> extends FieldEl
* @return Archimedes constant π
* @since 2.0
*/
- T getPi();
+ default T getPi() {
+ return newInstance(FastMath.PI);
+ }
/** Create an instance corresponding to a constant real value.
* @param value constant real value
@@ -50,29 +53,49 @@ public interface CalculusFieldElement> extends FieldEl
*/
T newInstance(double value);
+ /** {@inheritDoc} */
+ @Override
+ default T multiply(int n) {
+ return multiply((double) n);
+ }
+
/** '+' operator.
* @param a right hand side parameter of the operator
* @return this+a
*/
- T add(double a);
+ default T add(double a) {
+ return add(newInstance(a));
+ }
/** '-' operator.
* @param a right hand side parameter of the operator
* @return this-a
*/
- T subtract(double a);
+ default T subtract(double a) {
+ return subtract(newInstance(a));
+ }
/** '×' operator.
* @param a right hand side parameter of the operator
* @return this×a
*/
- T multiply(double a);
+ default T multiply(double a) {
+ return multiply(newInstance(a));
+ }
/** '÷' operator.
* @param a right hand side parameter of the operator
* @return this÷a
*/
- T divide(double a);
+ default T divide(double a) {
+ return divide(newInstance(a));
+ }
+
+ /** {@inheritDoc} */
+ @Override
+ default T subtract(T a) {
+ return add(a.negate());
+ }
/**
* Return the exponent of the instance, removing the bias.
@@ -119,23 +142,31 @@ T hypot(T y)
/** {@inheritDoc} */
@Override
- T reciprocal();
+ default T divide(T a) {
+ return multiply(a.reciprocal());
+ }
/** Square root.
* @return square root of the instance
*/
- T sqrt();
+ default T sqrt() {
+ return rootN(2);
+ }
/** Cubic root.
* @return cubic root of the instance
*/
- T cbrt();
+ default T cbrt() {
+ return rootN(3);
+ }
/** Nth root.
* @param n order of the root
* @return nth root of the instance
*/
- T rootN(int n);
+ default T rootN(int n) {
+ return pow(1. / n);
+ }
/** {@inheritDoc} */
@Override
@@ -147,13 +178,17 @@ default T square() {
* @param p power to apply
* @return thisp
*/
- T pow(double p);
+ default T pow(double p) {
+ return pow(newInstance(p));
+ }
/** Integer power operation.
* @param n power to apply
* @return thisn
*/
- T pow(int n);
+ default T pow(int n) {
+ return pow((double) n);
+ }
/** Power operation.
* @param e exponent
@@ -202,12 +237,16 @@ T pow(T e)
* @return [sin(this), cos(this)]
* @since 1.4
*/
- FieldSinCos sinCos();
+ default FieldSinCos sinCos() {
+ return new FieldSinCos<>(sin(), cos());
+ }
/** Tangent operation.
* @return tan(this)
*/
- T tan();
+ default T tan() {
+ return sin().divide(cos());
+ }
/** Arc cosine operation.
* @return acos(this)
@@ -259,12 +298,16 @@ T atan2(T x)
* @return [sinh(this), cosh(this)]
* @since 2.0
*/
- FieldSinhCosh sinhCosh();
+ default FieldSinhCosh sinhCosh() {
+ return new FieldSinhCosh<>(sinh(), cosh());
+ }
/** Hyperbolic tangent operation.
* @return tanh(this)
*/
- T tanh();
+ default T tanh() {
+ return sinh().divide(cosh());
+ }
/** Inverse hyperbolic cosine operation.
* @return acosh(this)
@@ -284,12 +327,16 @@ T atan2(T x)
/** Convert radians to degrees, with error of less than 0.5 ULP
* @return instance converted into degrees
*/
- T toDegrees();
+ default T toDegrees() {
+ return multiply(FastMath.toDegrees(1.));
+ }
/** Convert degrees to radians, with error of less than 0.5 ULP
* @return instance converted into radians
*/
- T toRadians();
+ default T toRadians() {
+ return multiply(FastMath.toRadians(1.));
+ }
/**
* Compute a linear combination.
@@ -308,8 +355,13 @@ T linearCombination(T[] a, T[] b)
* @return Σi ai bi
.
* @throws MathIllegalArgumentException if arrays dimensions don't match
*/
- T linearCombination(double[] a, T[] b)
- throws MathIllegalArgumentException;
+ default T linearCombination(double[] a, T[] b) throws MathIllegalArgumentException {
+ final T[] newInstances = MathArrays.buildArray(getField(), a.length);
+ for (int i = 0; i < a.length; i++) {
+ newInstances[i] = newInstance(a[i]);
+ }
+ return linearCombination(newInstances, b);
+ }
/**
* Compute a linear combination.
@@ -335,7 +387,9 @@ T linearCombination(double[] a, T[] b)
* @see #linearCombination(double, FieldElement, double, FieldElement, double, FieldElement)
* @see #linearCombination(double, FieldElement, double, FieldElement, double, FieldElement, double, FieldElement)
*/
- T linearCombination(double a1, T b1, double a2, T b2);
+ default T linearCombination(double a1, T b1, double a2, T b2) {
+ return linearCombination(newInstance(a1), b1, newInstance(a2), b2);
+ }
/**
* Compute a linear combination.
@@ -365,7 +419,9 @@ T linearCombination(double[] a, T[] b)
* @see #linearCombination(double, FieldElement, double, FieldElement)
* @see #linearCombination(double, FieldElement, double, FieldElement, double, FieldElement, double, FieldElement)
*/
- T linearCombination(double a1, T b1, double a2, T b2, double a3, T b3);
+ default T linearCombination(double a1, T b1, double a2, T b2, double a3, T b3) {
+ return linearCombination(newInstance(a1), b1, newInstance(a2), b2, newInstance(a3), b3);
+ }
/**
* Compute a linear combination.
@@ -401,7 +457,10 @@ T linearCombination(double[] a, T[] b)
* @see #linearCombination(double, FieldElement, double, FieldElement)
* @see #linearCombination(double, FieldElement, double, FieldElement, double, FieldElement)
*/
- T linearCombination(double a1, T b1, double a2, T b2, double a3, T b3, double a4, T b4);
+ default T linearCombination(double a1, T b1, double a2, T b2, double a3, T b3, double a4, T b4) {
+ return linearCombination(newInstance(a1), b1, newInstance(a2), b2, newInstance(a3), b3,
+ newInstance(a4), b4);
+ }
/** Get the smallest whole number larger than instance.
* @return ceil(this)
@@ -422,7 +481,9 @@ T linearCombination(double[] a, T[] b)
* @param a right hand side parameter of the operator
* @return this - n × a where n is the closest integer to this/a
*/
- T remainder(double a);
+ default T remainder(double a) {
+ return remainder(newInstance(a));
+ }
/** IEEE remainder operator.
* @param a right hand side parameter of the operator
@@ -454,7 +515,9 @@ T linearCombination(double[] a, T[] b)
* @param sign the sign for the returned value
* @return the instance with the same sign as the {@code sign} argument
*/
- T copySign(double sign);
+ default T copySign(double sign) {
+ return copySign(newInstance(sign));
+ }
/**
* Check if the instance is infinite.
@@ -490,9 +553,6 @@ default double norm() {
}
/** absolute value.
- *
- * Just another name for {@link #norm()}
- *
* @return abs(this)
*/
T abs();
diff --git a/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/Derivative.java b/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/Derivative.java
index 0ea90bf13..d8bf56930 100644
--- a/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/Derivative.java
+++ b/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/Derivative.java
@@ -25,6 +25,12 @@
*/
public interface Derivative> extends CalculusFieldElement {
+ /** {@inheritDoc} */
+ @Override
+ default double getReal() {
+ return getValue();
+ }
+
/** Get the number of free parameters.
* @return number of free parameters
*/
diff --git a/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/DerivativeStructure.java b/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/DerivativeStructure.java
index 0d8d5ce29..ac2a8db46 100644
--- a/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/DerivativeStructure.java
+++ b/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/DerivativeStructure.java
@@ -146,13 +146,6 @@ void setDerivativeComponent(final int index, final double value) {
return data[index];
}
- /** {@inheritDoc}
- */
- @Override
- public double getReal() {
- return data[0];
- }
-
/** Get the value part of the derivative structure.
* @return value part of the derivative structure
* @see #getPartialDerivative(int...)
@@ -220,12 +213,6 @@ public DerivativeStructure subtract(final DerivativeStructure a)
return ds;
}
- /** {@inheritDoc} */
- @Override
- public DerivativeStructure multiply(final int n) {
- return multiply((double) n);
- }
-
/** {@inheritDoc}
*/
@Override
@@ -515,13 +502,6 @@ public DerivativeStructure sqrt() {
return result;
}
- /** {@inheritDoc}
- */
- @Override
- public DerivativeStructure cbrt() {
- return rootN(3);
- }
-
/** {@inheritDoc}
*/
@Override
diff --git a/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/FieldDerivativeStructure.java b/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/FieldDerivativeStructure.java
index 07e2afccb..68039b2fe 100644
--- a/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/FieldDerivativeStructure.java
+++ b/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/FieldDerivativeStructure.java
@@ -228,12 +228,6 @@ public FieldDerivativeStructure multiply(final T a) {
return ds;
}
- /** {@inheritDoc} */
- @Override
- public FieldDerivativeStructure multiply(final int n) {
- return multiply((double) n);
- }
-
/** {@inheritDoc}
*/
@Override
@@ -581,13 +575,6 @@ public FieldDerivativeStructure sqrt() {
return result;
}
- /** {@inheritDoc}
- */
- @Override
- public FieldDerivativeStructure cbrt() {
- return rootN(3);
- }
-
/** {@inheritDoc}
*/
@Override
diff --git a/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/Gradient.java b/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/Gradient.java
index c8558ae50..76ef96a0b 100644
--- a/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/Gradient.java
+++ b/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/Gradient.java
@@ -125,12 +125,6 @@ public Gradient newInstance(final double c) {
return new Gradient(c, new double[grad.length]);
}
- /** {@inheritDoc} */
- @Override
- public double getReal() {
- return getValue();
- }
-
/** Get the value part of the function.
* @return value part of the value of the function
*/
diff --git a/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/UnivariateDerivative1.java b/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/UnivariateDerivative1.java
index 6815841ba..c6ed2d087 100644
--- a/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/UnivariateDerivative1.java
+++ b/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/UnivariateDerivative1.java
@@ -94,12 +94,6 @@ public UnivariateDerivative1 newInstance(final double value) {
return new UnivariateDerivative1(value, 0.0);
}
- /** {@inheritDoc} */
- @Override
- public double getReal() {
- return getValue();
- }
-
/** {@inheritDoc} */
@Override
public double getValue() {
diff --git a/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/UnivariateDerivative2.java b/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/UnivariateDerivative2.java
index c916b22e0..450a60486 100644
--- a/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/UnivariateDerivative2.java
+++ b/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/UnivariateDerivative2.java
@@ -100,12 +100,6 @@ public UnivariateDerivative2 newInstance(final double value) {
return new UnivariateDerivative2(value, 0.0, 0.0);
}
- /** {@inheritDoc} */
- @Override
- public double getReal() {
- return getValue();
- }
-
/** {@inheritDoc} */
@Override
public double getValue() {
diff --git a/hipparchus-core/src/main/java/org/hipparchus/dfp/Dfp.java b/hipparchus-core/src/main/java/org/hipparchus/dfp/Dfp.java
index 312f737bf..6962a3db2 100644
--- a/hipparchus-core/src/main/java/org/hipparchus/dfp/Dfp.java
+++ b/hipparchus-core/src/main/java/org/hipparchus/dfp/Dfp.java
@@ -2686,41 +2686,6 @@ public double getReal() {
return toDouble();
}
- /** {@inheritDoc}
- */
- @Override
- public Dfp add(final double a) {
- return add(newInstance(a));
- }
-
- /** {@inheritDoc}
- */
- @Override
- public Dfp subtract(final double a) {
- return subtract(newInstance(a));
- }
-
- /** {@inheritDoc}
- */
- @Override
- public Dfp multiply(final double a) {
- return multiply(newInstance(a));
- }
-
- /** {@inheritDoc}
- */
- @Override
- public Dfp divide(final double a) {
- return divide(newInstance(a));
- }
-
- /** {@inheritDoc}
- */
- @Override
- public Dfp remainder(final double a) {
- return remainder(newInstance(a));
- }
-
/** {@inheritDoc}
*/
@Override
@@ -2828,13 +2793,6 @@ public Dfp hypot(final Dfp y) {
}
- /** {@inheritDoc}
- */
- @Override
- public Dfp cbrt() {
- return rootN(3);
- }
-
/** {@inheritDoc}
*/
@Override
@@ -2914,13 +2872,6 @@ public Dfp sin() {
return DfpMath.sin(this);
}
- /** {@inheritDoc}
- */
- @Override
- public FieldSinCos sinCos() {
- return new FieldSinCos<>(DfpMath.sin(this), DfpMath.cos(this));
- }
-
/** {@inheritDoc}
*/
@Override
diff --git a/hipparchus-core/src/test/java/org/hipparchus/CalculusFieldElementTest.java b/hipparchus-core/src/test/java/org/hipparchus/CalculusFieldElementTest.java
new file mode 100644
index 000000000..64da4b84d
--- /dev/null
+++ b/hipparchus-core/src/test/java/org/hipparchus/CalculusFieldElementTest.java
@@ -0,0 +1,579 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF 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;
+
+import org.hipparchus.exception.MathIllegalArgumentException;
+import org.hipparchus.exception.MathRuntimeException;
+import org.hipparchus.exception.NullArgumentException;
+import org.hipparchus.util.FastMath;
+import org.junit.Assert;
+import org.junit.Test;
+
+public class CalculusFieldElementTest {
+
+ @Test
+ public void testMultiplyInt() {
+ // GIVEN
+ final double value = 3.;
+ final int factor = 2;
+ final TestCalculusFieldElement testElement = new TestCalculusFieldElement(value);
+ // WHEN
+ final TestCalculusFieldElement actualOperation = testElement.multiply(factor);
+ // THEN
+ final TestCalculusFieldElement expectedOperation = new TestCalculusFieldElement(value * factor);
+ Assert.assertEquals(expectedOperation, actualOperation);
+ }
+
+ @Test
+ public void testAddDouble() {
+ // GIVEN
+ final double value1 = 1.;
+ final double value2 = 2.;
+ final TestCalculusFieldElement testElement1 = new TestCalculusFieldElement(value1);
+ // WHEN
+ final TestCalculusFieldElement actualOperation = testElement1.add(value2);
+ // THEN
+ final TestCalculusFieldElement expectedOperation = new TestCalculusFieldElement(value1 + value2);
+ Assert.assertEquals(expectedOperation, actualOperation);
+ }
+
+ @Test
+ public void testSubtractDouble() {
+ // GIVEN
+ final double value1 = 1.;
+ final double value2 = 2.;
+ final TestCalculusFieldElement testElement1 = new TestCalculusFieldElement(value1);
+ // WHEN
+ final TestCalculusFieldElement actualOperation = testElement1.subtract(value2);
+ // THEN
+ final TestCalculusFieldElement expectedOperation = new TestCalculusFieldElement(value1 - value2);
+ Assert.assertEquals(expectedOperation, actualOperation);
+ }
+
+ @Test
+ public void testMultiplyDouble() {
+ // GIVEN
+ final double value1 = 3.;
+ final double value2 = 2.;
+ final TestCalculusFieldElement testElement1 = new TestCalculusFieldElement(value1);
+ // WHEN
+ final TestCalculusFieldElement actualOperation = testElement1.multiply(value2);
+ // THEN
+ final TestCalculusFieldElement expectedOperation = new TestCalculusFieldElement(value1 * value2);
+ Assert.assertEquals(expectedOperation, actualOperation);
+ }
+
+ @Test
+ public void testDivideDouble() {
+ // GIVEN
+ final double value1 = 3.;
+ final double value2 = 2.;
+ final TestCalculusFieldElement testElement1 = new TestCalculusFieldElement(value1);
+ // WHEN
+ final TestCalculusFieldElement actualOperation = testElement1.divide(value2);
+ // THEN
+ final TestCalculusFieldElement expectedOperation = new TestCalculusFieldElement(value1 / value2);
+ Assert.assertEquals(expectedOperation, actualOperation);
+ }
+
+ @Test
+ public void testSubtract() {
+ // GIVEN
+ final double value1 = 1.;
+ final double value2 = 2.;
+ final TestCalculusFieldElement testElement1 = new TestCalculusFieldElement(value1);
+ final TestCalculusFieldElement testElement2 = new TestCalculusFieldElement(value2);
+ // WHEN
+ final TestCalculusFieldElement actualOperation = testElement1.subtract(testElement2);
+ // THEN
+ final TestCalculusFieldElement expectedOperation = new TestCalculusFieldElement(value1 - value2);
+ Assert.assertEquals(expectedOperation, actualOperation);
+ }
+
+ @Test
+ public void testDivide() {
+ // GIVEN
+ final double value1 = 3.;
+ final double value2 = 2.;
+ final TestCalculusFieldElement testElement1 = new TestCalculusFieldElement(value1);
+ final TestCalculusFieldElement testElement2 = new TestCalculusFieldElement(value2);
+ // WHEN
+ final TestCalculusFieldElement actualOperation = testElement1.divide(testElement2);
+ // THEN
+ final TestCalculusFieldElement expectedOperation = new TestCalculusFieldElement(value1 / value2);
+ Assert.assertEquals(expectedOperation, actualOperation);
+ }
+
+ @Test
+ public void testSquare() {
+ // GIVEN
+ final double value = 3.;
+ final TestCalculusFieldElement testElement = new TestCalculusFieldElement(value);
+ // WHEN
+ final TestCalculusFieldElement actualOperation = testElement.square();
+ // THEN
+ final TestCalculusFieldElement expectedOperation = new TestCalculusFieldElement(value * value);
+ Assert.assertEquals(expectedOperation, actualOperation);
+ }
+
+ @Test
+ public void testSqrt() {
+ // GIVEN
+ final double value = 3.;
+ final TestCalculusFieldElement testElement = new TestCalculusFieldElement(value);
+ // WHEN
+ final TestCalculusFieldElement actualOperation = testElement.sqrt();
+ // THEN
+ final TestCalculusFieldElement expectedOperation = new TestCalculusFieldElement(FastMath.sqrt(value));
+ Assert.assertEquals(expectedOperation, actualOperation);
+ }
+
+ @Test
+ public void testCbrt() {
+ // GIVEN
+ final double value = 3.;
+ final TestCalculusFieldElement testElement = new TestCalculusFieldElement(value);
+ // WHEN
+ final TestCalculusFieldElement actualOperation = testElement.cbrt();
+ // THEN
+ final TestCalculusFieldElement expectedOperation = new TestCalculusFieldElement(FastMath.cbrt(value));
+ Assert.assertEquals(expectedOperation, actualOperation);
+ }
+
+ @Test
+ public void testRootN() {
+ // GIVEN
+ final int n = 4;
+ final double value = 3.;
+ final TestCalculusFieldElement testElement = new TestCalculusFieldElement(value);
+ // WHEN
+ final TestCalculusFieldElement actualOperation = testElement.rootN(n);
+ // THEN
+ final TestCalculusFieldElement expectedOperation = new TestCalculusFieldElement(FastMath.pow(value, 1. / n));
+ Assert.assertEquals(expectedOperation, actualOperation);
+ }
+
+ @Test
+ public void testPowInt() {
+ // GIVEN
+ final int exponent = 4;
+ final double value = 3.;
+ final TestCalculusFieldElement testElement = new TestCalculusFieldElement(value);
+ // WHEN
+ final TestCalculusFieldElement actualOperation = testElement.pow(exponent);
+ // THEN
+ final TestCalculusFieldElement expectedOperation = new TestCalculusFieldElement(FastMath.pow(value, exponent));
+ Assert.assertEquals(expectedOperation, actualOperation);
+ }
+
+ @Test
+ public void testPowDouble() {
+ // GIVEN
+ final double exponent = 4.5;
+ final double value = 3.;
+ final TestCalculusFieldElement testElement = new TestCalculusFieldElement(value);
+ // WHEN
+ final TestCalculusFieldElement actualOperation = testElement.pow(exponent);
+ // THEN
+ final TestCalculusFieldElement expectedOperation = new TestCalculusFieldElement(FastMath.pow(value, exponent));
+ Assert.assertEquals(expectedOperation, actualOperation);
+ }
+
+ @Test
+ public void testSin() {
+ // GIVEN
+ final double value = 3.;
+ final TestCalculusFieldElement testElement = new TestCalculusFieldElement(value);
+ // WHEN
+ final TestCalculusFieldElement actualOperation = testElement.sin();
+ // THEN
+ final TestCalculusFieldElement expectedOperation = new TestCalculusFieldElement(FastMath.sin(value));
+ Assert.assertEquals(expectedOperation, actualOperation);
+ }
+
+ @Test
+ public void testCos() {
+ // GIVEN
+ final double value = 3.;
+ final TestCalculusFieldElement testElement = new TestCalculusFieldElement(value);
+ // WHEN
+ final TestCalculusFieldElement actualOperation = testElement.cos();
+ // THEN
+ final TestCalculusFieldElement expectedOperation = new TestCalculusFieldElement(FastMath.cos(value));
+ Assert.assertEquals(expectedOperation, actualOperation);
+ }
+
+ @Test
+ public void testTan() {
+ // GIVEN
+ final double value = 3.;
+ final TestCalculusFieldElement testElement = new TestCalculusFieldElement(value);
+ // WHEN
+ final TestCalculusFieldElement actualOperation = testElement.tan();
+ // THEN
+ final TestCalculusFieldElement expectedOperation = new TestCalculusFieldElement(FastMath.tan(value));
+ Assert.assertEquals(expectedOperation, actualOperation);
+ }
+
+ @Test
+ public void testSinh() {
+ // GIVEN
+ final double value = 3.;
+ final TestCalculusFieldElement testElement = new TestCalculusFieldElement(value);
+ // WHEN
+ final TestCalculusFieldElement actualOperation = testElement.sinh();
+ // THEN
+ final TestCalculusFieldElement expectedOperation = new TestCalculusFieldElement(FastMath.sinh(value));
+ Assert.assertEquals(expectedOperation, actualOperation);
+ }
+
+ @Test
+ public void testCosh() {
+ // GIVEN
+ final double value = 3.;
+ final TestCalculusFieldElement testElement = new TestCalculusFieldElement(value);
+ // WHEN
+ final TestCalculusFieldElement actualOperation = testElement.cosh();
+ // THEN
+ final TestCalculusFieldElement expectedOperation = new TestCalculusFieldElement(FastMath.cosh(value));
+ Assert.assertEquals(expectedOperation, actualOperation);
+ }
+
+ @Test
+ public void testTanh() {
+ // GIVEN
+ final double value = 3.;
+ final TestCalculusFieldElement testElement = new TestCalculusFieldElement(value);
+ // WHEN
+ final TestCalculusFieldElement actualOperation = testElement.tanh();
+ // THEN
+ final TestCalculusFieldElement expectedOperation = new TestCalculusFieldElement(FastMath.tanh(value));
+ Assert.assertEquals(expectedOperation, actualOperation);
+ }
+
+ @Test
+ public void testToDegrees() {
+ // GIVEN
+ final double value = 3.;
+ final TestCalculusFieldElement testElement = new TestCalculusFieldElement(value);
+ // WHEN
+ final TestCalculusFieldElement actualOperation = testElement.toDegrees();
+ // THEN
+ final TestCalculusFieldElement expectedOperation = new TestCalculusFieldElement(FastMath.toDegrees(value));
+ Assert.assertEquals(expectedOperation, actualOperation);
+ }
+
+ @Test
+ public void testToRadians() {
+ // GIVEN
+ final double value = 3.;
+ final TestCalculusFieldElement testElement = new TestCalculusFieldElement(value);
+ // WHEN
+ final TestCalculusFieldElement actualOperation = testElement.toRadians();
+ // THEN
+ final TestCalculusFieldElement expectedOperation = new TestCalculusFieldElement(FastMath.toRadians(value));
+ Assert.assertEquals(expectedOperation, actualOperation);
+ }
+
+ @Test
+ public void testRemainderDouble() {
+ // GIVEN
+ final double divisor = 4.;
+ final double value = 3.;
+ final TestCalculusFieldElement testElement = new TestCalculusFieldElement(value);
+ // WHEN
+ final TestCalculusFieldElement actualOperation = testElement.remainder(divisor);
+ // THEN
+ final TestCalculusFieldElement expectedOperation = new TestCalculusFieldElement(
+ FastMath.IEEEremainder(value, divisor));
+ Assert.assertEquals(expectedOperation, actualOperation);
+ }
+
+ @Test
+ public void testLinearCombinationDouble2() {
+ // GIVEN
+ final double value1 = 3.;
+ final double value2 = 2.;
+ final TestCalculusFieldElement testElement1 = new TestCalculusFieldElement(value1);
+ final TestCalculusFieldElement testElement2 = new TestCalculusFieldElement(value2);
+ final double coeff1 = -5.;
+ final double coeff2 = 4.;
+ // WHEN
+ final TestCalculusFieldElement actualOperation = testElement1.linearCombination(coeff1, testElement1,
+ coeff2, testElement2);
+ // THEN
+ final TestCalculusFieldElement expectedOperation = new TestCalculusFieldElement(
+ coeff1 * value1 + coeff2 * value2);
+ Assert.assertEquals(expectedOperation, actualOperation);
+ }
+
+ @Test
+ public void testLinearCombinationDouble3() {
+ // GIVEN
+ final double value1 = 3.;
+ final double value2 = 2.;
+ final double value3 = -1;
+ final TestCalculusFieldElement testElement1 = new TestCalculusFieldElement(value1);
+ final TestCalculusFieldElement testElement2 = new TestCalculusFieldElement(value2);
+ final TestCalculusFieldElement testElement3 = new TestCalculusFieldElement(value3);
+ final double coeff1 = -5.;
+ final double coeff2 = 4.;
+ final double coeff3 = 6.;
+ // WHEN
+ final TestCalculusFieldElement actualOperation = testElement1.linearCombination(coeff1, testElement1,
+ coeff2, testElement2, coeff3, testElement3);
+ // THEN
+ final TestCalculusFieldElement expectedOperation = new TestCalculusFieldElement(
+ coeff1 * value1 + coeff2 * value2 + coeff3 * value3);
+ Assert.assertEquals(expectedOperation, actualOperation);
+ }
+
+ @Test
+ public void testIsFinite() {
+ Assert.assertTrue(new TestCalculusFieldElement(1.).isFinite());
+ Assert.assertFalse(new TestCalculusFieldElement(Double.NaN).isFinite());
+ Assert.assertFalse(new TestCalculusFieldElement(Double.POSITIVE_INFINITY).isFinite());
+ }
+
+ @Test
+ public void testIsInfinite() {
+ Assert.assertFalse(new TestCalculusFieldElement(1.).isInfinite());
+ Assert.assertTrue(new TestCalculusFieldElement(Double.POSITIVE_INFINITY).isInfinite());
+ }
+
+ @Test
+ public void testIsNan() {
+ Assert.assertFalse(new TestCalculusFieldElement(1.).isNaN());
+ Assert.assertTrue(new TestCalculusFieldElement(Double.NaN).isNaN());
+ }
+
+ @Test
+ public void testNorm() {
+ Assert.assertEquals(0., new TestCalculusFieldElement(0.).norm(), 0.0);
+ }
+
+ private static class TestCalculusFieldElement implements CalculusFieldElement {
+
+ private final double value;
+
+ TestCalculusFieldElement (double value) {
+ this.value = value;
+ }
+
+ @Override
+ public TestCalculusFieldElement newInstance(double value) {
+ return new TestCalculusFieldElement(value);
+ }
+
+ @Override
+ public TestCalculusFieldElement scalb(int n) {
+ return null;
+ }
+
+ @Override
+ public TestCalculusFieldElement ulp() {
+ return null;
+ }
+
+ @Override
+ public TestCalculusFieldElement hypot(TestCalculusFieldElement y) throws MathIllegalArgumentException {
+ return null;
+ }
+
+ @Override
+ public TestCalculusFieldElement pow(TestCalculusFieldElement e) throws MathIllegalArgumentException {
+ return new TestCalculusFieldElement(FastMath.pow(value, e.value));
+ }
+
+ @Override
+ public TestCalculusFieldElement exp() {
+ return null;
+ }
+
+ @Override
+ public TestCalculusFieldElement expm1() {
+ return null;
+ }
+
+ @Override
+ public TestCalculusFieldElement log() {
+ return null;
+ }
+
+ @Override
+ public TestCalculusFieldElement log1p() {
+ return null;
+ }
+
+ @Override
+ public TestCalculusFieldElement log10() {
+ return null;
+ }
+
+ @Override
+ public TestCalculusFieldElement sin() {
+ return new TestCalculusFieldElement(FastMath.sin(value));
+ }
+
+ @Override
+ public TestCalculusFieldElement cos() {
+ return new TestCalculusFieldElement(FastMath.cos(value));
+ }
+
+ @Override
+ public TestCalculusFieldElement acos() {
+ return null;
+ }
+
+ @Override
+ public TestCalculusFieldElement asin() {
+ return null;
+ }
+
+ @Override
+ public TestCalculusFieldElement atan() {
+ return null;
+ }
+
+ @Override
+ public TestCalculusFieldElement atan2(TestCalculusFieldElement x) throws MathIllegalArgumentException {
+ return null;
+ }
+
+ @Override
+ public TestCalculusFieldElement sinh() {
+ return new TestCalculusFieldElement(FastMath.sinh(value));
+ }
+
+ @Override
+ public TestCalculusFieldElement cosh() {
+ return new TestCalculusFieldElement(FastMath.cosh(value));
+ }
+
+ @Override
+ public TestCalculusFieldElement acosh() {
+ return null;
+ }
+
+ @Override
+ public TestCalculusFieldElement asinh() {
+ return null;
+ }
+
+ @Override
+ public TestCalculusFieldElement atanh() {
+ return null;
+ }
+
+ @Override
+ public TestCalculusFieldElement linearCombination(TestCalculusFieldElement[] a, TestCalculusFieldElement[] b) throws MathIllegalArgumentException {
+ return null;
+ }
+
+ @Override
+ public TestCalculusFieldElement linearCombination(TestCalculusFieldElement a1, TestCalculusFieldElement b1, TestCalculusFieldElement a2, TestCalculusFieldElement b2) {
+ return newInstance(a1.value * b1.value + a2.value * b2.value);
+ }
+
+ @Override
+ public TestCalculusFieldElement linearCombination(TestCalculusFieldElement a1, TestCalculusFieldElement b1, TestCalculusFieldElement a2, TestCalculusFieldElement b2, TestCalculusFieldElement a3, TestCalculusFieldElement b3) {
+ return newInstance(a1.value * b1.value + a2.value * b2.value + a3.value * b3.value);
+ }
+
+ @Override
+ public TestCalculusFieldElement linearCombination(TestCalculusFieldElement a1, TestCalculusFieldElement b1, TestCalculusFieldElement a2, TestCalculusFieldElement b2, TestCalculusFieldElement a3, TestCalculusFieldElement b3, TestCalculusFieldElement a4, TestCalculusFieldElement b4) {
+ return newInstance(a1.value * b1.value + a2.value * b2.value + a3.value * b3.value +
+ a4.value * b4.value);
+ }
+
+ @Override
+ public TestCalculusFieldElement ceil() {
+ return null;
+ }
+
+ @Override
+ public TestCalculusFieldElement floor() {
+ return null;
+ }
+
+ @Override
+ public TestCalculusFieldElement rint() {
+ return null;
+ }
+
+ @Override
+ public TestCalculusFieldElement remainder(TestCalculusFieldElement a) {
+ return new TestCalculusFieldElement(FastMath.IEEEremainder(value, a.value));
+ }
+
+ @Override
+ public TestCalculusFieldElement sign() {
+ return null;
+ }
+
+ @Override
+ public TestCalculusFieldElement copySign(TestCalculusFieldElement sign) {
+ return null;
+ }
+
+ @Override
+ public TestCalculusFieldElement abs() {
+ return null;
+ }
+
+ @Override
+ public double getReal() {
+ return value;
+ }
+
+ @Override
+ public TestCalculusFieldElement add(TestCalculusFieldElement a) throws NullArgumentException {
+ return new TestCalculusFieldElement(value + a.value);
+ }
+
+ @Override
+ public TestCalculusFieldElement negate() {
+ return new TestCalculusFieldElement(-value);
+ }
+
+ @Override
+ public TestCalculusFieldElement multiply(TestCalculusFieldElement a) throws NullArgumentException {
+ return new TestCalculusFieldElement(value * a.value);
+ }
+
+ @Override
+ public TestCalculusFieldElement reciprocal() throws MathRuntimeException {
+ return new TestCalculusFieldElement(1. / value);
+ }
+
+ @Override
+ public Field getField() {
+ return null;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj instanceof TestCalculusFieldElement) {
+ return Double.compare(value, ((TestCalculusFieldElement) obj).value) == 0;
+ } else {
+ return false;
+ }
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/src/changes/changes.xml b/src/changes/changes.xml
index c68b88885..a6b9e3122 100644
--- a/src/changes/changes.xml
+++ b/src/changes/changes.xml
@@ -50,6 +50,9 @@ If the output is not quite correct, check for invisible trailing spaces!
+
+ Add default implementations in CalculusFieldElement.
+
Add square method to FieldElement.