1 |
|
#include "Minimizer1D.hpp" |
2 |
|
#include "math.h" |
3 |
|
|
4 |
– |
//----------------------------------------------------------------------------// |
5 |
– |
void Minimizer1D::Minimize(vector<double>& direction), double left, double right); { |
6 |
– |
setDirection(direction); |
7 |
– |
setRange(left,right); |
8 |
– |
minimize(); |
9 |
– |
} |
10 |
– |
|
11 |
– |
//----------------------------------------------------------------------------// |
4 |
|
GoldenSectionMinimizer::GoldenSectionMinimizer(NLModel* nlp) |
5 |
|
:Minimizer1D(nlp){ |
6 |
|
setName("GoldenSection"); |
9 |
|
int GoldenSectionMinimizer::checkConvergence(){ |
10 |
|
|
11 |
|
if ((rightVar - leftVar) < stepTol) |
12 |
< |
return 1 |
12 |
> |
return 1; |
13 |
|
else |
14 |
|
return -1; |
15 |
|
} |
19 |
|
|
20 |
|
const double goldenRatio = 0.618034; |
21 |
|
|
22 |
< |
currentX = model->getX(); |
22 |
> |
tempX = currentX = model->getX(); |
23 |
|
|
24 |
|
alpha = leftVar + (1 - goldenRatio) * (rightVar - leftVar); |
25 |
|
beta = leftVar + goldenRatio * (rightVar - leftVar); |
26 |
|
|
27 |
< |
tempX = currentX + direction * alpha; |
27 |
> |
for (int i = 0; i < tempX.size(); i ++) |
28 |
> |
tempX[i] = currentX[i] + direction[i] * alpha; |
29 |
> |
|
30 |
|
fAlpha = model->calcF(tempX); |
31 |
|
|
32 |
< |
tempX = currentX + direction * beta; |
32 |
> |
for (int i = 0; i < tempX.size(); i ++) |
33 |
> |
tempX[i] = currentX[i] + direction[i] * beta; |
34 |
> |
|
35 |
|
fBeta = model->calcF(tempX); |
36 |
|
|
37 |
|
for(currentIter = 0; currentIter < maxIteration; currentIter++){ |
46 |
|
alpha = beta; |
47 |
|
beta = leftVar + goldenRatio * (rightVar - leftVar); |
48 |
|
|
49 |
< |
tempX = currentX + beta * direction; |
49 |
> |
for (int i = 0; i < tempX.size(); i ++) |
50 |
> |
tempX[i] = currentX[i] + direction[i] * beta; |
51 |
|
|
52 |
|
prevMinVar = minVar; |
53 |
|
fPrevMinVar = fMinVar; |
61 |
|
beta = alpha; |
62 |
|
alpha = leftVar + (1 - goldenRatio) * (rightVar - leftVar); |
63 |
|
|
64 |
< |
tempX = currentX + alpha * direction; |
64 |
> |
for (int i = 0; i < tempX.size(); i ++) |
65 |
> |
tempX[i] = currentX[i] + direction[i] * alpha; |
66 |
|
|
67 |
|
prevMinVar = minVar; |
68 |
|
fPrevMinVar = fMinVar; |
95 |
|
double e; |
96 |
|
double etemp; |
97 |
|
double stepTol2; |
98 |
< |
double fLeft, fRight; |
98 |
> |
double fLeftVar, fRightVar; |
99 |
|
const double goldenRatio = 0.3819660; |
100 |
|
vector<double> tempX, currentX; |
101 |
|
|
105 |
|
|
106 |
|
currentX = tempX = model->getX(); |
107 |
|
|
108 |
< |
tempX = currentX + leftVar * direction; |
109 |
< |
fLeft = model->calcF(tempX); |
108 |
> |
for (int i = 0; i < tempX.size(); i ++) |
109 |
> |
tempX[i] = currentX[i] + direction[i] * leftVar; |
110 |
|
|
111 |
< |
tempX = currentX + rightVar * direction; |
114 |
< |
fRight = model->calcF(tempX); |
111 |
> |
fLeftVar = model->calcF(tempX); |
112 |
|
|
113 |
< |
if(fRight < fLeft) { |
114 |
< |
prevMinPoint = rightVar; |
115 |
< |
fPrevMinVar = fRight; |
113 |
> |
for (int i = 0; i < tempX.size(); i ++) |
114 |
> |
tempX[i] = currentX[i] + direction[i] * rightVar; |
115 |
> |
|
116 |
> |
fRightVar = model->calcF(tempX); |
117 |
> |
|
118 |
> |
if(fRightVar < fLeftVar) { |
119 |
> |
prevMinVar = rightVar; |
120 |
> |
fPrevMinVar = fRightVar; |
121 |
|
v = leftVar; |
122 |
|
fv = fLeftVar; |
123 |
|
} |
124 |
|
else { |
125 |
|
prevMinVar = leftVar; |
126 |
< |
fPrevMinVar = fLeft; |
126 |
> |
fPrevMinVar = fLeftVar; |
127 |
|
v = rightVar; |
128 |
< |
fv = fRight; |
128 |
> |
fv = fRightVar; |
129 |
|
} |
130 |
+ |
|
131 |
+ |
midVar = leftVar + rightVar; |
132 |
|
|
133 |
|
for(currentIter = 0; currentIter < maxIteration; currentIter){ |
134 |
|
|
148 |
|
etemp = e; |
149 |
|
e = d; |
150 |
|
|
151 |
< |
if(fabs(p) >= fabs(0.5*q*etemp)) || p <= q*(leftVar - minVar) || p >= q*(rightVar - minVar)){ |
151 |
> |
if(fabs(p) >= fabs(0.5*q*etemp) || p <= q*(leftVar - minVar) || p >= q*(rightVar - minVar)){ |
152 |
|
e = minVar >= midVar ? leftVar - minVar : rightVar - minVar; |
153 |
|
d = goldenRatio * e; |
154 |
|
} |
167 |
|
|
168 |
|
u = fabs(d) >= stepTol ? minVar + d : minVar + copysign(d, stepTol); |
169 |
|
|
170 |
< |
tempX = currentX + u * direction; |
170 |
> |
for (int i = 0; i < tempX.size(); i ++) |
171 |
> |
tempX[i] = currentX[i] + direction[i] * u; |
172 |
> |
|
173 |
|
fu = model->calcF(); |
174 |
|
|
175 |
|
if(fu <= fMinVar){ |
213 |
|
|
214 |
|
|
215 |
|
minStatus = MINSTATUS_MAXITER; |
216 |
< |
return; |
211 |
< |
|
212 |
< |
//----------------------------------------------------------------------------// |
213 |
< |
|
216 |
> |
return; |
217 |
|
} |
218 |
|
|
219 |
< |
BrentMinimizer::checkConvergence(){ |
219 |
> |
int BrentMinimizer::checkConvergence(){ |
220 |
|
|
221 |
|
if (fabs(minVar - midVar) < stepTol) |
222 |
|
return 1; |