Return-Path: Delivered-To: apmail-jakarta-commons-dev-archive@apache.org Received: (qmail 34959 invoked from network); 14 Jun 2003 04:24:47 -0000 Received: from exchange.sun.com (192.18.33.10) by daedalus.apache.org with SMTP; 14 Jun 2003 04:24:47 -0000 Received: (qmail 29812 invoked by uid 97); 14 Jun 2003 04:27:13 -0000 Delivered-To: qmlist-jakarta-archive-commons-dev@nagoya.betaversion.org Received: (qmail 29805 invoked from network); 14 Jun 2003 04:27:13 -0000 Received: from daedalus.apache.org (HELO apache.org) (208.185.179.12) by nagoya.betaversion.org with SMTP; 14 Jun 2003 04:27:13 -0000 Received: (qmail 34707 invoked by uid 500); 14 Jun 2003 04:24:45 -0000 Mailing-List: contact commons-dev-help@jakarta.apache.org; run by ezmlm Precedence: bulk List-Unsubscribe: List-Subscribe: List-Help: List-Post: List-Id: "Jakarta Commons Developers List" Reply-To: "Jakarta Commons Developers List" Delivered-To: mailing list commons-dev@jakarta.apache.org Received: (qmail 34696 invoked by uid 500); 14 Jun 2003 04:24:44 -0000 Received: (qmail 34693 invoked from network); 14 Jun 2003 04:24:44 -0000 Received: from icarus.apache.org (208.185.179.13) by daedalus.apache.org with SMTP; 14 Jun 2003 04:24:44 -0000 Received: (qmail 93427 invoked by uid 1674); 14 Jun 2003 04:24:43 -0000 Date: 14 Jun 2003 04:24:43 -0000 Message-ID: <20030614042443.93426.qmail@icarus.apache.org> From: mdiggory@apache.org To: jakarta-commons-sandbox-cvs@apache.org Subject: cvs commit: jakarta-commons-sandbox/math/src/java/org/apache/commons/math/stat/distribution ExponentialDistributionImpl.java X-Spam-Rating: daedalus.apache.org 1.6.2 0/1000/N X-Spam-Rating: daedalus.apache.org 1.6.2 0/1000/N mdiggory 2003/06/13 21:24:43 Modified: math/src/test/org/apache/commons/math/stat/distribution ExponentialDistributionTest.java math/src/java/org/apache/commons/math/stat/distribution ExponentialDistributionImpl.java Added: math/src/test/org/apache/commons/math TestUtils.java Log: PR: http://nagoya.apache.org/bugzilla/show_bug.cgi?id=20773 Submitted by: brent@worden.org Revision Changes Path 1.1 jakarta-commons-sandbox/math/src/test/org/apache/commons/math/TestUtils.java Index: TestUtils.java =================================================================== package org.apache.commons.math; import junit.framework.Assert; /** * @author Brent Worden */ public class TestUtils { /** * */ private TestUtils() { super(); } public static void assertEquals(double expected, double actual, double delta) { // check for NaN if(Double.isNaN(expected)){ Assert.assertTrue(Double.isNaN(actual)); } else { Assert.assertEquals(expected, actual, delta); } } } 1.2 +96 -17 jakarta-commons-sandbox/math/src/test/org/apache/commons/math/stat/distribution/ExponentialDistributionTest.java Index: ExponentialDistributionTest.java =================================================================== RCS file: /home/cvs/jakarta-commons-sandbox/math/src/test/org/apache/commons/math/stat/distribution/ExponentialDistributionTest.java,v retrieving revision 1.1 retrieving revision 1.2 diff -u -r1.1 -r1.2 --- ExponentialDistributionTest.java 13 Jun 2003 13:22:40 -0000 1.1 +++ ExponentialDistributionTest.java 14 Jun 2003 04:24:43 -0000 1.2 @@ -53,6 +53,8 @@ */ package org.apache.commons.math.stat.distribution; +import org.apache.commons.math.TestUtils; + import junit.framework.TestCase; /** @@ -85,45 +87,122 @@ super.tearDown(); } - public void testLowerTailProbability(){ + public void testInverseCummulativeProbability001() { + testValue(.005003, .001); + } + + public void testInverseCummulativeProbability010() { + testValue(0.050252, .010); + } + + public void testInverseCummulativeProbability025() { + testValue(0.126589, .025); + } + + public void testInverseCummulativeProbability050() { + testValue(0.256566, .050); + } + + public void testInverseCummulativeProbability100() { + testValue(0.526803, .100); + } + + public void testInverseCummulativeProbability999() { + testValue(34.5388, .999); + } + + public void testInverseCummulativeProbability990() { + testValue(23.0259, .990); + } + + public void testInverseCummulativeProbability975() { + testValue(18.4444, .975); + } + + public void testInverseCummulativeProbability950() { + testValue(14.9787, .950); + } + + public void testInverseCummulativeProbability900() { + testValue(11.5129, .900); + } + + public void testCummulativeProbability001() { testProbability(0.005003, .001); + } + + public void testCummulativeProbability010() { testProbability(0.050252, .010); + } + + public void testCummulativeProbability025() { testProbability(0.126589, .025); + } + + public void testCummulativeProbability050() { testProbability(0.256566, .050); + } + + public void testCummulativeProbability100() { testProbability(0.526803, .100); } - public void testUpperTailProbability(){ + public void testCummulativeProbability999() { testProbability(34.5388, .999); + } + + public void testCummulativeProbability990() { testProbability(23.0259, .990); + } + + public void testCummulativeProbability975() { testProbability(18.4444, .975); + } + + public void testCummulativeProbability950() { testProbability(14.9787, .950); - testProbability(11.5129, .900); } - public void testLowerTailValues(){ - testValue(0.005003, .001); - testValue(0.050252, .010); - testValue(0.126589, .025); - testValue(0.256566, .050); - testValue(0.526803, .100); + public void testCummulativeProbability900() { + testProbability(11.5129, .900); + } + + public void testCummulativeProbabilityNegative() { + testProbability(-1.0, 0.0); + } + + public void testCummulativeProbabilityZero() { + testProbability(0.0, 0.0); + } + + public void testInverseCummulativeProbabilityNegative() { + testValue(Double.NaN, -1.0); + } + + public void testInverseCummulativeProbabilityZero() { + testValue(0.0, 0.0); + } + + public void testInverseCummulativeProbabilityOne() { + testValue(Double.POSITIVE_INFINITY, 1.0); + } + + public void testInverseCummulativeProbabilityPositive() { + testValue(Double.NaN, 2.0); } - public void testUpperTailValues(){ - testValue(34.5388, .999); - testValue(23.0259, .990); - testValue(18.4444, .975); - testValue(14.9787, .950); - testValue(11.5129, .900); + public void testCummulativeProbability2() { + double actual = exp.cummulativeProbability(0.25, 0.75); + assertEquals(0.0905214, actual, 10e-4); } private void testProbability(double x, double expected){ double actual = exp.cummulativeProbability(x); - assertEquals("probability for " + x, expected, actual, 10e-4); + TestUtils.assertEquals(expected, actual, 10e-4); } private void testValue(double expected, double p){ double actual = exp.inverseCummulativeProbability(p); - assertEquals("value for " + p, expected, actual, 10e-4); + TestUtils.assertEquals(expected, actual, 10e-4); } } 1.2 +20 -44 jakarta-commons-sandbox/math/src/java/org/apache/commons/math/stat/distribution/ExponentialDistributionImpl.java Index: ExponentialDistributionImpl.java =================================================================== RCS file: /home/cvs/jakarta-commons-sandbox/math/src/java/org/apache/commons/math/stat/distribution/ExponentialDistributionImpl.java,v retrieving revision 1.1 retrieving revision 1.2 diff -u -r1.1 -r1.2 --- ExponentialDistributionImpl.java 13 Jun 2003 13:22:41 -0000 1.1 +++ ExponentialDistributionImpl.java 14 Jun 2003 04:24:43 -0000 1.2 @@ -6,7 +6,6 @@ * @author Brent Worden */ public class ExponentialDistributionImpl - extends AbstractContinuousDistribution implements ExponentialDistribution { /** The mean of this distribution. */ @@ -21,45 +20,6 @@ setMean(mean); } - - /** - * Access the domain value lower bound, based on p, used to - * bracket a CDF root. This method is used by - * {@link #inverseCummulativeProbability(double)} to find critical values. - * - * @param p the desired probability for the critical value - * @return domain value lower bound, i.e. - * P(X < lower bound) < p - */ - protected double getDomainLowerBound(double p){ - return 0.0; - } - - /** - * Access the domain value upper bound, based on p, used to - * bracket a CDF root. This method is used by - * {@link #inverseCummulativeProbability(double)} to find critical values. - * - * @param p the desired probability for the critical value - * @return domain value upper bound, i.e. - * P(X < upper bound) > p - */ - protected double getDomainUpperBound(double p){ - return Double.MAX_VALUE; - } - - /** - * Access the initial domain value, based on p, used to - * bracket a CDF root. This method is used by - * {@link #inverseCummulativeProbability(double)} to find critical values. - * - * @param p the desired probability for the critical value - * @return initial domain value - */ - protected double getInitialDomain(double p){ - return getMean(); - } - /** * Modify the mean. * @param mean the new mean. @@ -98,7 +58,7 @@ */ public double cummulativeProbability(double x) { double ret; - if(x < 0.0){ + if(x <= 0.0){ ret = 0.0; } else { ret = 1.0 - Math.exp(-x / getMean()); @@ -114,10 +74,26 @@ * @return x, such that P(X < x) = p */ public double inverseCummulativeProbability(double p){ + double ret; + if(p < 0.0 || p > 1.0){ - throw new IllegalArgumentException( - "p must be between 0.0 and 1.0, inclusive."); + ret = Double.NaN; + } else if(p == 1.0){ + ret = Double.POSITIVE_INFINITY; + } else { + ret = -getMean() * Math.log(1.0 - p); } - return -getMean() * Math.log(1.0 - p); + + return ret; + } + + /** + * For this disbution, X, this method returns P(x0 < X < x1). + * @param x0 the lower bound + * @param x1 the upper bound + * @return the cummulative probability. + */ + public double cummulativeProbability(double x0, double x1) { + return cummulativeProbability(x1) - cummulativeProbability(x0); } } --------------------------------------------------------------------- To unsubscribe, e-mail: commons-dev-unsubscribe@jakarta.apache.org For additional commands, e-mail: commons-dev-help@jakarta.apache.org