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;
}; 

#endif
Revision:	1023
Committed:	Wed Feb 4 22:26:00 2004 UTC (20 years, 5 months ago) by tim
File size:	2464 byte(s)
Log Message:	Fix a bunch of bugs :-) Single version of conjugate gradient with golden search linesearch pass a couple of functions test. Brent's algorithm is still broken
#	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			#endif