Apache
/
commons-math
mirror of https://github.com/apache/commons-math.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

- In distribution.AbstractRealDistribution, removed superfluous methods getDomainLowerBound(double), getDomainUpperBound(double) and getInitialDomain(double p) (MATH-699). 

- Resolved checkstyle issues in the distribution package.
- Improved Javadoc of RealDistribution.getSupportLowerBound(), RealDistribution.getSupportUpperBound() and AbstractRealDistribution.inverseCumulativeDistribution(double).

git-svn-id: https://svn.apache.org/repos/asf/commons/proper/math/trunk@1209963 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Sebastien Brisard 2011-12-03 18:23:02 +00:00
parent b2e24119bc
commit f880c83e06
20 changed files with 115 additions and 432 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

77
src/main/java/org/apache/commons/math/distribution/AbstractRealDistribution.java
View File

@ -37,12 +37,12 @@ import org.apache.commons.math.util.FastMath;
*/
public abstract class AbstractRealDistribution
implements RealDistribution, Serializable {
/** Serializable version identifier */
private static final long serialVersionUID = -38038050983108802L;
/** Default accuracy. */
public static final double SOLVER_DEFAULT_ABSOLUTE_ACCURACY = 1e-6;
/** Serializable version identifier */
private static final long serialVersionUID = -38038050983108802L;
/** Solver absolute accuracy for inverse cumulative computation */
private double solverAbsoluteAccuracy = SOLVER_DEFAULT_ABSOLUTE_ACCURACY;
@ -66,8 +66,44 @@ implements RealDistribution, Serializable {
return cumulativeProbability(x1) - cumulativeProbability(x0);
}
/** {@inheritDoc} */
/**
* {@inheritDoc}
*
* The default implementation returns
* <ul>
* <li>{@link #getSupportLowerBound()} for {@code p = 0},</li>
* <li>{@link #getSupportUpperBound()} for {@code p = 1}.</li>
* </ul>
*/
public double inverseCumulativeProbability(final double p) throws OutOfRangeException {
/*
* IMPLEMENTATION NOTES
* --------------------
* Where applicable, use is made of the one-sided Chebyshev inequality
* to bracket the root. This inequality states that
* P(X - mu >= k * sig) <= 1 / (1 + k^2),
* mu: mean, sig: standard deviation. Equivalently
* 1 - P(X < mu + k * sig) <= 1 / (1 + k^2),
* F(mu + k * sig) >= k^2 / (1 + k^2).
*
* For k = sqrt(p / (1 - p)), we find
* F(mu + k * sig) >= p,
* and (mu + k * sig) is an upper-bound for the root.
*
* Then, introducing Y = -X, mean(Y) = -mu, sd(Y) = sig, and
* P(Y >= -mu + k * sig) <= 1 / (1 + k^2),
* P(-X >= -mu + k * sig) <= 1 / (1 + k^2),
* P(X <= mu - k * sig) <= 1 / (1 + k^2),
* F(mu - k * sig) <= 1 / (1 + k^2).
*
* For k = sqrt((1 - p) / p), we find
* F(mu - k * sig) <= p,
* and (mu - k * sig) is a lower-bound for the root.
*
* In cases where the Chebyshev inequality does not apply, geometric
* progressions 1, 2, 4, ... and -1, -2, -4, ... are used to bracket
* the root.
*/
if (p < 0.0 || p > 1.0) {
throw new OutOfRangeException(p, 0, 1);
}
@ -144,39 +180,6 @@ implements RealDistribution, Serializable {
return x;
}
/**
* Access the initial domain value, based on {@code p}, used to
* bracket a CDF root. This method is used by
* {@link #inverseCumulativeProbability(double)} to find critical values.
*
* @param p Desired probability for the critical value.
* @return the initial domain value.
* TODO to be deleted when applying MATH-699
*/
protected abstract double getInitialDomain(double p);
/**
* Access the domain value lower bound, based on {@code p}, used to
* bracket a CDF root. This method is used by
* {@link #inverseCumulativeProbability(double)} to find critical values.
*
* @param p Desired probability for the critical value.
* @return the domain value lower bound, i.e. {@code P(X < 'lower bound') < p}.
* TODO to be deleted when applying MATH-699
*/
protected abstract double getDomainLowerBound(double p);
/**
* Access the domain value upper bound, based on {@code p}, used to
* bracket a CDF root. This method is used by
* {@link #inverseCumulativeProbability(double)} to find critical values.
*
* @param p Desired probability for the critical value.
* @return the domain value upper bound, i.e. {@code P(X < 'upper bound') > p}.
* TODO to be deleted when applying MATH-699
*/
protected abstract double getDomainUpperBound(double p);
/**
* Returns the solver absolute accuracy for inverse cumulative computation.
* You can override this method in order to use a Brent solver with an

18
src/main/java/org/apache/commons/math/distribution/BetaDistribution.java
View File

@ -145,24 +145,6 @@ public class BetaDistribution extends AbstractRealDistribution {
}
}
/** {@inheritDoc} */
@Override
protected double getInitialDomain(double p) {
return p;
}
/** {@inheritDoc} */
@Override
protected double getDomainLowerBound(double p) {
return 0;
}
/** {@inheritDoc} */
@Override
protected double getDomainUpperBound(double p) {
return 1;
}
/** {@inheritDoc} */
public double cumulativeProbability(double x) {
if (x <= 0) {

44
src/main/java/org/apache/commons/math/distribution/CauchyDistribution.java
View File

@ -144,50 +144,6 @@ public class CauchyDistribution extends AbstractRealDistribution {
return ret;
}
/** {@inheritDoc} */
@Override
protected double getDomainLowerBound(double p) {
double ret;
if (p < 0.5) {
ret = -Double.MAX_VALUE;
} else {
ret = median;
}
return ret;
}
/** {@inheritDoc} */
@Override
protected double getDomainUpperBound(double p) {
double ret;
if (p < 0.5) {
ret = median;
} else {
ret = Double.MAX_VALUE;
}
return ret;
}
/** {@inheritDoc} */
@Override
protected double getInitialDomain(double p) {
double ret;
if (p < 0.5) {
ret = median - scale;
} else if (p > 0.5) {
ret = median + scale;
} else {
ret = median;
}
return ret;
}
/** {@inheritDoc} */
@Override
protected double getSolverAbsoluteAccuracy() {

44
src/main/java/org/apache/commons/math/distribution/ChiSquaredDistribution.java
View File

@ -108,50 +108,6 @@ public class ChiSquaredDistribution extends AbstractRealDistribution {
return super.inverseCumulativeProbability(p);
}
/** {@inheritDoc} */
@Override
protected double getDomainLowerBound(double p) {
return Double.MIN_VALUE * gamma.getBeta();
}
/** {@inheritDoc} */
@Override
protected double getDomainUpperBound(double p) {
// NOTE: chi squared is skewed to the left
// NOTE: therefore, P(X < &mu;) > .5
double ret;
if (p < .5) {
// use mean
ret = getDegreesOfFreedom();
} else {
// use max
ret = Double.MAX_VALUE;
}
return ret;
}
/** {@inheritDoc} */
@Override
protected double getInitialDomain(double p) {
// NOTE: chi squared is skewed to the left
// NOTE: therefore, P(X < &mu;) > 0.5
double ret;
if (p < 0.5) {
// use 1/2 mean
ret = getDegreesOfFreedom() * 0.5;
} else {
// use mean
ret = getDegreesOfFreedom();
}
return ret;
}
/** {@inheritDoc} */
@Override
protected double getSolverAbsoluteAccuracy() {

38
src/main/java/org/apache/commons/math/distribution/ExponentialDistribution.java
View File

@ -153,44 +153,6 @@ public class ExponentialDistribution extends AbstractRealDistribution {
return randomData.nextExponential(mean);
}
/** {@inheritDoc} */
@Override
protected double getDomainLowerBound(double p) {
return 0;
}
/** {@inheritDoc} */
@Override
protected double getDomainUpperBound(double p) {
// NOTE: exponential is skewed to the left
// NOTE: therefore, P(X < &mu;) > .5
if (p < 0.5) {
// use mean
return mean;
} else {
// use max
return Double.MAX_VALUE;
}
}
/** {@inheritDoc} */
@Override
protected double getInitialDomain(double p) {
// TODO: try to improve on this estimate
// TODO: what should really happen here is not derive from
// AbstractContinuousDistribution
// TODO: because the inverse cumulative distribution is simple.
// Exponential is skewed to the left, therefore, P(X < &mu;) > .5
if (p < 0.5) {
// use 1/2 mean
return mean * 0.5;
} else {
// use mean
return mean;
}
}
/** {@inheritDoc} */
@Override
protected double getSolverAbsoluteAccuracy() {

30
src/main/java/org/apache/commons/math/distribution/FDistribution.java
View File

@ -31,15 +31,15 @@ import org.apache.commons.math.util.FastMath;
* @version $Id$
*/
public class FDistribution extends AbstractRealDistribution {
/** Serializable version identifier. */
private static final long serialVersionUID = -8516354193418641566L;
/**
* Default inverse cumulative probability accuracy.
* @since 2.1
*/
public static final double DEFAULT_INVERSE_ABSOLUTE_ACCURACY = 1e-9;
/** Serializable version identifier. */
private static final long serialVersionUID = -8516354193418641566L;
/** The numerator degrees of freedom. */
private final double numeratorDegreesOfFreedom;
@ -172,30 +172,6 @@ public class FDistribution extends AbstractRealDistribution {
return super.inverseCumulativeProbability(p);
}
/** {@inheritDoc} */
@Override
protected double getDomainLowerBound(double p) {
return 0;
}
/** {@inheritDoc} */
@Override
protected double getDomainUpperBound(double p) {
return Double.MAX_VALUE;
}
/** {@inheritDoc} */
@Override
protected double getInitialDomain(double p) {
double ret = 1;
double d = denominatorDegreesOfFreedom;
if (d > 2) {
// use mean
ret = d / (d - 2);
}
return ret;
}
/**
* Access the numerator degrees of freedom.
*

46
src/main/java/org/apache/commons/math/distribution/GammaDistribution.java
View File

@ -161,52 +161,6 @@ public class GammaDistribution extends AbstractRealDistribution {
return super.inverseCumulativeProbability(p);
}
/** {@inheritDoc} */
@Override
protected double getDomainLowerBound(double p) {
// TODO: try to improve on this estimate
return Double.MIN_VALUE;
}
/** {@inheritDoc} */
@Override
protected double getDomainUpperBound(double p) {
// TODO: try to improve on this estimate
// NOTE: gamma is skewed to the left
// NOTE: therefore, P(X < &mu;) > .5
double ret;
if (p < 0.5) {
// use mean
ret = alpha * beta;
} else {
// use max value
ret = Double.MAX_VALUE;
}
return ret;
}
/** {@inheritDoc} */
@Override
protected double getInitialDomain(double p) {
// TODO: try to improve on this estimate
// Gamma is skewed to the left, therefore, P(X < &mu;) > .5
double ret;
if (p < 0.5) {
// use 1/2 mean
ret = alpha * beta * 0.5;
} else {
// use mean
ret = alpha * beta;
}
return ret;
}
/** {@inheritDoc} */
@Override
protected double getSolverAbsoluteAccuracy() {

5
src/main/java/org/apache/commons/math/distribution/IntegerDistribution.java
View File

@ -93,9 +93,8 @@ public interface IntegerDistribution {
* Use this method to get the numerical value of the variance of this
* distribution.
*
* @return the variance (possibly {@code Double.POSITIVE_INFINITY} as
* for certain cases in {@link TDistributionImpl}) or
* {@code Double.NaN} if it is not defined
* @return the variance (possibly {@code Double.POSITIVE_INFINITY} or
* {@code Double.NaN} if it is not defined)
*/
double getNumericalVariance();

44
src/main/java/org/apache/commons/math/distribution/NormalDistribution.java
View File

@ -172,50 +172,6 @@ public class NormalDistribution extends AbstractRealDistribution {
return super.inverseCumulativeProbability(p);
}
/** {@inheritDoc} */
@Override
protected double getDomainLowerBound(double p) {
double ret;
if (p < 0.5) {
ret = -Double.MAX_VALUE;
} else {
ret = mean;
}
return ret;
}
/** {@inheritDoc} */
@Override
protected double getDomainUpperBound(double p) {
double ret;
if (p < 0.5) {
ret = mean;
} else {
ret = Double.MAX_VALUE;
}
return ret;
}
/** {@inheritDoc} */
@Override
protected double getInitialDomain(double p) {
double ret;
if (p < 0.5) {
ret = mean - standardDeviation;
} else if (p > 0.5) {
ret = mean + standardDeviation;
} else {
ret = mean;
}
return ret;
}
/** {@inheritDoc} */
@Override
protected double getSolverAbsoluteAccuracy() {

6
src/main/java/org/apache/commons/math/distribution/PoissonDistribution.java
View File

@ -139,9 +139,9 @@ public class PoissonDistribution extends AbstractIntegerDistribution {
} else if (x == 0) {
ret = FastMath.exp(-mean);
} else {
ret = FastMath.exp(-SaddlePointExpansion.getStirlingError(x)
- SaddlePointExpansion.getDeviancePart(x, mean))
/ FastMath.sqrt(MathUtils.TWO_PI * x);
ret = FastMath.exp(-SaddlePointExpansion.getStirlingError(x) -
SaddlePointExpansion.getDeviancePart(x, mean)) /
FastMath.sqrt(MathUtils.TWO_PI * x);
}
return ret;
}

14
src/main/java/org/apache/commons/math/distribution/RealDistribution.java
View File

@ -105,13 +105,16 @@ public interface RealDistribution {
* distribution.
*
* @return the variance (possibly {@code Double.POSITIVE_INFINITY} as
* for certain cases in {@link TDistributionImpl}) or
* {@code Double.NaN} if it is not defined
* for certain cases in {@link TDistribution}) or {@code Double.NaN} if it
* is not defined
*/
double getNumericalVariance();
/**
* Access the lower bound of the support.
* Access the lower bound of the support. This method must return the same
* value as {@code inverseCumulativeProbability(0)}. In other words, this
* method must return
* <p><code>inf {x in R | P(X <= x) > 0}</code>.</p>
*
* @return lower bound of the support (might be
* {@code Double.NEGATIVE_INFINITY})
@ -119,7 +122,10 @@ public interface RealDistribution {
double getSupportLowerBound();
/**
* Access the upper bound of the support.
* Access the upper bound of the support. This method must return the same
* value as {@code inverseCumulativeProbability(1)}. In other words, this
* method must return
* <p><code>inf {x in R | P(X <= x) = 1}</code>.</p>
*
* @return upper bound of the support (might be
* {@code Double.POSITIVE_INFINITY})

28
src/main/java/org/apache/commons/math/distribution/TDistribution.java
View File

@ -98,11 +98,11 @@ public class TDistribution extends AbstractRealDistribution {
public double density(double x) {
final double n = degreesOfFreedom;
final double nPlus1Over2 = (n + 1) / 2;
return FastMath.exp(Gamma.logGamma(nPlus1Over2)
- 0.5 * (FastMath.log(FastMath.PI)
+ FastMath.log(n))
- Gamma.logGamma(n/2)
- nPlus1Over2 * FastMath.log(1 + x * x /n));
return FastMath.exp(Gamma.logGamma(nPlus1Over2) -
0.5 * (FastMath.log(FastMath.PI) +
FastMath.log(n)) -
Gamma.logGamma(n / 2) -
nPlus1Over2 * FastMath.log(1 + x * x / n));
}
/** {@inheritDoc} */
@ -143,24 +143,6 @@ public class TDistribution extends AbstractRealDistribution {
return super.inverseCumulativeProbability(p);
}
/** {@inheritDoc} */
@Override
protected double getDomainLowerBound(double p) {
return -Double.MAX_VALUE;
}
/** {@inheritDoc} */
@Override
protected double getDomainUpperBound(double p) {
return Double.MAX_VALUE;
}
/** {@inheritDoc} */
@Override
protected double getInitialDomain(double p) {
return 0;
}
/** {@inheritDoc} */
@Override
protected double getSolverAbsoluteAccuracy() {

29
src/main/java/org/apache/commons/math/distribution/WeibullDistribution.java
View File

@ -35,15 +35,15 @@ import org.apache.commons.math.util.FastMath;
* @version $Id$
*/
public class WeibullDistribution extends AbstractRealDistribution {
/** Serializable version identifier. */
private static final long serialVersionUID = 8589540077390120676L;
/**
* Default inverse cumulative probability accuracy.
* @since 2.1
*/
public static final double DEFAULT_INVERSE_ABSOLUTE_ACCURACY = 1e-9;
/** Serializable version identifier. */
private static final long serialVersionUID = 8589540077390120676L;
/** The shape parameter. */
private final double shape;
@ -188,25 +188,6 @@ public class WeibullDistribution extends AbstractRealDistribution {
return ret;
}
/** {@inheritDoc} */
@Override
protected double getDomainLowerBound(double p) {
return 0;
}
/** {@inheritDoc} */
@Override
protected double getDomainUpperBound(double p) {
return Double.MAX_VALUE;
}
/** {@inheritDoc} */
@Override
protected double getInitialDomain(double p) {
// use median
return FastMath.pow(scale * FastMath.log(2.0), 1.0 / shape);
}
/**
* Return the absolute accuracy setting of the solver used to estimate
* inverse cumulative probabilities.
@ -269,8 +250,8 @@ public class WeibullDistribution extends AbstractRealDistribution {
final double sc = getScale();
final double mn = getNumericalMean();
return (sc * sc) * FastMath.exp(Gamma.logGamma(1 + (2 / sh)))
- (mn * mn);
return (sc * sc) * FastMath.exp(Gamma.logGamma(1 + (2 / sh))) -
(mn * mn);
}
/**

30
src/test/java/org/apache/commons/math/distribution/AbstractRealDistributionTest.java
View File

@ -64,21 +64,6 @@ public class AbstractRealDistributionTest {
return 0.0;
}
@Override
protected double getDomainLowerBound(final double p) {
throw new UnsupportedOperationException();
}
@Override
protected double getDomainUpperBound(final double p) {
throw new UnsupportedOperationException();
}
@Override
protected double getInitialDomain(final double p) {
throw new UnsupportedOperationException();
}
public double getNumericalMean() {
return ((x0 + x1) * p12 + (x2 + x3) * (1.0 - p12)) / 2.0;
}
@ -164,21 +149,6 @@ public class AbstractRealDistributionTest {
}
}
@Override
protected double getDomainLowerBound(final double p) {
throw new UnsupportedOperationException();
}
@Override
protected double getDomainUpperBound(final double p) {
throw new UnsupportedOperationException();
}
@Override
protected double getInitialDomain(final double p) {
throw new UnsupportedOperationException();
}
public double getNumericalMean() {
final UnivariateFunction f = new UnivariateFunction() {