ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libmdtools/Functor.hpp
(Generate patch)

Comparing trunk/OOPSE/libmdtools/Functor.hpp (file contents):
Revision 962 by tim, Mon Jan 19 18:36:21 2004 UTC vs.
Revision 1031 by tim, Fri Feb 6 18:58:06 2004 UTC

# Line 1 | Line 1
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 ObjFunctor{
57 > class ObjFunctor1{
58  
59    public:
60 +    virtual ~ObjFunctor1() {}
61      virtual double operator()(vector<double>&, vector<double>&)=0;  
62      
63   };
64  
16 –
17 –
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 PtrFunctor : ObjFunctor{
68 > class PtrFunctor1 : public ObjFunctor1{
69  
70    public:
71  
72 <    PtrFunctor(double (*thePtrFunc)(vector<double>&, vector<double>&)){
72 >    PtrFunctor1(double (*thePtrFunc)(vector<double>&, vector<double>&)){
73        ptrFunc = thePtrFunc;
74      }
75 <    
75 >
76      virtual double operator()(vector<double>& arg, vector<double>& grad){
77         return (*ptrFunc)(arg, grad);
78      };
# Line 37 | Line 84 | class ClassMemObjFunctor : public ObjFunctor{
84   //ClassMemObjFunctor class wraps a pointer pointing to a member function of a class
85   //
86   template<typename TClass>
87 < class ClassMemObjFunctor : public ObjFunctor{
87 > class ClassMemObjFunctor1 : public ObjFunctor1{
88    public:
89 <    ClassMemObjFunctor(TClass* thePtrClass, double (TClass::*thePtrFunc)(vector<double>&, vector<double>&)){
89 >    ClassMemObjFunctor1(TClass* thePtrClass, double (TClass::*thePtrFunc)(vector<double>&, vector<double>&)){
90        ptrClass = thePtrClass;
91        ptrFunc = thePtrFunc;
92      }
93      
94 <    double operator()(vector<double>&, vector<double>&){
95 <      return (*ptrClass.*ptrFunc))(arg, grad);
94 >    double operator()(vector<double>&arg, vector<double>&grad){
95 >      return (*ptrClass.*ptrFunc)(arg, grad);
96      }
97    protected:
98      
# Line 53 | Line 100 | class ClassMemObjFunctor : public ObjFunctor{
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

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines