OOPSE/libmdtools/NLModel.hpp

#ifndef _NLMODEL_H_
#define _NLMODEL_H_

#include <vector>
#include <utility>

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

using namespace std;


typedef enum FDType {backward, forward, central} ;

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

//abstract class of nonlinear optimization model
class NLModel{
  public:    
    NLModel(ConstraintList* cons) {constraints = cons;}
    virtual ~NLModel() {  if (constraints != NULL) delete constraints;}
    virtual void setX(const vector<double>& x)= 0;

    virtual void setF(const vector<double>& fx)= 0;

    virtual int  getDim() const = 0;

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

    virtual double calcF()  = 0;
    virtual double calcF(const 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:
    ConstraintList* constraints;       //constraints of nonlinear optimization model
    int numOfFunEval;                  //number of function evaluation

#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 = NULL);
    ~NLModel0() {}

  protected:

    //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);
    vector<double> ForwardGrad(const vector<double>& x, double& fx, vector<double>& grad);
    vector<double> CentralGrad(const vector<double>& x, double& fx, vector<double>& grad);

    //Using finite difference methods to approximate the hessian
    //It is inappropriate to apply this method in large scale problem
    virtual SymMatrix FiniteHessian(vector<double>& sx);

    FDType fdType;
    vector<double> currentX;
};

//abstract class of nonlinear optimization model with first derivatives
class NLModel1 : public NLModel0{
  public:
    
    //Using finite difference methods to approximate the hessian
    //It is inappropriate to apply this method in large scale problem    
    virtual SymMatrix ForwardHessian(vector<double>& sx);
    
  protected:
    vector<double> currentGrad;
};

//concrete class of nonlinear optimization model with first derivatives
class ConcreteNLMode1 : NLModel1{
  public:
    ConcreteNLMode1(int dim, ObjFunctor1* func ,  ConstraintList* cons = NULL);
    ConcreteNLMode1(int dim, ConstraintList* cons = NULL);
    
    virtual double calcF();
    virtual double calcF(const 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;
};


/*
class NLModel2 : public NLModel1{
  public:

    NLModel2(int dim, ObjFunctor2* func ,  ConstraintList* cons = NULL);
    ~NLModel2() {}  
    
    virtual double calcF();
    virtual double calcF(const vector<double>& x);
    virtual vector<double> calcGrad();
    virtual vector<double> calcGrad(vector<double>& x);
    virtual SymMatrix calcHessian() ;
    virtual SymMatrix calcHessian(vector<double>& x) ;
    
  protected:
    
    SymMatrix hessian;
    ObjFunctor2* objFunc;
};
*/
#endif
Revision:	996
Committed:	Wed Jan 28 22:44:44 2004 UTC (20 years, 5 months ago) by tim
File size:	4175 byte(s)
Log Message:	Revision of NLModel0 and NLModel1
#	User	Rev	Content
1	tim	995	#ifndef _NLMODEL_H_
2			#define _NLMODEL_H_
3
4			#include <vector>
5	tim	996	#include <utility>
6	tim	995
7			#include "SymMatrix.hpp"
8			#include "Functor.hpp"
9
10			using namespace std;
11
12	tim	996
13	tim	995	typedef enum FDType {backward, forward, central} ;
14
15	tim	996	// special property of nonlinear object function
16			typedef enum NLOFProp{linear, quadratic, general};
17	tim	995
18			//abstract class of nonlinear optimization model
19			class NLModel{
20			public:
21			NLModel(ConstraintList* cons) {constraints = cons;}
22			virtual ~NLModel() { if (constraints != NULL) delete constraints;}
23			virtual void setX(const vector<double>& x)= 0;
24
25			virtual void setF(const vector<double>& fx)= 0;
26
27			virtual int getDim() const = 0;
28
29			bool hasConstraints() { return constraints == NULL ? false : true;}
30			int getConsType() { return constrains->getConsType();}
31
32			virtual double calcF() = 0;
33			virtual double calcF(const vector<double>& x) = 0;
34			virtual vector<double> calcGrad() = 0;
35			virtual vector<double> calcGrad(vector<double>& x) = 0;
36			virtual SymMatrix calcHessian() = 0;
37			virtual SymMatrix calcHessian(vector<double>& x) = 0;
38
39			#ifdef IS_MPI
40			void setMPIINITFunctor(MPIINITFunctor* func);
41	tim	996	int getLocalDim() {return localDim;}
42
43			virtual void update(); //a hook function to load balancing
44	tim	995	#endif
45
46			protected:
47			ConstraintList* constraints; //constraints of nonlinear optimization model
48			int numOfFunEval; //number of function evaluation
49
50			#ifdef IS_MPI
51			bool mpiInitFlag;
52	tim	996	int myRank; //rank of current node
53			int numOfProc; // number of processors
54	tim	995	MPIINITFunctor * mpiInitFunc;
55	tim	996
56	tim	995	int localDim;
57	tim	996	vector<int> procMappingArray;
58			int beginGlobalIndex;
59	tim	995	#endif
60			};
61
62			//abstract class of nonlinear optimization model without derivatives
63			class NLModel0 : public NLModel{
64			public:
65
66			NLModel0(int dim, ConstraintList* cons = NULL);
67			~NLModel0() {}
68
69			protected:
70
71			//Using finite difference methods to approximate the gradient
72			//It is inappropriate to apply these methods in large scale problem
73
74			vector<double> BackwardGrad(const vector<double>& x, double& fx, vector<double>& grad);
75			vector<double> ForwardGrad(const vector<double>& x, double& fx, vector<double>& grad);
76			vector<double> CentralGrad(const vector<double>& x, double& fx, vector<double>& grad);
77
78			//Using finite difference methods to approximate the hessian
79			//It is inappropriate to apply this method in large scale problem
80	tim	996	virtual SymMatrix FiniteHessian(vector<double>& sx);
81	tim	995
82			FDType fdType;
83			vector<double> currentX;
84			};
85
86			//abstract class of nonlinear optimization model with first derivatives
87			class NLModel1 : public NLModel0{
88			public:
89
90			//Using finite difference methods to approximate the hessian
91			//It is inappropriate to apply this method in large scale problem
92	tim	996	virtual SymMatrix ForwardHessian(vector<double>& sx);
93	tim	995
94			protected:
95			vector<double> currentGrad;
96			};
97
98	tim	996	//concrete class of nonlinear optimization model with first derivatives
99			class ConcreteNLMode1 : NLModel1{
100	tim	995	public:
101	tim	996	ConcreteNLMode1(int dim, ObjFunctor1* func , ConstraintList* cons = NULL);
102			ConcreteNLMode1(int dim, ConstraintList* cons = NULL);
103	tim	995
104			virtual double calcF();
105			virtual double calcF(const vector<double>& x);
106			virtual vector<double> calcGrad();
107			virtual vector<double> calcGrad(vector<double>& x);
108			virtual SymMatrix calcHessian() ;
109			virtual SymMatrix calcHessian(vector<double>& x) ;
110
111			protected:
112			ObjFunctor1* objfunc;
113			};
114
115
116			/*
117			class NLModel2 : public NLModel1{
118			public:
119
120			NLModel2(int dim, ObjFunctor2* func , ConstraintList* cons = NULL);
121			~NLModel2() {}
122
123			virtual double calcF();
124			virtual double calcF(const vector<double>& x);
125			virtual vector<double> calcGrad();
126			virtual vector<double> calcGrad(vector<double>& x);
127			virtual SymMatrix calcHessian() ;
128			virtual SymMatrix calcHessian(vector<double>& x) ;
129
130			protected:
131
132			SymMatrix hessian;
133			ObjFunctor2* objFunc;
134			};
135			*/
136			#endif