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 constructor and assignment operator
69
70 /// clone (required by the interface)
71 WrappedFunction * Clone() const override {
72 return new WrappedFunction(fFunc);
73 }
74
75 // virtual ~WrappedFunction() { /**/ }
76
77private:
78
79 double DoEval (double x) const override {
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 constructor and assignment operator
120
121 /// clone (required by the interface)
122 WrappedMemFunction * Clone() const override {
123 return new WrappedMemFunction(*fObj,fMemFunc);
124 }
125
126
127private:
128
129 double DoEval (double x) const override {
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)
170 WrappedMultiFunction * Clone() const override {
171 return new WrappedMultiFunction(fFunc,fDim);
172 }
173
174 unsigned int NDim() const override { return fDim; }
175
176 // virtual ~WrappedFunction() { /**/ }
177
178private:
179
180 double DoEval (const double * x) const override {
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 constructor and assignment operator
208
209 /// clone (required by the interface)
210 WrappedMemMultiFunction * Clone() const override {
212 }
213
214
215 unsigned int NDim() const override { return fDim; }
216
217private:
218
219 double DoEval (const double * x) const override {
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
#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.
double DoEval(double x) const override
implementation of the evaluation function. Must be implemented by derived classes
WrappedFunction * Clone() const override
clone (required by the interface)
WrappedFunction(Func f)
construct from the pointer to the object and the member function
Template class to wrap any member function of a class taking a double and returning a double in a 1D ...
double DoEval(double x) const override
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
WrappedMemFunction * Clone() const override
clone (required by the interface)
WrappedMemMultiFunction * Clone() const override
clone (required by the interface)
WrappedMemMultiFunction(FuncObj &obj, MemFuncPtr memFn, unsigned int dim=1)
construct from the pointer to the object and the member function
double DoEval(const double *x) const override
unsigned int NDim() const override
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
WrappedMultiFunction * Clone() const override
clone (required by the interface)
double DoEval(const double *x) const override
unsigned int NDim() const override
Retrieve the dimension of the function.
Double_t x[n]
Definition: legend1.C:17
Namespace for new Math classes and functions.
double(* FreeMultiFunctionPtr)(const double *)
double(* FreeFunctionPtr)(double)
This file contains a specialised ROOT message handler to test for diagnostic in unit tests.