Logo ROOT  
Reference Guide
WrappedFunction.h
Go to the documentation of this file.
1// @(#)root/mathcore:$Id$
2// Authors: L. Moneta, A. Zsenei 08/2005
3
4 /**********************************************************************
5 * *
6 * Copyright (c) 2004 ROOT Foundation, CERN/PH-SFT *
7 * *
8 * This library is free software; you can redistribute it and/or *
9 * modify it under the terms of the GNU General Public License *
10 * as published by the Free Software Foundation; either version 2 *
11 * of the License, or (at your option) any later version. *
12 * *
13 * This library is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
16 * General Public License for more details. *
17 * *
18 * You should have received a copy of the GNU General Public License *
19 * along with this library (see file COPYING); if not, write *
20 * to the Free Software Foundation, Inc., 59 Temple Place, Suite *
21 * 330, Boston, MA 02111-1307 USA, or contact the author. *
22 * *
23 **********************************************************************/
24
25#ifndef ROOT_Math_WrappedFunction
26#define ROOT_Math_WrappedFunction
27
28#include "IFunction.h"
29
30
31namespace ROOT {
32namespace Math {
33
34
35
36
38
40
41typedef double(*FreeMultiFunctionPtr)(const double*);
42
43/**
44 Template class to wrap any C++ callable object which takes one argument
45 i.e. implementing operator() (double x) in a One-dimensional function interface.
46 It provides a ROOT::Math::IGenFunction-like signature
47
48 Note: If you want to wrap just the reference (to avoid copying) you need to use
49 Func& or const Func & as template parameter. The former should be used when the
50 operator() is not a const method of Func
51
52 @ingroup GenFunc
53
54 */
55template< typename Func = FreeFunctionPtr >
57
58
59 public:
60
61 /**
62 construct from the pointer to the object and the member function
63 */
65 fFunc( f )
66 { /* no op */ }
67
68 // use default copy contructor and assignment operator
69
70 /// clone (required by the interface)
72 return new WrappedFunction(fFunc);
73 }
74
75 // virtual ~WrappedFunction() { /**/ }
76
77private:
78
79 virtual double DoEval (double x) const {
80 return fFunc( x );
81 }
82
83
84 Func fFunc;
85
86
87}; // WrappedFunction
88
89
90/**
91 Template class to wrap any member function of a class
92 taking a double and returning a double in a 1D function interface
93 For example, if you have a class like:
94 struct X {
95 double Eval(double x);
96 };
97 you can wrapped in the following way:
98 WrappedMemFunction<X, double ( X::* ) (double) > f;
99
100
101 @ingroup GenFunc
102
103 */
104
105template<typename FuncObj, typename MemFuncPtr >
107
108
109 public:
110
111 /**
112 construct from the pointer to the object and the member function
113 */
114 WrappedMemFunction( FuncObj & obj, MemFuncPtr memFn ) :
115 fObj(&obj),
116 fMemFunc( memFn )
117 { /* no op */ }
118
119 // use default copy contructor and assignment operator
120
121 /// clone (required by the interface)
123 return new WrappedMemFunction(*fObj,fMemFunc);
124 }
125
126
127private:
128
129 virtual double DoEval (double x) const {
130 return ((*fObj).*fMemFunc)( x );
131 }
132
133
134 FuncObj * fObj;
135 MemFuncPtr fMemFunc;
136
137
138}; // WrappedMemFunction
139
140
141/**
142 Template class to wrap any C++ callable object
143 implementing operator() (const double * x) in a multi-dimensional function interface.
144 It provides a ROOT::Math::IGenMultiFunction-like signature
145
146 Note: If you want to wrap just the reference (to avoid copying) you need to use
147 Func& or const Func & as template parameter. The former should be used when the
148 operator() is not a const method of Func
149
150 @ingroup GenFunc
151
152 */
153template< typename Func = FreeMultiFunctionPtr >
155
156
157 public:
158
159 /**
160 construct from the pointer to the object and the member function
161 */
162 WrappedMultiFunction( Func f , unsigned int dim = 1) :
163 fFunc( f ),
164 fDim( dim)
165 { /* no op */ }
166
167 // use default copy contructor and assignment operator
168
169 /// clone (required by the interface)
171 return new WrappedMultiFunction(fFunc,fDim);
172 }
173
174 unsigned int NDim() const { return fDim; }
175
176 // virtual ~WrappedFunction() { /**/ }
177
178private:
179
180 virtual double DoEval (const double * x) const {
181 return fFunc( x );
182 }
183
184
185 Func fFunc;
186 unsigned int fDim;
187
188
189}; // WrappedMultiFunction
190
191
192template<typename FuncObj, typename MemFuncPtr >
194
195
196 public:
197
198 /**
199 construct from the pointer to the object and the member function
200 */
201 WrappedMemMultiFunction( FuncObj & obj, MemFuncPtr memFn, unsigned int dim = 1 ) :
202 fObj(&obj),
203 fMemFunc( memFn ),
204 fDim(dim)
205 { /* no op */ }
206
207 // use default copy contructor and assignment operator
208
209 /// clone (required by the interface)
212 }
213
214
215 unsigned int NDim() const { return fDim; }
216
217private:
218
219 virtual double DoEval (const double * x) const {
220 return ((*fObj).*fMemFunc)( x );
221 }
222
223
224 FuncObj * fObj;
225 MemFuncPtr fMemFunc;
226 unsigned int fDim;
227
228
229}; // WrappedMemMultiFunction
230
231
232} // namespace Math
233} // namespace ROOT
234
235
236
237#endif // ROOT_Math_WrappedFunction
double
Definition: Converters.cxx:939
#define f(i)
Definition: RSha256.hxx:104
Documentation for the abstract class IBaseFunctionMultiDim.
Definition: IFunction.h:62
Interface (abstract class) for generic functions objects of one-dimension Provides a method to evalua...
Definition: IFunction.h:135
Template class to wrap any C++ callable object which takes one argument i.e.
WrappedFunction * Clone() const
clone (required by the interface)
WrappedFunction(Func f)
construct from the pointer to the object and the member function
virtual double DoEval(double x) const
implementation of the evaluation function. Must be implemented by derived classes
Template class to wrap any member function of a class taking a double and returning a double in a 1D ...
WrappedMemFunction * Clone() const
clone (required by the interface)
virtual double DoEval(double x) const
implementation of the evaluation function. Must be implemented by derived classes
WrappedMemFunction(FuncObj &obj, MemFuncPtr memFn)
construct from the pointer to the object and the member function
virtual double DoEval(const double *x) const
WrappedMemMultiFunction(FuncObj &obj, MemFuncPtr memFn, unsigned int dim=1)
construct from the pointer to the object and the member function
WrappedMemMultiFunction * Clone() const
clone (required by the interface)
unsigned int NDim() const
Retrieve the dimension of the function.
Template class to wrap any C++ callable object implementing operator() (const double * x) in a multi-...
WrappedMultiFunction(Func f, unsigned int dim=1)
construct from the pointer to the object and the member function
unsigned int NDim() const
Retrieve the dimension of the function.
WrappedMultiFunction * Clone() const
clone (required by the interface)
virtual double DoEval(const double *x) const
Double_t x[n]
Definition: legend1.C:17
Namespace for new Math classes and functions.
double(* FreeMultiFunctionPtr)(const double *)
double(* FreeFunctionPtr)(double)
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...
Definition: RNumpyDS.hxx:30