OOPSE/libmdtools/NLModel.hpp

#ifndef _NLMODEL_H_
#define _NLMODEL_H_

#include <vector>
#include <utility>
#include <math.h>

#include "SymMatrix.hpp"
#include "Functor.hpp"
#include "ConstraintList.hpp"

using namespace std;


typedef enum  {backward, forward, central} FDType;

// special property of nonlinear object function
typedef enum {linear, quadratic, general} NLOFProp;

//abstract class of nonlinear optimization model
class NLModel{
  public:    
    NLModel(int dim, ConstraintList* cons) { ndim = dim, constraints = cons;}
    virtual ~NLModel() {  if (constraints != NULL) delete constraints;}

    virtual void setX(const vector<double>& x)= 0;
    virtual vector<double> getX() = 0;

    virtual void setF(double f) = 0;
    virtual double getF() = 0;

    virtual int  getDim() {return ndim;}

    bool hasConstraints() {  return constraints == NULL ? false : true;}
    int getConsType() {  return constraints->getConsType();}

    virtual double calcF()  = 0;
    virtual double calcF(vector<double>& x)  = 0;
    virtual vector<double> calcGrad()  = 0;
    virtual vector<double> calcGrad(vector<double>& x)  = 0;
    virtual SymMatrix calcHessian()  = 0;
    virtual SymMatrix calcHessian(vector<double>& x)  = 0;

#ifdef IS_MPI
    //void setMPIINITFunctor(MPIINITFunctor* func);
    //int getLocalDim() {return localDim;}
    
    //virtual void update();  //a hook function to load balancing
#endif

  protected:
    NLModel() {}
    ConstraintList* constraints;       //constraints of nonlinear optimization model
    int numOfFunEval;                  //number of function evaluation
    int ndim;

#ifdef IS_MPI
    bool mpiInitFlag;
    int myRank;                           //rank of current node
    int numOfProc;                      // number of processors
    //MPIINITFunctor * mpiInitFunc;
    
    int localDim;
    vector<int> procMappingArray; 
    int beginGlobalIndex;   
#endif
};

//abstract class of nonlinear optimization model without derivatives
class NLModel0 : public NLModel{
  public:

    NLModel0(int dim,  ConstraintList* cons) : NLModel(dim, cons) { currentX.resize(dim);}
    ~NLModel0() {}

    virtual void setX(const vector<double>& x) {currentX = x;}
    vector<double>  getX() {return currentX;}

    void setF(double f) {currentF = f;}
    double getF() {return currentF;}

    //Using finite difference methods to approximate the gradient
    //It is inappropriate to apply these methods in large scale problem
    
    vector<double> BackwardGrad(const vector<double>& x, double& fx, vector<double>& grad, const vector<double>& h);
    vector<double> ForwardGrad(const vector<double>& x, double& fx, vector<double>& grad, const vector<double>& h);
    vector<double> CentralGrad(const vector<double>& x, double& fx, vector<double>& grad, const vector<double>& h);

    //Using finite difference methods to approximate the hessian
    //It is inappropriate to apply this method in large scale problem
    //virtual SymMatrix FiniteHessian(vector<double>& x, double fx, vector<double>& h);
    SymMatrix FiniteHessian(vector<double>& x, double fx, vector<double>& h);
  protected:
    NLModel0() {}

    FDType fdType;
    vector<double> currentX;
    double currentF;
};

//concrete class of nonlinear optimization model without derivatives

class ConcreteNLModel0 : public NLModel0{

  public:

    ConcreteNLModel0(int dim, ObjFunctor0* func ,  ConstraintList* cons = NULL) : NLModel0(dim, cons){objfunc = func;}
   

    virtual double calcF();
    virtual double calcF(vector<double>& x);
    virtual vector<double> calcGrad();
    virtual vector<double> calcGrad(vector<double>& x);
    virtual SymMatrix calcHessian() ;
    virtual SymMatrix calcHessian(vector<double>& x) ; 
    
  protected:

    ObjFunctor0* objfunc;

};

//abstract class of nonlinear optimization model with first derivatives
class NLModel1 : public NLModel0{

  public:
    NLModel1(int dim,  ConstraintList* cons ) : NLModel0(dim, cons){currentGrad.resize(dim);}
    //Using finite difference methods to approximate the hessian
    //It is inappropriate to apply this method in large scale problem    
    virtual SymMatrix FiniteHessian(vector<double>& x, vector<double>& h);

    void setGrad(vector<double>& grad) {currentGrad = grad;}
    vector<double> getGrad() {return currentGrad;}
  protected:

    vector<double> currentGrad;
};

//concrete class of nonlinear optimization model with first derivatives
class ConcreteNLModel1 : public NLModel1{

  public:

    ConcreteNLModel1(int dim, ObjFunctor1* func ,  ConstraintList* cons = NULL);
    
    
    virtual double calcF();
    virtual double calcF(vector<double>& x);
    virtual vector<double> calcGrad();
    virtual vector<double> calcGrad( vector<double>& x);
    virtual SymMatrix calcHessian() ;
    virtual SymMatrix calcHessian(vector<double>& x) ; 

  protected:

    ObjFunctor1* objfunc;
};

/*
//abstract class of nonlinear optimization model with second derivatives
class NLModel2 : public NLModel1{
  public:
    
  protected:    
    SymMatrix currentHessian;

};

//concrete class of nonlinear optimization model with second derivatives
class ConcreteNLModel2 : public NLModel2{
  public:

    ConcreteNLModel2(int dim, ObjFunctor2* func ,  ConstraintList* cons = NULL);
    ConcreteNLModel2(int dim, ConstraintList* cons = NULL);
    
    virtual double calcF();
    virtual double calcF(vector<double>& x);
    virtual vector<double> calcGrad();
    virtual vector<double> calcGrad(vector<double>& x);
    virtual SymMatrix calcHessian() ;
    virtual SymMatrix calcHessian(vector<double>& x) ;
    
  protected:
    
    ObjFunctor2* objFunc;
};
*/
#endif
Revision:	1031
Committed:	Fri Feb 6 18:58:06 2004 UTC (20 years, 5 months ago) by tim
File size:	5841 byte(s)
Log Message:	Add some lines into global.cpp to make it work with energy minimization
#	User	Rev	Content
1	tim	995	#ifndef _NLMODEL_H_
2			#define _NLMODEL_H_
3
4			#include <vector>
5	tim	996	#include <utility>
6	tim	1010	#include <math.h>
7	tim	995
8			#include "SymMatrix.hpp"
9			#include "Functor.hpp"
10	tim	1010	#include "ConstraintList.hpp"
11	tim	995
12			using namespace std;
13
14	tim	996
15	tim	1010	typedef enum {backward, forward, central} FDType;
16	tim	995
17	tim	996	// special property of nonlinear object function
18	tim	1010	typedef enum {linear, quadratic, general} NLOFProp;
19	tim	995
20			//abstract class of nonlinear optimization model
21			class NLModel{
22			public:
23	tim	1023	NLModel(int dim, ConstraintList* cons) { ndim = dim, constraints = cons;}
24	tim	995	virtual ~NLModel() { if (constraints != NULL) delete constraints;}
25	tim	1000
26	tim	995	virtual void setX(const vector<double>& x)= 0;
27	tim	1015	virtual vector<double> getX() = 0;
28	tim	995
29	tim	1015	virtual void setF(double f) = 0;
30			virtual double getF() = 0;
31
32	tim	1010	virtual int getDim() {return ndim;}
33	tim	995
34			bool hasConstraints() { return constraints == NULL ? false : true;}
35	tim	1010	int getConsType() { return constraints->getConsType();}
36	tim	995
37			virtual double calcF() = 0;
38	tim	1023	virtual double calcF(vector<double>& x) = 0;
39	tim	995	virtual vector<double> calcGrad() = 0;
40			virtual vector<double> calcGrad(vector<double>& x) = 0;
41			virtual SymMatrix calcHessian() = 0;
42			virtual SymMatrix calcHessian(vector<double>& x) = 0;
43
44			#ifdef IS_MPI
45	tim	1031	//void setMPIINITFunctor(MPIINITFunctor* func);
46			//int getLocalDim() {return localDim;}
47	tim	996
48	tim	1031	//virtual void update(); //a hook function to load balancing
49	tim	995	#endif
50
51			protected:
52	tim	1023	NLModel() {}
53	tim	995	ConstraintList* constraints; //constraints of nonlinear optimization model
54			int numOfFunEval; //number of function evaluation
55	tim	1010	int ndim;
56	tim	995
57			#ifdef IS_MPI
58			bool mpiInitFlag;
59	tim	996	int myRank; //rank of current node
60			int numOfProc; // number of processors
61	tim	1031	//MPIINITFunctor * mpiInitFunc;
62	tim	996
63	tim	995	int localDim;
64	tim	996	vector<int> procMappingArray;
65			int beginGlobalIndex;
66	tim	995	#endif
67			};
68
69			//abstract class of nonlinear optimization model without derivatives
70			class NLModel0 : public NLModel{
71			public:
72
73	tim	1023	NLModel0(int dim, ConstraintList* cons) : NLModel(dim, cons) { currentX.resize(dim);}
74	tim	995	~NLModel0() {}
75
76	tim	1015	virtual void setX(const vector<double>& x) {currentX = x;}
77			vector<double> getX() {return currentX;}
78	tim	995
79	tim	1015	void setF(double f) {currentF = f;}
80			double getF() {return currentF;}
81
82	tim	995	//Using finite difference methods to approximate the gradient
83			//It is inappropriate to apply these methods in large scale problem
84
85	tim	1010	vector<double> BackwardGrad(const vector<double>& x, double& fx, vector<double>& grad, const vector<double>& h);
86			vector<double> ForwardGrad(const vector<double>& x, double& fx, vector<double>& grad, const vector<double>& h);
87			vector<double> CentralGrad(const vector<double>& x, double& fx, vector<double>& grad, const vector<double>& h);
88	tim	995
89			//Using finite difference methods to approximate the hessian
90			//It is inappropriate to apply this method in large scale problem
91	tim	1010	//virtual SymMatrix FiniteHessian(vector<double>& x, double fx, vector<double>& h);
92	tim	1015	SymMatrix FiniteHessian(vector<double>& x, double fx, vector<double>& h);
93	tim	1000	protected:
94	tim	1023	NLModel0() {}
95	tim	1000
96	tim	995	FDType fdType;
97			vector<double> currentX;
98	tim	1010	double currentF;
99	tim	995	};
100
101	tim	1000	//concrete class of nonlinear optimization model without derivatives
102
103	tim	1023	class ConcreteNLModel0 : public NLModel0{
104	tim	1000
105			public:
106
107	tim	1023	ConcreteNLModel0(int dim, ObjFunctor0* func , ConstraintList* cons = NULL) : NLModel0(dim, cons){objfunc = func;}
108
109	tim	1000
110			virtual double calcF();
111	tim	1015	virtual double calcF(vector<double>& x);
112	tim	1000	virtual vector<double> calcGrad();
113			virtual vector<double> calcGrad(vector<double>& x);
114			virtual SymMatrix calcHessian() ;
115			virtual SymMatrix calcHessian(vector<double>& x) ;
116
117			protected:
118
119			ObjFunctor0* objfunc;
120
121			};
122
123	tim	995	//abstract class of nonlinear optimization model with first derivatives
124			class NLModel1 : public NLModel0{
125	tim	1000
126	tim	995	public:
127	tim	1023	NLModel1(int dim, ConstraintList* cons ) : NLModel0(dim, cons){currentGrad.resize(dim);}
128	tim	995	//Using finite difference methods to approximate the hessian
129			//It is inappropriate to apply this method in large scale problem
130	tim	1010	virtual SymMatrix FiniteHessian(vector<double>& x, vector<double>& h);
131	tim	1015
132			void setGrad(vector<double>& grad) {currentGrad = grad;}
133			vector<double> getGrad() {return currentGrad;}
134	tim	995	protected:
135	tim	1000
136	tim	995	vector<double> currentGrad;
137			};
138
139	tim	996	//concrete class of nonlinear optimization model with first derivatives
140	tim	1023	class ConcreteNLModel1 : public NLModel1{
141	tim	1000
142	tim	995	public:
143	tim	1000
144	tim	1023	ConcreteNLModel1(int dim, ObjFunctor1* func , ConstraintList* cons = NULL);
145	tim	995
146	tim	1023
147	tim	995	virtual double calcF();
148	tim	1015	virtual double calcF(vector<double>& x);
149	tim	995	virtual vector<double> calcGrad();
150	tim	1015	virtual vector<double> calcGrad( vector<double>& x);
151	tim	995	virtual SymMatrix calcHessian() ;
152			virtual SymMatrix calcHessian(vector<double>& x) ;
153
154			protected:
155	tim	1000
156	tim	995	ObjFunctor1* objfunc;
157			};
158
159			/*
160	tim	1000	//abstract class of nonlinear optimization model with second derivatives
161	tim	995	class NLModel2 : public NLModel1{
162			public:
163	tim	1000
164			protected:
165			SymMatrix currentHessian;
166	tim	995
167	tim	1000	};
168
169			//concrete class of nonlinear optimization model with second derivatives
170			class ConcreteNLModel2 : public NLModel2{
171			public:
172
173			ConcreteNLModel2(int dim, ObjFunctor2* func , ConstraintList* cons = NULL);
174			ConcreteNLModel2(int dim, ConstraintList* cons = NULL);
175	tim	995
176			virtual double calcF();
177	tim	1015	virtual double calcF(vector<double>& x);
178	tim	995	virtual vector<double> calcGrad();
179			virtual vector<double> calcGrad(vector<double>& x);
180			virtual SymMatrix calcHessian() ;
181			virtual SymMatrix calcHessian(vector<double>& x) ;
182
183			protected:
184
185			ObjFunctor2* objFunc;
186			};
187			*/
188			#endif