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
The following commit(s) were added to refs/heads/master by this push:
new 535db16 Updated checkstyle to enforce coding style.
new a911c0e Merge pull request #10 from aherbert/update-checkstyle
535db16 is described below
commit 535db16b12b587e55c2a72bcff27dc26c6940f92
Author: aherbert <[email protected]>
AuthorDate: Tue May 21 12:34:44 2019 +0100
Updated checkstyle to enforce coding style.
Use Checkstyle Sun checks as a template configuration.
Update the checks to match the coding style.
Added additional checks from the old checkstyle config.
Fixed all source and test source.
---
.../AbstractContinuousDistribution.java | 2 +-
.../distribution/AbstractDiscreteDistribution.java | 8 +-
.../distribution/GeometricDistribution.java | 2 +-
.../distribution/HypergeometricDistribution.java | 2 +-
.../statistics/distribution/LevyDistribution.java | 2 +-
.../distribution/LogNormalDistribution.java | 4 +-
.../distribution/NormalDistribution.java | 2 +-
.../distribution/SaddlePointExpansion.java | 65 +++---
.../statistics/distribution/TDistribution.java | 2 +-
.../distribution/UniformDiscreteDistribution.java | 2 +-
.../AbstractDiscreteDistributionTest.java | 31 ++-
.../distribution/BinomialDistributionTest.java | 54 ++---
.../distribution/CauchyDistributionTest.java | 4 +-
.../ConstantContinuousDistributionTest.java | 2 +-
.../ContinuousDistributionAbstractTest.java | 19 +-
.../DiscreteDistributionAbstractTest.java | 16 +-
.../distribution/ExponentialDistributionTest.java | 10 +-
.../statistics/distribution/FDistributionTest.java | 4 +-
.../distribution/GammaDistributionTest.java | 8 +-
.../distribution/GeometricDistributionTest.java | 8 +-
.../HypergeometricDistributionTest.java | 39 ++--
.../distribution/LogNormalDistributionTest.java | 49 +++--
.../distribution/NormalDistributionTest.java | 26 +--
.../distribution/ParetoDistributionTest.java | 27 ++-
.../distribution/PascalDistributionTest.java | 37 ++--
.../distribution/PoissonDistributionTest.java | 40 ++--
.../statistics/distribution/TDistributionTest.java | 30 +--
.../commons/statistics/distribution/TestUtils.java | 16 +-
.../distribution/TriangularDistributionTest.java | 44 ++--
.../UniformContinuousDistributionTest.java | 12 +-
.../UniformDiscreteDistributionTest.java | 2 +-
.../distribution/WeibullDistributionTest.java | 4 +-
.../distribution/ZipfDistributionTest.java | 17 +-
pom.xml | 2 +-
.../checkstyle/checkstyle-suppressions.xml | 7 +
src/main/resources/checkstyle/checkstyle.xml | 230 ++++++++++++++-------
36 files changed, 467 insertions(+), 362 deletions(-)
diff --git
a/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/AbstractContinuousDistribution.java
b/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/AbstractContinuousDistribution.java
index 4a54f10..5ff11cf 100644
---
a/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/AbstractContinuousDistribution.java
+++
b/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/AbstractContinuousDistribution.java
@@ -279,7 +279,7 @@ abstract class AbstractContinuousDistribution
* the book
* <blockquote>
* <b>Algorithms for Minimization Without Derivatives</b>,
- * <it>Richard P. Brent</it>,
+ * <i>Richard P. Brent</i>,
* Dover 0-486-41998-3
* </blockquote>
*
diff --git
a/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/AbstractDiscreteDistribution.java
b/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/AbstractDiscreteDistribution.java
index 4a69eb4..37cc174 100644
---
a/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/AbstractDiscreteDistribution.java
+++
b/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/AbstractDiscreteDistribution.java
@@ -179,9 +179,9 @@ abstract class AbstractDiscreteDistribution
/** {@inheritDoc} */
@Override
public DiscreteDistribution.Sampler createSampler(final
UniformRandomProvider rng) {
- // Inversion method distribution sampler.
- final DiscreteSampler sampler =
- new InverseTransformDiscreteSampler(rng,
this::inverseCumulativeProbability);
- return sampler::sample;
+ // Inversion method distribution sampler.
+ final DiscreteSampler sampler =
+ new InverseTransformDiscreteSampler(rng,
this::inverseCumulativeProbability);
+ return sampler::sample;
}
}
diff --git
a/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/GeometricDistribution.java
b/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/GeometricDistribution.java
index 0f8876f..a0758f7 100644
---
a/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/GeometricDistribution.java
+++
b/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/GeometricDistribution.java
@@ -155,6 +155,6 @@ public class GeometricDistribution extends
AbstractDiscreteDistribution {
if (p == 0) {
return 0;
}
- return Math.max(0, (int)
Math.ceil(Math.log1p(-p)/log1mProbabilityOfSuccess-1));
+ return Math.max(0, (int) Math.ceil(Math.log1p(-p) /
log1mProbabilityOfSuccess - 1));
}
}
diff --git
a/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/HypergeometricDistribution.java
b/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/HypergeometricDistribution.java
index d2bdbb0..2482869 100644
---
a/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/HypergeometricDistribution.java
+++
b/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/HypergeometricDistribution.java
@@ -95,7 +95,7 @@ public class HypergeometricDistribution extends
AbstractDiscreteDistribution {
* hypergeometric distribution.
*/
private int[] getDomain(int n, int m, int k) {
- return new int[] { getLowerDomain(n, m, k), getUpperDomain(m, k) };
+ return new int[] {getLowerDomain(n, m, k), getUpperDomain(m, k)};
}
/**
diff --git
a/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/LevyDistribution.java
b/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/LevyDistribution.java
index c61d6da..aab5dc3 100644
---
a/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/LevyDistribution.java
+++
b/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/LevyDistribution.java
@@ -66,7 +66,7 @@ public class LevyDistribution extends
AbstractContinuousDistribution {
final double delta = x - mu;
final double f = halfC / delta;
- return Math.sqrt(f / Math.PI) * Math.exp(-f) /delta;
+ return Math.sqrt(f / Math.PI) * Math.exp(-f) / delta;
}
/** {@inheritDoc}
diff --git
a/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/LogNormalDistribution.java
b/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/LogNormalDistribution.java
index e6bd521..b2f5d00 100644
---
a/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/LogNormalDistribution.java
+++
b/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/LogNormalDistribution.java
@@ -45,9 +45,9 @@ import
org.apache.commons.rng.sampling.distribution.ZigguratNormalizedGaussianSa
* </ul>
*/
public class LogNormalDistribution extends AbstractContinuousDistribution {
- /** √(2 π) */
+ /** √(2 π). */
private static final double SQRT2PI = Math.sqrt(2 * Math.PI);
- /** √(2) */
+ /** √(2). */
private static final double SQRT2 = Math.sqrt(2);
/** The scale parameter of this distribution. */
private final double scale;
diff --git
a/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/NormalDistribution.java
b/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/NormalDistribution.java
index 696fb57..f01abd7 100644
---
a/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/NormalDistribution.java
+++
b/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/NormalDistribution.java
@@ -29,7 +29,7 @@ import
org.apache.commons.rng.sampling.distribution.ZigguratNormalizedGaussianSa
* Implementation of the <a
href="http://en.wikipedia.org/wiki/Normal_distribution";>normal (Gaussian)
distribution</a>.
*/
public class NormalDistribution extends AbstractContinuousDistribution {
- /** √(2) */
+ /** √(2). */
private static final double SQRT2 = Math.sqrt(2.0);
/** Mean of this distribution. */
private final double mean;
diff --git
a/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/SaddlePointExpansion.java
b/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/SaddlePointExpansion.java
index 0ff3dd5..beab24a 100644
---
a/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/SaddlePointExpansion.java
+++
b/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/SaddlePointExpansion.java
@@ -29,43 +29,44 @@ import org.apache.commons.numbers.gamma.LogGamma;
* @since 1.0
*/
/* default */ final class SaddlePointExpansion {
- /** 2 π */
+ /** 2 π. */
private static final double TWO_PI = 2 * Math.PI;
/** 1/2 * log(2 π). */
private static final double HALF_LOG_TWO_PI = 0.5 * Math.log(TWO_PI);
/** exact Stirling expansion error for certain values. */
- private static final double[] EXACT_STIRLING_ERRORS = { 0.0, /* 0.0 */
- 0.1534264097200273452913848, /* 0.5 */
- 0.0810614667953272582196702, /* 1.0 */
- 0.0548141210519176538961390, /* 1.5 */
- 0.0413406959554092940938221, /* 2.0 */
- 0.03316287351993628748511048, /* 2.5 */
- 0.02767792568499833914878929, /* 3.0 */
- 0.02374616365629749597132920, /* 3.5 */
- 0.02079067210376509311152277, /* 4.0 */
- 0.01848845053267318523077934, /* 4.5 */
- 0.01664469118982119216319487, /* 5.0 */
- 0.01513497322191737887351255, /* 5.5 */
- 0.01387612882307074799874573, /* 6.0 */
- 0.01281046524292022692424986, /* 6.5 */
- 0.01189670994589177009505572, /* 7.0 */
- 0.01110455975820691732662991, /* 7.5 */
- 0.010411265261972096497478567, /* 8.0 */
- 0.009799416126158803298389475, /* 8.5 */
- 0.009255462182712732917728637, /* 9.0 */
- 0.008768700134139385462952823, /* 9.5 */
- 0.008330563433362871256469318, /* 10.0 */
- 0.007934114564314020547248100, /* 10.5 */
- 0.007573675487951840794972024, /* 11.0 */
- 0.007244554301320383179543912, /* 11.5 */
- 0.006942840107209529865664152, /* 12.0 */
- 0.006665247032707682442354394, /* 12.5 */
- 0.006408994188004207068439631, /* 13.0 */
- 0.006171712263039457647532867, /* 13.5 */
- 0.005951370112758847735624416, /* 14.0 */
- 0.005746216513010115682023589, /* 14.5 */
- 0.005554733551962801371038690 /* 15.0 */
+ private static final double[] EXACT_STIRLING_ERRORS = {
+ 0.0, /* 0.0 */
+ 0.1534264097200273452913848, /* 0.5 */
+ 0.0810614667953272582196702, /* 1.0 */
+ 0.0548141210519176538961390, /* 1.5 */
+ 0.0413406959554092940938221, /* 2.0 */
+ 0.03316287351993628748511048, /* 2.5 */
+ 0.02767792568499833914878929, /* 3.0 */
+ 0.02374616365629749597132920, /* 3.5 */
+ 0.02079067210376509311152277, /* 4.0 */
+ 0.01848845053267318523077934, /* 4.5 */
+ 0.01664469118982119216319487, /* 5.0 */
+ 0.01513497322191737887351255, /* 5.5 */
+ 0.01387612882307074799874573, /* 6.0 */
+ 0.01281046524292022692424986, /* 6.5 */
+ 0.01189670994589177009505572, /* 7.0 */
+ 0.01110455975820691732662991, /* 7.5 */
+ 0.010411265261972096497478567, /* 8.0 */
+ 0.009799416126158803298389475, /* 8.5 */
+ 0.009255462182712732917728637, /* 9.0 */
+ 0.008768700134139385462952823, /* 9.5 */
+ 0.008330563433362871256469318, /* 10.0 */
+ 0.007934114564314020547248100, /* 10.5 */
+ 0.007573675487951840794972024, /* 11.0 */
+ 0.007244554301320383179543912, /* 11.5 */
+ 0.006942840107209529865664152, /* 12.0 */
+ 0.006665247032707682442354394, /* 12.5 */
+ 0.006408994188004207068439631, /* 13.0 */
+ 0.006171712263039457647532867, /* 13.5 */
+ 0.005951370112758847735624416, /* 14.0 */
+ 0.005746216513010115682023589, /* 14.5 */
+ 0.005554733551962801371038690 /* 15.0 */
};
/**
diff --git
a/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/TDistribution.java
b/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/TDistribution.java
index 5245ca2..e3babf5 100644
---
a/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/TDistribution.java
+++
b/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/TDistribution.java
@@ -25,7 +25,7 @@ import org.apache.commons.numbers.gamma.LogGamma;
public class TDistribution extends AbstractContinuousDistribution {
/** The degrees of freedom. */
private final double degreesOfFreedom;
- /** degreesOfFreedom / 2 */
+ /** degreesOfFreedom / 2. */
private final double dofOver2;
/** Cached value. */
private final double factor;
diff --git
a/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/UniformDiscreteDistribution.java
b/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/UniformDiscreteDistribution.java
index 7d39a2a..b18ae01 100644
---
a/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/UniformDiscreteDistribution.java
+++
b/commons-statistics-distribution/src/main/java/org/apache/commons/statistics/distribution/UniformDiscreteDistribution.java
@@ -26,7 +26,7 @@ import
org.apache.commons.rng.sampling.distribution.DiscreteUniformSampler;
* uniform integer distribution</a>.
*/
public class UniformDiscreteDistribution extends AbstractDiscreteDistribution {
- /** 1 / 12 **/
+ /** 1 / 12. **/
private static final double ONE_TWELFTH = 1 / 12d;
/** Lower bound (inclusive) of this distribution. */
private final int lower;
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 505f768..3bc5bb7 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,21 +28,20 @@ public class AbstractDiscreteDistributionTest {
protected final double p = diceDistribution.probability(1);
@Test
- public void testInverseCumulativeProbabilityMethod()
- {
+ public void testInverseCumulativeProbabilityMethod() {
double precision = 0.000000000000001;
Assert.assertEquals(1,
diceDistribution.inverseCumulativeProbability(0));
- Assert.assertEquals(1,
diceDistribution.inverseCumulativeProbability((1d-Double.MIN_VALUE)/6d));
- Assert.assertEquals(2,
diceDistribution.inverseCumulativeProbability((1d+precision)/6d));
- Assert.assertEquals(2,
diceDistribution.inverseCumulativeProbability((2d-Double.MIN_VALUE)/6d));
- Assert.assertEquals(3,
diceDistribution.inverseCumulativeProbability((2d+precision)/6d));
- Assert.assertEquals(3,
diceDistribution.inverseCumulativeProbability((3d-Double.MIN_VALUE)/6d));
- Assert.assertEquals(4,
diceDistribution.inverseCumulativeProbability((3d+precision)/6d));
- Assert.assertEquals(4,
diceDistribution.inverseCumulativeProbability((4d-Double.MIN_VALUE)/6d));
- Assert.assertEquals(5,
diceDistribution.inverseCumulativeProbability((4d+precision)/6d));
- Assert.assertEquals(5,
diceDistribution.inverseCumulativeProbability((5d-precision)/6d));//Can't use
Double.MIN
- Assert.assertEquals(6,
diceDistribution.inverseCumulativeProbability((5d+precision)/6d));
- Assert.assertEquals(6,
diceDistribution.inverseCumulativeProbability((6d-precision)/6d));//Can't use
Double.MIN
+ Assert.assertEquals(1,
diceDistribution.inverseCumulativeProbability((1d - Double.MIN_VALUE) / 6d));
+ Assert.assertEquals(2,
diceDistribution.inverseCumulativeProbability((1d + precision) / 6d));
+ Assert.assertEquals(2,
diceDistribution.inverseCumulativeProbability((2d - Double.MIN_VALUE) / 6d));
+ Assert.assertEquals(3,
diceDistribution.inverseCumulativeProbability((2d + precision) / 6d));
+ Assert.assertEquals(3,
diceDistribution.inverseCumulativeProbability((3d - Double.MIN_VALUE) / 6d));
+ Assert.assertEquals(4,
diceDistribution.inverseCumulativeProbability((3d + precision) / 6d));
+ Assert.assertEquals(4,
diceDistribution.inverseCumulativeProbability((4d - Double.MIN_VALUE) / 6d));
+ Assert.assertEquals(5,
diceDistribution.inverseCumulativeProbability((4d + precision) / 6d));
+ Assert.assertEquals(5,
diceDistribution.inverseCumulativeProbability((5d - precision) / 6d)); //Can't
use Double.MIN
+ Assert.assertEquals(6,
diceDistribution.inverseCumulativeProbability((5d + precision) / 6d));
+ Assert.assertEquals(6,
diceDistribution.inverseCumulativeProbability((6d - precision) / 6d)); //Can't
use Double.MIN
Assert.assertEquals(6,
diceDistribution.inverseCumulativeProbability(1d));
}
@@ -70,7 +69,7 @@ public class AbstractDiscreteDistributionTest {
upper--;
}
for (int i = 0; i < 6; i++) {
- Assert.assertEquals(p, diceDistribution.probability(i, i+1),
1E-12);
+ Assert.assertEquals(p, diceDistribution.probability(i, i + 1),
1E-12);
}
}
@@ -80,7 +79,7 @@ public class AbstractDiscreteDistributionTest {
class DiceDistribution extends AbstractDiscreteDistribution {
public static final long serialVersionUID = 23734213;
- private final double p = 1d/6d;
+ private final double p = 1d / 6d;
@Override
public double probability(int x) {
@@ -109,7 +108,7 @@ public class AbstractDiscreteDistributionTest {
@Override
public double getVariance() {
- return 70/24; // E(X^2) - E(X)^2
+ return 70 / 24; // E(X^2) - E(X)^2
}
@Override
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 b8c54b2..460bb3c 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
@@ -45,7 +45,7 @@ public class BinomialDistributionTest extends
DiscreteDistributionAbstractTest {
/** Creates the default probability density test input values. */
@Override
public int[] makeDensityTestPoints() {
- return new int[] { -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
+ return new int[] {-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
}
/**
@@ -54,9 +54,9 @@ public class BinomialDistributionTest extends
DiscreteDistributionAbstractTest {
*/
@Override
public double[] makeDensityTestValues() {
- return new double[] { 0d, 0.0000059049d, 0.000137781d, 0.0014467005,
- 0.009001692, 0.036756909, 0.1029193452,
0.200120949, 0.266827932,
- 0.2334744405, 0.121060821, 0.0282475249, 0d };
+ return new double[] {0d, 0.0000059049d, 0.000137781d, 0.0014467005,
+ 0.009001692, 0.036756909, 0.1029193452,
0.200120949, 0.266827932,
+ 0.2334744405, 0.121060821, 0.0282475249, 0d};
}
/** Creates the default cumulative probability density test input values */
@@ -71,15 +71,15 @@ public class BinomialDistributionTest extends
DiscreteDistributionAbstractTest {
*/
@Override
public double[] makeCumulativeTestValues() {
- return new double[] { 0d, 5.9049e-06, 0.0001436859, 0.0015903864,
0.0105920784, 0.0473489874,
- 0.1502683326, 0.3503892816, 0.6172172136,
0.8506916541, 0.9717524751, 1d, 1d };
+ return new double[] {0d, 5.9049e-06, 0.0001436859, 0.0015903864,
0.0105920784, 0.0473489874,
+ 0.1502683326, 0.3503892816, 0.6172172136,
0.8506916541, 0.9717524751, 1d, 1d};
}
/** Creates the default inverse cumulative probability test input values */
@Override
public double[] makeInverseCumulativeTestPoints() {
- return new double[] { 0, 0.001d, 0.010d, 0.025d, 0.050d, 0.100d,
- 0.999d, 0.990d, 0.975d, 0.950d, 0.900d, 1 };
+ return new double[] {0, 0.001d, 0.010d, 0.025d, 0.050d, 0.100d,
+ 0.999d, 0.990d, 0.975d, 0.950d, 0.900d, 1d};
}
/**
@@ -88,7 +88,7 @@ public class BinomialDistributionTest extends
DiscreteDistributionAbstractTest {
*/
@Override
public int[] makeInverseCumulativeTestValues() {
- return new int[] { 0, 2, 3, 4, 5, 5, 10, 10, 10, 9, 9, 10 };
+ return new int[] {0, 2, 3, 4, 5, 5, 10, 10, 10, 9, 9, 10};
}
// ----------------- Additional test cases
---------------------------------
@@ -98,12 +98,12 @@ public class BinomialDistributionTest extends
DiscreteDistributionAbstractTest {
public void testDegenerate0() {
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 });
- setDensityTestPoints(new int[] { -1, 0, 1, 10, 11 });
- setDensityTestValues(new double[] { 0d, 1d, 0d, 0d, 0d });
- setInverseCumulativeTestPoints(new double[] { 0.1d, 0.5d });
- setInverseCumulativeTestValues(new int[] { 0, 0 });
+ setCumulativeTestPoints(new int[] {-1, 0, 1, 5, 10});
+ setCumulativeTestValues(new double[] {0d, 1d, 1d, 1d, 1d});
+ setDensityTestPoints(new int[] {-1, 0, 1, 10, 11});
+ setDensityTestValues(new double[] {0d, 1d, 0d, 0d, 0d});
+ setInverseCumulativeTestPoints(new double[] {0.1d, 0.5d});
+ setInverseCumulativeTestValues(new int[] {0, 0});
verifyDensities();
verifyCumulativeProbabilities();
verifyInverseCumulativeProbabilities();
@@ -116,12 +116,12 @@ public class BinomialDistributionTest extends
DiscreteDistributionAbstractTest {
public void testDegenerate1() {
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 });
- setDensityTestPoints(new int[] { -1, 0, 1, 2, 5, 10 });
- setDensityTestValues(new double[] { 0d, 0d, 0d, 0d, 1d, 0d });
- setInverseCumulativeTestPoints(new double[] { 0.1d, 0.5d });
- setInverseCumulativeTestValues(new int[] { 5, 5 });
+ setCumulativeTestPoints(new int[] {-1, 0, 1, 2, 5, 10});
+ setCumulativeTestValues(new double[] {0d, 0d, 0d, 0d, 1d, 1d});
+ setDensityTestPoints(new int[] {-1, 0, 1, 2, 5, 10});
+ setDensityTestValues(new double[] {0d, 0d, 0d, 0d, 1d, 0d});
+ setInverseCumulativeTestPoints(new double[] {0.1d, 0.5d});
+ setInverseCumulativeTestValues(new int[] {5, 5});
verifyDensities();
verifyCumulativeProbabilities();
verifyInverseCumulativeProbabilities();
@@ -134,12 +134,12 @@ public class BinomialDistributionTest extends
DiscreteDistributionAbstractTest {
public void testDegenerate2() {
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 });
- setDensityTestPoints(new int[] { -1, 0, 1, 2, 5, 10 });
- setDensityTestValues(new double[] { 0d, 1d, 0d, 0d, 0d, 0d });
- setInverseCumulativeTestPoints(new double[] { 0.1d, 0.5d });
- setInverseCumulativeTestValues(new int[] { 0, 0 });
+ setCumulativeTestPoints(new int[] {-1, 0, 1, 2, 5, 10});
+ setCumulativeTestValues(new double[] {0d, 1d, 1d, 1d, 1d, 1d});
+ setDensityTestPoints(new int[] {-1, 0, 1, 2, 5, 10});
+ setDensityTestValues(new double[] {0d, 1d, 0d, 0d, 0d, 0d});
+ setInverseCumulativeTestPoints(new double[] {0.1d, 0.5d});
+ setInverseCumulativeTestValues(new int[] {0, 0});
verifyDensities();
verifyCumulativeProbabilities();
verifyInverseCumulativeProbabilities();
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 7093931..c10ee6a 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
@@ -87,11 +87,11 @@ public class CauchyDistributionTest extends
ContinuousDistributionAbstractTest {
Assert.assertEquals(2.1, distribution.getScale(), 0.0);
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPrecondition1() {
new CauchyDistribution(0, 0);
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPrecondition2() {
new CauchyDistribution(0, -1);
}
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 1db6096..a7020b1 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
@@ -65,7 +65,7 @@ public class ConstantContinuousDistributionTest extends
ContinuousDistributionAb
public void testInverseCumulativeProbabilities() {
ContinuousDistribution dist = getDistribution();
for (double x : getCumulativeTestValues()) {
- Assert.assertEquals(1,dist.inverseCumulativeProbability(x), 0);
+ Assert.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 92af1a4..2c53f5c 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
@@ -274,13 +274,12 @@ public abstract class ContinuousDistributionAbstractTest {
// check that cdf(x, x) = 0
TestUtils.assertEquals(0d,
- distribution.probability
- (cumulativeTestPoints[i],
cumulativeTestPoints[i]),
+
distribution.probability(cumulativeTestPoints[i], cumulativeTestPoints[i]),
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 upper = Math.max(cumulativeTestPoints[i],
cumulativeTestPoints[i - 1]);
+ double lower = Math.min(cumulativeTestPoints[i],
cumulativeTestPoints[i - 1]);
double diff = distribution.cumulativeProbability(upper) -
distribution.cumulativeProbability(lower);
double direct = distribution.probability(lower, upper);
@@ -292,15 +291,15 @@ public abstract class ContinuousDistributionAbstractTest {
/**
* Verifies that illegal arguments are correctly handled
*/
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPrecondition1() {
distribution.probability(1, 0);
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPrecondition2() {
distribution.inverseCumulativeProbability(-1);
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPrecondition3() {
distribution.inverseCumulativeProbability(2);
}
@@ -390,10 +389,16 @@ public abstract class ContinuousDistributionAbstractTest {
this.cumulativeTestValues = cumulativeTestValues;
}
+ /**
+ * @return Returns the densityTestValues.
+ */
protected double[] getDensityTestValues() {
return densityTestValues;
}
+ /**
+ * @param densityTestValues The densityTestValues to set.
+ */
protected void setDensityTestValues(double[] densityTestValues) {
this.densityTestValues = densityTestValues;
}
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 88b49c3..0cc63cf 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
@@ -253,15 +253,15 @@ public abstract class DiscreteDistributionAbstractTest {
upper,
distribution.inverseCumulativeProbability(1.0));
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPrecondition1() {
distribution.probability(1, 0);
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPrecondition2() {
distribution.inverseCumulativeProbability(-1);
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPrecondition3() {
distribution.inverseCumulativeProbability(2);
}
@@ -287,11 +287,11 @@ public abstract class DiscreteDistributionAbstractTest {
1000));
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]) {
- observedCounts[j]++;
- }
- }
+ for (int j = 0; j < length; j++) {
+ if (sample[i] == densityPoints[j]) {
+ observedCounts[j]++;
+ }
+ }
}
TestUtils.assertChiSquareAccept(densityPoints, expectedCounts,
observedCounts, .001);
}
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 f883e54..74c2820 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
@@ -76,9 +76,9 @@ public class ExponentialDistributionTest extends
ContinuousDistributionAbstractT
@Test
public void testInverseCumulativeProbabilityExtremes() {
- setInverseCumulativeTestPoints(new double[] {0, 1});
- setInverseCumulativeTestValues(new double[] {0,
Double.POSITIVE_INFINITY});
- verifyInverseCumulativeProbabilities();
+ setInverseCumulativeTestPoints(new double[] {0, 1});
+ setInverseCumulativeTestValues(new double[] {0,
Double.POSITIVE_INFINITY});
+ verifyInverseCumulativeProbabilities();
}
@Test
@@ -97,7 +97,7 @@ public class ExponentialDistributionTest extends
ContinuousDistributionAbstractT
Assert.assertTrue(Precision.equals(Math.exp(-2), d1.density(2.0), 1));
ExponentialDistribution d2 = new ExponentialDistribution(3);
- Assert.assertTrue(Precision.equals(1/3.0, d2.density(0.0), 1));
+ Assert.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
Assert.assertEquals(0.2388437702, d2.density(1.0), 1e-8);
@@ -111,7 +111,7 @@ public class ExponentialDistributionTest extends
ContinuousDistributionAbstractT
Assert.assertEquals(5d, distribution.getMean(), Double.MIN_VALUE);
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPrecondition1() {
new ExponentialDistribution(0);
}
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 f03d817..09427e8 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
@@ -86,11 +86,11 @@ public class FDistributionTest extends
ContinuousDistributionAbstractTest {
Assert.assertEquals(6d, dist.getDenominatorDegreesOfFreedom(),
Double.MIN_VALUE);
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPrecondition1() {
new FDistribution(0, 1);
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPrecondition2() {
new FDistribution(1, 0);
}
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 92f5c7a..852ac4c 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
@@ -81,11 +81,11 @@ public class GammaDistributionTest extends
ContinuousDistributionAbstractTest {
Assert.assertEquals(2d, distribution.getScale(), 0);
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPrecondition1() {
new GammaDistribution(0, 1);
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPrecondition2() {
new GammaDistribution(1, 0);
}
@@ -108,13 +108,13 @@ public class GammaDistributionTest extends
ContinuousDistributionAbstractTest {
}
private void testProbability(double x, double a, double b, double
expected) {
- GammaDistribution distribution = new GammaDistribution( a, b );
+ GammaDistribution distribution = new GammaDistribution(a, b);
double actual = distribution.cumulativeProbability(x);
Assert.assertEquals("probability for " + x, expected, actual, 10e-4);
}
private void testValue(double expected, double a, double b, double p) {
- GammaDistribution distribution = new GammaDistribution( a, b );
+ GammaDistribution distribution = new GammaDistribution(a, b);
double actual = distribution.inverseCumulativeProbability(p);
Assert.assertEquals("critical value for " + p, expected, actual,
10e-4);
}
diff --git
a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/GeometricDistributionTest.java
b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/GeometricDistributionTest.java
index 0881073..907f4bb 100644
---
a/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/GeometricDistributionTest.java
+++
b/commons-statistics-distribution/src/test/java/org/apache/commons/statistics/distribution/GeometricDistributionTest.java
@@ -43,9 +43,9 @@ public class GeometricDistributionTest extends
DiscreteDistributionAbstractTest
/** Creates the default probability density test input values */
@Override
public int[] makeDensityTestPoints() {
- return new int[] { -1, 0, 1, 2, 3, 4, 5, 6, 7, 8,
- 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
- 19, 20, 21, 22, 23, 24, 25, 26, 27, 28 };
+ return new int[] {-1, 0, 1, 2, 3, 4, 5, 6, 7, 8,
+ 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
+ 19, 20, 21, 22, 23, 24, 25, 26, 27, 28};
}
/**
@@ -57,7 +57,7 @@ public class GeometricDistributionTest extends
DiscreteDistributionAbstractTest
return new double[] {
0d, 0.4, 0.24, 0.144, 0.0864, 0.05184, 0.031104, 0.0186624,
0.01119744, 0.006718464, 0.0040310784, 0.00241864704,
- 0.001451188224,0.0008707129344, 0.00052242776064,
0.000313456656384,
+ 0.001451188224, 0.0008707129344, 0.00052242776064,
0.000313456656384,
0.00018807399383, 0.000112844396298, 6.77066377789e-05,
4.06239826674e-05,
2.43743896004e-05, 1.46246337603e-05, 8.77478025615e-06,
5.26486815369e-06,
3.15892089221e-06, 1.89535253533e-06, 1.1372115212e-06,
6.82326912718e-07,
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 29af162..5ae8d9b 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
@@ -95,7 +95,7 @@ public class HypergeometricDistributionTest extends
DiscreteDistributionAbstract
0.990d, 0.975d, 0.950d, 0.900d, 1d};
}
- /** Creates the default inverse cumulative probability density test
expected values */
+ /** Creates the default inverse cumulative probability density test
expected values. */
@Override
public int[] makeInverseCumulativeTestValues() {
return new int[] {0, 0, 1, 1, 1, 1, 5, 4, 4, 4, 4, 5};
@@ -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);
+ 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);
+ 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);
+ 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});
@@ -157,23 +157,23 @@ public class HypergeometricDistributionTest extends
DiscreteDistributionAbstract
Assert.assertEquals(3, dist.getSupportUpperBound());
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPrecondition1() {
new HypergeometricDistribution(0, 3, 5);
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPrecondition2() {
new HypergeometricDistribution(5, -1, 5);
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPrecondition3() {
new HypergeometricDistribution(5, 3, -1);
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPrecondition4() {
new HypergeometricDistribution(5, 6, 5);
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPrecondition5() {
new HypergeometricDistribution(5, 3, 6);
}
@@ -215,21 +215,22 @@ public class HypergeometricDistributionTest extends
DiscreteDistributionAbstract
testHypergeometricDistributionProbabilities(populationSize,
sampleSize, numberOfSucceses, data);
}
- private void testHypergeometricDistributionProbabilities(int
populationSize, int sampleSize, int numberOfSucceses, double[][] data) {
+ private void testHypergeometricDistributionProbabilities(int
populationSize, int sampleSize,
+ int numberOfSucceses, double[][] data) {
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);
- TestUtils.assertRelativelyEquals("Expected equals for <"+x+">
pmf",pmf, actualPmf, 1.0e-9);
+ TestUtils.assertRelativelyEquals("Expected equals for <" + x + ">
pmf", pmf, actualPmf, 1.0e-9);
double cdf = data[i][2];
double actualCdf = dist.cumulativeProbability(x);
- TestUtils.assertRelativelyEquals("Expected equals for <"+x+">
cdf",cdf, actualCdf, 1.0e-9);
+ TestUtils.assertRelativelyEquals("Expected equals for <" + x + ">
cdf", cdf, actualCdf, 1.0e-9);
double cdf1 = data[i][3];
double actualCdf1 = dist.upperCumulativeProbability(x);
- TestUtils.assertRelativelyEquals("Expected equals for <"+x+">
cdf1",cdf1, actualCdf1, 1.0e-9);
+ TestUtils.assertRelativelyEquals("Expected equals for <" + x + ">
cdf1", cdf1, actualCdf1, 1.0e-9);
}
}
@@ -268,20 +269,20 @@ public class HypergeometricDistributionTest extends
DiscreteDistributionAbstract
dist = new HypergeometricDistribution(1500, 40, 100);
Assert.assertEquals(40d * 100d / 1500d, dist.getMean(), tol);
- Assert.assertEquals(( 100d * 40d * (1500d - 100d) * (1500d - 40d) ) /
( (1500d * 1500d * 1499d) ), dist.getVariance(), tol);
+ Assert.assertEquals((100d * 40d * (1500d - 100d) * (1500d - 40d)) /
((1500d * 1500d * 1499d)), dist.getVariance(), tol);
dist = new HypergeometricDistribution(3000, 55, 200);
Assert.assertEquals(55d * 200d / 3000d, dist.getMean(), tol);
- Assert.assertEquals(( 200d * 55d * (3000d - 200d) * (3000d - 55d) ) /
( (3000d * 3000d * 2999d) ), dist.getVariance(), tol);
+ Assert.assertEquals((200d * 55d * (3000d - 200d) * (3000d - 55d)) /
((3000d * 3000d * 2999d)), dist.getVariance(), tol);
}
@Test
public void testMath644() {
- int N = 14761461; // population
- int m = 1035; // successes in population
- int n = 1841; // number of trials
+ final int N = 14761461; // population
+ final int m = 1035; // successes in population
+ final int n = 1841; // number of trials
- int k = 0;
+ final int k = 0;
final HypergeometricDistribution dist = new
HypergeometricDistribution(N, m, n);
Assert.assertTrue(Precision.compareTo(1.0,
dist.upperCumulativeProbability(k), 1) == 0);
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 11274b8..36cae39 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
@@ -39,27 +39,27 @@ public class LogNormalDistributionTest extends
ContinuousDistributionAbstractTes
@Override
public double[] makeCumulativeTestPoints() {
// quantiles computed using R
- return new double[] { -2.226325228634938, -1.156887023657177,
- -0.643949578356075, -0.2027950777320613,
- 0.305827808237559, 6.42632522863494,
- 5.35688702365718, 4.843949578356074,
- 4.40279507773206, 3.89417219176244 };
+ return new double[] {-2.226325228634938, -1.156887023657177,
+ -0.643949578356075, -0.2027950777320613,
+ 0.305827808237559, 6.42632522863494,
+ 5.35688702365718, 4.843949578356074,
+ 4.40279507773206, 3.89417219176244};
}
/** Creates the default cumulative probability density test expected
values */
@Override
public double[] makeCumulativeTestValues() {
- return new double[] { 0, 0, 0, 0, 0.00948199951485, 0.432056525076,
- 0.381648158697, 0.354555726206, 0.329513316888,
- 0.298422824228 };
+ return new double[] {0, 0, 0, 0, 0.00948199951485, 0.432056525076,
+ 0.381648158697, 0.354555726206, 0.329513316888,
+ 0.298422824228};
}
/** Creates the default probability density test expected values */
@Override
public double[] makeDensityTestValues() {
- return new double[] { 0, 0, 0, 0, 0.0594218160072, 0.0436977691036,
- 0.0508364857798, 0.054873528325, 0.0587182664085,
- 0.0636229042785 };
+ return new double[] {0, 0, 0, 0, 0.0594218160072, 0.0436977691036,
+ 0.0508364857798, 0.054873528325, 0.0587182664085,
+ 0.0636229042785};
}
/**
@@ -107,10 +107,10 @@ public class LogNormalDistributionTest extends
ContinuousDistributionAbstractTes
LogNormalDistribution distribution =
(LogNormalDistribution)getDistribution();
double mu = distribution.getScale();
double sigma = distribution.getShape();
- setCumulativeTestPoints( new double[] { mu - 2 *sigma, mu - sigma,
- mu, mu + sigma, mu + 2 * sigma,
- mu + 3 * sigma,mu + 4 * sigma,
- mu + 5 * sigma });
+ setCumulativeTestPoints(new double[] {mu - 2 * sigma, mu - sigma,
+ mu, mu + sigma,
+ mu + 2 * sigma, mu + 3 * sigma,
+ mu + 4 * sigma, mu + 5 * sigma});
verifyCumulativeProbabilities();
}
@@ -170,22 +170,22 @@ public class LogNormalDistributionTest extends
ContinuousDistributionAbstractTes
Assert.assertEquals(1.4, distribution.getShape(), 0);
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPrecondition1() {
new LogNormalDistribution(1, 0);
}
@Test
public void testDensity() {
- double [] x = new double[]{-2, -1, 0, 1, 2};
+ 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,
- 0.1568740193 });
+ checkDensity(0, 1, x, new double[] {0.0000000000, 0.0000000000,
+ 0.0000000000, 0.3989422804,
+ 0.1568740193});
// R 2.13: print(dlnorm(c(-2,-1,0,1,2), mean=1.1), digits=10)
- checkDensity(1.1, 1, x, new double[] { 0.0000000000, 0.0000000000,
- 0.0000000000, 0.2178521770,
- 0.1836267118});
+ checkDensity(1.1, 1, x, new double[] {0.0000000000, 0.0000000000,
+ 0.0000000000, 0.2178521770,
+ 0.1836267118});
}
private void checkDensity(double scale,
@@ -209,8 +209,7 @@ public class LogNormalDistributionTest extends
ContinuousDistributionAbstractTes
double upperTail = d.cumulativeProbability(i);
if (i <= 72) { // make sure not top-coded
Assert.assertTrue(upperTail < 1.0d);
- }
- else { // make sure top coding not reversed
+ } else { // make sure top coding not reversed
Assert.assertTrue(upperTail > 0.99999);
}
}
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 872e31f..8c568d8 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
@@ -43,21 +43,21 @@ public class NormalDistributionTest extends
ContinuousDistributionAbstractTest {
public double[] makeCumulativeTestPoints() {
// quantiles computed using R
return new double[] {-2.226325228634938d, -1.156887023657177d,
-0.643949578356075d, -0.2027950777320613d, 0.305827808237559d,
- 6.42632522863494d, 5.35688702365718d, 4.843949578356074d,
4.40279507773206d, 3.89417219176244d};
+ 6.42632522863494d, 5.35688702365718d,
4.843949578356074d, 4.40279507773206d, 3.89417219176244d};
}
/** Creates the default cumulative probability density test expected
values */
@Override
public double[] makeCumulativeTestValues() {
return new double[] {0.001d, 0.01d, 0.025d, 0.05d, 0.1d, 0.999d,
- 0.990d, 0.975d, 0.950d, 0.900d};
+ 0.990d, 0.975d, 0.950d, 0.900d};
}
/** Creates the default probability density test expected values */
@Override
public double[] makeDensityTestValues() {
return new double[] {0.00240506434076, 0.0190372444310,
0.0417464784322, 0.0736683145538, 0.125355951380,
- 0.00240506434076, 0.0190372444310, 0.0417464784322,
0.0736683145538, 0.125355951380};
+ 0.00240506434076, 0.0190372444310,
0.0417464784322, 0.0736683145538, 0.125355951380};
}
// --------------------- Override tolerance --------------
@@ -73,9 +73,10 @@ public class NormalDistributionTest extends
ContinuousDistributionAbstractTest {
NormalDistribution distribution = (NormalDistribution)
getDistribution();
double mu = distribution.getMean();
double sigma = distribution.getStandardDeviation();
- setCumulativeTestPoints( new double[] {mu - 2 *sigma, mu - sigma,
- mu, mu + sigma, mu + 2 * sigma,
mu + 3 * sigma, mu + 4 * sigma,
- mu + 5 * sigma});
+ setCumulativeTestPoints(new double[] {mu - 2 * sigma, mu - sigma,
+ mu, mu + sigma,
+ mu + 2 * sigma, mu + 3 * sigma,
+ mu + 4 * sigma, mu + 5 * sigma});
// Quantiles computed using R (same as Mathematica)
setCumulativeTestValues(new double[] {0.02275013194817921,
0.158655253931457, 0.5, 0.841344746068543,
0.977249868051821,
0.99865010196837, 0.999968328758167, 0.999999713348428});
@@ -132,18 +133,18 @@ public class NormalDistributionTest extends
ContinuousDistributionAbstractTest {
Assert.assertEquals(1.4, distribution.getStandardDeviation(), 0);
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPrecondition1() {
new NormalDistribution(1, 0);
}
@Test
public void testDensity() {
- double [] x = new double[]{-2, -1, 0, 1, 2};
+ 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});
+ 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)
- checkDensity(1.1, 1, x, new
double[]{0.003266819056,0.043983595980,0.217852177033,0.396952547477,0.266085249899});
+ checkDensity(1.1, 1, x, new double[] {0.003266819056,
0.043983595980, 0.217852177033, 0.396952547477, 0.266085249899});
}
private void checkDensity(double mean, double sd, double[] x, double[]
expected) {
@@ -168,8 +169,7 @@ public class NormalDistributionTest extends
ContinuousDistributionAbstractTest {
// TODO: once MATH-364 is resolved, replace 9 with 30
Assert.assertTrue(lowerTail > 0.0d);
Assert.assertTrue(upperTail < 1.0d);
- }
- else { // make sure top coding not reversed
+ } else { // make sure top coding not reversed
Assert.assertTrue(lowerTail < 0.00001);
Assert.assertTrue(upperTail > 0.99999);
}
@@ -183,7 +183,7 @@ public class NormalDistributionTest extends
ContinuousDistributionAbstractTest {
@Test
public void testMath280() {
- NormalDistribution normal = new NormalDistribution(0,1);
+ NormalDistribution normal = new NormalDistribution(0, 1);
double result =
normal.inverseCumulativeProbability(0.9986501019683698);
Assert.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 ed32b0b..f2263ca 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
@@ -38,20 +38,20 @@ public class ParetoDistributionTest extends
ContinuousDistributionAbstractTest {
@Override
public double[] makeCumulativeTestPoints() {
// quantiles computed using R
- return new double[] { -2.226325228634938, -1.156887023657177,
-0.643949578356075, -0.2027950777320613, 0.305827808237559,
- +6.42632522863494, 5.35688702365718,
4.843949578356074, 4.40279507773206, 3.89417219176244 };
+ return new double[] {-2.226325228634938, -1.156887023657177,
-0.643949578356075, -0.2027950777320613, 0.305827808237559,
+ +6.42632522863494, 5.35688702365718,
4.843949578356074, 4.40279507773206, 3.89417219176244};
}
/** Creates the default cumulative probability density test expected
values */
@Override
public double[] makeCumulativeTestValues() {
- return new double[] { 0, 0, 0, 0, 0, 0.791089998892, 0.730456085931,
0.689667290488, 0.645278794701, 0.578763688757 };
+ return new double[] {0, 0, 0, 0, 0, 0.791089998892, 0.730456085931,
0.689667290488, 0.645278794701, 0.578763688757};
}
/** Creates the default probability density test expected values */
@Override
public double[] makeDensityTestValues() {
- return new double[] { 0, 0, 0, 0, 0, 0.0455118580441, 0.070444173646,
0.0896924681582, 0.112794186114, 0.151439332084 };
+ return new double[] {0, 0, 0, 0, 0, 0.0455118580441, 0.070444173646,
0.0896924681582, 0.112794186114, 0.151439332084};
}
/**
@@ -95,10 +95,10 @@ public class ParetoDistributionTest extends
ContinuousDistributionAbstractTest {
ParetoDistribution distribution =
(ParetoDistribution)getDistribution();
double mu = distribution.getScale();
double sigma = distribution.getShape();
- setCumulativeTestPoints( new double[] { mu - 2 *sigma, mu - sigma,
- mu, mu + sigma,
- mu + 2 * sigma, mu + 3 * sigma,
- mu + 4 * sigma, mu + 5 * sigma
});
+ setCumulativeTestPoints(new double[] {mu - 2 * sigma, mu - sigma,
+ mu, mu + sigma,
+ mu + 2 * sigma, mu + 3 * sigma,
+ mu + 4 * sigma, mu + 5 * sigma});
verifyCumulativeProbabilities();
}
@@ -141,18 +141,18 @@ public class ParetoDistributionTest extends
ContinuousDistributionAbstractTest {
Assert.assertEquals(1.4, distribution.getShape(), 0);
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPrecondition1() {
new ParetoDistribution(1, 0);
}
@Test
public void testDensity() {
- double [] x = new double[]{-2, -1, 0, 1, 2};
+ 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 });
+ 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)
- checkDensity(1.1, 1, x, new double[] { 0.000, 0.000, 0.000, 0.000,
0.275 });
+ checkDensity(1.1, 1, x, new double[] {0.000, 0.000, 0.000, 0.000,
0.275});
}
private void checkDensity(double scale, double shape, double[] x,
@@ -173,8 +173,7 @@ public class ParetoDistributionTest extends
ContinuousDistributionAbstractTest {
double upperTail = d.cumulativeProbability(i);
if (i <= 1000) { // make sure not top-coded
Assert.assertTrue(upperTail < 1.0d);
- }
- else { // make sure top coding not reversed
+ } else { // make sure top coding not reversed
Assert.assertTrue(upperTail > 0.999);
}
}
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 aa95478..cbbc895 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
@@ -29,6 +29,7 @@ public class PascalDistributionTest extends
DiscreteDistributionAbstractTest {
// --------------------- Override tolerance --------------
protected double defaultTolerance = 1e-7;
+
@Override
public void setUp() {
super.setUp();
@@ -40,48 +41,48 @@ public class PascalDistributionTest extends
DiscreteDistributionAbstractTest {
/** Creates the default discrete distribution instance to use in tests. */
@Override
public DiscreteDistribution makeDistribution() {
- return new PascalDistribution(10,0.70);
+ return new PascalDistribution(10, 0.70);
}
/** Creates the default probability density test input values */
@Override
public int[] makeDensityTestPoints() {
- return new int[] {-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
+ return new int[] {-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
}
/** Creates the default probability density test expected values */
@Override
public double[] makeDensityTestValues() {
- return new double[] {0, 0.0282475249, 0.0847425747, 0.139825248255,
0.167790297906, 0.163595540458,
- 0.137420253985, 0.103065190489, 0.070673273478,
0.0450542118422, 0.0270325271053,
- 0.0154085404500, 0.0084046584273};
+ return new double[] {0, 0.0282475249, 0.0847425747, 0.139825248255,
0.167790297906, 0.163595540458,
+ 0.137420253985, 0.103065190489, 0.070673273478,
0.0450542118422, 0.0270325271053,
+ 0.0154085404500, 0.0084046584273};
}
/** Creates the default cumulative probability density test input values */
@Override
public int[] makeCumulativeTestPoints() {
- return makeDensityTestPoints();
+ return makeDensityTestPoints();
}
/** Creates the default cumulative probability density test expected
values */
@Override
public double[] makeCumulativeTestValues() {
- return new double[] {0, 0.0282475249, 0.1129900996, 0.252815347855,
0.420605645761, 0.584201186219,
- 0.721621440204, 0.824686630693, 0.895359904171,
0.940414116013, 0.967446643119,
- 0.982855183569, 0.991259841996};
- }
+ return new double[] {0, 0.0282475249, 0.1129900996, 0.252815347855,
0.420605645761, 0.584201186219,
+ 0.721621440204, 0.824686630693, 0.895359904171,
0.940414116013, 0.967446643119,
+ 0.982855183569, 0.991259841996};
+ }
/** Creates the default inverse cumulative probability test input values */
@Override
public double[] makeInverseCumulativeTestPoints() {
- return new double[] {0.0, 0.001, 0.010, 0.025, 0.050, 0.100, 0.999,
- 0.990, 0.975, 0.950, 0.900, 1.0};
- }
+ return new double[] {0.0, 0.001, 0.010, 0.025, 0.050, 0.100, 0.999,
+ 0.990, 0.975, 0.950, 0.900, 1.0};
+ }
/** Creates the default inverse cumulative probability density test
expected values */
@Override
public int[] makeInverseCumulativeTestValues() {
- return new int[] {0, 0, 0, 0, 1, 1, 14, 11, 10, 9, 8, Integer.MAX_VALUE};
+ return new int[] {0, 0, 0, 0, 1, 1, 14, 11, 10, 9, 8,
Integer.MAX_VALUE};
}
//----------------- Additional test cases ---------------------------------
@@ -122,11 +123,11 @@ public class PascalDistributionTest extends
DiscreteDistributionAbstractTest {
PascalDistribution dist;
dist = new PascalDistribution(10, 0.5);
- Assert.assertEquals(( 10d * 0.5d ) / 0.5d, dist.getMean(), tol);
- Assert.assertEquals(( 10d * 0.5d ) / (0.5d * 0.5d),
dist.getVariance(), tol);
+ Assert.assertEquals((10d * 0.5d) / 0.5d, dist.getMean(), tol);
+ Assert.assertEquals((10d * 0.5d) / (0.5d * 0.5d), dist.getVariance(),
tol);
dist = new PascalDistribution(25, 0.7);
- Assert.assertEquals(( 25d * 0.3d ) / 0.7d, dist.getMean(), tol);
- Assert.assertEquals(( 25d * 0.3d ) / (0.7d * 0.7d),
dist.getVariance(), tol);
+ Assert.assertEquals((25d * 0.3d) / 0.7d, dist.getMean(), tol);
+ Assert.assertEquals((25d * 0.3d) / (0.7d * 0.7d), dist.getVariance(),
tol);
}
}
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 ed85600..e34435b 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
@@ -50,7 +50,7 @@ public class PoissonDistributionTest extends
DiscreteDistributionAbstractTest {
*/
@Override
public int[] makeDensityTestPoints() {
- return new int[] { -1, 0, 1, 2, 3, 4, 5, 10, 20};
+ return new int[] {-1, 0, 1, 2, 3, 4, 5, 10, 20};
}
/**
@@ -59,9 +59,9 @@ public class PoissonDistributionTest extends
DiscreteDistributionAbstractTest {
*/
@Override
public double[] makeDensityTestValues() {
- return new double[] { 0d, 0.0183156388887d, 0.073262555555d,
- 0.14652511111d, 0.195366814813d, 0.195366814813,
- 0.156293451851d, 0.00529247667642d,
8.27746364655e-09};
+ return new double[] {0d, 0.0183156388887d, 0.073262555555d,
+ 0.14652511111d, 0.195366814813d, 0.195366814813,
+ 0.156293451851d, 0.00529247667642d,
8.27746364655e-09};
}
/**
@@ -70,10 +70,10 @@ public class PoissonDistributionTest extends
DiscreteDistributionAbstractTest {
*/
@Override
public double[] makeLogDensityTestValues() {
- return new double[] { Double.NEGATIVE_INFINITY, -4.000000000000d,
- -2.613705638880d, -1.920558458320d,
-1.632876385868d,
- -1.632876385868d, -1.856019937183d,
-5.241468961877d,
- -18.609729238356d};
+ return new double[] {Double.NEGATIVE_INFINITY, -4.000000000000d,
+ -2.613705638880d, -1.920558458320d,
-1.632876385868d,
+ -1.632876385868d, -1.856019937183d,
-5.241468961877d,
+ -18.609729238356d};
}
/**
@@ -81,7 +81,7 @@ public class PoissonDistributionTest extends
DiscreteDistributionAbstractTest {
*/
@Override
public int[] makeCumulativeTestPoints() {
- return new int[] { -1, 0, 1, 2, 3, 4, 5, 10, 20 };
+ return new int[] {-1, 0, 1, 2, 3, 4, 5, 10, 20};
}
/**
@@ -89,9 +89,9 @@ public class PoissonDistributionTest extends
DiscreteDistributionAbstractTest {
*/
@Override
public double[] makeCumulativeTestValues() {
- return new double[] { 0d, 0.0183156388887d, 0.0915781944437d,
- 0.238103305554d, 0.433470120367d, 0.62883693518,
- 0.78513038703d, 0.99716023388d, 0.999999998077
};
+ return new double[] {0d, 0.0183156388887d, 0.0915781944437d,
+ 0.238103305554d, 0.433470120367d, 0.62883693518,
+ 0.78513038703d, 0.99716023388d, 0.999999998077};
}
/**
@@ -100,11 +100,11 @@ public class PoissonDistributionTest extends
DiscreteDistributionAbstractTest {
@Override
public double[] makeInverseCumulativeTestPoints() {
DiscreteDistribution dist = getDistribution();
- return new double[] { 0d, 0.018315638886d, 0.018315638890d,
- 0.091578194441d, 0.091578194445d,
0.238103305552d,
- 0.238103305556d, dist.cumulativeProbability(3),
- dist.cumulativeProbability(4),
dist.cumulativeProbability(5),
- dist.cumulativeProbability(10),
dist.cumulativeProbability(20)};
+ return new double[] {0d, 0.018315638886d, 0.018315638890d,
+ 0.091578194441d, 0.091578194445d, 0.238103305552d,
+ 0.238103305556d, dist.cumulativeProbability(3),
+ dist.cumulativeProbability(4),
dist.cumulativeProbability(5),
+ dist.cumulativeProbability(10),
dist.cumulativeProbability(20)};
}
/**
@@ -112,7 +112,7 @@ public class PoissonDistributionTest extends
DiscreteDistributionAbstractTest {
*/
@Override
public int[] makeInverseCumulativeTestValues() {
- return new int[] { 0, 0, 1, 1, 2, 2, 3, 3, 4, 5, 10, 20};
+ return new int[] {0, 0, 1, 1, 2, 2, 3, 3, 4, 5, 10, 20};
}
/**
@@ -143,7 +143,7 @@ public class PoissonDistributionTest extends
DiscreteDistributionAbstractTest {
Assert.assertEquals(0, dist.inverseCumulativeProbability(0d));
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testNegativeMean() {
new PoissonDistribution(-1);
}
@@ -168,7 +168,7 @@ public class PoissonDistributionTest extends
DiscreteDistributionAbstractTest {
try {
p = dist.cumulativeProbability((int) x);
Assert.assertFalse("NaN cumulative probability returned
for mean = " +
- mean + " x = " + x,Double.isNaN(p));
+ mean + " x = " + x, Double.isNaN(p));
if (x > mean - 2 * sigma) {
Assert.assertTrue("Zero cum probaility returned for
mean = " +
mean + " x = " + x, p > 0);
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 1b06362..e2fc246 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
@@ -80,11 +80,13 @@ public class TDistributionTest extends
ContinuousDistributionAbstractTest {
setDistribution(new TDistribution(1d));
// quantiles computed using R version 2.9.2
setCumulativeTestPoints(new double[] {-318.308838986, -31.8205159538,
-12.7062047362,
- -6.31375151468, -3.07768353718,
318.308838986, 31.8205159538, 12.7062047362,
- 6.31375151468, 3.07768353718});
+ -6.31375151468, -3.07768353718,
318.308838986,
+ 31.8205159538, 12.7062047362,
6.31375151468,
+ 3.07768353718});
setDensityTestValues(new double[] {3.14158231817e-06,
0.000314055924703, 0.00195946145194,
- 0.00778959736375, 0.0303958893917,
3.14158231817e-06, 0.000314055924703,
- 0.00195946145194, 0.00778959736375,
0.0303958893917});
+ 0.00778959736375, 0.0303958893917,
3.14158231817e-06,
+ 0.000314055924703,
0.00195946145194, 0.00778959736375,
+ 0.0303958893917});
setInverseCumulativeTestValues(getCumulativeTestPoints());
verifyCumulativeProbabilities();
verifyInverseCumulativeProbabilities();
@@ -116,7 +118,7 @@ public class TDistributionTest extends
ContinuousDistributionAbstractTest {
Assert.assertEquals(5d, dist.getDegreesOfFreedom(), Double.MIN_VALUE);
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPreconditions() {
new TDistribution(0);
}
@@ -146,22 +148,22 @@ public class TDistributionTest extends
ContinuousDistributionAbstractTest {
* Have chosen problevels from 0.10 to 0.001
*/
@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};
+ 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};
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);
TestUtils.assertEquals(prob, makeNistResults(args100, 100), 1.0e-4);
return;
}
- private double[] makeNistResults(double[] args, int df){
+ private double[] makeNistResults(double[] args, int df) {
TDistribution td = new TDistribution(df);
- double[] res = new double[ args.length ];
- for( int i = 0 ; i < res.length ; i++){
+ double[] res = new double[args.length];
+ for (int i = 0; i < res.length; i++) {
res[i] = 1.0 - td.cumulativeProbability(args[i]);
}
return res;
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 c2d4eb0..c750df4 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
@@ -23,9 +23,9 @@ import org.apache.commons.numbers.core.Precision;
import org.junit.Assert;
/**
- *
+ * Test utilities.
*/
-public class TestUtils {
+public final class TestUtils {
/**
* Collection of static methods used in math unit tests.
*/
@@ -50,7 +50,7 @@ public class TestUtils {
double actual,
double delta) {
// check for NaN
- if(Double.isNaN(expected)){
+ if (Double.isNaN(expected)) {
Assert.assertTrue("" + actual + " is not NaN.",
Double.isNaN(actual));
} else {
@@ -61,8 +61,8 @@ public class TestUtils {
/**
* Verifies that two double arrays have equal entries, up to tolerance
*/
- public static void assertEquals(double expected[],
- double observed[],
+ public static void assertEquals(double[] expected,
+ double[] observed,
double tolerance) {
assertEquals("Array comparison failure", expected, observed,
tolerance);
}
@@ -125,7 +125,7 @@ public class TestUtils {
Assert.fail(out.toString());
}
boolean failure = false;
- for (int i=0; i < expected.length; i++) {
+ for (int i = 0; i < expected.length; i++) {
if (!Precision.equalsIncludingNaN(expected[i], observed[i],
tolerance)) {
failure = true;
out.append("\n Elements at index ");
@@ -273,8 +273,8 @@ public class TestUtils {
j++;
}
}
- System.arraycopy(newPoints,0,densityPoints,0,positiveMassCount);
- System.arraycopy(newValues,0,densityValues,0,positiveMassCount);
+ System.arraycopy(newPoints, 0, densityPoints, 0,
positiveMassCount);
+ System.arraycopy(newValues, 0, densityValues, 0,
positiveMassCount);
}
return positiveMassCount;
}
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 0aab384..d4ac77b 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
@@ -76,15 +76,14 @@ public class TriangularDistributionTest extends
ContinuousDistributionAbstractTe
double third = 1 / 3.0;
double left = 18.75;
double area = 56.25;
- return new double[] { 0.0,
- 0.0,
- 0.75 / area, 3 / area, 6.75 / area, 12 / area,
- third,
- (left + 7.125) / area, (left + 13.5) / area,
- (left + 36) / area, (left + 37.125) / area,
- 1.0,
- 1.0
- };
+ return new double[] {0.0,
+ 0.0,
+ 0.75 / area, 3 / area, 6.75 / area, 12 / area,
+ third,
+ (left + 7.125) / area, (left + 13.5) / area,
+ (left + 36) / area, (left + 37.125) / area,
+ 1.0,
+ 1.0};
}
/**
@@ -97,7 +96,7 @@ public class TriangularDistributionTest extends
ContinuousDistributionAbstractTe
// 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];
+ 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);
@@ -113,7 +112,7 @@ public class TriangularDistributionTest extends
ContinuousDistributionAbstractTe
// 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];
+ 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);
@@ -122,14 +121,13 @@ public class TriangularDistributionTest extends
ContinuousDistributionAbstractTe
/** Creates the default probability density test expected values. */
@Override
public double[] makeDensityTestValues() {
- return new double[] { 0,
- 0,
- 2 / 75.0, 4 / 75.0, 6 / 75.0, 8 / 75.0,
- 10 / 75.0,
- 9 / 75.0, 8 / 75.0, 2 / 75.0, 1 / 75.0,
- 0,
- 0
- };
+ return new double[] {0,
+ 0,
+ 2 / 75.0, 4 / 75.0, 6 / 75.0, 8 / 75.0,
+ 10 / 75.0,
+ 9 / 75.0, 8 / 75.0, 2 / 75.0, 1 / 75.0,
+ 0,
+ 0};
}
//--- Additional test cases -----------------------------------------------
@@ -149,25 +147,25 @@ public class TriangularDistributionTest extends
ContinuousDistributionAbstractTe
}
/** Test pre-condition for equal lower/upper limit. */
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPreconditions1() {
new TriangularDistribution(0, 0, 0);
}
/** Test pre-condition for lower limit larger than upper limit. */
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPreconditions2() {
new TriangularDistribution(1, 1, 0);
}
/** Test pre-condition for mode larger than upper limit. */
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPreconditions3() {
new TriangularDistribution(0, 2, 1);
}
/** Test pre-condition for mode smaller than lower limit. */
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPreconditions4() {
new TriangularDistribution(2, 1, 3);
}
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 aab015b..8256af8 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
@@ -52,9 +52,9 @@ public class UniformContinuousDistributionTest extends
ContinuousDistributionAbs
/** Creates the default cumulative probability density test expected
values */
@Override
public double[] makeCumulativeTestValues() {
- return new double[] {0.0, 0.0, 0.0001, 0.25/1.75, 0.4999/1.75,
- 0.5/1.75, 0.5001/1.75, 0.75/1.75, 1.5/1.75,
- 1.7499/1.75, 1.0, 1.0};
+ return new double[] {0.0, 0.0, 0.0001, 0.25 / 1.75, 0.4999 / 1.75,
+ 0.5 / 1.75, 0.5001 / 1.75, 0.75 / 1.75, 1.5 /
1.75,
+ 1.7499 / 1.75, 1.0, 1.0};
}
/** Creates the default probability density test expected values */
@@ -81,13 +81,13 @@ public class UniformContinuousDistributionTest extends
ContinuousDistributionAbs
}
/** Test pre-condition for equal lower/upper bound. */
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPreconditions1() {
new UniformContinuousDistribution(0, 0);
}
/** Test pre-condition for lower bound larger than upper bound. */
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPreconditions2() {
new UniformContinuousDistribution(1, 0);
}
@@ -99,7 +99,7 @@ public class UniformContinuousDistributionTest extends
ContinuousDistributionAbs
dist = new UniformContinuousDistribution(0, 1);
Assert.assertEquals(0.5, dist.getMean(), 0);
- Assert.assertEquals(1/12.0, dist.getVariance(), 0);
+ Assert.assertEquals(1 / 12.0, dist.getVariance(), 0);
dist = new UniformContinuousDistribution(-1.5, 0.6);
Assert.assertEquals(-0.45, dist.getMean(), 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 a58ab0c..419aa99 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
@@ -99,7 +99,7 @@ public class UniformDiscreteDistributionTest extends
DiscreteDistributionAbstrac
}
// MATH-1141
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPreconditionUpperBoundInclusive1() {
new UniformDiscreteDistribution(1, 0);
}
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 33ba189..ee80123 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
@@ -82,7 +82,7 @@ public class WeibullDistributionTest extends
ContinuousDistributionAbstractTest
WeibullDistribution dist = new WeibullDistribution(1, 2);
Assert.assertEquals(1, dist.getShape(), 0);
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPrecondition1() {
new WeibullDistribution(0, 2);
}
@@ -92,7 +92,7 @@ public class WeibullDistributionTest extends
ContinuousDistributionAbstractTest
WeibullDistribution dist = new WeibullDistribution(1, 2);
Assert.assertEquals(2, dist.getScale(), 0);
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPrecondition2() {
new WeibullDistribution(1, 0);
}
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 c43328c..b542893 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
@@ -35,12 +35,12 @@ public class ZipfDistributionTest extends
DiscreteDistributionAbstractTest {
setTolerance(1e-12);
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPreconditions1() {
new ZipfDistribution(0, 1);
}
- @Test(expected=IllegalArgumentException.class)
+ @Test(expected = IllegalArgumentException.class)
public void testPreconditions2() {
new ZipfDistribution(1, 0);
}
@@ -137,25 +137,26 @@ public class ZipfDistributionTest extends
DiscreteDistributionAbstractTest {
for (double exponent : exponentValues) {
double weightSum = 0.;
double[] weights = new double[numPoints];
- for (int i = numPoints; i>=1; i-=1) {
- weights[i-1] = Math.pow(i, -exponent);
- weightSum += weights[i-1];
+ for (int i = numPoints; i >= 1; i -= 1) {
+ weights[i - 1] = Math.pow(i, -exponent);
+ weightSum += weights[i - 1];
}
// 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 =
- new ZipfDistribution(numPoints,
exponent).createSampler(RandomSource.create(RandomSource.WELL_19937_C, 6));
+ new ZipfDistribution(numPoints, exponent).createSampler(
+ RandomSource.create(RandomSource.WELL_19937_C, 6));
double[] expectedCounts = new double[numPoints];
long[] observedCounts = new long[numPoints];
for (int i = 0; i < numPoints; i++) {
- expectedCounts[i] = sampleSize * (weights[i]/weightSum);
+ expectedCounts[i] = sampleSize * (weights[i] / weightSum);
}
int[] sample = AbstractDiscreteDistribution.sample(sampleSize,
distribution);
for (int s : sample) {
- observedCounts[s-1]++;
+ observedCounts[s - 1]++;
}
TestUtils.assertChiSquareAccept(expectedCounts,
observedCounts, 0.001);
}
diff --git a/pom.xml b/pom.xml
index 956d0d0..2843b5d 100644
--- a/pom.xml
+++ b/pom.xml
@@ -90,7 +90,7 @@
<statistics.pmd.version>3.8</statistics.pmd.version>
<statistics.spotbugs.version>3.1.11</statistics.spotbugs.version>
<statistics.checkstyle.version>3.0.0</statistics.checkstyle.version>
- <statistics.checkstyle.dep.version>8.18</statistics.checkstyle.dep.version>
+ <statistics.checkstyle.dep.version>8.20</statistics.checkstyle.dep.version>
<statistics.clirr.version>2.8</statistics.clirr.version>
<!-- Workaround to avoid duplicating config files. -->
<statistics.parent.dir>${basedir}</statistics.parent.dir>
diff --git a/src/main/resources/checkstyle/checkstyle-suppressions.xml
b/src/main/resources/checkstyle/checkstyle-suppressions.xml
index f6aec29..1769ca2 100644
--- a/src/main/resources/checkstyle/checkstyle-suppressions.xml
+++ b/src/main/resources/checkstyle/checkstyle-suppressions.xml
@@ -19,6 +19,13 @@
"-//Checkstyle//DTD SuppressionFilter Configuration 1.2//EN"
"https://checkstyle.org/dtds/suppressions_1_2.dtd";>
<suppressions>
+ <!-- Allow variable to match known equations. -->
+ <suppress checks="LocalFinalVariableName"
files=".*[/\\]ZipfDistribution.java" />
+ <suppress checks="LocalFinalVariableName"
files=".*[/\\]HypergeometricDistribution.java" />
+ <!-- Be more lenient on tests. -->
<suppress checks="Javadoc" files=".*[/\\]test[/\\].*" />
<suppress checks="MultipleStringLiterals" files=".*[/\\]test[/\\].*" />
+ <suppress checks="DesignForExtension" files=".*[/\\]test[/\\].*" />
+ <suppress checks="LineLength" files=".*[/\\]test[/\\].*" />
+ <suppress checks="LocalFinalVariableName"
files=".*[/\\]HypergeometricDistributionTest.java" />
</suppressions>
diff --git a/src/main/resources/checkstyle/checkstyle.xml
b/src/main/resources/checkstyle/checkstyle.xml
index 42f417e..c9e05d1 100644
--- a/src/main/resources/checkstyle/checkstyle.xml
+++ b/src/main/resources/checkstyle/checkstyle.xml
@@ -17,9 +17,14 @@
limitations under the License.
-->
-<!DOCTYPE module PUBLIC "-//Checkstyle//DTD Checkstyle Configuration 1.1//EN"
"https://checkstyle.org/dtds/configuration_1_1.dtd";>
-
-<!-- Commons statistics customization of default Checkstyle behavior -->
+<!DOCTYPE module PUBLIC
+ "-//Checkstyle//DTD Checkstyle Configuration 1.3//EN"
+ "https://checkstyle.org/dtds/configuration_1_3.dtd";>
+
+<!--
+ Commons Statitics customization of default Checkstyle behaviour:
+
https://github.com/checkstyle/checkstyle/blob/master/src/main/resources/sun_checks.xml
+-->
<module name="Checker">
<module name="SuppressionFilter">
<!-- Default property set by maven-checkstyle-plugin -->
@@ -29,77 +34,188 @@
<property name="localeLanguage" value="en"/>
- <module name="TreeWalker">
+ <property name="fileExtensions" value="java, properties, xml" />
- <!-- Operator must be at end of wrapped line -->
- <module name="OperatorWrap">
- <property name="option" value="eol"/>
- </module>
+ <!-- Excludes all 'module-info.java' files -->
+ <!-- See https://checkstyle.org/config_filefilters.html -->
+ <module name="BeforeExecutionExclusionFileFilter">
+ <property name="fileNamePattern" value="module\-info\.java$" />
+ </module>
- <!-- No if/else/do/for/while without braces -->
- <module name="NeedBraces"/>
+ <!-- Checks that a package-info.java file exists for each package. -->
+ <!-- See
http://checkstyle.sourceforge.net/config_javadoc.html#JavadocPackage -->
+ <module name="JavadocPackage" />
+
+ <!-- Checks whether files end with a new line. -->
+ <!-- See
http://checkstyle.sourceforge.net/config_misc.html#NewlineAtEndOfFile -->
+ <module name="NewlineAtEndOfFile" />
+
+ <!-- Checks that property files contain the same keys. -->
+ <!-- See http://checkstyle.sourceforge.net/config_misc.html#Translation -->
+ <module name="Translation" />
+
+ <!-- Checks for Size Violations. -->
+ <!-- See http://checkstyle.sourceforge.net/config_sizes.html -->
+ <module name="FileLength" />
+
+ <!-- Checks for whitespace -->
+ <!-- See http://checkstyle.sourceforge.net/config_whitespace.html -->
+ <module name="FileTabCharacter" />
+
+ <!-- Miscellaneous other checks. -->
+ <!-- See http://checkstyle.sourceforge.net/config_misc.html -->
+ <module name="RegexpSingleline">
+ <property name="format" value="\s+$" />
+ <property name="minimum" value="0" />
+ <property name="maximum" value="0" />
+ <property name="message" value="Line has trailing spaces." />
+ </module>
- <!-- Interfaces must be types (not just constants) -->
- <module name="InterfaceIsType"/>
+ <!-- Checks for Headers -->
+ <!-- See http://checkstyle.sourceforge.net/config_header.html -->
+ <module name="Header">
+ <property name="headerFile" value="${checkstyle.header.file}"/>
+ </module>
- <!-- Must have class / interface header comments -->
- <module name="JavadocType"/>
+ <module name="TreeWalker">
- <!-- Require method javadocs, allow undeclared RTE -->
+ <!-- Checks for Javadoc comments. -->
+ <!-- See http://checkstyle.sourceforge.net/config_javadoc.html -->
+ <!-- Require method javadocs, allow undeclared RTE -->
<module name="JavadocMethod">
<property name="allowUndeclaredRTE" value="true"/>
<property name="allowThrowsTagsForSubclasses" value="true"/>
<property name="validateThrows" value="false"/>
</module>
+ <module name="JavadocType" />
+ <module name="JavadocVariable" />
+ <module name="JavadocStyle" />
+ <!-- <module name="MissingJavadocType"/> -->
- <!-- Require field javadoc -->
- <module name="JavadocVariable"/>
+ <!-- Checks for Naming Conventions. -->
+ <!-- See http://checkstyle.sourceforge.net/config_naming.html -->
+ <module name="ConstantName" />
+ <module name="LocalFinalVariableName" />
+ <module name="LocalVariableName" />
+ <module name="MemberName" />
+ <module name="MethodName" />
+ <module name="PackageName" />
+ <module name="ParameterName" />
+ <module name="StaticVariableName" />
+ <module name="TypeName" />
+
+ <!-- Checks for imports -->
+ <!-- See http://checkstyle.sourceforge.net/config_import.html -->
+ <module name="AvoidStarImport" />
+ <module name="IllegalImport" /> <!-- defaults to sun.* packages -->
+ <module name="RedundantImport" />
+ <module name="UnusedImports">
+ <property name="processJavadoc" value="false" />
+ </module>
- <!-- No public fields -->
- <module name="VisibilityModifier">
- <property name="protectedAllowed" value="true"/>
+ <!-- Checks for Size Violations. -->
+ <!-- See http://checkstyle.sourceforge.net/config_sizes.html -->
+ <module name="LineLength">
+ <!-- Ignore lines that begin with " * ", such as within a Javadoc
comment. -->
+ <property name="ignorePattern" value="^ *\* *[^ ]"/>
+ <property name="max" value="120"/>
+ </module>
+ <module name="MethodLength" />
+ <module name="ParameterNumber" />
+
+ <!-- Checks for whitespace -->
+ <!-- See http://checkstyle.sourceforge.net/config_whitespace.html -->
+ <module name="EmptyForIteratorPad" />
+ <module name="GenericWhitespace" />
+ <module name="MethodParamPad" />
+ <module name="NoWhitespaceAfter" />
+ <module name="NoWhitespaceBefore" />
+ <!-- Operator must be at end of wrapped line -->
+ <module name="OperatorWrap">
+ <property name="option" value="eol"/>
+ </module>
+ <module name="ParenPad" />
+ <module name="TypecastParenPad" />
+ <module name="WhitespaceAfter">
+ <property name="tokens" value="COMMA, SEMI, LITERAL_IF, LITERAL_ELSE,
LITERAL_WHILE, LITERAL_DO, LITERAL_FOR, DO_WHILE"/>
+ </module>
+ <module name="WhitespaceAround">
+ <property name="allowEmptyConstructors" value="true"/>
+ <property name="allowEmptyTypes" value="true"/>
</module>
- <!-- Require hash code override when equals is -->
- <module name="EqualsHashCode"/>
+ <!-- Modifier Checks -->
+ <!-- See http://checkstyle.sourceforge.net/config_modifiers.html -->
+ <module name="ModifierOrder" />
+ <module name="RedundantModifier" />
+ <!-- Checks for blocks. You know, those {}'s -->
+ <!-- See http://checkstyle.sourceforge.net/config_blocks.html -->
+ <module name="AvoidNestedBlocks" />
+ <module name="EmptyBlock" />
+ <module name="LeftCurly" />
+ <module name="NeedBraces" />
+ <module name="RightCurly" />
+
+ <!-- Checks for common coding problems -->
+ <!-- See http://checkstyle.sourceforge.net/config_coding.html -->
+ <module name="EmptyStatement" />
+ <module name="EqualsHashCode" />
+ <!-- Method parameters and local variables should not hide fields, except
in constructors and setters -->
+ <module name="HiddenField">
+ <property name="ignoreConstructorParameter" value="true" />
+ <property name="ignoreSetter" value="true" />
+ </module>
<!-- Disallow unnecessary instantiation of Boolean, String -->
<module name="IllegalInstantiation">
<property name="classes" value="java.lang.Boolean, java.lang.String"/>
</module>
+ <!-- Allowed for algorithm implementations. -->
+ <!-- <module name="InnerAssignment" /> -->
+ <!-- <module name="MagicNumber" /> -->
+ <module name="MissingSwitchDefault" />
+ <module name="MultipleVariableDeclarations" />
+ <module name="SimplifyBooleanExpression" />
+ <module name="SimplifyBooleanReturn" />
- <!-- Import should be explicit, really needed and only from pure java
packages -->
- <module name="AvoidStarImport" />
- <module name="UnusedImports" />
- <module name="IllegalImport" />
-
- <!-- Utility class should not be instantiated, they must have a private
constructor -->
+ <!-- Checks for class design -->
+ <!-- See http://checkstyle.sourceforge.net/config_design.html -->
+ <module name="DesignForExtension" />
+ <module name="FinalClass" />
<module name="HideUtilityClassConstructor" />
+ <module name="InterfaceIsType" />
+ <!-- No public fields -->
+ <module name="VisibilityModifier">
+ <property name="protectedAllowed" value="true"/>
+ </module>
- <!-- Switch statements should be complete and with independent cases -->
- <module name="FallThrough" />
- <module name="MissingSwitchDefault" />
+ <!-- Miscellaneous other checks. -->
+ <!-- See http://checkstyle.sourceforge.net/config_misc.html -->
+ <module name="ArrayTypeStyle" />
+ <!-- <module name="FinalParameters" /> -->
+ <module name="TodoComment">
+ <property name="severity" value="warning"/>
+ </module>
+ <module name="UpperEll" />
- <!-- Constant names should obey the traditional all uppercase naming
convention -->
- <module name="ConstantName" />
+ <!-- Addition to Checkstyle sun_checks.xml -->
- <!-- Method parameters and local variables should not hide fields, except
in constructors and setters -->
- <module name="HiddenField">
- <property name="ignoreConstructorParameter" value="true" />
- <property name="ignoreSetter" value="true" />
+ <!-- Indentation of 4 spaces. -->
+ <module name="Indentation">
+ <!-- Indentation style recommended by Oracle -->
+ <property name="caseIndent" value="0"/>
</module>
- <!-- No trailing whitespace -->
- <module name="Regexp">
- <property name="format" value="[ \t]+$"/>
- <property name="illegalPattern" value="true"/>
- <property name="message" value="Trailing whitespace"/>
- </module>
+ <!-- Switch statements should have independent cases -->
+ <module name="FallThrough" />
+
+ <!-- Constant names should obey the traditional all uppercase naming
convention -->
+ <module name="ConstantName" />
<!-- No System.out.println() statements -->
<module name="Regexp">
<!-- no sysouts -->
- <property name="format" value="System\.out\.println"/>
+ <property name="format" value="System\.(out|err)\."/>
<property name="illegalPattern" value="true"/>
</module>
@@ -107,13 +223,9 @@
<module name="Regexp">
<property name="format" value="@author"/>
<property name="illegalPattern" value="true"/>
- <property name="message" value="developers names should be in pom file"/>
+ <property name="message" value="Developers names should be in pom file"/>
</module>
- <!-- Use a consistent way to put modifiers -->
- <module name="RedundantModifier" />
- <module name="ModifierOrder" />
-
<!-- Use a consistent way to put declarations -->
<module name="DeclarationOrder" />
@@ -126,9 +238,6 @@
<!-- Don't use = or != for string comparisons -->
<module name="StringLiteralEquality" />
- <!-- Don't declare multiple variables in the same statement -->
- <module name="MultipleVariableDeclarations" />
-
<!-- String literals more than one character long should not be repeated
several times -->
<!-- the "unchecked" string is also accepted to allow
@SuppressWarnings("unchecked") -->
<module name="MultipleStringLiterals" >
@@ -138,8 +247,6 @@
<!-- Check if @Override tags are present -->
<module name="MissingOverride" />
- <!-- <module name="TodoComment" /> -->
-
<!-- Setup special comments to suppress specific checks from source files
-->
<module name="SuppressionCommentFilter">
<property name="offCommentFormat" value="CHECKSTYLE\: stop ([\w\|]+)"/>
@@ -153,19 +260,4 @@
</module>
- <!-- Verify that EVERY source file has the appropriate license -->
- <module name="Header">
- <property name="headerFile" value="${checkstyle.header.file}"/>
- </module>
-
- <!-- No tabs allowed! -->
- <module name="FileTabCharacter"/>
-
- <!-- Require files to end with newline characters -->
- <module name="NewlineAtEndOfFile"/>
-
- <!-- Require package javadoc -->
- <module name="JavadocPackage"/>
-
</module>
-
