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.