Coverage Report - org.apache.commons.math.distribution.ChiSquaredDistributionImpl

Classes in this File	Line Coverage	Branch Coverage	Complexity
ChiSquaredDistributionImpl	100%	100%	1.6;1.6

1		/*
2		* Copyright 2003-2004 The Apache Software Foundation.
3		*
4		* Licensed under the Apache License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.apache.org/licenses/LICENSE-2.0
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16		package org.apache.commons.math.distribution;
17
18		import java.io.Serializable;
19
20		import org.apache.commons.math.MathException;
21
22		/**
23		* The default implementation of {@link ChiSquaredDistribution}
24		*
25		* @version $Revision$ $Date: 2005-02-26 05:11:52 -0800 (Sat, 26 Feb 2005) $
26		*/
27		public class ChiSquaredDistributionImpl
28		extends AbstractContinuousDistribution
29		implements ChiSquaredDistribution, Serializable {
30
31		/** Serializable version identifier */
32		static final long serialVersionUID = -8352658048349159782L;
33
34		/** Internal Gamma distribution. */
35		private GammaDistribution gamma;
36
37		/**
38		* Create a Chi-Squared distribution with the given degrees of freedom.
39		* @param degreesOfFreedom degrees of freedom.
40		*/
41		public ChiSquaredDistributionImpl(double degreesOfFreedom) {
42	98	super();
43	98	setGamma(DistributionFactory.newInstance().createGammaDistribution(
44		degreesOfFreedom / 2.0, 2.0));
45	94	}
46
47		/**
48		* Modify the degrees of freedom.
49		* @param degreesOfFreedom the new degrees of freedom.
50		*/
51		public void setDegreesOfFreedom(double degreesOfFreedom) {
52	4	getGamma().setAlpha(degreesOfFreedom / 2.0);
53	2	}
54
55		/**
56		* Access the degrees of freedom.
57		* @return the degrees of freedom.
58		*/
59		public double getDegreesOfFreedom() {
60	64	return getGamma().getAlpha() * 2.0;
61		}
62
63		/**
64		* For this disbution, X, this method returns P(X < x).
65		* @param x the value at which the CDF is evaluated.
66		* @return CDF for this distribution.
67		* @throws MathException if the cumulative probability can not be
68		* computed due to convergence or other numerical errors.
69		*/
70		public double cumulativeProbability(double x) throws MathException {
71	842	return getGamma().cumulativeProbability(x);
72		}
73
74		/**
75		* For this distribution, X, this method returns the critical point x, such
76		* that P(X &lt; x) = <code>p</code>.
77		* <p>
78		* Returns 0 for p=0 and <code>Double.POSITIVE_INFINITY</code> for p=1.
79		*
80		* @param p the desired probability
81		* @return x, such that P(X &lt; x) = <code>p</code>
82		* @throws MathException if the inverse cumulative probability can not be
83		* computed due to convergence or other numerical errors.
84		* @throws IllegalArgumentException if <code>p</code> is not a valid
85		* probability.
86		*/
87		public double inverseCumulativeProbability(final double p)
88		throws MathException {
89	48	if (p == 0) {
90	2	return 0d;
91		}
92	46	if (p == 1) {
93	2	return Double.POSITIVE_INFINITY;
94		}
95	44	return super.inverseCumulativeProbability(p);
96		}
97
98		/**
99		* Access the domain value lower bound, based on <code>p</code>, used to
100		* bracket a CDF root. This method is used by
101		* {@link #inverseCumulativeProbability(double)} to find critical values.
102		*
103		* @param p the desired probability for the critical value
104		* @return domain value lower bound, i.e.
105		* P(X &lt; <i>lower bound</i>) &lt; <code>p</code>
106		*/
107		protected double getDomainLowerBound(double p) {
108	40	return Double.MIN_VALUE * getGamma().getBeta();
109		}
110
111		/**
112		* Access the domain value upper bound, based on <code>p</code>, used to
113		* bracket a CDF root. This method is used by
114		* {@link #inverseCumulativeProbability(double)} to find critical values.
115		*
116		* @param p the desired probability for the critical value
117		* @return domain value upper bound, i.e.
118		* P(X &lt; <i>upper bound</i>) &gt; <code>p</code>
119		*/
120		protected double getDomainUpperBound(double p) {
121		// NOTE: chi squared is skewed to the left
122		// NOTE: therefore, P(X < &mu;) > .5
123
124		double ret;
125
126	40	if (p < .5) {
127		// use mean
128	20	ret = getDegreesOfFreedom();
129		} else {
130		// use max
131	20	ret = Double.MAX_VALUE;
132		}
133
134	40	return ret;
135		}
136
137		/**
138		* Access the initial domain value, based on <code>p</code>, used to
139		* bracket a CDF root. This method is used by
140		* {@link #inverseCumulativeProbability(double)} to find critical values.
141		*
142		* @param p the desired probability for the critical value
143		* @return initial domain value
144		*/
145		protected double getInitialDomain(double p) {
146		// NOTE: chi squared is skewed to the left
147		// NOTE: therefore, P(X < &mu;) > .5
148
149		double ret;
150
151	40	if (p < .5) {
152		// use 1/2 mean
153	20	ret = getDegreesOfFreedom() * .5;
154		} else {
155		// use mean
156	20	ret = getDegreesOfFreedom();
157		}
158
159	40	return ret;
160		}
161
162		/**
163		* Modify the Gamma distribution.
164		* @param gamma the new distribution.
165		*/
166		private void setGamma(GammaDistribution gamma) {
167	94	this.gamma = gamma;
168	94	}
169
170		/**
171		* Access the Gamma distribution.
172		* @return the internal Gamma distribution.
173		*/
174		private GammaDistribution getGamma() {
175	950	return gamma;
176		}
177		}