Coverage Report - org.apache.commons.math.analysis.SimpsonIntegrator

Classes in this File	Line Coverage	Branch Coverage	Complexity
SimpsonIntegrator	86%	100%	4.0;4

1		/*
2		* Copyright 2005 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.analysis;
17
18		import org.apache.commons.math.ConvergenceException;
19		import org.apache.commons.math.FunctionEvaluationException;
20
21		/**
22		* Implements the <a href="http://mathworld.wolfram.com/SimpsonsRule.html">
23		* Simpson's Rule</a> for integration of real univariate functions. For
24		* reference, see <b>Introduction to Numerical Analysis</b>, ISBN 038795452X,
25		* chapter 3.
26		* <p>
27		* This implementation employs basic trapezoid rule as building blocks to
28		* calculate the Simpson's rule of alternating 2/3 and 4/3.
29		*
30		* @version $Revision$ $Date: 2005-08-24 15:27:44 -0700 (Wed, 24 Aug 2005) $
31		*/
32		public class SimpsonIntegrator extends UnivariateRealIntegratorImpl {
33
34		/** serializable version identifier */
35		static final long serialVersionUID = 3405465123320678216L;
36
37		/**
38		* Construct an integrator for the given function.
39		*
40		* @param f function to integrate
41		*/
42		public SimpsonIntegrator(UnivariateRealFunction f) {
43	6	super(f, 64);
44	6	}
45
46		/**
47		* Integrate the function in the given interval.
48		*
49		* @param min the lower bound for the interval
50		* @param max the upper bound for the interval
51		* @return the value of integral
52		* @throws ConvergenceException if the maximum iteration count is exceeded
53		* or the integrator detects convergence problems otherwise
54		* @throws FunctionEvaluationException if an error occurs evaluating the
55		* function
56		* @throws IllegalArgumentException if any parameters are invalid
57		*/
58		public double integrate(double min, double max) throws ConvergenceException,
59		FunctionEvaluationException, IllegalArgumentException {
60
61	16	int i = 1;
62		double s, olds, t, oldt;
63
64	16	clearResult();
65	16	verifyInterval(min, max);
66	14	verifyIterationCount();
67
68	10	TrapezoidIntegrator qtrap = new TrapezoidIntegrator(this.f);
69	10	if (minimalIterationCount == 1) {
70	0	s = (4 * qtrap.stage(min, max, 1) - qtrap.stage(min, max, 0)) / 3.0;
71	0	setResult(s, 1);
72	0	return result;
73		}
74		// Simpson's rule requires at least two trapezoid stages.
75	10	olds = 0;
76	10	oldt = qtrap.stage(min, max, 0);
77	62	while (i <= maximalIterationCount) {
78	62	t = qtrap.stage(min, max, i);
79	62	s = (4 * t - oldt) / 3.0;
80	62	if (i >= minimalIterationCount) {
81	42	if (Math.abs(s - olds) <= Math.abs(relativeAccuracy * olds)) {
82	10	setResult(s, i);
83	10	return result;
84		}
85		}
86	52	olds = s;
87	52	oldt = t;
88	52	i++;
89		}
90	0	throw new ConvergenceException("Maximum number of iterations exceeded.");
91		}
92
93		/**
94		* Verifies that the iteration limits are valid and within the range.
95		*
96		* @throws IllegalArgumentException if not
97		*/
98		protected void verifyIterationCount() throws IllegalArgumentException {
99	20	super.verifyIterationCount();
100		// at most 64 bisection refinements
101	18	if (maximalIterationCount > 64) {
102	2	throw new IllegalArgumentException
103		("Iteration upper limit out of [0, 64] range: " +
104		maximalIterationCount);
105		}
106	16	}
107		}