You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by er...@apache.org on 2018/01/25 19:07:03 UTC
[15/21] [math] MATH-1443: Depend on "Commons Statistics".
http://git-wip-us.apache.org/repos/asf/commons-math/blob/ef846813/src/main/java/org/apache/commons/math4/distribution/HypergeometricDistribution.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/distribution/HypergeometricDistribution.java b/src/main/java/org/apache/commons/math4/distribution/HypergeometricDistribution.java
deleted file mode 100644
index 137738d..0000000
--- a/src/main/java/org/apache/commons/math4/distribution/HypergeometricDistribution.java
+++ /dev/null
@@ -1,325 +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.NotPositiveException;
-import org.apache.commons.math4.exception.NotStrictlyPositiveException;
-import org.apache.commons.math4.exception.NumberIsTooLargeException;
-import org.apache.commons.math4.exception.util.LocalizedFormats;
-import org.apache.commons.math4.util.FastMath;
-
-/**
- * Implementation of the hypergeometric distribution.
- *
- * @see <a href="http://en.wikipedia.org/wiki/Hypergeometric_distribution">Hypergeometric distribution (Wikipedia)</a>
- * @see <a href="http://mathworld.wolfram.com/HypergeometricDistribution.html">Hypergeometric distribution (MathWorld)</a>
- */
-public class HypergeometricDistribution extends AbstractIntegerDistribution {
- /** Serializable version identifier. */
- private static final long serialVersionUID = 20160318L;
- /** The number of successes in the population. */
- private final int numberOfSuccesses;
- /** The population size. */
- private final int populationSize;
- /** The sample size. */
- private final int sampleSize;
- /** Cached numerical variance */
- private double numericalVariance = Double.NaN;
- /** Whether or not the numerical variance has been calculated */
- private boolean numericalVarianceIsCalculated = false;
-
- /**
- * Creates a new hypergeometric distribution.
- *
- * @param populationSize Population size.
- * @param numberOfSuccesses Number of successes in the population.
- * @param sampleSize Sample size.
- * @throws NotPositiveException if {@code numberOfSuccesses < 0}.
- * @throws NotStrictlyPositiveException if {@code populationSize <= 0}.
- * @throws NumberIsTooLargeException if {@code numberOfSuccesses > populationSize},
- * or {@code sampleSize > populationSize}.
- */
- public HypergeometricDistribution(int populationSize,
- int numberOfSuccesses,
- int sampleSize)
- throws NotPositiveException,
- NotStrictlyPositiveException,
- NumberIsTooLargeException {
- if (populationSize <= 0) {
- throw new NotStrictlyPositiveException(LocalizedFormats.POPULATION_SIZE,
- populationSize);
- }
- if (numberOfSuccesses < 0) {
- throw new NotPositiveException(LocalizedFormats.NUMBER_OF_SUCCESSES,
- numberOfSuccesses);
- }
- if (sampleSize < 0) {
- throw new NotPositiveException(LocalizedFormats.NUMBER_OF_SAMPLES,
- sampleSize);
- }
-
- if (numberOfSuccesses > populationSize) {
- throw new NumberIsTooLargeException(LocalizedFormats.NUMBER_OF_SUCCESS_LARGER_THAN_POPULATION_SIZE,
- numberOfSuccesses, populationSize, true);
- }
- if (sampleSize > populationSize) {
- throw new NumberIsTooLargeException(LocalizedFormats.SAMPLE_SIZE_LARGER_THAN_POPULATION_SIZE,
- sampleSize, populationSize, true);
- }
-
- this.numberOfSuccesses = numberOfSuccesses;
- this.populationSize = populationSize;
- this.sampleSize = sampleSize;
- }
-
- /** {@inheritDoc} */
- @Override
- public double cumulativeProbability(int x) {
- double ret;
-
- int[] domain = getDomain(populationSize, numberOfSuccesses, sampleSize);
- if (x < domain[0]) {
- ret = 0.0;
- } else if (x >= domain[1]) {
- ret = 1.0;
- } else {
- ret = innerCumulativeProbability(domain[0], x, 1);
- }
-
- return ret;
- }
-
- /**
- * Return the domain for the given hypergeometric distribution parameters.
- *
- * @param n Population size.
- * @param m Number of successes in the population.
- * @param k Sample size.
- * @return a two element array containing the lower and upper bounds of the
- * hypergeometric distribution.
- */
- private int[] getDomain(int n, int m, int k) {
- return new int[] { getLowerDomain(n, m, k), getUpperDomain(m, k) };
- }
-
- /**
- * Return the lowest domain value for the given hypergeometric distribution
- * parameters.
- *
- * @param n Population size.
- * @param m Number of successes in the population.
- * @param k Sample size.
- * @return the lowest domain value of the hypergeometric distribution.
- */
- private int getLowerDomain(int n, int m, int k) {
- return FastMath.max(0, m - (n - k));
- }
-
- /**
- * Access the number of successes.
- *
- * @return the number of successes.
- */
- public int getNumberOfSuccesses() {
- return numberOfSuccesses;
- }
-
- /**
- * Access the population size.
- *
- * @return the population size.
- */
- public int getPopulationSize() {
- return populationSize;
- }
-
- /**
- * Access the sample size.
- *
- * @return the sample size.
- */
- public int getSampleSize() {
- return sampleSize;
- }
-
- /**
- * Return the highest domain value for the given hypergeometric distribution
- * parameters.
- *
- * @param m Number of successes in the population.
- * @param k Sample size.
- * @return the highest domain value of the hypergeometric distribution.
- */
- private int getUpperDomain(int m, int k) {
- return FastMath.min(k, m);
- }
-
- /** {@inheritDoc} */
- @Override
- public double probability(int x) {
- final double logProbability = logProbability(x);
- return logProbability == Double.NEGATIVE_INFINITY ? 0 : FastMath.exp(logProbability);
- }
-
- /** {@inheritDoc} */
- @Override
- public double logProbability(int x) {
- double ret;
-
- int[] domain = getDomain(populationSize, numberOfSuccesses, sampleSize);
- if (x < domain[0] || x > domain[1]) {
- ret = Double.NEGATIVE_INFINITY;
- } else {
- double p = (double) sampleSize / (double) populationSize;
- double q = (double) (populationSize - sampleSize) / (double) populationSize;
- double p1 = SaddlePointExpansion.logBinomialProbability(x,
- numberOfSuccesses, p, q);
- double p2 =
- SaddlePointExpansion.logBinomialProbability(sampleSize - x,
- populationSize - numberOfSuccesses, p, q);
- double p3 =
- SaddlePointExpansion.logBinomialProbability(sampleSize, populationSize, p, q);
- ret = p1 + p2 - p3;
- }
-
- return ret;
- }
-
- /**
- * For this distribution, {@code X}, this method returns {@code P(X >= x)}.
- *
- * @param x Value at which the CDF is evaluated.
- * @return the upper tail CDF for this distribution.
- * @since 1.1
- */
- public double upperCumulativeProbability(int x) {
- double ret;
-
- final int[] domain = getDomain(populationSize, numberOfSuccesses, sampleSize);
- if (x <= domain[0]) {
- ret = 1.0;
- } else if (x > domain[1]) {
- ret = 0.0;
- } else {
- ret = innerCumulativeProbability(domain[1], x, -1);
- }
-
- return ret;
- }
-
- /**
- * For this distribution, {@code X}, this method returns
- * {@code P(x0 <= X <= x1)}.
- * This probability is computed by summing the point probabilities for the
- * values {@code x0, x0 + 1, x0 + 2, ..., x1}, in the order directed by
- * {@code dx}.
- *
- * @param x0 Inclusive lower bound.
- * @param x1 Inclusive upper bound.
- * @param dx Direction of summation (1 indicates summing from x0 to x1, and
- * 0 indicates summing from x1 to x0).
- * @return {@code P(x0 <= X <= x1)}.
- */
- private double innerCumulativeProbability(int x0, int x1, int dx) {
- double ret = probability(x0);
- while (x0 != x1) {
- x0 += dx;
- ret += probability(x0);
- }
- return ret;
- }
-
- /**
- * {@inheritDoc}
- *
- * For population size {@code N}, number of successes {@code m}, and sample
- * size {@code n}, the mean is {@code n * m / N}.
- */
- @Override
- public double getNumericalMean() {
- return getSampleSize() * (getNumberOfSuccesses() / (double) getPopulationSize());
- }
-
- /**
- * {@inheritDoc}
- *
- * For population size {@code N}, number of successes {@code m}, and sample
- * size {@code n}, the variance is
- * {@code [n * m * (N - n) * (N - m)] / [N^2 * (N - 1)]}.
- */
- @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 N = getPopulationSize();
- final double m = getNumberOfSuccesses();
- final double n = getSampleSize();
- return (n * m * (N - n) * (N - m)) / (N * N * (N - 1));
- }
-
- /**
- * {@inheritDoc}
- *
- * For population size {@code N}, number of successes {@code m}, and sample
- * size {@code n}, the lower bound of the support is
- * {@code max(0, n + m - N)}.
- *
- * @return lower bound of the support
- */
- @Override
- public int getSupportLowerBound() {
- return FastMath.max(0,
- getSampleSize() + getNumberOfSuccesses() - getPopulationSize());
- }
-
- /**
- * {@inheritDoc}
- *
- * For number of successes {@code m} and sample size {@code n}, the upper
- * bound of the support is {@code min(m, n)}.
- *
- * @return upper bound of the support
- */
- @Override
- public int getSupportUpperBound() {
- return FastMath.min(getNumberOfSuccesses(), getSampleSize());
- }
-
- /**
- * {@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/LaplaceDistribution.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/distribution/LaplaceDistribution.java b/src/main/java/org/apache/commons/math4/distribution/LaplaceDistribution.java
deleted file mode 100644
index c85618b..0000000
--- a/src/main/java/org/apache/commons/math4/distribution/LaplaceDistribution.java
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.math4.distribution;
-
-import org.apache.commons.math4.exception.NotStrictlyPositiveException;
-import org.apache.commons.math4.exception.OutOfRangeException;
-import org.apache.commons.math4.exception.util.LocalizedFormats;
-import org.apache.commons.math4.util.FastMath;
-
-/**
- * This class implements the Laplace distribution.
- *
- * @see <a href="http://en.wikipedia.org/wiki/Laplace_distribution">Laplace distribution (Wikipedia)</a>
- *
- * @since 3.4
- */
-public class LaplaceDistribution extends AbstractRealDistribution {
-
- /** Serializable version identifier. */
- private static final long serialVersionUID = 20160311L;
-
- /** The location parameter. */
- private final double mu;
- /** The scale parameter. */
- private final double beta;
-
- /**
- * Creates a distribution.
- *
- * @param mu location parameter
- * @param beta scale parameter (must be positive)
- * @throws NotStrictlyPositiveException if {@code beta <= 0}
- */
- public LaplaceDistribution(double mu, double beta) {
- if (beta <= 0.0) {
- throw new NotStrictlyPositiveException(LocalizedFormats.NOT_POSITIVE_SCALE, beta);
- }
-
- this.mu = mu;
- this.beta = beta;
- }
-
- /**
- * Access the location parameter, {@code mu}.
- *
- * @return the location parameter.
- */
- public double getLocation() {
- return mu;
- }
-
- /**
- * Access the scale parameter, {@code beta}.
- *
- * @return the scale parameter.
- */
- public double getScale() {
- return beta;
- }
-
- /** {@inheritDoc} */
- @Override
- public double density(double x) {
- return FastMath.exp(-FastMath.abs(x - mu) / beta) / (2.0 * beta);
- }
-
- /** {@inheritDoc} */
- @Override
- public double cumulativeProbability(double x) {
- if (x <= mu) {
- return FastMath.exp((x - mu) / beta) / 2.0;
- } else {
- return 1.0 - FastMath.exp((mu - x) / beta) / 2.0;
- }
- }
-
- /** {@inheritDoc} */
- @Override
- public double inverseCumulativeProbability(double p) throws OutOfRangeException {
- if (p < 0.0 || p > 1.0) {
- throw new OutOfRangeException(p, 0.0, 1.0);
- } else if (p == 0) {
- return Double.NEGATIVE_INFINITY;
- } else if (p == 1) {
- return Double.POSITIVE_INFINITY;
- }
- double x = (p > 0.5) ? -Math.log(2.0 - 2.0 * p) : Math.log(2.0 * p);
- return mu + beta * x;
- }
-
- /** {@inheritDoc} */
- @Override
- public double getNumericalMean() {
- return mu;
- }
-
- /** {@inheritDoc} */
- @Override
- public double getNumericalVariance() {
- return 2.0 * beta * beta;
- }
-
- /** {@inheritDoc} */
- @Override
- public double getSupportLowerBound() {
- return Double.NEGATIVE_INFINITY;
- }
-
- /** {@inheritDoc} */
- @Override
- public double getSupportUpperBound() {
- return Double.POSITIVE_INFINITY;
- }
-
- /** {@inheritDoc} */
- @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/LevyDistribution.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/distribution/LevyDistribution.java b/src/main/java/org/apache/commons/math4/distribution/LevyDistribution.java
deleted file mode 100644
index 5f99f8e..0000000
--- a/src/main/java/org/apache/commons/math4/distribution/LevyDistribution.java
+++ /dev/null
@@ -1,166 +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.OutOfRangeException;
-import org.apache.commons.numbers.gamma.Erfc;
-import org.apache.commons.numbers.gamma.InverseErfc;
-import org.apache.commons.math4.util.FastMath;
-
-/**
- * This class implements the <a href="http://en.wikipedia.org/wiki/L%C3%A9vy_distribution">
- * Lévy distribution</a>.
- *
- * @since 3.2
- */
-public class LevyDistribution extends AbstractRealDistribution {
-
- /** Serializable UID. */
- private static final long serialVersionUID = 20630311L;
-
- /** Location parameter. */
- private final double mu;
-
- /** Scale parameter. */
- private final double c; // Setting this to 1 returns a cumProb of 1.0
-
- /** Half of c (for calculations). */
- private final double halfC;
-
- /**
- * Creates a distribution.
- *
- * @param mu location
- * @param c scale parameter
- */
- public LevyDistribution(final double mu, final double c) {
- this.mu = mu;
- this.c = c;
- this.halfC = 0.5 * c;
- }
-
- /** {@inheritDoc}
- * <p>
- * From Wikipedia: The probability density function of the Lévy distribution
- * over the domain is
- * </p>
- * <div style="white-space: pre"><code>
- * f(x; μ, c) = √(c / 2π) * e<sup>-c / 2 (x - μ)</sup> / (x - μ)<sup>3/2</sup>
- * </code></div>
- * <p>
- * For this distribution, {@code X}, this method returns {@code P(X < x)}.
- * If {@code x} is less than location parameter μ, {@code Double.NaN} is
- * returned, as in these cases the distribution is not defined.
- * </p>
- */
- @Override
- public double density(final double x) {
- if (x < mu) {
- return Double.NaN;
- }
-
- final double delta = x - mu;
- final double f = halfC / delta;
- return FastMath.sqrt(f / FastMath.PI) * FastMath.exp(-f) /delta;
- }
-
- /** {@inheritDoc}
- *
- * See documentation of {@link #density(double)} for computation details.
- */
- @Override
- public double logDensity(double x) {
- if (x < mu) {
- return Double.NaN;
- }
-
- final double delta = x - mu;
- final double f = halfC / delta;
- return 0.5 * FastMath.log(f / FastMath.PI) - f - FastMath.log(delta);
- }
-
- /** {@inheritDoc}
- * <p>
- * From Wikipedia: the cumulative distribution function is
- * </p>
- * <pre>
- * f(x; u, c) = erfc (√ (c / 2 (x - u )))
- * </pre>
- */
- @Override
- public double cumulativeProbability(final double x) {
- if (x < mu) {
- return Double.NaN;
- }
- return Erfc.value(FastMath.sqrt(halfC / (x - mu)));
- }
-
- /** {@inheritDoc} */
- @Override
- public double inverseCumulativeProbability(final double p) throws OutOfRangeException {
- if (p < 0.0 || p > 1.0) {
- throw new OutOfRangeException(p, 0, 1);
- }
- final double t = InverseErfc.value(p);
- return mu + halfC / (t * t);
- }
-
- /** Get the scale parameter of the distribution.
- * @return scale parameter of the distribution
- */
- public double getScale() {
- return c;
- }
-
- /** Get the location parameter of the distribution.
- * @return location parameter of the distribution
- */
- public double getLocation() {
- return mu;
- }
-
- /** {@inheritDoc} */
- @Override
- public double getNumericalMean() {
- return Double.POSITIVE_INFINITY;
- }
-
- /** {@inheritDoc} */
- @Override
- public double getNumericalVariance() {
- return Double.POSITIVE_INFINITY;
- }
-
- /** {@inheritDoc} */
- @Override
- public double getSupportLowerBound() {
- return mu;
- }
-
- /** {@inheritDoc} */
- @Override
- public double getSupportUpperBound() {
- return Double.POSITIVE_INFINITY;
- }
-
- /** {@inheritDoc} */
- @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/LogNormalDistribution.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/distribution/LogNormalDistribution.java b/src/main/java/org/apache/commons/math4/distribution/LogNormalDistribution.java
deleted file mode 100644
index 0060a97..0000000
--- a/src/main/java/org/apache/commons/math4/distribution/LogNormalDistribution.java
+++ /dev/null
@@ -1,312 +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.NumberIsTooLargeException;
-import org.apache.commons.math4.exception.util.LocalizedFormats;
-import org.apache.commons.numbers.gamma.Erf;
-import org.apache.commons.numbers.gamma.ErfDifference;
-import org.apache.commons.math4.util.FastMath;
-import org.apache.commons.rng.UniformRandomProvider;
-import org.apache.commons.rng.sampling.distribution.ContinuousSampler;
-import org.apache.commons.rng.sampling.distribution.LogNormalSampler;
-import org.apache.commons.rng.sampling.distribution.ZigguratNormalizedGaussianSampler;
-
-/**
- * Implementation of the log-normal (gaussian) distribution.
- *
- * <p>
- * <strong>Parameters:</strong>
- * {@code X} is log-normally distributed if its natural logarithm {@code log(X)}
- * is normally distributed. The probability distribution function of {@code X}
- * is given by (for {@code x > 0})
- * </p>
- * <p>
- * {@code exp(-0.5 * ((ln(x) - m) / s)^2) / (s * sqrt(2 * pi) * x)}
- * </p>
- * <ul>
- * <li>{@code m} is the <em>scale</em> parameter: this is the mean of the
- * normally distributed natural logarithm of this distribution,</li>
- * <li>{@code s} is the <em>shape</em> parameter: this is the standard
- * deviation of the normally distributed natural logarithm of this
- * distribution.
- * </ul>
- *
- * @see <a href="http://en.wikipedia.org/wiki/Log-normal_distribution">
- * Log-normal distribution (Wikipedia)</a>
- * @see <a href="http://mathworld.wolfram.com/LogNormalDistribution.html">
- * Log Normal distribution (MathWorld)</a>
- *
- * @since 3.0
- */
-public class LogNormalDistribution extends AbstractRealDistribution {
- /** Default inverse cumulative probability accuracy. */
- public static final double DEFAULT_INVERSE_ABSOLUTE_ACCURACY = 1e-9;
-
- /** Serializable version identifier. */
- private static final long serialVersionUID = 20120112;
-
- /** √(2 π) */
- private static final double SQRT2PI = FastMath.sqrt(2 * FastMath.PI);
-
- /** √(2) */
- private static final double SQRT2 = FastMath.sqrt(2.0);
-
- /** The scale parameter of this distribution. */
- private final double scale;
-
- /** The shape parameter of this distribution. */
- private final double shape;
- /** The value of {@code log(shape) + 0.5 * log(2*PI)} stored for faster computation. */
- private final double logShapePlusHalfLog2Pi;
-
- /** Inverse cumulative probability accuracy. */
- private final double solverAbsoluteAccuracy;
-
- /**
- * Creates a log-normal distribution, where the mean and standard deviation
- * of the {@link NormalDistribution normally distributed} natural
- * logarithm of the log-normal distribution are equal to zero and one
- * respectively. In other words, the scale of the returned distribution is
- * {@code 0}, while its shape is {@code 1}.
- */
- public LogNormalDistribution() {
- this(0, 1);
- }
-
- /**
- * Creates a log-normal distribution.
- *
- * @param scale Scale parameter of this distribution.
- * @param shape Shape parameter of this distribution.
- * @throws NotStrictlyPositiveException if {@code shape <= 0}.
- */
- public LogNormalDistribution(double scale, double shape)
- throws NotStrictlyPositiveException {
- this(scale, shape, DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
- }
-
- /**
- * Creates a log-normal distribution.
- *
- * @param scale Scale parameter of this distribution.
- * @param shape Shape parameter of this distribution.
- * @param inverseCumAccuracy Inverse cumulative probability accuracy.
- * @throws NotStrictlyPositiveException if {@code shape <= 0}.
- */
- public LogNormalDistribution(double scale,
- double shape,
- double inverseCumAccuracy)
- throws NotStrictlyPositiveException {
- if (shape <= 0) {
- throw new NotStrictlyPositiveException(LocalizedFormats.SHAPE, shape);
- }
-
- this.scale = scale;
- this.shape = shape;
- this.logShapePlusHalfLog2Pi = FastMath.log(shape) + 0.5 * FastMath.log(2 * FastMath.PI);
- this.solverAbsoluteAccuracy = inverseCumAccuracy;
- }
-
- /**
- * Returns the scale parameter of this distribution.
- *
- * @return the scale parameter
- */
- public double getScale() {
- return scale;
- }
-
- /**
- * Returns the shape parameter of this distribution.
- *
- * @return the shape parameter
- */
- public double getShape() {
- return shape;
- }
-
- /**
- * {@inheritDoc}
- *
- * For scale {@code m}, and shape {@code s} of this distribution, the PDF
- * is given by
- * <ul>
- * <li>{@code 0} if {@code x <= 0},</li>
- * <li>{@code exp(-0.5 * ((ln(x) - m) / s)^2) / (s * sqrt(2 * pi) * x)}
- * otherwise.</li>
- * </ul>
- */
- @Override
- public double density(double x) {
- if (x <= 0) {
- return 0;
- }
- final double x0 = FastMath.log(x) - scale;
- final double x1 = x0 / shape;
- return FastMath.exp(-0.5 * x1 * x1) / (shape * SQRT2PI * x);
- }
-
- /** {@inheritDoc}
- *
- * See documentation of {@link #density(double)} for computation details.
- */
- @Override
- public double logDensity(double x) {
- if (x <= 0) {
- return Double.NEGATIVE_INFINITY;
- }
- final double logX = FastMath.log(x);
- final double x0 = logX - scale;
- final double x1 = x0 / shape;
- return -0.5 * x1 * x1 - (logShapePlusHalfLog2Pi + logX);
- }
-
- /**
- * {@inheritDoc}
- *
- * For scale {@code m}, and shape {@code s} of this distribution, the CDF
- * is given by
- * <ul>
- * <li>{@code 0} if {@code x <= 0},</li>
- * <li>{@code 0} if {@code ln(x) - m < 0} and {@code m - ln(x) > 40 * s}, as
- * in these cases the actual value is within {@code Double.MIN_VALUE} of 0,
- * <li>{@code 1} if {@code ln(x) - m >= 0} and {@code ln(x) - m > 40 * s},
- * as in these cases the actual value is within {@code Double.MIN_VALUE} of
- * 1,</li>
- * <li>{@code 0.5 + 0.5 * erf((ln(x) - m) / (s * sqrt(2))} otherwise.</li>
- * </ul>
- */
- @Override
- public double cumulativeProbability(double x) {
- if (x <= 0) {
- return 0;
- }
- final double dev = FastMath.log(x) - scale;
- if (FastMath.abs(dev) > 40 * shape) {
- return dev < 0 ? 0.0d : 1.0d;
- }
- return 0.5 + 0.5 * Erf.value(dev / (shape * SQRT2));
- }
-
- /** {@inheritDoc} */
- @Override
- public double probability(double x0,
- double x1)
- throws NumberIsTooLargeException {
- if (x0 > x1) {
- throw new NumberIsTooLargeException(LocalizedFormats.LOWER_ENDPOINT_ABOVE_UPPER_ENDPOINT,
- x0, x1, true);
- }
- if (x0 <= 0 || x1 <= 0) {
- return super.probability(x0, x1);
- }
- final double denom = shape * SQRT2;
- final double v0 = (FastMath.log(x0) - scale) / denom;
- final double v1 = (FastMath.log(x1) - scale) / denom;
- return 0.5 * ErfDifference.value(v0, v1);
- }
-
- /** {@inheritDoc} */
- @Override
- protected double getSolverAbsoluteAccuracy() {
- return solverAbsoluteAccuracy;
- }
-
- /**
- * {@inheritDoc}
- *
- * For scale {@code m} and shape {@code s}, the mean is
- * {@code exp(m + s^2 / 2)}.
- */
- @Override
- public double getNumericalMean() {
- double s = shape;
- return FastMath.exp(scale + (s * s / 2));
- }
-
- /**
- * {@inheritDoc}
- *
- * For scale {@code m} and shape {@code s}, the variance is
- * {@code (exp(s^2) - 1) * exp(2 * m + s^2)}.
- */
- @Override
- public double getNumericalVariance() {
- final double s = shape;
- final double ss = s * s;
- return (FastMath.expm1(ss)) * FastMath.exp(2 * scale + ss);
- }
-
- /**
- * {@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;
- }
-
- /** {@inheritDoc} */
- @Override
- public RealDistribution.Sampler createSampler(final UniformRandomProvider rng) {
- return new RealDistribution.Sampler() {
- /**
- * Log normal distribution sampler.
- */
- private final ContinuousSampler sampler =
- new LogNormalSampler(new ZigguratNormalizedGaussianSampler(rng), scale, shape);
-
- /**{@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/LogisticDistribution.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/distribution/LogisticDistribution.java b/src/main/java/org/apache/commons/math4/distribution/LogisticDistribution.java
deleted file mode 100644
index 1c69804..0000000
--- a/src/main/java/org/apache/commons/math4/distribution/LogisticDistribution.java
+++ /dev/null
@@ -1,136 +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.math4.util.FastMath;
-import org.apache.commons.math4.util.MathUtils;
-
-/**
- * This class implements the Logistic distribution.
- *
- * @see <a href="http://en.wikipedia.org/wiki/Logistic_distribution">Logistic Distribution (Wikipedia)</a>
- * @see <a href="http://mathworld.wolfram.com/LogisticDistribution.html">Logistic Distribution (Mathworld)</a>
- *
- * @since 3.4
- */
-public class LogisticDistribution extends AbstractRealDistribution {
-
- /** Serializable version identifier. */
- private static final long serialVersionUID = 20160311L;
-
- /** The location parameter. */
- private final double mu;
- /** The scale parameter. */
- private final double s;
-
- /**
- * Creates a distribution.
- *
- * @param mu location parameter
- * @param s scale parameter (must be positive)
- * @throws NotStrictlyPositiveException if {@code beta <= 0}
- */
- public LogisticDistribution(double mu,
- double s) {
- if (s <= 0.0) {
- throw new NotStrictlyPositiveException(LocalizedFormats.NOT_POSITIVE_SCALE, s);
- }
-
- this.mu = mu;
- this.s = s;
- }
-
- /**
- * Access the location parameter, {@code mu}.
- *
- * @return the location parameter.
- */
- public double getLocation() {
- return mu;
- }
-
- /**
- * Access the scale parameter, {@code s}.
- *
- * @return the scale parameter.
- */
- public double getScale() {
- return s;
- }
-
- /** {@inheritDoc} */
- @Override
- public double density(double x) {
- double z = (x - mu) / s;
- double v = FastMath.exp(-z);
- return 1 / s * v / ((1.0 + v) * (1.0 + v));
- }
-
- /** {@inheritDoc} */
- @Override
- public double cumulativeProbability(double x) {
- double z = 1 / s * (x - mu);
- return 1.0 / (1.0 + FastMath.exp(-z));
- }
-
- /** {@inheritDoc} */
- @Override
- public double inverseCumulativeProbability(double p) throws OutOfRangeException {
- if (p < 0.0 || p > 1.0) {
- throw new OutOfRangeException(p, 0.0, 1.0);
- } else if (p == 0) {
- return 0.0;
- } else if (p == 1) {
- return Double.POSITIVE_INFINITY;
- }
- return s * Math.log(p / (1.0 - p)) + mu;
- }
-
- /** {@inheritDoc} */
- @Override
- public double getNumericalMean() {
- return mu;
- }
-
- /** {@inheritDoc} */
- @Override
- public double getNumericalVariance() {
- return (MathUtils.PI_SQUARED / 3.0) * (1.0 / (s * s));
- }
-
- /** {@inheritDoc} */
- @Override
- public double getSupportLowerBound() {
- return Double.NEGATIVE_INFINITY;
- }
-
- /** {@inheritDoc} */
- @Override
- public double getSupportUpperBound() {
- return Double.POSITIVE_INFINITY;
- }
-
- /** {@inheritDoc} */
- @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/NakagamiDistribution.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/distribution/NakagamiDistribution.java b/src/main/java/org/apache/commons/math4/distribution/NakagamiDistribution.java
deleted file mode 100644
index c26b2e6..0000000
--- a/src/main/java/org/apache/commons/math4/distribution/NakagamiDistribution.java
+++ /dev/null
@@ -1,157 +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.NumberIsTooSmallException;
-import org.apache.commons.math4.exception.util.LocalizedFormats;
-import org.apache.commons.numbers.gamma.Gamma;
-import org.apache.commons.numbers.gamma.RegularizedGamma;
-import org.apache.commons.math4.util.FastMath;
-
-/**
- * This class implements the Nakagami distribution.
- *
- * @see <a href="http://en.wikipedia.org/wiki/Nakagami_distribution">Nakagami Distribution (Wikipedia)</a>
- *
- * @since 3.4
- */
-public class NakagamiDistribution extends AbstractRealDistribution {
-
- /** Default inverse cumulative probability accuracy. */
- 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 mu;
- /** The scale parameter. */
- private final double omega;
- /** Inverse cumulative probability accuracy. */
- private final double inverseAbsoluteAccuracy;
-
- /**
- * Creates a distribution.
- *
- * @param mu shape parameter
- * @param omega scale parameter (must be positive)
- * @throws NumberIsTooSmallException if {@code mu < 0.5}
- * @throws NotStrictlyPositiveException if {@code omega <= 0}
- */
- public NakagamiDistribution(double mu,
- double omega) {
- this(mu, omega, DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
- }
-
- /**
- * Creates a distribution.
- *
- * @param mu shape parameter
- * @param omega scale parameter (must be positive)
- * @param inverseAbsoluteAccuracy the maximum absolute error in inverse
- * cumulative probability estimates (defaults to {@link #DEFAULT_INVERSE_ABSOLUTE_ACCURACY}).
- * @throws NumberIsTooSmallException if {@code mu < 0.5}
- * @throws NotStrictlyPositiveException if {@code omega <= 0}
- */
- public NakagamiDistribution(double mu,
- double omega,
- double inverseAbsoluteAccuracy) {
- if (mu < 0.5) {
- throw new NumberIsTooSmallException(mu, 0.5, true);
- }
- if (omega <= 0) {
- throw new NotStrictlyPositiveException(LocalizedFormats.NOT_POSITIVE_SCALE, omega);
- }
-
- this.mu = mu;
- this.omega = omega;
- this.inverseAbsoluteAccuracy = inverseAbsoluteAccuracy;
- }
-
- /**
- * Access the shape parameter, {@code mu}.
- *
- * @return the shape parameter.
- */
- public double getShape() {
- return mu;
- }
-
- /**
- * Access the scale parameter, {@code omega}.
- *
- * @return the scale parameter.
- */
- public double getScale() {
- return omega;
- }
-
- /** {@inheritDoc} */
- @Override
- protected double getSolverAbsoluteAccuracy() {
- return inverseAbsoluteAccuracy;
- }
-
- /** {@inheritDoc} */
- @Override
- public double density(double x) {
- if (x <= 0) {
- return 0.0;
- }
- return 2.0 * FastMath.pow(mu, mu) / (Gamma.value(mu) * FastMath.pow(omega, mu)) *
- FastMath.pow(x, 2 * mu - 1) * FastMath.exp(-mu * x * x / omega);
- }
-
- /** {@inheritDoc} */
- @Override
- public double cumulativeProbability(double x) {
- return RegularizedGamma.P.value(mu, mu * x * x / omega);
- }
-
- /** {@inheritDoc} */
- @Override
- public double getNumericalMean() {
- return Gamma.value(mu + 0.5) / Gamma.value(mu) * FastMath.sqrt(omega / mu);
- }
-
- /** {@inheritDoc} */
- @Override
- public double getNumericalVariance() {
- double v = Gamma.value(mu + 0.5) / Gamma.value(mu);
- return omega * (1 - 1 / mu * v * v);
- }
-
- /** {@inheritDoc} */
- @Override
- public double getSupportLowerBound() {
- return 0;
- }
-
- /** {@inheritDoc} */
- @Override
- public double getSupportUpperBound() {
- return Double.POSITIVE_INFINITY;
- }
-
- /** {@inheritDoc} */
- @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/NormalDistribution.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/distribution/NormalDistribution.java b/src/main/java/org/apache/commons/math4/distribution/NormalDistribution.java
deleted file mode 100644
index 76c41a3..0000000
--- a/src/main/java/org/apache/commons/math4/distribution/NormalDistribution.java
+++ /dev/null
@@ -1,261 +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.NumberIsTooLargeException;
-import org.apache.commons.math4.exception.OutOfRangeException;
-import org.apache.commons.math4.exception.util.LocalizedFormats;
-import org.apache.commons.numbers.gamma.Erfc;
-import org.apache.commons.numbers.gamma.InverseErf;
-import org.apache.commons.numbers.gamma.ErfDifference;
-import org.apache.commons.math4.util.FastMath;
-import org.apache.commons.rng.UniformRandomProvider;
-import org.apache.commons.rng.sampling.distribution.ContinuousSampler;
-import org.apache.commons.rng.sampling.distribution.GaussianSampler;
-import org.apache.commons.rng.sampling.distribution.MarsagliaNormalizedGaussianSampler;
-
-/**
- * Implementation of the normal (gaussian) distribution.
- *
- * @see <a href="http://en.wikipedia.org/wiki/Normal_distribution">Normal distribution (Wikipedia)</a>
- * @see <a href="http://mathworld.wolfram.com/NormalDistribution.html">Normal distribution (MathWorld)</a>
- */
-public class NormalDistribution 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 = 8589540077390120676L;
- /** √(2) */
- private static final double SQRT2 = FastMath.sqrt(2.0);
- /** Mean of this distribution. */
- private final double mean;
- /** Standard deviation of this distribution. */
- private final double standardDeviation;
- /** The value of {@code log(sd) + 0.5*log(2*pi)} stored for faster computation. */
- private final double logStandardDeviationPlusHalfLog2Pi;
- /** Inverse cumulative probability accuracy. */
- private final double solverAbsoluteAccuracy;
-
- /**
- * Create a normal distribution with mean equal to zero and standard
- * deviation equal to one.
- */
- public NormalDistribution() {
- this(0, 1);
- }
-
- /**
- * Creates a distribution.
- *
- * @param mean Mean for this distribution.
- * @param sd Standard deviation for this distribution.
- * @throws NotStrictlyPositiveException if {@code sd <= 0}.
- */
- public NormalDistribution(double mean,
- double sd)
- throws NotStrictlyPositiveException {
- this(mean, sd, DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
- }
-
-
- /**
- * Creates a distribution.
- *
- * @param mean Mean for this distribution.
- * @param sd Standard deviation for this distribution.
- * @param inverseCumAccuracy Inverse cumulative probability accuracy.
- * @throws NotStrictlyPositiveException if {@code sd <= 0}.
- */
- public NormalDistribution(double mean,
- double sd,
- double inverseCumAccuracy)
- throws NotStrictlyPositiveException {
- if (sd <= 0) {
- throw new NotStrictlyPositiveException(LocalizedFormats.STANDARD_DEVIATION, sd);
- }
-
- this.mean = mean;
- standardDeviation = sd;
- logStandardDeviationPlusHalfLog2Pi = FastMath.log(sd) + 0.5 * FastMath.log(2 * FastMath.PI);
- solverAbsoluteAccuracy = inverseCumAccuracy;
- }
-
- /**
- * Access the mean.
- *
- * @return the mean for this distribution.
- */
- public double getMean() {
- return mean;
- }
-
- /**
- * Access the standard deviation.
- *
- * @return the standard deviation for this distribution.
- */
- public double getStandardDeviation() {
- return standardDeviation;
- }
-
- /** {@inheritDoc} */
- @Override
- public double density(double x) {
- return FastMath.exp(logDensity(x));
- }
-
- /** {@inheritDoc} */
- @Override
- public double logDensity(double x) {
- final double x0 = x - mean;
- final double x1 = x0 / standardDeviation;
- return -0.5 * x1 * x1 - logStandardDeviationPlusHalfLog2Pi;
- }
-
- /**
- * {@inheritDoc}
- *
- * If {@code x} is more than 40 standard deviations from the mean, 0 or 1
- * is returned, as in these cases the actual value is within
- * {@code Double.MIN_VALUE} of 0 or 1.
- */
- @Override
- public double cumulativeProbability(double x) {
- final double dev = x - mean;
- if (FastMath.abs(dev) > 40 * standardDeviation) {
- return dev < 0 ? 0.0d : 1.0d;
- }
- return 0.5 * Erfc.value(-dev / (standardDeviation * SQRT2));
- }
-
- /** {@inheritDoc}
- * @since 3.2
- */
- @Override
- public double inverseCumulativeProbability(final double p) throws OutOfRangeException {
- if (p < 0.0 || p > 1.0) {
- throw new OutOfRangeException(p, 0, 1);
- }
- return mean + standardDeviation * SQRT2 * InverseErf.value(2 * p - 1);
- }
-
- /** {@inheritDoc} */
- @Override
- public double probability(double x0,
- double x1)
- throws NumberIsTooLargeException {
- if (x0 > x1) {
- throw new NumberIsTooLargeException(LocalizedFormats.LOWER_ENDPOINT_ABOVE_UPPER_ENDPOINT,
- x0, x1, true);
- }
- final double denom = standardDeviation * SQRT2;
- final double v0 = (x0 - mean) / denom;
- final double v1 = (x1 - mean) / denom;
- return 0.5 * ErfDifference.value(v0, v1);
- }
-
- /** {@inheritDoc} */
- @Override
- protected double getSolverAbsoluteAccuracy() {
- return solverAbsoluteAccuracy;
- }
-
- /**
- * {@inheritDoc}
- *
- * For mean parameter {@code mu}, the mean is {@code mu}.
- */
- @Override
- public double getNumericalMean() {
- return getMean();
- }
-
- /**
- * {@inheritDoc}
- *
- * For standard deviation parameter {@code s}, the variance is {@code s^2}.
- */
- @Override
- public double getNumericalVariance() {
- final double s = getStandardDeviation();
- return s * s;
- }
-
- /**
- * {@inheritDoc}
- *
- * The lower bound of the support is always negative infinity
- * no matter the parameters.
- *
- * @return lower bound of the support (always
- * {@code Double.NEGATIVE_INFINITY})
- */
- @Override
- public double getSupportLowerBound() {
- return Double.NEGATIVE_INFINITY;
- }
-
- /**
- * {@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;
- }
-
- /** {@inheritDoc} */
- @Override
- public RealDistribution.Sampler createSampler(final UniformRandomProvider rng) {
- return new RealDistribution.Sampler() {
- /**
- * Gaussian distribution sampler.
- */
- private final ContinuousSampler sampler =
- new GaussianSampler(new MarsagliaNormalizedGaussianSampler(rng),
- mean, standardDeviation);
-
- /**{@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/ParetoDistribution.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/distribution/ParetoDistribution.java b/src/main/java/org/apache/commons/math4/distribution/ParetoDistribution.java
deleted file mode 100644
index e2b350e..0000000
--- a/src/main/java/org/apache/commons/math4/distribution/ParetoDistribution.java
+++ /dev/null
@@ -1,269 +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.ContinuousSampler;
-import org.apache.commons.rng.sampling.distribution.InverseTransformParetoSampler;
-
-/**
- * Implementation of the Pareto distribution.
- *
- * <p>
- * <strong>Parameters:</strong>
- * The probability distribution function of {@code X} is given by (for {@code x >= k}):
- * <pre>
- * α * k^α / x^(α + 1)
- * </pre>
- * <ul>
- * <li>{@code k} is the <em>scale</em> parameter: this is the minimum possible value of {@code X},</li>
- * <li>{@code α} is the <em>shape</em> parameter: this is the Pareto index</li>
- * </ul>
- *
- * @see <a href="http://en.wikipedia.org/wiki/Pareto_distribution">
- * Pareto distribution (Wikipedia)</a>
- * @see <a href="http://mathworld.wolfram.com/ParetoDistribution.html">
- * Pareto distribution (MathWorld)</a>
- *
- * @since 3.3
- */
-public class ParetoDistribution extends AbstractRealDistribution {
-
- /** Default inverse cumulative probability accuracy. */
- public static final double DEFAULT_INVERSE_ABSOLUTE_ACCURACY = 1e-9;
-
- /** Serializable version identifier. */
- private static final long serialVersionUID = 20160311L;
-
- /** The scale parameter of this distribution. */
- private final double scale;
-
- /** The shape parameter of this distribution. */
- private final double shape;
-
- /** Inverse cumulative probability accuracy. */
- private final double solverAbsoluteAccuracy;
-
- /**
- * Creates a Pareto distribution with a scale of {@code 1} and a shape of {@code 1}.
- */
- public ParetoDistribution() {
- this(1, 1);
- }
-
- /**
- * Creates a Pareto distribution.
- *
- * @param scale the scale parameter of this distribution
- * @param shape the shape parameter of this distribution
- * @throws NotStrictlyPositiveException if {@code scale <= 0} or {@code shape <= 0}.
- */
- public ParetoDistribution(double scale,
- double shape)
- throws NotStrictlyPositiveException {
- this(scale, shape, DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
- }
-
- /**
- * Creates a Pareto distribution.
- *
- * @param scale Scale parameter of this distribution.
- * @param shape Shape parameter of this distribution.
- * @param inverseCumAccuracy Inverse cumulative probability accuracy.
- * @throws NotStrictlyPositiveException if {@code scale <= 0} or {@code shape <= 0}.
- */
- public ParetoDistribution(double scale,
- double shape,
- double inverseCumAccuracy)
- throws NotStrictlyPositiveException {
- if (scale <= 0) {
- throw new NotStrictlyPositiveException(LocalizedFormats.SCALE, scale);
- }
-
- if (shape <= 0) {
- throw new NotStrictlyPositiveException(LocalizedFormats.SHAPE, shape);
- }
-
- this.scale = scale;
- this.shape = shape;
- this.solverAbsoluteAccuracy = inverseCumAccuracy;
- }
-
- /**
- * Returns the scale parameter of this distribution.
- *
- * @return the scale parameter
- */
- public double getScale() {
- return scale;
- }
-
- /**
- * Returns the shape parameter of this distribution.
- *
- * @return the shape parameter
- */
- public double getShape() {
- return shape;
- }
-
- /**
- * {@inheritDoc}
- * <p>
- * For scale {@code k}, and shape {@code α} of this distribution, the PDF
- * is given by
- * <ul>
- * <li>{@code 0} if {@code x < k},</li>
- * <li>{@code α * k^α / x^(α + 1)} otherwise.</li>
- * </ul>
- */
- @Override
- public double density(double x) {
- if (x < scale) {
- return 0;
- }
- return FastMath.pow(scale, shape) / FastMath.pow(x, shape + 1) * shape;
- }
-
- /** {@inheritDoc}
- *
- * See documentation of {@link #density(double)} for computation details.
- */
- @Override
- public double logDensity(double x) {
- if (x < scale) {
- return Double.NEGATIVE_INFINITY;
- }
- return FastMath.log(scale) * shape - FastMath.log(x) * (shape + 1) + FastMath.log(shape);
- }
-
- /**
- * {@inheritDoc}
- * <p>
- * For scale {@code k}, and shape {@code α} of this distribution, the CDF is given by
- * <ul>
- * <li>{@code 0} if {@code x < k},</li>
- * <li>{@code 1 - (k / x)^α} otherwise.</li>
- * </ul>
- */
- @Override
- public double cumulativeProbability(double x) {
- if (x <= scale) {
- return 0;
- }
- return 1 - FastMath.pow(scale / x, shape);
- }
-
- /** {@inheritDoc} */
- @Override
- protected double getSolverAbsoluteAccuracy() {
- return solverAbsoluteAccuracy;
- }
-
- /**
- * {@inheritDoc}
- * <p>
- * For scale {@code k} and shape {@code α}, the mean is given by
- * <ul>
- * <li>{@code ∞} if {@code α <= 1},</li>
- * <li>{@code α * k / (α - 1)} otherwise.</li>
- * </ul>
- */
- @Override
- public double getNumericalMean() {
- if (shape <= 1) {
- return Double.POSITIVE_INFINITY;
- }
- return shape * scale / (shape - 1);
- }
-
- /**
- * {@inheritDoc}
- * <p>
- * For scale {@code k} and shape {@code α}, the variance is given by
- * <ul>
- * <li>{@code ∞} if {@code 1 < α <= 2},</li>
- * <li>{@code k^2 * α / ((α - 1)^2 * (α - 2))} otherwise.</li>
- * </ul>
- */
- @Override
- public double getNumericalVariance() {
- if (shape <= 2) {
- return Double.POSITIVE_INFINITY;
- }
- double s = shape - 1;
- return scale * scale * shape / (s * s) / (shape - 2);
- }
-
- /**
- * {@inheritDoc}
- * <p>
- * The lower bound of the support is equal to the scale parameter {@code k}.
- *
- * @return lower bound of the support
- */
- @Override
- public double getSupportLowerBound() {
- return scale;
- }
-
- /**
- * {@inheritDoc}
- * <p>
- * 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}
- * <p>
- * 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() {
- /**
- * Pareto distribution sampler.
- */
- private final ContinuousSampler sampler =
- new InverseTransformParetoSampler(rng, scale, shape);
-
- /**{@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/PascalDistribution.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/distribution/PascalDistribution.java b/src/main/java/org/apache/commons/math4/distribution/PascalDistribution.java
deleted file mode 100644
index 9a693d1..0000000
--- a/src/main/java/org/apache/commons/math4/distribution/PascalDistribution.java
+++ /dev/null
@@ -1,228 +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.combinatorics.BinomialCoefficientDouble;
-import org.apache.commons.numbers.combinatorics.LogBinomialCoefficient;
-import org.apache.commons.numbers.gamma.RegularizedBeta;
-import org.apache.commons.math4.util.FastMath;
-
-/**
- * <p>
- * Implementation of the Pascal distribution. The Pascal distribution is a
- * special case of the Negative Binomial distribution where the number of
- * successes parameter is an integer.
- * </p>
- * <p>
- * There are various ways to express the probability mass and distribution
- * functions for the Pascal distribution. The present implementation represents
- * the distribution of the number of failures before {@code r} successes occur.
- * This is the convention adopted in e.g.
- * <a href="http://mathworld.wolfram.com/NegativeBinomialDistribution.html">MathWorld</a>,
- * but <em>not</em> in
- * <a href="http://en.wikipedia.org/wiki/Negative_binomial_distribution">Wikipedia</a>.
- * </p>
- * <p>
- * For a random variable {@code X} whose values are distributed according to this
- * distribution, the probability mass function is given by<br>
- * {@code P(X = k) = C(k + r - 1, r - 1) * p^r * (1 - p)^k,}<br>
- * where {@code r} is the number of successes, {@code p} is the probability of
- * success, and {@code X} is the total number of failures. {@code C(n, k)} is
- * the binomial coefficient ({@code n} choose {@code k}). The mean and variance
- * of {@code X} are<br>
- * {@code E(X) = (1 - p) * r / p, var(X) = (1 - p) * r / p^2.}<br>
- * Finally, the cumulative distribution function is given by<br>
- * {@code P(X <= k) = I(p, r, k + 1)},
- * where I is the regularized incomplete Beta function.
- * </p>
- *
- * @see <a href="http://en.wikipedia.org/wiki/Negative_binomial_distribution">
- * Negative binomial distribution (Wikipedia)</a>
- * @see <a href="http://mathworld.wolfram.com/NegativeBinomialDistribution.html">
- * Negative binomial distribution (MathWorld)</a>
- * @since 1.2 (changed to concrete class in 3.0)
- */
-public class PascalDistribution extends AbstractIntegerDistribution {
- /** Serializable version identifier. */
- private static final long serialVersionUID = 6751309484392813623L;
- /** The number of successes. */
- private final int numberOfSuccesses;
- /** The probability of success. */
- private final double probabilityOfSuccess;
- /** The value of {@code log(p)}, where {@code p} is the probability of success,
- * stored for faster computation. */
- private final double logProbabilityOfSuccess;
- /** The value of {@code log(1-p)}, where {@code p} is the probability of success,
- * stored for faster computation. */
- private final double log1mProbabilityOfSuccess;
-
- /**
- * Create a Pascal distribution with the given number of successes and
- * probability of success.
- *
- * @param r Number of successes.
- * @param p Probability of success.
- * @throws NotStrictlyPositiveException if the number of successes is not positive
- * @throws OutOfRangeException if the probability of success is not in the
- * range {@code [0, 1]}.
- */
- public PascalDistribution(int r,
- double p)
- throws NotStrictlyPositiveException,
- OutOfRangeException {
- if (r <= 0) {
- throw new NotStrictlyPositiveException(LocalizedFormats.NUMBER_OF_SUCCESSES,
- r);
- }
- if (p < 0 || p > 1) {
- throw new OutOfRangeException(p, 0, 1);
- }
-
- numberOfSuccesses = r;
- probabilityOfSuccess = p;
- logProbabilityOfSuccess = FastMath.log(p);
- log1mProbabilityOfSuccess = FastMath.log1p(-p);
- }
-
- /**
- * Access the number of successes for this distribution.
- *
- * @return the number of successes.
- */
- public int getNumberOfSuccesses() {
- return numberOfSuccesses;
- }
-
- /**
- * Access the probability of success for this distribution.
- *
- * @return the probability of success.
- */
- public double getProbabilityOfSuccess() {
- return probabilityOfSuccess;
- }
-
- /** {@inheritDoc} */
- @Override
- public double probability(int x) {
- double ret;
- if (x < 0) {
- ret = 0.0;
- } else {
- ret = BinomialCoefficientDouble.value(x +
- numberOfSuccesses - 1, numberOfSuccesses - 1) *
- FastMath.pow(probabilityOfSuccess, numberOfSuccesses) *
- FastMath.pow(1.0 - probabilityOfSuccess, x);
- }
- return ret;
- }
-
- /** {@inheritDoc} */
- @Override
- public double logProbability(int x) {
- double ret;
- if (x < 0) {
- ret = Double.NEGATIVE_INFINITY;
- } else {
- ret = LogBinomialCoefficient.value(x +
- numberOfSuccesses - 1, numberOfSuccesses - 1) +
- logProbabilityOfSuccess * numberOfSuccesses +
- log1mProbabilityOfSuccess * x;
- }
- return ret;
- }
-
- /** {@inheritDoc} */
- @Override
- public double cumulativeProbability(int x) {
- double ret;
- if (x < 0) {
- ret = 0.0;
- } else {
- ret = RegularizedBeta.value(probabilityOfSuccess,
- numberOfSuccesses, x + 1.0);
- }
- return ret;
- }
-
- /**
- * {@inheritDoc}
- *
- * For number of successes {@code r} and probability of success {@code p},
- * the mean is {@code r * (1 - p) / p}.
- */
- @Override
- public double getNumericalMean() {
- final double p = getProbabilityOfSuccess();
- final double r = getNumberOfSuccesses();
- return (r * (1 - p)) / p;
- }
-
- /**
- * {@inheritDoc}
- *
- * For number of successes {@code r} and probability of success {@code p},
- * the variance is {@code r * (1 - p) / p^2}.
- */
- @Override
- public double getNumericalVariance() {
- final double p = getProbabilityOfSuccess();
- final double r = getNumberOfSuccesses();
- return r * (1 - p) / (p * p);
- }
-
- /**
- * {@inheritDoc}
- *
- * The lower bound of the support is always 0 no matter the parameters.
- *
- * @return lower bound of the support (always 0)
- */
- @Override
- public int getSupportLowerBound() {
- return 0;
- }
-
- /**
- * {@inheritDoc}
- *
- * The upper bound of the support is always positive infinity no matter the
- * parameters. Positive infinity is symbolized by {@code Integer.MAX_VALUE}.
- *
- * @return upper bound of the support (always {@code Integer.MAX_VALUE}
- * for positive infinity)
- */
- @Override
- public int getSupportUpperBound() {
- return Integer.MAX_VALUE;
- }
-
- /**
- * {@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/PoissonDistribution.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/distribution/PoissonDistribution.java b/src/main/java/org/apache/commons/math4/distribution/PoissonDistribution.java
deleted file mode 100644
index 87cd7ce..0000000
--- a/src/main/java/org/apache/commons/math4/distribution/PoissonDistribution.java
+++ /dev/null
@@ -1,259 +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.numbers.gamma.RegularizedGamma;
-import org.apache.commons.math4.util.FastMath;
-import org.apache.commons.math4.util.MathUtils;
-import org.apache.commons.rng.UniformRandomProvider;
-import org.apache.commons.rng.sampling.distribution.DiscreteSampler;
-import org.apache.commons.rng.sampling.distribution.PoissonSampler;
-
-/**
- * Implementation of the Poisson distribution.
- *
- * @see <a href="http://en.wikipedia.org/wiki/Poisson_distribution">Poisson distribution (Wikipedia)</a>
- * @see <a href="http://mathworld.wolfram.com/PoissonDistribution.html">Poisson distribution (MathWorld)</a>
- */
-public class PoissonDistribution extends AbstractIntegerDistribution {
- /**
- * Default maximum number of iterations for cumulative probability calculations.
- * @since 2.1
- */
- private static final int DEFAULT_MAX_ITERATIONS = 10000000;
- /**
- * Default convergence criterion.
- * @since 2.1
- */
- private static final double DEFAULT_EPSILON = 1e-12;
- /** Serializable version identifier. */
- private static final long serialVersionUID = -3349935121172596109L;
- /** Distribution used to compute normal approximation. */
- private final NormalDistribution normal;
- /** Mean of the distribution. */
- private final double mean;
-
- /** Maximum number of iterations for cumulative probability. */
- private final int maxIterations;
-
- /** Convergence criterion for cumulative probability. */
- private final double epsilon;
-
- /**
- * Creates a new Poisson distribution with specified mean.
- *
- * @param p the Poisson mean
- * @throws NotStrictlyPositiveException if {@code p <= 0}.
- */
- public PoissonDistribution(double p)
- throws NotStrictlyPositiveException {
- this(p, DEFAULT_EPSILON, DEFAULT_MAX_ITERATIONS);
- }
-
- /**
- * Creates a new Poisson distribution with specified mean, convergence
- * criterion and maximum number of iterations.
- *
- * @param p Poisson mean.
- * @param epsilon Convergence criterion for cumulative probabilities.
- * @param maxIterations the maximum number of iterations for cumulative
- * probabilities.
- * @throws NotStrictlyPositiveException if {@code p <= 0}.
- * @since 2.1
- */
- public PoissonDistribution(double p,
- double epsilon,
- int maxIterations)
- throws NotStrictlyPositiveException {
- if (p <= 0) {
- throw new NotStrictlyPositiveException(LocalizedFormats.MEAN, p);
- }
- mean = p;
- this.epsilon = epsilon;
- this.maxIterations = maxIterations;
-
- normal = new NormalDistribution(p, FastMath.sqrt(p),
- NormalDistribution.DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
- }
-
- /**
- * Creates a new Poisson distribution with the specified mean and
- * convergence criterion.
- *
- * @param p Poisson mean.
- * @param epsilon Convergence criterion for cumulative probabilities.
- * @throws NotStrictlyPositiveException if {@code p <= 0}.
- * @since 2.1
- */
- public PoissonDistribution(double p, double epsilon)
- throws NotStrictlyPositiveException {
- this(p, epsilon, DEFAULT_MAX_ITERATIONS);
- }
-
- /**
- * Creates a new Poisson distribution with the specified mean and maximum
- * number of iterations.
- *
- * @param p Poisson mean.
- * @param maxIterations Maximum number of iterations for cumulative
- * probabilities.
- * @since 2.1
- */
- public PoissonDistribution(double p, int maxIterations) {
- this(p, DEFAULT_EPSILON, maxIterations);
- }
-
- /**
- * Get the mean for the distribution.
- *
- * @return the mean for the distribution.
- */
- public double getMean() {
- return mean;
- }
-
- /** {@inheritDoc} */
- @Override
- public double probability(int x) {
- final double logProbability = logProbability(x);
- return logProbability == Double.NEGATIVE_INFINITY ? 0 : FastMath.exp(logProbability);
- }
-
- /** {@inheritDoc} */
- @Override
- public double logProbability(int x) {
- double ret;
- if (x < 0 || x == Integer.MAX_VALUE) {
- ret = Double.NEGATIVE_INFINITY;
- } else if (x == 0) {
- ret = -mean;
- } else {
- ret = -SaddlePointExpansion.getStirlingError(x) -
- SaddlePointExpansion.getDeviancePart(x, mean) -
- 0.5 * FastMath.log(MathUtils.TWO_PI) - 0.5 * FastMath.log(x);
- }
- return ret;
- }
-
- /** {@inheritDoc} */
- @Override
- public double cumulativeProbability(int x) {
- if (x < 0) {
- return 0;
- }
- if (x == Integer.MAX_VALUE) {
- return 1;
- }
- return RegularizedGamma.Q.value((double) x + 1, mean, epsilon,
- maxIterations);
- }
-
- /**
- * Calculates the Poisson distribution function using a normal
- * approximation. The {@code N(mean, sqrt(mean))} distribution is used
- * to approximate the Poisson distribution. The computation uses
- * "half-correction" (evaluating the normal distribution function at
- * {@code x + 0.5}).
- *
- * @param x Upper bound, inclusive.
- * @return the distribution function value calculated using a normal
- * approximation.
- */
- public double normalApproximateProbability(int x) {
- // calculate the probability using half-correction
- return normal.cumulativeProbability(x + 0.5);
- }
-
- /**
- * {@inheritDoc}
- *
- * For mean parameter {@code p}, the mean is {@code p}.
- */
- @Override
- public double getNumericalMean() {
- return getMean();
- }
-
- /**
- * {@inheritDoc}
- *
- * For mean parameter {@code p}, the variance is {@code p}.
- */
- @Override
- public double getNumericalVariance() {
- return getMean();
- }
-
- /**
- * {@inheritDoc}
- *
- * The lower bound of the support is always 0 no matter the mean parameter.
- *
- * @return lower bound of the support (always 0)
- */
- @Override
- public int getSupportLowerBound() {
- return 0;
- }
-
- /**
- * {@inheritDoc}
- *
- * The upper bound of the support is positive infinity,
- * regardless of the parameter values. There is no integer infinity,
- * so this method returns {@code Integer.MAX_VALUE}.
- *
- * @return upper bound of the support (always {@code Integer.MAX_VALUE} for
- * positive infinity)
- */
- @Override
- public int getSupportUpperBound() {
- return Integer.MAX_VALUE;
- }
-
- /**
- * {@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() {
- /**
- * Poisson distribution sampler.
- */
- private final DiscreteSampler sampler =
- new PoissonSampler(rng, mean);
-
- /**{@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/TDistribution.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math4/distribution/TDistribution.java b/src/main/java/org/apache/commons/math4/distribution/TDistribution.java
deleted file mode 100644
index 194ce94..0000000
--- a/src/main/java/org/apache/commons/math4/distribution/TDistribution.java
+++ /dev/null
@@ -1,218 +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.numbers.gamma.RegularizedBeta;
-import org.apache.commons.numbers.gamma.LogGamma;
-import org.apache.commons.math4.util.FastMath;
-
-/**
- * Implementation of Student's t-distribution.
- *
- * @see "<a href='http://en.wikipedia.org/wiki/Student's_t-distribution'>Student's t-distribution (Wikipedia)</a>"
- * @see "<a href='http://mathworld.wolfram.com/Studentst-Distribution.html'>Student's t-distribution (MathWorld)</a>"
- */
-public class TDistribution 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 degrees of freedom. */
- private final double degreesOfFreedom;
- /** Inverse cumulative probability accuracy. */
- private final double solverAbsoluteAccuracy;
- /** Static computation factor based on degreesOfFreedom. */
- private final double factor;
-
- /**
- * Creates a distribution.
- *
- * @param degreesOfFreedom Degrees of freedom.
- * @throws NotStrictlyPositiveException if {@code degreesOfFreedom <= 0}
- */
- public TDistribution(double degreesOfFreedom)
- throws NotStrictlyPositiveException {
- this(degreesOfFreedom, DEFAULT_INVERSE_ABSOLUTE_ACCURACY);
- }
-
- /**
- * Creates a distribution.
- *
- * @param degreesOfFreedom Degrees of freedom.
- * @param inverseCumAccuracy the maximum absolute error in inverse
- * cumulative probability estimates
- * (defaults to {@link #DEFAULT_INVERSE_ABSOLUTE_ACCURACY}).
- * @throws NotStrictlyPositiveException if {@code degreesOfFreedom <= 0}
- */
- public TDistribution(double degreesOfFreedom,
- double inverseCumAccuracy)
- throws NotStrictlyPositiveException {
- if (degreesOfFreedom <= 0) {
- throw new NotStrictlyPositiveException(LocalizedFormats.DEGREES_OF_FREEDOM,
- degreesOfFreedom);
- }
- this.degreesOfFreedom = degreesOfFreedom;
- solverAbsoluteAccuracy = inverseCumAccuracy;
-
- final double n = degreesOfFreedom;
- final double nPlus1Over2 = (n + 1) / 2;
- factor = LogGamma.value(nPlus1Over2) -
- 0.5 * (FastMath.log(FastMath.PI) + FastMath.log(n)) -
- LogGamma.value(n / 2);
- }
-
- /**
- * Access the degrees of freedom.
- *
- * @return the degrees of freedom.
- */
- public double getDegreesOfFreedom() {
- return degreesOfFreedom;
- }
-
- /** {@inheritDoc} */
- @Override
- public double density(double x) {
- return FastMath.exp(logDensity(x));
- }
-
- /** {@inheritDoc} */
- @Override
- public double logDensity(double x) {
- final double n = degreesOfFreedom;
- final double nPlus1Over2 = (n + 1) / 2;
- return factor - nPlus1Over2 * FastMath.log(1 + x * x / n);
- }
-
- /** {@inheritDoc} */
- @Override
- public double cumulativeProbability(double x) {
- double ret;
- if (x == 0) {
- ret = 0.5;
- } else {
- double t =
- RegularizedBeta.value(degreesOfFreedom / (degreesOfFreedom + (x * x)),
- 0.5 * degreesOfFreedom,
- 0.5);
- if (x < 0.0) {
- ret = 0.5 * t;
- } else {
- ret = 1.0 - 0.5 * t;
- }
- }
-
- return ret;
- }
-
- /** {@inheritDoc} */
- @Override
- protected double getSolverAbsoluteAccuracy() {
- return solverAbsoluteAccuracy;
- }
-
- /**
- * {@inheritDoc}
- *
- * For degrees of freedom parameter {@code df}, the mean is
- * <ul>
- * <li>if {@code df > 1} then {@code 0},</li>
- * <li>else undefined ({@code Double.NaN}).</li>
- * </ul>
- */
- @Override
- public double getNumericalMean() {
- final double df = getDegreesOfFreedom();
-
- if (df > 1) {
- return 0;
- }
-
- return Double.NaN;
- }
-
- /**
- * {@inheritDoc}
- *
- * For degrees of freedom parameter {@code df}, the variance is
- * <ul>
- * <li>if {@code df > 2} then {@code df / (df - 2)},</li>
- * <li>if {@code 1 < df <= 2} then positive infinity
- * ({@code Double.POSITIVE_INFINITY}),</li>
- * <li>else undefined ({@code Double.NaN}).</li>
- * </ul>
- */
- @Override
- public double getNumericalVariance() {
- final double df = getDegreesOfFreedom();
-
- if (df > 2) {
- return df / (df - 2);
- }
-
- if (df > 1 && df <= 2) {
- return Double.POSITIVE_INFINITY;
- }
-
- return Double.NaN;
- }
-
- /**
- * {@inheritDoc}
- *
- * The lower bound of the support is always negative infinity no matter the
- * parameters.
- *
- * @return lower bound of the support (always
- * {@code Double.NEGATIVE_INFINITY})
- */
- @Override
- public double getSupportLowerBound() {
- return Double.NEGATIVE_INFINITY;
- }
-
- /**
- * {@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;
- }
-}