001 /*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements. See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache License, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License. You may obtain a copy of the License at
008 *
009 * http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the License for the specific language governing permissions and
015 * limitations under the License.
016 */
017 package org.apache.commons.math.analysis.integration;
018
019 import org.apache.commons.math.ConvergingAlgorithmImpl;
020 import org.apache.commons.math.MathRuntimeException;
021 import org.apache.commons.math.analysis.UnivariateRealFunction;
022 import org.apache.commons.math.exception.util.LocalizedFormats;
023 import org.apache.commons.math.exception.NullArgumentException;
024
025 /**
026 * Provide a default implementation for several generic functions.
027 *
028 * @version $Revision: 1072409 $ $Date: 2011-02-19 19:50:36 +0100 (sam. 19 f??vr. 2011) $
029 * @since 1.2
030 */
031 public abstract class UnivariateRealIntegratorImpl
032 extends ConvergingAlgorithmImpl implements UnivariateRealIntegrator {
033
034 /** Serializable version identifier. */
035 private static final long serialVersionUID = 6248808456637441533L;
036
037 /** minimum number of iterations */
038 protected int minimalIterationCount;
039
040 /** default minimum number of iterations */
041 protected int defaultMinimalIterationCount;
042
043 /** indicates whether an integral has been computed */
044 protected boolean resultComputed = false;
045
046 /** the last computed integral */
047 protected double result;
048
049 /**
050 * The integrand function.
051 *
052 * @deprecated as of 2.0 the integrand function is passed as an argument
053 * to the {@link #integrate(UnivariateRealFunction, double, double)}method.
054 */
055 @Deprecated
056 protected UnivariateRealFunction f;
057
058 /**
059 * Construct an integrator with given iteration count and accuracy.
060 *
061 * @param f the integrand function
062 * @param defaultMaximalIterationCount maximum number of iterations
063 * @throws IllegalArgumentException if f is null or the iteration
064 * limits are not valid
065 * @deprecated as of 2.0 the integrand function is passed as an argument
066 * to the {@link #integrate(UnivariateRealFunction, double, double)}method.
067 */
068 @Deprecated
069 protected UnivariateRealIntegratorImpl(final UnivariateRealFunction f,
070 final int defaultMaximalIterationCount)
071 throws IllegalArgumentException {
072 super(defaultMaximalIterationCount, 1.0e-15);
073 if (f == null) {
074 throw new NullArgumentException(LocalizedFormats.FUNCTION);
075 }
076
077 this.f = f;
078
079 // parameters that are problem specific
080 setRelativeAccuracy(1.0e-6);
081 this.defaultMinimalIterationCount = 3;
082 this.minimalIterationCount = defaultMinimalIterationCount;
083
084 verifyIterationCount();
085 }
086
087 /**
088 * Construct an integrator with given iteration count and accuracy.
089 *
090 * @param defaultMaximalIterationCount maximum number of iterations
091 * @throws IllegalArgumentException if f is null or the iteration
092 * limits are not valid
093 */
094 protected UnivariateRealIntegratorImpl(final int defaultMaximalIterationCount)
095 throws IllegalArgumentException {
096 super(defaultMaximalIterationCount, 1.0e-15);
097
098 // parameters that are problem specific
099 setRelativeAccuracy(1.0e-6);
100 this.defaultMinimalIterationCount = 3;
101 this.minimalIterationCount = defaultMinimalIterationCount;
102
103 verifyIterationCount();
104 }
105
106 /**
107 * Access the last computed integral.
108 *
109 * @return the last computed integral
110 * @throws IllegalStateException if no integral has been computed
111 */
112 public double getResult() throws IllegalStateException {
113 if (resultComputed) {
114 return result;
115 } else {
116 throw MathRuntimeException.createIllegalStateException(LocalizedFormats.NO_RESULT_AVAILABLE);
117 }
118 }
119
120 /**
121 * Convenience function for implementations.
122 *
123 * @param newResult the result to set
124 * @param iterationCount the iteration count to set
125 */
126 protected final void setResult(double newResult, int iterationCount) {
127 this.result = newResult;
128 this.iterationCount = iterationCount;
129 this.resultComputed = true;
130 }
131
132 /**
133 * Convenience function for implementations.
134 */
135 protected final void clearResult() {
136 this.iterationCount = 0;
137 this.resultComputed = false;
138 }
139
140 /** {@inheritDoc} */
141 public void setMinimalIterationCount(int count) {
142 minimalIterationCount = count;
143 }
144
145 /** {@inheritDoc} */
146 public int getMinimalIterationCount() {
147 return minimalIterationCount;
148 }
149
150 /** {@inheritDoc} */
151 public void resetMinimalIterationCount() {
152 minimalIterationCount = defaultMinimalIterationCount;
153 }
154
155 /**
156 * Verifies that the endpoints specify an interval.
157 *
158 * @param lower lower endpoint
159 * @param upper upper endpoint
160 * @throws IllegalArgumentException if not interval
161 */
162 protected void verifyInterval(double lower, double upper) throws
163 IllegalArgumentException {
164 if (lower >= upper) {
165 throw MathRuntimeException.createIllegalArgumentException(
166 LocalizedFormats.ENDPOINTS_NOT_AN_INTERVAL,
167 lower, upper);
168 }
169 }
170
171 /**
172 * Verifies that the upper and lower limits of iterations are valid.
173 *
174 * @throws IllegalArgumentException if not valid
175 */
176 protected void verifyIterationCount() throws IllegalArgumentException {
177 if ((minimalIterationCount <= 0) || (maximalIterationCount <= minimalIterationCount)) {
178 throw MathRuntimeException.createIllegalArgumentException(
179 LocalizedFormats.INVALID_ITERATIONS_LIMITS,
180 minimalIterationCount, maximalIterationCount);
181 }
182 }
183 }