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/24 12:59:13 UTC
[commons-statistics] 05/11: Use final
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 <ah...@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);