1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 package org.apache.commons.math.analysis.solvers;
19
20 import org.apache.commons.math.ConvergingAlgorithmImpl;
21 import org.apache.commons.math.FunctionEvaluationException;
22 import org.apache.commons.math.MathRuntimeException;
23 import org.apache.commons.math.analysis.UnivariateRealFunction;
24
25
26
27
28
29
30
31 public abstract class UnivariateRealSolverImpl
32 extends ConvergingAlgorithmImpl implements UnivariateRealSolver {
33
34
35 protected double functionValueAccuracy;
36
37
38 protected double defaultFunctionValueAccuracy;
39
40
41 protected boolean resultComputed = false;
42
43
44 protected double result;
45
46
47 protected double functionValue;
48
49
50
51
52
53
54 @Deprecated
55 protected UnivariateRealFunction f;
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70 @Deprecated
71 protected UnivariateRealSolverImpl(final UnivariateRealFunction f,
72 final int defaultMaximalIterationCount,
73 final double defaultAbsoluteAccuracy) {
74 super(defaultMaximalIterationCount, defaultAbsoluteAccuracy);
75 if (f == null) {
76 throw MathRuntimeException.createIllegalArgumentException("function to solve cannot be null");
77 }
78 this.f = f;
79 this.defaultFunctionValueAccuracy = 1.0e-15;
80 this.functionValueAccuracy = defaultFunctionValueAccuracy;
81 }
82
83
84
85
86
87
88
89
90
91 protected UnivariateRealSolverImpl(final int defaultMaximalIterationCount,
92 final double defaultAbsoluteAccuracy) {
93 super(defaultMaximalIterationCount, defaultAbsoluteAccuracy);
94 this.defaultFunctionValueAccuracy = 1.0e-15;
95 this.functionValueAccuracy = defaultFunctionValueAccuracy;
96 }
97
98
99
100
101 protected void checkResultComputed() throws IllegalStateException {
102 if (!resultComputed) {
103 throw MathRuntimeException.createIllegalStateException("no result available");
104 }
105 }
106
107
108 public double getResult() {
109 checkResultComputed();
110 return result;
111 }
112
113
114 public double getFunctionValue() {
115 checkResultComputed();
116 return functionValue;
117 }
118
119
120 public void setFunctionValueAccuracy(final double accuracy) {
121 functionValueAccuracy = accuracy;
122 }
123
124
125 public double getFunctionValueAccuracy() {
126 return functionValueAccuracy;
127 }
128
129
130 public void resetFunctionValueAccuracy() {
131 functionValueAccuracy = defaultFunctionValueAccuracy;
132 }
133
134
135
136
137
138
139
140 protected final void setResult(final double result, final int iterationCount) {
141 this.result = result;
142 this.iterationCount = iterationCount;
143 this.resultComputed = true;
144 }
145
146
147
148
149
150
151
152
153 protected final void setResult(final double x, final double fx,
154 final int iterationCount) {
155 this.result = x;
156 this.functionValue = fx;
157 this.iterationCount = iterationCount;
158 this.resultComputed = true;
159 }
160
161
162
163
164 protected final void clearResult() {
165 this.iterationCount = 0;
166 this.resultComputed = false;
167 }
168
169
170
171
172
173
174
175
176
177
178
179 protected boolean isBracketing(final double lower, final double upper,
180 final UnivariateRealFunction f)
181 throws FunctionEvaluationException {
182 final double f1 = f.value(lower);
183 final double f2 = f.value(upper);
184 return ((f1 > 0 && f2 < 0) || (f1 < 0 && f2 > 0));
185 }
186
187
188
189
190
191
192
193
194
195 protected boolean isSequence(final double start, final double mid, final double end) {
196 return (start < mid) && (mid < end);
197 }
198
199
200
201
202
203
204
205
206
207 protected void verifyInterval(final double lower, final double upper) {
208 if (lower >= upper) {
209 throw MathRuntimeException.createIllegalArgumentException(
210 "endpoints do not specify an interval: [{0}, {1}]",
211 lower, upper);
212 }
213 }
214
215
216
217
218
219
220
221
222
223
224 protected void verifySequence(final double lower, final double initial, final double upper) {
225 if (!isSequence(lower, initial, upper)) {
226 throw MathRuntimeException.createIllegalArgumentException(
227 "invalid interval, initial value parameters: lower={0}, initial={1}, upper={2}",
228 lower, initial, upper);
229 }
230 }
231
232
233
234
235
236
237
238
239
240
241
242
243 protected void verifyBracketing(final double lower, final double upper,
244 final UnivariateRealFunction f)
245 throws FunctionEvaluationException {
246
247 verifyInterval(lower, upper);
248 if (!isBracketing(lower, upper, f)) {
249 throw MathRuntimeException.createIllegalArgumentException(
250 "function values at endpoints do not have different signs. " +
251 "Endpoints: [{0}, {1}], Values: [{2}, {3}]",
252 lower, upper, f.value(lower), f.value(upper));
253 }
254 }
255 }