You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by ah...@apache.org on 2020/06/29 15:28:39 UTC
[commons-numbers] 01/08: Fix SonarCloud: Test scope for JUnit5 can
be package-private
This is an automated email from the ASF dual-hosted git repository.
aherbert pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-numbers.git
commit c83453e4745f7942686790c043d42886ebc78d4c
Author: aherbert <ah...@apache.org>
AuthorDate: Mon Jun 29 15:41:52 2020 +0100
Fix SonarCloud: Test scope for JUnit5 can be package-private
---
.../numbers/angle/PlaneAngleRadiansTest.java | 30 +--
.../commons/numbers/angle/PlaneAngleTest.java | 30 +--
.../commons/numbers/arrays/CosAngleTest.java | 8 +-
.../numbers/arrays/LinearCombinationTest.java | 10 +-
.../arrays/MultidimensionalCounterTest.java | 10 +-
.../commons/numbers/arrays/SafeNormTest.java | 14 +-
.../BinomialCoefficientDoubleTest.java | 12 +-
.../combinatorics/BinomialCoefficientTest.java | 20 +-
.../numbers/combinatorics/CombinationsTest.java | 32 +--
.../numbers/combinatorics/FactorialDoubleTest.java | 24 +-
.../numbers/combinatorics/FactorialTest.java | 8 +-
.../combinatorics/LogBinomialCoefficientTest.java | 10 +-
.../numbers/combinatorics/LogFactorialTest.java | 18 +-
.../numbers/complex/streams/ComplexUtilsTest.java | 82 +++----
.../commons/numbers/complex/CReferenceTest.java | 26 +--
.../commons/numbers/complex/CStandardTest.java | 32 +--
.../numbers/complex/ComplexEdgeCaseTest.java | 22 +-
.../commons/numbers/complex/ComplexTest.java | 242 ++++++++++-----------
.../commons/numbers/core/ArithmeticUtilsTest.java | 54 ++---
.../apache/commons/numbers/core/PrecisionTest.java | 44 ++--
.../examples/jmh/arrays/DoublePrecisionTest.java | 10 +-
.../jmh/arrays/LinearCombinationsTest.java | 8 +-
.../org/apache/commons/numbers/field/FP64Test.java | 20 +-
.../commons/numbers/fraction/BigFractionTest.java | 72 +++---
.../numbers/fraction/ContinuedFractionTest.java | 14 +-
.../commons/numbers/fraction/FractionTest.java | 58 ++---
.../apache/commons/numbers/gamma/DigammaTest.java | 8 +-
.../commons/numbers/gamma/ErfDifferenceTest.java | 2 +-
.../org/apache/commons/numbers/gamma/ErfTest.java | 14 +-
.../org/apache/commons/numbers/gamma/ErfcTest.java | 4 +-
.../apache/commons/numbers/gamma/GammaTest.java | 6 +-
.../commons/numbers/gamma/InvGamma1pm1Test.java | 6 +-
.../commons/numbers/gamma/InverseErfTest.java | 6 +-
.../commons/numbers/gamma/InverseErfcTest.java | 6 +-
.../numbers/gamma/LanczosApproximationTest.java | 4 +-
.../apache/commons/numbers/gamma/LogBetaTest.java | 28 +--
.../commons/numbers/gamma/LogGamma1pTest.java | 6 +-
.../commons/numbers/gamma/LogGammaSumTest.java | 10 +-
.../apache/commons/numbers/gamma/LogGammaTest.java | 14 +-
.../commons/numbers/gamma/RegularizedBetaTest.java | 26 +--
.../numbers/gamma/RegularizedGammaTest.java | 20 +-
.../apache/commons/numbers/gamma/TrigammaTest.java | 4 +-
.../apache/commons/numbers/primes/PrimesTest.java | 6 +-
.../commons/numbers/primes/SmallPrimesTest.java | 30 +--
.../commons/numbers/quaternion/QuaternionTest.java | 102 ++++-----
.../commons/numbers/quaternion/SlerpTest.java | 22 +-
.../numbers/rootfinder/BrentSolverTest.java | 14 +-
47 files changed, 624 insertions(+), 624 deletions(-)
diff --git a/commons-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleRadiansTest.java b/commons-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleRadiansTest.java
index 79b62eb..e4484f3 100644
--- a/commons-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleRadiansTest.java
+++ b/commons-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleRadiansTest.java
@@ -25,7 +25,7 @@ import org.junit.jupiter.api.Test;
public class PlaneAngleRadiansTest {
@Test
@SuppressWarnings("squid:S3415")
- public void testConstants() {
+ void testConstants() {
final double eps = 0;
Assertions.assertEquals(Math.PI, PlaneAngleRadians.PI, eps);
@@ -36,7 +36,7 @@ public class PlaneAngleRadiansTest {
// Test constants using "sin" and "cos".
@Test
- public void testConstants2() {
+ void testConstants2() {
final double eps = Math.ulp(1d);
Assertions.assertEquals(0d, Math.sin(PlaneAngleRadians.PI), eps);
@@ -53,7 +53,7 @@ public class PlaneAngleRadiansTest {
}
@Test
- public void testNormalize() {
+ void testNormalize() {
for (double a = -15.0; a <= 15.0; a += 0.1) {
for (double b = -15.0; b <= 15.0; b += 0.2) {
final double c = PlaneAngleRadians.normalize(a, b);
@@ -66,7 +66,7 @@ public class PlaneAngleRadiansTest {
}
@Test
- public void testNormalizeBetweenMinusPiAndPi1() {
+ void testNormalizeBetweenMinusPiAndPi1() {
final double value = 1.25 * PlaneAngleRadians.TWO_PI;
final double expected = PlaneAngleRadians.PI_OVER_TWO;
final double actual = PlaneAngleRadians.normalizeBetweenMinusPiAndPi(value);
@@ -74,7 +74,7 @@ public class PlaneAngleRadiansTest {
Assertions.assertEquals(expected, actual, tol);
}
@Test
- public void testNormalizeBetweenMinusPiAndPi2() {
+ void testNormalizeBetweenMinusPiAndPi2() {
final double value = 0.75 * PlaneAngleRadians.TWO_PI;
final double expected = -PlaneAngleRadians.PI_OVER_TWO;
final double actual = PlaneAngleRadians.normalizeBetweenMinusPiAndPi(value);
@@ -82,7 +82,7 @@ public class PlaneAngleRadiansTest {
Assertions.assertEquals(expected, actual, tol);
}
@Test
- public void testNormalizeBetweenMinusPiAndPi3() {
+ void testNormalizeBetweenMinusPiAndPi3() {
final double value = PlaneAngleRadians.PI + 1e-10;
final double expected = -PlaneAngleRadians.PI + 1e-10;
final double actual = PlaneAngleRadians.normalizeBetweenMinusPiAndPi(value);
@@ -90,7 +90,7 @@ public class PlaneAngleRadiansTest {
Assertions.assertEquals(expected, actual, tol);
}
@Test
- public void testNormalizeBetweenMinusPiAndPi4() {
+ void testNormalizeBetweenMinusPiAndPi4() {
final double value = 5 * PlaneAngleRadians.PI / 4;
final double expected = PlaneAngleRadians.PI * (1d / 4 - 1);
final double actual = PlaneAngleRadians.normalizeBetweenMinusPiAndPi(value);
@@ -99,7 +99,7 @@ public class PlaneAngleRadiansTest {
}
@Test
- public void testNormalizeBetweenMinusPiAndPi_lowerBound() {
+ void testNormalizeBetweenMinusPiAndPi_lowerBound() {
final double value = PlaneAngleRadians.PI;
final double expected = -PlaneAngleRadians.PI;
final double actual = PlaneAngleRadians.normalizeBetweenMinusPiAndPi(value);
@@ -107,7 +107,7 @@ public class PlaneAngleRadiansTest {
Assertions.assertEquals(expected, actual, tol);
}
@Test
- public void testNormalizeBetweenMinusPiAndPi_upperBound() {
+ void testNormalizeBetweenMinusPiAndPi_upperBound() {
final double value = PlaneAngleRadians.PI;
final double expected = -PlaneAngleRadians.PI;
final double actual = PlaneAngleRadians.normalizeBetweenMinusPiAndPi(value);
@@ -116,7 +116,7 @@ public class PlaneAngleRadiansTest {
}
@Test
- public void testNormalizeBetweenZeroAndTwoPi1() {
+ void testNormalizeBetweenZeroAndTwoPi1() {
final double value = 1.25 * PlaneAngleRadians.TWO_PI;
final double expected = PlaneAngleRadians.PI_OVER_TWO;
final double actual = PlaneAngleRadians.normalizeBetweenZeroAndTwoPi(value);
@@ -124,7 +124,7 @@ public class PlaneAngleRadiansTest {
Assertions.assertEquals(expected, actual, tol);
}
@Test
- public void testNormalizeBetweenZeroAndTwoPi2() {
+ void testNormalizeBetweenZeroAndTwoPi2() {
final double value = 1.75 * PlaneAngleRadians.TWO_PI;
final double expected = PlaneAngleRadians.THREE_PI_OVER_TWO;
final double actual = PlaneAngleRadians.normalizeBetweenZeroAndTwoPi(value);
@@ -132,7 +132,7 @@ public class PlaneAngleRadiansTest {
Assertions.assertEquals(expected, actual, tol);
}
@Test
- public void testNormalizeBetweenZeroAndTwoPi3() {
+ void testNormalizeBetweenZeroAndTwoPi3() {
final double value = -PlaneAngleRadians.PI + 1e-10;
final double expected = PlaneAngleRadians.PI + 1e-10;
final double actual = PlaneAngleRadians.normalizeBetweenZeroAndTwoPi(value);
@@ -140,7 +140,7 @@ public class PlaneAngleRadiansTest {
Assertions.assertEquals(expected, actual, tol);
}
@Test
- public void testNormalizeBetweenZeroAndTwoPi4() {
+ void testNormalizeBetweenZeroAndTwoPi4() {
final double value = 9 * PlaneAngleRadians.PI / 4;
final double expected = PlaneAngleRadians.PI / 4;
final double actual = PlaneAngleRadians.normalizeBetweenZeroAndTwoPi(value);
@@ -149,7 +149,7 @@ public class PlaneAngleRadiansTest {
}
@Test
- public void testNormalizeBetweenZeroAndTwoPi_lowerBound() {
+ void testNormalizeBetweenZeroAndTwoPi_lowerBound() {
final double value = 0.0;
final double expected = 0.0;
final double actual = PlaneAngleRadians.normalizeBetweenZeroAndTwoPi(value);
@@ -157,7 +157,7 @@ public class PlaneAngleRadiansTest {
Assertions.assertEquals(expected, actual, tol);
}
@Test
- public void testNormalizeBetweenZeroAndTwoPi_upperBound() {
+ void testNormalizeBetweenZeroAndTwoPi_upperBound() {
final double value = PlaneAngleRadians.TWO_PI;
final double expected = 0.0;
final double actual = PlaneAngleRadians.normalizeBetweenZeroAndTwoPi(value);
diff --git a/commons-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleTest.java b/commons-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleTest.java
index 5cd2039..c61d024 100644
--- a/commons-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleTest.java
+++ b/commons-numbers-angle/src/test/java/org/apache/commons/numbers/angle/PlaneAngleTest.java
@@ -24,14 +24,14 @@ import org.junit.jupiter.api.Test;
*/
public class PlaneAngleTest {
@Test
- public void testConversionTurns() {
+ void testConversionTurns() {
final double value = 12.3456;
final PlaneAngle a = PlaneAngle.ofTurns(value);
Assertions.assertEquals(value, a.toTurns(), 0d);
}
@Test
- public void testConversionRadians() {
+ void testConversionRadians() {
final double one = 2 * Math.PI;
final double value = 12.3456 * one;
final PlaneAngle a = PlaneAngle.ofRadians(value);
@@ -39,7 +39,7 @@ public class PlaneAngleTest {
}
@Test
- public void testConversionDegrees() {
+ void testConversionDegrees() {
final double one = 360;
final double value = 12.3456 * one;
final PlaneAngle a = PlaneAngle.ofDegrees(value);
@@ -47,7 +47,7 @@ public class PlaneAngleTest {
}
@Test
- public void testNormalizeRadians() {
+ void testNormalizeRadians() {
for (double a = -15.0; a <= 15.0; a += 0.1) {
for (double b = -15.0; b <= 15.0; b += 0.2) {
final PlaneAngle aA = PlaneAngle.ofRadians(a);
@@ -62,7 +62,7 @@ public class PlaneAngleTest {
}
@Test
- public void testNormalizeMixed() {
+ void testNormalizeMixed() {
for (double a = -15.0; a <= 15.0; a += 0.1) {
for (double b = -15.0; b <= 15.0; b += 0.2) {
final PlaneAngle aA = PlaneAngle.ofDegrees(a);
@@ -77,7 +77,7 @@ public class PlaneAngleTest {
}
@Test
- public void testNormalizeAroundZero1() {
+ void testNormalizeAroundZero1() {
final double value = 1.25;
final double expected = 0.25;
final double actual = PlaneAngle.ofTurns(value).normalize(PlaneAngle.ZERO).toTurns();
@@ -85,7 +85,7 @@ public class PlaneAngleTest {
Assertions.assertEquals(expected, actual, tol);
}
@Test
- public void testNormalizeAroundZero2() {
+ void testNormalizeAroundZero2() {
final double value = 0.75;
final double expected = -0.25;
final double actual = PlaneAngle.ofTurns(value).normalize(PlaneAngle.ZERO).toTurns();
@@ -93,7 +93,7 @@ public class PlaneAngleTest {
Assertions.assertEquals(expected, actual, tol);
}
@Test
- public void testNormalizeAroundZero3() {
+ void testNormalizeAroundZero3() {
final double value = 0.5 + 1e-10;
final double expected = -0.5 + 1e-10;
final double actual = PlaneAngle.ofTurns(value).normalize(PlaneAngle.ZERO).toTurns();
@@ -101,7 +101,7 @@ public class PlaneAngleTest {
Assertions.assertEquals(expected, actual, tol);
}
@Test
- public void testNormalizeAroundZero4() {
+ void testNormalizeAroundZero4() {
final double value = 5 * Math.PI / 4;
final double expected = Math.PI * (1d / 4 - 1);
final double actual = PlaneAngle.ofRadians(value).normalize(PlaneAngle.ZERO).toRadians();
@@ -110,7 +110,7 @@ public class PlaneAngleTest {
}
@Test
- public void testNormalizeUpperAndLowerBounds() {
+ void testNormalizeUpperAndLowerBounds() {
// arrange
double eps = 1e-15;
@@ -129,7 +129,7 @@ public class PlaneAngleTest {
}
@Test
- public void testNormalizeVeryCloseToBounds() {
+ void testNormalizeVeryCloseToBounds() {
// arrange
double eps = 1e-22;
@@ -151,7 +151,7 @@ public class PlaneAngleTest {
}
@Test
- public void testHashCode() {
+ void testHashCode() {
// Test assumes that the internal representation is in "turns".
final double value = -123.456789;
final int expected = Double.valueOf(value).hashCode();
@@ -160,7 +160,7 @@ public class PlaneAngleTest {
}
@Test
- public void testEquals() {
+ void testEquals() {
final double value = 12345.6789;
final PlaneAngle a = PlaneAngle.ofRadians(value);
Assertions.assertTrue(a.equals(a));
@@ -171,11 +171,11 @@ public class PlaneAngleTest {
}
@Test
- public void testZero() {
+ void testZero() {
Assertions.assertEquals(0, PlaneAngle.ZERO.toRadians(), 0d);
}
@Test
- public void testPi() {
+ void testPi() {
Assertions.assertEquals(Math.PI, PlaneAngle.PI.toRadians(), 0d);
}
}
diff --git a/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/CosAngleTest.java b/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/CosAngleTest.java
index 758ee3f..33f9e54 100644
--- a/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/CosAngleTest.java
+++ b/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/CosAngleTest.java
@@ -25,7 +25,7 @@ import org.junit.jupiter.api.Test;
public class CosAngleTest {
@Test
- public void testCosAngle2D() {
+ void testCosAngle2D() {
double expected;
final double[] v1 = {1, 0};
@@ -51,7 +51,7 @@ public class CosAngleTest {
}
@Test
- public void testCosAngle3D() {
+ void testCosAngle3D() {
double expected;
final double[] v1 = {1, 1, 0};
@@ -64,7 +64,7 @@ public class CosAngleTest {
}
@Test
- public void testCosAngleExtreme() {
+ void testCosAngleExtreme() {
double expected;
final double tiny = 1e-200;
@@ -80,7 +80,7 @@ public class CosAngleTest {
}
@Test
- public void testCosAngle_dimensionMismatch() {
+ void testCosAngle_dimensionMismatch() {
final double[] a = {1.0};
final double[] b = {1.0, 2.0};
diff --git a/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/LinearCombinationTest.java b/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/LinearCombinationTest.java
index 82894f6..fedb4e3 100644
--- a/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/LinearCombinationTest.java
+++ b/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/LinearCombinationTest.java
@@ -29,7 +29,7 @@ import org.apache.commons.numbers.fraction.BigFraction;
public class LinearCombinationTest {
// MATH-1005
@Test
- public void testSingleElementArray() {
+ void testSingleElementArray() {
final double[] a = {1.23456789};
final double[] b = {98765432.1};
@@ -37,7 +37,7 @@ public class LinearCombinationTest {
}
@Test
- public void testTwoSums() {
+ void testTwoSums() {
final BigFraction[] aF = new BigFraction[] {
BigFraction.of(-1321008684645961L, 268435456L),
BigFraction.of(-5774608829631843L, 268435456L),
@@ -77,7 +77,7 @@ public class LinearCombinationTest {
}
@Test
- public void testArrayVsInline() {
+ void testArrayVsInline() {
final UniformRandomProvider rng = RandomSource.create(RandomSource.XO_SHI_RO_256_PP);
double sInline;
@@ -114,7 +114,7 @@ public class LinearCombinationTest {
}
@Test
- public void testHuge() {
+ void testHuge() {
int scale = 971;
final double[] a = new double[] {
-1321008684645961.0 / 268435456.0,
@@ -147,7 +147,7 @@ public class LinearCombinationTest {
}
@Test
- public void testInfinite() {
+ void testInfinite() {
final double[][] a = new double[][] {
{1, 2, 3, 4},
{1, Double.POSITIVE_INFINITY, 3, 4},
diff --git a/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/MultidimensionalCounterTest.java b/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/MultidimensionalCounterTest.java
index 88f5815..b8f05b6 100644
--- a/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/MultidimensionalCounterTest.java
+++ b/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/MultidimensionalCounterTest.java
@@ -27,7 +27,7 @@ import org.junit.jupiter.api.Test;
*/
public class MultidimensionalCounterTest {
@Test
- public void testPreconditions() {
+ void testPreconditions() {
Assertions.assertThrows(IllegalArgumentException.class, () -> MultidimensionalCounter.of(0, 1));
Assertions.assertThrows(IllegalArgumentException.class, () -> MultidimensionalCounter.of(2, 0));
Assertions.assertThrows(IllegalArgumentException.class, () -> MultidimensionalCounter.of(-1, 1));
@@ -43,7 +43,7 @@ public class MultidimensionalCounterTest {
}
@Test
- public void testMulti2UniConversion() {
+ void testMulti2UniConversion() {
final MultidimensionalCounter c = MultidimensionalCounter.of(2, 4, 5);
Assertions.assertEquals(33, c.toUni(1, 2, 3));
@@ -53,7 +53,7 @@ public class MultidimensionalCounterTest {
}
@Test
- public void testAccessors() {
+ void testAccessors() {
final int[] originalSize = new int[] {2, 6, 5};
final MultidimensionalCounter c = MultidimensionalCounter.of(originalSize);
final int nDim = c.getDimension();
@@ -66,7 +66,7 @@ public class MultidimensionalCounterTest {
}
@Test
- public void testIterationConsistency() {
+ void testIterationConsistency() {
final MultidimensionalCounter c = MultidimensionalCounter.of(2, 3, 4);
final int[][] expected = new int[][] {
{0, 0, 0},
@@ -112,7 +112,7 @@ public class MultidimensionalCounterTest {
}
@Test
- public void testToString() {
+ void testToString() {
final int[] sizes = new int[] {7, 5, 3, 1};
final MultidimensionalCounter c = MultidimensionalCounter.of(sizes);
Assertions.assertEquals(Arrays.toString(sizes), c.toString());
diff --git a/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/SafeNormTest.java b/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/SafeNormTest.java
index 82de37c..b920918 100644
--- a/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/SafeNormTest.java
+++ b/commons-numbers-arrays/src/test/java/org/apache/commons/numbers/arrays/SafeNormTest.java
@@ -25,48 +25,48 @@ import org.junit.jupiter.api.Test;
public class SafeNormTest {
@Test
- public void testTiny() {
+ void testTiny() {
final double s = 1e-320;
final double[] v = new double[] {s, s};
Assertions.assertEquals(Math.sqrt(2) * s, SafeNorm.value(v));
}
@Test
- public void testBig() {
+ void testBig() {
final double s = 1e300;
final double[] v = new double[] {s, s};
Assertions.assertEquals(Math.sqrt(2) * s, SafeNorm.value(v));
}
@Test
- public void testOne3D() {
+ void testOne3D() {
final double s = 1;
final double[] v = new double[] {s, s, s};
Assertions.assertEquals(Math.sqrt(3), SafeNorm.value(v));
}
@Test
- public void testUnit3D() {
+ void testUnit3D() {
Assertions.assertEquals(1, SafeNorm.value(new double[] {1, 0, 0}), 0d);
Assertions.assertEquals(1, SafeNorm.value(new double[] {0, 1, 0}), 0d);
Assertions.assertEquals(1, SafeNorm.value(new double[] {0, 0, 1}), 0d);
}
@Test
- public void testSimple() {
+ void testSimple() {
final double[] v = new double[] {-0.9, 8.7, -6.5, -4.3, -2.1, 0, 1.2, 3.4, -5.6, 7.8, 9.0};
final double expected = direct(v);
Assertions.assertEquals(expected, SafeNorm.value(v));
}
@Test
- public void testZero() {
+ void testZero() {
final double[] v = new double[] {0, 0, 0, 0, 0};
Assertions.assertEquals(0d, SafeNorm.value(v));
}
@Test
- public void testTinyAndSmallNormal() {
+ void testTinyAndSmallNormal() {
// Ensure the sum of the squared values for 'normal' values (1e-19*1e-19)
// is less than largest tiny value (1e-20)
final double[] v = new double[] {1e-20, 1e-19};
diff --git a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/BinomialCoefficientDoubleTest.java b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/BinomialCoefficientDoubleTest.java
index 1a17721..606b8be 100644
--- a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/BinomialCoefficientDoubleTest.java
+++ b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/BinomialCoefficientDoubleTest.java
@@ -25,12 +25,12 @@ import org.junit.jupiter.api.Test;
public class BinomialCoefficientDoubleTest {
/** Verify that b(0,0) = 1 */
@Test
- public void test0Choose0() {
+ void test0Choose0() {
Assertions.assertEquals(1d, BinomialCoefficientDouble.value(0, 0), 0);
}
@Test
- public void testBinomialCoefficient() {
+ void testBinomialCoefficient() {
final long[] bcoef5 = {1, 5, 10, 10, 5, 1};
final long[] bcoef6 = {1, 6, 15, 20, 15, 6, 1};
@@ -59,21 +59,21 @@ public class BinomialCoefficientDoubleTest {
}
@Test
- public void testBinomialCoefficientFail1() {
+ void testBinomialCoefficientFail1() {
Assertions.assertThrows(CombinatoricsException.class,
() -> BinomialCoefficientDouble.value(4, 5)
);
}
@Test
- public void testBinomialCoefficientFail2() {
+ void testBinomialCoefficientFail2() {
Assertions.assertThrows(CombinatoricsException.class,
() -> BinomialCoefficientDouble.value(-1, -2)
);
}
@Test
- public void testBinomialCoefficientFail3() {
+ void testBinomialCoefficientFail3() {
final double x = BinomialCoefficientDouble.value(1030, 515);
Assertions.assertTrue(Double.isInfinite(x), "expecting infinite binomial coefficient");
}
@@ -83,7 +83,7 @@ public class BinomialCoefficientDoubleTest {
* JIRA: MATH-241
*/
@Test
- public void testBinomialCoefficientLarge() throws Exception {
+ void testBinomialCoefficientLarge() throws Exception {
// This tests all legal and illegal values for n <= 200.
for (int n = 0; n <= 200; n++) {
for (int k = 0; k <= n; k++) {
diff --git a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/BinomialCoefficientTest.java b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/BinomialCoefficientTest.java
index 8080f80..341f9cc 100644
--- a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/BinomialCoefficientTest.java
+++ b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/BinomialCoefficientTest.java
@@ -33,12 +33,12 @@ public class BinomialCoefficientTest {
/** Verify that b(0,0) = 1 */
@Test
- public void test0Choose0() {
+ void test0Choose0() {
Assertions.assertEquals(1, BinomialCoefficient.value(0, 0));
}
@Test
- public void testBinomialCoefficient() {
+ void testBinomialCoefficient() {
final long[] bcoef5 = {1, 5, 10, 10, 5, 1};
final long[] bcoef6 = {1, 6, 15, 20, 15, 6, 1};
@@ -72,28 +72,28 @@ public class BinomialCoefficientTest {
}
@Test
- public void testBinomialCoefficientKLargerThanN() {
+ void testBinomialCoefficientKLargerThanN() {
Assertions.assertThrows(CombinatoricsException.class,
() -> BinomialCoefficient.value(4, 5)
);
}
@Test
- public void testBinomialCoefficientNegativeN() {
+ void testBinomialCoefficientNegativeN() {
Assertions.assertThrows(CombinatoricsException.class,
() -> BinomialCoefficient.value(-1, 1)
);
}
@Test
- public void testBinomialCoefficientNegativeK() {
+ void testBinomialCoefficientNegativeK() {
Assertions.assertThrows(CombinatoricsException.class,
() -> BinomialCoefficient.value(10, -1)
);
}
@Test
- public void testBinomialCoefficientNAbove66ResultOverflow() {
+ void testBinomialCoefficientNAbove66ResultOverflow() {
Assertions.assertThrows(ArithmeticException.class,
() -> BinomialCoefficient.value(67, 30)
);
@@ -104,7 +104,7 @@ public class BinomialCoefficientTest {
* JIRA: MATH-241
*/
@Test
- public void testBinomialCoefficientLarge() throws Exception {
+ void testBinomialCoefficientLarge() throws Exception {
// This tests all legal and illegal values for n <= 200.
for (int n = 0; n <= 200; n++) {
for (int k = 0; k <= n; k++) {
@@ -144,21 +144,21 @@ public class BinomialCoefficientTest {
}
@Test
- public void checkNLessThanOne() {
+ void checkNLessThanOne() {
Assertions.assertThrows(CombinatoricsException.class,
() -> BinomialCoefficient.checkBinomial(-1, -2)
);
}
@Test
- public void checkKGreaterThanN() {
+ void checkKGreaterThanN() {
Assertions.assertThrows(CombinatoricsException.class,
() -> BinomialCoefficient.checkBinomial(4, 5)
);
}
@Test
- public void testCheckBinomial3() {
+ void testCheckBinomial3() {
// OK (no exception thrown)
BinomialCoefficient.checkBinomial(5, 4);
}
diff --git a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/CombinationsTest.java b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/CombinationsTest.java
index ca3ead1..a32a42f 100644
--- a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/CombinationsTest.java
+++ b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/CombinationsTest.java
@@ -28,21 +28,21 @@ import org.junit.jupiter.api.Test;
*/
public class CombinationsTest {
@Test
- public void testGetN() {
+ void testGetN() {
final int n = 5;
final int k = 3;
Assertions.assertEquals(n, Combinations.of(n, k).getN());
}
@Test
- public void testGetK() {
+ void testGetK() {
final int n = 5;
final int k = 3;
Assertions.assertEquals(k, Combinations.of(n, k).getK());
}
@Test
- public void testLexicographicIterator() {
+ void testLexicographicIterator() {
checkLexicographicIterator(5, 3);
checkLexicographicIterator(6, 4);
checkLexicographicIterator(8, 2);
@@ -57,14 +57,14 @@ public class CombinationsTest {
}
@Test
- public void testLexicographicIteratorThrows() {
+ void testLexicographicIteratorThrows() {
checkLexicographicIteratorThrows(2, 1);
// Only 1 combination
checkLexicographicIteratorThrows(1, 1);
}
@Test
- public void testLexicographicComparatorWrongIterate1() {
+ void testLexicographicComparatorWrongIterate1() {
final int n = 5;
final int k = 3;
final Comparator<int[]> comp = Combinations.of(n, k).comparator();
@@ -74,7 +74,7 @@ public class CombinationsTest {
}
@Test
- public void testLexicographicComparatorWrongIterate2() {
+ void testLexicographicComparatorWrongIterate2() {
final int n = 5;
final int k = 3;
final Comparator<int[]> comp = Combinations.of(n, k).comparator();
@@ -84,7 +84,7 @@ public class CombinationsTest {
}
@Test
- public void testLexicographicComparatorWrongIterate3() {
+ void testLexicographicComparatorWrongIterate3() {
final int n = 5;
final int k = 3;
final Comparator<int[]> comp = Combinations.of(n, k).comparator();
@@ -94,7 +94,7 @@ public class CombinationsTest {
}
@Test
- public void testLexicographicComparatorWrongIterate4() {
+ void testLexicographicComparatorWrongIterate4() {
final int n = 5;
final int k = 3;
final Comparator<int[]> comp = Combinations.of(n, k).comparator();
@@ -104,7 +104,7 @@ public class CombinationsTest {
}
@Test
- public void testLexicographicComparator() {
+ void testLexicographicComparator() {
final int n = 5;
final int k = 3;
final Comparator<int[]> comp = Combinations.of(n, k).comparator();
@@ -120,7 +120,7 @@ public class CombinationsTest {
* Check that iterates can be passed unsorted.
*/
@Test
- public void testLexicographicComparatorUnsorted() {
+ void testLexicographicComparatorUnsorted() {
final int n = 5;
final int k = 3;
final Comparator<int[]> comp = Combinations.of(n, k).comparator();
@@ -133,7 +133,7 @@ public class CombinationsTest {
}
@Test
- public void testEmptyCombination() {
+ void testEmptyCombination() {
final Iterator<int[]> iter = Combinations.of(12345, 0).iterator();
Assertions.assertTrue(iter.hasNext());
final int[] c = iter.next();
@@ -142,7 +142,7 @@ public class CombinationsTest {
}
@Test
- public void testFullSetCombination() {
+ void testFullSetCombination() {
final int n = 67;
final Iterator<int[]> iter = Combinations.of(n, n).iterator();
Assertions.assertTrue(iter.hasNext());
@@ -215,28 +215,28 @@ public class CombinationsTest {
}
@Test
- public void testBinomialCoefficientKLargerThanN() {
+ void testBinomialCoefficientKLargerThanN() {
Assertions.assertThrows(CombinatoricsException.class,
() -> Combinations.of(4, 5)
);
}
@Test
- public void testBinomialCoefficientNegativeN() {
+ void testBinomialCoefficientNegativeN() {
Assertions.assertThrows(CombinatoricsException.class,
() -> Combinations.of(-1, 1)
);
}
@Test
- public void testBinomialCoefficientNegativeK() {
+ void testBinomialCoefficientNegativeK() {
Assertions.assertThrows(CombinatoricsException.class,
() -> Combinations.of(10, -1)
);
}
@Test
- public void testBinomialCoefficientKAboveN() {
+ void testBinomialCoefficientKAboveN() {
Assertions.assertThrows(CombinatoricsException.class,
() -> Combinations.of(10, 20)
);
diff --git a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialDoubleTest.java b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialDoubleTest.java
index c4075ea..9862b76 100644
--- a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialDoubleTest.java
+++ b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialDoubleTest.java
@@ -24,12 +24,12 @@ import org.junit.jupiter.api.Test;
*/
public class FactorialDoubleTest {
@Test
- public void testFactorialZero() {
+ void testFactorialZero() {
Assertions.assertEquals(1, FactorialDouble.create().value(0), 0d, "0!");
}
@Test
- public void testFactorialDirect() {
+ void testFactorialDirect() {
for (int i = 1; i < 21; i++) {
Assertions.assertEquals(
factorialDirect(i), FactorialDouble.create().value(i), 0d, i + "!");
@@ -37,35 +37,35 @@ public class FactorialDoubleTest {
}
@Test
- public void testLargestFactorialDouble() {
+ void testLargestFactorialDouble() {
final int n = 170;
Assertions.assertTrue(
Double.POSITIVE_INFINITY != FactorialDouble.create().value(n), n + "!");
}
@Test
- public void testFactorialDoubleTooLarge() {
+ void testFactorialDoubleTooLarge() {
final int n = 171;
Assertions.assertEquals(
Double.POSITIVE_INFINITY, FactorialDouble.create().value(n), 0d, n + "!");
}
@Test
- public void testNonPositiveArgumentWithCache() {
+ void testNonPositiveArgumentWithCache() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> FactorialDouble.create().withCache(-1)
);
}
@Test
- public void testNonPositiveArgument() {
+ void testNonPositiveArgument() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> FactorialDouble.create().value(-1)
);
}
@Test
- public void testCompareDirectWithoutCache() {
+ void testCompareDirectWithoutCache() {
// This test shows that delegating to the "Gamma" class will also lead to a
// less accurate result.
@@ -80,7 +80,7 @@ public class FactorialDoubleTest {
}
@Test
- public void testCompareDirectWithCache() {
+ void testCompareDirectWithCache() {
final int max = 100;
final FactorialDouble f = FactorialDouble.create().withCache(max);
@@ -92,7 +92,7 @@ public class FactorialDoubleTest {
}
@Test
- public void testCacheIncrease() {
+ void testCacheIncrease() {
final int max = 100;
final FactorialDouble f1 = FactorialDouble.create().withCache(max);
final FactorialDouble f2 = f1.withCache(2 * max);
@@ -102,7 +102,7 @@ public class FactorialDoubleTest {
}
@Test
- public void testZeroCache() {
+ void testZeroCache() {
// Ensure that no exception is thrown.
final FactorialDouble f = FactorialDouble.create().withCache(0);
Assertions.assertEquals(1, f.value(0), 0d);
@@ -110,7 +110,7 @@ public class FactorialDoubleTest {
}
@Test
- public void testUselessCache() {
+ void testUselessCache() {
Assertions.assertDoesNotThrow(() -> {
LogFactorial.create().withCache(1);
LogFactorial.create().withCache(2);
@@ -118,7 +118,7 @@ public class FactorialDoubleTest {
}
@Test
- public void testCacheDecrease() {
+ void testCacheDecrease() {
final int max = 100;
final FactorialDouble f1 = FactorialDouble.create().withCache(max);
final FactorialDouble f2 = f1.withCache(max / 2);
diff --git a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialTest.java b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialTest.java
index 4dba998..1579375 100644
--- a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialTest.java
+++ b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/FactorialTest.java
@@ -24,26 +24,26 @@ import org.junit.jupiter.api.Test;
*/
public class FactorialTest {
@Test
- public void testFactorialZero() {
+ void testFactorialZero() {
Assertions.assertEquals(1, Factorial.value(0), "0!");
}
@Test
- public void testFactorial() {
+ void testFactorial() {
for (int i = 1; i < 21; i++) {
Assertions.assertEquals(factorial(i), Factorial.value(i), i + "!");
}
}
@Test
- public void testPrecondition1() {
+ void testPrecondition1() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> Factorial.value(-1)
);
}
@Test
- public void testPrecondition2() {
+ void testPrecondition2() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> Factorial.value(21)
);
diff --git a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogBinomialCoefficientTest.java b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogBinomialCoefficientTest.java
index e8c20b6..fa36927 100644
--- a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogBinomialCoefficientTest.java
+++ b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogBinomialCoefficientTest.java
@@ -25,12 +25,12 @@ import org.junit.jupiter.api.Test;
public class LogBinomialCoefficientTest {
/** Verify that b(0,0) = 1 */
@Test
- public void test0Choose0() {
+ void test0Choose0() {
Assertions.assertEquals(0d, LogBinomialCoefficient.value(0, 0), 0);
}
@Test
- public void testBinomialCoefficient() {
+ void testBinomialCoefficient() {
final long[] bcoef5 = {1, 5, 10, 10, 5, 1};
final long[] bcoef6 = {1, 6, 15, 20, 15, 6, 1};
@@ -54,14 +54,14 @@ public class LogBinomialCoefficientTest {
}
@Test
- public void testBinomialCoefficientFail1() {
+ void testBinomialCoefficientFail1() {
Assertions.assertThrows(CombinatoricsException.class,
() -> LogBinomialCoefficient.value(4, 5)
);
}
@Test
- public void testBinomialCoefficientFail2() {
+ void testBinomialCoefficientFail2() {
Assertions.assertThrows(CombinatoricsException.class,
() -> LogBinomialCoefficient.value(-1, -2)
);
@@ -72,7 +72,7 @@ public class LogBinomialCoefficientTest {
* JIRA: MATH-241
*/
@Test
- public void testBinomialCoefficientLarge() throws Exception {
+ void testBinomialCoefficientLarge() throws Exception {
// This tests all legal and illegal values for n <= 200.
for (int n = 0; n <= 200; n++) {
for (int k = 0; k <= n; k++) {
diff --git a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogFactorialTest.java b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogFactorialTest.java
index 291c557..568335d 100644
--- a/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogFactorialTest.java
+++ b/commons-numbers-combinatorics/src/test/java/org/apache/commons/numbers/combinatorics/LogFactorialTest.java
@@ -26,14 +26,14 @@ import org.junit.jupiter.api.Test;
*/
public class LogFactorialTest {
@Test
- public void testNonPositiveArgumentWithCache() {
+ void testNonPositiveArgumentWithCache() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> LogFactorial.create().withCache(-1)
);
}
@Test
- public void testNonPositiveArgument() {
+ void testNonPositiveArgument() {
final LogFactorial f = LogFactorial.create();
Assertions.assertThrows(IllegalArgumentException.class,
() -> f.value(-1)
@@ -41,7 +41,7 @@ public class LogFactorialTest {
}
@Test
- public void testDelegation() {
+ void testDelegation() {
final LogFactorial f = LogFactorial.create();
// Starting at 21 because for smaller arguments, there is no delegation to the
@@ -54,7 +54,7 @@ public class LogFactorialTest {
}
@Test
- public void testCompareDirectWithoutCache() {
+ void testCompareDirectWithoutCache() {
// This test shows that delegating to the "Gamma" class leads to difference
// wrt the "direct" computation.
@@ -69,7 +69,7 @@ public class LogFactorialTest {
}
@Test
- public void testCompareDirectWithCache() {
+ void testCompareDirectWithCache() {
final int max = 1000;
final LogFactorial f = LogFactorial.create().withCache(max);
@@ -81,7 +81,7 @@ public class LogFactorialTest {
}
@Test
- public void testZeroCache() {
+ void testZeroCache() {
// Ensure that no exception is thrown.
final LogFactorial f = LogFactorial.create().withCache(0);
Assertions.assertEquals(0, f.value(0), 0d);
@@ -89,14 +89,14 @@ public class LogFactorialTest {
}
@Test
- public void testUselessCache() {
+ void testUselessCache() {
// Ensure that no exception is thrown.
LogFactorial.create().withCache(1);
LogFactorial.create().withCache(2);
}
@Test
- public void testCacheIncrease() {
+ void testCacheIncrease() {
final int max = 100;
final LogFactorial f1 = LogFactorial.create().withCache(max);
final LogFactorial f2 = f1.withCache(2 * max);
@@ -107,7 +107,7 @@ public class LogFactorialTest {
}
@Test
- public void testCacheDecrease() {
+ void testCacheDecrease() {
final int max = 100;
final LogFactorial f1 = LogFactorial.create().withCache(max);
final LogFactorial f2 = f1.withCache(max / 2);
diff --git a/commons-numbers-complex-streams/src/test/java/org/apache/commons/numbers/complex/streams/ComplexUtilsTest.java b/commons-numbers-complex-streams/src/test/java/org/apache/commons/numbers/complex/streams/ComplexUtilsTest.java
index 3c43298..7bac2b1 100644
--- a/commons-numbers-complex-streams/src/test/java/org/apache/commons/numbers/complex/streams/ComplexUtilsTest.java
+++ b/commons-numbers-complex-streams/src/test/java/org/apache/commons/numbers/complex/streams/ComplexUtilsTest.java
@@ -237,7 +237,7 @@ public class ComplexUtilsTest {
// CHECKSTYLE: resume MethodLength
@Test
- public void testPolar2Complex() {
+ void testPolar2Complex() {
TestUtils.assertEquals(Complex.ONE, ComplexUtils.polar2Complex(1, 0), 10e-12);
TestUtils.assertEquals(Complex.ZERO, ComplexUtils.polar2Complex(0, 1), 10e-12);
TestUtils.assertEquals(Complex.ZERO, ComplexUtils.polar2Complex(0, -1), 10e-12);
@@ -312,42 +312,42 @@ public class ComplexUtilsTest {
}
@Test
- public void testPolar2ComplexIllegalModulus() {
+ void testPolar2ComplexIllegalModulus() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.polar2Complex(-1, 0)
);
}
@Test
- public void testPolar2ComplexIllegalModulus1D() {
+ void testPolar2ComplexIllegalModulus1D() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.polar2Complex(new double[]{0, -1, 2}, new double[]{0, 1, 2})
);
}
@Test
- public void testPolar2ComplexIllegalModulus2D() {
+ void testPolar2ComplexIllegalModulus2D() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.polar2Complex(new double[][]{{0, 2, 2}, {0, -1, 2}}, new double[][]{{0, 1, 2}, {0, 1, 2}})
);
}
@Test
- public void testPolar2ComplexIllegalModulus3D() {
+ void testPolar2ComplexIllegalModulus3D() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.polar2Complex(new double[][][]{{{0, 2, 2}}, {{0, -1, 2}}}, new double[][][]{{{0, 1, 2}}, {{0, 1, 2}}})
);
}
@Test
- public void testPolar2ComplexNaN() {
+ void testPolar2ComplexNaN() {
TestUtils.assertSame(NAN, ComplexUtils.polar2Complex(nan, 1));
TestUtils.assertSame(NAN, ComplexUtils.polar2Complex(1, nan));
TestUtils.assertSame(NAN, ComplexUtils.polar2Complex(nan, nan));
}
@Test
- public void testPolar2ComplexInf() {
+ void testPolar2ComplexInf() {
TestUtils.assertSame(NAN, ComplexUtils.polar2Complex(1, inf));
TestUtils.assertSame(NAN, ComplexUtils.polar2Complex(1, negInf));
TestUtils.assertSame(NAN, ComplexUtils.polar2Complex(inf, inf));
@@ -360,7 +360,7 @@ public class ComplexUtilsTest {
}
@Test
- public void testCExtract() {
+ void testCExtract() {
final double[] real = new double[] {negInf, -123.45, 0, 1, 234.56, pi, inf};
final Complex[] complex = ComplexUtils.real2Complex(real);
@@ -372,7 +372,7 @@ public class ComplexUtilsTest {
// EXTRACTION METHODS
@Test
- public void testExtractionMethods() {
+ void testExtractionMethods() {
setArrays();
// Extract complex from real double array, index 3
TestUtils.assertSame(Complex.ofCartesian(3, 0), ComplexUtils.extractComplexFromRealArray(d, 3));
@@ -408,7 +408,7 @@ public class ComplexUtilsTest {
// REAL <-> COMPLEX
@Test
- public void testRealToComplex() {
+ void testRealToComplex() {
setArrays();
// Real double to complex, whole array
TestUtils.assertEquals(msg, cr, ComplexUtils.real2Complex(d), Math.ulp(1.0));
@@ -428,7 +428,7 @@ public class ComplexUtilsTest {
}
@Test
- public void testComplexToReal() {
+ void testComplexToReal() {
setArrays();
// Real complex to double, whole array
Assertions.assertArrayEquals(sr, ComplexUtils.complex2Real(c), Math.ulp(1.0), msg);
@@ -451,7 +451,7 @@ public class ComplexUtilsTest {
// IMAGINARY <-> COMPLEX
@Test
- public void testImaginaryToComplex() {
+ void testImaginaryToComplex() {
setArrays();
// Imaginary double to complex, whole array
TestUtils.assertEquals(msg, ci, ComplexUtils.imaginary2Complex(d), Math.ulp(1.0));
@@ -469,7 +469,7 @@ public class ComplexUtilsTest {
}
@Test
- public void testComplexToImaginary() {
+ void testComplexToImaginary() {
setArrays();
// Imaginary complex to double, whole array
Assertions.assertArrayEquals(si, ComplexUtils.complex2Imaginary(c), Math.ulp(1.0), msg);
@@ -492,147 +492,147 @@ public class ComplexUtilsTest {
// INTERLEAVED <-> COMPLEX
@Test
- public void testComplex2InterleavedIllegalIndex2Dmin() {
+ void testComplex2InterleavedIllegalIndex2Dmin() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.complex2Interleaved(c2d, -1)
);
}
@Test
- public void testComplex2InterleavedIllegalIndex2Dmax() {
+ void testComplex2InterleavedIllegalIndex2Dmax() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.complex2Interleaved(c2d, 2)
);
}
@Test
- public void testComplex2InterleavedIllegalIndex3Dmin() {
+ void testComplex2InterleavedIllegalIndex3Dmin() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.complex2Interleaved(c3d, -1)
);
}
@Test
- public void testComplex2InterleavedIllegalIndex3Dmax() {
+ void testComplex2InterleavedIllegalIndex3Dmax() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.complex2Interleaved(c3d, 3)
);
}
@Test
- public void testComplex2InterleavedIllegalIndex4Dmin() {
+ void testComplex2InterleavedIllegalIndex4Dmin() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.complex2Interleaved(c4d, -1)
);
}
@Test
- public void testComplex2InterleavedIllegalIndex4Dmax() {
+ void testComplex2InterleavedIllegalIndex4Dmax() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.complex2Interleaved(c4d, 4)
);
}
@Test
- public void testComplex2InterleavedFloatIllegalIndex2Dmin() {
+ void testComplex2InterleavedFloatIllegalIndex2Dmin() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.complex2InterleavedFloat(c2d, -1)
);
}
@Test
- public void testComplex2InterleavedFloatIllegalIndex2Dmax() {
+ void testComplex2InterleavedFloatIllegalIndex2Dmax() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.complex2InterleavedFloat(c2d, 2)
);
}
@Test
- public void testComplex2InterleavedFloatIllegalIndex3Dmin() {
+ void testComplex2InterleavedFloatIllegalIndex3Dmin() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.complex2InterleavedFloat(c3d, -1)
);
}
@Test
- public void testComplex2InterleavedFloatIllegalIndex3Dmax() {
+ void testComplex2InterleavedFloatIllegalIndex3Dmax() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.complex2InterleavedFloat(c3d, 3)
);
}
@Test
- public void testInterleaved2ComplexIllegalIndex2Dmin() {
+ void testInterleaved2ComplexIllegalIndex2Dmin() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.interleaved2Complex(di2d0, -1)
);
}
@Test
- public void testInterleaved2ComplexIllegalIndex2Dmax() {
+ void testInterleaved2ComplexIllegalIndex2Dmax() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.interleaved2Complex(di2d0, 2)
);
}
@Test
- public void testInterleaved2ComplexIllegalIndex3Dmin() {
+ void testInterleaved2ComplexIllegalIndex3Dmin() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.interleaved2Complex(di3d0, -1)
);
}
@Test
- public void testInterleaved2ComplexIllegalIndex3Dmax() {
+ void testInterleaved2ComplexIllegalIndex3Dmax() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.interleaved2Complex(di3d0, 3)
);
}
@Test
- public void testInterleaved2ComplexIllegalIndex4Dmin() {
+ void testInterleaved2ComplexIllegalIndex4Dmin() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.interleaved2Complex(di4d0, -1)
);
}
@Test
- public void testInterleaved2ComplexIllegalIndex4Dmax() {
+ void testInterleaved2ComplexIllegalIndex4Dmax() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.interleaved2Complex(di4d0, 4)
);
}
@Test
- public void testInterleaved2ComplexFloatIllegalIndex2Dmin() {
+ void testInterleaved2ComplexFloatIllegalIndex2Dmin() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.interleaved2Complex(fi2d0, -1)
);
}
@Test
- public void testInterleaved2ComplexFloatIllegalIndex2Dmax() {
+ void testInterleaved2ComplexFloatIllegalIndex2Dmax() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.interleaved2Complex(fi2d0, 2)
);
}
@Test
- public void testInterleaved2ComplexFloatIllegalIndex3Dmin() {
+ void testInterleaved2ComplexFloatIllegalIndex3Dmin() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.interleaved2Complex(fi3d0, -1)
);
}
@Test
- public void testInterleaved2ComplexFloatIllegalIndex3Dmax() {
+ void testInterleaved2ComplexFloatIllegalIndex3Dmax() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> ComplexUtils.interleaved2Complex(fi3d0, 3)
);
}
@Test
- public void testInterleavedToComplex() {
+ void testInterleavedToComplex() {
setArrays();
// Interleaved double to complex, whole array
TestUtils.assertEquals(msg, c, ComplexUtils.interleaved2Complex(di), Math.ulp(1.0));
@@ -667,7 +667,7 @@ public class ComplexUtilsTest {
}
@Test
- public void testComplexToInterleaved() {
+ void testComplexToInterleaved() {
setArrays();
Assertions.assertArrayEquals(di, ComplexUtils.complex2Interleaved(c), Math.ulp(1.0), msg);
// Interleaved complex to float, whole array
@@ -703,7 +703,7 @@ public class ComplexUtilsTest {
// SPLIT TO COMPLEX
@Test
- public void testSplit2Complex() {
+ void testSplit2Complex() {
setArrays();
// Split double to complex, whole array
TestUtils.assertEquals(msg, c, ComplexUtils.split2Complex(sr, si), Math.ulp(1.0));
@@ -718,7 +718,7 @@ public class ComplexUtilsTest {
// INITIALIZATION METHODS
@Test
- public void testInitialize() {
+ void testInitialize() {
Complex[] complexes = new Complex[10];
ComplexUtils.initialize(complexes);
for (Complex cc : complexes) {
@@ -727,7 +727,7 @@ public class ComplexUtilsTest {
}
@Test
- public void testInitialize2d() {
+ void testInitialize2d() {
Complex[][] complexes = new Complex[10][10];
ComplexUtils.initialize(complexes);
for (Complex[] c1 : complexes) {
@@ -738,7 +738,7 @@ public class ComplexUtilsTest {
}
@Test
- public void testInitialize3d() {
+ void testInitialize3d() {
Complex[][][] complexes = new Complex[10][10][10];
ComplexUtils.initialize(complexes);
for (Complex[][] c2 : complexes) {
@@ -751,7 +751,7 @@ public class ComplexUtilsTest {
}
@Test
- public void testAbs() {
+ void testAbs() {
setArrays();
double[] observed = ComplexUtils.abs(c);
Assertions.assertEquals(c.length, observed.length);
@@ -761,7 +761,7 @@ public class ComplexUtilsTest {
}
@Test
- public void testArg() {
+ void testArg() {
setArrays();
double[] observed = ComplexUtils.arg(c);
Assertions.assertEquals(c.length, observed.length);
diff --git a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CReferenceTest.java b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CReferenceTest.java
index 6eab130..322c946 100644
--- a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CReferenceTest.java
+++ b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CReferenceTest.java
@@ -266,72 +266,72 @@ public class CReferenceTest {
}
@Test
- public void testAcos() {
+ void testAcos() {
assertOperation("acos", Complex::acos, 2);
}
@Test
- public void testAcosh() {
+ void testAcosh() {
assertOperation("acosh", Complex::acosh, 2);
}
@Test
- public void testAsinh() {
+ void testAsinh() {
// Odd function: negative real cases defined by positive real cases
assertOperation("asinh", Complex::asinh, 3);
}
@Test
- public void testAtanh() {
+ void testAtanh() {
// Odd function: negative real cases defined by positive real cases
assertOperation("atanh", Complex::atanh, 1);
}
@Test
- public void testCosh() {
+ void testCosh() {
// Even function: negative real cases defined by positive real cases
assertOperation("cosh", Complex::cosh, 2);
}
@Test
- public void testSinh() {
+ void testSinh() {
// Odd function: negative real cases defined by positive real cases
assertOperation("sinh", Complex::sinh, 2);
}
@Test
- public void testTanh() {
+ void testTanh() {
// Odd function: negative real cases defined by positive real cases
assertOperation("tanh", Complex::tanh, 2);
}
@Test
- public void testExp() {
+ void testExp() {
assertOperation("exp", Complex::exp, 2);
}
@Test
- public void testLog() {
+ void testLog() {
assertOperation("log", Complex::log, 1);
}
@Test
- public void testSqrt() {
+ void testSqrt() {
assertOperation("sqrt", Complex::sqrt, 1);
}
@Test
- public void testMultiply() {
+ void testMultiply() {
assertBiOperation("multiply", Complex::multiply, 0);
}
@Test
- public void testDivide() {
+ void testDivide() {
assertBiOperation("divide", Complex::divide, 7);
}
@Test
- public void testPowComplex() {
+ void testPowComplex() {
assertBiOperation("pow", Complex::pow, 9);
}
}
diff --git a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CStandardTest.java b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CStandardTest.java
index cd9b47c..09f8489 100644
--- a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CStandardTest.java
+++ b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/CStandardTest.java
@@ -724,7 +724,7 @@ public class CStandardTest {
* ISO C Standard G.5 (4).
*/
@Test
- public void testMultiply() {
+ void testMultiply() {
final ArrayList<Complex> infinites = createInfinites();
final ArrayList<Complex> nonZeroFinites = createNonZeroFinites();
final ArrayList<Complex> zeroFinites = createZeroFinites();
@@ -783,7 +783,7 @@ public class CStandardTest {
* ISO C Standard G.5 (4).
*/
@Test
- public void testDivide() {
+ void testDivide() {
final ArrayList<Complex> infinites = createInfinites();
final ArrayList<Complex> nonZeroFinites = createNonZeroFinites();
final ArrayList<Complex> zeroFinites = createZeroFinites();
@@ -850,7 +850,7 @@ public class CStandardTest {
* ISO C Standard G.6 (3).
*/
@Test
- public void testSqrt1() {
+ void testSqrt1() {
assertComplex(complex(-2.0, 0.0).sqrt(), complex(0.0, Math.sqrt(2)));
assertComplex(complex(-2.0, -0.0).sqrt(), complex(0.0, -Math.sqrt(2)));
}
@@ -859,7 +859,7 @@ public class CStandardTest {
* ISO C Standard G.6 (7).
*/
@Test
- public void testImplicitTrig() {
+ void testImplicitTrig() {
final UniformRandomProvider rng = RandomSource.create(RandomSource.SPLIT_MIX_64);
for (int i = 0; i < 100; i++) {
final double re = next(rng);
@@ -890,7 +890,7 @@ public class CStandardTest {
* Functionality is defined by ISO C Standard F.9.4.3 hypot function.
*/
@Test
- public void testAbs() {
+ void testAbs() {
Assertions.assertEquals(inf, complex(inf, nan).abs());
Assertions.assertEquals(inf, complex(negInf, nan).abs());
final UniformRandomProvider rng = RandomSource.create(RandomSource.XO_RO_SHI_RO_128_PP);
@@ -975,7 +975,7 @@ public class CStandardTest {
* ISO C Standard G.6.1.1.
*/
@Test
- public void testAcos() {
+ void testAcos() {
final UnaryOperator<Complex> operation = Complex::acos;
assertConjugateEquality(operation);
assertComplex(Complex.ZERO, operation, piTwoNegZero);
@@ -1012,7 +1012,7 @@ public class CStandardTest {
* Complex math functions cacosh and ctanh</a>
*/
@Test
- public void testAcosh() {
+ void testAcosh() {
final UnaryOperator<Complex> operation = Complex::acosh;
assertConjugateEquality(operation);
assertComplex(Complex.ZERO, operation, zeroPiTwo);
@@ -1046,7 +1046,7 @@ public class CStandardTest {
* ISO C Standard G.6.2.2.
*/
@Test
- public void testAsinh() {
+ void testAsinh() {
final UnaryOperator<Complex> operation = Complex::asinh;
final FunctionType type = FunctionType.ODD;
assertConjugateEquality(operation);
@@ -1075,7 +1075,7 @@ public class CStandardTest {
* ISO C Standard G.6.2.3.
*/
@Test
- public void testAtanh() {
+ void testAtanh() {
final UnaryOperator<Complex> operation = Complex::atanh;
final FunctionType type = FunctionType.ODD;
assertConjugateEquality(operation);
@@ -1106,7 +1106,7 @@ public class CStandardTest {
* ISO C Standard G.6.2.4.
*/
@Test
- public void testCosh() {
+ void testCosh() {
final UnaryOperator<Complex> operation = Complex::cosh;
final FunctionType type = FunctionType.EVEN;
assertConjugateEquality(operation);
@@ -1137,7 +1137,7 @@ public class CStandardTest {
* ISO C Standard G.6.2.5.
*/
@Test
- public void testSinh() {
+ void testSinh() {
final UnaryOperator<Complex> operation = Complex::sinh;
final FunctionType type = FunctionType.ODD;
assertConjugateEquality(operation);
@@ -1172,7 +1172,7 @@ public class CStandardTest {
* Complex math functions cacosh and ctanh</a>
*/
@Test
- public void testTanh() {
+ void testTanh() {
final UnaryOperator<Complex> operation = Complex::tanh;
final FunctionType type = FunctionType.ODD;
assertConjugateEquality(operation);
@@ -1202,7 +1202,7 @@ public class CStandardTest {
* ISO C Standard G.6.3.1.
*/
@Test
- public void testExp() {
+ void testExp() {
final UnaryOperator<Complex> operation = Complex::exp;
assertConjugateEquality(operation);
assertComplex(Complex.ZERO, operation, oneZero);
@@ -1235,7 +1235,7 @@ public class CStandardTest {
* ISO C Standard G.6.3.2.
*/
@Test
- public void testLog() {
+ void testLog() {
final UnaryOperator<Complex> operation = Complex::log;
assertConjugateEquality(operation);
assertComplex(negZeroZero, operation, negInfPi);
@@ -1268,7 +1268,7 @@ public class CStandardTest {
* has no effect on infinite or nan.
*/
@Test
- public void testLog10() {
+ void testLog10() {
final UnaryOperator<Complex> operation = Complex::log10;
assertConjugateEquality(operation);
assertComplex(negZeroZero, operation, negInfPi);
@@ -1300,7 +1300,7 @@ public class CStandardTest {
* ISO C Standard G.6.4.2.
*/
@Test
- public void testSqrt() {
+ void testSqrt() {
final UnaryOperator<Complex> operation = Complex::sqrt;
assertConjugateEquality(operation);
assertComplex(negZeroZero, operation, Complex.ZERO);
diff --git a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexEdgeCaseTest.java b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexEdgeCaseTest.java
index 4f76f4d..351baa9 100644
--- a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexEdgeCaseTest.java
+++ b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexEdgeCaseTest.java
@@ -129,7 +129,7 @@ public class ComplexEdgeCaseTest {
}
@Test
- public void testAcos() {
+ void testAcos() {
// acos(z) = (pi / 2) + i ln(iz + sqrt(1 - z^2))
final String name = "acos";
final UnaryOperator<Complex> operation = Complex::acos;
@@ -165,7 +165,7 @@ public class ComplexEdgeCaseTest {
// acosh is defined by acos so is not tested
@Test
- public void testAsin() {
+ void testAsin() {
// asin(z) = -i (ln(iz + sqrt(1 - z^2)))
final String name = "asin";
final UnaryOperator<Complex> operation = Complex::asin;
@@ -198,7 +198,7 @@ public class ComplexEdgeCaseTest {
// asinh is defined by asin so is not tested
@Test
- public void testAtanh() {
+ void testAtanh() {
// atanh(z) = (1/2) ln((1 + z) / (1 - z))
// Odd function: negative real cases defined by positive real cases
final String name = "atanh";
@@ -227,7 +227,7 @@ public class ComplexEdgeCaseTest {
}
@Test
- public void testCosh() {
+ void testCosh() {
// cosh(a + b i) = cosh(a)cos(b) + i sinh(a)sin(b)
// Even function: negative real cases defined by positive real cases
final String name = "cosh";
@@ -292,7 +292,7 @@ public class ComplexEdgeCaseTest {
}
@Test
- public void testSinh() {
+ void testSinh() {
// sinh(a + b i) = sinh(a)cos(b) + i cosh(a)sin(b)
// Odd function: negative real cases defined by positive real cases
final String name = "sinh";
@@ -355,7 +355,7 @@ public class ComplexEdgeCaseTest {
}
@Test
- public void testTanh() {
+ void testTanh() {
// tan(a + b i) = sinh(2a)/(cosh(2a)+cos(2b)) + i [sin(2b)/(cosh(2a)+cos(2b))]
// Odd function: negative real cases defined by positive real cases
final String name = "tanh";
@@ -402,7 +402,7 @@ public class ComplexEdgeCaseTest {
}
@Test
- public void testExp() {
+ void testExp() {
final String name = "exp";
final UnaryOperator<Complex> operation = Complex::exp;
@@ -424,7 +424,7 @@ public class ComplexEdgeCaseTest {
}
@Test
- public void testLog() {
+ void testLog() {
final String name = "log";
final UnaryOperator<Complex> operation = Complex::log;
@@ -558,7 +558,7 @@ public class ComplexEdgeCaseTest {
}
@Test
- public void testSqrt() {
+ void testSqrt() {
final String name = "sqrt";
final UnaryOperator<Complex> operation = Complex::sqrt;
@@ -640,7 +640,7 @@ public class ComplexEdgeCaseTest {
// multiply/divide are tested in CStandardTest
@Test
- public void testDivide() {
+ void testDivide() {
final String name = "divide";
final BiFunction<Complex, Complex, Complex> operation = Complex::divide;
@@ -680,7 +680,7 @@ public class ComplexEdgeCaseTest {
}
@Test
- public void testPow() {
+ void testPow() {
final String name = "pow";
final BiFunction<Complex, Complex, Complex> operation = Complex::pow;
diff --git a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexTest.java b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexTest.java
index 1dcf513..b0c006e 100644
--- a/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexTest.java
+++ b/commons-numbers-complex/src/test/java/org/apache/commons/numbers/complex/ComplexTest.java
@@ -96,7 +96,7 @@ public class ComplexTest {
@Test
@Disabled("Used to output the java environment")
@SuppressWarnings("squid:S2699")
- public void testJava() {
+ void testJava() {
// CHECKSTYLE: stop Regexp
System.out.println(">>testJava()");
// MathTest#testExpSpecialCases() checks the following:
@@ -126,14 +126,14 @@ public class ComplexTest {
}
@Test
- public void testCartesianConstructor() {
+ void testCartesianConstructor() {
final Complex z = Complex.ofCartesian(3.0, 4.0);
Assertions.assertEquals(3.0, z.getReal());
Assertions.assertEquals(4.0, z.getImaginary());
}
@Test
- public void testPolarConstructor() {
+ void testPolarConstructor() {
final double r = 98765;
final double theta = 0.12345;
final Complex z = Complex.ofPolar(r, theta);
@@ -167,7 +167,7 @@ public class ComplexTest {
}
@Test
- public void testPolarConstructorAbsArg() {
+ void testPolarConstructorAbsArg() {
// The test should work with any seed but use a fixed seed to avoid build
// instability.
final UniformRandomProvider rng = RandomSource.create(RandomSource.SPLIT_MIX_64, 678678638L);
@@ -183,7 +183,7 @@ public class ComplexTest {
}
@Test
- public void testCisConstructor() {
+ void testCisConstructor() {
final double x = 0.12345;
final Complex z = Complex.ofCis(x);
Assertions.assertEquals(Math.cos(x), z.getReal());
@@ -194,7 +194,7 @@ public class ComplexTest {
* Test parse and toString are compatible.
*/
@Test
- public void testParseAndToString() {
+ void testParseAndToString() {
final double[] parts = {Double.NEGATIVE_INFINITY, -1, -0.0, 0.0, 1, Math.PI, Double.POSITIVE_INFINITY,
Double.NaN};
for (final double x : parts) {
@@ -217,42 +217,42 @@ public class ComplexTest {
}
@Test
- public void testParseNull() {
+ void testParseNull() {
Assertions.assertThrows(NullPointerException.class, () -> Complex.parse(null));
}
@Test
- public void testParseEmpty() {
+ void testParseEmpty() {
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse(""));
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse(" "));
}
@Test
- public void testParseWrongStart() {
+ void testParseWrongStart() {
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse("1.0,2.0)"));
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse("[1.0,2.0)"));
}
@Test
- public void testParseWrongEnd() {
+ void testParseWrongEnd() {
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse("(1.0,2.0"));
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse("(1.0,2.0]"));
}
@Test
- public void testParseWrongSeparator() {
+ void testParseWrongSeparator() {
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse("(1.0 2.0)"));
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse("(1.0:2.0)"));
}
@Test
- public void testParseSeparatorOutsideStartAndEnd() {
+ void testParseSeparatorOutsideStartAndEnd() {
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse("(1.0,2.0),"));
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse(",(1.0,2.0)"));
}
@Test
- public void testParseExtraSeparator() {
+ void testParseExtraSeparator() {
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse("(1.0,,2.0)"));
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse("(1.0,2.0,)"));
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse("(,1.0,2.0)"));
@@ -260,17 +260,17 @@ public class ComplexTest {
}
@Test
- public void testParseInvalidRe() {
+ void testParseInvalidRe() {
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse("(I.0,2.0)"));
}
@Test
- public void testParseInvalidIm() {
+ void testParseInvalidIm() {
Assertions.assertThrows(NumberFormatException.class, () -> Complex.parse("(1.0,2.G)"));
}
@Test
- public void testParseSpaceAllowedAroundNumbers() {
+ void testParseSpaceAllowedAroundNumbers() {
final double re = 1.234;
final double im = 5.678;
final Complex z = Complex.ofCartesian(re, im);
@@ -283,7 +283,7 @@ public class ComplexTest {
}
@Test
- public void testCGrammar() {
+ void testCGrammar() {
final UniformRandomProvider rng = RandomSource.create(RandomSource.SPLIT_MIX_64);
for (int i = 0; i < 10; i++) {
final Complex z = Complex.ofCartesian(rng.nextDouble(), rng.nextDouble());
@@ -293,13 +293,13 @@ public class ComplexTest {
}
@Test
- public void testAbs() {
+ void testAbs() {
final Complex z = Complex.ofCartesian(3.0, 4.0);
Assertions.assertEquals(5.0, z.abs());
}
@Test
- public void testAbsNaN() {
+ void testAbsNaN() {
// The result is NaN if either argument is NaN and the other is not infinite
Assertions.assertEquals(nan, NAN.abs());
Assertions.assertEquals(nan, Complex.ofCartesian(3.0, nan).abs());
@@ -319,7 +319,7 @@ public class ComplexTest {
* Test standard values
*/
@Test
- public void testArg() {
+ void testArg() {
Complex z = Complex.ofCartesian(1, 0);
assertArgument(0.0, z, 1.0e-12);
@@ -349,7 +349,7 @@ public class ComplexTest {
* Verify atan2-style handling of infinite parts
*/
@Test
- public void testArgInf() {
+ void testArgInf() {
assertArgument(Math.PI / 4, infInf, 1.0e-12);
assertArgument(Math.PI / 2, oneInf, 1.0e-12);
assertArgument(0.0, infOne, 1.0e-12);
@@ -364,7 +364,7 @@ public class ComplexTest {
* Verify that either part NaN results in NaN
*/
@Test
- public void testArgNaN() {
+ void testArgNaN() {
assertArgument(Double.NaN, nanZero, 0);
assertArgument(Double.NaN, zeroNan, 0);
assertArgument(Double.NaN, NAN, 0);
@@ -377,13 +377,13 @@ public class ComplexTest {
}
@Test
- public void testNorm() {
+ void testNorm() {
final Complex z = Complex.ofCartesian(3.0, 4.0);
Assertions.assertEquals(25.0, z.norm());
}
@Test
- public void testNormNaN() {
+ void testNormNaN() {
// The result is NaN if either argument is NaN and the other is not infinite
Assertions.assertEquals(nan, NAN.norm());
Assertions.assertEquals(nan, Complex.ofCartesian(3.0, nan).norm());
@@ -399,7 +399,7 @@ public class ComplexTest {
* Test all number types: isNaN, isInfinite, isFinite.
*/
@Test
- public void testNumberType() {
+ void testNumberType() {
assertNumberType(0, 0, NumberType.FINITE);
assertNumberType(1, 0, NumberType.FINITE);
assertNumberType(0, 1, NumberType.FINITE);
@@ -457,7 +457,7 @@ public class ComplexTest {
}
@Test
- public void testConjugate() {
+ void testConjugate() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final Complex z = x.conj();
Assertions.assertEquals(3.0, z.getReal());
@@ -465,13 +465,13 @@ public class ComplexTest {
}
@Test
- public void testConjugateNaN() {
+ void testConjugateNaN() {
final Complex z = NAN.conj();
Assertions.assertTrue(z.isNaN());
}
@Test
- public void testConjugateInfinite() {
+ void testConjugateInfinite() {
Complex z = Complex.ofCartesian(0, inf);
Assertions.assertEquals(neginf, z.conj().getImaginary());
z = Complex.ofCartesian(0, neginf);
@@ -479,7 +479,7 @@ public class ComplexTest {
}
@Test
- public void testNegate() {
+ void testNegate() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final Complex z = x.negate();
Assertions.assertEquals(-3.0, z.getReal());
@@ -487,13 +487,13 @@ public class ComplexTest {
}
@Test
- public void testNegateNaN() {
+ void testNegateNaN() {
final Complex z = NAN.negate();
Assertions.assertTrue(z.isNaN());
}
@Test
- public void testProj() {
+ void testProj() {
final Complex z = Complex.ofCartesian(3.0, 4.0);
Assertions.assertSame(z, z.proj());
// Sign must be the same for projection
@@ -509,7 +509,7 @@ public class ComplexTest {
}
@Test
- public void testAdd() {
+ void testAdd() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final Complex y = Complex.ofCartesian(5.0, 6.0);
final Complex z = x.add(y);
@@ -518,7 +518,7 @@ public class ComplexTest {
}
@Test
- public void testAddInf() {
+ void testAddInf() {
Complex x = Complex.ofCartesian(1, 1);
final Complex z = Complex.ofCartesian(inf, 0);
final Complex w = x.add(z);
@@ -530,7 +530,7 @@ public class ComplexTest {
}
@Test
- public void testAddReal() {
+ void testAddReal() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 5.0;
final Complex z = x.add(y);
@@ -541,7 +541,7 @@ public class ComplexTest {
}
@Test
- public void testAddRealNaN() {
+ void testAddRealNaN() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = nan;
final Complex z = x.add(y);
@@ -552,7 +552,7 @@ public class ComplexTest {
}
@Test
- public void testAddRealInf() {
+ void testAddRealInf() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = inf;
final Complex z = x.add(y);
@@ -563,7 +563,7 @@ public class ComplexTest {
}
@Test
- public void testAddRealWithNegZeroImaginary() {
+ void testAddRealWithNegZeroImaginary() {
final Complex x = Complex.ofCartesian(3.0, -0.0);
final double y = 5.0;
final Complex z = x.add(y);
@@ -576,7 +576,7 @@ public class ComplexTest {
}
@Test
- public void testAddImaginary() {
+ void testAddImaginary() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 5.0;
final Complex z = x.addImaginary(y);
@@ -587,7 +587,7 @@ public class ComplexTest {
}
@Test
- public void testAddImaginaryNaN() {
+ void testAddImaginaryNaN() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = nan;
final Complex z = x.addImaginary(y);
@@ -598,7 +598,7 @@ public class ComplexTest {
}
@Test
- public void testAddImaginaryInf() {
+ void testAddImaginaryInf() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = inf;
final Complex z = x.addImaginary(y);
@@ -609,7 +609,7 @@ public class ComplexTest {
}
@Test
- public void testAddImaginaryWithNegZeroReal() {
+ void testAddImaginaryWithNegZeroReal() {
final Complex x = Complex.ofCartesian(-0.0, 4.0);
final double y = 5.0;
final Complex z = x.addImaginary(y);
@@ -622,7 +622,7 @@ public class ComplexTest {
}
@Test
- public void testSubtract() {
+ void testSubtract() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final Complex y = Complex.ofCartesian(5.0, 7.0);
final Complex z = x.subtract(y);
@@ -631,7 +631,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractInf() {
+ void testSubtractInf() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final Complex y = Complex.ofCartesian(inf, 7.0);
Complex z = x.subtract(y);
@@ -644,7 +644,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractReal() {
+ void testSubtractReal() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 5.0;
final Complex z = x.subtract(y);
@@ -655,7 +655,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractRealNaN() {
+ void testSubtractRealNaN() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = nan;
final Complex z = x.subtract(y);
@@ -666,7 +666,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractRealInf() {
+ void testSubtractRealInf() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = inf;
final Complex z = x.subtract(y);
@@ -677,7 +677,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractRealWithNegZeroImaginary() {
+ void testSubtractRealWithNegZeroImaginary() {
final Complex x = Complex.ofCartesian(3.0, -0.0);
final double y = 5.0;
final Complex z = x.subtract(y);
@@ -689,7 +689,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractImaginary() {
+ void testSubtractImaginary() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 5.0;
final Complex z = x.subtractImaginary(y);
@@ -700,7 +700,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractImaginaryNaN() {
+ void testSubtractImaginaryNaN() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = nan;
final Complex z = x.subtractImaginary(y);
@@ -711,7 +711,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractImaginaryInf() {
+ void testSubtractImaginaryInf() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = inf;
final Complex z = x.subtractImaginary(y);
@@ -722,7 +722,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractImaginaryWithNegZeroReal() {
+ void testSubtractImaginaryWithNegZeroReal() {
final Complex x = Complex.ofCartesian(-0.0, 4.0);
final double y = 5.0;
final Complex z = x.subtractImaginary(y);
@@ -734,7 +734,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractFromReal() {
+ void testSubtractFromReal() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 5.0;
final Complex z = x.subtractFrom(y);
@@ -745,7 +745,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractFromRealNaN() {
+ void testSubtractFromRealNaN() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = nan;
final Complex z = x.subtractFrom(y);
@@ -756,7 +756,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractFromRealInf() {
+ void testSubtractFromRealInf() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = inf;
final Complex z = x.subtractFrom(y);
@@ -767,7 +767,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractFromRealWithPosZeroImaginary() {
+ void testSubtractFromRealWithPosZeroImaginary() {
final Complex x = Complex.ofCartesian(3.0, 0.0);
final double y = 5.0;
final Complex z = x.subtractFrom(y);
@@ -778,7 +778,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractFromImaginary() {
+ void testSubtractFromImaginary() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 5.0;
final Complex z = x.subtractFromImaginary(y);
@@ -789,7 +789,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractFromImaginaryNaN() {
+ void testSubtractFromImaginaryNaN() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = nan;
final Complex z = x.subtractFromImaginary(y);
@@ -800,7 +800,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractFromImaginaryInf() {
+ void testSubtractFromImaginaryInf() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = inf;
final Complex z = x.subtractFromImaginary(y);
@@ -811,7 +811,7 @@ public class ComplexTest {
}
@Test
- public void testSubtractFromImaginaryWithPosZeroReal() {
+ void testSubtractFromImaginaryWithPosZeroReal() {
final Complex x = Complex.ofCartesian(0.0, 4.0);
final double y = 5.0;
final Complex z = x.subtractFromImaginary(y);
@@ -822,7 +822,7 @@ public class ComplexTest {
}
@Test
- public void testMultiply() {
+ void testMultiply() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final Complex y = Complex.ofCartesian(5.0, 6.0);
final Complex z = x.multiply(y);
@@ -831,7 +831,7 @@ public class ComplexTest {
}
@Test
- public void testMultiplyInfInf() {
+ void testMultiplyInfInf() {
final Complex z = infInf.multiply(infInf);
// Assert.assertTrue(z.isNaN()); // MATH-620
Assertions.assertTrue(z.isInfinite());
@@ -844,7 +844,7 @@ public class ComplexTest {
}
@Test
- public void testMultiplyReal() {
+ void testMultiplyReal() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 2.0;
Complex z = x.multiply(y);
@@ -861,7 +861,7 @@ public class ComplexTest {
}
@Test
- public void testMultiplyRealNaN() {
+ void testMultiplyRealNaN() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = nan;
final Complex z = x.multiply(y);
@@ -872,7 +872,7 @@ public class ComplexTest {
}
@Test
- public void testMultiplyRealInf() {
+ void testMultiplyRealInf() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = inf;
Complex z = x.multiply(y);
@@ -889,7 +889,7 @@ public class ComplexTest {
}
@Test
- public void testMultiplyRealZero() {
+ void testMultiplyRealZero() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 0.0;
Complex z = x.multiply(y);
@@ -908,7 +908,7 @@ public class ComplexTest {
}
@Test
- public void testMultiplyImaginary() {
+ void testMultiplyImaginary() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 2.0;
Complex z = x.multiplyImaginary(y);
@@ -925,7 +925,7 @@ public class ComplexTest {
}
@Test
- public void testMultiplyImaginaryNaN() {
+ void testMultiplyImaginaryNaN() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = nan;
final Complex z = x.multiplyImaginary(y);
@@ -936,7 +936,7 @@ public class ComplexTest {
}
@Test
- public void testMultiplyImaginaryInf() {
+ void testMultiplyImaginaryInf() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = inf;
Complex z = x.multiplyImaginary(y);
@@ -953,7 +953,7 @@ public class ComplexTest {
}
@Test
- public void testMultiplyImaginaryZero() {
+ void testMultiplyImaginaryZero() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 0.0;
Complex z = x.multiplyImaginary(y);
@@ -974,7 +974,7 @@ public class ComplexTest {
}
@Test
- public void testNonZeroMultiplyI() {
+ void testNonZeroMultiplyI() {
final double[] parts = {3.0, 4.0};
for (final double a : parts) {
for (final double b : parts) {
@@ -990,7 +990,7 @@ public class ComplexTest {
}
@Test
- public void testNonZeroMultiplyNegativeI() {
+ void testNonZeroMultiplyNegativeI() {
// This works no matter how you represent -I as a Complex
final double[] parts = {3.0, 4.0};
final Complex[] negIs = {Complex.ofCartesian(-0.0, -1), Complex.ofCartesian(0.0, -1)};
@@ -1010,7 +1010,7 @@ public class ComplexTest {
}
@Test
- public void testMultiplyZeroByI() {
+ void testMultiplyZeroByI() {
final double[] zeros = {-0.0, 0.0};
for (final double a : zeros) {
for (final double b : zeros) {
@@ -1035,7 +1035,7 @@ public class ComplexTest {
}
@Test
- public void testMultiplyZeroByNegativeI() {
+ void testMultiplyZeroByNegativeI() {
// Depending on how we represent -I this does not work for 2/4 cases
// but the cases are different. Here we test the negation of I.
final Complex negI = Complex.I.negate();
@@ -1072,7 +1072,7 @@ public class ComplexTest {
}
@Test
- public void testDivide() {
+ void testDivide() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final Complex y = Complex.ofCartesian(5.0, 6.0);
final Complex z = x.divide(y);
@@ -1081,28 +1081,28 @@ public class ComplexTest {
}
@Test
- public void testDivideZero() {
+ void testDivideZero() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final Complex z = x.divide(Complex.ZERO);
Assertions.assertEquals(INF, z);
}
@Test
- public void testDivideZeroZero() {
+ void testDivideZeroZero() {
final Complex x = Complex.ofCartesian(0.0, 0.0);
final Complex z = x.divide(Complex.ZERO);
Assertions.assertEquals(NAN, z);
}
@Test
- public void testDivideNaN() {
+ void testDivideNaN() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final Complex z = x.divide(NAN);
Assertions.assertTrue(z.isNaN());
}
@Test
- public void testDivideNanInf() {
+ void testDivideNanInf() {
Complex z = oneInf.divide(Complex.ONE);
Assertions.assertTrue(Double.isNaN(z.getReal()));
Assertions.assertEquals(inf, z.getImaginary(), 0);
@@ -1117,7 +1117,7 @@ public class ComplexTest {
}
@Test
- public void testDivideReal() {
+ void testDivideReal() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 2.0;
Complex z = x.divide(y);
@@ -1134,7 +1134,7 @@ public class ComplexTest {
}
@Test
- public void testDivideRealNaN() {
+ void testDivideRealNaN() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = nan;
final Complex z = x.divide(y);
@@ -1145,7 +1145,7 @@ public class ComplexTest {
}
@Test
- public void testDivideRealInf() {
+ void testDivideRealInf() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = inf;
Complex z = x.divide(y);
@@ -1162,7 +1162,7 @@ public class ComplexTest {
}
@Test
- public void testDivideRealZero() {
+ void testDivideRealZero() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 0.0;
Complex z = x.divide(y);
@@ -1179,7 +1179,7 @@ public class ComplexTest {
}
@Test
- public void testDivideImaginary() {
+ void testDivideImaginary() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 2.0;
Complex z = x.divideImaginary(y);
@@ -1196,7 +1196,7 @@ public class ComplexTest {
}
@Test
- public void testDivideImaginaryNaN() {
+ void testDivideImaginaryNaN() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = nan;
final Complex z = x.divideImaginary(y);
@@ -1207,7 +1207,7 @@ public class ComplexTest {
}
@Test
- public void testDivideImaginaryInf() {
+ void testDivideImaginaryInf() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = inf;
Complex z = x.divideImaginary(y);
@@ -1224,7 +1224,7 @@ public class ComplexTest {
}
@Test
- public void testDivideImaginaryZero() {
+ void testDivideImaginaryZero() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final double y = 0.0;
Complex z = x.divideImaginary(y);
@@ -1253,7 +1253,7 @@ public class ComplexTest {
* differences should be the sign of zero in certain cases.
*/
@Test
- public void testSignedArithmetic() {
+ void testSignedArithmetic() {
// The following lists the conditions for the double primitive operation where
// the Complex operation is different. Here the double argument can be:
// x : any value
@@ -1362,7 +1362,7 @@ public class ComplexTest {
* by zero using a Complex then multiplied by I.
*/
@Test
- public void testSignedDivideImaginaryArithmetic() {
+ void testSignedDivideImaginaryArithmetic() {
// Cases for divide by non-zero:
// 2: (-0.0,+x) / -y
// 4: (+x,+/-0.0) / -/+y
@@ -1414,7 +1414,7 @@ public class ComplexTest {
}
@Test
- public void testLog10() {
+ void testLog10() {
final double ln10 = Math.log(10);
final UniformRandomProvider rng = RandomSource.create(RandomSource.SPLIT_MIX_64);
for (int i = 0; i < 10; i++) {
@@ -1429,7 +1429,7 @@ public class ComplexTest {
}
@Test
- public void testPow() {
+ void testPow() {
final Complex x = Complex.ofCartesian(3, 4);
final double yDouble = 5.0;
final Complex yComplex = ofReal(yDouble);
@@ -1437,7 +1437,7 @@ public class ComplexTest {
}
@Test
- public void testPowComplexRealZero() {
+ void testPowComplexRealZero() {
// Hits the edge case when real == 0 but imaginary != 0
final Complex x = Complex.ofCartesian(0, 1);
final Complex z = Complex.ofCartesian(2, 3);
@@ -1448,7 +1448,7 @@ public class ComplexTest {
}
@Test
- public void testPowComplexZeroBase() {
+ void testPowComplexZeroBase() {
final double x = Double.MIN_VALUE;
assertPowComplexZeroBase(0, 0, NAN);
assertPowComplexZeroBase(0, x, NAN);
@@ -1463,7 +1463,7 @@ public class ComplexTest {
}
@Test
- public void testPowScalerRealZero() {
+ void testPowScalerRealZero() {
// Hits the edge case when real == 0 but imaginary != 0
final Complex x = Complex.ofCartesian(0, 1);
final Complex c = x.pow(2);
@@ -1473,7 +1473,7 @@ public class ComplexTest {
}
@Test
- public void testPowScalarZeroBase() {
+ void testPowScalarZeroBase() {
final double x = Double.MIN_VALUE;
assertPowScalarZeroBase(0, NAN);
assertPowScalarZeroBase(x, Complex.ZERO);
@@ -1485,7 +1485,7 @@ public class ComplexTest {
}
@Test
- public void testPowNanBase() {
+ void testPowNanBase() {
final Complex x = NAN;
final double yDouble = 5.0;
final Complex yComplex = ofReal(yDouble);
@@ -1493,7 +1493,7 @@ public class ComplexTest {
}
@Test
- public void testPowNanExponent() {
+ void testPowNanExponent() {
final Complex x = Complex.ofCartesian(3, 4);
final double yDouble = Double.NaN;
final Complex yComplex = ofReal(yDouble);
@@ -1501,7 +1501,7 @@ public class ComplexTest {
}
@Test
- public void testSqrtPolar() {
+ void testSqrtPolar() {
final double tol = 1e-12;
double r = 1;
for (int i = 0; i < 5; i++) {
@@ -1517,7 +1517,7 @@ public class ComplexTest {
}
@Test
- public void testZerothRootThrows() {
+ void testZerothRootThrows() {
final Complex c = Complex.ofCartesian(1, 1);
Assertions.assertThrows(IllegalArgumentException.class, () -> c.nthRoot(0),
"zeroth root should not be allowed");
@@ -1536,7 +1536,7 @@ public class ComplexTest {
* </pre>
*/
@Test
- public void testNthRootNormalThirdRoot() {
+ void testNthRootNormalThirdRoot() {
// The complex number we want to compute all third-roots for.
final Complex z = Complex.ofCartesian(-2, 2);
// The List holding all third roots
@@ -1568,7 +1568,7 @@ public class ComplexTest {
* </pre>
*/
@Test
- public void testNthRootNormalFourthRoot() {
+ void testNthRootNormalFourthRoot() {
// The complex number we want to compute all third-roots for.
final Complex z = Complex.ofCartesian(5, -2);
// The List holding all fourth roots
@@ -1602,7 +1602,7 @@ public class ComplexTest {
* </pre>
*/
@Test
- public void testNthRootCornercaseThirdRootImaginaryPartEmpty() {
+ void testNthRootCornercaseThirdRootImaginaryPartEmpty() {
// The number 8 has three third roots. One we all already know is the number 2.
// But there are two more complex roots.
final Complex z = Complex.ofCartesian(8, 0);
@@ -1634,7 +1634,7 @@ public class ComplexTest {
* </pre>
*/
@Test
- public void testNthRootCornercaseThirdRootRealPartZero() {
+ void testNthRootCornercaseThirdRootRealPartZero() {
// complex number with only imaginary part
final Complex z = Complex.ofCartesian(0, 2);
// The List holding all third roots
@@ -1668,7 +1668,7 @@ public class ComplexTest {
* </pre>
*/
@Test
- public void testNthRootNegativeArg() {
+ void testNthRootNegativeArg() {
// The complex number we want to compute all third-roots for.
final Complex z = Complex.ofCartesian(1, 0);
// The List holding all fourth roots
@@ -1702,7 +1702,7 @@ public class ComplexTest {
}
@Test
- public void testNthRootNan() {
+ void testNthRootNan() {
final int n = 3;
final Complex z = ofReal(Double.NaN);
final List<Complex> r = z.nthRoot(n);
@@ -1714,7 +1714,7 @@ public class ComplexTest {
}
@Test
- public void testNthRootInf() {
+ void testNthRootInf() {
final int n = 3;
final Complex z = ofReal(Double.NEGATIVE_INFINITY);
final List<Complex> r = z.nthRoot(n);
@@ -1722,39 +1722,39 @@ public class ComplexTest {
}
@Test
- public void testEqualsWithNull() {
+ void testEqualsWithNull() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
Assertions.assertFalse(x.equals(null));
}
@Test
- public void testEqualsWithAnotherClass() {
+ void testEqualsWithAnotherClass() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
Assertions.assertFalse(x.equals(new Object()));
}
@Test
- public void testEqualsWithSameObject() {
+ void testEqualsWithSameObject() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
Assertions.assertEquals(x, x);
}
@Test
- public void testEqualsWithCopyObject() {
+ void testEqualsWithCopyObject() {
final Complex x = Complex.ofCartesian(3.0, 4.0);
final Complex y = Complex.ofCartesian(3.0, 4.0);
Assertions.assertEquals(x, y);
}
@Test
- public void testEqualsWithRealDifference() {
+ void testEqualsWithRealDifference() {
final Complex x = Complex.ofCartesian(0.0, 0.0);
final Complex y = Complex.ofCartesian(0.0 + Double.MIN_VALUE, 0.0);
Assertions.assertNotEquals(x, y);
}
@Test
- public void testEqualsWithImaginaryDifference() {
+ void testEqualsWithImaginaryDifference() {
final Complex x = Complex.ofCartesian(0.0, 0.0);
final Complex y = Complex.ofCartesian(0.0, 0.0 + Double.MIN_VALUE);
Assertions.assertNotEquals(x, y);
@@ -1766,7 +1766,7 @@ public class ComplexTest {
* complex numbers.
*/
@Test
- public void testEqualsIsConsistentWithArraysEquals() {
+ void testEqualsIsConsistentWithArraysEquals() {
// Explicit check of the cases documented in the Javadoc:
assertEqualsIsConsistentWithArraysEquals(Complex.ofCartesian(Double.NaN, 0.0),
Complex.ofCartesian(Double.NaN, 1.0), "NaN real and different non-NaN imaginary");
@@ -1804,7 +1804,7 @@ public class ComplexTest {
* {@link Complex#isNaN()} are {@code false} for {@link Complex#equals(Object)}.
*/
@Test
- public void testEqualsWithDifferentNaNs() {
+ void testEqualsWithDifferentNaNs() {
// Test some NaN combinations
final double[] values = {Double.NaN, 0, 1};
final ArrayList<Complex> list = createCombinations(values);
@@ -1847,7 +1847,7 @@ public class ComplexTest {
* hash codes are {@code false} for {@link Object#equals(Object)}.
*/
@Test
- public void testHashCode() {
+ void testHashCode() {
// Test some values match Arrays.hashCode(double[])
final double[] values = {Double.NaN, Double.NEGATIVE_INFINITY, -3.45, -1, -0.0, 0.0, Double.MIN_VALUE, 1, 3.45,
Double.POSITIVE_INFINITY};
@@ -1900,7 +1900,7 @@ public class ComplexTest {
* href="https://issues.apache.org/jira/projects/MATH/issues/MATH-1118">MATH-1118</a>
*/
@Test
- public void testHashCodeWithDifferentZeros() {
+ void testHashCodeWithDifferentZeros() {
final double[] values = {-0.0, 0.0};
final ArrayList<Complex> list = createCombinations(values);
@@ -1951,7 +1951,7 @@ public class ComplexTest {
}
@Test
- public void testAtanhEdgeConditions() {
+ void testAtanhEdgeConditions() {
// Hits the edge case when imaginary == 0 but real != 0 or 1
final Complex c = Complex.ofCartesian(2, 0).atanh();
// Answer from g++
@@ -1960,7 +1960,7 @@ public class ComplexTest {
}
@Test
- public void testAtanhAssumptions() {
+ void testAtanhAssumptions() {
// Compute the same constants used by atanh
final double safeUpper = Math.sqrt(Double.MAX_VALUE) / 2;
final double safeLower = Math.sqrt(Double.MIN_NORMAL) * 2;
@@ -1990,7 +1990,7 @@ public class ComplexTest {
}
@Test
- public void testCoshSinhTanhAssumptions() {
+ void testCoshSinhTanhAssumptions() {
// Use the same constants used to approximate cosh/sinh with e^|x| / 2
final double safeExpMax = 708;
@@ -2042,7 +2042,7 @@ public class ComplexTest {
* of sin and cos together when |x| is small.
*/
@Test
- public void testSinCosLinearAssumptions() {
+ void testSinCosLinearAssumptions() {
// Are cos and sin linear around zero?
// If cos is still 1 then since d(sin) dx = cos then sin is linear.
Assertions.assertEquals(1.0, Math.cos(Double.MIN_NORMAL));
@@ -2065,7 +2065,7 @@ public class ComplexTest {
* different numbers.
*/
@Test
- public void testAbsVsSqrt() {
+ void testAbsVsSqrt() {
final UniformRandomProvider rng = RandomSource.create(RandomSource.XO_RO_SHI_RO_128_PP);
// Note: All methods implement scaling to ensure the magnitude can be computed.
// Try very large or small numbers that will over/underflow to test that the
@@ -2129,7 +2129,7 @@ public class ComplexTest {
* different numbers.
*/
@Test
- public void testAbsVsLog() {
+ void testAbsVsLog() {
final UniformRandomProvider rng = RandomSource.create(RandomSource.XO_RO_SHI_RO_128_PP);
// Note: All methods implement scaling to ensure the magnitude can be computed.
// Try very large or small numbers that will over/underflow to test that the
diff --git a/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/ArithmeticUtilsTest.java b/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/ArithmeticUtilsTest.java
index fbeb78e..a86ae4c 100644
--- a/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/ArithmeticUtilsTest.java
+++ b/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/ArithmeticUtilsTest.java
@@ -30,7 +30,7 @@ import org.junit.jupiter.api.Test;
public class ArithmeticUtilsTest {
@Test
- public void testGcd() {
+ void testGcd() {
int a = 30;
int b = 50;
int c = 77;
@@ -81,7 +81,7 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testGcdConsistency() {
+ void testGcdConsistency() {
// Use Integer to prevent varargs vs array issue with Arrays.asList
Integer[] primeList = {19, 23, 53, 67, 73, 79, 101, 103, 111, 131};
@@ -102,7 +102,7 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testGcdLong() {
+ void testGcdLong() {
long a = 30;
long b = 50;
long c = 77;
@@ -156,7 +156,7 @@ public class ArithmeticUtilsTest {
@Test
- public void testLcm() {
+ void testLcm() {
int a = 30;
int b = 50;
int c = 77;
@@ -203,7 +203,7 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testLcmLong() {
+ void testLcmLong() {
long a = 30;
long b = 50;
long c = 77;
@@ -254,7 +254,7 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testPow() {
+ void testPow() {
Assertions.assertEquals(1801088541, ArithmeticUtils.pow(21, 7));
Assertions.assertEquals(1, ArithmeticUtils.pow(21, 0));
@@ -322,14 +322,14 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testPowIntOverflow() {
+ void testPowIntOverflow() {
Assertions.assertThrows(ArithmeticException.class,
() -> ArithmeticUtils.pow(21, 8)
);
}
@Test
- public void testPowInt() {
+ void testPowInt() {
final int base = 21;
Assertions.assertEquals(85766121L,
@@ -339,14 +339,14 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testPowNegativeIntOverflow() {
+ void testPowNegativeIntOverflow() {
Assertions.assertThrows(ArithmeticException.class,
() -> ArithmeticUtils.pow(-21, 8)
);
}
@Test
- public void testPowNegativeInt() {
+ void testPowNegativeInt() {
final int base = -21;
Assertions.assertEquals(85766121,
@@ -356,7 +356,7 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testPowMinusOneInt() {
+ void testPowMinusOneInt() {
final int base = -1;
for (int i = 0; i < 100; i++) {
final int pow = ArithmeticUtils.pow(base, i);
@@ -365,7 +365,7 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testPowOneInt() {
+ void testPowOneInt() {
final int base = 1;
for (int i = 0; i < 100; i++) {
final int pow = ArithmeticUtils.pow(base, i);
@@ -374,14 +374,14 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testPowLongOverflow() {
+ void testPowLongOverflow() {
Assertions.assertThrows(ArithmeticException.class,
() -> ArithmeticUtils.pow(21, 15)
);
}
@Test
- public void testPowLong() {
+ void testPowLong() {
final long base = 21;
Assertions.assertEquals(154472377739119461L,
@@ -391,14 +391,14 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testPowNegativeLongOverflow() {
+ void testPowNegativeLongOverflow() {
Assertions.assertThrows(ArithmeticException.class,
() -> ArithmeticUtils.pow(-21L, 15)
);
}
@Test
- public void testPowNegativeLong() {
+ void testPowNegativeLong() {
final long base = -21;
Assertions.assertEquals(-154472377739119461L,
@@ -408,7 +408,7 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testPowMinusOneLong() {
+ void testPowMinusOneLong() {
final long base = -1;
for (int i = 0; i < 100; i++) {
final long pow = ArithmeticUtils.pow(base, i);
@@ -417,7 +417,7 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testPowOneLong() {
+ void testPowOneLong() {
final long base = 1;
for (int i = 0; i < 100; i++) {
final long pow = ArithmeticUtils.pow(base, i);
@@ -426,7 +426,7 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testIsPowerOfTwo() {
+ void testIsPowerOfTwo() {
final int n = 1025;
final boolean[] expected = new boolean[n];
Arrays.fill(expected, false);
@@ -533,13 +533,13 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testRemainderUnsignedInt() {
+ void testRemainderUnsignedInt() {
Assertions.assertEquals(36, ArithmeticUtils.remainderUnsigned(-2147479015, 63));
Assertions.assertEquals(6, ArithmeticUtils.remainderUnsigned(-2147479015, 25));
}
@Test
- public void testRemainderUnsignedIntSpecialCases() {
+ void testRemainderUnsignedIntSpecialCases() {
int[] ints = getIntSpecialCases();
for (int dividend : ints) {
for (int divisor : ints) {
@@ -555,12 +555,12 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testRemainderUnsignedLong() {
+ void testRemainderUnsignedLong() {
Assertions.assertEquals(48L, ArithmeticUtils.remainderUnsigned(-2147479015L, 63L));
}
@Test
- public void testRemainderUnsignedLongSpecialCases() {
+ void testRemainderUnsignedLongSpecialCases() {
long[] longs = getLongSpecialCases();
for (long dividend : longs) {
for (long divisor : longs) {
@@ -579,7 +579,7 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testDivideUnsignedInt() {
+ void testDivideUnsignedInt() {
Assertions.assertEquals(34087115, ArithmeticUtils.divideUnsigned(-2147479015, 63));
Assertions.assertEquals(85899531, ArithmeticUtils.divideUnsigned(-2147479015, 25));
Assertions.assertEquals(2147483646, ArithmeticUtils.divideUnsigned(-3, 2));
@@ -593,7 +593,7 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testDivideUnsignedIntSpecialCases() {
+ void testDivideUnsignedIntSpecialCases() {
int[] ints = getIntSpecialCases();
for (int dividend : ints) {
for (int divisor : ints) {
@@ -609,12 +609,12 @@ public class ArithmeticUtilsTest {
}
@Test
- public void testDivideUnsignedLong() {
+ void testDivideUnsignedLong() {
Assertions.assertEquals(292805461453366231L, ArithmeticUtils.divideUnsigned(-2147479015L, 63L));
}
@Test
- public void testDivideUnsignedLongSpecialCases() {
+ void testDivideUnsignedLongSpecialCases() {
long[] longs = getLongSpecialCases();
for (long dividend : longs) {
for (long divisor : longs) {
diff --git a/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/PrecisionTest.java b/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/PrecisionTest.java
index 92e193f..94e8ca4 100644
--- a/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/PrecisionTest.java
+++ b/commons-numbers-core/src/test/java/org/apache/commons/numbers/core/PrecisionTest.java
@@ -50,7 +50,7 @@ public class PrecisionTest {
}
@Test
- public void testEqualsWithRelativeTolerance() {
+ void testEqualsWithRelativeTolerance() {
Assertions.assertTrue(Precision.equalsWithRelativeTolerance(0d, 0d, 0d));
Assertions.assertTrue(Precision.equalsWithRelativeTolerance(0d, 1 / Double.NEGATIVE_INFINITY, 0d));
@@ -77,7 +77,7 @@ public class PrecisionTest {
}
@Test
- public void testEqualsIncludingNaN() {
+ void testEqualsIncludingNaN() {
double[] testArray = {
Double.NaN,
Double.POSITIVE_INFINITY,
@@ -98,12 +98,12 @@ public class PrecisionTest {
}
@Test
- public void testEqualsWithAllowedDelta() {
+ void testEqualsWithAllowedDelta() {
assertEqualsWithAllowedDelta(Precision::equalsIncludingNaN, true);
}
@Test
- public void testEqualsIncludingNaNWithAllowedDelta() {
+ void testEqualsIncludingNaNWithAllowedDelta() {
assertEqualsWithAllowedDelta(Precision::equalsIncludingNaN, true);
}
@@ -120,18 +120,18 @@ public class PrecisionTest {
}
@Test
- public void testEqualsWithAllowedUlps() {
+ void testEqualsWithAllowedUlps() {
assertEqualsIncludingNaNWithAllowedUlps(Precision::equals, false, false);
}
@Test
- public void testEqualsWithImplicitAllowedUlpsOf1() {
+ void testEqualsWithImplicitAllowedUlpsOf1() {
// Use the version without the ulp argument
assertEqualsIncludingNaNWithAllowedUlps((a, b, ulp) -> Precision.equals(a, b), false, true);
}
@Test
- public void testEqualsIncludingNaNWithAllowedUlps() {
+ void testEqualsIncludingNaNWithAllowedUlps() {
assertEqualsIncludingNaNWithAllowedUlps(Precision::equalsIncludingNaN, true, false);
}
@@ -176,7 +176,7 @@ public class PrecisionTest {
// converted to float
@Test
- public void testFloatEqualsIncludingNaN() {
+ void testFloatEqualsIncludingNaN() {
float[] testArray = {
Float.NaN,
Float.POSITIVE_INFINITY,
@@ -197,12 +197,12 @@ public class PrecisionTest {
}
@Test
- public void testFloatEqualsWithAllowedDelta() {
+ void testFloatEqualsWithAllowedDelta() {
assertFloatEqualsWithAllowedDelta(Precision::equalsIncludingNaN, true);
}
@Test
- public void testFloatEqualsIncludingNaNWithAllowedDelta() {
+ void testFloatEqualsIncludingNaNWithAllowedDelta() {
assertFloatEqualsWithAllowedDelta(Precision::equalsIncludingNaN, true);
}
@@ -219,18 +219,18 @@ public class PrecisionTest {
}
@Test
- public void testFloatEqualsWithAllowedUlps() {
+ void testFloatEqualsWithAllowedUlps() {
assertFloatEqualsIncludingNaNWithAllowedUlps(Precision::equals, false, false);
}
@Test
- public void testFloatEqualsWithImplicitAllowedUlpsOf1() {
+ void testFloatEqualsWithImplicitAllowedUlpsOf1() {
// Use the version without the ulp argument
assertFloatEqualsIncludingNaNWithAllowedUlps((a, b, ulp) -> Precision.equals(a, b), false, true);
}
@Test
- public void testFloatEqualsIncludingNaNWithAllowedUlps() {
+ void testFloatEqualsIncludingNaNWithAllowedUlps() {
assertFloatEqualsIncludingNaNWithAllowedUlps(Precision::equalsIncludingNaN, true, false);
}
@@ -272,7 +272,7 @@ public class PrecisionTest {
}
@Test
- public void testCompareToEpsilon() {
+ void testCompareToEpsilon() {
Assertions.assertEquals(0, Precision.compareTo(152.33, 152.32, .011));
Assertions.assertTrue(Precision.compareTo(152.308, 152.32, .011) < 0);
Assertions.assertTrue(Precision.compareTo(152.33, 152.318, .011) > 0);
@@ -281,7 +281,7 @@ public class PrecisionTest {
}
@Test
- public void testCompareToMaxUlps() {
+ void testCompareToMaxUlps() {
double a = 152.32;
double delta = Math.ulp(a);
for (int i = 0; i <= 10; ++i) {
@@ -318,7 +318,7 @@ public class PrecisionTest {
}
@Test
- public void testRoundDouble() {
+ void testRoundDouble() {
double x = 1.234567890;
Assertions.assertEquals(1.23, Precision.round(x, 2), 0.0);
Assertions.assertEquals(1.235, Precision.round(x, 3), 0.0);
@@ -423,7 +423,7 @@ public class PrecisionTest {
}
@Test
- public void testRepresentableDelta() {
+ void testRepresentableDelta() {
int nonRepresentableCount = 0;
final double x = 100;
final int numTrials = 10000;
@@ -439,13 +439,13 @@ public class PrecisionTest {
}
@Test
- public void testIssue721() {
+ void testIssue721() {
Assertions.assertEquals(-53, Math.getExponent(Precision.EPSILON));
Assertions.assertEquals(-1022, Math.getExponent(Precision.SAFE_MIN));
}
@Test
- public void testMath475() {
+ void testMath475() {
final double a = 1.7976931348623182E16;
final double b = Math.nextUp(a);
@@ -464,7 +464,7 @@ public class PrecisionTest {
}
@Test
- public void testMath475Float() {
+ void testMath475Float() {
final float a = 1.7976931348623182E16f;
final float b = Math.nextUp(a);
@@ -483,7 +483,7 @@ public class PrecisionTest {
}
@Test
- public void testMath843() {
+ void testMath843() {
final double afterEpsilon = Math.nextAfter(Precision.EPSILON,
Double.POSITIVE_INFINITY);
@@ -495,7 +495,7 @@ public class PrecisionTest {
}
@Test
- public void testMath1127() {
+ void testMath1127() {
Assertions.assertFalse(Precision.equals(2.0, -2.0, 1));
Assertions.assertTrue(Precision.equals(0.0, -0.0, 0));
Assertions.assertFalse(Precision.equals(2.0f, -2.0f, 1));
diff --git a/commons-numbers-examples/examples-jmh/src/test/java/org/apache/commons/numbers/examples/jmh/arrays/DoublePrecisionTest.java b/commons-numbers-examples/examples-jmh/src/test/java/org/apache/commons/numbers/examples/jmh/arrays/DoublePrecisionTest.java
index deda670..d48c5a0 100644
--- a/commons-numbers-examples/examples-jmh/src/test/java/org/apache/commons/numbers/examples/jmh/arrays/DoublePrecisionTest.java
+++ b/commons-numbers-examples/examples-jmh/src/test/java/org/apache/commons/numbers/examples/jmh/arrays/DoublePrecisionTest.java
@@ -24,7 +24,7 @@ import org.junit.jupiter.api.Test;
*/
public class DoublePrecisionTest {
@Test
- public void testSplitAssumptions() {
+ void testSplitAssumptions() {
// The multiplier used to split the double value into high and low parts.
final double scale = (1 << 27) + 1;
// The upper limit above which a number may overflow during the split into a high part.
@@ -40,7 +40,7 @@ public class DoublePrecisionTest {
}
@Test
- public void testHighPart() {
+ void testHighPart() {
Assertions.assertEquals(Double.NaN, DoublePrecision.highPart(Double.POSITIVE_INFINITY));
Assertions.assertEquals(Double.NaN, DoublePrecision.highPart(Double.NEGATIVE_INFINITY));
Assertions.assertEquals(Double.NaN, DoublePrecision.highPart(Double.NaN));
@@ -50,7 +50,7 @@ public class DoublePrecisionTest {
}
@Test
- public void testHighPartUnscaled() {
+ void testHighPartUnscaled() {
Assertions.assertEquals(Double.NaN, DoublePrecision.highPartUnscaled(Double.POSITIVE_INFINITY));
Assertions.assertEquals(Double.NaN, DoublePrecision.highPartUnscaled(Double.NEGATIVE_INFINITY));
Assertions.assertEquals(Double.NaN, DoublePrecision.highPartUnscaled(Double.NaN));
@@ -64,7 +64,7 @@ public class DoublePrecisionTest {
* result as JDK 9 Math.fma(x, y, -x * y) for edge cases.
*/
@Test
- public void testProductLow() {
+ void testProductLow() {
assertProductLow(0.0, 1.0, Math.nextDown(Double.MIN_NORMAL));
assertProductLow(0.0, -1.0, Math.nextDown(Double.MIN_NORMAL));
assertProductLow(Double.NaN, 1.0, Double.POSITIVE_INFINITY);
@@ -79,7 +79,7 @@ public class DoublePrecisionTest {
}
@Test
- public void testIsNotNormal() {
+ void testIsNotNormal() {
for (double a : new double[] {Double.MAX_VALUE, 1.0, Double.MIN_NORMAL}) {
Assertions.assertFalse(DoublePrecision.isNotNormal(a));
Assertions.assertFalse(DoublePrecision.isNotNormal(-a));
diff --git a/commons-numbers-examples/examples-jmh/src/test/java/org/apache/commons/numbers/examples/jmh/arrays/LinearCombinationsTest.java b/commons-numbers-examples/examples-jmh/src/test/java/org/apache/commons/numbers/examples/jmh/arrays/LinearCombinationsTest.java
index f2c99d1..d0bccb3 100644
--- a/commons-numbers-examples/examples-jmh/src/test/java/org/apache/commons/numbers/examples/jmh/arrays/LinearCombinationsTest.java
+++ b/commons-numbers-examples/examples-jmh/src/test/java/org/apache/commons/numbers/examples/jmh/arrays/LinearCombinationsTest.java
@@ -359,7 +359,7 @@ public class LinearCombinationsTest {
* greater in magnitude than the the original number due to round-off in the split.
*/
@Test
- public void testOverflow() {
+ void testOverflow() {
// Create a simple dot product that is different in high precision and has
// values that create a high part above the original number. This can be done using
// a mantissa with almost all bits set to 1.
@@ -423,7 +423,7 @@ public class LinearCombinationsTest {
* This case is derived from computations on a complex cis number.
*/
@Test
- public void testCisNumber() {
+ void testCisNumber() {
final double theta = 5.992112452678286E-7;
final double x = Math.cos(theta);
final double y = Math.sin(theta);
@@ -439,7 +439,7 @@ public class LinearCombinationsTest {
* round-off sum in single or 2-fold precision.
*/
@Test
- public void testSumZero() {
+ void testSumZero() {
// Fixed seed for stability
final UniformRandomProvider rng = RandomSource.create(RandomSource.XO_RO_SHI_RO_128_PP, 876543L);
final int size = 10;
@@ -569,7 +569,7 @@ public class LinearCombinationsTest {
* Test the clip method does what it specifies.
*/
@Test
- public void testClip() {
+ void testClip() {
// min value is not affected
Assertions.assertEquals(Double.MIN_VALUE, clip(MIN).doubleValue());
Assertions.assertEquals(-Double.MIN_VALUE, clip(MIN.negate()).doubleValue());
diff --git a/commons-numbers-field/src/test/java/org/apache/commons/numbers/field/FP64Test.java b/commons-numbers-field/src/test/java/org/apache/commons/numbers/field/FP64Test.java
index 260ecc7..6291667 100644
--- a/commons-numbers-field/src/test/java/org/apache/commons/numbers/field/FP64Test.java
+++ b/commons-numbers-field/src/test/java/org/apache/commons/numbers/field/FP64Test.java
@@ -24,7 +24,7 @@ import org.junit.jupiter.api.Test;
*/
public class FP64Test {
@Test
- public void testConsistencyWithDouble() {
+ void testConsistencyWithDouble() {
final double v = -5.67e89;
final Double a = Double.valueOf(v);
final FP64 b = FP64.of(v);
@@ -38,7 +38,7 @@ public class FP64Test {
}
@Test
- public void testEquals() {
+ void testEquals() {
final FP64 a = FP64.of(1.23);
final FP64 b = FP64.of(4.56);
@@ -54,23 +54,23 @@ public class FP64Test {
}
@Test
- public void testOne() {
+ void testOne() {
Assertions.assertEquals(1d, FP64.of(-3.4).one().doubleValue(), 0d);
}
@Test
- public void testZero() {
+ void testZero() {
Assertions.assertEquals(0d, FP64.of(-3.4).zero().doubleValue(), 0d);
}
@Test
- public void testSubtract() {
+ void testSubtract() {
final double a = 123.4;
final double b = 5678.9;
Assertions.assertEquals(a - b, FP64.of(a).subtract(FP64.of(b)).doubleValue(), 0d);
}
@Test
- public void testDivide() {
+ void testDivide() {
final double a = 123.4;
final double b = 5678.9;
@@ -78,7 +78,7 @@ public class FP64Test {
}
@Test
- public void testMultiplyInt() {
+ void testMultiplyInt() {
final double a = 123.4;
final int n = 3456789;
@@ -86,19 +86,19 @@ public class FP64Test {
}
@Test
- public void testPowInt() {
+ void testPowInt() {
final double a = 123.4;
final int n = 5;
Assertions.assertEquals(Math.pow(a, n), FP64.of(a).pow(n).doubleValue(), 0d);
}
@Test
- public void testZeroPow() {
+ void testZeroPow() {
Assertions.assertSame(FP64.of(9876.5).one(), FP64.of(2.3456).pow(0));
}
@Test
- public void testCompare() {
+ void testCompare() {
Assertions.assertTrue(FP64.of(0).compareTo(FP64.of(-1)) > 0);
Assertions.assertTrue(FP64.of(1).compareTo(FP64.of(2)) < 0);
diff --git a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/BigFractionTest.java b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/BigFractionTest.java
index f0bcd27..a457767 100644
--- a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/BigFractionTest.java
+++ b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/BigFractionTest.java
@@ -69,7 +69,7 @@ public class BigFractionTest {
}
@Test
- public void testConstructor() {
+ void testConstructor() {
for (final CommonTestCases.UnaryOperatorTestCase testCase : CommonTestCases.numDenConstructorTestCases()) {
assertFraction(
testCase.expectedNumerator,
@@ -97,7 +97,7 @@ public class BigFractionTest {
}
@Test
- public void testConstructorZero() {
+ void testConstructorZero() {
Assertions.assertSame(BigFraction.ZERO, BigFraction.from(0.0));
Assertions.assertSame(BigFraction.ZERO, BigFraction.from(0.0, 1e-10, 100));
Assertions.assertSame(BigFraction.ZERO, BigFraction.from(0.0, 100));
@@ -114,7 +114,7 @@ public class BigFractionTest {
// MATH-179
@Test
- public void testDoubleConstructor() throws Exception {
+ void testDoubleConstructor() throws Exception {
for (final CommonTestCases.DoubleToFractionTestCase testCase : CommonTestCases.doubleConstructorTestCases()) {
assertFraction(
testCase.expectedNumerator,
@@ -148,7 +148,7 @@ public class BigFractionTest {
// MATH-181
// NUMBERS-147
@Test
- public void testDoubleConstructorWithMaxDenominator() throws Exception {
+ void testDoubleConstructorWithMaxDenominator() throws Exception {
for (final CommonTestCases.DoubleToFractionTestCase testCase : CommonTestCases.doubleMaxDenomConstructorTestCases()) {
assertFraction(
testCase.expectedNumerator,
@@ -168,7 +168,7 @@ public class BigFractionTest {
}
@Test
- public void testDoubleConstructorThrows() {
+ void testDoubleConstructorThrows() {
final double eps = 1e-5;
final int maxIterations = Integer.MAX_VALUE;
final int maxDenominator = Integer.MAX_VALUE;
@@ -185,7 +185,7 @@ public class BigFractionTest {
}
@Test
- public void testDoubleConstructorGoldenRatioThrows() {
+ void testDoubleConstructorGoldenRatioThrows() {
// the golden ratio is notoriously a difficult number for continuous fraction
Assertions.assertThrows(FractionException.class,
() -> BigFraction.from((1 + Math.sqrt(5)) / 2, 1.0e-12, 25)
@@ -194,7 +194,7 @@ public class BigFractionTest {
// MATH-1029
@Test
- public void testDoubleConstructorWithMaxDenominatorOverFlow() {
+ void testDoubleConstructorWithMaxDenominatorOverFlow() {
Assertions.assertThrows(ArithmeticException.class,
() -> BigFraction.from(1e10, 1000)
);
@@ -204,7 +204,7 @@ public class BigFractionTest {
}
@Test
- public void testDoubleConstructorOverflow() {
+ void testDoubleConstructorOverflow() {
assertDoubleConstructorOverflow(0.75000000001455192);
assertDoubleConstructorOverflow(1.0e10);
assertDoubleConstructorOverflow(-1.0e10);
@@ -218,7 +218,7 @@ public class BigFractionTest {
}
@Test
- public void testDoubleConstructorWithEpsilonLimit() throws Exception {
+ void testDoubleConstructorWithEpsilonLimit() throws Exception {
assertFraction(2, 5, BigFraction.from(0.4, 1.0e-5, 100));
assertFraction(3, 5, BigFraction.from(0.6152, 0.02, 100));
@@ -230,7 +230,7 @@ public class BigFractionTest {
}
@Test
- public void testCompareTo() {
+ void testCompareTo() {
final BigFraction a = BigFraction.of(1, 2);
final BigFraction b = BigFraction.of(1, 3);
final BigFraction c = BigFraction.of(1, 2);
@@ -272,7 +272,7 @@ public class BigFractionTest {
}
@Test
- public void testDoubleValue() {
+ void testDoubleValue() {
assertDoubleValue(0.5, 1, 2);
assertDoubleValue(-0.5, -1, 2);
assertDoubleValue(-0.5, 1, -2);
@@ -303,7 +303,7 @@ public class BigFractionTest {
}
@Test
- public void testDoubleValueForSubnormalNumbers() {
+ void testDoubleValueForSubnormalNumbers() {
assertDoubleValue(
//Double.MIN_VALUE * 2/3
Double.MIN_VALUE,
@@ -347,7 +347,7 @@ public class BigFractionTest {
}
@Test
- public void testDoubleValueForInfinities() {
+ void testDoubleValueForInfinities() {
//the smallest integer that rounds up to Double.POSITIVE_INFINITY
final BigInteger minInf = BigInteger.ONE
.shiftLeft(1024)
@@ -367,7 +367,7 @@ public class BigFractionTest {
// MATH-744
@Test
- public void testDoubleValueForLargeNumeratorAndDenominator() {
+ void testDoubleValueForLargeNumeratorAndDenominator() {
final BigInteger pow400 = BigInteger.TEN.pow(400);
final BigInteger pow401 = BigInteger.TEN.pow(401);
final BigInteger two = new BigInteger("2");
@@ -379,7 +379,7 @@ public class BigFractionTest {
// MATH-744
@Test
- public void testFloatValueForLargeNumeratorAndDenominator() {
+ void testFloatValueForLargeNumeratorAndDenominator() {
final BigInteger pow400 = BigInteger.TEN.pow(400);
final BigInteger pow401 = BigInteger.TEN.pow(401);
final BigInteger two = new BigInteger("2");
@@ -390,7 +390,7 @@ public class BigFractionTest {
}
@Test
- public void testDoubleValueForLargeNumeratorAndSmallDenominator() {
+ void testDoubleValueForLargeNumeratorAndSmallDenominator() {
// NUMBERS-15
final BigInteger pow300 = BigInteger.TEN.pow(300);
final BigInteger pow330 = BigInteger.TEN.pow(330);
@@ -421,7 +421,7 @@ public class BigFractionTest {
// NUMBERS-15
@Test
- public void testFloatValueForLargeNumeratorAndSmallDenominator() {
+ void testFloatValueForLargeNumeratorAndSmallDenominator() {
final BigInteger pow30 = BigInteger.TEN.pow(30);
final BigInteger pow40 = BigInteger.TEN.pow(40);
final BigFraction large = BigFraction.of(pow40.add(BigInteger.ONE),
@@ -431,7 +431,7 @@ public class BigFractionTest {
}
@Test
- public void testFloatValue() {
+ void testFloatValue() {
Assertions.assertEquals(0.5f, BigFraction.of(1, 2).floatValue());
Assertions.assertEquals(0.5f, BigFraction.of(-1, -2).floatValue());
Assertions.assertEquals(-0.5f, BigFraction.of(-1, 2).floatValue());
@@ -448,7 +448,7 @@ public class BigFractionTest {
}
@Test
- public void testIntValue() {
+ void testIntValue() {
Assertions.assertEquals(0, BigFraction.of(1, 2).intValue());
Assertions.assertEquals(0, BigFraction.of(-1, -2).intValue());
Assertions.assertEquals(0, BigFraction.of(-1, 2).intValue());
@@ -464,7 +464,7 @@ public class BigFractionTest {
}
@Test
- public void testLongValue() {
+ void testLongValue() {
Assertions.assertEquals(0L, BigFraction.of(1, 2).longValue());
Assertions.assertEquals(0L, BigFraction.of(-1, -2).longValue());
Assertions.assertEquals(0L, BigFraction.of(-1, 2).longValue());
@@ -480,7 +480,7 @@ public class BigFractionTest {
}
@Test
- public void testBigDecimalValue() {
+ void testBigDecimalValue() {
Assertions.assertEquals(new BigDecimal(0.5), BigFraction.of(1, 2).bigDecimalValue());
Assertions.assertEquals(new BigDecimal("0.0003"), BigFraction.of(3, 10000).bigDecimalValue());
Assertions.assertEquals(new BigDecimal("0"), BigFraction.of(1, 3).bigDecimalValue(RoundingMode.DOWN));
@@ -488,7 +488,7 @@ public class BigFractionTest {
}
@Test
- public void testAbs() {
+ void testAbs() {
for (final CommonTestCases.UnaryOperatorTestCase testCase : CommonTestCases.absTestCases()) {
final BigFraction f = BigFraction.of(testCase.operandNumerator, testCase.operandDenominator);
assertFraction(testCase.expectedNumerator, testCase.expectedDenominator, f.abs());
@@ -496,7 +496,7 @@ public class BigFractionTest {
}
@Test
- public void testReciprocal() {
+ void testReciprocal() {
for (final CommonTestCases.UnaryOperatorTestCase testCase : CommonTestCases.reciprocalTestCases()) {
final BigFraction f = BigFraction.of(testCase.operandNumerator, testCase.operandDenominator);
assertFraction(testCase.expectedNumerator, testCase.expectedDenominator, f.reciprocal());
@@ -507,7 +507,7 @@ public class BigFractionTest {
}
@Test
- public void testNegate() {
+ void testNegate() {
for (final CommonTestCases.UnaryOperatorTestCase testCase : CommonTestCases.negateTestCases()) {
final BigFraction f = BigFraction.of(testCase.operandNumerator, testCase.operandDenominator);
assertFraction(testCase.expectedNumerator, testCase.expectedDenominator, f.negate());
@@ -515,7 +515,7 @@ public class BigFractionTest {
}
@Test
- public void testAdd() {
+ void testAdd() {
for (final CommonTestCases.BinaryOperatorTestCase testCase : CommonTestCases.addFractionTestCases()) {
final BigFraction f1 = BigFraction.of(testCase.firstOperandNumerator, testCase.firstOperandDenominator);
final BigFraction f2 = BigFraction.of(testCase.secondOperandNumerator, testCase.secondOperandDenominator);
@@ -539,7 +539,7 @@ public class BigFractionTest {
}
@Test
- public void testDivide() {
+ void testDivide() {
for (final CommonTestCases.BinaryOperatorTestCase testCase : CommonTestCases.divideByFractionTestCases()) {
final BigFraction f1 = BigFraction.of(testCase.firstOperandNumerator, testCase.firstOperandDenominator);
final BigFraction f2 = BigFraction.of(testCase.secondOperandNumerator, testCase.secondOperandDenominator);
@@ -569,7 +569,7 @@ public class BigFractionTest {
}
@Test
- public void testMultiply() {
+ void testMultiply() {
for (final CommonTestCases.BinaryOperatorTestCase testCase : CommonTestCases.multiplyByFractionTestCases()) {
final BigFraction f1 = BigFraction.of(testCase.firstOperandNumerator, testCase.firstOperandDenominator);
final BigFraction f2 = BigFraction.of(testCase.secondOperandNumerator, testCase.secondOperandDenominator);
@@ -588,7 +588,7 @@ public class BigFractionTest {
}
@Test
- public void testPow() {
+ void testPow() {
for (final CommonTestCases.BinaryIntOperatorTestCase testCase : CommonTestCases.powTestCases()) {
final BigFraction f1 = BigFraction.of(testCase.firstOperandNumerator, testCase.firstOperandDenominator);
final int exponent = testCase.secondOperand;
@@ -604,7 +604,7 @@ public class BigFractionTest {
}
@Test
- public void testSubtract() {
+ void testSubtract() {
for (final CommonTestCases.BinaryOperatorTestCase testCase : CommonTestCases.subtractFractionTestCases()) {
final BigFraction f1 = BigFraction.of(testCase.firstOperandNumerator, testCase.firstOperandDenominator);
final BigFraction f2 = BigFraction.of(testCase.secondOperandNumerator, testCase.secondOperandDenominator);
@@ -623,7 +623,7 @@ public class BigFractionTest {
}
@Test
- public void testEqualsAndHashCode() {
+ void testEqualsAndHashCode() {
final BigFraction zero = BigFraction.of(0, 1);
Assertions.assertEquals(zero, zero);
Assertions.assertFalse(zero.equals(null));
@@ -685,17 +685,17 @@ public class BigFractionTest {
}
@Test
- public void testAdditiveNeutral() {
+ void testAdditiveNeutral() {
Assertions.assertEquals(BigFraction.ZERO, BigFraction.ONE.zero());
}
@Test
- public void testMultiplicativeNeutral() {
+ void testMultiplicativeNeutral() {
Assertions.assertEquals(BigFraction.ONE, BigFraction.ZERO.one());
}
@Test
- public void testSerial() {
+ void testSerial() {
final BigFraction[] fractions = {
BigFraction.of(3, 4), BigFraction.ONE, BigFraction.ZERO,
BigFraction.of(17), BigFraction.from(Math.PI, 1000),
@@ -708,7 +708,7 @@ public class BigFractionTest {
}
@Test
- public void testToString() {
+ void testToString() {
Assertions.assertEquals("0", BigFraction.of(0, 3).toString());
Assertions.assertEquals("0", BigFraction.of(0, -3).toString());
Assertions.assertEquals("3", BigFraction.of(6, 2).toString());
@@ -718,7 +718,7 @@ public class BigFractionTest {
}
@Test
- public void testParse() {
+ void testParse() {
final String[] validExpressions = new String[] {
"1 / 2",
"-1 / 2",
@@ -770,7 +770,7 @@ public class BigFractionTest {
}
@Test
- public void testMath340() {
+ void testMath340() {
final BigFraction fractionA = BigFraction.from(0.00131);
final BigFraction fractionB = BigFraction.from(.37).reciprocal();
final BigFraction errorResult = fractionA.multiply(fractionB);
diff --git a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/ContinuedFractionTest.java b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/ContinuedFractionTest.java
index 6760894..af2f180 100644
--- a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/ContinuedFractionTest.java
+++ b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/ContinuedFractionTest.java
@@ -26,7 +26,7 @@ import org.junit.jupiter.api.Test;
public class ContinuedFractionTest {
@Test
- public void testGoldenRatio() throws Exception {
+ void testGoldenRatio() throws Exception {
ContinuedFraction cf = new ContinuedFraction() {
@Override
public double getA(int n, double x) {
@@ -45,7 +45,7 @@ public class ContinuedFractionTest {
}
@Test
- public void test415Over93() throws Exception {
+ void test415Over93() throws Exception {
// https://en.wikipedia.org/wiki/Continued_fraction
// 415 1
// --- = 4 + ---------
@@ -80,7 +80,7 @@ public class ContinuedFractionTest {
}
@Test
- public void testMaxIterationsThrows() throws Exception {
+ void testMaxIterationsThrows() throws Exception {
ContinuedFraction cf = new ContinuedFraction() {
@Override
public double getA(int n, double x) {
@@ -101,7 +101,7 @@ public class ContinuedFractionTest {
}
@Test
- public void testNaNThrows() throws Exception {
+ void testNaNThrows() throws Exception {
// Create a NaN during the iteration
ContinuedFraction cf = new ContinuedFraction() {
@Override
@@ -122,7 +122,7 @@ public class ContinuedFractionTest {
}
@Test
- public void testInfThrows() throws Exception {
+ void testInfThrows() throws Exception {
// Create an infinity during the iteration:
// a / cPrev => a_1 / b_0 => Double.MAX_VALUE / 0.5
ContinuedFraction cf = new ContinuedFraction() {
@@ -150,7 +150,7 @@ public class ContinuedFractionTest {
// NUMBERS-46
@Test
- public void testOneIteration() {
+ void testOneIteration() {
ContinuedFraction cf = new ContinuedFraction() {
@Override
public double getA(int n, double x) {
@@ -170,7 +170,7 @@ public class ContinuedFractionTest {
// NUMBERS-46
@Test
- public void testTwoIterations() {
+ void testTwoIterations() {
ContinuedFraction cf = new ContinuedFraction() {
@Override
public double getA(int n, double x) {
diff --git a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionTest.java b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionTest.java
index f26a616..0c5bc3e 100644
--- a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionTest.java
+++ b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionTest.java
@@ -49,7 +49,7 @@ public class FractionTest {
}
@Test
- public void testConstructor() {
+ void testConstructor() {
for (final CommonTestCases.UnaryOperatorTestCase testCase : CommonTestCases.numDenConstructorTestCases()) {
assertFraction(
testCase.expectedNumerator,
@@ -69,7 +69,7 @@ public class FractionTest {
}
@Test
- public void testConstructorZero() {
+ void testConstructorZero() {
Assertions.assertSame(Fraction.ZERO, Fraction.from(0.0));
Assertions.assertSame(Fraction.ZERO, Fraction.from(0.0, 1e-10, 100));
Assertions.assertSame(Fraction.ZERO, Fraction.from(0.0, 100));
@@ -80,7 +80,7 @@ public class FractionTest {
// MATH-179
@Test
- public void testDoubleConstructor() throws Exception {
+ void testDoubleConstructor() throws Exception {
for (final CommonTestCases.DoubleToFractionTestCase testCase : CommonTestCases.doubleConstructorTestCases()) {
assertFraction(
testCase.expectedNumerator,
@@ -101,7 +101,7 @@ public class FractionTest {
// MATH-181
// NUMBERS-147
@Test
- public void testDoubleConstructorWithMaxDenominator() throws Exception {
+ void testDoubleConstructorWithMaxDenominator() throws Exception {
for (final CommonTestCases.DoubleToFractionTestCase testCase : CommonTestCases.doubleMaxDenomConstructorTestCases()) {
assertFraction(
testCase.expectedNumerator,
@@ -120,7 +120,7 @@ public class FractionTest {
}
@Test
- public void testDoubleConstructorThrows() {
+ void testDoubleConstructorThrows() {
final double eps = 1e-5;
final int maxIterations = Integer.MAX_VALUE;
final int maxDenominator = Integer.MAX_VALUE;
@@ -137,7 +137,7 @@ public class FractionTest {
}
@Test
- public void testDoubleConstructorGoldenRatioThrows() {
+ void testDoubleConstructorGoldenRatioThrows() {
// the golden ratio is notoriously a difficult number for continuous fraction
Assertions.assertThrows(ArithmeticException.class,
() -> Fraction.from((1 + Math.sqrt(5)) / 2, 1.0e-12, 25)
@@ -146,7 +146,7 @@ public class FractionTest {
// MATH-1029
@Test
- public void testDoubleConstructorWithMaxDenominatorOverFlow() {
+ void testDoubleConstructorWithMaxDenominatorOverFlow() {
Assertions.assertThrows(ArithmeticException.class,
() -> Fraction.from(1e10, 1000)
);
@@ -156,7 +156,7 @@ public class FractionTest {
}
@Test
- public void testDoubleConstructorOverflow() {
+ void testDoubleConstructorOverflow() {
assertDoubleConstructorOverflow(0.75000000001455192);
assertDoubleConstructorOverflow(1.0e10);
assertDoubleConstructorOverflow(-1.0e10);
@@ -170,7 +170,7 @@ public class FractionTest {
}
@Test
- public void testDoubleConstructorWithEpsilonLimit() throws Exception {
+ void testDoubleConstructorWithEpsilonLimit() throws Exception {
assertFraction(2, 5, Fraction.from(0.4, 1.0e-5, 100));
assertFraction(3, 5, Fraction.from(0.6152, 0.02, 100));
@@ -182,7 +182,7 @@ public class FractionTest {
}
@Test
- public void testCompareTo() {
+ void testCompareTo() {
final Fraction a = Fraction.of(1, 2);
final Fraction b = Fraction.of(1, 3);
final Fraction c = Fraction.of(1, 2);
@@ -224,7 +224,7 @@ public class FractionTest {
}
@Test
- public void testDoubleValue() {
+ void testDoubleValue() {
assertDoubleValue(0.5, 1, 2);
assertDoubleValue(-0.5, -1, 2);
assertDoubleValue(-0.5, 1, -2);
@@ -237,7 +237,7 @@ public class FractionTest {
}
@Test
- public void testFloatValue() {
+ void testFloatValue() {
Assertions.assertEquals(0.5f, Fraction.of(1, 2).floatValue());
Assertions.assertEquals(0.5f, Fraction.of(-1, -2).floatValue());
Assertions.assertEquals(-0.5f, Fraction.of(-1, 2).floatValue());
@@ -254,7 +254,7 @@ public class FractionTest {
}
@Test
- public void testIntValue() {
+ void testIntValue() {
Assertions.assertEquals(0, Fraction.of(1, 2).intValue());
Assertions.assertEquals(0, Fraction.of(-1, -2).intValue());
Assertions.assertEquals(0, Fraction.of(-1, 2).intValue());
@@ -275,7 +275,7 @@ public class FractionTest {
}
@Test
- public void testLongValue() {
+ void testLongValue() {
Assertions.assertEquals(0L, Fraction.of(1, 2).longValue());
Assertions.assertEquals(0L, Fraction.of(-1, -2).longValue());
Assertions.assertEquals(0L, Fraction.of(-1, 2).longValue());
@@ -296,7 +296,7 @@ public class FractionTest {
}
@Test
- public void testAbs() {
+ void testAbs() {
for (final CommonTestCases.UnaryOperatorTestCase testCase : CommonTestCases.absTestCases()) {
final Fraction f = Fraction.of(testCase.operandNumerator, testCase.operandDenominator);
assertFraction(testCase.expectedNumerator, testCase.expectedDenominator, f.abs());
@@ -304,7 +304,7 @@ public class FractionTest {
}
@Test
- public void testReciprocal() {
+ void testReciprocal() {
for (final CommonTestCases.UnaryOperatorTestCase testCase : CommonTestCases.reciprocalTestCases()) {
final Fraction f = Fraction.of(testCase.operandNumerator, testCase.operandDenominator);
assertFraction(testCase.expectedNumerator, testCase.expectedDenominator, f.reciprocal());
@@ -315,7 +315,7 @@ public class FractionTest {
}
@Test
- public void testNegate() {
+ void testNegate() {
for (final CommonTestCases.UnaryOperatorTestCase testCase : CommonTestCases.negateTestCases()) {
final Fraction f = Fraction.of(testCase.operandNumerator, testCase.operandDenominator);
assertFraction(testCase.expectedNumerator, testCase.expectedDenominator, f.negate());
@@ -330,7 +330,7 @@ public class FractionTest {
}
@Test
- public void testAdd() {
+ void testAdd() {
for (final CommonTestCases.BinaryOperatorTestCase testCase : CommonTestCases.addFractionTestCases()) {
final Fraction f1 = Fraction.of(testCase.firstOperandNumerator, testCase.firstOperandDenominator);
final Fraction f2 = Fraction.of(testCase.secondOperandNumerator, testCase.secondOperandDenominator);
@@ -361,7 +361,7 @@ public class FractionTest {
}
@Test
- public void testDivide() {
+ void testDivide() {
for (final CommonTestCases.BinaryOperatorTestCase testCase : CommonTestCases.divideByFractionTestCases()) {
final Fraction f1 = Fraction.of(testCase.firstOperandNumerator, testCase.firstOperandDenominator);
final Fraction f2 = Fraction.of(testCase.secondOperandNumerator, testCase.secondOperandDenominator);
@@ -390,7 +390,7 @@ public class FractionTest {
}
@Test
- public void testMultiply() {
+ void testMultiply() {
for (final CommonTestCases.BinaryOperatorTestCase testCase : CommonTestCases.multiplyByFractionTestCases()) {
final Fraction f1 = Fraction.of(testCase.firstOperandNumerator, testCase.firstOperandDenominator);
final Fraction f2 = Fraction.of(testCase.secondOperandNumerator, testCase.secondOperandDenominator);
@@ -416,7 +416,7 @@ public class FractionTest {
}
@Test
- public void testPow() {
+ void testPow() {
for (final CommonTestCases.BinaryIntOperatorTestCase testCase : CommonTestCases.powTestCases()) {
final Fraction f1 = Fraction.of(testCase.firstOperandNumerator, testCase.firstOperandDenominator);
final int exponent = testCase.secondOperand;
@@ -430,7 +430,7 @@ public class FractionTest {
}
@Test
- public void testSubtract() {
+ void testSubtract() {
for (final CommonTestCases.BinaryOperatorTestCase testCase : CommonTestCases.subtractFractionTestCases()) {
final Fraction f1 = Fraction.of(testCase.firstOperandNumerator, testCase.firstOperandDenominator);
final Fraction f2 = Fraction.of(testCase.secondOperandNumerator, testCase.secondOperandDenominator);
@@ -461,7 +461,7 @@ public class FractionTest {
}
@Test
- public void testEqualsAndHashCode() {
+ void testEqualsAndHashCode() {
final Fraction zero = Fraction.of(0, 1);
Assertions.assertEquals(zero, zero);
Assertions.assertNotEquals(zero, null);
@@ -534,17 +534,17 @@ public class FractionTest {
}
@Test
- public void testAdditiveNeutral() {
+ void testAdditiveNeutral() {
Assertions.assertEquals(Fraction.ZERO, Fraction.ONE.zero());
}
@Test
- public void testMultiplicativeNeutral() {
+ void testMultiplicativeNeutral() {
Assertions.assertEquals(Fraction.ONE, Fraction.ZERO.one());
}
@Test
- public void testSerial() {
+ void testSerial() {
final Fraction[] fractions = {
Fraction.of(3, 4), Fraction.ONE, Fraction.ZERO,
Fraction.of(17), Fraction.from(Math.PI, 1000),
@@ -557,7 +557,7 @@ public class FractionTest {
}
@Test
- public void testToString() {
+ void testToString() {
Assertions.assertEquals("0", Fraction.of(0, 3).toString());
Assertions.assertEquals("0", Fraction.of(0, -3).toString());
Assertions.assertEquals("3", Fraction.of(6, 2).toString());
@@ -567,7 +567,7 @@ public class FractionTest {
}
@Test
- public void testParse() {
+ void testParse() {
final String[] validExpressions = new String[] {
"1 / 2",
"-1 / 2",
@@ -614,7 +614,7 @@ public class FractionTest {
}
@Test
- public void testMath1261() {
+ void testMath1261() {
final Fraction a = Fraction.of(Integer.MAX_VALUE, 2);
assertFraction(Integer.MAX_VALUE, 1, a.multiply(2));
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/DigammaTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/DigammaTest.java
index 02d285f..b8431a6 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/DigammaTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/DigammaTest.java
@@ -24,7 +24,7 @@ import org.junit.jupiter.api.Test;
*/
public class DigammaTest {
@Test
- public void testDigammaLargeArgs() {
+ void testDigammaLargeArgs() {
double eps = 1e-8;
Assertions.assertEquals(4.6001618527380874002, Digamma.value(100), eps);
Assertions.assertEquals(3.9019896734278921970, Digamma.value(50), eps);
@@ -41,7 +41,7 @@ public class DigammaTest {
}
@Test
- public void testDigammaSmallArgs() {
+ void testDigammaSmallArgs() {
// values for negative powers of 10 from 1 to 30 as computed by webMathematica with 20 digits.
// For example, to compute trigamma($i) = Polygamma(1, $i), use
//
@@ -58,7 +58,7 @@ public class DigammaTest {
}
@Test
- public void testDigammaZero() {
+ void testDigammaZero() {
// webMathematica states Complexinfinity.
// The value computed is Double.NEGATIVE_INFINITY but we leave this as a test for infinity
// since the next value down -Double.MIN_VALUE is Double.POSITIVE_INFINITY indicating
@@ -67,7 +67,7 @@ public class DigammaTest {
}
@Test
- public void testDigammaNonRealArgs() {
+ void testDigammaNonRealArgs() {
Assertions.assertTrue(Double.isNaN(Digamma.value(Double.NaN)));
Assertions.assertTrue(Double.isInfinite(Digamma.value(Double.POSITIVE_INFINITY)));
Assertions.assertTrue(Double.isInfinite(Digamma.value(Double.NEGATIVE_INFINITY)));
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfDifferenceTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfDifferenceTest.java
index da9bf8a..881563c 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfDifferenceTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfDifferenceTest.java
@@ -28,7 +28,7 @@ public class ErfDifferenceTest {
* with results obtained from Erf.value(double) and Erfc.value(double).
*/
@Test
- public void testTwoArgumentErf() {
+ void testTwoArgumentErf() {
final double[] xi = new double[] {-2, -1, -0.9, -0.1, 0, 0.1, 0.9, 1, 2};
for (double x1 : xi) {
for (double x2 : xi) {
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfTest.java
index c1a021d..f9b3f62 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfTest.java
@@ -24,7 +24,7 @@ import org.junit.jupiter.api.Test;
*/
public class ErfTest {
@Test
- public void testErf0() {
+ void testErf0() {
double actual = Erf.value(0);
double expected = 0;
Assertions.assertEquals(expected, actual, 1e-15);
@@ -32,7 +32,7 @@ public class ErfTest {
}
@Test
- public void testErf1960() {
+ void testErf1960() {
double x = 1.960 / Math.sqrt(2);
double actual = Erf.value(x);
double expected = 0.95;
@@ -46,7 +46,7 @@ public class ErfTest {
}
@Test
- public void testErf2576() {
+ void testErf2576() {
double x = 2.576 / Math.sqrt(2);
double actual = Erf.value(x);
double expected = 0.99;
@@ -60,7 +60,7 @@ public class ErfTest {
}
@Test
- public void testErf2807() {
+ void testErf2807() {
double x = 2.807 / Math.sqrt(2);
double actual = Erf.value(x);
double expected = 0.995;
@@ -74,7 +74,7 @@ public class ErfTest {
}
@Test
- public void testErf3291() {
+ void testErf3291() {
double x = 3.291 / Math.sqrt(2);
double actual = Erf.value(x);
double expected = 0.999;
@@ -91,7 +91,7 @@ public class ErfTest {
* MATH-301, MATH-456
*/
@Test
- public void testLargeValues() {
+ void testLargeValues() {
for (int i = 1; i < 200; i *= 10) {
double result = Erf.value(i);
Assertions.assertFalse(Double.isNaN(result));
@@ -117,7 +117,7 @@ public class ErfTest {
* (Apple OSX packaged version) erfl (extended precision erf).
*/
@Test
- public void testErfGnu() {
+ void testErfGnu() {
final double tol = 1E-15;
final double[] gnuValues = new double[] {
-1, -1, -1, -1, -1,
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfcTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfcTest.java
index 1257152..99f2845 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfcTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/ErfcTest.java
@@ -28,7 +28,7 @@ public class ErfcTest {
* (Apple OSX packaged version) erfcl (extended precision erfc).
*/
@Test
- public void testErfcGnu() {
+ void testErfcGnu() {
final double tol = 1e-15;
final double[] gnuValues = new double[] {
2, 2, 2, 2, 2,
@@ -56,7 +56,7 @@ public class ErfcTest {
* http//www.jstatsoft.org/v11/a05/paper
*/
@Test
- public void testErfcMaple() {
+ void testErfcMaple() {
double[][] ref = new double[][] {
{0.1, 4.60172162722971e-01},
{1.2, 1.15069670221708e-01},
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/GammaTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/GammaTest.java
index f14606b..1c19785 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/GammaTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/GammaTest.java
@@ -507,7 +507,7 @@ public class GammaTest {
};
@Test
- public void testGamma() {
+ void testGamma() {
for (int i = 0; i < GAMMA_REF.length; i++) {
final double[] ref = GAMMA_REF[i];
final double x = ref[0];
@@ -532,14 +532,14 @@ public class GammaTest {
}
@Test
- public void testGammaNegativeInteger() {
+ void testGammaNegativeInteger() {
for (int i = -100; i <= 0; i++) {
Assertions.assertTrue(Double.isNaN(Gamma.value(i)), Integer.toString(i));
}
}
@Test
- public void testGammaNegativeDouble() {
+ void testGammaNegativeDouble() {
// check that the gamma function properly switches sign
// see: https://en.wikipedia.org/wiki/Gamma_function
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InvGamma1pm1Test.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InvGamma1pm1Test.java
index d99b316..07f8087 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InvGamma1pm1Test.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InvGamma1pm1Test.java
@@ -65,7 +65,7 @@ public class InvGamma1pm1Test {
};
@Test
- public void testInvGamma1pm1() {
+ void testInvGamma1pm1() {
final int ulps = 3;
for (int i = 0; i < INV_GAMMA1P_M1_REF.length; i++) {
final double[] ref = INV_GAMMA1P_M1_REF[i];
@@ -78,14 +78,14 @@ public class InvGamma1pm1Test {
}
@Test
- public void testInvGamma1pm1Precondition1() {
+ void testInvGamma1pm1Precondition1() {
Assertions.assertThrows(GammaException.class,
() -> InvGamma1pm1.value(-0.51)
);
}
@Test
- public void testInvGamma1pm1Precondition2() {
+ void testInvGamma1pm1Precondition2() {
Assertions.assertThrows(GammaException.class,
() -> InvGamma1pm1.value(1.51)
);
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InverseErfTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InverseErfTest.java
index af2295d..f19837e 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InverseErfTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InverseErfTest.java
@@ -24,14 +24,14 @@ import org.junit.jupiter.api.Test;
*/
public class InverseErfTest {
@Test
- public void testErfInvNaN() {
+ void testErfInvNaN() {
Assertions.assertTrue(Double.isNaN(InverseErf.value(-1.001)));
Assertions.assertTrue(Double.isNaN(InverseErf.value(+1.001)));
Assertions.assertTrue(Double.isNaN(InverseErf.value(Double.NaN)));
}
@Test
- public void testErfInvInfinite() {
+ void testErfInvInfinite() {
Assertions.assertTrue(Double.isInfinite(InverseErf.value(-1)));
Assertions.assertTrue(InverseErf.value(-1) < 0);
Assertions.assertTrue(Double.isInfinite(InverseErf.value(+1)));
@@ -39,7 +39,7 @@ public class InverseErfTest {
}
@Test
- public void testErfInv() {
+ void testErfInv() {
for (double x = -5.9; x < 5.9; x += 0.01) {
final double y = Erf.value(x);
final double dydx = 2 * Math.exp(-x * x) / Math.sqrt(Math.PI);
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InverseErfcTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InverseErfcTest.java
index a902927..dd9d015 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InverseErfcTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/InverseErfcTest.java
@@ -24,13 +24,13 @@ import org.junit.jupiter.api.Test;
*/
public class InverseErfcTest {
@Test
- public void testErfcInvNaN() {
+ void testErfcInvNaN() {
Assertions.assertTrue(Double.isNaN(InverseErfc.value(-0.001)));
Assertions.assertTrue(Double.isNaN(InverseErfc.value(+2.001)));
}
@Test
- public void testErfcInvInfinite() {
+ void testErfcInvInfinite() {
Assertions.assertTrue(Double.isInfinite(InverseErfc.value(-0)));
Assertions.assertTrue(InverseErfc.value(0) > 0);
Assertions.assertTrue(Double.isInfinite(InverseErfc.value(+2)));
@@ -38,7 +38,7 @@ public class InverseErfcTest {
}
@Test
- public void testErfcInv() {
+ void testErfcInv() {
for (double x = -5.85; x < 5.9; x += 0.01) {
final double y = Erfc.value(x);
final double dydxAbs = 2 * Math.exp(-x * x) / Math.sqrt(Math.PI);
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LanczosApproximationTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LanczosApproximationTest.java
index b9680fe..d562909 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LanczosApproximationTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LanczosApproximationTest.java
@@ -24,12 +24,12 @@ import org.junit.jupiter.api.Test;
*/
public class LanczosApproximationTest {
@Test
- public void testG() {
+ void testG() {
Assertions.assertEquals(607d / 128d, LanczosApproximation.g(), 0d);
}
@Test
- public void testSomeValues() {
+ void testSomeValues() {
// Given that few values are checked, this test would only serve
// as early warning of unexpected changes to the current code.
Assertions.assertEquals(29.020294557631818d, LanczosApproximation.value(0.1d), 0d);
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogBetaTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogBetaTest.java
index aebaeab..9e6a68b 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogBetaTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogBetaTest.java
@@ -534,7 +534,7 @@ public class LogBetaTest {
};
@Test
- public void testLogBeta() {
+ void testLogBeta() {
final int ulps = 3;
for (int i = 0; i < LOG_BETA_REF.length; i++) {
final double[] ref = LOG_BETA_REF[i];
@@ -550,37 +550,37 @@ public class LogBetaTest {
}
@Test
- public void testLogBetaNanPositive() {
+ void testLogBetaNanPositive() {
testLogBeta(Double.NaN, Double.NaN, 2);
}
@Test
- public void testLogBetaPositiveNan() {
+ void testLogBetaPositiveNan() {
testLogBeta(Double.NaN, 1, Double.NaN);
}
@Test
- public void testLogBetaNegativePositive() {
+ void testLogBetaNegativePositive() {
testLogBeta(Double.NaN, -1, 2);
}
@Test
- public void testLogBetaPositiveNegative() {
+ void testLogBetaPositiveNegative() {
testLogBeta(Double.NaN, 1, -2);
}
@Test
- public void testLogBetaZeroPositive() {
+ void testLogBetaZeroPositive() {
testLogBeta(Double.NaN, 0, 2);
}
@Test
- public void testLogBetaPositiveZero() {
+ void testLogBetaPositiveZero() {
testLogBeta(Double.NaN, 1, 0);
}
@Test
- public void testLogBetaPositivePositive() {
+ void testLogBetaPositivePositive() {
testLogBeta(-0.693147180559945, 1, 2);
}
@@ -616,7 +616,7 @@ public class LogBetaTest {
}
@Test
- public void testLogGammaMinusLogGammaSum() {
+ void testLogGammaMinusLogGammaSum() {
final int ulps = 4;
for (int i = 0; i < LOG_GAMMA_MINUS_LOG_GAMMA_SUM_REF.length; i++) {
final double[] ref = LOG_GAMMA_MINUS_LOG_GAMMA_SUM_REF[i];
@@ -632,14 +632,14 @@ public class LogBetaTest {
}
@Test
- public void testLogGammaMinusLogGammaSumPrecondition1() {
+ void testLogGammaMinusLogGammaSumPrecondition1() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> logGammaMinusLogGammaSum(-1, 8)
);
}
@Test
- public void testLogGammaMinusLogGammaSumPrecondition2() {
+ void testLogGammaMinusLogGammaSumPrecondition2() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> logGammaMinusLogGammaSum(1, 7)
);
@@ -671,7 +671,7 @@ public class LogBetaTest {
}
@Test
- public void testSumDeltaMinusDeltaSum() {
+ void testSumDeltaMinusDeltaSum() {
final int ulps = 3;
for (int i = 0; i < SUM_DELTA_MINUS_DELTA_SUM_REF.length; i++) {
final double[] ref = SUM_DELTA_MINUS_DELTA_SUM_REF[i];
@@ -687,14 +687,14 @@ public class LogBetaTest {
}
@Test
- public void testSumDeltaMinusDeltaSumPrecondition1() {
+ void testSumDeltaMinusDeltaSumPrecondition1() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> sumDeltaMinusDeltaSum(9, 10)
);
}
@Test
- public void testSumDeltaMinusDeltaSumPrecondition2() {
+ void testSumDeltaMinusDeltaSumPrecondition2() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> sumDeltaMinusDeltaSum(10, 9)
);
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGamma1pTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGamma1pTest.java
index 33ac6ad..c1ea8f6 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGamma1pTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGamma1pTest.java
@@ -44,7 +44,7 @@ public class LogGamma1pTest {
};
@Test
- public void testLogGamma1p() {
+ void testLogGamma1p() {
final int ulps = 3;
for (int i = 0; i < LOG_GAMMA1P_REF.length; i++) {
final double[] ref = LOG_GAMMA1P_REF[i];
@@ -57,14 +57,14 @@ public class LogGamma1pTest {
}
@Test
- public void testLogGamma1pPrecondition1() {
+ void testLogGamma1pPrecondition1() {
Assertions.assertThrows(GammaException.class,
() -> LogGamma1p.value(-0.51)
);
}
@Test
- public void testLogGamma1pPrecondition2() {
+ void testLogGamma1pPrecondition2() {
Assertions.assertThrows(GammaException.class,
() -> LogGamma1p.value(1.51)
);
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGammaSumTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGammaSumTest.java
index 9bba2b0..a54b6cc 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGammaSumTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGammaSumTest.java
@@ -129,7 +129,7 @@ public class LogGammaSumTest {
};
@Test
- public void testLogGammaSum() {
+ void testLogGammaSum() {
final int ulps = 2;
for (int i = 0; i < LOG_GAMMA_SUM_REF.length; i++) {
final double[] ref = LOG_GAMMA_SUM_REF[i];
@@ -145,28 +145,28 @@ public class LogGammaSumTest {
}
@Test
- public void testLogGammaSumPrecondition1() {
+ void testLogGammaSumPrecondition1() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> LogGammaSum.value(0, 1)
);
}
@Test
- public void testLogGammaSumPrecondition2() {
+ void testLogGammaSumPrecondition2() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> LogGammaSum.value(3, 1)
);
}
@Test
- public void testLogGammaSumPrecondition3() {
+ void testLogGammaSumPrecondition3() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> LogGammaSum.value(1, 0)
);
}
@Test
- public void testLogGammaSumPrecondition4() {
+ void testLogGammaSumPrecondition4() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> LogGammaSum.value(1, 3)
);
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGammaTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGammaTest.java
index 698d8e8..4cbc033 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGammaTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/LogGammaTest.java
@@ -176,27 +176,27 @@ public class LogGammaTest {
};
@Test
- public void testLogGammaNan() {
+ void testLogGammaNan() {
testLogGamma(Double.NaN, Double.NaN);
}
@Test
- public void testLogGammaNegative() {
+ void testLogGammaNegative() {
testLogGamma(Double.NaN, -1.0);
}
@Test
- public void testLogGammaZero() {
+ void testLogGammaZero() {
testLogGamma(Double.NaN, 0.0);
}
@Test
- public void testLogGammaPositive() {
+ void testLogGammaPositive() {
testLogGamma(0.6931471805599457, 3.0);
}
@Test
- public void testLogGamma() {
+ void testLogGamma() {
final int ulps = 3;
for (int i = 0; i < LOG_GAMMA_REF.length; i++) {
final double[] data = LOG_GAMMA_REF[i];
@@ -214,12 +214,12 @@ public class LogGammaTest {
}
@Test
- public void testLogGammaPrecondition1() {
+ void testLogGammaPrecondition1() {
Assertions.assertTrue(Double.isNaN(LogGamma.value(0.0)));
}
@Test
- public void testLogGammaPrecondition2() {
+ void testLogGammaPrecondition2() {
Assertions.assertTrue(Double.isNaN(LogGamma.value(-1.0)));
}
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/RegularizedBetaTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/RegularizedBetaTest.java
index 7fdeaed..32f0e03 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/RegularizedBetaTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/RegularizedBetaTest.java
@@ -24,70 +24,70 @@ import org.junit.jupiter.api.Test;
*/
public class RegularizedBetaTest {
@Test
- public void testRegularizedBetaNanPositivePositive() {
+ void testRegularizedBetaNanPositivePositive() {
testRegularizedBeta(Double.NaN, Double.NaN, 1.0, 1.0);
}
@Test
- public void testRegularizedBetaPositiveNanPositive() {
+ void testRegularizedBetaPositiveNanPositive() {
testRegularizedBeta(Double.NaN, 0.5, Double.NaN, 1.0);
}
@Test
- public void testRegularizedBetaPositivePositiveNan() {
+ void testRegularizedBetaPositivePositiveNan() {
testRegularizedBeta(Double.NaN, 0.5, 1.0, Double.NaN);
}
@Test
- public void testRegularizedBetaNegativePositivePositive() {
+ void testRegularizedBetaNegativePositivePositive() {
testRegularizedBeta(Double.NaN, -0.5, 1.0, 2.0);
}
@Test
- public void testRegularizedBetaPositiveNegativePositive() {
+ void testRegularizedBetaPositiveNegativePositive() {
testRegularizedBeta(Double.NaN, 0.5, -1.0, 2.0);
}
@Test
- public void testRegularizedBetaPositivePositiveNegative() {
+ void testRegularizedBetaPositivePositiveNegative() {
testRegularizedBeta(Double.NaN, 0.5, 1.0, -2.0);
}
@Test
- public void testRegularizedBetaZeroPositivePositive() {
+ void testRegularizedBetaZeroPositivePositive() {
testRegularizedBeta(0.0, 0.0, 1.0, 2.0);
}
@Test
- public void testRegularizedBetaPositiveZeroPositive() {
+ void testRegularizedBetaPositiveZeroPositive() {
testRegularizedBeta(Double.NaN, 0.5, 0.0, 2.0);
}
@Test
- public void testRegularizedBetaPositivePositiveZero() {
+ void testRegularizedBetaPositivePositiveZero() {
testRegularizedBeta(Double.NaN, 0.5, 1.0, 0.0);
}
@Test
- public void testRegularizedBetaAboveOnePositivePositive() {
+ void testRegularizedBetaAboveOnePositivePositive() {
testRegularizedBeta(Double.NaN, 1.5, 1.0, 2.0);
}
@Test
- public void testRegularizedBetaPositivePositivePositive() {
+ void testRegularizedBetaPositivePositivePositive() {
testRegularizedBeta(0.75, 0.5, 1.0, 2.0);
}
@Test
- public void testRegularizedBetaTinyArgument() {
+ void testRegularizedBetaTinyArgument() {
double actual = RegularizedBeta.value(1e-17, 1.0, 1e12);
// This value is from R: pbeta(1e-17,1,1e12)
Assertions.assertEquals(9.999950000166648e-6, actual, 1e-16);
}
@Test
- public void testMath1067() {
+ void testMath1067() {
final double x = 0.22580645161290325;
final double a = 64.33333333333334;
final double b = 223;
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/RegularizedGammaTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/RegularizedGammaTest.java
index ca8e895..5557e50 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/RegularizedGammaTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/RegularizedGammaTest.java
@@ -24,42 +24,42 @@ import org.junit.jupiter.api.Test;
*/
public class RegularizedGammaTest {
@Test
- public void testRegularizedGammaNanPositive() {
+ void testRegularizedGammaNanPositive() {
testRegularizedGamma(Double.NaN, Double.NaN, 1.0);
}
@Test
- public void testRegularizedGammaPositiveNan() {
+ void testRegularizedGammaPositiveNan() {
testRegularizedGamma(Double.NaN, 1.0, Double.NaN);
}
@Test
- public void testRegularizedGammaNegativePositive() {
+ void testRegularizedGammaNegativePositive() {
testRegularizedGamma(Double.NaN, -1.5, 1.0);
}
@Test
- public void testRegularizedGammaPositiveNegative() {
+ void testRegularizedGammaPositiveNegative() {
testRegularizedGamma(Double.NaN, 1.0, -1.0);
}
@Test
- public void testRegularizedGammaZeroPositive() {
+ void testRegularizedGammaZeroPositive() {
testRegularizedGamma(Double.NaN, 0.0, 1.0);
}
@Test
- public void testRegularizedGammaPositiveZero() {
+ void testRegularizedGammaPositiveZero() {
testRegularizedGamma(0.0, 1.0, 0.0);
}
@Test
- public void testRegularizedGammaPositivePositive() {
+ void testRegularizedGammaPositivePositive() {
testRegularizedGamma(0.632120558828558, 1.0, 1.0);
}
@Test
- public void testRegularizedGammaPWithACloseToZero() {
+ void testRegularizedGammaPWithACloseToZero() {
// Creates a case where the regularized gamma P series is evaluated and the
// result is outside the expected bounds of [0, 1]. This should be clipped to 1.0.
final double a = 1e-18;
@@ -69,7 +69,7 @@ public class RegularizedGammaTest {
}
@Test
- public void testRegularizedGammaPWithAVeryCloseToZero() {
+ void testRegularizedGammaPWithAVeryCloseToZero() {
// Creates a case where the partial sum is infinite due to inclusion of 1 / a
final double a = Double.MIN_VALUE;
// x must force use of the series in regularized gamma P using x < a + 1
@@ -85,7 +85,7 @@ public class RegularizedGammaTest {
}
@Test
- public void testRegularizedGammaMaxIterationsExceededThrows() {
+ void testRegularizedGammaMaxIterationsExceededThrows() {
final double a = 1.0;
final double x = 1.0;
// OK without
diff --git a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/TrigammaTest.java b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/TrigammaTest.java
index 1a8012f..a865c92 100644
--- a/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/TrigammaTest.java
+++ b/commons-numbers-gamma/src/test/java/org/apache/commons/numbers/gamma/TrigammaTest.java
@@ -24,7 +24,7 @@ import org.junit.jupiter.api.Test;
*/
public class TrigammaTest {
@Test
- public void testTrigamma() {
+ void testTrigamma() {
double eps = 1e-8;
// computed using webMathematica. For example, to compute trigamma($i) = Polygamma(1, $i), use
//
@@ -62,7 +62,7 @@ public class TrigammaTest {
}
@Test
- public void testTrigammaNonRealArgs() {
+ void testTrigammaNonRealArgs() {
Assertions.assertTrue(Double.isNaN(Trigamma.value(Double.NaN)));
Assertions.assertTrue(Double.isInfinite(Trigamma.value(Double.POSITIVE_INFINITY)));
Assertions.assertTrue(Double.isInfinite(Trigamma.value(Double.NEGATIVE_INFINITY)));
diff --git a/commons-numbers-primes/src/test/java/org/apache/commons/numbers/primes/PrimesTest.java b/commons-numbers-primes/src/test/java/org/apache/commons/numbers/primes/PrimesTest.java
index 9667a16..e7242c8 100644
--- a/commons-numbers-primes/src/test/java/org/apache/commons/numbers/primes/PrimesTest.java
+++ b/commons-numbers-primes/src/test/java/org/apache/commons/numbers/primes/PrimesTest.java
@@ -85,7 +85,7 @@ public class PrimesTest {
}
@Test
- public void testNextPrime() {
+ void testNextPrime() {
Assertions.assertEquals(2, Primes.nextPrime(0));
Assertions.assertEquals(2, Primes.nextPrime(1));
@@ -115,7 +115,7 @@ public class PrimesTest {
}
@Test
- public void testIsPrime() throws Exception {
+ void testIsPrime() throws Exception {
for (int i : BELOW_2) {
Assertions.assertFalse(Primes.isPrime(i));
}
@@ -152,7 +152,7 @@ public class PrimesTest {
}
@Test
- public void testPrimeFactors() throws Exception {
+ void testPrimeFactors() throws Exception {
for (int i : BELOW_2) {
assertPrimeFactorsException(i, MessageFormat.format(Primes.NUMBER_TOO_SMALL, i, 2));
}
diff --git a/commons-numbers-primes/src/test/java/org/apache/commons/numbers/primes/SmallPrimesTest.java b/commons-numbers-primes/src/test/java/org/apache/commons/numbers/primes/SmallPrimesTest.java
index 4305109..4f3dd5f 100644
--- a/commons-numbers-primes/src/test/java/org/apache/commons/numbers/primes/SmallPrimesTest.java
+++ b/commons-numbers-primes/src/test/java/org/apache/commons/numbers/primes/SmallPrimesTest.java
@@ -30,7 +30,7 @@ public class SmallPrimesTest {
private static final int[] LARGE_PRIME = {3673, 3677};
@Test
- public void smallTrialDivision_smallComposite() {
+ void smallTrialDivision_smallComposite() {
final List<Integer> factors = new ArrayList<Integer>();
final int result = SmallPrimes.smallTrialDivision(3 * 7 * 23, factors);
Assertions.assertEquals(1, result);
@@ -38,7 +38,7 @@ public class SmallPrimesTest {
}
@Test
- public void smallTrialDivision_repeatedFactors() {
+ void smallTrialDivision_repeatedFactors() {
final List<Integer> factors = new ArrayList<Integer>();
final int result = SmallPrimes.smallTrialDivision(2 * 2 * 3 * 3 * 3, factors);
Assertions.assertEquals(1, result);
@@ -46,7 +46,7 @@ public class SmallPrimesTest {
}
@Test
- public void smallTrialDivision_oneFactor() {
+ void smallTrialDivision_oneFactor() {
final List<Integer> factors = new ArrayList<Integer>();
final int result = SmallPrimes.smallTrialDivision(59, factors);
Assertions.assertEquals(1, result);
@@ -54,7 +54,7 @@ public class SmallPrimesTest {
}
@Test
- public void smallTrialDivision_BoundaryPrimes() {
+ void smallTrialDivision_BoundaryPrimes() {
final List<Integer> factors = new ArrayList<Integer>();
final int penultimatePrime = SmallPrimes.PRIMES[SmallPrimes.PRIMES.length - 2];
final int result = SmallPrimes.smallTrialDivision(penultimatePrime * SmallPrimes.PRIMES_LAST, factors);
@@ -63,7 +63,7 @@ public class SmallPrimesTest {
}
@Test
- public void smallTrialDivision_largeComposite() {
+ void smallTrialDivision_largeComposite() {
final List<Integer> factors = new ArrayList<Integer>();
final int result = SmallPrimes.smallTrialDivision(2 * 5 * LARGE_PRIME[0], factors);
Assertions.assertEquals(LARGE_PRIME[0], result);
@@ -71,7 +71,7 @@ public class SmallPrimesTest {
}
@Test
- public void smallTrialDivision_noSmallPrimeFactors() {
+ void smallTrialDivision_noSmallPrimeFactors() {
final List<Integer> factors = new ArrayList<Integer>();
final int result = SmallPrimes.smallTrialDivision(LARGE_PRIME[0] * LARGE_PRIME[1], factors);
Assertions.assertEquals(LARGE_PRIME[0] * LARGE_PRIME[1], result);
@@ -79,7 +79,7 @@ public class SmallPrimesTest {
}
@Test
- public void boundedTrialDivision_twoDifferentFactors() {
+ void boundedTrialDivision_twoDifferentFactors() {
final List<Integer> factors = new ArrayList<Integer>();
final int result = SmallPrimes.boundedTrialDivision(LARGE_PRIME[0] * LARGE_PRIME[1], Integer.MAX_VALUE,
factors);
@@ -88,7 +88,7 @@ public class SmallPrimesTest {
}
@Test
- public void boundedTrialDivision_square() {
+ void boundedTrialDivision_square() {
final List<Integer> factors = new ArrayList<Integer>();
final int result = SmallPrimes.boundedTrialDivision(LARGE_PRIME[0] * LARGE_PRIME[0], Integer.MAX_VALUE,
factors);
@@ -97,37 +97,37 @@ public class SmallPrimesTest {
}
@Test
- public void trialDivision_smallComposite() {
+ void trialDivision_smallComposite() {
final List<Integer> factors = SmallPrimes.trialDivision(5 * 11 * 29 * 103);
Assertions.assertEquals(Arrays.asList(5, 11, 29, 103), factors);
}
@Test
- public void trialDivision_repeatedFactors() {
+ void trialDivision_repeatedFactors() {
final List<Integer> factors = SmallPrimes.trialDivision(2 * 2 * 2 * 2 * 5 * 5);
Assertions.assertEquals(Arrays.asList(2, 2, 2, 2, 5, 5), factors);
}
@Test
- public void trialDivision_oneSmallFactor() {
+ void trialDivision_oneSmallFactor() {
final List<Integer> factors = SmallPrimes.trialDivision(101);
Assertions.assertEquals(Collections.singletonList(101), factors);
}
@Test
- public void trialDivision_largeComposite() {
+ void trialDivision_largeComposite() {
final List<Integer> factors = SmallPrimes.trialDivision(2 * 3 * LARGE_PRIME[0]);
Assertions.assertEquals(Arrays.asList(2, 3, LARGE_PRIME[0]), factors);
}
@Test
- public void trialDivision_veryLargeComposite() {
+ void trialDivision_veryLargeComposite() {
final List<Integer> factors = SmallPrimes.trialDivision(2 * LARGE_PRIME[0] * LARGE_PRIME[1]);
Assertions.assertEquals(Arrays.asList(2, LARGE_PRIME[0], LARGE_PRIME[1]), factors);
}
@Test
- public void millerRabinPrimeTest_primes() {
+ void millerRabinPrimeTest_primes() {
for (final int n : PrimesTest.PRIMES) {
if (n % 2 == 1) {
Assertions.assertTrue(SmallPrimes.millerRabinPrimeTest(n));
@@ -136,7 +136,7 @@ public class SmallPrimesTest {
}
@Test
- public void millerRabinPrimeTest_composites() {
+ void millerRabinPrimeTest_composites() {
for (final int n : PrimesTest.NOT_PRIMES) {
if (n % 2 == 1) {
Assertions.assertFalse(SmallPrimes.millerRabinPrimeTest(n));
diff --git a/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/QuaternionTest.java b/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/QuaternionTest.java
index aede102..4ea8545 100644
--- a/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/QuaternionTest.java
+++ b/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/QuaternionTest.java
@@ -28,12 +28,12 @@ public class QuaternionTest {
private static final double COMPARISON_EPS = 1e-14;
@Test
- public void testZeroQuaternion() {
+ void testZeroQuaternion() {
Assertions.assertEquals(0, Quaternion.ZERO.norm(), 0d);
}
@Test
- public void testUnitQuaternions() {
+ void testUnitQuaternions() {
Assertions.assertEquals(1, Quaternion.ONE.norm(), 0d);
Assertions.assertSame(Quaternion.ONE, Quaternion.ONE.normalize());
@@ -48,7 +48,7 @@ public class QuaternionTest {
}
@Test
- public final void testAccessors1() {
+ final void testAccessors1() {
final double q0 = 2;
final double q1 = 5.4;
final double q2 = 17;
@@ -62,7 +62,7 @@ public class QuaternionTest {
}
@Test
- public final void testAccessors2() {
+ final void testAccessors2() {
final double q0 = 2;
final double q1 = 5.4;
final double q2 = 17;
@@ -79,7 +79,7 @@ public class QuaternionTest {
}
@Test
- public final void testAccessors3() {
+ final void testAccessors3() {
final double q0 = 2;
final double q1 = 5.4;
final double q2 = 17;
@@ -96,14 +96,14 @@ public class QuaternionTest {
}
@Test
- public void testWrongDimension() {
+ void testWrongDimension() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> Quaternion.of(new double[] {1, 2})
);
}
@Test
- public final void testConjugate() {
+ final void testConjugate() {
final double q0 = 2;
final double q1 = 5.4;
final double q2 = 17;
@@ -120,7 +120,7 @@ public class QuaternionTest {
/* TODO remove dependency on Vector3D
@Test
- public final void testProductQuaternionQuaternion() {
+ final void testProductQuaternionQuaternion() {
// Case : analytic test case
@@ -165,7 +165,7 @@ public class QuaternionTest {
*/
/* TODO remove dependency on Vector3D
@Test
- public final void testProductQuaternionVector() {
+ final void testProductQuaternionVector() {
// Case : Product between a vector and a quaternion : QxV
@@ -216,7 +216,7 @@ public class QuaternionTest {
}
*/
@Test
- public final void testDotProductQuaternionQuaternion() {
+ final void testDotProductQuaternionQuaternion() {
// expected output
final double expected = -6.;
// inputs
@@ -231,7 +231,7 @@ public class QuaternionTest {
}
@Test
- public final void testScalarMultiplyDouble() {
+ final void testScalarMultiplyDouble() {
// expected outputs
final double w = 1.6;
final double x = -4.8;
@@ -250,7 +250,7 @@ public class QuaternionTest {
}
@Test
- public final void testAddQuaternionQuaternion() {
+ final void testAddQuaternionQuaternion() {
// expected outputs
final double w = 4;
final double x = -1;
@@ -275,7 +275,7 @@ public class QuaternionTest {
}
@Test
- public final void testSubtractQuaternionQuaternion() {
+ final void testSubtractQuaternionQuaternion() {
// expected outputs
final double w = -2.;
final double x = 5.;
@@ -300,7 +300,7 @@ public class QuaternionTest {
}
@Test
- public final void testNorm() {
+ final void testNorm() {
final double q0 = 2;
final double q1 = 1;
@@ -317,7 +317,7 @@ public class QuaternionTest {
}
@Test
- public final void testNormalize() {
+ final void testNormalize() {
final Quaternion q = Quaternion.of(2, 1, -4, -2);
@@ -334,7 +334,7 @@ public class QuaternionTest {
}
@Test
- public final void testNormalizeFail_zero() {
+ final void testNormalizeFail_zero() {
final Quaternion q = Quaternion.of(0, 0, 0, 0);
Assertions.assertThrows(IllegalStateException.class,
q::normalize
@@ -342,7 +342,7 @@ public class QuaternionTest {
}
@Test
- public final void testNormalizeFail_nan() {
+ final void testNormalizeFail_nan() {
final Quaternion q = Quaternion.of(0, 0, 0, Double.NaN);
Assertions.assertThrows(IllegalStateException.class,
q::normalize
@@ -351,7 +351,7 @@ public class QuaternionTest {
}
@Test
- public final void testNormalizeFail_positiveInfinity() {
+ final void testNormalizeFail_positiveInfinity() {
final Quaternion q = Quaternion.of(0, 0, Double.POSITIVE_INFINITY, 0);
Assertions.assertThrows(IllegalStateException.class,
q::normalize
@@ -359,7 +359,7 @@ public class QuaternionTest {
}
@Test
- public final void testNormalizeFail_negativeInfinity() {
+ final void testNormalizeFail_negativeInfinity() {
final Quaternion q = Quaternion.of(0, Double.NEGATIVE_INFINITY, 0, 0);
Assertions.assertThrows(IllegalStateException.class,
q::normalize
@@ -367,7 +367,7 @@ public class QuaternionTest {
}
@Test
- public final void testObjectEquals() {
+ final void testObjectEquals() {
final double one = 1;
final Quaternion q1 = Quaternion.of(one, one, one, one);
Assertions.assertEquals(q1, q1);
@@ -382,7 +382,7 @@ public class QuaternionTest {
}
@Test
- public void testHashCode() {
+ void testHashCode() {
Quaternion x = Quaternion.of(0.0, 0.0, 0.0, 0.0);
Quaternion y = Quaternion.of(0.0, 0.0 + Double.MIN_VALUE, 0.0, 0.0);
Assertions.assertNotEquals(x.hashCode(), y.hashCode());
@@ -415,7 +415,7 @@ public class QuaternionTest {
}
@Test
- public final void testQuaternionEquals() {
+ final void testQuaternionEquals() {
final double inc = 1e-5;
final Quaternion q1 = Quaternion.of(2, 1, -4, -2);
final Quaternion q2 = Quaternion.of(q1.getW() + inc, q1.getX(), q1.getY(), q1.getZ());
@@ -435,7 +435,7 @@ public class QuaternionTest {
}
@Test
- public final void testQuaternionEquals2() {
+ final void testQuaternionEquals2() {
final Quaternion q1 = Quaternion.of(1, 4, 2, 3);
final double gap = 1e-5;
final Quaternion q2 = Quaternion.of(1 + gap, 4 + gap, 2 + gap, 3 + gap);
@@ -446,7 +446,7 @@ public class QuaternionTest {
}
@Test
- public final void testIsUnit() {
+ final void testIsUnit() {
final Random r = new Random(48);
final int numberOfTrials = 1000;
for (int i = 0; i < numberOfTrials; i++) {
@@ -460,7 +460,7 @@ public class QuaternionTest {
}
@Test
- public final void testIsPure() {
+ final void testIsPure() {
final Quaternion q1 = Quaternion.of(0, 5, 4, 8);
Assertions.assertTrue(q1.isPure(EPS));
@@ -480,7 +480,7 @@ public class QuaternionTest {
}
@Test
- public final void testPositivePolarFormWhenScalarPositive() {
+ final void testPositivePolarFormWhenScalarPositive() {
Quaternion q = Quaternion.of(3, -3, -3, 3).positivePolarForm();
Quaternion expected = Quaternion.of(0.5, -0.5, -0.5, 0.5);
assertEquals(q, expected, EPS);
@@ -489,7 +489,7 @@ public class QuaternionTest {
}
@Test
- public final void testPositivePolarFormWhenScalarNegative() {
+ final void testPositivePolarFormWhenScalarNegative() {
Quaternion q = Quaternion.of(-3, 3, -3, 3).positivePolarForm();
Quaternion expected = Quaternion.of(0.5, -0.5, 0.5, -0.5);
assertEquals(q, expected, EPS);
@@ -498,7 +498,7 @@ public class QuaternionTest {
}
@Test
- public final void testPositivePolarFormWhenScalarPositiveAndNormalized() {
+ final void testPositivePolarFormWhenScalarPositiveAndNormalized() {
Quaternion q = Quaternion.of(123, 45, 67, 89).normalize().positivePolarForm();
Assertions.assertTrue(q.getW() >= 0);
@@ -506,7 +506,7 @@ public class QuaternionTest {
}
@Test
- public final void testPositivePolarFormWhenScalarNegativeAndNormalized() {
+ final void testPositivePolarFormWhenScalarNegativeAndNormalized() {
Quaternion q = Quaternion.of(123, 45, 67, 89).normalize().negate().positivePolarForm();
Assertions.assertTrue(q.getW() >= 0);
@@ -514,7 +514,7 @@ public class QuaternionTest {
}
@Test
- public void testNegate() {
+ void testNegate() {
final double a = -1;
final double b = 2;
final double c = -3;
@@ -530,7 +530,7 @@ public class QuaternionTest {
}
@Test
- public void testNegateNormalized() {
+ void testNegateNormalized() {
final double a = -1;
final double b = 2;
final double c = -3;
@@ -541,7 +541,7 @@ public class QuaternionTest {
}
@Test
- public void testNegatePositivePolarForm() {
+ void testNegatePositivePolarForm() {
final double a = -1;
final double b = 2;
final double c = -3;
@@ -553,7 +553,7 @@ public class QuaternionTest {
/* TODO remove dependency on Rotation
@Test
- public final void testPolarForm() {
+ final void testPolarForm() {
final Random r = new Random(48);
final int numberOfTrials = 1000;
for (int i = 0; i < numberOfTrials; i++) {
@@ -581,7 +581,7 @@ public class QuaternionTest {
}
*/
@Test
- public final void testInverse() {
+ final void testInverse() {
final Quaternion q = Quaternion.of(1.5, 4, 2, -2.5);
final Quaternion inverseQ = q.inverse();
@@ -606,7 +606,7 @@ public class QuaternionTest {
}
@Test
- public void testInverse_zeroNorm() {
+ void testInverse_zeroNorm() {
Quaternion q = Quaternion.of(0, 0, 0, 0);
Assertions.assertThrows(IllegalStateException.class,
q::inverse
@@ -614,7 +614,7 @@ public class QuaternionTest {
}
@Test
- public void testInverse_nanNorm() {
+ void testInverse_nanNorm() {
Quaternion q = Quaternion.of(Double.NaN, 0, 0, 0);
Assertions.assertThrows(IllegalStateException.class,
q::inverse
@@ -622,7 +622,7 @@ public class QuaternionTest {
}
@Test
- public void testInverse_positiveInfinityNorm() {
+ void testInverse_positiveInfinityNorm() {
Quaternion q = Quaternion.of(0, Double.POSITIVE_INFINITY, 0, 0);
Assertions.assertThrows(IllegalStateException.class,
q::inverse
@@ -630,7 +630,7 @@ public class QuaternionTest {
}
@Test
- public void testInverse_negativeInfinityNorm() {
+ void testInverse_negativeInfinityNorm() {
Quaternion q = Quaternion.of(0, 0, Double.NEGATIVE_INFINITY, 0);
Assertions.assertThrows(IllegalStateException.class,
q::inverse
@@ -638,7 +638,7 @@ public class QuaternionTest {
}
@Test
- public void testInverseNormalized() {
+ void testInverseNormalized() {
final Quaternion invQ = Quaternion.of(-1.2, 3.4, -5.6, -7.8).normalize().inverse();
final Quaternion q = invQ.inverse();
final Quaternion result = q.multiply(invQ);
@@ -646,7 +646,7 @@ public class QuaternionTest {
}
@Test
- public void testInversePositivePolarForm() {
+ void testInversePositivePolarForm() {
final Quaternion invQ = Quaternion.of(1.2, -3.4, 5.6, -7.8).positivePolarForm().inverse();
final Quaternion q = invQ.inverse();
final Quaternion result = q.multiply(invQ);
@@ -654,7 +654,7 @@ public class QuaternionTest {
}
@Test
- public final void testMultiply() {
+ final void testMultiply() {
final Quaternion q1 = Quaternion.of(1, 2, 3, 4);
final Quaternion q2 = Quaternion.of(4, 3, 2, 1);
final Quaternion actual = q1.multiply(q2);
@@ -667,14 +667,14 @@ public class QuaternionTest {
}
@Test
- public final void testParseFromToString() {
+ final void testParseFromToString() {
final Quaternion q = Quaternion.of(1.1, 2.2, 3.3, 4.4);
Quaternion parsed = Quaternion.parse(q.toString());
assertEquals(parsed, q, EPS);
}
@Test
- public final void testParseSpecials() {
+ final void testParseSpecials() {
Quaternion parsed = Quaternion.parse("[1e-5 Infinity NaN -0xa.cp0]");
Assertions.assertEquals(1e-5, parsed.getW(), EPS);
Assertions.assertTrue(Double.isInfinite(parsed.getX()));
@@ -683,56 +683,56 @@ public class QuaternionTest {
}
@Test
- public final void testParseMissingStart() {
+ final void testParseMissingStart() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> Quaternion.parse("1.0 2.0 3.0 4.0]")
);
}
@Test
- public final void testParseMissingEnd() {
+ final void testParseMissingEnd() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> Quaternion.parse("[1.0 2.0 3.0 4.0")
);
}
@Test
- public final void testParseMissingPart() {
+ final void testParseMissingPart() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> Quaternion.parse("[1.0 2.0 3.0 ]")
);
}
@Test
- public final void testParseInvalidScalar() {
+ final void testParseInvalidScalar() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> Quaternion.parse("[1.x 2.0 3.0 4.0]")
);
}
@Test
- public final void testParseInvalidI() {
+ final void testParseInvalidI() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> Quaternion.parse("[1.0 2.0x 3.0 4.0]")
);
}
@Test
- public final void testParseInvalidJ() {
+ final void testParseInvalidJ() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> Quaternion.parse("[1.0 2.0 3.0x 4.0]")
);
}
@Test
- public final void testParseInvalidK() {
+ final void testParseInvalidK() {
Assertions.assertThrows(IllegalArgumentException.class,
() -> Quaternion.parse("[1.0 2.0 3.0 4.0x]")
);
}
@Test
- public final void testToString() {
+ final void testToString() {
final Quaternion q = Quaternion.of(1, 2, 3, 4);
Assertions.assertEquals("[1.0 2.0 3.0 4.0]", q.toString());
}
diff --git a/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/SlerpTest.java b/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/SlerpTest.java
index 71ebb5e..bcdbcbe 100644
--- a/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/SlerpTest.java
+++ b/commons-numbers-quaternion/src/test/java/org/apache/commons/numbers/quaternion/SlerpTest.java
@@ -29,7 +29,7 @@ public class SlerpTest {
private static final double INV_SQRT_2 = 1.0 / SQRT_2;
@Test
- public void testSlerp_sphericalAlgorithm() {
+ void testSlerp_sphericalAlgorithm() {
// arrange
Quaternion q1 = createZRotation(0.75 * Math.PI);
Quaternion q2 = createZRotation(-0.75 * Math.PI);
@@ -47,7 +47,7 @@ public class SlerpTest {
}
@Test
- public void testSlerp_sphericalAlgorithm_allOutputsAreInPositivePolarForm() {
+ void testSlerp_sphericalAlgorithm_allOutputsAreInPositivePolarForm() {
// arrange
Quaternion q1 = createZRotation(0.75 * Math.PI);
Quaternion q2 = createZRotation(-0.75 * Math.PI);
@@ -69,7 +69,7 @@ public class SlerpTest {
}
@Test
- public void testSlerp_nonNormalizedInputs() {
+ void testSlerp_nonNormalizedInputs() {
// arrange
Quaternion q1 = createZRotation(0).multiply(10.0);
Quaternion q2 = createZRotation(Math.PI).multiply(0.2);
@@ -85,7 +85,7 @@ public class SlerpTest {
}
@Test
- public void testSlerp_linearAlgorithm() {
+ void testSlerp_linearAlgorithm() {
// arrange
Quaternion q1 = createZRotation(0.75 * Math.PI);
Quaternion q2 = createZRotation(0.76 * Math.PI);
@@ -101,7 +101,7 @@ public class SlerpTest {
}
@Test
- public void testSlerp_linearAlgorithm_allOutputsAreInPositivePolarForm() {
+ void testSlerp_linearAlgorithm_allOutputsAreInPositivePolarForm() {
// arrange
Quaternion q1 = createZRotation(0.75 * Math.PI);
Quaternion q2 = createZRotation(0.76 * Math.PI);
@@ -123,7 +123,7 @@ public class SlerpTest {
}
@Test
- public void testSlerp_identicalInputs() {
+ void testSlerp_identicalInputs() {
// arrange
Quaternion q1 = createZRotation(0);
Quaternion q2 = createZRotation(0);
@@ -139,7 +139,7 @@ public class SlerpTest {
}
@Test
- public void testSlerp_inputQuaternionsHaveMinusOneDotProduct() {
+ void testSlerp_inputQuaternionsHaveMinusOneDotProduct() {
// arrange
Quaternion q1 = createZRotation(0.5 * Math.PI);
Quaternion q2 = createZRotation(1.5 * Math.PI).conjugate(); // 3pi/2 around -z
@@ -157,7 +157,7 @@ public class SlerpTest {
}
@Test
- public void testSlerp_tOutsideOfZeroToOne() {
+ void testSlerp_tOutsideOfZeroToOne() {
// arrange
Quaternion q1 = createZRotation(0);
Quaternion q2 = createZRotation(0.25 * Math.PI);
@@ -175,7 +175,7 @@ public class SlerpTest {
}
@Test
- public void testVectorTransform_simple() {
+ void testVectorTransform_simple() {
// arrange
Quaternion q0 = Quaternion.of(1, 0, 0, 0); // rotation of zero
Quaternion q1 = Quaternion.of(0, 0, 0, 1); // pi rotation around +z
@@ -202,7 +202,7 @@ public class SlerpTest {
}
@Test
- public void testVectorTransform_multipleCombinations() {
+ void testVectorTransform_multipleCombinations() {
// arrange
Quaternion[] quaternions = {
// +x axis
@@ -280,7 +280,7 @@ public class SlerpTest {
}
@Test
- public void testVectorTransform_tOutsideOfZeroToOne_() {
+ void testVectorTransform_tOutsideOfZeroToOne_() {
// arrange
double angle1 = Math.PI * 0.25;
double angle2 = Math.PI * 0.75;
diff --git a/commons-numbers-rootfinder/src/test/java/org/apache/commons/numbers/rootfinder/BrentSolverTest.java b/commons-numbers-rootfinder/src/test/java/org/apache/commons/numbers/rootfinder/BrentSolverTest.java
index ab2afb6..aebd765 100644
--- a/commons-numbers-rootfinder/src/test/java/org/apache/commons/numbers/rootfinder/BrentSolverTest.java
+++ b/commons-numbers-rootfinder/src/test/java/org/apache/commons/numbers/rootfinder/BrentSolverTest.java
@@ -30,7 +30,7 @@ public class BrentSolverTest {
private static final double DEFAULT_FUNCTION_ACCURACY = 1e-15;
@Test
- public void testSinZero() {
+ void testSinZero() {
// The sinus function is behaved well around the root at pi. The second
// order derivative is zero, which means linar approximating methods will
// still converge quadratically.
@@ -56,7 +56,7 @@ public class BrentSolverTest {
}
@Test
- public void testQuinticZero() {
+ void testQuinticZero() {
// The quintic function has zeros at 0, +-0.5 and +-1.
// Around the root of 0 the function is well behaved, with a second derivative
// of zero a 0.
@@ -140,7 +140,7 @@ public class BrentSolverTest {
}
@Test
- public void testTooManyCalls() {
+ void testTooManyCalls() {
final DoubleUnaryOperator func = new QuinticFunction();
final BrentSolver solver = new BrentSolver(DEFAULT_ABSOLUTE_ACCURACY,
DEFAULT_RELATIVE_ACCURACY,
@@ -167,7 +167,7 @@ public class BrentSolverTest {
}
@Test
- public void testRootEndpoints() {
+ void testRootEndpoints() {
final DoubleUnaryOperator f = new Sin();
final BrentSolver solver = new BrentSolver(DEFAULT_ABSOLUTE_ACCURACY,
DEFAULT_RELATIVE_ACCURACY,
@@ -188,7 +188,7 @@ public class BrentSolverTest {
}
@Test
- public void testBadEndpoints() {
+ void testBadEndpoints() {
final DoubleUnaryOperator f = new Sin();
final BrentSolver solver = new BrentSolver(DEFAULT_ABSOLUTE_ACCURACY,
DEFAULT_RELATIVE_ACCURACY,
@@ -217,7 +217,7 @@ public class BrentSolverTest {
}
@Test
- public void testBadInitialGuess() {
+ void testBadInitialGuess() {
final DoubleUnaryOperator func = new QuinticFunction();
final BrentSolver solver = new BrentSolver(DEFAULT_ABSOLUTE_ACCURACY,
DEFAULT_RELATIVE_ACCURACY,
@@ -234,7 +234,7 @@ public class BrentSolverTest {
}
@Test
- public void testInitialGuess() {
+ void testInitialGuess() {
final DoubleUnaryOperator func = new QuinticFunction();
final BrentSolver solver = new BrentSolver(DEFAULT_ABSOLUTE_ACCURACY,
DEFAULT_RELATIVE_ACCURACY,