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-statistics.git
commit a01bfa87e8c438453c29ba2a4f3e910668494537 Author: aherbert <aherb...@apache.org> AuthorDate: Wed Jun 24 12:24:51 2020 +0100 Use final --- .../AbstractDiscreteDistributionTest.java | 2 +- .../distribution/BetaDistributionTest.java | 8 ++--- .../distribution/BinomialDistributionTest.java | 10 +++--- .../distribution/CauchyDistributionTest.java | 2 +- .../distribution/ChiSquaredDistributionTest.java | 6 ++-- .../ConstantContinuousDistributionTest.java | 4 +-- .../ContinuousDistributionAbstractTest.java | 10 +++--- .../DiscreteDistributionAbstractTest.java | 16 ++++----- .../distribution/ExponentialDistributionTest.java | 8 ++--- .../statistics/distribution/FDistributionTest.java | 16 ++++----- .../distribution/GammaDistributionTest.java | 24 ++++++------- .../distribution/GumbelDistributionTest.java | 4 +-- .../HypergeometricDistributionTest.java | 42 +++++++++++----------- .../distribution/LaplaceDistributionTest.java | 4 +-- .../distribution/LevyDistributionTest.java | 4 +-- .../distribution/LogNormalDistributionTest.java | 28 +++++++-------- .../distribution/LogisticsDistributionTest.java | 6 ++-- .../distribution/NakagamiDistributionTest.java | 4 +-- .../distribution/NormalDistributionTest.java | 16 ++++----- .../distribution/ParetoDistributionTest.java | 24 ++++++------- .../distribution/PascalDistributionTest.java | 2 +- .../distribution/PoissonDistributionTest.java | 22 ++++++------ .../statistics/distribution/TDistributionTest.java | 18 +++++----- .../commons/statistics/distribution/TestUtils.java | 20 +++++------ .../distribution/TriangularDistributionTest.java | 18 +++++----- .../UniformContinuousDistributionTest.java | 8 ++--- .../UniformDiscreteDistributionTest.java | 6 ++-- .../distribution/WeibullDistributionTest.java | 4 +-- .../distribution/ZipfDistributionTest.java | 24 ++++++------- 29 files changed, 180 insertions(+), 180 deletions(-) diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/AbstractDiscreteDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/AbstractDiscreteDistributionTest.java index d61c483..03c6a6b 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/AbstractDiscreteDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/AbstractDiscreteDistributionTest.java @@ -28,7 +28,7 @@ public class AbstractDiscreteDistributionTest { @Test public void testInverseCumulativeProbabilityMethod() { - double precision = 0.000000000000001; + final double precision = 0.000000000000001; Assertions.assertEquals(1, diceDistribution.inverseCumulativeProbability(0)); Assertions.assertEquals(1, diceDistribution.inverseCumulativeProbability((1d - Double.MIN_VALUE) / 6d)); Assertions.assertEquals(2, diceDistribution.inverseCumulativeProbability((1d + precision) / 6d)); diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/BetaDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/BetaDistributionTest.java index 714ef93..8cbb2fa 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/BetaDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/BetaDistributionTest.java @@ -32,7 +32,7 @@ public class BetaDistributionTest { @Test public void testCumulative() { - double[] x = new double[]{-0.1, 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1}; + final double[] x = new double[]{-0.1, 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1}; // all test data computed using R 2.5 checkCumulative(0.1, 0.1, x, new double[]{ @@ -150,7 +150,7 @@ public class BetaDistributionTest { } private void checkCumulative(double alpha, double beta, double[] x, double[] cumes) { - BetaDistribution d = new BetaDistribution(alpha, beta); + final BetaDistribution d = new BetaDistribution(alpha, beta); for (int i = 0; i < x.length; i++) { Assertions.assertEquals(cumes[i], d.cumulativeProbability(x[i]), 1e-8); } @@ -162,7 +162,7 @@ public class BetaDistributionTest { @Test public void testDensity() { - double[] x = new double[]{1e-6, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9}; + final double[] x = new double[]{1e-6, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9}; checkDensity(0.1, 0.1, x, new double[]{ 12741.2357380649, 0.4429889586665234, 2.639378715e-01, 2.066393611e-01, @@ -292,7 +292,7 @@ public class BetaDistributionTest { @SuppressWarnings("boxing") private void checkDensity(double alpha, double beta, double[] x, double[] expected) { - BetaDistribution d = new BetaDistribution(alpha, beta); + final BetaDistribution d = new BetaDistribution(alpha, beta); for (int i = 0; i < x.length; i++) { final int index = i; Assertions.assertEquals(expected[i], d.density(x[i]), 1e-5, diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/BinomialDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/BinomialDistributionTest.java index cbc57ca..d66d799 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/BinomialDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/BinomialDistributionTest.java @@ -95,7 +95,7 @@ public class BinomialDistributionTest extends DiscreteDistributionAbstractTest { /** Test degenerate case p = 0 */ @Test public void testDegenerate0() { - BinomialDistribution dist = new BinomialDistribution(5, 0.0d); + final BinomialDistribution dist = new BinomialDistribution(5, 0.0d); setDistribution(dist); setCumulativeTestPoints(new int[] {-1, 0, 1, 5, 10}); setCumulativeTestValues(new double[] {0d, 1d, 1d, 1d, 1d}); @@ -113,7 +113,7 @@ public class BinomialDistributionTest extends DiscreteDistributionAbstractTest { /** Test degenerate case p = 1 */ @Test public void testDegenerate1() { - BinomialDistribution dist = new BinomialDistribution(5, 1.0d); + final BinomialDistribution dist = new BinomialDistribution(5, 1.0d); setDistribution(dist); setCumulativeTestPoints(new int[] {-1, 0, 1, 2, 5, 10}); setCumulativeTestValues(new double[] {0d, 0d, 0d, 0d, 1d, 1d}); @@ -131,7 +131,7 @@ public class BinomialDistributionTest extends DiscreteDistributionAbstractTest { /** Test degenerate case n = 0 */ @Test public void testDegenerate2() { - BinomialDistribution dist = new BinomialDistribution(0, 0.01d); + final BinomialDistribution dist = new BinomialDistribution(0, 0.01d); setDistribution(dist); setCumulativeTestPoints(new int[] {-1, 0, 1, 2, 5, 10}); setCumulativeTestValues(new double[] {0d, 1d, 1d, 1d, 1d, 1d}); @@ -193,8 +193,8 @@ public class BinomialDistributionTest extends DiscreteDistributionAbstractTest { // numerically stable. for (int trials = 500000; trials < 20000000; trials += 100000) { - BinomialDistribution dist = new BinomialDistribution(trials, 0.5); - int p = dist.inverseCumulativeProbability(0.5); + final BinomialDistribution dist = new BinomialDistribution(trials, 0.5); + final int p = dist.inverseCumulativeProbability(0.5); Assertions.assertEquals(trials / 2, p); } } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/CauchyDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/CauchyDistributionTest.java index 73e31fc..122db27 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/CauchyDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/CauchyDistributionTest.java @@ -78,7 +78,7 @@ public class CauchyDistributionTest extends ContinuousDistributionAbstractTest { @Test public void testParameterAccessors() { - CauchyDistribution distribution = makeDistribution(); + final CauchyDistribution distribution = makeDistribution(); Assertions.assertEquals(1.2, distribution.getMedian(), 0.0); Assertions.assertEquals(2.1, distribution.getScale(), 0.0); } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ChiSquaredDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ChiSquaredDistributionTest.java index 4fc17b0..b4cfb78 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ChiSquaredDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ChiSquaredDistributionTest.java @@ -97,7 +97,7 @@ public class ChiSquaredDistributionTest extends ContinuousDistributionAbstractTe @Test public void testParameterAccessors() { - ChiSquaredDistribution distribution = makeDistribution(); + final ChiSquaredDistribution distribution = makeDistribution(); Assertions.assertEquals(5d, distribution.getDegreesOfFreedom(), Double.MIN_VALUE); } @@ -127,7 +127,7 @@ public class ChiSquaredDistributionTest extends ContinuousDistributionAbstractTe @Test public void testDensity() { - double[] x = new double[]{-0.1, 1e-6, 0.5, 1, 2, 5}; + final double[] x = new double[]{-0.1, 1e-6, 0.5, 1, 2, 5}; //R 2.5: print(dchisq(x, df=1), digits=10) checkDensity(1, x, new double[]{0.00000000000, 398.94208093034, 0.43939128947, 0.24197072452, 0.10377687436, 0.01464498256}); //R 2.5: print(dchisq(x, df=0.1), digits=10) @@ -139,7 +139,7 @@ public class ChiSquaredDistributionTest extends ContinuousDistributionAbstractTe } private void checkDensity(double df, double[] x, double[] expected) { - ChiSquaredDistribution d = new ChiSquaredDistribution(df); + final ChiSquaredDistribution d = new ChiSquaredDistribution(df); for (int i = 0; i < x.length; i++) { Assertions.assertEquals(expected[i], d.density(x[i]), 1e-5); } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ConstantContinuousDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ConstantContinuousDistributionTest.java index bc4a2cf..58f4c5a 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ConstantContinuousDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ConstantContinuousDistributionTest.java @@ -63,8 +63,8 @@ public class ConstantContinuousDistributionTest extends ContinuousDistributionAb @Override @Test public void testInverseCumulativeProbabilities() { - ContinuousDistribution dist = getDistribution(); - for (double x : getCumulativeTestValues()) { + final ContinuousDistribution dist = getDistribution(); + for (final double x : getCumulativeTestValues()) { Assertions.assertEquals(1, dist.inverseCumulativeProbability(x), 0); } } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ContinuousDistributionAbstractTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ContinuousDistributionAbstractTest.java index 39178d9..6e517ee 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ContinuousDistributionAbstractTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ContinuousDistributionAbstractTest.java @@ -182,7 +182,7 @@ public abstract class ContinuousDistributionAbstractTest { } else { try { distribution.probability(cumulativeTestPoints[i], cumulativeTestPoints[j]); - } catch (IllegalArgumentException e) { + } catch (final IllegalArgumentException e) { continue; } Assertions.fail("distribution.probability(double, double) should have thrown an exception that second argument is too large"); @@ -279,11 +279,11 @@ public abstract class ContinuousDistributionAbstractTest { tolerance); // check that P(a < X <= b) = P(X <= b) - P(X <= a) - double upper = Math.max(cumulativeTestPoints[i], cumulativeTestPoints[i - 1]); - double lower = Math.min(cumulativeTestPoints[i], cumulativeTestPoints[i - 1]); - double diff = distribution.cumulativeProbability(upper) - + final double upper = Math.max(cumulativeTestPoints[i], cumulativeTestPoints[i - 1]); + final double lower = Math.min(cumulativeTestPoints[i], cumulativeTestPoints[i - 1]); + final double diff = distribution.cumulativeProbability(upper) - distribution.cumulativeProbability(lower); - double direct = distribution.probability(lower, upper); + final double direct = distribution.probability(lower, upper); TestUtils.assertEquals("Inconsistent probability for (" + lower + "," + upper + ")", diff, direct, tolerance); } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/DiscreteDistributionAbstractTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/DiscreteDistributionAbstractTest.java index 0961f44..b60ff9f 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/DiscreteDistributionAbstractTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/DiscreteDistributionAbstractTest.java @@ -273,13 +273,13 @@ public abstract class DiscreteDistributionAbstractTest { */ @Test public void testSampling() { - int[] densityPoints = makeDensityTestPoints(); - double[] densityValues = makeDensityTestValues(); - int sampleSize = 1000; - int length = TestUtils.eliminateZeroMassPoints(densityPoints, densityValues); - AbstractDiscreteDistribution dist = (AbstractDiscreteDistribution) makeDistribution(); - double[] expectedCounts = new double[length]; - long[] observedCounts = new long[length]; + final int[] densityPoints = makeDensityTestPoints(); + final double[] densityValues = makeDensityTestValues(); + final int sampleSize = 1000; + final int length = TestUtils.eliminateZeroMassPoints(densityPoints, densityValues); + final AbstractDiscreteDistribution dist = (AbstractDiscreteDistribution) makeDistribution(); + final double[] expectedCounts = new double[length]; + final long[] observedCounts = new long[length]; for (int i = 0; i < length; i++) { expectedCounts[i] = sampleSize * densityValues[i]; } @@ -287,7 +287,7 @@ public abstract class DiscreteDistributionAbstractTest { final DiscreteDistribution.Sampler sampler = dist.createSampler(RandomSource.create(RandomSource.WELL_512_A, 1000)); - int[] sample = AbstractDiscreteDistribution.sample(sampleSize, sampler); + final int[] sample = AbstractDiscreteDistribution.sample(sampleSize, sampler); for (int i = 0; i < sampleSize; i++) { for (int j = 0; j < length; j++) { if (sample[i] == densityPoints[j]) { diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ExponentialDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ExponentialDistributionTest.java index 0202be6..4750e74 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ExponentialDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ExponentialDistributionTest.java @@ -83,20 +83,20 @@ public class ExponentialDistributionTest extends ContinuousDistributionAbstractT @Test public void testCumulativeProbability2() { - double actual = getDistribution().probability(0.25, 0.75); + final double actual = getDistribution().probability(0.25, 0.75); Assertions.assertEquals(0.0905214, actual, 10e-4); } @Test public void testDensity() { - ExponentialDistribution d1 = new ExponentialDistribution(1); + final ExponentialDistribution d1 = new ExponentialDistribution(1); Assertions.assertTrue(Precision.equals(0.0, d1.density(-1e-9), 1)); Assertions.assertTrue(Precision.equals(1.0, d1.density(0.0), 1)); Assertions.assertTrue(Precision.equals(0.0, d1.density(1000.0), 1)); Assertions.assertTrue(Precision.equals(Math.exp(-1), d1.density(1.0), 1)); Assertions.assertTrue(Precision.equals(Math.exp(-2), d1.density(2.0), 1)); - ExponentialDistribution d2 = new ExponentialDistribution(3); + final ExponentialDistribution d2 = new ExponentialDistribution(3); Assertions.assertTrue(Precision.equals(1 / 3.0, d2.density(0.0), 1)); // computed using print(dexp(1, rate=1/3), digits=10) in R 2.5 Assertions.assertEquals(0.2388437702, d2.density(1.0), 1e-8); @@ -107,7 +107,7 @@ public class ExponentialDistributionTest extends ContinuousDistributionAbstractT @Test public void testMeanAccessors() { - ExponentialDistribution distribution = makeDistribution(); + final ExponentialDistribution distribution = makeDistribution(); Assertions.assertEquals(5d, distribution.getMean(), Double.MIN_VALUE); } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/FDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/FDistributionTest.java index cb59564..dfe4a52 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/FDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/FDistributionTest.java @@ -81,7 +81,7 @@ public class FDistributionTest extends ContinuousDistributionAbstractTest { @Test public void testParameterAccessors() { - FDistribution dist = makeDistribution(); + final FDistribution dist = makeDistribution(); Assertions.assertEquals(5d, dist.getNumeratorDegreesOfFreedom(), Double.MIN_VALUE); Assertions.assertEquals(6d, dist.getDenominatorDegreesOfFreedom(), Double.MIN_VALUE); } @@ -115,9 +115,9 @@ public class FDistributionTest extends ContinuousDistributionAbstractTest { @Test public void testLargeDegreesOfFreedom() { - FDistribution fd = new FDistribution(100000, 100000); - double p = fd.cumulativeProbability(.999); - double x = fd.inverseCumulativeProbability(p); + final FDistribution fd = new FDistribution(100000, 100000); + final double p = fd.cumulativeProbability(.999); + final double x = fd.inverseCumulativeProbability(p); Assertions.assertEquals(.999, x, 1.0e-5); } @@ -139,11 +139,11 @@ public class FDistributionTest extends ContinuousDistributionAbstractTest { // this test was failing due to inaccurate results from ContinuedFraction. try { - double prob = 0.01; - FDistribution f = new FDistribution(200000, 200000); - double result = f.inverseCumulativeProbability(prob); + final double prob = 0.01; + final FDistribution f = new FDistribution(200000, 200000); + final double result = f.inverseCumulativeProbability(prob); Assertions.assertTrue(result < 1.0); - } catch (AssertionError ex) { + } catch (final AssertionError ex) { Assertions.fail("Failing to calculate inverse cumulative probability"); } } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/GammaDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/GammaDistributionTest.java index d58a519..c4db0a2 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/GammaDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/GammaDistributionTest.java @@ -77,7 +77,7 @@ public class GammaDistributionTest extends ContinuousDistributionAbstractTest { @Test public void testParameterAccessors() { - GammaDistribution distribution = makeDistribution(); + final GammaDistribution distribution = makeDistribution(); Assertions.assertEquals(4d, distribution.getShape(), 0); Assertions.assertEquals(2d, distribution.getScale(), 0); } @@ -123,20 +123,20 @@ public class GammaDistributionTest extends ContinuousDistributionAbstractTest { } private void testProbability(double x, double a, double b, double expected) { - GammaDistribution distribution = new GammaDistribution(a, b); - double actual = distribution.cumulativeProbability(x); + final GammaDistribution distribution = new GammaDistribution(a, b); + final double actual = distribution.cumulativeProbability(x); Assertions.assertEquals(expected, actual, 10e-4, () -> "probability for " + x); } private void testValue(double expected, double a, double b, double p) { - GammaDistribution distribution = new GammaDistribution(a, b); - double actual = distribution.inverseCumulativeProbability(p); + final GammaDistribution distribution = new GammaDistribution(a, b); + final double actual = distribution.inverseCumulativeProbability(p); Assertions.assertEquals(expected, actual, 10e-4, () -> "critical value for " + p); } @Test public void testDensity() { - double[] x = new double[]{-0.1, 1e-6, 0.5, 1, 2, 5}; + final double[] x = new double[]{-0.1, 1e-6, 0.5, 1, 2, 5}; // R2.5: print(dgamma(x, shape=1, rate=1), digits=10) checkDensity(1, 1, x, new double[]{0.000000000000, 0.999999000001, 0.606530659713, 0.367879441171, 0.135335283237, 0.006737946999}); // R2.5: print(dgamma(x, shape=2, rate=1), digits=10) @@ -159,7 +159,7 @@ public class GammaDistributionTest extends ContinuousDistributionAbstractTest { } private void checkDensity(double alpha, double rate, double[] x, double[] expected) { - GammaDistribution d = new GammaDistribution(alpha, 1 / rate); + final GammaDistribution d = new GammaDistribution(alpha, 1 / rate); for (int i = 0; i < x.length; i++) { Assertions.assertEquals(expected[i], d.density(x[i]), Math.abs(expected[i]) * 1e-5); } @@ -167,7 +167,7 @@ public class GammaDistributionTest extends ContinuousDistributionAbstractTest { @Test public void testLogDensity() { - double[] x = new double[]{-0.1, 1e-6, 0.5, 1, 2, 5}; + final double[] x = new double[]{-0.1, 1e-6, 0.5, 1, 2, 5}; final double inf = Double.POSITIVE_INFINITY; // R2.5: print(dgamma(x, shape=1, rate=1, log=TRUE), digits=10) checkLogDensity(1, 1, x, new double[]{-inf, -1e-06, -5e-01, -1e+00, -2e+00, -5e+00}); @@ -191,7 +191,7 @@ public class GammaDistributionTest extends ContinuousDistributionAbstractTest { } private void checkLogDensity(double alpha, double rate, double[] x, double[] expected) { - GammaDistribution d = new GammaDistribution(alpha, 1 / rate); + final GammaDistribution d = new GammaDistribution(alpha, 1 / rate); for (int i = 0; i < x.length; i++) { Assertions.assertEquals(expected[i], d.logDensity(x[i]), Math.abs(expected[i]) * 1e-5); } @@ -215,8 +215,8 @@ public class GammaDistributionTest extends ContinuousDistributionAbstractTest { if (Double.isNaN(x) || (x <= 0.0)) { ret = Double.NaN; } else { - double sum = LanczosApproximation.value(x); - double tmp = x + LanczosApproximation.g() + .5; + final double sum = LanczosApproximation.value(x); + final double tmp = x + LanczosApproximation.g() + .5; ret = ((x + .5) * Math.log(tmp)) - tmp + HALF_LOG_2_PI + Math.log(sum / x); } @@ -343,7 +343,7 @@ public class GammaDistributionTest extends ContinuousDistributionAbstractTest { Assertions.assertTrue(newMean <= meanOF, msg); Assertions.assertTrue(newSd <= sdOF, msg); } - } catch (IOException e) { + } catch (final IOException e) { Assertions.fail(e.getMessage()); } finally { in.close(); diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/GumbelDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/GumbelDistributionTest.java index 61268f2..0acdc39 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/GumbelDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/GumbelDistributionTest.java @@ -66,7 +66,7 @@ public class GumbelDistributionTest extends ContinuousDistributionAbstractTest { @Test public void testParameterAccessors() { - GumbelDistribution d = makeDistribution(); + final GumbelDistribution d = makeDistribution(); Assertions.assertEquals(0.5, d.getLocation(), Precision.EPSILON); Assertions.assertEquals(2, d.getScale(), Precision.EPSILON); } @@ -92,7 +92,7 @@ public class GumbelDistributionTest extends ContinuousDistributionAbstractTest { @Test public void testSupport() { - GumbelDistribution d = makeDistribution(); + final GumbelDistribution d = makeDistribution(); Assertions.assertTrue(Double.isInfinite(d.getSupportLowerBound())); Assertions.assertTrue(Double.isInfinite(d.getSupportUpperBound())); Assertions.assertTrue(d.isSupportConnected()); diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/HypergeometricDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/HypergeometricDistributionTest.java index 539dfab..835aa67 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/HypergeometricDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/HypergeometricDistributionTest.java @@ -106,7 +106,7 @@ public class HypergeometricDistributionTest extends DiscreteDistributionAbstract /** Verify that if there are no failures, mass is concentrated on sampleSize */ @Test public void testDegenerateNoFailures() { - HypergeometricDistribution dist = new HypergeometricDistribution(5, 5, 3); + final HypergeometricDistribution dist = new HypergeometricDistribution(5, 5, 3); setDistribution(dist); setCumulativeTestPoints(new int[] {-1, 0, 1, 3, 10 }); setCumulativeTestValues(new double[] {0d, 0d, 0d, 1d, 1d}); @@ -124,7 +124,7 @@ public class HypergeometricDistributionTest extends DiscreteDistributionAbstract /** Verify that if there are no successes, mass is concentrated on 0 */ @Test public void testDegenerateNoSuccesses() { - HypergeometricDistribution dist = new HypergeometricDistribution(5, 0, 3); + final HypergeometricDistribution dist = new HypergeometricDistribution(5, 0, 3); setDistribution(dist); setCumulativeTestPoints(new int[] {-1, 0, 1, 3, 10 }); setCumulativeTestValues(new double[] {0d, 1d, 1d, 1d, 1d}); @@ -142,7 +142,7 @@ public class HypergeometricDistributionTest extends DiscreteDistributionAbstract /** Verify that if sampleSize = populationSize, mass is concentrated on numberOfSuccesses */ @Test public void testDegenerateFullSample() { - HypergeometricDistribution dist = new HypergeometricDistribution(5, 3, 5); + final HypergeometricDistribution dist = new HypergeometricDistribution(5, 3, 5); setDistribution(dist); setCumulativeTestPoints(new int[] {-1, 0, 1, 3, 10 }); setCumulativeTestValues(new double[] {0d, 0d, 0d, 1d, 1d}); @@ -159,7 +159,7 @@ public class HypergeometricDistributionTest extends DiscreteDistributionAbstract @Test public void testParameterAccessors() { - HypergeometricDistribution dist = new HypergeometricDistribution(5, 3, 4); + final HypergeometricDistribution dist = new HypergeometricDistribution(5, 3, 4); Assertions.assertEquals(5, dist.getPopulationSize()); Assertions.assertEquals(3, dist.getNumberOfSuccesses()); Assertions.assertEquals(4, dist.getSampleSize()); @@ -202,10 +202,10 @@ public class HypergeometricDistributionTest extends DiscreteDistributionAbstract @Test public void testLargeValues() { - int populationSize = 3456; - int sampleSize = 789; - int numberOfSucceses = 101; - double[][] data = { + final int populationSize = 3456; + final int sampleSize = 789; + final int numberOfSucceses = 101; + final double[][] data = { {0.0, 2.75646034603961e-12, 2.75646034603961e-12, 1.0}, {1.0, 8.55705370142386e-11, 8.83269973602783e-11, 0.999999999997244}, {2.0, 1.31288129219665e-9, 1.40120828955693e-9, 0.999999999911673}, @@ -233,29 +233,29 @@ public class HypergeometricDistributionTest extends DiscreteDistributionAbstract private void testHypergeometricDistributionProbabilities(int populationSize, int sampleSize, int numberOfSucceses, double[][] data) { - HypergeometricDistribution dist = new HypergeometricDistribution(populationSize, numberOfSucceses, sampleSize); + final HypergeometricDistribution dist = new HypergeometricDistribution(populationSize, numberOfSucceses, sampleSize); for (int i = 0; i < data.length; ++i) { - int x = (int)data[i][0]; - double pmf = data[i][1]; - double actualPmf = dist.probability(x); + final int x = (int)data[i][0]; + final double pmf = data[i][1]; + final double actualPmf = dist.probability(x); TestUtils.assertRelativelyEquals("Expected equals for <" + x + "> pmf", pmf, actualPmf, 1.0e-9); - double cdf = data[i][2]; - double actualCdf = dist.cumulativeProbability(x); + final double cdf = data[i][2]; + final double actualCdf = dist.cumulativeProbability(x); TestUtils.assertRelativelyEquals("Expected equals for <" + x + "> cdf", cdf, actualCdf, 1.0e-9); - double cdf1 = data[i][3]; - double actualCdf1 = dist.upperCumulativeProbability(x); + final double cdf1 = data[i][3]; + final double actualCdf1 = dist.upperCumulativeProbability(x); TestUtils.assertRelativelyEquals("Expected equals for <" + x + "> cdf1", cdf1, actualCdf1, 1.0e-9); } } @Test public void testMoreLargeValues() { - int populationSize = 26896; - int sampleSize = 895; - int numberOfSucceses = 55; - double[][] data = { + final int populationSize = 26896; + final int sampleSize = 895; + final int numberOfSucceses = 55; + final double[][] data = { {0.0, 0.155168304750504, 0.155168304750504, 1.0}, {1.0, 0.29437545000746, 0.449543754757964, 0.844831695249496}, {2.0, 0.273841321577003, 0.723385076334967, 0.550456245242036}, @@ -291,7 +291,7 @@ public class HypergeometricDistributionTest extends DiscreteDistributionAbstract Assertions.assertTrue(Precision.compareTo(dist.cumulativeProbability(k), 0.0, 1) > 0); // another way to calculate the upper cumulative probability - double upper = 1.0 - dist.cumulativeProbability(k) + dist.probability(k); + final double upper = 1.0 - dist.cumulativeProbability(k) + dist.probability(k); Assertions.assertTrue(Precision.compareTo(1.0, upper, 1) == 0); } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LaplaceDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LaplaceDistributionTest.java index da54db5..0272cbb 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LaplaceDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LaplaceDistributionTest.java @@ -66,7 +66,7 @@ public class LaplaceDistributionTest extends ContinuousDistributionAbstractTest @Test public void testParameterAccessors() { - LaplaceDistribution d = makeDistribution(); + final LaplaceDistribution d = makeDistribution(); Assertions.assertEquals(0, d.getLocation(), Precision.EPSILON); Assertions.assertEquals(1, d.getScale(), Precision.EPSILON); } @@ -91,7 +91,7 @@ public class LaplaceDistributionTest extends ContinuousDistributionAbstractTest @Test public void testSupport() { - LaplaceDistribution d = makeDistribution(); + final LaplaceDistribution d = makeDistribution(); Assertions.assertTrue(Double.isInfinite(d.getSupportLowerBound())); Assertions.assertTrue(Double.isInfinite(d.getSupportUpperBound())); Assertions.assertTrue(d.isSupportConnected()); diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LevyDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LevyDistributionTest.java index 9ab0958..7718367 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LevyDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LevyDistributionTest.java @@ -70,7 +70,7 @@ public class LevyDistributionTest extends ContinuousDistributionAbstractTest { @Test public void testParameterAccessors() { - LevyDistribution d = makeDistribution(); + final LevyDistribution d = makeDistribution(); Assertions.assertEquals(1.2, d.getLocation(), Precision.EPSILON); Assertions.assertEquals(0.4, d.getScale(), Precision.EPSILON); } @@ -94,7 +94,7 @@ public class LevyDistributionTest extends ContinuousDistributionAbstractTest { @Test public void testSupport() { - LevyDistribution d = makeDistribution(); + final LevyDistribution d = makeDistribution(); Assertions.assertEquals(d.getLocation(), d.getSupportLowerBound(), Precision.EPSILON); Assertions.assertTrue(Double.isInfinite(d.getSupportUpperBound())); Assertions.assertTrue(d.isSupportConnected()); diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LogNormalDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LogNormalDistributionTest.java index 7f74e25..8ef02b8 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LogNormalDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LogNormalDistributionTest.java @@ -79,8 +79,8 @@ public class LogNormalDistributionTest extends ContinuousDistributionAbstractTes // Exclude the test points less than zero, as they have cumulative // probability of zero, meaning the inverse returns zero, and not the // points less than zero. - double[] points = makeCumulativeTestValues(); - double[] points2 = new double[points.length - 4]; + final double[] points = makeCumulativeTestValues(); + final double[] points2 = new double[points.length - 4]; System.arraycopy(points, 4, points2, 0, points2.length - 4); return points2; //return Arrays.copyOfRange(points, 4, points.length - 4); @@ -95,8 +95,8 @@ public class LogNormalDistributionTest extends ContinuousDistributionAbstractTes // Exclude the test points less than zero, as they have cumulative // probability of zero, meaning the inverse returns zero, and not the // points less than zero. - double[] points = makeCumulativeTestPoints(); - double[] points2 = new double[points.length - 4]; + final double[] points = makeCumulativeTestPoints(); + final double[] points2 = new double[points.length - 4]; System.arraycopy(points, 4, points2, 0, points2.length - 4); return points2; //return Arrays.copyOfRange(points, 1, points.length - 4); @@ -105,9 +105,9 @@ public class LogNormalDistributionTest extends ContinuousDistributionAbstractTes //-------------------- Additional test cases ------------------------------- private void verifyQuantiles() { - LogNormalDistribution distribution = (LogNormalDistribution)getDistribution(); - double mu = distribution.getScale(); - double sigma = distribution.getShape(); + final LogNormalDistribution distribution = (LogNormalDistribution)getDistribution(); + final double mu = distribution.getScale(); + final double sigma = distribution.getShape(); setCumulativeTestPoints(new double[] {mu - 2 * sigma, mu - sigma, mu, mu + sigma, mu + 2 * sigma, mu + 3 * sigma, @@ -170,7 +170,7 @@ public class LogNormalDistributionTest extends ContinuousDistributionAbstractTes @Test public void testParameterAccessors() { - LogNormalDistribution distribution = (LogNormalDistribution)getDistribution(); + final LogNormalDistribution distribution = (LogNormalDistribution)getDistribution(); Assertions.assertEquals(2.1, distribution.getScale(), 0); Assertions.assertEquals(1.4, distribution.getShape(), 0); } @@ -200,7 +200,7 @@ public class LogNormalDistributionTest extends ContinuousDistributionAbstractTes @Test public void testDensity() { - double[] x = new double[]{-2, -1, 0, 1, 2}; + final double[] x = new double[]{-2, -1, 0, 1, 2}; // R 2.13: print(dlnorm(c(-2,-1,0,1,2)), digits=10) checkDensity(0, 1, x, new double[] {0.0000000000, 0.0000000000, 0.0000000000, 0.3989422804, @@ -215,7 +215,7 @@ public class LogNormalDistributionTest extends ContinuousDistributionAbstractTes double shape, double[] x, double[] expected) { - LogNormalDistribution d = new LogNormalDistribution(scale, shape); + final LogNormalDistribution d = new LogNormalDistribution(scale, shape); for (int i = 0; i < x.length; i++) { Assertions.assertEquals(expected[i], d.density(x[i]), 1e-9); } @@ -227,9 +227,9 @@ public class LogNormalDistributionTest extends ContinuousDistributionAbstractTes */ @Test public void testExtremeValues() { - LogNormalDistribution d = new LogNormalDistribution(0, 1); + final LogNormalDistribution d = new LogNormalDistribution(0, 1); for (int i = 0; i < 1e5; i++) { // make sure no convergence exception - double upperTail = d.cumulativeProbability(i); + final double upperTail = d.cumulativeProbability(i); if (i <= 72) { // make sure not top-coded Assertions.assertTrue(upperTail < 1.0d); } else { // make sure top coding not reversed @@ -245,8 +245,8 @@ public class LogNormalDistributionTest extends ContinuousDistributionAbstractTes @Test public void testTinyVariance() { - LogNormalDistribution dist = new LogNormalDistribution(0, 1e-9); - double t = dist.getVariance(); + final LogNormalDistribution dist = new LogNormalDistribution(0, 1e-9); + final double t = dist.getVariance(); Assertions.assertEquals(1e-18, t, 1e-20); } } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LogisticsDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LogisticsDistributionTest.java index 8170b54..700dd44 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LogisticsDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/LogisticsDistributionTest.java @@ -66,7 +66,7 @@ public class LogisticsDistributionTest extends ContinuousDistributionAbstractTes @Test public void testParametersAccessors() { - LogisticDistribution d = makeDistribution(); + final LogisticDistribution d = makeDistribution(); Assertions.assertEquals(2, d.getLocation(), Precision.EPSILON); Assertions.assertEquals(5, d.getScale(), Precision.EPSILON); } @@ -78,7 +78,7 @@ public class LogisticsDistributionTest extends ContinuousDistributionAbstractTes @Test public void testMeanAndVariance() { - LogisticDistribution d = makeDistribution(); + final LogisticDistribution d = makeDistribution(); // Constructor 'location' parameter = mean Assertions.assertEquals(2.0, d.getMean()); // Variance = (s^2 * pi^2) / 3 @@ -88,7 +88,7 @@ public class LogisticsDistributionTest extends ContinuousDistributionAbstractTes @Test public void testSupport() { - LogisticDistribution d = makeDistribution(); + final LogisticDistribution d = makeDistribution(); Assertions.assertTrue(Double.isInfinite(d.getSupportLowerBound())); Assertions.assertTrue(Double.isInfinite(d.getSupportUpperBound())); Assertions.assertTrue(d.isSupportConnected()); diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/NakagamiDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/NakagamiDistributionTest.java index 542bffc..c6fab0c 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/NakagamiDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/NakagamiDistributionTest.java @@ -60,7 +60,7 @@ public class NakagamiDistributionTest extends ContinuousDistributionAbstractTest @Test public void testParameterAccessors() { - NakagamiDistribution d = makeDistribution(); + final NakagamiDistribution d = makeDistribution(); Assertions.assertEquals(0.5, d.getShape(), Precision.EPSILON); Assertions.assertEquals(1, d.getScale(), Precision.EPSILON); } @@ -84,7 +84,7 @@ public class NakagamiDistributionTest extends ContinuousDistributionAbstractTest @Test public void testSupport() { - NakagamiDistribution d = makeDistribution(); + final NakagamiDistribution d = makeDistribution(); Assertions.assertEquals(0, d.getSupportLowerBound(), Precision.EPSILON); Assertions.assertTrue(Double.isInfinite(d.getSupportUpperBound())); Assertions.assertTrue(d.isSupportConnected()); diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/NormalDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/NormalDistributionTest.java index 5ca01e2..e1902f8 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/NormalDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/NormalDistributionTest.java @@ -115,16 +115,16 @@ public class NormalDistributionTest extends ContinuousDistributionAbstractTest { @Test public void testCumulativeProbability() { final ContinuousDistribution dist = new NormalDistribution(0, 1); - double x = -10; - double expected = 7.61985e-24; - double v = dist.cumulativeProbability(x); - double tol = 1e-5; + final double x = -10; + final double expected = 7.61985e-24; + final double v = dist.cumulativeProbability(x); + final double tol = 1e-5; Assertions.assertEquals(1, v / expected, 1e-5); } @Test public void testParameterAccessors() { - NormalDistribution distribution = makeDistribution(); + final NormalDistribution distribution = makeDistribution(); Assertions.assertEquals(2.1, distribution.getMean(), 0); Assertions.assertEquals(1.4, distribution.getStandardDeviation(), 0); } @@ -154,7 +154,7 @@ public class NormalDistributionTest extends ContinuousDistributionAbstractTest { @Test public void testDensity() { - double[] x = new double[] {-2, -1, 0, 1, 2}; + final double[] x = new double[] {-2, -1, 0, 1, 2}; // R 2.5: print(dnorm(c(-2,-1,0,1,2)), digits=10) checkDensity(0, 1, x, new double[] {0.05399096651, 0.24197072452, 0.39894228040, 0.24197072452, 0.05399096651}); // R 2.5: print(dnorm(c(-2,-1,0,1,2), mean=1.1), digits=10) @@ -162,7 +162,7 @@ public class NormalDistributionTest extends ContinuousDistributionAbstractTest { } private void checkDensity(double mean, double sd, double[] x, double[] expected) { - NormalDistribution d = new NormalDistribution(mean, sd); + final NormalDistribution d = new NormalDistribution(mean, sd); for (int i = 0; i < x.length; i++) { Assertions.assertEquals(expected[i], d.density(x[i]), 1e-9); } @@ -214,7 +214,7 @@ public class NormalDistributionTest extends ContinuousDistributionAbstractTest { @Test public void testMath280() { - NormalDistribution normal = new NormalDistribution(0, 1); + final NormalDistribution normal = new NormalDistribution(0, 1); double result = normal.inverseCumulativeProbability(0.9986501019683698); Assertions.assertEquals(3.0, result, DEFAULT_TOLERANCE); result = normal.inverseCumulativeProbability(0.841344746068543); diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ParetoDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ParetoDistributionTest.java index 96431ba..bd19bfc 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ParetoDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ParetoDistributionTest.java @@ -70,8 +70,8 @@ public class ParetoDistributionTest extends ContinuousDistributionAbstractTest { // Exclude the test points less than zero, as they have cumulative // probability of zero, meaning the inverse returns zero, and not the // points less than zero. - double[] points = makeCumulativeTestValues(); - double[] points2 = new double[points.length - 5]; + final double[] points = makeCumulativeTestValues(); + final double[] points2 = new double[points.length - 5]; System.arraycopy(points, 5, points2, 0, points.length - 5); return points2; } @@ -84,8 +84,8 @@ public class ParetoDistributionTest extends ContinuousDistributionAbstractTest { // Exclude the test points less than zero, as they have cumulative // probability of zero, meaning the inverse returns zero, and not the // points less than zero. - double[] points = makeCumulativeTestPoints(); - double[] points2 = new double[points.length - 5]; + final double[] points = makeCumulativeTestPoints(); + final double[] points2 = new double[points.length - 5]; System.arraycopy(points, 5, points2, 0, points.length - 5); return points2; } @@ -93,9 +93,9 @@ public class ParetoDistributionTest extends ContinuousDistributionAbstractTest { //-------------------- Additional test cases ------------------------------- private void verifyQuantiles() { - ParetoDistribution distribution = (ParetoDistribution)getDistribution(); - double mu = distribution.getScale(); - double sigma = distribution.getShape(); + final ParetoDistribution distribution = (ParetoDistribution)getDistribution(); + final double mu = distribution.getScale(); + final double sigma = distribution.getShape(); setCumulativeTestPoints(new double[] {mu - 2 * sigma, mu - sigma, mu, mu + sigma, mu + 2 * sigma, mu + 3 * sigma, @@ -132,7 +132,7 @@ public class ParetoDistributionTest extends ContinuousDistributionAbstractTest { @Test public void testParameterAccessors() { - ParetoDistribution distribution = (ParetoDistribution)getDistribution(); + final ParetoDistribution distribution = (ParetoDistribution)getDistribution(); Assertions.assertEquals(2.1, distribution.getScale(), 0); Assertions.assertEquals(1.4, distribution.getShape(), 0); } @@ -163,7 +163,7 @@ public class ParetoDistributionTest extends ContinuousDistributionAbstractTest { @Test public void testDensity() { - double[] x = new double[] {-2, -1, 0, 1, 2}; + final double[] x = new double[] {-2, -1, 0, 1, 2}; // R 2.14: print(dpareto(c(-2,-1,0,1,2), scale=1, shape=1), digits=10) checkDensity(1, 1, x, new double[] {0.00, 0.00, 0.00, 1.00, 0.25}); // R 2.14: print(dpareto(c(-2,-1,0,1,2), scale=1.1, shape=1), digits=10) @@ -172,7 +172,7 @@ public class ParetoDistributionTest extends ContinuousDistributionAbstractTest { private void checkDensity(double scale, double shape, double[] x, double[] expected) { - ParetoDistribution d = new ParetoDistribution(scale, shape); + final ParetoDistribution d = new ParetoDistribution(scale, shape); for (int i = 0; i < x.length; i++) { Assertions.assertEquals(expected[i], d.density(x[i]), 1e-9); } @@ -183,9 +183,9 @@ public class ParetoDistributionTest extends ContinuousDistributionAbstractTest { */ @Test public void testExtremeValues() { - ParetoDistribution d = new ParetoDistribution(1, 1); + final ParetoDistribution d = new ParetoDistribution(1, 1); for (int i = 0; i < 1e5; i++) { // make sure no convergence exception - double upperTail = d.cumulativeProbability(i); + final double upperTail = d.cumulativeProbability(i); if (i <= 1000) { // make sure not top-coded Assertions.assertTrue(upperTail < 1.0d); } else { // make sure top coding not reversed diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/PascalDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/PascalDistributionTest.java index 1e63f99..5698eff 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/PascalDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/PascalDistributionTest.java @@ -119,7 +119,7 @@ public class PascalDistributionTest extends DiscreteDistributionAbstractTest { @Test public void testParameterAccessors() { - PascalDistribution distribution = makeDistribution(); + final PascalDistribution distribution = makeDistribution(); Assertions.assertEquals(10, distribution.getNumberOfSuccesses()); Assertions.assertEquals(0.7, distribution.getProbabilityOfSuccess()); } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/PoissonDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/PoissonDistributionTest.java index 317dfd4..bd5beef 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/PoissonDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/PoissonDistributionTest.java @@ -103,7 +103,7 @@ public class PoissonDistributionTest extends DiscreteDistributionAbstractTest { */ @Override public double[] makeInverseCumulativeTestPoints() { - DiscreteDistribution dist = getDistribution(); + final DiscreteDistribution dist = getDistribution(); return new double[] {0d, 0.018315638886d, 0.018315638890d, 0.091578194441d, 0.091578194445d, 0.238103305552d, 0.238103305556d, dist.cumulativeProbability(3), @@ -144,14 +144,14 @@ public class PoissonDistributionTest extends DiscreteDistributionAbstractTest { */ @Test public void testDegenerateInverseCumulativeProbability() { - PoissonDistribution dist = new PoissonDistribution(DEFAULT_TEST_POISSON_PARAMETER); + final PoissonDistribution dist = new PoissonDistribution(DEFAULT_TEST_POISSON_PARAMETER); Assertions.assertEquals(Integer.MAX_VALUE, dist.inverseCumulativeProbability(1.0d)); Assertions.assertEquals(0, dist.inverseCumulativeProbability(0d)); } @Test public void testParameterAccessors() { - PoissonDistribution dist = new PoissonDistribution(10.0); + final PoissonDistribution dist = new PoissonDistribution(10.0); Assertions.assertEquals(10.0, dist.getMean(), 0.0); } @@ -178,12 +178,12 @@ public class PoissonDistributionTest extends DiscreteDistributionAbstractTest { public void testLargeMeanCumulativeProbability() { double mean = 1.0; while (mean <= 10000000.0) { - PoissonDistribution dist = new PoissonDistribution(mean); + final PoissonDistribution dist = new PoissonDistribution(mean); double x = mean * 2.0; - double dx = x / 10.0; + final double dx = x / 10.0; double p = Double.NaN; - double sigma = Math.sqrt(mean); + final double sigma = Math.sqrt(mean); while (x >= 0) { try { p = dist.cumulativeProbability((int) x); @@ -191,7 +191,7 @@ public class PoissonDistributionTest extends DiscreteDistributionAbstractTest { if (x > mean - 2 * sigma) { Assertions.assertTrue(p > 0, "Zero cumulative probaility"); } - } catch (AssertionError ex) { + } catch (final AssertionError ex) { Assertions.fail("mean of " + mean + " and x of " + x + " caused " + ex.getMessage()); } x -= dx; @@ -228,16 +228,16 @@ public class PoissonDistributionTest extends DiscreteDistributionAbstractTest { public void testLargeMeanInverseCumulativeProbability() { double mean = 1.0; while (mean <= 100000.0) { // Extended test value: 1E7. Reduced to limit run time. - PoissonDistribution dist = new PoissonDistribution(mean); + final PoissonDistribution dist = new PoissonDistribution(mean); double p = 0.1; - double dp = p; + final double dp = p; while (p < .99) { try { - int ret = dist.inverseCumulativeProbability(p); + final int ret = dist.inverseCumulativeProbability(p); // Verify that returned value satisties definition Assertions.assertTrue(p <= dist.cumulativeProbability(ret)); Assertions.assertTrue(p > dist.cumulativeProbability(ret - 1)); - } catch (AssertionError ex) { + } catch (final AssertionError ex) { Assertions.fail("mean of " + mean + " and p of " + p + " caused " + ex.getMessage()); } p += dp; diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/TDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/TDistributionTest.java index 742200d..b3af9f5 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/TDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/TDistributionTest.java @@ -71,7 +71,7 @@ public class TDistributionTest extends ContinuousDistributionAbstractTest { */ @Test public void testCumulativeProbabilityAgainstStackOverflow() { - TDistribution td = new TDistribution(5.); + final TDistribution td = new TDistribution(5.); td.cumulativeProbability(.1); td.cumulativeProbability(.01); } @@ -115,7 +115,7 @@ public class TDistributionTest extends ContinuousDistributionAbstractTest { @Test public void testParameterAccessors() { - TDistribution dist = makeDistribution(); + final TDistribution dist = makeDistribution(); Assertions.assertEquals(5d, dist.getDegreesOfFreedom(), Double.MIN_VALUE); } @@ -150,11 +150,11 @@ public class TDistributionTest extends ContinuousDistributionAbstractTest { */ @Test public void nistData() { - double[] prob = new double[]{0.10, 0.05, 0.025, 0.01, 0.005, 0.001}; - double[] args2 = new double[]{1.886, 2.920, 4.303, 6.965, 9.925, 22.327}; - double[] args10 = new double[]{1.372, 1.812, 2.228, 2.764, 3.169, 4.143}; - double[] args30 = new double[]{1.310, 1.697, 2.042, 2.457, 2.750, 3.385}; - double[] args100 = new double[]{1.290, 1.660, 1.984, 2.364, 2.626, 3.174}; + final double[] prob = new double[]{0.10, 0.05, 0.025, 0.01, 0.005, 0.001}; + final double[] args2 = new double[]{1.886, 2.920, 4.303, 6.965, 9.925, 22.327}; + final double[] args10 = new double[]{1.372, 1.812, 2.228, 2.764, 3.169, 4.143}; + final double[] args30 = new double[]{1.310, 1.697, 2.042, 2.457, 2.750, 3.385}; + final double[] args100 = new double[]{1.290, 1.660, 1.984, 2.364, 2.626, 3.174}; TestUtils.assertEquals(prob, makeNistResults(args2, 2), 1.0e-4); TestUtils.assertEquals(prob, makeNistResults(args10, 10), 1.0e-4); TestUtils.assertEquals(prob, makeNistResults(args30, 30), 1.0e-4); @@ -163,8 +163,8 @@ public class TDistributionTest extends ContinuousDistributionAbstractTest { } private double[] makeNistResults(double[] args, int df) { - TDistribution td = new TDistribution(df); - double[] res = new double[args.length]; + final TDistribution td = new TDistribution(df); + final double[] res = new double[args.length]; for (int i = 0; i < res.length; i++) { res[i] = 1.0 - td.cumulativeProbability(args[i]); } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/TestUtils.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/TestUtils.java index 2e6dde9..adbc375 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/TestUtils.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/TestUtils.java @@ -104,7 +104,7 @@ public final class TestUtils { } else if (expected == 0.0) { Assertions.assertEquals(actual, expected, relativeError, msg); } else { - double absError = Math.abs(expected) * relativeError; + final double absError = Math.abs(expected) * relativeError; Assertions.assertEquals(expected, actual, absError, msg); } } @@ -114,7 +114,7 @@ public final class TestUtils { double[] expected, double[] observed, double tolerance) { - StringBuilder out = new StringBuilder(msg); + final StringBuilder out = new StringBuilder(msg); if (expected.length != observed.length) { out.append("\n Arrays not same length. \n"); out.append("expected has length "); @@ -154,12 +154,12 @@ public final class TestUtils { double[] expected, long[] observed, double alpha) { - ChiSquareTest chiSquareTest = new ChiSquareTest(); + final ChiSquareTest chiSquareTest = new ChiSquareTest(); // Fail if we can reject null hypothesis that distributions are the same if (chiSquareTest.chiSquareTest(expected, observed, alpha)) { - StringBuilder msgBuffer = new StringBuilder(); - DecimalFormat df = new DecimalFormat("#.##"); + final StringBuilder msgBuffer = new StringBuilder(); + final DecimalFormat df = new DecimalFormat("#.##"); msgBuffer.append("Chisquare test failed"); msgBuffer.append(" p-value = "); msgBuffer.append(chiSquareTest.chiSquareTest(expected, observed)); @@ -195,7 +195,7 @@ public final class TestUtils { double[] expected, long[] observed, double alpha) { - String[] labels = new String[values.length]; + final String[] labels = new String[values.length]; for (int i = 0; i < values.length; i++) { labels[i] = Integer.toString(values[i]); } @@ -213,7 +213,7 @@ public final class TestUtils { public static void assertChiSquareAccept(double[] expected, long[] observed, double alpha) { - String[] labels = new String[expected.length]; + final String[] labels = new String[expected.length]; for (int i = 0; i < labels.length; i++) { labels[i] = Integer.toString(i + 1); } @@ -225,7 +225,7 @@ public final class TestUtils { * these values in an array. */ public static double[] getDistributionQuartiles(ContinuousDistribution distribution) { - double[] quantiles = new double[3]; + final double[] quantiles = new double[3]; quantiles[0] = distribution.inverseCumulativeProbability(0.25d); quantiles[1] = distribution.inverseCumulativeProbability(0.5d); quantiles[2] = distribution.inverseCumulativeProbability(0.75d); @@ -262,8 +262,8 @@ public final class TestUtils { } } if (positiveMassCount < densityValues.length) { - int[] newPoints = new int[positiveMassCount]; - double[] newValues = new double[positiveMassCount]; + final int[] newPoints = new int[positiveMassCount]; + final double[] newValues = new double[positiveMassCount]; int j = 0; for (int i = 0; i < densityValues.length; i++) { if (densityValues[i] > 0) { diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/TriangularDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/TriangularDistributionTest.java index 079d05b..4b808d1 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/TriangularDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/TriangularDistributionTest.java @@ -73,9 +73,9 @@ public class TriangularDistributionTest extends ContinuousDistributionAbstractTe // Area total = 18.75 + 37.5 = 56.25 // Derivative left side = 7.5 / 5 = 1.5 // Derivative right side = -7.5 / 10 = -0.75 - double third = 1 / 3.0; - double left = 18.75; - double area = 56.25; + final double third = 1 / 3.0; + final double left = 18.75; + final double area = 56.25; return new double[] {0.0, 0.0, 0.75 / area, 3 / area, 6.75 / area, 12 / area, @@ -95,8 +95,8 @@ public class TriangularDistributionTest extends ContinuousDistributionAbstractTe // Exclude the points outside the limits, as they have cumulative // probability of zero and one, meaning the inverse returns the // limits and not the points outside the limits. - double[] points = makeCumulativeTestValues(); - double[] points2 = new double[points.length - 2]; + final double[] points = makeCumulativeTestValues(); + final double[] points2 = new double[points.length - 2]; System.arraycopy(points, 1, points2, 0, points2.length); return points2; //return Arrays.copyOfRange(points, 1, points.length - 1); @@ -111,8 +111,8 @@ public class TriangularDistributionTest extends ContinuousDistributionAbstractTe // Exclude the points outside the limits, as they have cumulative // probability of zero and one, meaning the inverse returns the // limits and not the points outside the limits. - double[] points = makeCumulativeTestPoints(); - double[] points2 = new double[points.length - 2]; + final double[] points = makeCumulativeTestPoints(); + final double[] points2 = new double[points.length - 2]; System.arraycopy(points, 1, points2, 0, points2.length); return points2; //return Arrays.copyOfRange(points, 1, points.length - 1); @@ -135,14 +135,14 @@ public class TriangularDistributionTest extends ContinuousDistributionAbstractTe /** Test lower bound getter. */ @Test public void testGetLowerBound() { - TriangularDistribution distribution = makeDistribution(); + final TriangularDistribution distribution = makeDistribution(); Assertions.assertEquals(-3.0, distribution.getSupportLowerBound(), 0); } /** Test upper bound getter. */ @Test public void testGetUpperBound() { - TriangularDistribution distribution = makeDistribution(); + final TriangularDistribution distribution = makeDistribution(); Assertions.assertEquals(12.0, distribution.getSupportUpperBound(), 0); } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/UniformContinuousDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/UniformContinuousDistributionTest.java index 3c86bd8..f1eb91d 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/UniformContinuousDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/UniformContinuousDistributionTest.java @@ -60,7 +60,7 @@ public class UniformContinuousDistributionTest extends ContinuousDistributionAbs /** Creates the default probability density test expected values */ @Override public double[] makeDensityTestValues() { - double d = 1 / 1.75; + final double d = 1 / 1.75; return new double[] {0, d, d, d, d, d, d, d, d, d, d, 0}; } @@ -69,14 +69,14 @@ public class UniformContinuousDistributionTest extends ContinuousDistributionAbs /** Test lower bound getter. */ @Test public void testGetLowerBound() { - UniformContinuousDistribution distribution = makeDistribution(); + final UniformContinuousDistribution distribution = makeDistribution(); Assertions.assertEquals(-0.5, distribution.getSupportLowerBound(), 0); } /** Test upper bound getter. */ @Test public void testGetUpperBound() { - UniformContinuousDistribution distribution = makeDistribution(); + final UniformContinuousDistribution distribution = makeDistribution(); Assertions.assertEquals(1.25, distribution.getSupportUpperBound(), 0); } @@ -115,7 +115,7 @@ public class UniformContinuousDistributionTest extends ContinuousDistributionAbs */ @Test public void testInverseCumulativeDistribution() { - UniformContinuousDistribution dist = new UniformContinuousDistribution(0, 1e-9); + final UniformContinuousDistribution dist = new UniformContinuousDistribution(0, 1e-9); Assertions.assertEquals(2.5e-10, dist.inverseCumulativeProbability(0.25), 0); } diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/UniformDiscreteDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/UniformDiscreteDistributionTest.java index be79fbe..993cb97 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/UniformDiscreteDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/UniformDiscreteDistributionTest.java @@ -52,7 +52,7 @@ public class UniformDiscreteDistributionTest extends DiscreteDistributionAbstrac /** Creates the default probability density test expected values. */ @Override public double[] makeDensityTestValues() { - double d = 1.0 / (5 - -3 + 1); + final double d = 1.0 / (5 - -3 + 1); return new double[] {0, d, d, d, d, d, d, d, d, d, 0}; } @@ -115,7 +115,7 @@ public class UniformDiscreteDistributionTest extends DiscreteDistributionAbstrac @Test public void testLargeRangeSubtractionOverflow() { final int hi = Integer.MAX_VALUE / 2 + 10; - UniformDiscreteDistribution dist = new UniformDiscreteDistribution(-hi, hi - 1); + final UniformDiscreteDistribution dist = new UniformDiscreteDistribution(-hi, hi - 1); final double tol = Math.ulp(1d); Assertions.assertEquals(0.5 / hi, dist.probability(123456), tol); @@ -128,7 +128,7 @@ public class UniformDiscreteDistributionTest extends DiscreteDistributionAbstrac @Test public void testLargeRangeAdditionOverflow() { final int hi = Integer.MAX_VALUE / 2 + 10; - UniformDiscreteDistribution dist = new UniformDiscreteDistribution(hi - 1, hi + 1); + final UniformDiscreteDistribution dist = new UniformDiscreteDistribution(hi - 1, hi + 1); final double tol = Math.ulp(1d); Assertions.assertEquals(1d / 3d, dist.probability(hi), tol); diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/WeibullDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/WeibullDistributionTest.java index 01c15b3..e09e3a1 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/WeibullDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/WeibullDistributionTest.java @@ -61,8 +61,8 @@ public class WeibullDistributionTest extends ContinuousDistributionAbstractTest @Test public void testInverseCumulativeProbabilitySmallPAccuracy() { - WeibullDistribution dist = new WeibullDistribution(2, 3); - double t = dist.inverseCumulativeProbability(1e-17); + final WeibullDistribution dist = new WeibullDistribution(2, 3); + final double t = dist.inverseCumulativeProbability(1e-17); // Analytically, answer is solution to 1e-17 = 1-exp(-(x/3)^2) // x = sqrt(-9*log(1-1e-17)) // If we're not careful, answer will be 0. Answer below is computed with care in Octave: diff --git a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ZipfDistributionTest.java b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ZipfDistributionTest.java index e5efadc..345b969 100644 --- a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ZipfDistributionTest.java +++ b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/ZipfDistributionTest.java @@ -102,7 +102,7 @@ public class ZipfDistributionTest extends DiscreteDistributionAbstractTest { @Test public void testParameterAccessors() { - ZipfDistribution distribution = makeDistribution(); + final ZipfDistribution distribution = makeDistribution(); Assertions.assertEquals(10, distribution.getNumberOfElements()); Assertions.assertEquals(1.0, distribution.getExponent()); } @@ -132,21 +132,21 @@ public class ZipfDistributionTest extends DiscreteDistributionAbstractTest { */ @Test public void testSamplingExtended() { - int sampleSize = 1000; + final int sampleSize = 1000; - int[] numPointsValues = { + final int[] numPointsValues = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20, 25, 30, 35, 40, 45, 50, 60, 70, 80, 90, 100 }; - double[] exponentValues = { + final double[] exponentValues = { 1e-10, 1e-9, 1e-8, 1e-7, 1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 1e-1, 2e-1, 5e-1, 1. - 1e-9, 1.0, 1. + 1e-9, 1.1, 1.2, 1.3, 1.5, 1.6, 1.7, 1.8, 2.0, 2.5, 3.0, 4., 5., 6., 7., 8., 9., 10., 20., 30., 100., 150. }; - for (int numPoints : numPointsValues) { - for (double exponent : exponentValues) { + for (final int numPoints : numPointsValues) { + for (final double exponent : exponentValues) { double weightSum = 0.; - double[] weights = new double[numPoints]; + final double[] weights = new double[numPoints]; for (int i = numPoints; i >= 1; i -= 1) { weights[i - 1] = Math.pow(i, -exponent); weightSum += weights[i - 1]; @@ -155,17 +155,17 @@ public class ZipfDistributionTest extends DiscreteDistributionAbstractTest { // Use fixed seed, the test is expected to fail for more than 50% of all // seeds because each test case can fail with probability 0.001, the chance // that all test cases do not fail is 0.999^(32*22) = 0.49442874426 - DiscreteDistribution.Sampler distribution = + final DiscreteDistribution.Sampler distribution = new ZipfDistribution(numPoints, exponent).createSampler( RandomSource.create(RandomSource.WELL_19937_C, 6)); - double[] expectedCounts = new double[numPoints]; - long[] observedCounts = new long[numPoints]; + final double[] expectedCounts = new double[numPoints]; + final long[] observedCounts = new long[numPoints]; for (int i = 0; i < numPoints; i++) { expectedCounts[i] = sampleSize * (weights[i] / weightSum); } - int[] sample = AbstractDiscreteDistribution.sample(sampleSize, distribution); - for (int s : sample) { + final int[] sample = AbstractDiscreteDistribution.sample(sampleSize, distribution); + for (final int s : sample) { observedCounts[s - 1]++; } TestUtils.assertChiSquareAccept(expectedCounts, observedCounts, 0.001);