http://git-wip-us.apache.org/repos/asf/commons-math/blob/ef846813/src/test/java/org/apache/commons/math4/distribution/NormalDistributionTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/distribution/NormalDistributionTest.java b/src/test/java/org/apache/commons/math4/distribution/NormalDistributionTest.java deleted file mode 100644 index 4e00f56..0000000 --- a/src/test/java/org/apache/commons/math4/distribution/NormalDistributionTest.java +++ /dev/null @@ -1,216 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.commons.math4.distribution; - -import org.apache.commons.math4.distribution.NormalDistribution; -import org.apache.commons.math4.exception.NotStrictlyPositiveException; -import org.junit.Assert; -import org.junit.Test; - -/** - * Test cases for {@link NormalDistribution}. Extends - * {@link RealDistributionAbstractTest}. See class javadoc of that class - * for details. - * - */ -public class NormalDistributionTest extends RealDistributionAbstractTest { - - //-------------- Implementations for abstract methods ----------------------- - - /** Creates the default real distribution instance to use in tests. */ - @Override - public NormalDistribution makeDistribution() { - return new NormalDistribution(2.1, 1.4); - } - - /** Creates the default cumulative probability distribution test input values */ - @Override - 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}; - } - - /** 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}; - } - - /** 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}; - } - - // --------------------- Override tolerance -------------- - protected double defaultTolerance = NormalDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY; - @Override - public void setUp() { - super.setUp(); - setTolerance(defaultTolerance); - } - - //---------------------------- Additional test cases ------------------------- - - private void verifyQuantiles() { - 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}); - // 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}); - verifyCumulativeProbabilities(); - } - - @Test - public void testQuantiles() { - setDensityTestValues(new double[] {0.0385649760808, 0.172836231799, 0.284958771715, 0.172836231799, 0.0385649760808, - 0.00316560600853, 9.55930184035e-05, 1.06194251052e-06}); - verifyQuantiles(); - verifyDensities(); - - setDistribution(new NormalDistribution(0, 1)); - setDensityTestValues(new double[] {0.0539909665132, 0.241970724519, 0.398942280401, 0.241970724519, 0.0539909665132, - 0.00443184841194, 0.000133830225765, 1.48671951473e-06}); - verifyQuantiles(); - verifyDensities(); - - setDistribution(new NormalDistribution(0, 0.1)); - setDensityTestValues(new double[] {0.539909665132, 2.41970724519, 3.98942280401, 2.41970724519, - 0.539909665132, 0.0443184841194, 0.00133830225765, 1.48671951473e-05}); - verifyQuantiles(); - verifyDensities(); - } - - @Test - public void testInverseCumulativeProbabilityExtremes() { - setInverseCumulativeTestPoints(new double[] {0, 1}); - setInverseCumulativeTestValues( - new double[] {Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY}); - verifyInverseCumulativeProbabilities(); - } - - // MATH-1257 - @Test - public void testCumulativeProbability() { - final RealDistribution dist = new NormalDistribution(0, 1); - double x = -10; - double expected = 7.61985e-24; - double v = dist.cumulativeProbability(x); - double tol = 1e-5; - Assert.assertEquals(1, v / expected, 1e-5); - } - - @Test - public void testGetMean() { - NormalDistribution distribution = (NormalDistribution) getDistribution(); - Assert.assertEquals(2.1, distribution.getMean(), 0); - } - - @Test - public void testGetStandardDeviation() { - NormalDistribution distribution = (NormalDistribution) getDistribution(); - Assert.assertEquals(1.4, distribution.getStandardDeviation(), 0); - } - - @Test(expected=NotStrictlyPositiveException.class) - public void testPreconditions() { - new NormalDistribution(1, 0); - } - - @Test - public void testDensity() { - double [] x = new double[]{-2, -1, 0, 1, 2}; - // R 2.5: print(dnorm(c(-2,-1,0,1,2)), digits=10) - checkDensity(0, 1, x, new double[]{0.05399096651, 0.24197072452, 0.39894228040, 0.24197072452, 0.05399096651}); - // R 2.5: print(dnorm(c(-2,-1,0,1,2), mean=1.1), digits=10) - 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) { - NormalDistribution d = new NormalDistribution(mean, sd); - for (int i = 0; i < x.length; i++) { - Assert.assertEquals(expected[i], d.density(x[i]), 1e-9); - } - } - - /** - * Check to make sure top-coding of extreme values works correctly. - * Verifies fixes for JIRA MATH-167, MATH-414 - */ - @Test - public void testExtremeValues() { - NormalDistribution distribution = new NormalDistribution(0, 1); - for (int i = 0; i < 100; i++) { // make sure no convergence exception - double lowerTail = distribution.cumulativeProbability(-i); - double upperTail = distribution.cumulativeProbability(i); - if (i < 9) { // make sure not top-coded - // For i = 10, due to bad tail precision in erf (MATH-364), 1 is returned - // 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 - Assert.assertTrue(lowerTail < 0.00001); - Assert.assertTrue(upperTail > 0.99999); - } - } - - Assert.assertEquals(distribution.cumulativeProbability(Double.MAX_VALUE), 1, 0); - Assert.assertEquals(distribution.cumulativeProbability(-Double.MAX_VALUE), 0, 0); - Assert.assertEquals(distribution.cumulativeProbability(Double.POSITIVE_INFINITY), 1, 0); - Assert.assertEquals(distribution.cumulativeProbability(Double.NEGATIVE_INFINITY), 0, 0); - } - - @Test - public void testMath280() { - NormalDistribution normal = new NormalDistribution(0,1); - double result = normal.inverseCumulativeProbability(0.9986501019683698); - Assert.assertEquals(3.0, result, defaultTolerance); - result = normal.inverseCumulativeProbability(0.841344746068543); - Assert.assertEquals(1.0, result, defaultTolerance); - result = normal.inverseCumulativeProbability(0.9999683287581673); - Assert.assertEquals(4.0, result, defaultTolerance); - result = normal.inverseCumulativeProbability(0.9772498680518209); - Assert.assertEquals(2.0, result, defaultTolerance); - } - - @Test - public void testMoments() { - final double tol = 1e-9; - NormalDistribution dist; - - dist = new NormalDistribution(0, 1); - Assert.assertEquals(dist.getNumericalMean(), 0, tol); - Assert.assertEquals(dist.getNumericalVariance(), 1, tol); - - dist = new NormalDistribution(2.2, 1.4); - Assert.assertEquals(dist.getNumericalMean(), 2.2, tol); - Assert.assertEquals(dist.getNumericalVariance(), 1.4 * 1.4, tol); - - dist = new NormalDistribution(-2000.9, 10.4); - Assert.assertEquals(dist.getNumericalMean(), -2000.9, tol); - Assert.assertEquals(dist.getNumericalVariance(), 10.4 * 10.4, tol); - } -}
http://git-wip-us.apache.org/repos/asf/commons-math/blob/ef846813/src/test/java/org/apache/commons/math4/distribution/ParetoDistributionTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/distribution/ParetoDistributionTest.java b/src/test/java/org/apache/commons/math4/distribution/ParetoDistributionTest.java deleted file mode 100644 index 0c5d488..0000000 --- a/src/test/java/org/apache/commons/math4/distribution/ParetoDistributionTest.java +++ /dev/null @@ -1,206 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.commons.math4.distribution; - -import org.apache.commons.math4.distribution.ParetoDistribution; -import org.apache.commons.math4.exception.NotStrictlyPositiveException; -import org.junit.Assert; -import org.junit.Test; - -/** - * Test cases for {@link ParetoDistribution}. - * <p> - * Extends {@link RealDistributionAbstractTest}. See class javadoc of that class for details. - * - * @since 3.3 - */ -public class ParetoDistributionTest extends RealDistributionAbstractTest { - - //-------------- Implementations for abstract methods ----------------------- - - /** Creates the default real distribution instance to use in tests. */ - @Override - public ParetoDistribution makeDistribution() { - return new ParetoDistribution(2.1, 1.4); - } - - /** Creates the default cumulative probability distribution test input values */ - @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 }; - } - - /** 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 }; - } - - /** 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 }; - } - - /** - * Creates the default inverse cumulative probability distribution test input values. - */ - @Override - public double[] makeInverseCumulativeTestPoints() { - // Exclude the test points less than zero, as they have cumulative - // probability of zero, meaning the inverse returns zero, and not the - // points less than zero. - double[] points = makeCumulativeTestValues(); - double[] points2 = new double[points.length - 5]; - System.arraycopy(points, 5, points2, 0, points.length - 5); - return points2; - } - - /** - * Creates the default inverse cumulative probability test expected values. - */ - @Override - public double[] makeInverseCumulativeTestValues() { - // Exclude the test points less than zero, as they have cumulative - // probability of zero, meaning the inverse returns zero, and not the - // points less than zero. - double[] points = makeCumulativeTestPoints(); - double[] points2 = new double[points.length - 5]; - System.arraycopy(points, 5, points2, 0, points.length - 5); - return points2; - } - - // --------------------- Override tolerance -------------- - @Override - public void setUp() { - super.setUp(); - setTolerance(ParetoDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY); - } - - //---------------------------- Additional test cases ------------------------- - - private void verifyQuantiles() { - 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 }); - verifyCumulativeProbabilities(); - } - - @Test - public void testQuantiles() { - setCumulativeTestValues(new double[] {0, 0, 0, 0.510884134236, 0.694625688662, 0.785201995008, 0.837811522357, 0.871634279326}); - setDensityTestValues(new double[] {0, 0, 0.666666666, 0.195646346305, 0.0872498032394, 0.0477328899983, 0.0294888141169, 0.0197485724114}); - verifyQuantiles(); - verifyDensities(); - - setDistribution(new ParetoDistribution(1, 1)); - setCumulativeTestValues(new double[] {0, 0, 0, 0.5, 0.666666666667, 0.75, 0.8, 0.833333333333}); - setDensityTestValues(new double[] {0, 0, 1.0, 0.25, 0.111111111111, 0.0625, 0.04, 0.0277777777778}); - verifyQuantiles(); - verifyDensities(); - - setDistribution(new ParetoDistribution(0.1, 0.1)); - setCumulativeTestValues(new double[] {0, 0, 0, 0.0669670084632, 0.104041540159, 0.129449436704, 0.148660077479, 0.164041197922}); - setDensityTestValues(new double[] {0, 0, 1.0, 0.466516495768, 0.298652819947, 0.217637640824, 0.170267984504, 0.139326467013}); - verifyQuantiles(); - verifyDensities(); - } - - @Test - public void testInverseCumulativeProbabilityExtremes() { - setInverseCumulativeTestPoints(new double[] {0, 1}); - setInverseCumulativeTestValues(new double[] {2.1, Double.POSITIVE_INFINITY}); - verifyInverseCumulativeProbabilities(); - } - - @Test - public void testGetScale() { - ParetoDistribution distribution = (ParetoDistribution)getDistribution(); - Assert.assertEquals(2.1, distribution.getScale(), 0); - } - - @Test - public void testGetShape() { - ParetoDistribution distribution = (ParetoDistribution)getDistribution(); - Assert.assertEquals(1.4, distribution.getShape(), 0); - } - - @Test(expected=NotStrictlyPositiveException.class) - public void testPreconditions() { - new ParetoDistribution(1, 0); - } - - @Test - public void testDensity() { - double [] x = new double[]{-2, -1, 0, 1, 2}; - // R 2.14: print(dpareto(c(-2,-1,0,1,2), scale=1, shape=1), digits=10) - checkDensity(1, 1, x, new double[] { 0.00, 0.00, 0.00, 1.00, 0.25 }); - // R 2.14: print(dpareto(c(-2,-1,0,1,2), scale=1.1, shape=1), digits=10) - 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, - double[] expected) { - ParetoDistribution d = new ParetoDistribution(scale, shape); - for (int i = 0; i < x.length; i++) { - Assert.assertEquals(expected[i], d.density(x[i]), 1e-9); - } - } - - /** - * Check to make sure top-coding of extreme values works correctly. - */ - @Test - public void testExtremeValues() { - ParetoDistribution d = new ParetoDistribution(1, 1); - for (int i = 0; i < 1e5; i++) { // make sure no convergence exception - 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 - Assert.assertTrue(upperTail > 0.999); - } - } - - Assert.assertEquals(d.cumulativeProbability(Double.MAX_VALUE), 1, 0); - Assert.assertEquals(d.cumulativeProbability(-Double.MAX_VALUE), 0, 0); - Assert.assertEquals(d.cumulativeProbability(Double.POSITIVE_INFINITY), 1, 0); - Assert.assertEquals(d.cumulativeProbability(Double.NEGATIVE_INFINITY), 0, 0); - } - - @Test - public void testMeanVariance() { - final double tol = 1e-9; - ParetoDistribution dist; - - dist = new ParetoDistribution(1, 1); - Assert.assertEquals(dist.getNumericalMean(), Double.POSITIVE_INFINITY, tol); - Assert.assertEquals(dist.getNumericalVariance(), Double.POSITIVE_INFINITY, tol); - - dist = new ParetoDistribution(2.2, 2.4); - Assert.assertEquals(dist.getNumericalMean(), 3.771428571428, tol); - Assert.assertEquals(dist.getNumericalVariance(), 14.816326530, tol); - } -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/ef846813/src/test/java/org/apache/commons/math4/distribution/PascalDistributionTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/distribution/PascalDistributionTest.java b/src/test/java/org/apache/commons/math4/distribution/PascalDistributionTest.java deleted file mode 100644 index 6f2725e..0000000 --- a/src/test/java/org/apache/commons/math4/distribution/PascalDistributionTest.java +++ /dev/null @@ -1,135 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.commons.math4.distribution; - -import org.apache.commons.math4.distribution.IntegerDistribution; -import org.apache.commons.math4.distribution.NormalDistribution; -import org.apache.commons.math4.distribution.PascalDistribution; -import org.junit.Assert; -import org.junit.Test; - -/** - * Test cases for PascalDistribution. - * Extends IntegerDistributionAbstractTest. See class javadoc for - * IntegerDistributionAbstractTest for details. - * - */ -public class PascalDistributionTest extends IntegerDistributionAbstractTest { - - // --------------------- Override tolerance -------------- - protected double defaultTolerance = NormalDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY; - @Override - public void setUp() { - super.setUp(); - setTolerance(defaultTolerance); - } - - //-------------- Implementations for abstract methods ----------------------- - - /** Creates the default discrete distribution instance to use in tests. */ - @Override - public IntegerDistribution makeDistribution() { - 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}; - } - - /** 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}; - } - - /** Creates the default cumulative probability density test input values */ - @Override - public int[] makeCumulativeTestPoints() { - 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}; - } - - /** 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}; - } - - /** 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}; - } - - //----------------- Additional test cases --------------------------------- - - /** Test degenerate case p = 0 */ - @Test - public void testDegenerate0() { - setDistribution(new PascalDistribution(5, 0.0d)); - setCumulativeTestPoints(new int[] {-1, 0, 1, 5, 10 }); - setCumulativeTestValues(new double[] {0d, 0d, 0d, 0d, 0d}); - setDensityTestPoints(new int[] {-1, 0, 1, 10, 11}); - setDensityTestValues(new double[] {0d, 0d, 0d, 0d, 0d}); - setInverseCumulativeTestPoints(new double[] {0.1d, 0.5d}); - setInverseCumulativeTestValues(new int[] {Integer.MAX_VALUE, Integer.MAX_VALUE}); - verifyDensities(); - verifyCumulativeProbabilities(); - verifyInverseCumulativeProbabilities(); - } - - /** Test degenerate case p = 1 */ - @Test - public void testDegenerate1() { - setDistribution(new PascalDistribution(5, 1.0d)); - 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(); - } - - @Test - public void testMoments() { - final double tol = 1e-9; - PascalDistribution dist; - - dist = new PascalDistribution(10, 0.5); - Assert.assertEquals(dist.getNumericalMean(), ( 10d * 0.5d ) / 0.5d, tol); - Assert.assertEquals(dist.getNumericalVariance(), ( 10d * 0.5d ) / (0.5d * 0.5d), tol); - - dist = new PascalDistribution(25, 0.7); - Assert.assertEquals(dist.getNumericalMean(), ( 25d * 0.3d ) / 0.7d, tol); - Assert.assertEquals(dist.getNumericalVariance(), ( 25d * 0.3d ) / (0.7d * 0.7d), tol); - } -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/ef846813/src/test/java/org/apache/commons/math4/distribution/PoissonDistributionTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/distribution/PoissonDistributionTest.java b/src/test/java/org/apache/commons/math4/distribution/PoissonDistributionTest.java deleted file mode 100644 index a0c404c..0000000 --- a/src/test/java/org/apache/commons/math4/distribution/PoissonDistributionTest.java +++ /dev/null @@ -1,248 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.commons.math4.distribution; - -import org.apache.commons.math4.distribution.IntegerDistribution; -import org.apache.commons.math4.distribution.PoissonDistribution; -import org.apache.commons.math4.exception.NotStrictlyPositiveException; -import org.apache.commons.math4.util.FastMath; -import org.junit.Assert; -import org.junit.Test; - -/** - * <code>PoissonDistributionTest</code> - * - */ -public class PoissonDistributionTest extends IntegerDistributionAbstractTest { - - /** - * Poisson parameter value for the test distribution. - */ - private static final double DEFAULT_TEST_POISSON_PARAMETER = 4.0; - - /** - * Constructor. - */ - public PoissonDistributionTest() { - setTolerance(1e-12); - } - - /** - * Creates the default discrete distribution instance to use in tests. - */ - @Override - public IntegerDistribution makeDistribution() { - return new PoissonDistribution(DEFAULT_TEST_POISSON_PARAMETER); - } - - /** - * Creates the default probability density test input values. - */ - @Override - public int[] makeDensityTestPoints() { - return new int[] { -1, 0, 1, 2, 3, 4, 5, 10, 20}; - } - - /** - * Creates the default probability density test expected values. - * These and all other test values are generated by R, version 1.8.1 - */ - @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}; - } - - /** - * Creates the default logarithmic probability density test expected values. - * Reference values are from R, version 2.14.1. - */ - @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}; - } - - /** - * Creates the default cumulative probability density test input values. - */ - @Override - public int[] makeCumulativeTestPoints() { - return new int[] { -1, 0, 1, 2, 3, 4, 5, 10, 20 }; - } - - /** - * Creates the default cumulative probability density test expected values. - */ - @Override - public double[] makeCumulativeTestValues() { - return new double[] { 0d, 0.0183156388887d, 0.0915781944437d, - 0.238103305554d, 0.433470120367d, 0.62883693518, - 0.78513038703d, 0.99716023388d, 0.999999998077 }; - } - - /** - * Creates the default inverse cumulative probability test input values. - */ - @Override - public double[] makeInverseCumulativeTestPoints() { - IntegerDistribution 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)}; - } - - /** - * Creates the default inverse cumulative probability density test expected values. - */ - @Override - public int[] makeInverseCumulativeTestValues() { - return new int[] { 0, 0, 1, 1, 2, 2, 3, 3, 4, 5, 10, 20}; - } - - /** - * Test the normal approximation of the Poisson distribution by - * calculating P(90 ≤ X ≤ 110) for X = Po(100) and - * P(9900 ≤ X ≤ 10200) for X = Po(10000) - */ - @Test - public void testNormalApproximateProbability() { - PoissonDistribution dist = new PoissonDistribution(100); - double result = dist.normalApproximateProbability(110) - - dist.normalApproximateProbability(89); - Assert.assertEquals(0.706281887248, result, 1E-10); - - dist = new PoissonDistribution(10000); - result = dist.normalApproximateProbability(10200) - - dist.normalApproximateProbability(9899); - Assert.assertEquals(0.820070051552, result, 1E-10); - } - - /** - * Test the degenerate cases of a 0.0 and 1.0 inverse cumulative probability. - */ - @Test - public void testDegenerateInverseCumulativeProbability() { - PoissonDistribution dist = new PoissonDistribution(DEFAULT_TEST_POISSON_PARAMETER); - Assert.assertEquals(Integer.MAX_VALUE, dist.inverseCumulativeProbability(1.0d)); - Assert.assertEquals(0, dist.inverseCumulativeProbability(0d)); - } - - @Test(expected=NotStrictlyPositiveException.class) - public void testNegativeMean() { - new PoissonDistribution(-1); - } - - @Test - public void testMean() { - PoissonDistribution dist = new PoissonDistribution(10.0); - Assert.assertEquals(10.0, dist.getMean(), 0.0); - } - - @Test - public void testLargeMeanCumulativeProbability() { - double mean = 1.0; - while (mean <= 10000000.0) { - PoissonDistribution dist = new PoissonDistribution(mean); - - double x = mean * 2.0; - double dx = x / 10.0; - double p = Double.NaN; - double sigma = FastMath.sqrt(mean); - while (x >= 0) { - try { - p = dist.cumulativeProbability((int) x); - Assert.assertFalse("NaN cumulative probability returned for mean = " + - mean + " x = " + x,Double.isNaN(p)); - if (x > mean - 2 * sigma) { - Assert.assertTrue("Zero cum probaility returned for mean = " + - mean + " x = " + x, p > 0); - } - } catch (Exception ex) { - Assert.fail("mean of " + mean + " and x of " + x + " caused " + ex.getMessage()); - } - x -= dx; - } - - mean *= 10.0; - } - } - - /** - * JIRA: MATH-282 - */ - @Test - public void testCumulativeProbabilitySpecial() { - PoissonDistribution dist; - dist = new PoissonDistribution(9120); - checkProbability(dist, 9075); - checkProbability(dist, 9102); - dist = new PoissonDistribution(5058); - checkProbability(dist, 5044); - dist = new PoissonDistribution(6986); - checkProbability(dist, 6950); - } - - private void checkProbability(PoissonDistribution dist, int x) { - double p = dist.cumulativeProbability(x); - Assert.assertFalse("NaN cumulative probability returned for mean = " + - dist.getMean() + " x = " + x, Double.isNaN(p)); - Assert.assertTrue("Zero cum probability returned for mean = " + - dist.getMean() + " x = " + x, p > 0); - } - - @Test - public void testLargeMeanInverseCumulativeProbability() { - double mean = 1.0; - while (mean <= 100000.0) { // Extended test value: 1E7. Reduced to limit run time. - PoissonDistribution dist = new PoissonDistribution(mean); - double p = 0.1; - double dp = p; - while (p < .99) { - try { - int ret = dist.inverseCumulativeProbability(p); - // Verify that returned value satisties definition - Assert.assertTrue(p <= dist.cumulativeProbability(ret)); - Assert.assertTrue(p > dist.cumulativeProbability(ret - 1)); - } catch (Exception ex) { - Assert.fail("mean of " + mean + " and p of " + p + " caused " + ex.getMessage()); - } - p += dp; - } - mean *= 10.0; - } - } - - @Test - public void testMoments() { - final double tol = 1e-9; - PoissonDistribution dist; - - dist = new PoissonDistribution(1); - Assert.assertEquals(dist.getNumericalMean(), 1, tol); - Assert.assertEquals(dist.getNumericalVariance(), 1, tol); - - dist = new PoissonDistribution(11.23); - Assert.assertEquals(dist.getNumericalMean(), 11.23, tol); - Assert.assertEquals(dist.getNumericalVariance(), 11.23, tol); - } -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/ef846813/src/test/java/org/apache/commons/math4/distribution/TDistributionTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/distribution/TDistributionTest.java b/src/test/java/org/apache/commons/math4/distribution/TDistributionTest.java deleted file mode 100644 index 992bb34..0000000 --- a/src/test/java/org/apache/commons/math4/distribution/TDistributionTest.java +++ /dev/null @@ -1,173 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.commons.math4.distribution; - -import org.junit.Assert; -import org.junit.Test; -import org.apache.commons.math4.TestUtils; -import org.apache.commons.math4.distribution.TDistribution; -import org.apache.commons.math4.exception.NotStrictlyPositiveException; -/** - * Test cases for TDistribution. - * Extends ContinuousDistributionAbstractTest. See class javadoc for - * ContinuousDistributionAbstractTest for details. - * - */ -public class TDistributionTest extends RealDistributionAbstractTest { - -//-------------- Implementations for abstract methods ----------------------- - - /** Creates the default continuous distribution instance to use in tests. */ - @Override - public TDistribution makeDistribution() { - return new TDistribution(5.0); - } - - /** Creates the default cumulative probability distribution test input values */ - @Override - public double[] makeCumulativeTestPoints() { - // quantiles computed using R version 2.9.2 - return new double[] {-5.89342953136, -3.36492999891, -2.57058183564, -2.01504837333, -1.47588404882, - 5.89342953136, 3.36492999891, 2.57058183564, 2.01504837333, 1.47588404882}; - } - - /** Creates the default cumulative probability density test expected values */ - @Override - public double[] makeCumulativeTestValues() { - return new double[] {0.001, 0.01, 0.025, 0.05, 0.1, 0.999, - 0.990, 0.975, 0.950, 0.900}; - } - - /** Creates the default probability density test expected values */ - @Override - public double[] makeDensityTestValues() { - return new double[] {0.000756494565517, 0.0109109752919, 0.0303377878006, 0.0637967988952, 0.128289492005, - 0.000756494565517, 0.0109109752919, 0.0303377878006, 0.0637967988952, 0.128289492005}; - } - - // --------------------- Override tolerance -------------- - @Override - public void setUp() { - super.setUp(); - setTolerance(1E-9); - } - - //---------------------------- Additional test cases ------------------------- - /** - * @see <a href="http://issues.apache.org/bugzilla/show_bug.cgi?id=27243";> - * Bug report that prompted this unit test.</a> - */ - @Test - public void testCumulativeProbabilityAgainstStackOverflow() { - TDistribution td = new TDistribution(5.); - td.cumulativeProbability(.1); - td.cumulativeProbability(.01); - } - - @Test - public void testSmallDf() { - 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}); - 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}); - setInverseCumulativeTestValues(getCumulativeTestPoints()); - verifyCumulativeProbabilities(); - verifyInverseCumulativeProbabilities(); - verifyDensities(); - } - - @Test - public void testInverseCumulativeProbabilityExtremes() { - setInverseCumulativeTestPoints(new double[] {0, 1}); - setInverseCumulativeTestValues( - new double[] {Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY}); - verifyInverseCumulativeProbabilities(); - } - - @Test - public void testCumulativeProbablilityExtremes() { - TDistribution dist; - for (int i = 1; i < 11; i++) { - dist = new TDistribution(i * 5); - Assert.assertEquals(1, - dist.cumulativeProbability(Double.POSITIVE_INFINITY), Double.MIN_VALUE); - Assert.assertEquals(0, - dist.cumulativeProbability(Double.NEGATIVE_INFINITY), Double.MIN_VALUE); - } - } - - @Test - public void testDfAccessors() { - TDistribution dist = (TDistribution) getDistribution(); - Assert.assertEquals(5d, dist.getDegreesOfFreedom(), Double.MIN_VALUE); - } - - @Test(expected=NotStrictlyPositiveException.class) - public void testPreconditions() { - new TDistribution(0); - } - - @Test - public void testMoments() { - final double tol = 1e-9; - TDistribution dist; - - dist = new TDistribution(1); - Assert.assertTrue(Double.isNaN(dist.getNumericalMean())); - Assert.assertTrue(Double.isNaN(dist.getNumericalVariance())); - - dist = new TDistribution(1.5); - Assert.assertEquals(dist.getNumericalMean(), 0, tol); - Assert.assertTrue(Double.isInfinite(dist.getNumericalVariance())); - - dist = new TDistribution(5); - Assert.assertEquals(dist.getNumericalMean(), 0, tol); - Assert.assertEquals(dist.getNumericalVariance(), 5d / (5d - 2d), tol); - } - - /* - * Adding this test to benchmark against tables published by NIST - * http://itl.nist.gov/div898/handbook/eda/section3/eda3672.htm - * Have chosen tabulated results for degrees of freedom 2,10,30,100 - * 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}; - 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){ - TDistribution td = new TDistribution(df); - double[] res = new double[ args.length ]; - for( int i = 0 ; i < res.length ; i++){ - res[i] = 1.0 - td.cumulativeProbability(args[i]); - } - return res; - } -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/ef846813/src/test/java/org/apache/commons/math4/distribution/TriangularDistributionTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/distribution/TriangularDistributionTest.java b/src/test/java/org/apache/commons/math4/distribution/TriangularDistributionTest.java deleted file mode 100644 index d8027e7..0000000 --- a/src/test/java/org/apache/commons/math4/distribution/TriangularDistributionTest.java +++ /dev/null @@ -1,194 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.commons.math4.distribution; - -import org.apache.commons.math4.distribution.TriangularDistribution; -import org.apache.commons.math4.exception.NumberIsTooLargeException; -import org.apache.commons.math4.exception.NumberIsTooSmallException; -import org.junit.Assert; -import org.junit.Test; - -/** - * Test cases for {@link TriangularDistribution}. See class javadoc for - * {@link RealDistributionAbstractTest} for further details. - */ -public class TriangularDistributionTest extends RealDistributionAbstractTest { - - // --- Override tolerance ------------------------------------------------- - - @Override - public void setUp() { - super.setUp(); - setTolerance(1e-4); - } - - //--- Implementations for abstract methods -------------------------------- - - /** - * Creates the default triangular distribution instance to use in tests. - */ - @Override - public TriangularDistribution makeDistribution() { - // Left side 5 wide, right side 10 wide. - return new TriangularDistribution(-3, 2, 12); - } - - /** - * Creates the default cumulative probability distribution test input - * values. - */ - @Override - public double[] makeCumulativeTestPoints() { - return new double[] { -3.0001, // below lower limit - -3.0, // at lower limit - -2.0, -1.0, 0.0, 1.0, // on lower side - 2.0, // at mode - 3.0, 4.0, 10.0, 11.0, // on upper side - 12.0, // at upper limit - 12.0001 // above upper limit - }; - } - - /** - * Creates the default cumulative probability density test expected values. - */ - @Override - public double[] makeCumulativeTestValues() { - // Top at 2 / (b - a) = 2 / (12 - -3) = 2 / 15 = 7.5 - // Area left = 7.5 * 5 * 0.5 = 18.75 (1/3 of the total area) - // Area right = 7.5 * 10 * 0.5 = 37.5 (2/3 of the total area) - // Area total = 18.75 + 37.5 = 56.25 - // Derivative left side = 7.5 / 5 = 1.5 - // Derivative right side = -7.5 / 10 = -0.75 - double third = 1 / 3.0; - double left = 18.75; - double area = 56.25; - 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 - }; - } - - /** - * Creates the default inverse cumulative probability distribution test - * input values. - */ - @Override - public double[] makeInverseCumulativeTestPoints() { - // Exclude the points outside the limits, as they have cumulative - // probability of zero and one, meaning the inverse returns the - // limits and not the points outside the limits. - double[] points = makeCumulativeTestValues(); - double[] points2 = new double[points.length-2]; - System.arraycopy(points, 1, points2, 0, points2.length); - return points2; - //return Arrays.copyOfRange(points, 1, points.length - 1); - } - - /** - * Creates the default inverse cumulative probability density test expected - * values. - */ - @Override - public double[] makeInverseCumulativeTestValues() { - // Exclude the points outside the limits, as they have cumulative - // probability of zero and one, meaning the inverse returns the - // limits and not the points outside the limits. - double[] points = makeCumulativeTestPoints(); - double[] points2 = new double[points.length-2]; - System.arraycopy(points, 1, points2, 0, points2.length); - return points2; - //return Arrays.copyOfRange(points, 1, points.length - 1); - } - - /** 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 - }; - } - - //--- Additional test cases ----------------------------------------------- - - /** Test lower bound getter. */ - @Test - public void testGetLowerBound() { - TriangularDistribution distribution = makeDistribution(); - Assert.assertEquals(-3.0, distribution.getSupportLowerBound(), 0); - } - - /** Test upper bound getter. */ - @Test - public void testGetUpperBound() { - TriangularDistribution distribution = makeDistribution(); - Assert.assertEquals(12.0, distribution.getSupportUpperBound(), 0); - } - - /** Test pre-condition for equal lower/upper limit. */ - @Test(expected=NumberIsTooLargeException.class) - public void testPreconditions1() { - new TriangularDistribution(0, 0, 0); - } - - /** Test pre-condition for lower limit larger than upper limit. */ - @Test(expected=NumberIsTooLargeException.class) - public void testPreconditions2() { - new TriangularDistribution(1, 1, 0); - } - - /** Test pre-condition for mode larger than upper limit. */ - @Test(expected=NumberIsTooLargeException.class) - public void testPreconditions3() { - new TriangularDistribution(0, 2, 1); - } - - /** Test pre-condition for mode smaller than lower limit. */ - @Test(expected=NumberIsTooSmallException.class) - public void testPreconditions4() { - new TriangularDistribution(2, 1, 3); - } - - /** Test mean/variance. */ - @Test - public void testMeanVariance() { - TriangularDistribution dist; - - dist = new TriangularDistribution(0, 0.5, 1.0); - Assert.assertEquals(dist.getNumericalMean(), 0.5, 0); - Assert.assertEquals(dist.getNumericalVariance(), 1 / 24.0, 0); - - dist = new TriangularDistribution(0, 1, 1); - Assert.assertEquals(dist.getNumericalMean(), 2 / 3.0, 0); - Assert.assertEquals(dist.getNumericalVariance(), 1 / 18.0, 0); - - dist = new TriangularDistribution(-3, 2, 12); - Assert.assertEquals(dist.getNumericalMean(), 3 + (2 / 3.0), 0); - Assert.assertEquals(dist.getNumericalVariance(), 175 / 18.0, 0); - } -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/ef846813/src/test/java/org/apache/commons/math4/distribution/UniformIntegerDistributionTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/distribution/UniformIntegerDistributionTest.java b/src/test/java/org/apache/commons/math4/distribution/UniformIntegerDistributionTest.java deleted file mode 100644 index 7d552dc..0000000 --- a/src/test/java/org/apache/commons/math4/distribution/UniformIntegerDistributionTest.java +++ /dev/null @@ -1,142 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.commons.math4.distribution; - -import org.junit.Assert; -import org.junit.Test; -import org.apache.commons.math4.distribution.IntegerDistribution; -import org.apache.commons.math4.distribution.UniformIntegerDistribution; -import org.apache.commons.math4.exception.NumberIsTooLargeException; -import org.apache.commons.numbers.core.Precision; - -/** - * Test cases for UniformIntegerDistribution. See class javadoc for - * {@link IntegerDistributionAbstractTest} for further details. - */ -public class UniformIntegerDistributionTest extends IntegerDistributionAbstractTest { - - // --- Override tolerance ------------------------------------------------- - - @Override - public void setUp() { - super.setUp(); - setTolerance(1e-9); - } - - //--- Implementations for abstract methods -------------------------------- - - /** Creates the default discrete distribution instance to use in tests. */ - @Override - public IntegerDistribution makeDistribution() { - return new UniformIntegerDistribution(-3, 5); - } - - /** Creates the default probability density test input values. */ - @Override - public int[] makeDensityTestPoints() { - return new int[] {-4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6}; - } - - /** Creates the default probability density test expected values. */ - @Override - public double[] makeDensityTestValues() { - double d = 1.0 / (5 - -3 + 1); - return new double[] {0, d, d, d, d, d, d, d, d, d, 0}; - } - - /** Creates the default cumulative probability density test input values. */ - @Override - public int[] makeCumulativeTestPoints() { - return makeDensityTestPoints(); - } - - /** Creates the default cumulative probability density test expected values. */ - @Override - public double[] makeCumulativeTestValues() { - return new double[] {0, 1 / 9.0, 2 / 9.0, 3 / 9.0, 4 / 9.0, 5 / 9.0, - 6 / 9.0, 7 / 9.0, 8 / 9.0, 1, 1}; - } - - /** Creates the default inverse cumulative probability test input values */ - @Override - public double[] makeInverseCumulativeTestPoints() { - return new double[] {0, 0.001, 0.010, 0.025, 0.050, 0.100, 0.200, - 0.5, 0.999, 0.990, 0.975, 0.950, 0.900, 1}; - } - - /** Creates the default inverse cumulative probability density test expected values */ - @Override - public int[] makeInverseCumulativeTestValues() { - return new int[] {-3, -3, -3, -3, -3, -3, -2, 1, 5, 5, 5, 5, 5, 5}; - } - - //--- Additional test cases ----------------------------------------------- - - /** Test mean/variance. */ - @Test - public void testMoments() { - UniformIntegerDistribution dist; - - dist = new UniformIntegerDistribution(0, 5); - Assert.assertEquals(dist.getNumericalMean(), 2.5, 0); - Assert.assertEquals(dist.getNumericalVariance(), 35 / 12.0, 0); - - dist = new UniformIntegerDistribution(0, 1); - Assert.assertEquals(dist.getNumericalMean(), 0.5, 0); - Assert.assertEquals(dist.getNumericalVariance(), 3 / 12.0, 0); - } - - // MATH-1141 - @Test - public void testPreconditionUpperBoundInclusive() { - try { - new UniformIntegerDistribution(1, 0); - } catch (NumberIsTooLargeException e) { - // Expected. - } - - // Degenerate case is allowed. - new UniformIntegerDistribution(0, 0); - } - - // MATH-1396 - @Test - public void testLargeRangeSubtractionOverflow() { - final int hi = Integer.MAX_VALUE / 2 + 10; - UniformIntegerDistribution dist = new UniformIntegerDistribution(-hi, hi - 1); - - final double tol = Math.ulp(1d); - Assert.assertEquals(0.5 / hi, dist.probability(123456), tol); - Assert.assertEquals(0.5, dist.cumulativeProbability(-1), tol); - - Assert.assertTrue(Precision.equals((Math.pow(2d * hi, 2) - 1) / 12, dist.getNumericalVariance(), 1)); - } - - // MATH-1396 - @Test - public void testLargeRangeAdditionOverflow() { - final int hi = Integer.MAX_VALUE / 2 + 10; - UniformIntegerDistribution dist = new UniformIntegerDistribution(hi - 1, hi + 1); - - final double tol = Math.ulp(1d); - Assert.assertEquals(1d / 3d, dist.probability(hi), tol); - Assert.assertEquals(2d / 3d, dist.cumulativeProbability(hi), tol); - - Assert.assertTrue(Precision.equals(hi, dist.getNumericalMean(), 1)); - } -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/ef846813/src/test/java/org/apache/commons/math4/distribution/UniformRealDistributionTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/distribution/UniformRealDistributionTest.java b/src/test/java/org/apache/commons/math4/distribution/UniformRealDistributionTest.java deleted file mode 100644 index f09f876..0000000 --- a/src/test/java/org/apache/commons/math4/distribution/UniformRealDistributionTest.java +++ /dev/null @@ -1,125 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.commons.math4.distribution; - -import org.apache.commons.math4.distribution.UniformRealDistribution; -import org.apache.commons.math4.exception.NumberIsTooLargeException; -import org.junit.Assert; -import org.junit.Test; - -/** - * Test cases for UniformRealDistribution. See class javadoc for - * {@link RealDistributionAbstractTest} for further details. - */ -public class UniformRealDistributionTest extends RealDistributionAbstractTest { - - // --- Override tolerance ------------------------------------------------- - - @Override - public void setUp() { - super.setUp(); - setTolerance(1e-4); - } - - //--- Implementations for abstract methods -------------------------------- - - /** Creates the default uniform real distribution instance to use in tests. */ - @Override - public UniformRealDistribution makeDistribution() { - return new UniformRealDistribution(-0.5, 1.25); - } - - /** Creates the default cumulative probability distribution test input values */ - @Override - public double[] makeCumulativeTestPoints() { - return new double[] {-0.5001, -0.5, -0.4999, -0.25, -0.0001, 0.0, - 0.0001, 0.25, 1.0, 1.2499, 1.25, 1.2501}; - } - - /** 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}; - } - - /** Creates the default probability density test expected values */ - @Override - public double[] makeDensityTestValues() { - double d = 1 / 1.75; - return new double[] {0, d, d, d, d, d, d, d, d, d, d, 0}; - } - - //--- Additional test cases ----------------------------------------------- - - /** Test lower bound getter. */ - @Test - public void testGetLowerBound() { - UniformRealDistribution distribution = makeDistribution(); - Assert.assertEquals(-0.5, distribution.getSupportLowerBound(), 0); - } - - /** Test upper bound getter. */ - @Test - public void testGetUpperBound() { - UniformRealDistribution distribution = makeDistribution(); - Assert.assertEquals(1.25, distribution.getSupportUpperBound(), 0); - } - - /** Test pre-condition for equal lower/upper bound. */ - @Test(expected=NumberIsTooLargeException.class) - public void testPreconditions1() { - new UniformRealDistribution(0, 0); - } - - /** Test pre-condition for lower bound larger than upper bound. */ - @Test(expected=NumberIsTooLargeException.class) - public void testPreconditions2() { - new UniformRealDistribution(1, 0); - } - - /** Test mean/variance. */ - @Test - public void testMeanVariance() { - UniformRealDistribution dist; - - dist = new UniformRealDistribution(0, 1); - Assert.assertEquals(dist.getNumericalMean(), 0.5, 0); - Assert.assertEquals(dist.getNumericalVariance(), 1/12.0, 0); - - dist = new UniformRealDistribution(-1.5, 0.6); - Assert.assertEquals(dist.getNumericalMean(), -0.45, 0); - Assert.assertEquals(dist.getNumericalVariance(), 0.3675, 0); - - dist = new UniformRealDistribution(-0.5, 1.25); - Assert.assertEquals(dist.getNumericalMean(), 0.375, 0); - Assert.assertEquals(dist.getNumericalVariance(), 0.2552083333333333, 0); - } - - /** - * Check accuracy of analytical inverse CDF. Fails if a solver is used - * with the default accuracy. - */ - @Test - public void testInverseCumulativeDistribution() { - UniformRealDistribution dist = new UniformRealDistribution(0, 1e-9); - - Assert.assertEquals(2.5e-10, dist.inverseCumulativeProbability(0.25), 0); - } -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/ef846813/src/test/java/org/apache/commons/math4/distribution/WeibullDistributionTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/distribution/WeibullDistributionTest.java b/src/test/java/org/apache/commons/math4/distribution/WeibullDistributionTest.java deleted file mode 100644 index 1f5846d..0000000 --- a/src/test/java/org/apache/commons/math4/distribution/WeibullDistributionTest.java +++ /dev/null @@ -1,126 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.commons.math4.distribution; - -import org.apache.commons.math4.distribution.WeibullDistribution; -import org.apache.commons.math4.exception.NotStrictlyPositiveException; -import org.apache.commons.numbers.gamma.LogGamma; -import org.apache.commons.math4.util.FastMath; -import org.junit.Assert; -import org.junit.Test; - -/** - * Test cases for WeibullDistribution. - * Extends ContinuousDistributionAbstractTest. See class javadoc for - * ContinuousDistributionAbstractTest for details. - * - */ -public class WeibullDistributionTest extends RealDistributionAbstractTest { - - //-------------- Implementations for abstract methods ----------------------- - - /** Creates the default continuous distribution instance to use in tests. */ - @Override - public WeibullDistribution makeDistribution() { - return new WeibullDistribution(1.2, 2.1); - } - - /** Creates the default cumulative probability distribution test input values */ - @Override - public double[] makeCumulativeTestPoints() { - // quantiles computed using R version 2.9.2 - return new double[] {0.00664355180993, 0.0454328283309, 0.0981162737374, 0.176713524579, 0.321946865392, - 10.5115496887, 7.4976304671, 6.23205600701, 5.23968436955, 4.2079028257}; - } - - /** Creates the default cumulative probability density test expected values */ - @Override - public double[] makeCumulativeTestValues() { - return new double[] {0.001, 0.01, 0.025, 0.05, 0.1, 0.999, 0.990, 0.975, 0.950, 0.900}; - } - - /** Creates the default probability density test expected values */ - @Override - public double[] makeDensityTestValues() { - return new double[] {0.180535929306, 0.262801138133, 0.301905425199, 0.330899152971, - 0.353441418887, 0.000788590320203, 0.00737060094841, 0.0177576041516, 0.0343043442574, 0.065664589369}; - } - - //---------------------------- Additional test cases ------------------------- - - @Test - public void testInverseCumulativeProbabilitySmallPAccuracy() { - WeibullDistribution dist = new WeibullDistribution(2, 3); - double t = dist.inverseCumulativeProbability(1e-17); - // Analytically, answer is solution to 1e-17 = 1-exp(-(x/3)^2) - // x = sqrt(-9*log(1-1e-17)) - // If we're not careful, answer will be 0. Answer below is computed with care in Octave: - Assert.assertEquals(9.48683298050514e-9, t, 1e-17); - } - - @Test - public void testInverseCumulativeProbabilityExtremes() { - setInverseCumulativeTestPoints(new double[] {0.0, 1.0}); - setInverseCumulativeTestValues( - new double[] {0.0, Double.POSITIVE_INFINITY}); - verifyInverseCumulativeProbabilities(); - } - - @Test - public void testAlpha() { - WeibullDistribution dist = new WeibullDistribution(1, 2); - Assert.assertEquals(1, dist.getShape(), 0); - try { - new WeibullDistribution(0, 2); - Assert.fail("NotStrictlyPositiveException expected"); - } catch (NotStrictlyPositiveException e) { - // Expected. - } - } - - @Test - public void testBeta() { - WeibullDistribution dist = new WeibullDistribution(1, 2); - Assert.assertEquals(2, dist.getScale(), 0); - try { - new WeibullDistribution(1, 0); - Assert.fail("NotStrictlyPositiveException expected"); - } catch (NotStrictlyPositiveException e) { - // Expected. - } - } - - @Test - public void testMoments() { - final double tol = 1e-9; - WeibullDistribution dist; - - dist = new WeibullDistribution(2.5, 3.5); - // In R: 3.5*gamma(1+(1/2.5)) (or emperically: mean(rweibull(10000, 2.5, 3.5))) - Assert.assertEquals(dist.getNumericalMean(), 3.5 * FastMath.exp(LogGamma.value(1 + (1 / 2.5))), tol); - Assert.assertEquals(dist.getNumericalVariance(), (3.5 * 3.5) * - FastMath.exp(LogGamma.value(1 + (2 / 2.5))) - - (dist.getNumericalMean() * dist.getNumericalMean()), tol); - - dist = new WeibullDistribution(10.4, 2.222); - Assert.assertEquals(dist.getNumericalMean(), 2.222 * FastMath.exp(LogGamma.value(1 + (1 / 10.4))), tol); - Assert.assertEquals(dist.getNumericalVariance(), (2.222 * 2.222) * - FastMath.exp(LogGamma.value(1 + (2 / 10.4))) - - (dist.getNumericalMean() * dist.getNumericalMean()), tol); - } -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/ef846813/src/test/java/org/apache/commons/math4/distribution/ZipfDistributionTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/distribution/ZipfDistributionTest.java b/src/test/java/org/apache/commons/math4/distribution/ZipfDistributionTest.java deleted file mode 100644 index ca28514..0000000 --- a/src/test/java/org/apache/commons/math4/distribution/ZipfDistributionTest.java +++ /dev/null @@ -1,197 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.commons.math4.distribution; - -import org.apache.commons.math4.TestUtils; -import org.apache.commons.math4.exception.NotStrictlyPositiveException; -import org.apache.commons.rng.simple.RandomSource; -import org.apache.commons.math4.util.FastMath; -import org.junit.Assert; -import org.junit.Ignore; -import org.junit.Test; - -/** - * Test cases for {@link ZipfDistribution}. - * Extends IntegerDistributionAbstractTest. - * See class javadoc for IntegerDistributionAbstractTest for details. - */ -public class ZipfDistributionTest extends IntegerDistributionAbstractTest { - - /** - * Constructor to override default tolerance. - */ - public ZipfDistributionTest() { - setTolerance(1e-12); - } - - @Test(expected=NotStrictlyPositiveException.class) - public void testPreconditions1() { - new ZipfDistribution(0, 1); - } - - @Test(expected=NotStrictlyPositiveException.class) - public void testPreconditions2() { - new ZipfDistribution(1, 0); - } - - //-------------- Implementations for abstract methods ----------------------- - - /** Creates the default discrete distribution instance to use in tests. */ - @Override - public IntegerDistribution makeDistribution() { - return new ZipfDistribution(10, 1); - } - - /** 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}; - } - - /** - * Creates the default probability density test expected values. - * Reference values are from R, version 2.15.3 (VGAM package 0.9-0). - */ - @Override - public double[] makeDensityTestValues() { - return new double[] {0d, 0d, 0.341417152147, 0.170708576074, 0.113805717382, 0.0853542880369, 0.0682834304295, - 0.0569028586912, 0.0487738788782, 0.0426771440184, 0.0379352391275, 0.0341417152147, 0}; - } - - /** - * Creates the default logarithmic probability density test expected values. - * Reference values are from R, version 2.14.1. - */ - @Override - public double[] makeLogDensityTestValues() { - return new double[] {Double.NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY, - -1.07465022926458, -1.76779740982453, -2.17326251793269, -2.46094459038447, - -2.68408814169868, -2.86640969849264, -3.0205603783199, -3.15409177094442, - -3.2718748066008, -3.37723532225863, Double.NEGATIVE_INFINITY}; - } - - /** Creates the default cumulative probability density test input values */ - @Override - public int[] makeCumulativeTestPoints() { - return makeDensityTestPoints(); - } - - /** Creates the default cumulative probability density test expected values */ - @Override - public double[] makeCumulativeTestValues() { - return new double[] {0, 0, 0.341417152147, 0.512125728221, 0.625931445604, 0.71128573364, - 0.77956916407, 0.836472022761, 0.885245901639, 0.927923045658, 0.965858284785, 1d, 1d}; - } - - /** Creates the default inverse cumulative probability test input values */ - @Override - public double[] makeInverseCumulativeTestPoints() { - return new double[] {0d, 0.001d, 0.010d, 0.025d, 0.050d, 0.3413d, 0.3415d, 0.999d, - 0.990d, 0.975d, 0.950d, 0.900d, 1d}; - } - - /** Creates the default inverse cumulative probability density test expected values */ - @Override - public int[] makeInverseCumulativeTestValues() { - return new int[] {1, 1, 1, 1, 1, 1, 2, 10, 10, 10, 9, 8, 10}; - } - - @Test - public void testMoments() { - final double tol = 1e-9; - ZipfDistribution dist; - - dist = new ZipfDistribution(2, 0.5); - Assert.assertEquals(dist.getNumericalMean(), FastMath.sqrt(2), tol); - Assert.assertEquals(dist.getNumericalVariance(), 0.24264068711928521, tol); - } - - - /** - * Test sampling for various number of points and exponents. - */ - @Test - public void testSamplingExtended() { - int sampleSize = 1000; - - int[] numPointsValues = { - 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20, 25, 30, 35, 40, 45, 50, 60, 70, 80, 90, 100 - }; - double[] exponentValues = { - 1e-10, 1e-9, 1e-8, 1e-7, 1e-6, 1e-5, 1e-4, 1e-3, 1e-2, 1e-1, 2e-1, 5e-1, - 1. - 1e-9, 1.0, 1. + 1e-9, 1.1, 1.2, 1.3, 1.5, 1.6, 1.7, 1.8, 2.0, - 2.5, 3.0, 4., 5., 6., 7., 8., 9., 10., 20., 30., 100., 150. - }; - - for (int numPoints : numPointsValues) { - for (double exponent : exponentValues) { - 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]; - } - - // 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 - IntegerDistribution.Sampler distribution = - 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); - } - int[] sample = AbstractIntegerDistribution.sample(sampleSize, distribution); - for (int s : sample) { - observedCounts[s-1]++; - } - TestUtils.assertChiSquareAccept(expectedCounts, observedCounts, 0.001); - } - } - } - - @Ignore - @Test - public void testSamplerPerformance() { - int[] numPointsValues = {1, 2, 5, 10, 100, 1000, 10000}; - double[] exponentValues = {1e-3, 1e-2, 1e-1, 1., 2., 5., 10.}; - int numGeneratedSamples = 1000000; - - long sum = 0; - - for (int numPoints : numPointsValues) { - for (double exponent : exponentValues) { - long start = System.currentTimeMillis(); - final int[] randomNumberCounter = new int[1]; - - final IntegerDistribution.Sampler distribution = - new ZipfDistribution(numPoints, exponent).createSampler(RandomSource.create(RandomSource.WELL_1024_A)); - for (int i = 0; i < numGeneratedSamples; ++i) { - sum += distribution.sample(); - } - - long end = System.currentTimeMillis(); - System.out.println("n = " + numPoints + ", exponent = " + exponent + ", avg number consumed random values = " + (double)(randomNumberCounter[0])/numGeneratedSamples + ", measured time = " + (end-start)/1000. + "s"); - } - } - System.out.println(sum); - } - -}
