OOPSE/libmdtools/Minimizer1D.hpp

#ifndef _MINIMIZER1D_H_
#define _MINIMIZER1D_H_

#include "MinimizerBase.hpp"

//abstract class of one dimension minimizer for line searching 
// optimize f(x+val*direction)
//some potential problem, such as which class is responsible for deleting NLModel,
//can be resolved by using smart pointer
class Minimizer1D : public MinimizerBase{

  public:
    Minimizer1D(NLModel* nlp) {model = nlp;}
    virtual ~Minimizer1D() {}

    virtual void init() {}
  virtual bool isSolvable() {return true;}

    virtual void minimize() = 0;
    virtual void minimize(vector<double>& direction, double left, double right) = 0;

    void setRange(double left, double right) {leftVar = left, rightVar= right;}
    void setDirection(vector<double>& direction) {this->direction = direction;}
    double getMinVar() {return minVar;}
    double getPrevMinVar() {return prevMinVar;}

    void setMaxIteration(int iter) {maxIteration = iter;}

    int getMaxIteration() {return maxIteration;}
    int getCurrentIteration() {return currentIter;}

    void setStepTol(double tol) {stepTol =tol;}
    double getStepTol() {return stepTol;}
  protected:

    NLModel* model;
    double leftVar; 
    double rightVar; 
    double minVar; 
    double prevMinVar;
     
    vector<double> direction;

    int maxIteration;
    int currentIter;
    double stepTol;
};

class GoldenSectionMinimizer : public Minimizer1D{

  public:

    GoldenSectionMinimizer(NLModel* nlp);
    void minimize();
    virtual void minimize(vector<double>& direction, double left, double right){
      setRange(left, right);
      setDirection(direction);
      minimize();
    }    
    virtual int checkConvergence();
    
  protected:

    double fMinVar;
    double fPrevMinVar; 
    
    double fAlpha;
    double fBeta;
    double alpha;
    double beta;
    
};

class BrentMinimizer : public Minimizer1D{
  public:
    
    BrentMinimizer(NLModel* nlp);

    void minimize();
    virtual void minimize(vector<double>& direction, double left, double right);
    virtual int checkConvergence();

  protected:

    void bracket(double& cx, double& fc, double& ax, double& fa, double& bx, double& fb);
    double fMinVar;
    double fPrevMinVar;
    double midVar;
    
};
#endif
Revision:	1031
Committed:	Fri Feb 6 18:58:06 2004 UTC (20 years, 7 months ago) by tim
File size:	2327 byte(s)
Log Message:	Add some lines into global.cpp to make it work with energy minimization
#	User	Rev	Content
1	tim	1002	#ifndef _MINIMIZER1D_H_
2			#define _MINIMIZER1D_H_
3
4			#include "MinimizerBase.hpp"
5
6			//abstract class of one dimension minimizer for line searching
7			// optimize f(x+val*direction)
8			//some potential problem, such as which class is responsible for deleting NLModel,
9			//can be resolved by using smart pointer
10			class Minimizer1D : public MinimizerBase{
11
12			public:
13			Minimizer1D(NLModel* nlp) {model = nlp;}
14			virtual ~Minimizer1D() {}
15
16			virtual void init() {}
17	tim	1023	virtual bool isSolvable() {return true;}
18
19	tim	1015	virtual void minimize() = 0;
20	tim	1023	virtual void minimize(vector<double>& direction, double left, double right) = 0;
21	tim	1002
22	tim	1010	void setRange(double left, double right) {leftVar = left, rightVar= right;}
23	tim	1002	void setDirection(vector<double>& direction) {this->direction = direction;}
24			double getMinVar() {return minVar;}
25			double getPrevMinVar() {return prevMinVar;}
26
27			void setMaxIteration(int iter) {maxIteration = iter;}
28
29			int getMaxIteration() {return maxIteration;}
30			int getCurrentIteration() {return currentIter;}
31
32			void setStepTol(double tol) {stepTol =tol;}
33			double getStepTol() {return stepTol;}
34			protected:
35
36			NLModel* model;
37			double leftVar;
38			double rightVar;
39			double minVar;
40	tim	1023	double prevMinVar;
41	tim	1005
42	tim	1002	vector<double> direction;
43
44			int maxIteration;
45			int currentIter;
46	tim	1023	double stepTol;
47	tim	1002	};
48
49			class GoldenSectionMinimizer : public Minimizer1D{
50
51			public:
52
53	tim	1005	GoldenSectionMinimizer(NLModel* nlp);
54	tim	1010	void minimize();
55	tim	1023	virtual void minimize(vector<double>& direction, double left, double right){
56			setRange(left, right);
57			setDirection(direction);
58			minimize();
59			}
60	tim	1005	virtual int checkConvergence();
61
62			protected:
63	tim	1002
64	tim	1005	double fMinVar;
65			double fPrevMinVar;
66	tim	1002
67			double fAlpha;
68			double fBeta;
69			double alpha;
70			double beta;
71
72			};
73
74			class BrentMinimizer : public Minimizer1D{
75			public:
76	tim	1005
77	tim	1002	BrentMinimizer(NLModel* nlp);
78	tim	1005
79	tim	1002	void minimize();
80	tim	1031	virtual void minimize(vector<double>& direction, double left, double right);
81	tim	1005	virtual int checkConvergence();
82	tim	1031
83	tim	1002	protected:
84	tim	1005
85	tim	1031	void bracket(double& cx, double& fc, double& ax, double& fa, double& bx, double& fb);
86	tim	1005	double fMinVar;
87			double fPrevMinVar;
88			double midVar;
89	tim	1002
90			};
91			#endif