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
#	Content
1	#ifndef _FUNCTOR_H_
2	#define _FUNCTOR_H_
3
4	#include <vector>
5
6	using namespace std;
7
8	class ObjFunctor0{
9	public:
10
11	virtual ~ObjFunctor0() {}
12	virtual double operator()(vector<double>&)=0;
13
14	};
15
16	class PtrFunctor0 : public ObjFunctor0{
17
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	/**
53	* Abstract class of object function which have an overloaded method
54	* to calculate the gradient
55	*/
56
57	class ObjFunctor1{
58
59	public:
60	virtual ~ObjFunctor1() {}
61	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	class PtrFunctor1 : public ObjFunctor1{
69
70	public:
71
72	PtrFunctor1(double (*thePtrFunc)(vector<double>&, vector<double>&)){
73	ptrFunc = thePtrFunc;
74	}
75
76	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	class ClassMemObjFunctor1 : public ObjFunctor1{
88	public:
89	ClassMemObjFunctor1(TClass* thePtrClass, double (TClass::*thePtrFunc)(vector<double>&, vector<double>&)){
90	ptrClass = thePtrClass;
91	ptrFunc = thePtrFunc;
92	}
93
94	double operator()(vector<double>&arg, vector<double>&grad){
95	return (ptrClass.ptrFunc)(arg, grad);
96	}
97	protected:
98
99	double (TClass::*ptrFunc)(vector<double>&, vector<double>&);
100	TClass* ptrClass;
101	};
102
103
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	#endif