ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libmdtools/Minimizer1D.cpp
(Generate patch)

Comparing trunk/OOPSE/libmdtools/Minimizer1D.cpp (file contents):
Revision 1005 by tim, Tue Feb 3 15:21:32 2004 UTC vs.
Revision 1015 by tim, Tue Feb 3 22:54:52 2004 UTC

# Line 1 | Line 1
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");
# Line 17 | Line 9 | int GoldenSectionMinimizer::checkConvergence(){
9   int GoldenSectionMinimizer::checkConvergence(){
10  
11    if ((rightVar - leftVar) < stepTol)
12 <    return 1
12 >    return 1;
13    else
14      return -1;
15   }
# Line 27 | Line 19 | void GoldenSectionMinimizer::minimize(){
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++){
# Line 50 | Line 46 | void GoldenSectionMinimizer::minimize(){
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;
# Line 64 | Line 61 | void GoldenSectionMinimizer::minimize(){
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;
# Line 97 | Line 95 | void BrentMinimizer::minimize(){
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    
# Line 107 | Line 105 | void BrentMinimizer::minimize(){
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  
# Line 144 | Line 148 | void BrentMinimizer::minimize(){
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         }
# Line 163 | Line 167 | void BrentMinimizer::minimize(){
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){
# Line 207 | Line 213 | void BrentMinimizer::minimize(){
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;

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines