Classes in this File | Line Coverage | Branch Coverage | Complexity | ||||||||
UnivariateRealSolverImpl |
|
| 1.6363636363636365;1.636 |
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 | ||
17 | package org.apache.commons.math.analysis; |
|
18 | ||
19 | import java.io.Serializable; |
|
20 | ||
21 | import org.apache.commons.math.FunctionEvaluationException; |
|
22 | ||
23 | /** |
|
24 | * Provide a default implementation for several functions useful to generic |
|
25 | * solvers. |
|
26 | * |
|
27 | * @version $Revision$ $Date: 2005-08-26 07:05:45 -0700 (Fri, 26 Aug 2005) $ |
|
28 | */ |
|
29 | public abstract class UnivariateRealSolverImpl implements UnivariateRealSolver, |
|
30 | Serializable { |
|
31 | ||
32 | /** Serializable version identifier */ |
|
33 | static final long serialVersionUID = 1112491292565386596L; |
|
34 | ||
35 | /** Maximum absolute error. */ |
|
36 | protected double absoluteAccuracy; |
|
37 | ||
38 | /** Maximum relative error. */ |
|
39 | protected double relativeAccuracy; |
|
40 | ||
41 | /** Maximum error of function. */ |
|
42 | protected double functionValueAccuracy; |
|
43 | ||
44 | /** Maximum number of iterations. */ |
|
45 | protected int maximalIterationCount; |
|
46 | ||
47 | /** Default maximum absolute error. */ |
|
48 | protected double defaultAbsoluteAccuracy; |
|
49 | ||
50 | /** Default maximum relative error. */ |
|
51 | protected double defaultRelativeAccuracy; |
|
52 | ||
53 | /** Default maximum error of function. */ |
|
54 | protected double defaultFunctionValueAccuracy; |
|
55 | ||
56 | /** Default maximum number of iterations. */ |
|
57 | protected int defaultMaximalIterationCount; |
|
58 | ||
59 | /** Indicates where a root has been computed. */ |
|
60 | 282 | protected boolean resultComputed = false; |
61 | ||
62 | /** The last computed root. */ |
|
63 | protected double result; |
|
64 | ||
65 | // Mainly for test framework. |
|
66 | /** The last iteration count. */ |
|
67 | protected int iterationCount; |
|
68 | ||
69 | /** The function to solve. */ |
|
70 | protected UnivariateRealFunction f; |
|
71 | ||
72 | /** |
|
73 | * Construct a solver with given iteration count and accuracy. |
|
74 | * |
|
75 | * @param f the function to solve. |
|
76 | * @param defaultAbsoluteAccuracy maximum absolute error |
|
77 | * @param defaultMaximalIterationCount maximum number of iterations |
|
78 | * @throws IllegalArgumentException if f is null or the |
|
79 | * defaultAbsoluteAccuracy is not valid |
|
80 | */ |
|
81 | protected UnivariateRealSolverImpl( |
|
82 | UnivariateRealFunction f, |
|
83 | int defaultMaximalIterationCount, |
|
84 | double defaultAbsoluteAccuracy) { |
|
85 | ||
86 | 282 | super(); |
87 | ||
88 | 282 | if (f == null) { |
89 | 8 | throw new IllegalArgumentException("function can not be null."); |
90 | } |
|
91 | ||
92 | 274 | this.f = f; |
93 | 274 | this.defaultAbsoluteAccuracy = defaultAbsoluteAccuracy; |
94 | 274 | this.defaultRelativeAccuracy = 1E-14; |
95 | 274 | this.defaultFunctionValueAccuracy = 1E-15; |
96 | 274 | this.absoluteAccuracy = defaultAbsoluteAccuracy; |
97 | 274 | this.relativeAccuracy = defaultRelativeAccuracy; |
98 | 274 | this.functionValueAccuracy = defaultFunctionValueAccuracy; |
99 | 274 | this.defaultMaximalIterationCount = defaultMaximalIterationCount; |
100 | 274 | this.maximalIterationCount = defaultMaximalIterationCount; |
101 | 274 | } |
102 | ||
103 | /** |
|
104 | * Access the last computed root. |
|
105 | * |
|
106 | * @return the last computed root |
|
107 | * @throws IllegalStateException if no root has been computed |
|
108 | */ |
|
109 | public double getResult() { |
|
110 | 6 | if (resultComputed) { |
111 | 6 | return result; |
112 | } else { |
|
113 | 0 | throw new IllegalStateException("No result available"); |
114 | } |
|
115 | } |
|
116 | ||
117 | /** |
|
118 | * Access the last iteration count. |
|
119 | * |
|
120 | * @return the last iteration count |
|
121 | * @throws IllegalStateException if no root has been computed |
|
122 | * |
|
123 | */ |
|
124 | public int getIterationCount() { |
|
125 | 56 | if (resultComputed) { |
126 | 56 | return iterationCount; |
127 | } else { |
|
128 | 0 | throw new IllegalStateException("No result available"); |
129 | } |
|
130 | } |
|
131 | ||
132 | /** |
|
133 | * Convenience function for implementations. |
|
134 | * |
|
135 | * @param result the result to set |
|
136 | * @param iterationCount the iteration count to set |
|
137 | */ |
|
138 | protected final void setResult(double result, int iterationCount) { |
|
139 | 396 | this.result = result; |
140 | 396 | this.iterationCount = iterationCount; |
141 | 396 | this.resultComputed = true; |
142 | 396 | } |
143 | ||
144 | /** |
|
145 | * Convenience function for implementations. |
|
146 | */ |
|
147 | protected final void clearResult() { |
|
148 | 346 | this.resultComputed = false; |
149 | 346 | } |
150 | ||
151 | /** |
|
152 | * Set the absolute accuracy. |
|
153 | * |
|
154 | * @param accuracy the accuracy. |
|
155 | * @throws IllegalArgumentException if the accuracy can't be achieved by |
|
156 | * the solver or is otherwise deemed unreasonable. |
|
157 | */ |
|
158 | public void setAbsoluteAccuracy(double accuracy) { |
|
159 | 10 | absoluteAccuracy = accuracy; |
160 | 10 | } |
161 | ||
162 | /** |
|
163 | * Get the actual absolute accuracy. |
|
164 | * |
|
165 | * @return the accuracy |
|
166 | */ |
|
167 | public double getAbsoluteAccuracy() { |
|
168 | 226 | return absoluteAccuracy; |
169 | } |
|
170 | ||
171 | /** |
|
172 | * Reset the absolute accuracy to the default. |
|
173 | */ |
|
174 | public void resetAbsoluteAccuracy() { |
|
175 | 2 | absoluteAccuracy = defaultAbsoluteAccuracy; |
176 | 2 | } |
177 | ||
178 | /** |
|
179 | * Set the upper limit for the number of iterations. |
|
180 | * |
|
181 | * @param count maximum number of iterations |
|
182 | */ |
|
183 | public void setMaximalIterationCount(int count) { |
|
184 | 4 | maximalIterationCount = count; |
185 | 4 | } |
186 | ||
187 | /** |
|
188 | * Get the upper limit for the number of iterations. |
|
189 | * |
|
190 | * @return the actual upper limit |
|
191 | */ |
|
192 | public int getMaximalIterationCount() { |
|
193 | 6 | return maximalIterationCount; |
194 | } |
|
195 | ||
196 | /** |
|
197 | * Reset the upper limit for the number of iterations to the default. |
|
198 | */ |
|
199 | public void resetMaximalIterationCount() { |
|
200 | 2 | maximalIterationCount = defaultMaximalIterationCount; |
201 | 2 | } |
202 | ||
203 | /** |
|
204 | * Set the relative accuracy. |
|
205 | * |
|
206 | * @param accuracy the relative accuracy. |
|
207 | * @throws IllegalArgumentException if the accuracy can't be achieved by |
|
208 | * the solver or is otherwise deemed unreasonable. |
|
209 | */ |
|
210 | public void setRelativeAccuracy(double accuracy) { |
|
211 | 8 | relativeAccuracy = accuracy; |
212 | 8 | } |
213 | ||
214 | /** |
|
215 | * Get the actual relative accuracy. |
|
216 | * @return the accuracy |
|
217 | */ |
|
218 | public double getRelativeAccuracy() { |
|
219 | 84 | return relativeAccuracy; |
220 | } |
|
221 | ||
222 | /** |
|
223 | * Reset the relative accuracy to the default. |
|
224 | */ |
|
225 | public void resetRelativeAccuracy() { |
|
226 | 6 | relativeAccuracy = defaultRelativeAccuracy; |
227 | 6 | } |
228 | ||
229 | /** |
|
230 | * Set the function value accuracy. |
|
231 | * |
|
232 | * @param accuracy the accuracy. |
|
233 | * @throws IllegalArgumentException if the accuracy can't be achieved by |
|
234 | * the solver or is otherwise deemed unreasonable. |
|
235 | */ |
|
236 | public void setFunctionValueAccuracy(double accuracy) { |
|
237 | 4 | functionValueAccuracy = accuracy; |
238 | 4 | } |
239 | ||
240 | /** |
|
241 | * Get the actual function value accuracy. |
|
242 | * @return the accuracy |
|
243 | */ |
|
244 | public double getFunctionValueAccuracy() { |
|
245 | 6 | return functionValueAccuracy; |
246 | } |
|
247 | ||
248 | /** |
|
249 | * Reset the actual function accuracy to the default. |
|
250 | */ |
|
251 | public void resetFunctionValueAccuracy() { |
|
252 | 2 | functionValueAccuracy = defaultFunctionValueAccuracy; |
253 | 2 | } |
254 | ||
255 | ||
256 | /** |
|
257 | * Returns true iff the function takes opposite signs at the endpoints. |
|
258 | * |
|
259 | * @param lower the lower endpoint |
|
260 | * @param upper the upper endpoint |
|
261 | * @param f the function |
|
262 | * @return true if f(lower) * f(upper) < 0 |
|
263 | * @throws FunctionEvaluationException if an error occurs evaluating the |
|
264 | * function at the endpoints |
|
265 | */ |
|
266 | protected boolean isBracketing(double lower, double upper, |
|
267 | UnivariateRealFunction f) throws FunctionEvaluationException { |
|
268 | 66 | double f1 = f.value(lower); |
269 | 66 | double f2 = f.value(upper); |
270 | 66 | return ((f1 > 0 && f2 < 0) || (f1 < 0 && f2 > 0)); |
271 | } |
|
272 | ||
273 | /** |
|
274 | * Returns true if the arguments form a (strictly) increasing sequence |
|
275 | * |
|
276 | * @param start first number |
|
277 | * @param mid second number |
|
278 | * @param end third number |
|
279 | * @return true if the arguments form an increasing sequence |
|
280 | */ |
|
281 | protected boolean isSequence(double start, double mid, double end) { |
|
282 | 140 | return (start < mid) && (mid < end); |
283 | } |
|
284 | ||
285 | /** |
|
286 | * Verifies that the endpoints specify an interval, |
|
287 | * throws IllegalArgumentException if not |
|
288 | * |
|
289 | * @param lower lower endpoint |
|
290 | * @param upper upper endpoint |
|
291 | * @throws IllegalArgumentException |
|
292 | */ |
|
293 | protected void verifyInterval(double lower, double upper) { |
|
294 | 414 | if (lower >= upper) { |
295 | 8 | throw new IllegalArgumentException |
296 | ("Endpoints do not specify an interval: [" + lower + |
|
297 | "," + upper + "]"); |
|
298 | } |
|
299 | 406 | } |
300 | ||
301 | /** |
|
302 | * Verifies that <code>lower < initial < upper</code> |
|
303 | * throws IllegalArgumentException if not |
|
304 | * |
|
305 | * @param lower lower endpoint |
|
306 | * @param initial initial value |
|
307 | * @param upper upper endpoint |
|
308 | * @throws IllegalArgumentException |
|
309 | */ |
|
310 | protected void verifySequence(double lower, double initial, double upper) { |
|
311 | 4 | if (!isSequence(lower, initial, upper)) { |
312 | 0 | throw new IllegalArgumentException |
313 | ("Invalid interval, initial value parameters: lower=" + |
|
314 | lower + " initial=" + initial + " upper=" + upper); |
|
315 | } |
|
316 | 4 | } |
317 | ||
318 | /** |
|
319 | * Verifies that the endpoints specify an interval and the function takes |
|
320 | * opposite signs at the enpoints, throws IllegalArgumentException if not |
|
321 | * |
|
322 | * @param lower lower endpoint |
|
323 | * @param upper upper endpoint |
|
324 | * @param f function |
|
325 | * @throws IllegalArgumentException |
|
326 | * @throws FunctionEvaluationException if an error occurs evaluating the |
|
327 | * function at the endpoints |
|
328 | */ |
|
329 | protected void verifyBracketing(double lower, double upper, |
|
330 | UnivariateRealFunction f) throws FunctionEvaluationException { |
|
331 | ||
332 | 72 | verifyInterval(lower, upper); |
333 | 66 | if (!isBracketing(lower, upper, f)) { |
334 | 6 | throw new IllegalArgumentException |
335 | ("Function values at endpoints do not have different signs." + |
|
336 | " Endpoints: [" + lower + "," + upper + "]" + |
|
337 | " Values: [" + f.value(lower) + "," + f.value(upper) + "]"); |
|
338 | } |
|
339 | 60 | } |
340 | } |