OOPSE/libmdtools/Functor.hpp

#ifndef _FUNCTOR_H_
#define _FUNCTOR_H_

#include <vector>

using namespace std;

class ObjFunctor0{
  public:

    virtual ~ObjFunctor0() {}
    virtual double operator()(vector<double>&)=0;  
    
};

class PtrFunctor0 : public ObjFunctor0{

  public:

    PtrFunctor0(double (*thePtrFunc)(vector<double>&)){
      ptrFunc = thePtrFunc;
    }
    
    virtual double operator()(vector<double>& arg){
       return (*ptrFunc)(arg);
    };
    
  protected:
    double (*ptrFunc)(vector<double>&);
};


//ClassMemObjFunctor class wraps a pointer pointing to a member function of a class
//
template<typename TClass>
class ClassMemObjFunctor0 : public ObjFunctor0{
  public:
    ClassMemObjFunctor0(TClass* thePtrClass, double (TClass::*thePtrFunc)(vector<double>&)){
      ptrClass = thePtrClass;
      ptrFunc = thePtrFunc;
    }
    
    double operator()(vector<double>& arg){
      return (*ptrClass.*ptrFunc)(arg);
    }
  protected:
    
    double (TClass::*ptrFunc)(vector<double>&);   
    TClass* ptrClass;
}; 

/**
 * Abstract class of object function which have an overloaded method
 * to calculate the gradient 
 */
 
class ObjFunctor1{

  public:
    virtual ~ObjFunctor1() {}
    virtual double operator()(vector<double>&, vector<double>&)=0;  
    
};

//PtrFunctor class wraps a pointer which points to an objct function. 
// PtrFunctor can be invoked by
// functor(vector<double>&, vector<double>&)
class PtrFunctor1 : public ObjFunctor1{

  public:

    PtrFunctor1(double (*thePtrFunc)(vector<double>&, vector<double>&)){
      ptrFunc = thePtrFunc;
    }
 
    virtual double operator()(vector<double>& arg, vector<double>& grad){
       return (*ptrFunc)(arg, grad);
    };
    
  protected:
    double (*ptrFunc)(vector<double>&, vector<double>&);
};

//ClassMemObjFunctor class wraps a pointer pointing to a member function of a class
//
template<typename TClass>
class ClassMemObjFunctor1 : public ObjFunctor1{
  public:
    ClassMemObjFunctor1(TClass* thePtrClass, double (TClass::*thePtrFunc)(vector<double>&, vector<double>&)){
      ptrClass = thePtrClass;
      ptrFunc = thePtrFunc;
    }
    
    double operator()(vector<double>&arg, vector<double>&grad){
      return (*ptrClass.*ptrFunc)(arg, grad);
    }
  protected:
    
    double (TClass::*ptrFunc)(vector<double>&, vector<double>&);   
    TClass* ptrClass;
}; 


class OutputFunctor{
  public:

    virtual ~OutputFunctor() {}
    virtual void operator()(vector<double>&, int)=0;  
    
};

class PtrOutputFunctor : public OutputFunctor{

  public:

    PtrOutputFunctor(void (*thePtrFunc)(vector<double>&, int)){
      ptrFunc = thePtrFunc;
    }
    
    virtual void operator()(vector<double>& arg1, int arg2){
       return (*ptrFunc)(arg1, arg2);
    };
    
  protected:
    void (*ptrFunc)(vector<double>&, int);
};


//ClassMemObjFunctor class wraps a pointer pointing to a member function of a class
//
template<typename TClass>
class ClassMemOutputFunctor : public OutputFunctor{
  public:
    ClassMemOutputFunctor(TClass* thePtrClass, void (TClass::*thePtrFunc)(vector<double>&, int)){
      ptrClass = thePtrClass;
      ptrFunc = thePtrFunc;
    }
    
    void operator()(vector<double>& arg1, int arg2){
      return (*ptrClass.*ptrFunc)(arg1, arg2);
    }
  protected:
    
    void (TClass::*ptrFunc)(vector<double>&, int);   
    TClass* ptrClass;
}; 
#endif
Revision:	1031
Committed:	Fri Feb 6 18:58:06 2004 UTC (20 years, 5 months ago) by tim
File size:	3517 byte(s)
Log Message:	Add some lines into global.cpp to make it work with energy minimization
#	User	Rev	Content
1	tim	962	#ifndef _FUNCTOR_H_
2	tim	939	#define _FUNCTOR_H_
3
4	tim	1007	#include <vector>
5
6			using namespace std;
7
8			class ObjFunctor0{
9			public:
10	tim	1023
11			virtual ~ObjFunctor0() {}
12	tim	1007	virtual double operator()(vector<double>&)=0;
13	tim	1023
14	tim	1007	};
15
16	tim	1023	class PtrFunctor0 : public ObjFunctor0{
17	tim	1007
18			public:
19
20			PtrFunctor0(double (*thePtrFunc)(vector<double>&)){
21			ptrFunc = thePtrFunc;
22			}
23
24			virtual double operator()(vector<double>& arg){
25			return (*ptrFunc)(arg);
26			};
27
28			protected:
29			double (*ptrFunc)(vector<double>&);
30			};
31
32
33			//ClassMemObjFunctor class wraps a pointer pointing to a member function of a class
34			//
35			template<typename TClass>
36			class ClassMemObjFunctor0 : public ObjFunctor0{
37			public:
38			ClassMemObjFunctor0(TClass* thePtrClass, double (TClass::*thePtrFunc)(vector<double>&)){
39			ptrClass = thePtrClass;
40			ptrFunc = thePtrFunc;
41			}
42
43			double operator()(vector<double>& arg){
44			return (ptrClass.ptrFunc)(arg);
45			}
46			protected:
47
48			double (TClass::*ptrFunc)(vector<double>&);
49			TClass* ptrClass;
50			};
51
52	tim	939	/**
53			* Abstract class of object function which have an overloaded method
54			* to calculate the gradient
55			*/
56
57	tim	987	class ObjFunctor1{
58	tim	939
59			public:
60	tim	1023	virtual ~ObjFunctor1() {}
61	tim	939	virtual double operator()(vector<double>&, vector<double>&)=0;
62
63			};
64
65			//PtrFunctor class wraps a pointer which points to an objct function.
66			// PtrFunctor can be invoked by
67			// functor(vector<double>&, vector<double>&)
68	tim	1023	class PtrFunctor1 : public ObjFunctor1{
69	tim	939
70			public:
71
72	tim	987	PtrFunctor1(double (*thePtrFunc)(vector<double>&, vector<double>&)){
73	tim	939	ptrFunc = thePtrFunc;
74			}
75	tim	1023
76	tim	939	virtual double operator()(vector<double>& arg, vector<double>& grad){
77			return (*ptrFunc)(arg, grad);
78			};
79
80			protected:
81			double (*ptrFunc)(vector<double>&, vector<double>&);
82			};
83
84			//ClassMemObjFunctor class wraps a pointer pointing to a member function of a class
85			//
86			template<typename TClass>
87	tim	987	class ClassMemObjFunctor1 : public ObjFunctor1{
88	tim	939	public:
89	tim	987	ClassMemObjFunctor1(TClass* thePtrClass, double (TClass::*thePtrFunc)(vector<double>&, vector<double>&)){
90	tim	939	ptrClass = thePtrClass;
91			ptrFunc = thePtrFunc;
92			}
93
94	tim	1007	double operator()(vector<double>&arg, vector<double>&grad){
95			return (ptrClass.ptrFunc)(arg, grad);
96	tim	939	}
97			protected:
98
99			double (TClass::*ptrFunc)(vector<double>&, vector<double>&);
100			TClass* ptrClass;
101			};
102
103	tim	1031
104			class OutputFunctor{
105			public:
106
107			virtual ~OutputFunctor() {}
108			virtual void operator()(vector<double>&, int)=0;
109
110			};
111
112			class PtrOutputFunctor : public OutputFunctor{
113
114			public:
115
116			PtrOutputFunctor(void (*thePtrFunc)(vector<double>&, int)){
117			ptrFunc = thePtrFunc;
118			}
119
120			virtual void operator()(vector<double>& arg1, int arg2){
121			return (*ptrFunc)(arg1, arg2);
122			};
123
124			protected:
125			void (*ptrFunc)(vector<double>&, int);
126			};
127
128
129			//ClassMemObjFunctor class wraps a pointer pointing to a member function of a class
130			//
131			template<typename TClass>
132			class ClassMemOutputFunctor : public OutputFunctor{
133			public:
134			ClassMemOutputFunctor(TClass* thePtrClass, void (TClass::*thePtrFunc)(vector<double>&, int)){
135			ptrClass = thePtrClass;
136			ptrFunc = thePtrFunc;
137			}
138
139			void operator()(vector<double>& arg1, int arg2){
140			return (ptrClass.ptrFunc)(arg1, arg2);
141			}
142			protected:
143
144			void (TClass::*ptrFunc)(vector<double>&, int);
145			TClass* ptrClass;
146			};
147	tim	939	#endif