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 (21 years, 2 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
#	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	#endif