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 1023 by tim, Wed Feb 4 22:26:00 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 < //----------------------------------------------------------------------------//
3 > #include "Utility.hpp"
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 48 | Line 44 | void GoldenSectionMinimizer::minimize(){
44      if (fAlpha > fBeta){
45        leftVar = alpha;
46        alpha = beta;
47 +      
48        beta =  leftVar + goldenRatio * (rightVar - leftVar);
49  
50 <      tempX = currentX + beta * direction;
51 <
52 <      prevMinVar = minVar;
53 <      fPrevMinVar = fMinVar;
50 >      for (int i = 0; i < tempX.size(); i ++)
51 >        tempX[i] = currentX[i] + direction[i] * beta;
52 >      fAlpha = fBeta;
53 >      fBeta  = model->calcF(tempX);
54        
55 +      prevMinVar = alpha;
56 +      fPrevMinVar = fAlpha;      
57        minVar = beta;
58 <      fMinVar = model->calcF(tempX);
60 <      
58 >      fMinVar = fBeta;      
59      }
60      else{
61        rightVar = beta;
62        beta = alpha;
63 +
64        alpha = leftVar + (1 - goldenRatio) * (rightVar  - leftVar);
65  
66 <      tempX = currentX + alpha * direction;
66 >      for (int i = 0; i < tempX.size(); i ++)
67 >        tempX[i] = currentX[i] + direction[i] * alpha;
68  
69 <      prevMinVar = minVar;
70 <      fPrevMinVar = fMinVar;
71 <      
69 >      fBeta = fAlpha;
70 >      fAlpha = model->calcF(tempX);
71 >
72 >      prevMinVar = beta;
73 >      fPrevMinVar = fBeta;
74 >
75        minVar = alpha;
76 <      fMinVar = model->calcF(tempX);
76 >      fMinVar = fAlpha;      
77      }
78      
79    }
# Line 97 | Line 100 | void BrentMinimizer::minimize(){
100    double e;
101    double etemp;
102    double stepTol2;
103 <  double fLeft, fRight;
103 >  double fLeftVar, fRightVar;
104    const double goldenRatio = 0.3819660;
105    vector<double> tempX, currentX;
106    
# Line 107 | Line 110 | void BrentMinimizer::minimize(){
110  
111    currentX = tempX = model->getX();
112  
113 <  tempX = currentX + leftVar * direction;
114 <  fLeft = model->calcF(tempX);
113 >  for (int i = 0; i < tempX.size(); i ++)
114 >    tempX[i] = currentX[i] + direction[i] * leftVar;
115    
116 <  tempX = currentX + rightVar * direction;
114 <  fRight = model->calcF(tempX);
116 >  fLeftVar = model->calcF(tempX);
117  
118 <  if(fRight < fLeft) {
119 <    prevMinPoint = rightVar;
120 <    fPrevMinVar = fRight;
118 >  for (int i = 0; i < tempX.size(); i ++)
119 >    tempX[i] = currentX[i] + direction[i] * rightVar;  
120 >  
121 >  fRightVar = model->calcF(tempX);
122 >
123 >  if(fRightVar < fLeftVar) {
124 >    prevMinVar = rightVar;
125 >    fPrevMinVar = fRightVar;
126      v  = leftVar;
127      fv = fLeftVar;
128    }
129    else {
130      prevMinVar = leftVar;
131 <    fPrevMinVar = fLeft;
131 >    fPrevMinVar = fLeftVar;
132      v  = rightVar;
133 <    fv = fRight;
133 >    fv = fRightVar;
134    }
135 +
136 +  midVar = (leftVar + rightVar) / 2;
137    
138 <  for(currentIter = 0; currentIter < maxIteration; currentIter){
138 >  for(currentIter = 0; currentIter < maxIteration; currentIter++){
139  
140       // a trial parabolic fit
141       if (fabs(e) > stepTol){
# Line 144 | Line 153 | void BrentMinimizer::minimize(){
153         etemp = e;
154         e  = d;
155  
156 <       if(fabs(p) >= fabs(0.5*q*etemp)) || p <= q*(leftVar - minVar) || p >= q*(rightVar - minVar)){
156 >       if(fabs(p) >= fabs(0.5*q*etemp) || p <= q*(leftVar - minVar) || p >= q*(rightVar - minVar)){
157           e =  minVar >= midVar ? leftVar - minVar : rightVar - minVar;
158           d = goldenRatio * e;
159         }
# Line 163 | Line 172 | void BrentMinimizer::minimize(){
172  
173       u = fabs(d) >= stepTol ? minVar + d : minVar + copysign(d, stepTol);
174  
175 <     tempX = currentX + u * direction;
176 <     fu = model->calcF();  
175 >     for (int i = 0; i < tempX.size(); i ++)
176 >       tempX[i] = currentX[i] + direction[i] * u;  
177 >    
178 >     fu = model->calcF(tempX);  
179  
180       if(fu <= fMinVar){
181  
# Line 196 | Line 207 | void BrentMinimizer::minimize(){
207        }  
208      }    
209  
210 <    midVar = leftVar + rightVar;
210 >    midVar = (leftVar + rightVar) /2;
211  
212       if (checkConvergence() > 0){
213         minStatus = MINSTATUS_CONVERGE;
# Line 207 | Line 218 | void BrentMinimizer::minimize(){
218  
219  
220    minStatus = MINSTATUS_MAXITER;
221 <  return;
211 <
212 < //----------------------------------------------------------------------------//
213 <  
221 >  return;  
222   }
223  
224 < BrentMinimizer::checkConvergence(){
224 > int BrentMinimizer::checkConvergence(){
225    
226    if (fabs(minVar - midVar) <  stepTol)
227      return 1;

Diff Legend

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