http://git-wip-us.apache.org/repos/asf/commons-math/blob/ef846813/src/main/java/org/apache/commons/math4/distribution/TriangularDistribution.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/distribution/TriangularDistribution.java b/src/main/java/org/apache/commons/math4/distribution/TriangularDistribution.java deleted file mode 100644 index 4013c47..0000000 --- a/src/main/java/org/apache/commons/math4/distribution/TriangularDistribution.java +++ /dev/null @@ -1,253 +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.exception.NumberIsTooLargeException; -import org.apache.commons.math4.exception.NumberIsTooSmallException; -import org.apache.commons.math4.exception.OutOfRangeException; -import org.apache.commons.math4.exception.util.LocalizedFormats; -import org.apache.commons.math4.util.FastMath; - -/** - * Implementation of the triangular real distribution. - * - * @see <a href="http://en.wikipedia.org/wiki/Triangular_distribution";> - * Triangular distribution (Wikipedia)</a> - * - * @since 3.0 - */ -public class TriangularDistribution extends AbstractRealDistribution { - /** Serializable version identifier. */ - private static final long serialVersionUID = 20160311L; - /** Lower limit of this distribution (inclusive). */ - private final double a; - /** Upper limit of this distribution (inclusive). */ - private final double b; - /** Mode of this distribution. */ - private final double c; - /** Inverse cumulative probability accuracy. */ - private final double solverAbsoluteAccuracy; - - /** - * Creates a distribution. - * - * @param a Lower limit of this distribution (inclusive). - * @param b Upper limit of this distribution (inclusive). - * @param c Mode of this distribution. - * @throws NumberIsTooLargeException if {@code a >= b} or if {@code c > b}. - * @throws NumberIsTooSmallException if {@code c < a}. - * @since 3.1 - */ - public TriangularDistribution(double a, - double c, - double b) - throws NumberIsTooLargeException, - NumberIsTooSmallException { - if (a >= b) { - throw new NumberIsTooLargeException( - LocalizedFormats.LOWER_BOUND_NOT_BELOW_UPPER_BOUND, - a, b, false); - } - if (c < a) { - throw new NumberIsTooSmallException( - LocalizedFormats.NUMBER_TOO_SMALL, c, a, true); - } - if (c > b) { - throw new NumberIsTooLargeException( - LocalizedFormats.NUMBER_TOO_LARGE, c, b, true); - } - - this.a = a; - this.c = c; - this.b = b; - solverAbsoluteAccuracy = FastMath.max(FastMath.ulp(a), FastMath.ulp(b)); - } - - /** - * Returns the mode {@code c} of this distribution. - * - * @return the mode {@code c} of this distribution - */ - public double getMode() { - return c; - } - - /** - * {@inheritDoc} - * - * <p> - * For this distribution, the returned value is not really meaningful, - * since exact formulas are implemented for the computation of the - * {@link #inverseCumulativeProbability(double)} (no solver is invoked). - * </p> - * <p> - * For lower limit {@code a} and upper limit {@code b}, the current - * implementation returns {@code max(ulp(a), ulp(b)}. - * </p> - */ - @Override - protected double getSolverAbsoluteAccuracy() { - return solverAbsoluteAccuracy; - } - - /** - * {@inheritDoc} - * - * For lower limit {@code a}, upper limit {@code b} and mode {@code c}, the - * PDF is given by - * <ul> - * <li>{@code 2 * (x - a) / [(b - a) * (c - a)]} if {@code a <= x < c},</li> - * <li>{@code 2 / (b - a)} if {@code x = c},</li> - * <li>{@code 2 * (b - x) / [(b - a) * (b - c)]} if {@code c < x <= b},</li> - * <li>{@code 0} otherwise. - * </ul> - */ - @Override - public double density(double x) { - if (x < a) { - return 0; - } - if (a <= x && x < c) { - double divident = 2 * (x - a); - double divisor = (b - a) * (c - a); - return divident / divisor; - } - if (x == c) { - return 2 / (b - a); - } - if (c < x && x <= b) { - double divident = 2 * (b - x); - double divisor = (b - a) * (b - c); - return divident / divisor; - } - return 0; - } - - /** - * {@inheritDoc} - * - * For lower limit {@code a}, upper limit {@code b} and mode {@code c}, the - * CDF is given by - * <ul> - * <li>{@code 0} if {@code x < a},</li> - * <li>{@code (x - a)^2 / [(b - a) * (c - a)]} if {@code a <= x < c},</li> - * <li>{@code (c - a) / (b - a)} if {@code x = c},</li> - * <li>{@code 1 - (b - x)^2 / [(b - a) * (b - c)]} if {@code c < x <= b},</li> - * <li>{@code 1} if {@code x > b}.</li> - * </ul> - */ - @Override - public double cumulativeProbability(double x) { - if (x < a) { - return 0; - } - if (a <= x && x < c) { - double divident = (x - a) * (x - a); - double divisor = (b - a) * (c - a); - return divident / divisor; - } - if (x == c) { - return (c - a) / (b - a); - } - if (c < x && x <= b) { - double divident = (b - x) * (b - x); - double divisor = (b - a) * (b - c); - return 1 - (divident / divisor); - } - return 1; - } - - /** - * {@inheritDoc} - * - * For lower limit {@code a}, upper limit {@code b}, and mode {@code c}, - * the mean is {@code (a + b + c) / 3}. - */ - @Override - public double getNumericalMean() { - return (a + b + c) / 3; - } - - /** - * {@inheritDoc} - * - * For lower limit {@code a}, upper limit {@code b}, and mode {@code c}, - * the variance is {@code (a^2 + b^2 + c^2 - a * b - a * c - b * c) / 18}. - */ - @Override - public double getNumericalVariance() { - return (a * a + b * b + c * c - a * b - a * c - b * c) / 18; - } - - /** - * {@inheritDoc} - * - * The lower bound of the support is equal to the lower limit parameter - * {@code a} of the distribution. - * - * @return lower bound of the support - */ - @Override - public double getSupportLowerBound() { - return a; - } - - /** - * {@inheritDoc} - * - * The upper bound of the support is equal to the upper limit parameter - * {@code b} of the distribution. - * - * @return upper bound of the support - */ - @Override - public double getSupportUpperBound() { - return b; - } - - /** - * {@inheritDoc} - * - * The support of this distribution is connected. - * - * @return {@code true} - */ - @Override - public boolean isSupportConnected() { - return true; - } - - /** {@inheritDoc} */ - @Override - public double inverseCumulativeProbability(double p) - throws OutOfRangeException { - if (p < 0 || p > 1) { - throw new OutOfRangeException(p, 0, 1); - } - if (p == 0) { - return a; - } - if (p == 1) { - return b; - } - if (p < (c - a) / (b - a)) { - return a + FastMath.sqrt(p * (b - a) * (c - a)); - } - return b - FastMath.sqrt((1 - p) * (b - a) * (b - c)); - } -}
http://git-wip-us.apache.org/repos/asf/commons-math/blob/ef846813/src/main/java/org/apache/commons/math4/distribution/UniformIntegerDistribution.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/distribution/UniformIntegerDistribution.java b/src/main/java/org/apache/commons/math4/distribution/UniformIntegerDistribution.java deleted file mode 100644 index 83ab4f2..0000000 --- a/src/main/java/org/apache/commons/math4/distribution/UniformIntegerDistribution.java +++ /dev/null @@ -1,165 +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.exception.NumberIsTooLargeException; -import org.apache.commons.math4.exception.util.LocalizedFormats; -import org.apache.commons.rng.UniformRandomProvider; -import org.apache.commons.rng.sampling.distribution.DiscreteSampler; -import org.apache.commons.rng.sampling.distribution.DiscreteUniformSampler; - -/** - * Implementation of the <a href="http://en.wikipedia.org/wiki/Uniform_distribution_(discrete)"> - * uniform integer distribution</a>. - * - * @since 3.0 - */ -public class UniformIntegerDistribution extends AbstractIntegerDistribution { - /** Serializable version identifier. */ - private static final long serialVersionUID = 20160308L; - /** Lower bound (inclusive) of this distribution. */ - private final int lower; - /** Upper bound (inclusive) of this distribution. */ - private final int upper; - /** "upper" + "lower" (to avoid overflow). */ - private final double upperPlusLower; - /** "upper" - "lower" (to avoid overflow). */ - private final double upperMinusLower; - - /** - * Creates a new uniform integer distribution using the given lower and - * upper bounds (both inclusive). - * - * @param lower Lower bound (inclusive) of this distribution. - * @param upper Upper bound (inclusive) of this distribution. - * @throws NumberIsTooLargeException if {@code lower > upper}. - */ - public UniformIntegerDistribution(int lower, - int upper) - throws NumberIsTooLargeException { - if (lower > upper) { - throw new NumberIsTooLargeException( - LocalizedFormats.LOWER_BOUND_NOT_BELOW_UPPER_BOUND, - lower, upper, true); - } - this.lower = lower; - this.upper = upper; - upperPlusLower = (double) upper + (double) lower; - upperMinusLower = (double) upper - (double) lower; - } - - /** {@inheritDoc} */ - @Override - public double probability(int x) { - if (x < lower || x > upper) { - return 0; - } - return 1.0 / (upperMinusLower + 1); - } - - /** {@inheritDoc} */ - @Override - public double cumulativeProbability(int x) { - if (x < lower) { - return 0; - } - if (x > upper) { - return 1; - } - return (x - lower + 1.0) / (upperMinusLower + 1.0); - } - - /** - * {@inheritDoc} - * - * For lower bound {@code lower} and upper bound {@code upper}, the mean is - * {@code 0.5 * (lower + upper)}. - */ - @Override - public double getNumericalMean() { - return 0.5 * upperPlusLower; - } - - /** - * {@inheritDoc} - * - * For lower bound {@code lower} and upper bound {@code upper}, and - * {@code n = upper - lower + 1}, the variance is {@code (n^2 - 1) / 12}. - */ - @Override - public double getNumericalVariance() { - double n = upperMinusLower + 1; - return (n * n - 1) / 12.0; - } - - /** - * {@inheritDoc} - * - * The lower bound of the support is equal to the lower bound parameter - * of the distribution. - * - * @return lower bound of the support - */ - @Override - public int getSupportLowerBound() { - return lower; - } - - /** - * {@inheritDoc} - * - * The upper bound of the support is equal to the upper bound parameter - * of the distribution. - * - * @return upper bound of the support - */ - @Override - public int getSupportUpperBound() { - return upper; - } - - /** - * {@inheritDoc} - * - * The support of this distribution is connected. - * - * @return {@code true} - */ - @Override - public boolean isSupportConnected() { - return true; - } - - /**{@inheritDoc} */ - @Override - public IntegerDistribution.Sampler createSampler(final UniformRandomProvider rng) { - return new IntegerDistribution.Sampler() { - /** - * Discrete uniform distribution sampler. - */ - private final DiscreteSampler sampler = - new DiscreteUniformSampler(rng, lower, upper); - - /**{@inheritDoc} */ - @Override - public int sample() { - return sampler.sample(); - } - }; - } -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/ef846813/src/main/java/org/apache/commons/math4/distribution/UniformRealDistribution.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/distribution/UniformRealDistribution.java b/src/main/java/org/apache/commons/math4/distribution/UniformRealDistribution.java deleted file mode 100644 index be033e3..0000000 --- a/src/main/java/org/apache/commons/math4/distribution/UniformRealDistribution.java +++ /dev/null @@ -1,180 +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.exception.NumberIsTooLargeException; -import org.apache.commons.math4.exception.OutOfRangeException; -import org.apache.commons.math4.exception.util.LocalizedFormats; -import org.apache.commons.rng.UniformRandomProvider; -import org.apache.commons.rng.sampling.distribution.ContinuousSampler; -import org.apache.commons.rng.sampling.distribution.ContinuousUniformSampler; - -/** - * Implementation of the uniform real distribution. - * - * @see <a href="http://en.wikipedia.org/wiki/Uniform_distribution_(continuous)" - * >Uniform distribution (continuous), at Wikipedia</a> - * - * @since 3.0 - */ -public class UniformRealDistribution extends AbstractRealDistribution { - /** Serializable version identifier. */ - private static final long serialVersionUID = 20160311L; - /** Lower bound of this distribution (inclusive). */ - private final double lower; - /** Upper bound of this distribution (exclusive). */ - private final double upper; - - /** - * Create a standard uniform real distribution with lower bound (inclusive) - * equal to zero and upper bound (exclusive) equal to one. - */ - public UniformRealDistribution() { - this(0, 1); - } - - /** - * Creates a uniform distribution. - * - * @param lower Lower bound of this distribution (inclusive). - * @param upper Upper bound of this distribution (exclusive). - * @throws NumberIsTooLargeException if {@code lower >= upper}. - */ - public UniformRealDistribution(double lower, - double upper) - throws NumberIsTooLargeException { - if (lower >= upper) { - throw new NumberIsTooLargeException( - LocalizedFormats.LOWER_BOUND_NOT_BELOW_UPPER_BOUND, - lower, upper, false); - } - - this.lower = lower; - this.upper = upper; - } - - /** {@inheritDoc} */ - @Override - public double density(double x) { - if (x < lower || x > upper) { - return 0.0; - } - return 1 / (upper - lower); - } - - /** {@inheritDoc} */ - @Override - public double cumulativeProbability(double x) { - if (x <= lower) { - return 0; - } - if (x >= upper) { - return 1; - } - return (x - lower) / (upper - lower); - } - - /** {@inheritDoc} */ - @Override - public double inverseCumulativeProbability(final double p) - throws OutOfRangeException { - if (p < 0.0 || p > 1.0) { - throw new OutOfRangeException(p, 0, 1); - } - return p * (upper - lower) + lower; - } - - /** - * {@inheritDoc} - * - * For lower bound {@code lower} and upper bound {@code upper}, the mean is - * {@code 0.5 * (lower + upper)}. - */ - @Override - public double getNumericalMean() { - return 0.5 * (lower + upper); - } - - /** - * {@inheritDoc} - * - * For lower bound {@code lower} and upper bound {@code upper}, the - * variance is {@code (upper - lower)^2 / 12}. - */ - @Override - public double getNumericalVariance() { - double ul = upper - lower; - return ul * ul / 12; - } - - /** - * {@inheritDoc} - * - * The lower bound of the support is equal to the lower bound parameter - * of the distribution. - * - * @return lower bound of the support - */ - @Override - public double getSupportLowerBound() { - return lower; - } - - /** - * {@inheritDoc} - * - * The upper bound of the support is equal to the upper bound parameter - * of the distribution. - * - * @return upper bound of the support - */ - @Override - public double getSupportUpperBound() { - return upper; - } - - /** - * {@inheritDoc} - * - * The support of this distribution is connected. - * - * @return {@code true} - */ - @Override - public boolean isSupportConnected() { - return true; - } - - /** {@inheritDoc} */ - @Override - public RealDistribution.Sampler createSampler(final UniformRandomProvider rng) { - return new RealDistribution.Sampler() { - /** - * Uniform distribution sampler. - */ - private final ContinuousSampler sampler = - new ContinuousUniformSampler(rng, lower, upper); - - /**{@inheritDoc} */ - @Override - public double sample() { - return sampler.sample(); - } - }; - } -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/ef846813/src/main/java/org/apache/commons/math4/distribution/WeibullDistribution.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/distribution/WeibullDistribution.java b/src/main/java/org/apache/commons/math4/distribution/WeibullDistribution.java deleted file mode 100644 index e0a9dbb..0000000 --- a/src/main/java/org/apache/commons/math4/distribution/WeibullDistribution.java +++ /dev/null @@ -1,297 +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.exception.NotStrictlyPositiveException; -import org.apache.commons.math4.exception.OutOfRangeException; -import org.apache.commons.math4.exception.util.LocalizedFormats; -import org.apache.commons.numbers.gamma.LogGamma; -import org.apache.commons.math4.util.FastMath; - -/** - * Implementation of the Weibull distribution. This implementation uses the - * two parameter form of the distribution defined by - * <a href="http://mathworld.wolfram.com/WeibullDistribution.html";> - * Weibull Distribution</a>, equations (1) and (2). - * - * @see <a href="http://en.wikipedia.org/wiki/Weibull_distribution";>Weibull distribution (Wikipedia)</a> - * @see <a href="http://mathworld.wolfram.com/WeibullDistribution.html";>Weibull distribution (MathWorld)</a> - * - * @since 1.1 - */ -public class WeibullDistribution extends AbstractRealDistribution { - /** - * 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 = 20160311L; - /** The shape parameter. */ - private final double shape; - /** The scale parameter. */ - private final double scale; - /** Inverse cumulative probability accuracy. */ - private final double solverAbsoluteAccuracy; - /** Cached numerical mean */ - private double numericalMean = Double.NaN; - /** Whether or not the numerical mean has been calculated */ - private boolean numericalMeanIsCalculated = false; - /** Cached numerical variance */ - private double numericalVariance = Double.NaN; - /** Whether or not the numerical variance has been calculated */ - private boolean numericalVarianceIsCalculated = false; - - /** - * Creates a distribution. - * - * @param alpha Shape parameter. - * @param beta Scale parameter. - * @throws NotStrictlyPositiveException if {@code alpha <= 0} or - * {@code beta <= 0}. - */ - public WeibullDistribution(double alpha, double beta) - throws NotStrictlyPositiveException { - this(alpha, beta, DEFAULT_INVERSE_ABSOLUTE_ACCURACY); - } - - /** - * Creates a distribution. - * - * @param alpha Shape parameter. - * @param beta Scale parameter. - * @param inverseCumAccuracy Maximum absolute error in inverse - * cumulative probability estimates - * (defaults to {@link #DEFAULT_INVERSE_ABSOLUTE_ACCURACY}). - * @throws NotStrictlyPositiveException if {@code alpha <= 0} or {@code beta <= 0}. - */ - public WeibullDistribution(double alpha, - double beta, - double inverseCumAccuracy) - throws NotStrictlyPositiveException { - if (alpha <= 0) { - throw new NotStrictlyPositiveException(LocalizedFormats.SHAPE, - alpha); - } - if (beta <= 0) { - throw new NotStrictlyPositiveException(LocalizedFormats.SCALE, - beta); - } - scale = beta; - shape = alpha; - solverAbsoluteAccuracy = inverseCumAccuracy; - } - - /** - * Access the shape parameter, {@code alpha}. - * - * @return the shape parameter, {@code alpha}. - */ - public double getShape() { - return shape; - } - - /** - * Access the scale parameter, {@code beta}. - * - * @return the scale parameter, {@code beta}. - */ - public double getScale() { - return scale; - } - - /** {@inheritDoc} */ - @Override - public double density(double x) { - if (x < 0) { - return 0; - } - - final double xscale = x / scale; - final double xscalepow = FastMath.pow(xscale, shape - 1); - - /* - * FastMath.pow(x / scale, shape) = - * FastMath.pow(xscale, shape) = - * FastMath.pow(xscale, shape - 1) * xscale - */ - final double xscalepowshape = xscalepow * xscale; - - return (shape / scale) * xscalepow * FastMath.exp(-xscalepowshape); - } - - /** {@inheritDoc} */ - @Override - public double logDensity(double x) { - if (x < 0) { - return Double.NEGATIVE_INFINITY; - } - - final double xscale = x / scale; - final double logxscalepow = FastMath.log(xscale) * (shape - 1); - - /* - * FastMath.pow(x / scale, shape) = - * FastMath.pow(xscale, shape) = - * FastMath.pow(xscale, shape - 1) * xscale - */ - final double xscalepowshape = FastMath.exp(logxscalepow) * xscale; - - return FastMath.log(shape / scale) + logxscalepow - xscalepowshape; - } - - /** {@inheritDoc} */ - @Override - public double cumulativeProbability(double x) { - double ret; - if (x <= 0.0) { - ret = 0.0; - } else { - ret = 1.0 - FastMath.exp(-FastMath.pow(x / scale, shape)); - } - return ret; - } - - /** - * {@inheritDoc} - * - * Returns {@code 0} when {@code p == 0} and - * {@code Double.POSITIVE_INFINITY} when {@code p == 1}. - */ - @Override - public double inverseCumulativeProbability(double p) { - double ret; - if (p < 0.0 || p > 1.0) { - throw new OutOfRangeException(p, 0.0, 1.0); - } else if (p == 0) { - ret = 0.0; - } else if (p == 1) { - ret = Double.POSITIVE_INFINITY; - } else { - ret = scale * FastMath.pow(-FastMath.log1p(-p), 1.0 / shape); - } - return ret; - } - - /** - * Return the absolute accuracy setting of the solver used to estimate - * inverse cumulative probabilities. - * - * @return the solver absolute accuracy. - * @since 2.1 - */ - @Override - protected double getSolverAbsoluteAccuracy() { - return solverAbsoluteAccuracy; - } - - /** - * {@inheritDoc} - * - * The mean is {@code scale * Gamma(1 + (1 / shape))}, where {@code Gamma()} - * is the Gamma-function. - */ - @Override - public double getNumericalMean() { - if (!numericalMeanIsCalculated) { - numericalMean = calculateNumericalMean(); - numericalMeanIsCalculated = true; - } - return numericalMean; - } - - /** - * used by {@link #getNumericalMean()} - * - * @return the mean of this distribution - */ - protected double calculateNumericalMean() { - final double sh = getShape(); - final double sc = getScale(); - - return sc * FastMath.exp(LogGamma.value(1 + (1 / sh))); - } - - /** - * {@inheritDoc} - * - * The variance is {@code scale^2 * Gamma(1 + (2 / shape)) - mean^2} - * where {@code Gamma()} is the Gamma-function. - */ - @Override - public double getNumericalVariance() { - if (!numericalVarianceIsCalculated) { - numericalVariance = calculateNumericalVariance(); - numericalVarianceIsCalculated = true; - } - return numericalVariance; - } - - /** - * used by {@link #getNumericalVariance()} - * - * @return the variance of this distribution - */ - protected double calculateNumericalVariance() { - final double sh = getShape(); - final double sc = getScale(); - final double mn = getNumericalMean(); - - return (sc * sc) * FastMath.exp(LogGamma.value(1 + (2 / sh))) - - (mn * mn); - } - - /** - * {@inheritDoc} - * - * The lower bound of the support is always 0 no matter the parameters. - * - * @return lower bound of the support (always 0) - */ - @Override - public double getSupportLowerBound() { - return 0; - } - - /** - * {@inheritDoc} - * - * The upper bound of the support is always positive infinity - * no matter the parameters. - * - * @return upper bound of the support (always - * {@code Double.POSITIVE_INFINITY}) - */ - @Override - public double getSupportUpperBound() { - return Double.POSITIVE_INFINITY; - } - - /** - * {@inheritDoc} - * - * The support of this distribution is connected. - * - * @return {@code true} - */ - @Override - public boolean isSupportConnected() { - return true; - } -} - http://git-wip-us.apache.org/repos/asf/commons-math/blob/ef846813/src/main/java/org/apache/commons/math4/distribution/ZipfDistribution.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math4/distribution/ZipfDistribution.java b/src/main/java/org/apache/commons/math4/distribution/ZipfDistribution.java deleted file mode 100644 index 17a95c2..0000000 --- a/src/main/java/org/apache/commons/math4/distribution/ZipfDistribution.java +++ /dev/null @@ -1,278 +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.exception.NotStrictlyPositiveException; -import org.apache.commons.math4.exception.util.LocalizedFormats; -import org.apache.commons.math4.util.FastMath; -import org.apache.commons.rng.UniformRandomProvider; -import org.apache.commons.rng.sampling.distribution.DiscreteSampler; -import org.apache.commons.rng.sampling.distribution.RejectionInversionZipfSampler; - -/** - * Implementation of the Zipf distribution. - * <p> - * <strong>Parameters:</strong> - * For a random variable {@code X} whose values are distributed according to this - * distribution, the probability mass function is given by - * <pre> - * P(X = k) = H(N,s) * 1 / k^s for {@code k = 1,2,...,N}. - * </pre> - * {@code H(N,s)} is the normalizing constant - * which corresponds to the generalized harmonic number of order N of s. - * <ul> - * <li>{@code N} is the number of elements</li> - * <li>{@code s} is the exponent</li> - * </ul> - * @see <a href="https://en.wikipedia.org/wiki/Zipf's_law">Zipf's law (Wikipedia)</a> - * @see <a href="https://en.wikipedia.org/wiki/Harmonic_number#Generalized_harmonic_numbers";>Generalized harmonic numbers</a> - */ -public class ZipfDistribution extends AbstractIntegerDistribution { - /** Serializable version identifier. */ - private static final long serialVersionUID = 20150501L; - /** Number of elements. */ - private final int numberOfElements; - /** Exponent parameter of the distribution. */ - private final double exponent; - /** Cached values of the nth generalized harmonic. */ - private final double nthHarmonic; - /** Cached numerical mean */ - private double numericalMean = Double.NaN; - /** Whether or not the numerical mean has been calculated */ - private boolean numericalMeanIsCalculated = false; - /** Cached numerical variance */ - private double numericalVariance = Double.NaN; - /** Whether or not the numerical variance has been calculated */ - private boolean numericalVarianceIsCalculated = false; - - /** - * Creates a distribution. - * - * @param numberOfElements Number of elements. - * @param exponent Exponent. - * @exception NotStrictlyPositiveException if {@code numberOfElements <= 0} - * or {@code exponent <= 0}. - */ - public ZipfDistribution(int numberOfElements, - double exponent) - throws NotStrictlyPositiveException { - if (numberOfElements <= 0) { - throw new NotStrictlyPositiveException(LocalizedFormats.DIMENSION, - numberOfElements); - } - if (exponent <= 0) { - throw new NotStrictlyPositiveException(LocalizedFormats.EXPONENT, - exponent); - } - - this.numberOfElements = numberOfElements; - this.exponent = exponent; - this.nthHarmonic = generalizedHarmonic(numberOfElements, exponent); - } - - /** - * Get the number of elements (e.g. corpus size) for the distribution. - * - * @return the number of elements - */ - public int getNumberOfElements() { - return numberOfElements; - } - - /** - * Get the exponent characterizing the distribution. - * - * @return the exponent - */ - public double getExponent() { - return exponent; - } - - /** {@inheritDoc} */ - @Override - public double probability(final int x) { - if (x <= 0 || x > numberOfElements) { - return 0.0; - } - - return (1.0 / FastMath.pow(x, exponent)) / nthHarmonic; - } - - /** {@inheritDoc} */ - @Override - public double logProbability(int x) { - if (x <= 0 || x > numberOfElements) { - return Double.NEGATIVE_INFINITY; - } - - return -FastMath.log(x) * exponent - FastMath.log(nthHarmonic); - } - - /** {@inheritDoc} */ - @Override - public double cumulativeProbability(final int x) { - if (x <= 0) { - return 0.0; - } else if (x >= numberOfElements) { - return 1.0; - } - - return generalizedHarmonic(x, exponent) / nthHarmonic; - } - - /** - * {@inheritDoc} - * - * For number of elements {@code N} and exponent {@code s}, the mean is - * {@code Hs1 / Hs}, where - * <ul> - * <li>{@code Hs1 = generalizedHarmonic(N, s - 1)},</li> - * <li>{@code Hs = generalizedHarmonic(N, s)}.</li> - * </ul> - */ - @Override - public double getNumericalMean() { - if (!numericalMeanIsCalculated) { - numericalMean = calculateNumericalMean(); - numericalMeanIsCalculated = true; - } - return numericalMean; - } - - /** - * Used by {@link #getNumericalMean()}. - * - * @return the mean of this distribution - */ - protected double calculateNumericalMean() { - final int N = getNumberOfElements(); - final double s = getExponent(); - - final double Hs1 = generalizedHarmonic(N, s - 1); - final double Hs = nthHarmonic; - - return Hs1 / Hs; - } - - /** - * {@inheritDoc} - * - * For number of elements {@code N} and exponent {@code s}, the mean is - * {@code (Hs2 / Hs) - (Hs1^2 / Hs^2)}, where - * <ul> - * <li>{@code Hs2 = generalizedHarmonic(N, s - 2)},</li> - * <li>{@code Hs1 = generalizedHarmonic(N, s - 1)},</li> - * <li>{@code Hs = generalizedHarmonic(N, s)}.</li> - * </ul> - */ - @Override - public double getNumericalVariance() { - if (!numericalVarianceIsCalculated) { - numericalVariance = calculateNumericalVariance(); - numericalVarianceIsCalculated = true; - } - return numericalVariance; - } - - /** - * Used by {@link #getNumericalVariance()}. - * - * @return the variance of this distribution - */ - protected double calculateNumericalVariance() { - final int N = getNumberOfElements(); - final double s = getExponent(); - - final double Hs2 = generalizedHarmonic(N, s - 2); - final double Hs1 = generalizedHarmonic(N, s - 1); - final double Hs = nthHarmonic; - - return (Hs2 / Hs) - ((Hs1 * Hs1) / (Hs * Hs)); - } - - /** - * Calculates the Nth generalized harmonic number. See - * <a href="http://mathworld.wolfram.com/HarmonicSeries.html";>Harmonic - * Series</a>. - * - * @param n Term in the series to calculate (must be larger than 1) - * @param m Exponent (special case {@code m = 1} is the harmonic series). - * @return the n<sup>th</sup> generalized harmonic number. - */ - private double generalizedHarmonic(final int n, final double m) { - double value = 0; - for (int k = n; k > 0; --k) { - value += 1.0 / FastMath.pow(k, m); - } - return value; - } - - /** - * {@inheritDoc} - * - * The lower bound of the support is always 1 no matter the parameters. - * - * @return lower bound of the support (always 1) - */ - @Override - public int getSupportLowerBound() { - return 1; - } - - /** - * {@inheritDoc} - * - * The upper bound of the support is the number of elements. - * - * @return upper bound of the support - */ - @Override - public int getSupportUpperBound() { - return getNumberOfElements(); - } - - /** - * {@inheritDoc} - * - * The support of this distribution is connected. - * - * @return {@code true} - */ - @Override - public boolean isSupportConnected() { - return true; - } - - /**{@inheritDoc} */ - @Override - public IntegerDistribution.Sampler createSampler(final UniformRandomProvider rng) { - return new IntegerDistribution.Sampler() { - /** - * Zipf distribution sampler. - */ - private final DiscreteSampler sampler = - new RejectionInversionZipfSampler(rng, numberOfElements, exponent); - - /**{@inheritDoc} */ - @Override - public int sample() { - return sampler.sample(); - } - }; - } -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/ef846813/src/test/java/org/apache/commons/math4/distribution/BetaDistributionTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/distribution/BetaDistributionTest.java b/src/test/java/org/apache/commons/math4/distribution/BetaDistributionTest.java deleted file mode 100644 index bcf5865..0000000 --- a/src/test/java/org/apache/commons/math4/distribution/BetaDistributionTest.java +++ /dev/null @@ -1,386 +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 java.util.Arrays; - -import org.apache.commons.statistics.distribution.ContinuousDistribution; -import org.apache.commons.rng.simple.RandomSource; -import org.apache.commons.rng.UniformRandomProvider; -import org.apache.commons.math4.stat.StatUtils; -import org.apache.commons.math4.stat.inference.KolmogorovSmirnovTest; -import org.apache.commons.math4.stat.inference.InferenceTestUtils; -import org.junit.Assert; -import org.junit.Test; - -public class BetaDistributionTest { - - static final double[] alphaBetas = {0.1, 1, 10, 100, 1000}; - static final double epsilon = StatUtils.min(alphaBetas); - - @Test - public void testCumulative() { - double[] x = new double[]{-0.1, 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1}; - // all test data computed using R 2.5 - checkCumulative(0.1, 0.1, - x, new double[]{ - 0.0000000000, 0.0000000000, 0.4063850939, 0.4397091902, 0.4628041861, - 0.4821200456, 0.5000000000, 0.5178799544, 0.5371958139, 0.5602908098, - 0.5936149061, 1.0000000000, 1.0000000000}); - checkCumulative(0.1, 0.5, - x, new double[]{ - 0.0000000000, 0.0000000000, 0.7048336221, 0.7593042194, 0.7951765304, - 0.8234948385, 0.8480017124, 0.8706034370, 0.8926585878, 0.9156406404, - 0.9423662883, 1.0000000000, 1.0000000000}); - checkCumulative(0.1, 1.0, - x, new double[]{ - 0.0000000000, 0.0000000000, 0.7943282347, 0.8513399225, 0.8865681506, - 0.9124435366, 0.9330329915, 0.9502002165, 0.9649610951, 0.9779327685, - 0.9895192582, 1.0000000000, 1.0000000000}); - checkCumulative(0.1, 2.0, - x, new double[]{ - 0.0000000000, 0.0000000000, 0.8658177758, 0.9194471163, 0.9486279211, - 0.9671901487, 0.9796846411, 0.9882082252, 0.9939099280, 0.9974914239, - 0.9994144508, 1.0000000000, 1.0000000000}); - checkCumulative(0.1, 4.0, - x, new double[]{ - 0.0000000000, 0.0000000000, 0.9234991121, 0.9661958941, 0.9842285085, - 0.9928444112, 0.9970040660, 0.9989112804, 0.9996895625, 0.9999440793, - 0.9999967829, 1.0000000000, 1.0000000000}); - checkCumulative(0.5, 0.1, - x, new double[]{ - 0.00000000000, 0.00000000000, 0.05763371168, 0.08435935962, - 0.10734141216, 0.12939656302, 0.15199828760, 0.17650516146, - 0.20482346963, 0.24069578055, 0.29516637795, 1.00000000000, 1.00000000000}); - - checkCumulative(0.5, 0.5, - x, new double[]{ - 0.0000000000, 0.0000000000, 0.2048327647, 0.2951672353, 0.3690101196, - 0.4359057832, 0.5000000000, 0.5640942168, 0.6309898804, 0.7048327647, - 0.7951672353, 1.0000000000, 1.0000000000}); - checkCumulative(0.5, 1.0, - x, new double[]{ - 0.0000000000, 0.0000000000, 0.3162277660, 0.4472135955, 0.5477225575, - 0.6324555320, 0.7071067812, 0.7745966692, 0.8366600265, 0.8944271910, - 0.9486832981, 1.0000000000, 1.0000000000}); - checkCumulative(0.5, 2.0, - x, new double[]{ - 0.0000000000, 0.0000000000, 0.4585302607, 0.6260990337, 0.7394254526, - 0.8221921916, 0.8838834765, 0.9295160031, 0.9621590305, 0.9838699101, - 0.9961174630, 1.0000000000, 1.0000000000}); - checkCumulative(0.5, 4.0, - x, new double[]{ - 0.0000000000, 0.0000000000, 0.6266250826, 0.8049844719, 0.8987784842, - 0.9502644369, 0.9777960959, 0.9914837366, 0.9974556254, 0.9995223859, - 0.9999714889, 1.0000000000, 1.0000000000}); - checkCumulative(1.0, 0.1, - x, new double[]{ - 0.00000000000, 0.00000000000, 0.01048074179, 0.02206723146, - 0.03503890488, 0.04979978349, 0.06696700846, 0.08755646344, - 0.11343184943, 0.14866007748, 0.20567176528, 1.00000000000, 1.00000000000}); - checkCumulative(1.0, 0.5, - x, new double[]{ - 0.00000000000, 0.00000000000, 0.05131670195, 0.10557280900, - 0.16333997347, 0.22540333076, 0.29289321881, 0.36754446797, - 0.45227744249, 0.55278640450, 0.68377223398, 1.00000000000, 1.00000000000}); - checkCumulative(1, 1, - x, new double[]{ - 0.0, 0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.0}); - checkCumulative(1, 2, - x, new double[]{ - 0.00, 0.00, 0.19, 0.36, 0.51, 0.64, 0.75, 0.84, 0.91, 0.96, 0.99, 1.00, 1.00}); - checkCumulative(1, 4, - x, new double[]{ - 0.0000, 0.0000, 0.3439, 0.5904, 0.7599, 0.8704, 0.9375, 0.9744, 0.9919, - 0.9984, 0.9999, 1.0000, 1.0000}); - checkCumulative(2.0, 0.1, - x, new double[]{ - 0.0000000000000, 0.0000000000000, 0.0005855492117, 0.0025085760862, - 0.0060900720266, 0.0117917748341, 0.0203153588864, 0.0328098512512, - 0.0513720788952, 0.0805528836776, 0.1341822241505, 1.0000000000000, 1.0000000000000}); - checkCumulative(2, 1, - x, new double[]{ - 0.00, 0.00, 0.01, 0.04, 0.09, 0.16, 0.25, 0.36, 0.49, 0.64, 0.81, 1.00, 1.00}); - checkCumulative(2.0, 0.5, - x, new double[]{ - 0.000000000000, 0.000000000000, 0.003882537047, 0.016130089900, - 0.037840969486, 0.070483996910, 0.116116523517, 0.177807808356, - 0.260574547368, 0.373900966300, 0.541469739276, 1.000000000000, 1.000000000000}); - checkCumulative(2, 2, - x, new double[]{ - 0.000, 0.000, 0.028, 0.104, 0.216, 0.352, 0.500, 0.648, 0.784, 0.896, 0.972, 1.000, 1.000}); - checkCumulative(2, 4, - x, new double[]{ - 0.00000, 0.00000, 0.08146, 0.26272, 0.47178, 0.66304, 0.81250, 0.91296, - 0.96922, 0.99328, 0.99954, 1.00000, 1.00000}); - checkCumulative(4.0, 0.1, - x, new double[]{ - 0.000000000e+00, 0.000000000e+00, 3.217128269e-06, 5.592070271e-05, - 3.104375474e-04, 1.088719595e-03, 2.995933981e-03, 7.155588777e-03, - 1.577149153e-02, 3.380410585e-02, 7.650088789e-02, 1.000000000e+00, 1.000000000e+00}); - checkCumulative(4.0, 0.5, - x, new double[]{ - 0.000000000e+00, 0.000000000e+00, 2.851114863e-05, 4.776140576e-04, - 2.544374616e-03, 8.516263371e-03, 2.220390414e-02, 4.973556312e-02, - 1.012215158e-01, 1.950155281e-01, 3.733749174e-01, 1.000000000e+00, 1.000000000e+00}); - checkCumulative(4, 1, - x, new double[]{ - 0.0000, 0.0000, 0.0001, 0.0016, 0.0081, 0.0256, 0.0625, 0.1296, 0.2401, - 0.4096, 0.6561, 1.0000, 1.0000}); - checkCumulative(4, 2, - x, new double[]{ - 0.00000, 0.00000, 0.00046, 0.00672, 0.03078, 0.08704, 0.18750, 0.33696, - 0.52822, 0.73728, 0.91854, 1.00000, 1.00000}); - checkCumulative(4, 4, - x, new double[]{ - 0.000000, 0.000000, 0.002728, 0.033344, 0.126036, 0.289792, 0.500000, - 0.710208, 0.873964, 0.966656, 0.997272, 1.000000, 1.000000}); - - } - - private void checkCumulative(double alpha, double beta, double[] x, double[] cumes) { - BetaDistribution d = new BetaDistribution(alpha, beta); - for (int i = 0; i < x.length; i++) { - Assert.assertEquals(cumes[i], d.cumulativeProbability(x[i]), 1e-8); - } - - for (int i = 1; i < x.length - 1; i++) { - Assert.assertEquals(x[i], d.inverseCumulativeProbability(cumes[i]), 1e-5); - } - } - - @Test - public void testDensity() { - double[] x = new double[]{1e-6, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9}; - checkDensity(0.1, 0.1, - x, new double[]{ - 12741.2357380649, 0.4429889586665234, 2.639378715e-01, 2.066393611e-01, - 1.832401831e-01, 1.766302780e-01, 1.832404579e-01, 2.066400696e-01, - 2.639396531e-01, 4.429925026e-01}); - checkDensity(0.1, 0.5, - x, new double[]{ - 2.218377102e+04, 7.394524202e-01, 4.203020268e-01, 3.119435533e-01, - 2.600787829e-01, 2.330648626e-01, 2.211408259e-01, 2.222728708e-01, - 2.414013907e-01, 3.070567405e-01}); - checkDensity(0.1, 1.0, - x, new double[]{ - 2.511886432e+04, 7.943210858e-01, 4.256680458e-01, 2.955218303e-01, - 2.281103709e-01, 1.866062624e-01, 1.583664652e-01, 1.378514078e-01, - 1.222414585e-01, 1.099464743e-01}); - checkDensity(0.1, 2.0, - x, new double[]{ - 2.763072312e+04, 7.863770012e-01, 3.745874120e-01, 2.275514842e-01, - 1.505525939e-01, 1.026332391e-01, 6.968107049e-02, 4.549081293e-02, - 2.689298641e-02, 1.209399123e-02}); - checkDensity(0.1, 4.0, - x, new double[]{ - 2.997927462e+04, 6.911058917e-01, 2.601128486e-01, 1.209774010e-01, - 5.880564714e-02, 2.783915474e-02, 1.209657335e-02, 4.442148268e-03, - 1.167143939e-03, 1.312171805e-04}); - checkDensity(0.5, 0.1, - x, new double[]{ - 88.3152184726, 0.3070542841, 0.2414007269, 0.2222727015, - 0.2211409364, 0.2330652355, 0.2600795198, 0.3119449793, - 0.4203052841, 0.7394649088}); - checkDensity(0.5, 0.5, - x, new double[]{ - 318.3100453389, 1.0610282383, 0.7957732234, 0.6946084565, - 0.6497470636, 0.6366197724, 0.6497476051, 0.6946097796, - 0.7957762075, 1.0610376697}); - checkDensity(0.5, 1.0, - x, new double[]{ - 500.0000000000, 1.5811309244, 1.1180311937, 0.9128694077, - 0.7905684268, 0.7071060741, 0.6454966865, 0.5976138778, - 0.5590166450, 0.5270459839}); - checkDensity(0.5, 2.0, - x, new double[]{ - 749.99925000000, 2.134537420613655, 1.34163575536, 0.95851150881, - 0.71151039830, 0.53032849490, 0.38729704363, 0.26892534859, - 0.16770415497, 0.07905610701}); - checkDensity(0.5, 4.0, - x, new double[]{ - 1.093746719e+03, 2.52142232809988, 1.252190241e+00, 6.849343920e-01, - 3.735417140e-01, 1.933481570e-01, 9.036885833e-02, 3.529621669e-02, - 9.782644546e-03, 1.152878503e-03}); - checkDensity(1.0, 0.1, - x, new double[]{ - 0.1000000900, 0.1099466942, 0.1222417336, 0.1378517623, 0.1583669403, - 0.1866069342, 0.2281113974, 0.2955236034, 0.4256718768, - 0.7943353837}); - checkDensity(1.0, 0.5, - x, new double[]{ - 0.5000002500, 0.5270465695, 0.5590173438, 0.5976147315, 0.6454977623, - 0.7071074883, 0.7905704033, 0.9128724506, - 1.1180367838, 1.5811467358}); - checkDensity(1, 1, - x, new double[]{ - 1, 1, 1, - 1, 1, 1, 1, - 1, 1, 1}); - checkDensity(1, 2, - x, new double[]{ - 1.999998, 1.799998, 1.599998, 1.399998, 1.199998, 0.999998, 0.799998, - 0.599998, 0.399998, - 0.199998}); - checkDensity(1, 4, - x, new double[]{ - 3.999988000012, 2.915990280011, 2.047992320010, 1.371994120008, - 0.863995680007, 0.499997000006, 0.255998080005, 0.107998920004, - 0.031999520002, 0.003999880001}); - checkDensity(2.0, 0.1, - x, new double[]{ - 1.100000990e-07, 1.209425730e-02, 2.689331586e-02, 4.549123318e-02, - 6.968162794e-02, 1.026340191e-01, 1.505537732e-01, 2.275534997e-01, - 3.745917198e-01, 7.863929037e-01}); - checkDensity(2.0, 0.5, - x, new double[]{ - 7.500003750e-07, 7.905777599e-02, 1.677060417e-01, 2.689275256e-01, - 3.872996256e-01, 5.303316769e-01, 7.115145488e-01, 9.585174425e-01, - 1.341645818e+00, 2.134537420613655}); - checkDensity(2, 1, - x, new double[]{ - 0.000002, 0.200002, 0.400002, 0.600002, 0.800002, 1.000002, 1.200002, - 1.400002, 1.600002, - 1.800002}); - checkDensity(2, 2, - x, new double[]{ - 5.9999940e-06, 5.4000480e-01, 9.6000360e-01, 1.2600024e+00, - 1.4400012e+00, 1.5000000e+00, 1.4399988e+00, 1.2599976e+00, - 9.5999640e-01, 5.3999520e-01}); - checkDensity(2, 4, - x, new double[]{ - 0.00001999994, 1.45800971996, 2.04800255997, 2.05799803998, - 1.72799567999, 1.24999500000, 0.76799552000, 0.37799676001, - 0.12799824001, 0.01799948000}); - checkDensity(4.0, 0.1, - x, new double[]{ - 1.193501074e-19, 1.312253162e-04, 1.167181580e-03, 4.442248535e-03, - 1.209679109e-02, 2.783958903e-02, 5.880649983e-02, 1.209791638e-01, - 2.601171405e-01, 6.911229392e-01}); - checkDensity(4.0, 0.5, - x, new double[]{ - 1.093750547e-18, 1.152948959e-03, 9.782950259e-03, 3.529697305e-02, - 9.037036449e-02, 1.933508639e-01, 3.735463833e-01, 6.849425461e-01, - 1.252205894e+00, 2.52142232809988}); - checkDensity(4, 1, - x, new double[]{ - 4.000000000e-18, 4.000120001e-03, 3.200048000e-02, 1.080010800e-01, - 2.560019200e-01, 5.000030000e-01, 8.640043200e-01, 1.372005880e+00, - 2.048007680e+00, 2.916009720e+00}); - checkDensity(4, 2, - x, new double[]{ - 1.999998000e-17, 1.800052000e-02, 1.280017600e-01, 3.780032400e-01, - 7.680044800e-01, 1.250005000e+00, 1.728004320e+00, 2.058001960e+00, - 2.047997440e+00, 1.457990280e+00}); - checkDensity(4, 4, - x, new double[]{ - 1.399995800e-16, 1.020627216e-01, 5.734464512e-01, 1.296547409e+00, - 1.935364838e+00, 2.187500000e+00, 1.935355162e+00, 1.296532591e+00, - 5.734335488e-01, 1.020572784e-01}); - - } - - @SuppressWarnings("boxing") - private void checkDensity(double alpha, double beta, double[] x, double[] expected) { - BetaDistribution d = new BetaDistribution(alpha, beta); - for (int i = 0; i < x.length; i++) { - Assert.assertEquals(String.format("density at x=%.1f for alpha=%.1f, beta=%.1f", x[i], alpha, beta), expected[i], d.density(x[i]), 1e-5); - } - } - - @Test - public void testMoments() { - final double tol = 1e-9; - BetaDistribution dist; - - dist = new BetaDistribution(1, 1); - Assert.assertEquals(dist.getNumericalMean(), 0.5, tol); - Assert.assertEquals(dist.getNumericalVariance(), 1.0 / 12.0, tol); - - dist = new BetaDistribution(2, 5); - Assert.assertEquals(dist.getNumericalMean(), 2.0 / 7.0, tol); - Assert.assertEquals(dist.getNumericalVariance(), 10.0 / (49.0 * 8.0), tol); - } - - @Test - public void testMomentsSampling() { - final UniformRandomProvider rng = RandomSource.create(RandomSource.WELL_1024_A, - 123456789L); - final int numSamples = 1000; - for (final double alpha : alphaBetas) { - for (final double beta : alphaBetas) { - final BetaDistribution betaDistribution = new BetaDistribution(alpha, beta); - final double[] observed = AbstractRealDistribution.sample(numSamples, - betaDistribution.createSampler(rng)); - Arrays.sort(observed); - - final String distribution = String.format("Beta(%.2f, %.2f)", alpha, beta); - Assert.assertEquals(String.format("E[%s]", distribution), - betaDistribution.getNumericalMean(), - StatUtils.mean(observed), epsilon); - Assert.assertEquals(String.format("Var[%s]", distribution), - betaDistribution.getNumericalVariance(), - StatUtils.variance(observed), epsilon); - } - } - } - - @Test - public void testGoodnessOfFit() { - final UniformRandomProvider rng = RandomSource.create(RandomSource.WELL_19937_A, - 123456789L); - final int numSamples = 1000; - final double level = 0.01; - for (final double alpha : alphaBetas) { - for (final double beta : alphaBetas) { - final org.apache.commons.statistics.distribution.BetaDistribution betaDistribution = - new org.apache.commons.statistics.distribution.BetaDistribution(alpha, beta); - - final ContinuousDistribution.Sampler sampler = betaDistribution.createSampler(rng); - final double[] observed = AbstractRealDistribution.sample(numSamples, sampler); - - Assert.assertFalse("G goodness-of-fit test rejected null at alpha = " + level, - gTest(betaDistribution, observed) < level); - Assert.assertFalse("KS goodness-of-fit test rejected null at alpha = " + level, - new KolmogorovSmirnovTest().kolmogorovSmirnovTest(betaDistribution, observed) < level); - } - } - } - - private double gTest(final ContinuousDistribution expectedDistribution, final double[] values) { - final int numBins = values.length / 30; - final double[] breaks = new double[numBins]; - for (int b = 0; b < breaks.length; b++) { - breaks[b] = expectedDistribution.inverseCumulativeProbability((double) b / numBins); - } - - final long[] observed = new long[numBins]; - for (final double value : values) { - int b = 0; - do { - b++; - } while (b < numBins && value >= breaks[b]); - - observed[b - 1]++; - } - - final double[] expected = new double[numBins]; - Arrays.fill(expected, (double) values.length / numBins); - - return InferenceTestUtils.gTest(expected, observed); - } -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/ef846813/src/test/java/org/apache/commons/math4/distribution/BinomialDistributionTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/distribution/BinomialDistributionTest.java b/src/test/java/org/apache/commons/math4/distribution/BinomialDistributionTest.java deleted file mode 100644 index 27ac515..0000000 --- a/src/test/java/org/apache/commons/math4/distribution/BinomialDistributionTest.java +++ /dev/null @@ -1,175 +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.BinomialDistribution; -import org.apache.commons.math4.distribution.IntegerDistribution; -import org.junit.Assert; -import org.junit.Test; - -/** - * Test cases for BinomialDistribution. Extends IntegerDistributionAbstractTest. - * See class javadoc for IntegerDistributionAbstractTest for details. - * - */ -public class BinomialDistributionTest extends IntegerDistributionAbstractTest { - - /** - * Constructor to override default tolerance. - */ - public BinomialDistributionTest() { - setTolerance(1e-12); - } - - // -------------- Implementations for abstract methods - // ----------------------- - - /** Creates the default discrete distribution instance to use in tests. */ - @Override - public IntegerDistribution makeDistribution() { - return new BinomialDistribution(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. - * Reference values are from R, version 2.15.3. - */ - @Override - public double[] makeDensityTestValues() { - return new double[] { 0d, 0.0000059049d, 0.000137781d, 0.0014467005, - 0.009001692, 0.036756909, 0.1029193452, 0.200120949, 0.266827932, - 0.2334744405, 0.121060821, 0.0282475249, 0d }; - } - - /** Creates the default cumulative probability density test input values */ - @Override - public int[] makeCumulativeTestPoints() { - return makeDensityTestPoints(); - } - - /** - * Creates the default cumulative probability density test expected values. - * Reference values are from R, version 2.15.3. - */ - @Override - public double[] makeCumulativeTestValues() { - return new double[] { 0d, 5.9049e-06, 0.0001436859, 0.0015903864, 0.0105920784, 0.0473489874, - 0.1502683326, 0.3503892816, 0.6172172136, 0.8506916541, 0.9717524751, 1d, 1d }; - } - - /** Creates the default inverse cumulative probability test input values */ - @Override - public double[] makeInverseCumulativeTestPoints() { - return new double[] { 0, 0.001d, 0.010d, 0.025d, 0.050d, 0.100d, - 0.999d, 0.990d, 0.975d, 0.950d, 0.900d, 1 }; - } - - /** - * Creates the default inverse cumulative probability density test expected - * values - */ - @Override - public int[] makeInverseCumulativeTestValues() { - return new int[] { 0, 2, 3, 4, 5, 5, 10, 10, 10, 9, 9, 10 }; - } - - // ----------------- Additional test cases --------------------------------- - - /** Test degenerate case p = 0 */ - @Test - public void testDegenerate0() { - BinomialDistribution dist = new BinomialDistribution(5, 0.0d); - setDistribution(dist); - setCumulativeTestPoints(new int[] { -1, 0, 1, 5, 10 }); - setCumulativeTestValues(new double[] { 0d, 1d, 1d, 1d, 1d }); - setDensityTestPoints(new int[] { -1, 0, 1, 10, 11 }); - setDensityTestValues(new double[] { 0d, 1d, 0d, 0d, 0d }); - setInverseCumulativeTestPoints(new double[] { 0.1d, 0.5d }); - setInverseCumulativeTestValues(new int[] { 0, 0 }); - verifyDensities(); - verifyCumulativeProbabilities(); - verifyInverseCumulativeProbabilities(); - Assert.assertEquals(dist.getSupportLowerBound(), 0); - Assert.assertEquals(dist.getSupportUpperBound(), 0); - } - - /** Test degenerate case p = 1 */ - @Test - public void testDegenerate1() { - BinomialDistribution dist = new BinomialDistribution(5, 1.0d); - setDistribution(dist); - setCumulativeTestPoints(new int[] { -1, 0, 1, 2, 5, 10 }); - setCumulativeTestValues(new double[] { 0d, 0d, 0d, 0d, 1d, 1d }); - setDensityTestPoints(new int[] { -1, 0, 1, 2, 5, 10 }); - setDensityTestValues(new double[] { 0d, 0d, 0d, 0d, 1d, 0d }); - setInverseCumulativeTestPoints(new double[] { 0.1d, 0.5d }); - setInverseCumulativeTestValues(new int[] { 5, 5 }); - verifyDensities(); - verifyCumulativeProbabilities(); - verifyInverseCumulativeProbabilities(); - Assert.assertEquals(dist.getSupportLowerBound(), 5); - Assert.assertEquals(dist.getSupportUpperBound(), 5); - } - - /** Test degenerate case n = 0 */ - @Test - public void testDegenerate2() { - BinomialDistribution dist = new BinomialDistribution(0, 0.01d); - setDistribution(dist); - setCumulativeTestPoints(new int[] { -1, 0, 1, 2, 5, 10 }); - setCumulativeTestValues(new double[] { 0d, 1d, 1d, 1d, 1d, 1d }); - setDensityTestPoints(new int[] { -1, 0, 1, 2, 5, 10 }); - setDensityTestValues(new double[] { 0d, 1d, 0d, 0d, 0d, 0d }); - setInverseCumulativeTestPoints(new double[] { 0.1d, 0.5d }); - setInverseCumulativeTestValues(new int[] { 0, 0 }); - verifyDensities(); - verifyCumulativeProbabilities(); - verifyInverseCumulativeProbabilities(); - Assert.assertEquals(dist.getSupportLowerBound(), 0); - Assert.assertEquals(dist.getSupportUpperBound(), 0); - } - - @Test - public void testMoments() { - final double tol = 1e-9; - BinomialDistribution dist; - - dist = new BinomialDistribution(10, 0.5); - Assert.assertEquals(dist.getNumericalMean(), 10d * 0.5d, tol); - Assert.assertEquals(dist.getNumericalVariance(), 10d * 0.5d * 0.5d, tol); - - dist = new BinomialDistribution(30, 0.3); - Assert.assertEquals(dist.getNumericalMean(), 30d * 0.3d, tol); - Assert.assertEquals(dist.getNumericalVariance(), 30d * 0.3d * (1d - 0.3d), tol); - } - - @Test - public void testMath718() { - // for large trials the evaluation of ContinuedFraction was inaccurate - // do a sweep over several large trials to test if the current implementation is - // numerically stable. - - for (int trials = 500000; trials < 20000000; trials += 100000) { - BinomialDistribution dist = new BinomialDistribution(trials, 0.5); - int p = dist.inverseCumulativeProbability(0.5); - Assert.assertEquals(trials / 2, p); - } - } -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/ef846813/src/test/java/org/apache/commons/math4/distribution/CauchyDistributionTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/distribution/CauchyDistributionTest.java b/src/test/java/org/apache/commons/math4/distribution/CauchyDistributionTest.java deleted file mode 100644 index 86bd0e4..0000000 --- a/src/test/java/org/apache/commons/math4/distribution/CauchyDistributionTest.java +++ /dev/null @@ -1,122 +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.CauchyDistribution; -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 CauchyDistribution. - * Extends ContinuousDistributionAbstractTest. See class javadoc for - * ContinuousDistributionAbstractTest for details. - * - */ -public class CauchyDistributionTest extends RealDistributionAbstractTest { - - // --------------------- 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 continuous distribution instance to use in tests. */ - @Override - public CauchyDistribution makeDistribution() { - return new CauchyDistribution(1.2, 2.1); - } - - /** Creates the default cumulative probability distribution test input values */ - @Override - public double[] makeCumulativeTestPoints() { - // quantiles computed using R 2.9.2 - return new double[] {-667.24856187, -65.6230835029, -25.4830299460, -12.0588781808, - -5.26313542807, 669.64856187, 68.0230835029, 27.8830299460, 14.4588781808, 7.66313542807}; - } - - /** 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[] {1.49599158008e-06, 0.000149550440335, 0.000933076881878, 0.00370933207799, 0.0144742330437, - 1.49599158008e-06, 0.000149550440335, 0.000933076881878, 0.00370933207799, 0.0144742330437}; - } - - //---------------------------- Additional test cases ------------------------- - - @Test - public void testInverseCumulativeProbabilityExtremes() { - setInverseCumulativeTestPoints(new double[] {0.0, 1.0}); - setInverseCumulativeTestValues( - new double[] {Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY}); - verifyInverseCumulativeProbabilities(); - } - - @Test - public void testMedian() { - CauchyDistribution distribution = (CauchyDistribution) getDistribution(); - Assert.assertEquals(1.2, distribution.getMedian(), 0.0); - } - - @Test - public void testScale() { - CauchyDistribution distribution = (CauchyDistribution) getDistribution(); - Assert.assertEquals(2.1, distribution.getScale(), 0.0); - } - - @Test - public void testPreconditions() { - try { - new CauchyDistribution(0, 0); - Assert.fail("Cannot have zero scale"); - } catch (NotStrictlyPositiveException ex) { - // Expected. - } - try { - new CauchyDistribution(0, -1); - Assert.fail("Cannot have negative scale"); - } catch (NotStrictlyPositiveException ex) { - // Expected. - } - } - - @Test - public void testMoments() { - CauchyDistribution dist; - - dist = new CauchyDistribution(10.2, 0.15); - Assert.assertTrue(Double.isNaN(dist.getNumericalMean())); - Assert.assertTrue(Double.isNaN(dist.getNumericalVariance())); - - dist = new CauchyDistribution(23.12, 2.12); - Assert.assertTrue(Double.isNaN(dist.getNumericalMean())); - Assert.assertTrue(Double.isNaN(dist.getNumericalVariance())); - } -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/ef846813/src/test/java/org/apache/commons/math4/distribution/ChiSquaredDistributionTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/distribution/ChiSquaredDistributionTest.java b/src/test/java/org/apache/commons/math4/distribution/ChiSquaredDistributionTest.java deleted file mode 100644 index fc1ab85..0000000 --- a/src/test/java/org/apache/commons/math4/distribution/ChiSquaredDistributionTest.java +++ /dev/null @@ -1,137 +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.ChiSquaredDistribution; -import org.junit.Assert; -import org.junit.Test; - -/** - * Test cases for {@link ChiSquaredDistribution}. - * - * @see RealDistributionAbstractTest - */ -public class ChiSquaredDistributionTest extends RealDistributionAbstractTest { - - //-------------- Implementations for abstract methods ----------------------- - - /** Creates the default continuous distribution instance to use in tests. */ - @Override - public ChiSquaredDistribution makeDistribution() { - return new ChiSquaredDistribution(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[] {0.210212602629, 0.554298076728, 0.831211613487, 1.14547622606, 1.61030798696, - 20.5150056524, 15.0862724694, 12.8325019940, 11.0704976935, 9.23635689978}; - } - - /** 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 inverse cumulative probability test input values */ - @Override - public double[] makeInverseCumulativeTestPoints() { - return new double[] {0, 0.001d, 0.01d, 0.025d, 0.05d, 0.1d, 0.999d, - 0.990d, 0.975d, 0.950d, 0.900d, 1}; - } - - /** Creates the default inverse cumulative probability density test expected values */ - @Override - public double[] makeInverseCumulativeTestValues() { - return new double[] {0, 0.210212602629, 0.554298076728, 0.831211613487, 1.14547622606, 1.61030798696, - 20.5150056524, 15.0862724694, 12.8325019940, 11.0704976935, 9.23635689978, - Double.POSITIVE_INFINITY}; - } - - /** Creates the default probability density test expected values */ - @Override - public double[] makeDensityTestValues() { - return new double[] {0.0115379817652, 0.0415948507811, 0.0665060119842, 0.0919455953114, 0.121472591024, - 0.000433630076361, 0.00412780610309, 0.00999340341045, 0.0193246438937, 0.0368460089216}; - } - - // --------------------- Override tolerance -------------- - @Override - public void setUp() { - super.setUp(); - setTolerance(1e-9); - } - - //---------------------------- Additional test cases ------------------------- - - @Test - public void testSmallDf() { - setDistribution(new ChiSquaredDistribution(0.1d)); - setTolerance(1E-4); - // quantiles computed using R version 1.8.1 (linux version) - setCumulativeTestPoints(new double[] {1.168926E-60, 1.168926E-40, 1.063132E-32, - 1.144775E-26, 1.168926E-20, 5.472917, 2.175255, 1.13438, - 0.5318646, 0.1526342}); - setInverseCumulativeTestValues(getCumulativeTestPoints()); - setInverseCumulativeTestPoints(getCumulativeTestValues()); - verifyCumulativeProbabilities(); - verifyInverseCumulativeProbabilities(); - } - - @Test - public void testDfAccessors() { - ChiSquaredDistribution distribution = (ChiSquaredDistribution) getDistribution(); - Assert.assertEquals(5d, distribution.getDegreesOfFreedom(), Double.MIN_VALUE); - } - - @Test - public void testDensity() { - double[] x = new double[]{-0.1, 1e-6, 0.5, 1, 2, 5}; - //R 2.5: print(dchisq(x, df=1), digits=10) - checkDensity(1, x, new double[]{0.00000000000, 398.94208093034, 0.43939128947, 0.24197072452, 0.10377687436, 0.01464498256}); - //R 2.5: print(dchisq(x, df=0.1), digits=10) - checkDensity(0.1, x, new double[]{0.000000000e+00, 2.486453997e+04, 7.464238732e-02, 3.009077718e-02, 9.447299159e-03, 8.827199396e-04}); - //R 2.5: print(dchisq(x, df=2), digits=10) - checkDensity(2, x, new double[]{0.00000000000, 0.49999975000, 0.38940039154, 0.30326532986, 0.18393972059, 0.04104249931}); - //R 2.5: print(dchisq(x, df=10), digits=10) - checkDensity(10, x, new double[]{0.000000000e+00, 1.302082682e-27, 6.337896998e-05, 7.897534632e-04, 7.664155024e-03, 6.680094289e-02}); - } - - private void checkDensity(double df, double[] x, double[] expected) { - ChiSquaredDistribution d = new ChiSquaredDistribution(df); - for (int i = 0; i < x.length; i++) { - Assert.assertEquals(expected[i], d.density(x[i]), 1e-5); - } - } - - @Test - public void testMoments() { - final double tol = 1e-9; - ChiSquaredDistribution dist; - - dist = new ChiSquaredDistribution(1500); - Assert.assertEquals(dist.getNumericalMean(), 1500, tol); - Assert.assertEquals(dist.getNumericalVariance(), 3000, tol); - - dist = new ChiSquaredDistribution(1.12); - Assert.assertEquals(dist.getNumericalMean(), 1.12, tol); - Assert.assertEquals(dist.getNumericalVariance(), 2.24, tol); - } -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/ef846813/src/test/java/org/apache/commons/math4/distribution/ConstantRealDistributionTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/math4/distribution/ConstantRealDistributionTest.java b/src/test/java/org/apache/commons/math4/distribution/ConstantRealDistributionTest.java deleted file mode 100644 index a2c7706..0000000 --- a/src/test/java/org/apache/commons/math4/distribution/ConstantRealDistributionTest.java +++ /dev/null @@ -1,94 +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.ConstantRealDistribution; -import org.apache.commons.math4.distribution.RealDistribution; -import org.junit.Assert; -import org.junit.Test; - -/** - * Test cases for ConstantRealDistribution. - */ -public class ConstantRealDistributionTest extends RealDistributionAbstractTest { - - // --- Override tolerance ------------------------------------------------- - - @Override - public void setUp() { - super.setUp(); - setTolerance(0); - } - - //--- Implementations for abstract methods -------------------------------- - - /** Creates the default uniform real distribution instance to use in tests. */ - @Override - public ConstantRealDistribution makeDistribution() { - return new ConstantRealDistribution(1); - } - - /** Creates the default cumulative probability distribution test input values */ - @Override - public double[] makeCumulativeTestPoints() { - return new double[] {0, 0.5, 1}; - } - - /** Creates the default cumulative probability distribution test expected values */ - @Override - public double[] makeCumulativeTestValues() { - return new double[] {0, 0, 1}; - } - - /** Creates the default probability density test expected values */ - @Override - public double[] makeDensityTestValues() { - return new double[] {0, 0, 1}; - } - - /** Override default test, verifying that inverse cum is constant */ - @Override - @Test - public void testInverseCumulativeProbabilities() { - RealDistribution dist = getDistribution(); - for (double x : getCumulativeTestValues()) { - Assert.assertEquals(1,dist.inverseCumulativeProbability(x), 0); - } - } - - //--- Additional test cases ----------------------------------------------- - - @Test - public void testMeanVariance() { - ConstantRealDistribution dist; - - dist = new ConstantRealDistribution(-1); - Assert.assertEquals(dist.getNumericalMean(), -1, 0d); - Assert.assertEquals(dist.getNumericalVariance(), 0, 0d); - } - - @Test - @Override - public void testSampler() { - final double value = 12.345; - final RealDistribution.Sampler sampler = new ConstantRealDistribution(value).createSampler(null); - for (int i = 0; i < 10; i++) { - Assert.assertEquals(value, sampler.sample(), 0); - } - } -}
