Author: luc
Date: Wed Sep 10 12:55:08 2008
New Revision: 693959
URL: http://svn.apache.org/viewvc?rev=693959&view=rev
Log:
added beta distribution
JIRA: MATH-222
Added:
commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/distribution/BetaDistribution.java
(with props)
commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/distribution/BetaDistributionImpl.java
(with props)
commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/distribution/BetaDistributionTest.java
(with props)
Modified:
commons/proper/math/branches/MATH_2_0/src/site/xdoc/changes.xml
Added:
commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/distribution/BetaDistribution.java
URL:
http://svn.apache.org/viewvc/commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/distribution/BetaDistribution.java?rev=693959&view=auto
==============================================================================
---
commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/distribution/BetaDistribution.java
(added)
+++
commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/distribution/BetaDistribution.java
Wed Sep 10 12:55:08 2008
@@ -0,0 +1,58 @@
+/*
+ * 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.math.distribution;
+
+import org.apache.commons.math.MathException;
+
+/**
+ * Computes the cumulative, inverse cumulative and density functions for the
beta distribuiton.
+ *
+ * See http://en.wikipedia.org/wiki/Beta_distribution
+ */
+public interface BetaDistribution extends ContinuousDistribution,
HasDensity<Double> {
+ /**
+ * Modify the shape parameter, alpha.
+ * @param alpha the new shape parameter.
+ */
+ void setAlpha(double alpha);
+
+ /**
+ * Access the shape parameter, alpha
+ * @return alpha.
+ */
+ double getAlpha();
+
+ /**
+ * Modify the shape parameter, beta.
+ * @param beta the new scale parameter.
+ */
+ void setBeta(double beta);
+
+ /**
+ * Access the shape parameter, beta
+ * @return beta.
+ */
+ double getBeta();
+
+ /**
+ * Return the probability density for a particular point.
+ * @param x The point at which the density should be computed.
+ * @return The pdf at point x.
+ */
+ double density(Double x) throws MathException;
+
+}
Propchange:
commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/distribution/BetaDistribution.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange:
commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/distribution/BetaDistribution.java
------------------------------------------------------------------------------
svn:keywords = Author Date Id Revision
Added:
commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/distribution/BetaDistributionImpl.java
URL:
http://svn.apache.org/viewvc/commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/distribution/BetaDistributionImpl.java?rev=693959&view=auto
==============================================================================
---
commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/distribution/BetaDistributionImpl.java
(added)
+++
commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/distribution/BetaDistributionImpl.java
Wed Sep 10 12:55:08 2008
@@ -0,0 +1,232 @@
+/*
+ * 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.math.distribution;
+
+import org.apache.commons.math.MathException;
+import org.apache.commons.math.special.Gamma;
+import org.apache.commons.math.special.Beta;
+
+/**
+ * Implements the Beta distribution.
+ * <p>
+ * References:
+ * <ul>
+ * <li><a href="http://en.wikipedia.org/wiki/Beta_distribution";>
+ * Beta distribution</a></li>
+ * </ul>
+ * </p>
+ */
+public class BetaDistributionImpl
+ extends AbstractContinuousDistribution implements BetaDistribution {
+
+ /** Serializable version identifier. */
+ private static final long serialVersionUID = -1221965979403477668L;
+
+ /** First shape parameter. */
+ private double alpha;
+
+ /** Second shape parameter. */
+ private double beta;
+
+ /** Normalizing factor used in density computations.
+ * updated whenever alpha or beta are changed.
+ */
+ private double z;
+
+ /**
+ * Build a new instance.
+ * @param alpha first shape parameter (must be positive)
+ * @param beta second shape parameter (must be positive)
+ */
+ public BetaDistributionImpl(double alpha, double beta) {
+ this.alpha = alpha;
+ this.beta = beta;
+ z = Double.NaN;
+ }
+
+ /**
+ * Modify the shape parameter, alpha.
+ *
+ * @param alpha the new shape parameter.
+ */
+ public void setAlpha(double alpha) {
+ this.alpha = alpha;
+ z = Double.NaN;
+ }
+
+ /**
+ * Access the shape parameter, alpha
+ *
+ * @return alpha.
+ */
+ public double getAlpha() {
+ return alpha;
+ }
+
+ /**
+ * Modify the shape parameter, beta.
+ *
+ * @param beta the new scale parameter.
+ */
+ public void setBeta(double beta) {
+ this.beta = beta;
+ z = Double.NaN;
+ }
+
+ /**
+ * Access the shape parameter, beta
+ *
+ * @return beta.
+ */
+ public double getBeta() {
+ return beta;
+ }
+
+ /**
+ * Recompute the normalization factor.
+ */
+ private void recomputeZ() {
+ if (Double.isNaN(z)) {
+ z = Gamma.logGamma(alpha) + Gamma.logGamma(beta) -
Gamma.logGamma(alpha + beta);
+ }
+ }
+
+ /**
+ * Return the probability density for a particular point.
+ *
+ * @param x The point at which the density should be computed.
+ * @return The pdf at point x.
+ */
+ public double density(Double x) throws MathException {
+ recomputeZ();
+ if (x < 0 || x > 1) {
+ return 0;
+ } else if (x == 0) {
+ if (alpha < 1) {
+ throw new MathException("Cannot compute beta density at 0 when
alpha = {0,number}", new Double[]{alpha});
+ }
+ return 0;
+ } else if (x == 1) {
+ if (beta < 1) {
+ throw new MathException("Cannot compute beta density at 1 when
beta = %.3g", new Double[]{beta});
+ }
+ return 0;
+ } else {
+ double logX = Math.log(x);
+ double log1mX = Math.log1p(-x);
+ return Math.exp((alpha - 1) * logX + (beta - 1) * log1mX - z);
+ }
+ }
+
+ /**
+ * For this distribution, X, this method returns x such that P(X < x) =
p.
+ *
+ * @param p the cumulative probability.
+ * @return x.
+ * @throws org.apache.commons.math.MathException
+ * if the inverse cumulative probability can not be
+ * computed due to convergence or other numerical errors.
+ */
+ public double inverseCumulativeProbability(double p) throws MathException {
+ if (p == 0) {
+ return 0;
+ } else if (p == 1) {
+ return 1;
+ } else {
+ return super.inverseCumulativeProbability(p);
+ }
+ }
+
+ /**
+ * Access the initial domain value, based on <code>p</code>, used to
+ * bracket a CDF root. This method is used by
+ * [EMAIL PROTECTED] #inverseCumulativeProbability(double)} to find
critical values.
+ *
+ * @param p the desired probability for the critical value
+ * @return initial domain value
+ */
+ protected double getInitialDomain(double p) {
+ return p;
+ }
+
+ /**
+ * Access the domain value lower bound, based on <code>p</code>, used to
+ * bracket a CDF root. This method is used by
+ * [EMAIL PROTECTED] #inverseCumulativeProbability(double)} to find
critical values.
+ *
+ * @param p the desired probability for the critical value
+ * @return domain value lower bound, i.e.
+ * P(X < <i>lower bound</i>) < <code>p</code>
+ */
+ protected double getDomainLowerBound(double p) {
+ return 0;
+ }
+
+ /**
+ * Access the domain value upper bound, based on <code>p</code>, used to
+ * bracket a CDF root. This method is used by
+ * [EMAIL PROTECTED] #inverseCumulativeProbability(double)} to find
critical values.
+ *
+ * @param p the desired probability for the critical value
+ * @return domain value upper bound, i.e.
+ * P(X < <i>upper bound</i>) > <code>p</code>
+ */
+ protected double getDomainUpperBound(double p) {
+ return 1;
+ }
+
+ /**
+ * For a random variable X whose values are distributed according
+ * to this distribution, this method returns P(X ≤ x). In other words,
+ * this method represents the (cumulative) distribution function, or
+ * CDF, for this distribution.
+ *
+ * @param x the value at which the distribution function is evaluated.
+ * @return the probability that a random variable with this
+ * distribution takes a value less than or equal to <code>x</code>
+ * @throws org.apache.commons.math.MathException
+ * if the cumulative probability can not be
+ * computed due to convergence or other numerical errors.
+ */
+ public double cumulativeProbability(double x) throws MathException {
+ if (x <= 0) {
+ return 0;
+ } else if (x >= 1) {
+ return 1;
+ } else {
+ return Beta.regularizedBeta(x, alpha, beta);
+ }
+ }
+
+ /**
+ * For a random variable X whose values are distributed according
+ * to this distribution, this method returns P(x0 ≤ X ≤ x1).
+ *
+ * @param x0 the (inclusive) lower bound
+ * @param x1 the (inclusive) upper bound
+ * @return the probability that a random variable with this distribution
+ * will take a value between <code>x0</code> and <code>x1</code>,
+ * including the endpoints
+ * @throws org.apache.commons.math.MathException
+ * if the cumulative probability can not
be
+ * computed due to convergence or other
numerical errors.
+ * @throws IllegalArgumentException if <code>x0 > x1</code>
+ */
+ public double cumulativeProbability(double x0, double x1) throws
MathException {
+ return cumulativeProbability(x1) - cumulativeProbability(x0);
+ }
+}
Propchange:
commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/distribution/BetaDistributionImpl.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange:
commons/proper/math/branches/MATH_2_0/src/java/org/apache/commons/math/distribution/BetaDistributionImpl.java
------------------------------------------------------------------------------
svn:keywords = Author Date Id Revision
Modified: commons/proper/math/branches/MATH_2_0/src/site/xdoc/changes.xml
URL:
http://svn.apache.org/viewvc/commons/proper/math/branches/MATH_2_0/src/site/xdoc/changes.xml?rev=693959&r1=693958&r2=693959&view=diff
==============================================================================
--- commons/proper/math/branches/MATH_2_0/src/site/xdoc/changes.xml (original)
+++ commons/proper/math/branches/MATH_2_0/src/site/xdoc/changes.xml Wed Sep 10
12:55:08 2008
@@ -40,6 +40,9 @@
<body>
<release version="2.0" date="TBD" description="TBD">
<action dev="luc" type="add" issue="MATH-222" due-to="Ted Dunning">
+ Added beta distribution.
+ </action>
+ <action dev="luc" type="add" issue="MATH-222" due-to="Ted Dunning">
Added probability density functions computation for distributions for
which
it is feasible.
</action>
Added:
commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/distribution/BetaDistributionTest.java
URL:
http://svn.apache.org/viewvc/commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/distribution/BetaDistributionTest.java?rev=693959&view=auto
==============================================================================
---
commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/distribution/BetaDistributionTest.java
(added)
+++
commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/distribution/BetaDistributionTest.java
Wed Sep 10 12:55:08 2008
@@ -0,0 +1,289 @@
+/*
+ * 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.math.distribution;
+
+import junit.framework.TestCase;
+import org.apache.commons.math.MathException;
+
+public class BetaDistributionTest extends TestCase {
+ public void testCumulative() throws MathException {
+ 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) throws MathException {
+ BetaDistribution d = new BetaDistributionImpl(alpha, beta);
+ for (int i = 0; i < x.length; i++) {
+ assertEquals(cumes[i], d.cumulativeProbability(x[i]), 1e-8);
+ }
+
+ for (int i = 1; i < x.length - 1; i++) {
+ assertEquals(x[i], d.inverseCumulativeProbability(cumes[i]), 1e-5);
+ }
+ }
+
+ public void testDensity() throws MathException {
+ 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});
+
+ }
+
+ private void checkDensity(double alpha, double beta, double[] x, double[]
expected) throws MathException {
+ BetaDistribution d = new BetaDistributionImpl(alpha, beta);
+ for (int i = 0; i < x.length; i++) {
+ assertEquals(String.format("density at x=%.1f for alpha=%.1f,
beta=%.1f", x[i], alpha, beta), expected[i], d.density(x[i]), 1e-5);
+ }
+ }
+}
Propchange:
commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/distribution/BetaDistributionTest.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange:
commons/proper/math/branches/MATH_2_0/src/test/org/apache/commons/math/distribution/BetaDistributionTest.java
------------------------------------------------------------------------------
svn:keywords = Author Date Id Revision
