/usr/include/root/Math/ParamFunctor.h is in libroot-math-mathcore-dev 5.34.19+dfsg-1.2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 | // @(#)root/mathcore:$Id$
// Author: L. Moneta Mon Nov 13 15:58:13 2006
/**********************************************************************
* *
* Copyright (c) 2006 LCG ROOT Math Team, CERN/PH-SFT *
* *
* *
**********************************************************************/
// Header file for Functor classes.
// design is inspired by the Loki Functor
#ifndef ROOT_Math_ParamFunctor
#define ROOT_Math_ParamFunctor
// #ifndef ROOT_Math_IFunction
// #include "Math/IFunction.h"
// #endif
// #ifndef Root_Math_StaticCheck
// #include "Math/StaticCheck.h"
// #endif
//#ifndef __CINT__
//#include <memory>
#include <vector>
#include <iostream>
namespace ROOT {
namespace Math {
/** class defining the signature for multi-dim parametric functions
@ingroup ParamFunctor_int
*/
class ParamFunctionBase {
public:
virtual ~ParamFunctionBase() {}
// virtual double operator() (const double * x, const double *p) const = 0;
virtual double operator() (double * x, double *p) = 0;
virtual ParamFunctionBase * Clone() const = 0;
};
/**
ParamFunctor Handler class is responsible for wrapping any other functor and pointer to
free C functions.
It can be created from any function implementing the correct signature
corresponding to the requested type
@ingroup ParamFunctor_int
*/
#ifndef __CINT__
template<class ParentFunctor, class Func >
class ParamFunctorHandler : public ParentFunctor::Impl {
typedef typename ParentFunctor::Impl Base;
public:
// constructor
ParamFunctorHandler(const Func & fun) : fFunc(fun) {}
virtual ~ParamFunctorHandler() {}
// for 1D functions
inline double operator() (double x, double *p) {
return fFunc(x,p);
}
// inline double operator() (double x, const double *p) const {
// return fFunc(x,p);
// }
// for multi-dimensional functions
// inline double operator() (const double * x, const double *p) const {
// return fFunc(x,p);
// }
inline double operator() (double * x, double *p) {
return FuncEvaluator<Func>::Eval(fFunc,x,p);
}
// clone (use same pointer)
ParamFunctorHandler * Clone() const {
return new ParamFunctorHandler(fFunc);
}
private :
Func fFunc;
// structure to distinguish pointer types
template <typename F> struct FuncEvaluator {
inline static double Eval( F & f, double *x, double * p) {
return f(x,p);
}
};
template <typename F> struct FuncEvaluator<F*> {
inline static double Eval( F * f, double *x, double * p) {
return (*f)(x,p);
}
};
template <typename F> struct FuncEvaluator<F* const> {
inline static double Eval( const F * f, double *x, double * p) {
return (*f)(x,p);
}
};
// need maybe also volatile ?
};
#if defined(__MAKECINT__) || defined(G__DICTIONARY)
// needed since CINT initialize it with TRootIOCtor
//class TRootIOCtor;
template<class ParentFunctor>
class ParamFunctorHandler<ParentFunctor,TRootIOCtor *> : public ParentFunctor::Impl
{
public:
ParamFunctorHandler(TRootIOCtor *) {}
double operator() (double *, double * ) { return 0; }
// clone (use same pointer)
ParamFunctorHandler * Clone() const {
return 0;
}
};
#endif
/**
ParamFunctor Handler to Wrap pointers to member functions
@ingroup ParamFunctor_int
*/
template <class ParentFunctor, typename PointerToObj,
typename PointerToMemFn>
class ParamMemFunHandler : public ParentFunctor::Impl
{
typedef typename ParentFunctor::Impl Base;
public:
/// constructor from a pointer to the class and a pointer to the function
ParamMemFunHandler(const PointerToObj& pObj, PointerToMemFn pMemFn)
: fObj(pObj), fMemFn(pMemFn)
{}
virtual ~ParamMemFunHandler() {}
// inline double operator() (double x, const double * p) const {
// return ((*fObj).*fMemFn)(x,p);
// }
inline double operator() (double x, double * p) {
return ((*fObj).*fMemFn)(x,p);
}
// inline double operator() (const double * x, const double * p) const {
// return ((*fObj).*fMemFn)(x,p);
// }
inline double operator() (double * x, double * p) {
return ((*fObj).*fMemFn)(x,p);
}
// clone (use same pointer)
ParamMemFunHandler * Clone() const {
return new ParamMemFunHandler(fObj, fMemFn);
}
private :
ParamMemFunHandler(const ParamMemFunHandler&); // Not implemented
ParamMemFunHandler& operator=(const ParamMemFunHandler&); // Not implemented
PointerToObj fObj;
PointerToMemFn fMemFn;
};
#endif
/**
Param Functor class for Multidimensional functions.
It is used to wrap in a very simple and convenient way
any other C++ callable object (implemention double operator( const double *, const double * ) )
or a member function with the correct signature,
like Foo::EvalPar(const double *, const double *)
@ingroup ParamFunc
*/
class ParamFunctor {
public:
typedef ParamFunctionBase Impl;
/**
Default constructor
*/
ParamFunctor () : fImpl(0) {}
/**
construct from a pointer to member function (multi-dim type)
*/
template <class PtrObj, typename MemFn>
ParamFunctor(const PtrObj& p, MemFn memFn)
: fImpl(new ParamMemFunHandler<ParamFunctor, PtrObj, MemFn>(p, memFn))
{}
/**
construct from another generic Functor of multi-dimension
*/
template <typename Func>
explicit ParamFunctor( const Func & f) :
fImpl(new ParamFunctorHandler<ParamFunctor,Func>(f) )
{}
// specialization used in TF1
typedef double (* FreeFunc ) (double * , double *);
ParamFunctor(FreeFunc f) :
fImpl(new ParamFunctorHandler<ParamFunctor,FreeFunc>(f) )
{
}
/**
Destructor (no operations)
*/
virtual ~ParamFunctor () {
if (fImpl) delete fImpl;
}
/**
Copy constructor
*/
ParamFunctor(const ParamFunctor & rhs) :
fImpl(0)
{
// if (rhs.fImpl.get() != 0)
// fImpl = std::auto_ptr<Impl>( (rhs.fImpl)->Clone() );
if (rhs.fImpl != 0) fImpl = rhs.fImpl->Clone();
}
/**
Assignment operator
*/
ParamFunctor & operator = (const ParamFunctor & rhs) {
// ParamFunctor copy(rhs);
// swap auto_ptr by hand
// Impl * p = fImpl.release();
// fImpl.reset(copy.fImpl.release());
// copy.fImpl.reset(p);
if(this != &rhs) {
if (fImpl) delete fImpl;
fImpl = 0;
if (rhs.fImpl != 0)
fImpl = rhs.fImpl->Clone();
}
return *this;
}
void * GetImpl() { return (void *) fImpl; }
double operator() (double * x, double * p) {
return (*fImpl)(x,p);
}
bool Empty() { return fImpl == 0; }
void SetFunction(Impl * f) {
fImpl = f;
}
private :
//std::auto_ptr<Impl> fImpl;
Impl * fImpl;
};
} // end namespace Math
} // end namespace ROOT
#endif /* ROOT_Math_ParamFunctor */
|