From 666bee04911df3638ca25ecb02bf7fc807d962c8 Mon Sep 17 00:00:00 2001 From: Sean R Date: Fri, 5 Jun 2026 18:28:24 -0400 Subject: [PATCH 1/2] Add some simple unit tests --- .../analysis/differentiation/TaylorMap.java | 2 +- .../analysis/FunctionUtilsTest.java | 44 ++++++++++++++ .../polynomials/PolynomialsUtilsTest.java | 32 ++++++++++ .../hipparchus/complex/QuaternionTest.java | 60 +++++++++++++++++++ 4 files changed, 137 insertions(+), 1 deletion(-) diff --git a/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/TaylorMap.java b/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/TaylorMap.java index 67d6d7af9..da85686ed 100644 --- a/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/TaylorMap.java +++ b/hipparchus-core/src/main/java/org/hipparchus/analysis/differentiation/TaylorMap.java @@ -41,7 +41,7 @@ public class TaylorMap implements DifferentialAlgebra { /** Simple constructor. *

- * The number of number of parameters and derivation orders of all + * The number of parameters and derivation orders of all * functions must match. *

* @param point point at which map is evaluated diff --git a/hipparchus-core/src/test/java/org/hipparchus/analysis/FunctionUtilsTest.java b/hipparchus-core/src/test/java/org/hipparchus/analysis/FunctionUtilsTest.java index b8e82ff19..d554d2ed9 100644 --- a/hipparchus-core/src/test/java/org/hipparchus/analysis/FunctionUtilsTest.java +++ b/hipparchus-core/src/test/java/org/hipparchus/analysis/FunctionUtilsTest.java @@ -118,6 +118,13 @@ void testAdd() { assertEquals(4 - 2, FunctionUtils.add(c, FunctionUtils.compose(m, id)).value(2), EPS); } + @Test + void testAddEmpty() { + assertThrows(ArrayIndexOutOfBoundsException.class, () -> { + FunctionUtils.add(new UnivariateFunction[0]).value(1.0); + }); + } + @Test void testAddDifferentiable() { UnivariateDifferentiableFunction sin = new Sin(); @@ -133,6 +140,13 @@ void testAddDifferentiable() { assertEquals(4 + FastMath.sin(1.2), FunctionUtils.add(sin, c).value(1.2), EPS); } + @Test + void testAddDifferentiableEmpty() { + assertThrows(ArrayIndexOutOfBoundsException.class, () -> { + FunctionUtils.add(new UnivariateDifferentiableFunction[0]).value(1.0); + }); + } + @Test void testMultiply() { UnivariateFunction c = new Constant(4); @@ -143,6 +157,13 @@ void testMultiply() { assertEquals(1, FunctionUtils.multiply(FunctionUtils.compose(inv, pow), pow).value(3.5), EPS); } + @Test + void testMultiplyEmpty() { + assertThrows(ArrayIndexOutOfBoundsException.class, () -> { + FunctionUtils.multiply(new UnivariateFunction[0]).value(1.0); + }); + } + @Test void testMultiplyDifferentiable() { UnivariateDifferentiableFunction c = new Constant(4); @@ -196,6 +217,14 @@ void testCollector() { assertEquals(-24, coll.value(new double[] {1, -2, 7.5, 10, -24, 9.99}), 0); } + @Test + void testCollectorEmpty() { + MultivariateFunction coll = FunctionUtils.collector(new Add(), 0); + assertThrows(ArrayIndexOutOfBoundsException.class, () -> { + coll.value(new double[0]); + }); + } + @Test void testSinc() { BivariateFunction div = new Divide(); @@ -278,6 +307,13 @@ void testToDifferentiableUnivariate() { assertEquals(2, ((Integer) e.getParts()[1]).intValue()); assertEquals(3, ((Integer) e.getParts()[0]).intValue()); } + + try { + FunctionUtils.compose((UnivariateFunction) null).value(1.0); + fail("an exception should have been thrown"); + } catch (NullPointerException e) { + // expected + } } @Test @@ -340,6 +376,14 @@ void testToDifferentiableMultivariateInconsistentGradient() { assertEquals(3, ((Integer) e.getParts()[0]).intValue()); assertEquals(2, ((Integer) e.getParts()[1]).intValue()); } + + try { + MultivariateFunction df = FunctionUtils.derivative(mdf, new int[] { 1 }); + df.value(new double[] { 1.0, 2.0 }); + fail("an exception should have been thrown"); + } catch (MathIllegalArgumentException e) { + // expected dimension mismatch + } } @Test diff --git a/hipparchus-core/src/test/java/org/hipparchus/analysis/polynomials/PolynomialsUtilsTest.java b/hipparchus-core/src/test/java/org/hipparchus/analysis/polynomials/PolynomialsUtilsTest.java index 3fef40bd6..11c2e6a83 100644 --- a/hipparchus-core/src/test/java/org/hipparchus/analysis/polynomials/PolynomialsUtilsTest.java +++ b/hipparchus-core/src/test/java/org/hipparchus/analysis/polynomials/PolynomialsUtilsTest.java @@ -26,11 +26,13 @@ import org.hipparchus.util.CombinatoricsUtils; import org.hipparchus.util.FastMath; import org.hipparchus.util.Precision; +import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotEquals; import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.junit.jupiter.api.Assertions.fail; /** * Tests the PolynomialsUtils class. @@ -265,6 +267,16 @@ void testHighDegreeLegendre() { } } + @Test + void testNegativeDegree() { + try { + PolynomialsUtils.createChebyshevPolynomial(-1); + fail("Expected MathIllegalArgumentException"); + } catch (org.hipparchus.exception.MathIllegalArgumentException e) { + // expected + } + } + @Test void testJacobiLegendre() { for (int i = 0; i < 10; ++i) { @@ -348,6 +360,26 @@ void testShift() { PolynomialFunction f2x3 = new PolynomialFunction(PolynomialsUtils.shift(f2x.getCoefficients(), 3)); checkPolynomial(f2x3, "29648 + 49239 x + 32745 x^2 + 10898 x^3 + 1815 x^4 + 121 x^5"); + + // Zero shift + double[] coeffs = { 1.0, 2.0, 3.0 }; + Assertions.assertArrayEquals(coeffs, PolynomialsUtils.shift(coeffs, 0), 1e-15); + + // Empty coeffs + double[] empty = new double[0]; + Assertions.assertArrayEquals(empty, PolynomialsUtils.shift(empty, 1.0), 1e-15); + + // Single coeff + double[] single = { 5.0 }; + Assertions.assertArrayEquals(single, PolynomialsUtils.shift(single, 10.0), 1e-15); + + // Null coeffs + try { + PolynomialsUtils.shift(null, 1.0); + fail("Expected NullPointerException"); + } catch (NullPointerException e) { + // expected + } } diff --git a/hipparchus-core/src/test/java/org/hipparchus/complex/QuaternionTest.java b/hipparchus-core/src/test/java/org/hipparchus/complex/QuaternionTest.java index 97e909b1c..d5de93602 100644 --- a/hipparchus-core/src/test/java/org/hipparchus/complex/QuaternionTest.java +++ b/hipparchus-core/src/test/java/org/hipparchus/complex/QuaternionTest.java @@ -407,4 +407,64 @@ final void testToString() { final Quaternion q = new Quaternion(1, 2, 3, 4); assertEquals("[1.0 2.0 3.0 4.0]", q.toString()); } + + @Test + final void testGetPositivePolarForm() { + final Quaternion q = new Quaternion(-3, 1, -2, 1); + final Quaternion p = q.getPositivePolarForm(); + assertTrue(p.getQ0() > 0); + assertEquals(1.0, p.getNorm(), EPS); + + final Quaternion q2 = new Quaternion(3, 1, -2, 1); + final Quaternion p2 = q2.getPositivePolarForm(); + assertTrue(p2.getQ0() > 0); + assertEquals(1.0, p2.getNorm(), EPS); + + final Quaternion q3 = new Quaternion(0, 1, -2, 1); + final Quaternion p3 = q3.getPositivePolarForm(); + assertEquals(0, p3.getQ0(), EPS); + assertEquals(1.0, p3.getNorm(), EPS); + } + + @Test + final void testHashCode() { + final Quaternion q1 = new Quaternion(1, 2, 3, 4); + final Quaternion q2 = new Quaternion(1, 2, 3, 4); + assertEquals(q1.hashCode(), q2.hashCode()); + + final Quaternion q3 = new Quaternion(1, 2, 3, 5); + assertNotEquals(q1.hashCode(), q3.hashCode()); + } + + @Test + final void testObjectEqualsMore() { + final Quaternion q1 = new Quaternion(1, 2, 3, 4); + assertEquals(q1, q1); + assertNotEquals(null, q1); + assertNotEquals(q1, "not a quaternion"); + final Quaternion q2 = new Quaternion(1, 2, 3, 4); + assertEquals(q1, q2); + } + + @Test + final void testInstanceMethods() { + final Quaternion q1 = new Quaternion(1, 2, 3, 4); + final Quaternion q2 = new Quaternion(5, 6, 7, 8); + + // multiply(Quaternion) + final Quaternion qM = q1.multiply(q2); + assertEquals(Quaternion.multiply(q1, q2), qM); + + // add(Quaternion) + final Quaternion qA = q1.add(q2); + assertEquals(Quaternion.add(q1, q2), qA); + + // subtract(Quaternion) + final Quaternion qS = q1.subtract(q2); + assertEquals(Quaternion.subtract(q1, q2), qS); + + // dotProduct(Quaternion) + final double d = q1.dotProduct(q2); + assertEquals(Quaternion.dotProduct(q1, q2), d, EPS); + } } From 89b49a3b1d2b85830a196f9f65ec854b26d8f3b6 Mon Sep 17 00:00:00 2001 From: Sean R Date: Fri, 5 Jun 2026 18:34:58 -0400 Subject: [PATCH 2/2] Update changes.xml --- hipparchus-core/src/changes/changes.xml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/hipparchus-core/src/changes/changes.xml b/hipparchus-core/src/changes/changes.xml index 46b583f76..8869ec88c 100644 --- a/hipparchus-core/src/changes/changes.xml +++ b/hipparchus-core/src/changes/changes.xml @@ -799,6 +799,9 @@ If the output is not quite correct, check for invisible trailing spaces! Forked from the Apache Commons Math library. + + Added some basic edge case unit tests. +