Logo ROOT  

Reference Guide
 
Loading...
Searching...
No Matches
TFormulaPrimitive_v5.cxx
Go to the documentation of this file.
1// @(#)root/hist:$Id$
2// Author: Marian Ivanov, 2005
3
4/*************************************************************************
5* Copyright (C) 1995-2000, Rene Brun and Fons Rademakers. *
6* All rights reserved. *
7* *
8* For the licensing terms see $ROOTSYS/LICENSE. *
9* For the list of contributors see $ROOTSYS/README/CREDITS. *
10*************************************************************************/
11
12#include "v5/TFormulaPrimitive.h"
13
14#include "TMath.h"
15#include "TNamed.h"
16#include "TObjArray.h"
17#include "TVirtualMutex.h"
18
19#include <cmath>
20
21#ifdef WIN32
22#pragma optimize("",off)
23#endif
24
25static TVirtualMutex* gTFormulaPrimativeListMutex = nullptr;
26
27
28
29namespace ROOT {
30 namespace v5 {
31
32 void TMath_GenerInterface();
33
34/** \class TFormulaPrimitive TFormulaPrimitive.h "inc/v5/TFormulaPrimitive.h"
35 \ingroup Hist
36The Formula Primitive class
37
38Helper class for TFormula to speed up TFormula evaluation
39TFormula can use all functions registered in the list of TFormulaPrimitives
40User can add new function to the list of primitives
41if FormulaPrimitive with given name is already defined new primitive is ignored
42
43Example:
44
45~~~ {.cpp}
46 TFormulaPrimitive::AddFormula(new TFormulaPrimitive("Pow2","Pow2",TFastFun::Pow2));
47 TF1 f1("f1","Pow2(x)");
48~~~
49
50 - TFormulaPrimitive is used to get direct acces to the function pointers
51 - GenFunc - pointers to the static function
52 - TFunc - pointers to the data member functions
53
54The following sufixes are currently used, to describe function arguments:
55
56 - G - generic layout - pointer to double (arguments), pointer to double (parameters)
57 - 10 - double
58 - 110 - double, double
59 - 1110 - double, double, double
60*/
61
62//______________________________________________________________________________
63// TFormula primitive
64//
65TObjArray * TFormulaPrimitive::fgListOfFunction = nullptr;
66#ifdef R__COMPLETE_MEM_TERMINATION
67namespace {
68 class TFormulaPrimitiveCleanup {
69 TObjArray **fListOfFunctions;
70 public:
71 TFormulaPrimitiveCleanup(TObjArray **functions) : fListOfFunctions(functions) {}
72 ~TFormulaPrimitiveCleanup() {
73 delete *fListOfFunctions;
74 }
75 };
76
77}
78#endif
79
80////////////////////////////////////////////////////////////////////////////////
81/// Default constructor.
82
83TFormulaPrimitive::TFormulaPrimitive() : fFuncG(nullptr), fType(0), fNArguments(0), fNParameters(0), fIsStatic(true) {}
84
85////////////////////////////////////////////////////////////////////////////////
86/// Constructor.
87
88TFormulaPrimitive::TFormulaPrimitive(const char *name,const char *formula,
89 GenFunc0 fpointer) : TNamed(name,formula),
90 fFunc0(fpointer),
91 fType(0),fNArguments(0),fNParameters(0),fIsStatic(kTRUE)
92{
93}
94
95////////////////////////////////////////////////////////////////////////////////
96/// Constructor.
97
98TFormulaPrimitive::TFormulaPrimitive(const char *name,const char *formula,
99 GenFunc10 fpointer) : TNamed(name,formula),
100 fFunc10(fpointer),
101 fType(10),fNArguments(1),fNParameters(0),fIsStatic(kTRUE)
102{
103}
104
105////////////////////////////////////////////////////////////////////////////////
106/// Constructor.
107
108TFormulaPrimitive::TFormulaPrimitive(const char *name,const char *formula,
109 GenFunc110 fpointer) : TNamed(name,formula),
110 fFunc110(fpointer),
111 fType(110),fNArguments(2),fNParameters(0),fIsStatic(kTRUE)
112{
113}
114
115////////////////////////////////////////////////////////////////////////////////
116/// Constructor.
117
118TFormulaPrimitive::TFormulaPrimitive(const char *name,const char *formula,
119 GenFunc1110 fpointer) : TNamed(name,formula),
120 fFunc1110(fpointer),
121 fType(1110),fNArguments(3),fNParameters(0),fIsStatic(kTRUE)
122{
123}
124
125////////////////////////////////////////////////////////////////////////////////
126/// Constructor.
127
128TFormulaPrimitive::TFormulaPrimitive(const char *name,const char *formula,
129 GenFuncG fpointer,Int_t npar) : TNamed(name,formula),
130 fFuncG(fpointer),
131 fType(-1),fNArguments(2),fNParameters(npar),fIsStatic(kTRUE)
132{
133}
134
135////////////////////////////////////////////////////////////////////////////////
136/// Constructor.
137
138TFormulaPrimitive::TFormulaPrimitive(const char *name,const char *formula,
139 TFuncG fpointer) : TNamed(name,formula),
140 fTFuncG(fpointer),
141 fType(0),fNArguments(0),fNParameters(0),fIsStatic(kFALSE)
142{
143}
144
145////////////////////////////////////////////////////////////////////////////////
146/// Constructor.
147
148TFormulaPrimitive::TFormulaPrimitive(const char *name,const char *formula,
149 TFunc0 fpointer) : TNamed(name,formula),
150 fTFunc0(fpointer),
151 fType(0),fNArguments(0),fNParameters(0),fIsStatic(kFALSE)
152{
153}
154
155////////////////////////////////////////////////////////////////////////////////
156/// Constructor.
157
158TFormulaPrimitive::TFormulaPrimitive(const char *name,const char *formula,
159 TFunc10 fpointer) : TNamed(name,formula),
160 fTFunc10(fpointer),
161 fType(-10),fNArguments(1),fNParameters(0),fIsStatic(kFALSE)
162{
163}
164
165////////////////////////////////////////////////////////////////////////////////
166/// Constructor.
167
168TFormulaPrimitive::TFormulaPrimitive(const char *name,const char *formula,
169 TFunc110 fpointer) : TNamed(name,formula),
170 fTFunc110(fpointer),
171 fType(-110),fNArguments(2),fNParameters(0),fIsStatic(kFALSE)
172{
173}
174
175////////////////////////////////////////////////////////////////////////////////
176/// Constructor.
177
178TFormulaPrimitive::TFormulaPrimitive(const char *name,const char *formula,
179 TFunc1110 fpointer) :TNamed(name,formula),
180 fTFunc1110(fpointer),
181 fType(-1110),fNArguments(3),fNParameters(0),fIsStatic(kFALSE)
182{
183}
184
185////////////////////////////////////////////////////////////////////////////////
186/// Add formula to the list of primitive formulas.
187/// If primitive formula already defined do nothing.
188
189Int_t TFormulaPrimitive::AddFormula(TFormulaPrimitive * formula)
190{
191 R__LOCKGUARD2(gTFormulaPrimativeListMutex);
192 if (fgListOfFunction == nullptr) BuildBasicFormulas();
193 if (FindFormula(formula->GetName(),formula->fNArguments)){
194 delete formula;
195 return 0;
196 }
197 fgListOfFunction->AddLast(formula);
198 return 1;
199}
200
201////////////////////////////////////////////////////////////////////////////////
202/// Eval primitive function at point x.
203
204Double_t TFormulaPrimitive::Eval(Double_t* x)
205{
206 if (fIsStatic == kFALSE) return 0;
207
208 if (fType==0) return fFunc0();
209 if (fType==10) {
210 return fFunc10(x[0]);
211 }
212 if (fType==110) {
213 return fFunc110(x[0],x[1]);
214 }
215 if (fType==1110) {
216 return fFunc1110(x[0],x[1],x[2]);
217 }
218 return 0;
219}
220
221////////////////////////////////////////////////////////////////////////////////
222/// Eval member function of object o at point x.
223
224Double_t TFormulaPrimitive::Eval(TObject *o, Double_t *x)
225{
226 if (fIsStatic == kTRUE) return 0;
227 if (fType== 0) return (*o.*fTFunc0)();
228 if (fType==-10) return (*o.*fTFunc10)(*x);
229 if (fType==-110) return (*o.*fTFunc110)(x[0],x[1]);
230 if (fType==-1110) return (*o.*fTFunc1110)(x[0],x[1],x[2]);
231 return 0;
232}
233
234////////////////////////////////////////////////////////////////////////////////
235/// Eval primitive parametric function.
236
237Double_t TFormulaPrimitive::Eval(Double_t *x, Double_t *param)
238{
239 return fFuncG(x,param);
240}
241
242#define RTFastFun__POLY(var) \
243{ \
244 Double_t res= param[var-1]+param[var]*x[0]; \
245 for (Int_t j=var-1 ;j>0;j--) res = param[j-1]+x[0]*res; \
246 return res; \
247}
248
249namespace TFastFun {
250 //
251 // Namespace with basic primitive functions registered by TFormulaPrimitive
252 // all function registered by TFormulaPrimitive can be used in TFormula
253 //
254 Double_t Pow2(Double_t x){return x*x;}
255 Double_t Pow3(Double_t x){return x*x*x;}
256 Double_t Pow4(Double_t x){return x*x*x*x;}
257 Double_t Pow5(Double_t x){return x*x*x*x*x;}
258 inline Double_t FPoln(Double_t *x, Double_t *param, Int_t npar);
259 Double_t FPol0(Double_t * /*x*/, Double_t *param){ return param[0];}
260 Double_t FPol1(Double_t *x, Double_t *param){ return param[0]+param[1]*x[0];}
261 Double_t FPol2(Double_t *x, Double_t *param){ return param[0]+x[0]*(param[1]+param[2]*x[0]);}
262 Double_t FPol3(Double_t *x, Double_t *param){ return param[0]+x[0]*(param[1]+x[0]*(param[2]+param[3]*x[0]));}
263 Double_t FPol4(Double_t *x, Double_t *param){ RTFastFun__POLY(4)}
264 Double_t FPol5(Double_t *x, Double_t *param){ RTFastFun__POLY(5)}
265 Double_t FPol6(Double_t *x, Double_t *param){ RTFastFun__POLY(6)}
266 Double_t FPol7(Double_t *x, Double_t *param){ RTFastFun__POLY(7)}
267 Double_t FPol8(Double_t *x, Double_t *param){ RTFastFun__POLY(8)}
268 Double_t FPol9(Double_t *x, Double_t *param){ RTFastFun__POLY(9)}
269 Double_t FPol10(Double_t *x, Double_t *param){ RTFastFun__POLY(10)}
270 //
271 //
272 Double_t PlusXY(Double_t x,Double_t y){return x+y;}
273 Double_t MinusXY(Double_t x,Double_t y){return x-y;}
274 Double_t MultXY(Double_t x,Double_t y){return x*y;}
275 Double_t DivXY(Double_t x, Double_t y){return TMath::Abs(y)>0 ? x/y:0;}
276 Double_t XpYpZ(Double_t x, Double_t y, Double_t z){ return x+y+z;}
277 Double_t XxYxZ(Double_t x, Double_t y, Double_t z){ return x*y*z;}
278 Double_t XxYpZ(Double_t x, Double_t y, Double_t z){ return x*(y+z);}
279 Double_t XpYxZ(Double_t x, Double_t y, Double_t z){ return x+(y*z);}
280 Double_t Gaus(Double_t x, Double_t mean, Double_t sigma);
281 Double_t Gausn(Double_t x, Double_t mean, Double_t sigma);
282 Double_t Landau(Double_t x, Double_t mean, Double_t sigma){return TMath::Landau(x,mean,sigma,kFALSE);}
283 Double_t Landaun(Double_t x, Double_t mean, Double_t sigma){return TMath::Landau(x,mean,sigma,kTRUE);}
284 Double_t Sqrt(Double_t x) {return x>0?sqrt(x):0;}
285 //
286 Double_t Sign(Double_t x){return (x<0)? -1:1;}
287 Double_t Nint(Double_t x){return TMath::Nint(x);}
288 Double_t Abs(Double_t x){return TMath::Abs(x);}
289 //logical
290 Double_t XandY(Double_t x, Double_t y){ return (x*y>0.1);}
291 Double_t XorY(Double_t x, Double_t y) { return (x+y>0.1);}
292 Double_t XgY(Double_t x, Double_t y) {return (x>y);}
293 Double_t XgeY(Double_t x, Double_t y) {return (x>=y);}
294 Double_t XlY(Double_t x, Double_t y) {return (x<y);}
295 Double_t XleY(Double_t x, Double_t y) {return (x<=y);}
296 Double_t XeY(Double_t x,Double_t y) {return (x==y);}
297 Double_t XneY(Double_t x,Double_t y) {return (x!=y);}
298 Double_t XNot(Double_t x){ return (x<0.1);}
299};
300
301////////////////////////////////////////////////////////////////////////////////
302/// Find the formula in the list of formulas.
303
304TFormulaPrimitive* TFormulaPrimitive::FindFormula(const char* name)
305{
306 R__LOCKGUARD2(gTFormulaPrimativeListMutex);
307 if (!fgListOfFunction) {
308 BuildBasicFormulas();
309 }
310 Int_t nobjects = fgListOfFunction->GetEntries();
311 for (Int_t i = 0; i < nobjects; ++i) {
312 TFormulaPrimitive *formula = (TFormulaPrimitive*)fgListOfFunction->At(i);
313 if (formula && 0==strcmp(name, formula->GetName())) return formula;
314 }
315 return nullptr;
316}
317
318////////////////////////////////////////////////////////////////////////////////
319/// Find the formula in the list of formulas.
320
321TFormulaPrimitive* TFormulaPrimitive::FindFormula(const char* name, UInt_t nargs)
322{
323 R__LOCKGUARD2(gTFormulaPrimativeListMutex);
324 if (!fgListOfFunction) {
325 BuildBasicFormulas();
326 }
327 Int_t nobjects = fgListOfFunction->GetEntries();
328 for (Int_t i = 0; i < nobjects; ++i) {
329 TFormulaPrimitive *prim = (TFormulaPrimitive*)fgListOfFunction->At(i);
330 if (prim) {
331 bool match = ( ((UInt_t)prim->fNArguments) == nargs );
332 if (match && 0==strcmp(name, prim->GetName())) return prim;
333 }
334 }
335 return nullptr;
336}
337
338////////////////////////////////////////////////////////////////////////////////
339/// Find the formula in the list of formulas.
340
341TFormulaPrimitive* TFormulaPrimitive::FindFormula(const char* name, const char *args)
342{
343 // let's count the argument(s)
344 if (args) {
345 Int_t nargs = 0;
346 if (args[0]!=')') {
347 nargs = 1;
348 int nest = 0;
349 for(UInt_t c = 0; c < strlen(args); ++c ) {
350 switch (args[c]) {
351 case '(': ++nest; break;
352 case ')': --nest; break;
353 case '<': ++nest; break;
354 case '>': --nest; break;
355 case ',': nargs += (nest==0); break;
356 }
357 }
358 }
359 return FindFormula(name,nargs);
360 } else {
361 return FindFormula(name);
362 }
363 return nullptr;
364}
365
366////////////////////////////////////////////////////////////////////////////////
367/// FPoln.
368
369Double_t TFastFun::FPoln(Double_t *x, Double_t *param, Int_t npar)
370{
371 Double_t res = 0; Double_t temp=1;
372 for (Int_t j=npar ;j>=0;j--) {
373 res += temp*param[j];
374 temp *= *x;
375 }
376 return res;
377}
378
379////////////////////////////////////////////////////////////////////////////////
380/// Gauss.
381
382Double_t TFastFun::Gaus(Double_t x, Double_t mean, Double_t sigma)
383{
384 if (sigma == 0) return 1.e30;
385 Double_t arg = (x-mean)/sigma;
386 return TMath::Exp(-0.5*arg*arg);
387}
388
389////////////////////////////////////////////////////////////////////////////////
390/// Normalize gauss.
391
392Double_t TFastFun::Gausn(Double_t x, Double_t mean, Double_t sigma)
393{
394 if (sigma == 0) return 0;
395 Double_t arg = (x-mean)/sigma;
396 return TMath::Exp(-0.5*arg*arg)/(2.50662827463100024*sigma); //sqrt(2*Pi)=2.50662827463100024
397}
398
399////////////////////////////////////////////////////////////////////////////////
400/// Built-in functions.
401
402Int_t TFormulaPrimitive::BuildBasicFormulas()
403{
404 R__LOCKGUARD2(gTFormulaPrimativeListMutex);
405 if (fgListOfFunction==nullptr) {
406 fgListOfFunction = new TObjArray(1000);
407 fgListOfFunction->SetOwner(kTRUE);
408 }
409#ifdef R__COMPLETE_MEM_TERMINATION
410 static TFormulaPrimitiveCleanup gCleanup(&fgListOfFunction);
411#endif
412
413 //
414 // logical
415 //
416 AddFormula(new TFormulaPrimitive("XandY","XandY",TFastFun::XandY));
417 AddFormula(new TFormulaPrimitive("XorY","XorY",TFastFun::XorY));
418 AddFormula(new TFormulaPrimitive("XNot","XNot",TFastFun::XNot));
419 AddFormula(new TFormulaPrimitive("XlY","XlY",TFastFun::XlY));
420 AddFormula(new TFormulaPrimitive("XleY","XleY",TFastFun::XleY));
421 AddFormula(new TFormulaPrimitive("XgY","XgY",TFastFun::XgY));
422 AddFormula(new TFormulaPrimitive("XgeY","XgeY",TFastFun::XgeY));
423 AddFormula(new TFormulaPrimitive("XeY","XeY",TFastFun::XeY));
424 AddFormula(new TFormulaPrimitive("XneY","XneY",TFastFun::XneY));
425 // addition + multiplication
426 AddFormula(new TFormulaPrimitive("PlusXY","PlusXY",TFastFun::PlusXY));
427 AddFormula(new TFormulaPrimitive("MinusXY","MinusXY",TFastFun::MinusXY));
428 AddFormula(new TFormulaPrimitive("MultXY","MultXY",TFastFun::MultXY));
429 AddFormula(new TFormulaPrimitive("DivXY","DivXY",TFastFun::DivXY));
430 AddFormula(new TFormulaPrimitive("XpYpZ","XpYpZ",TFastFun::XpYpZ));
431 AddFormula(new TFormulaPrimitive("XxYxZ","XxYxZ",TFastFun::XxYxZ));
432 AddFormula(new TFormulaPrimitive("XxYpZ","XxYpZ",TFastFun::XxYpZ));
433 AddFormula(new TFormulaPrimitive("XpYxZ","XpYxZ",TFastFun::XpYxZ));
434 //
435 //
436 AddFormula(new TFormulaPrimitive("Gaus","Gaus",TFastFun::Gaus));
437 AddFormula(new TFormulaPrimitive("Gausn","Gausn",TFastFun::Gausn));
438 AddFormula(new TFormulaPrimitive("Landau","Landau",TFastFun::Landau));
439 AddFormula(new TFormulaPrimitive("Landaun","Landaun",TFastFun::Landaun));
440 //
441 //
442 // polynoms
443 //
444 //
445 AddFormula(new TFormulaPrimitive("Pol0","Pol0",(GenFuncG)TFastFun::FPol0,1));
446 AddFormula(new TFormulaPrimitive("Pol1","Pol1",(GenFuncG)TFastFun::FPol1,2));
447 AddFormula(new TFormulaPrimitive("Pol2","Pol2",(GenFuncG)TFastFun::FPol2,3));
448 AddFormula(new TFormulaPrimitive("Pol3","Pol3",(GenFuncG)TFastFun::FPol3,4));
449 AddFormula(new TFormulaPrimitive("Pol4","Pol4",(GenFuncG)TFastFun::FPol4,5));
450 AddFormula(new TFormulaPrimitive("Pol5","Pol5",(GenFuncG)TFastFun::FPol5,6));
451 AddFormula(new TFormulaPrimitive("Pol6","Pol6",(GenFuncG)TFastFun::FPol6,7));
452 AddFormula(new TFormulaPrimitive("Pol7","Pol7",(GenFuncG)TFastFun::FPol7,8));
453 AddFormula(new TFormulaPrimitive("Pol8","Pol8",(GenFuncG)TFastFun::FPol8,9));
454 AddFormula(new TFormulaPrimitive("Pol9","Pol9",(GenFuncG)TFastFun::FPol9,10));
455 AddFormula(new TFormulaPrimitive("Pol10","Pol10",(GenFuncG)TFastFun::FPol10,11));
456 //
457 // pows
458 AddFormula(new TFormulaPrimitive("Pow2","Pow2",TFastFun::Pow2));
459 AddFormula(new TFormulaPrimitive("Pow3","Pow3",TFastFun::Pow3));
460 AddFormula(new TFormulaPrimitive("Pow4","Pow4",TFastFun::Pow4));
461 AddFormula(new TFormulaPrimitive("Pow5","Pow5",TFastFun::Pow5));
462 //
463 //
464 AddFormula(new TFormulaPrimitive("TMath::Cos","TMath::Cos",cos)); // 10
465 AddFormula(new TFormulaPrimitive("cos","cos",cos)); // 10
466 AddFormula(new TFormulaPrimitive("TMath::Sin","TMath::Sin",sin)); // 11
467 AddFormula(new TFormulaPrimitive("sin","sin",sin)); // 11
468 AddFormula(new TFormulaPrimitive("TMath::Tan","TMath::Tan",tan)); // 12
469 AddFormula(new TFormulaPrimitive("tan","tan",tan)); // 12
470 AddFormula(new TFormulaPrimitive("TMath::ACos","TMath::ACos",acos)); // 13
471 AddFormula(new TFormulaPrimitive("acos","acos",acos)); // 13
472 AddFormula(new TFormulaPrimitive("TMath::ASin","TMath::ASin",asin)); // 14
473 AddFormula(new TFormulaPrimitive("asin","asin",asin)); // 14
474 AddFormula(new TFormulaPrimitive("TMath::ATan","TMath::ATan",atan)); // 15
475 AddFormula(new TFormulaPrimitive("atan","atan",atan)); // 15
476 AddFormula(new TFormulaPrimitive("TMath::ATan2","TMath::ATan2",atan2)); // 16
477 AddFormula(new TFormulaPrimitive("atan2","atan2",atan2)); // 16
478 // kpow = 20, ksq = 21, ksqrt = 22,
479 AddFormula(new TFormulaPrimitive("pow","pow",TMath::Power)); //20
480 AddFormula(new TFormulaPrimitive("sq","sq",TFastFun::Pow2)); //21
481 AddFormula(new TFormulaPrimitive("sqrt","sqrt",TFastFun::Sqrt)); //22
482 // kmin = 24, kmax = 25,
483 AddFormula(new TFormulaPrimitive("min","min",(GenFunc110)TMath::Min)); //24
484 AddFormula(new TFormulaPrimitive("max","max",(GenFunc110)TMath::Max)); //25
485 // klog = 30, kexp = 31, klog10 = 32,
486 AddFormula(new TFormulaPrimitive("log","log",TMath::Log)); //30
487 AddFormula(new TFormulaPrimitive("exp","exp",TMath::Exp)); //31
488 AddFormula(new TFormulaPrimitive("log10","log10",TMath::Log10)); //32
489 //
490 // cosh 70 acosh 73
491 // sinh 71 asinh 74
492 // tanh 72 atanh 75
493 //
494 AddFormula(new TFormulaPrimitive("TMath::CosH","TMath::Cosh",cosh)); // 70
495 AddFormula(new TFormulaPrimitive("cosh","cosh",cosh)); // 70
496 AddFormula(new TFormulaPrimitive("TMath::SinH","TMath::SinH",sinh)); // 71
497 AddFormula(new TFormulaPrimitive("sinh","sinh",sinh)); // 71
498 AddFormula(new TFormulaPrimitive("TMath::TanH","TMath::Tanh",tanh)); // 72
499 AddFormula(new TFormulaPrimitive("tanh","tanh",tanh)); // 72
500 AddFormula(new TFormulaPrimitive("TMath::ACosH","TMath::ACosh",TMath::ACosH)); // 73
501 AddFormula(new TFormulaPrimitive("acosh","acosH",TMath::ACosH)); // 73
502 AddFormula(new TFormulaPrimitive("TMath::ASinH","TMath::ASinh",TMath::ASinH)); // 74
503 AddFormula(new TFormulaPrimitive("acosh","acosH",TMath::ASinH)); // 74
504 AddFormula(new TFormulaPrimitive("TMath::ATanH","TMath::ATanh",TMath::ATanH)); // 75
505 AddFormula(new TFormulaPrimitive("atanh","atanh",TMath::ATanH)); // 75
506 //
507 AddFormula(new TFormulaPrimitive("TMath::Abs","TMath::Abs",TMath::Abs));
508 AddFormula(new TFormulaPrimitive("TMath::BreitWigner","TMath::BreitWigner",TMath::BreitWigner));
509
510 //Disable direct access to TMath::Landau for now because of the default parameter.
511 //AddFormula(new TFormulaPrimitive("TMath::Landau","TMath::Landau",(TFormulaPrimitive::GenFunc1110)TMath::Landau));
512
513 TMath_GenerInterface();
514 return 1;
515}
516
517 } // end namespace v5
518
519} // end namespace ROOT
c
#define c(i)
Definition RSha256.hxx:101
Int_t
int Int_t
Signed integer 4 bytes (int)
Definition RtypesCore.h:59
UInt_t
unsigned int UInt_t
Unsigned integer 4 bytes (unsigned int)
Definition RtypesCore.h:60
kFALSE
constexpr Bool_t kFALSE
Definition RtypesCore.h:108
Double_t
double Double_t
Double 8 bytes.
Definition RtypesCore.h:73
kTRUE
constexpr Bool_t kTRUE
Definition RtypesCore.h:107
TRangeDynCast
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
Definition TCollection.h:358
gTFormulaPrimativeListMutex
static TVirtualMutex * gTFormulaPrimativeListMutex
Definition TFormulaPrimitive_v5.cxx:25
RTFastFun__POLY
#define RTFastFun__POLY(var)
Definition TFormulaPrimitive_v5.cxx:242
name
char name[80]
Definition TGX11.cxx:110
R__LOCKGUARD2
#define R__LOCKGUARD2(mutex)
Definition TVirtualMutex.h:96
ROOT::v5::TFormulaPrimitive
The Formula Primitive class.
Definition TFormulaPrimitive.h:38
ROOT::v5::TFormulaPrimitive::fFunc1110
GenFunc1110 fFunc1110
pointer to the function
Definition TFormulaPrimitive.h:59
ROOT::v5::TFormulaPrimitive::AddFormula
static Int_t AddFormula(TFormulaPrimitive *formula)
Add formula to the list of primitive formulas.
Definition TFormulaPrimitive_v5.cxx:189
ROOT::v5::TFormulaPrimitive::GenFuncG
Double_t(* GenFuncG)(const Double_t *, const Double_t *)
Definition TFormulaPrimitive.h:41
ROOT::v5::TFormulaPrimitive::TFormulaPrimitive
TFormulaPrimitive()
Default constructor.
Definition TFormulaPrimitive_v5.cxx:83
ROOT::v5::TFormulaPrimitive::fTFunc110
TFunc110 fTFunc110
pointer to member function
Definition TFormulaPrimitive.h:63
ROOT::v5::TFormulaPrimitive::fFunc10
GenFunc10 fFunc10
pointer to the function
Definition TFormulaPrimitive.h:57
ROOT::v5::TFormulaPrimitive::FindFormula
static TFormulaPrimitive * FindFormula(const char *name)
Find the formula in the list of formulas.
Definition TFormulaPrimitive_v5.cxx:304
ROOT::v5::TFormulaPrimitive::fTFunc10
TFunc10 fTFunc10
pointer to member function
Definition TFormulaPrimitive.h:62
ROOT::v5::TFormulaPrimitive::fFunc110
GenFunc110 fFunc110
pointer to the function
Definition TFormulaPrimitive.h:58
ROOT::v5::TFormulaPrimitive::fTFunc0
TFunc0 fTFunc0
pointer to the TFormula generic function
Definition TFormulaPrimitive.h:61
ROOT::v5::TFormulaPrimitive::BuildBasicFormulas
static Int_t BuildBasicFormulas()
list of global primitive formulas
Definition TFormulaPrimitive_v5.cxx:402
ROOT::v5::TFormulaPrimitive::fFunc0
GenFunc0 fFunc0
pointer to the TFormula generic function
Definition TFormulaPrimitive.h:56
ROOT::v5::TFormulaPrimitive::Eval
Double_t Eval(Double_t *x)
Eval primitive function at point x.
Definition TFormulaPrimitive_v5.cxx:204
ROOT::v5::TFormulaPrimitive::GenFunc110
Double_t(* GenFunc110)(Double_t, Double_t)
Definition TFormulaPrimitive.h:44
ROOT::v5::TFormulaPrimitive::fTFunc1110
TFunc1110 fTFunc1110
pointer to member function
Definition TFormulaPrimitive.h:64
ROOT::v5::TFormulaPrimitive::fgListOfFunction
static TObjArray * fgListOfFunction
Definition TFormulaPrimitive.h:52
TNamed
The TNamed class is the base class for all named ROOT classes.
Definition TNamed.h:29
TNamed::GetName
const char * GetName() const override
Returns name of object.
Definition TNamed.h:49
TObjArray
An array of TObjects.
Definition TObjArray.h:31
TObject
Mother of all ROOT objects.
Definition TObject.h:41
TVirtualMutex
This class implements a mutex interface.
Definition TVirtualMutex.h:32
sigma
const Double_t sigma
Definition h1analysisProxy.h:11
y
Double_t y[n]
Definition legend1.C:17
x
Double_t x[n]
Definition legend1.C:17
ROOT::v5::TFastFun::Landau
Double_t Landau(Double_t x, Double_t mean, Double_t sigma)
Definition TFormulaPrimitive_v5.cxx:282
ROOT::v5::TFastFun::Pow3
Double_t Pow3(Double_t x)
Definition TFormulaPrimitive_v5.cxx:255
ROOT::v5::TFastFun::XorY
Double_t XorY(Double_t x, Double_t y)
Definition TFormulaPrimitive_v5.cxx:291
ROOT::v5::TFastFun::Abs
Double_t Abs(Double_t x)
Definition TFormulaPrimitive_v5.cxx:288
ROOT::v5::TFastFun::XpYpZ
Double_t XpYpZ(Double_t x, Double_t y, Double_t z)
Definition TFormulaPrimitive_v5.cxx:276
ROOT::v5::TFastFun::Pow4
Double_t Pow4(Double_t x)
Definition TFormulaPrimitive_v5.cxx:256
ROOT::v5::TFastFun::FPol7
Double_t FPol7(Double_t *x, Double_t *param)
Definition TFormulaPrimitive_v5.cxx:266
ROOT::v5::TFastFun::XneY
Double_t XneY(Double_t x, Double_t y)
Definition TFormulaPrimitive_v5.cxx:297
ROOT::v5::TFastFun::Pow2
Double_t Pow2(Double_t x)
Definition TFormulaPrimitive_v5.cxx:254
ROOT::v5::TFastFun::FPol0
Double_t FPol0(Double_t *, Double_t *param)
Definition TFormulaPrimitive_v5.cxx:259
ROOT::v5::TFastFun::XlY
Double_t XlY(Double_t x, Double_t y)
Definition TFormulaPrimitive_v5.cxx:294
ROOT::v5::TFastFun::XxYpZ
Double_t XxYpZ(Double_t x, Double_t y, Double_t z)
Definition TFormulaPrimitive_v5.cxx:278
ROOT::v5::TFastFun::FPoln
Double_t FPoln(Double_t *x, Double_t *param, Int_t npar)
FPoln.
Definition TFormulaPrimitive_v5.cxx:369
ROOT::v5::TFastFun::XNot
Double_t XNot(Double_t x)
Definition TFormulaPrimitive_v5.cxx:298
ROOT::v5::TFastFun::XxYxZ
Double_t XxYxZ(Double_t x, Double_t y, Double_t z)
Definition TFormulaPrimitive_v5.cxx:277
ROOT::v5::TFastFun::FPol1
Double_t FPol1(Double_t *x, Double_t *param)
Definition TFormulaPrimitive_v5.cxx:260
ROOT::v5::TFastFun::Nint
Double_t Nint(Double_t x)
Definition TFormulaPrimitive_v5.cxx:287
ROOT::v5::TFastFun::XgeY
Double_t XgeY(Double_t x, Double_t y)
Definition TFormulaPrimitive_v5.cxx:293
ROOT::v5::TFastFun::XpYxZ
Double_t XpYxZ(Double_t x, Double_t y, Double_t z)
Definition TFormulaPrimitive_v5.cxx:279
ROOT::v5::TFastFun::Gausn
Double_t Gausn(Double_t x, Double_t mean, Double_t sigma)
Normalize gauss.
Definition TFormulaPrimitive_v5.cxx:392
ROOT::v5::TFastFun::PlusXY
Double_t PlusXY(Double_t x, Double_t y)
Definition TFormulaPrimitive_v5.cxx:272
ROOT::v5::TFastFun::Gaus
Double_t Gaus(Double_t x, Double_t mean, Double_t sigma)
Gauss.
Definition TFormulaPrimitive_v5.cxx:382
ROOT::v5::TFastFun::MinusXY
Double_t MinusXY(Double_t x, Double_t y)
Definition TFormulaPrimitive_v5.cxx:273
ROOT::v5::TFastFun::Landaun
Double_t Landaun(Double_t x, Double_t mean, Double_t sigma)
Definition TFormulaPrimitive_v5.cxx:283
ROOT::v5::TFastFun::FPol4
Double_t FPol4(Double_t *x, Double_t *param)
Definition TFormulaPrimitive_v5.cxx:263
ROOT::v5::TFastFun::XandY
Double_t XandY(Double_t x, Double_t y)
Definition TFormulaPrimitive_v5.cxx:290
ROOT::v5::TFastFun::XeY
Double_t XeY(Double_t x, Double_t y)
Definition TFormulaPrimitive_v5.cxx:296
ROOT::v5::TFastFun::XleY
Double_t XleY(Double_t x, Double_t y)
Definition TFormulaPrimitive_v5.cxx:295
ROOT::v5::TFastFun::Sqrt
Double_t Sqrt(Double_t x)
Definition TFormulaPrimitive_v5.cxx:284
ROOT::v5::TFastFun::FPol9
Double_t FPol9(Double_t *x, Double_t *param)
Definition TFormulaPrimitive_v5.cxx:268
ROOT::v5::TFastFun::FPol6
Double_t FPol6(Double_t *x, Double_t *param)
Definition TFormulaPrimitive_v5.cxx:265
ROOT::v5::TFastFun::FPol10
Double_t FPol10(Double_t *x, Double_t *param)
Definition TFormulaPrimitive_v5.cxx:269
ROOT::v5::TFastFun::DivXY
Double_t DivXY(Double_t x, Double_t y)
Definition TFormulaPrimitive_v5.cxx:275
ROOT::v5::TFastFun::FPol3
Double_t FPol3(Double_t *x, Double_t *param)
Definition TFormulaPrimitive_v5.cxx:262
ROOT::v5::TFastFun::XgY
Double_t XgY(Double_t x, Double_t y)
Definition TFormulaPrimitive_v5.cxx:292
ROOT::v5::TFastFun::Pow5
Double_t Pow5(Double_t x)
Definition TFormulaPrimitive_v5.cxx:257
ROOT::v5::TFastFun::FPol2
Double_t FPol2(Double_t *x, Double_t *param)
Definition TFormulaPrimitive_v5.cxx:261
ROOT::v5::TFastFun::FPol8
Double_t FPol8(Double_t *x, Double_t *param)
Definition TFormulaPrimitive_v5.cxx:267
ROOT::v5::TFastFun::Sign
Double_t Sign(Double_t x)
Definition TFormulaPrimitive_v5.cxx:286
ROOT::v5::TFastFun::FPol5
Double_t FPol5(Double_t *x, Double_t *param)
Definition TFormulaPrimitive_v5.cxx:264
ROOT::v5::TFastFun::MultXY
Double_t MultXY(Double_t x, Double_t y)
Definition TFormulaPrimitive_v5.cxx:274
ROOT::v5::TMath_GenerInterface
void TMath_GenerInterface()
Definition TFormulaMathInterface.cxx:8
TMath::Nint
Int_t Nint(T x)
Round to nearest integer. Rounds half integers to the nearest even integer.
Definition TMath.h:704
TMath::Max
Short_t Max(Short_t a, Short_t b)
Returns the largest of a and b.
Definition TMathBase.h:251
TMath::Exp
Double_t Exp(Double_t x)
Returns the base-e exponential function of x, which is e raised to the power x.
Definition TMath.h:720
TMath::ASinH
Double_t ASinH(Double_t)
Returns the area hyperbolic sine of x.
Definition TMath.cxx:67
TMath::BreitWigner
Double_t BreitWigner(Double_t x, Double_t mean=0, Double_t gamma=1)
Calculates a Breit Wigner function with mean and gamma.
Definition TMath.cxx:442
TMath::Landau
Double_t Landau(Double_t x, Double_t mpv=0, Double_t sigma=1, Bool_t norm=kFALSE)
The LANDAU function.
Definition TMath.cxx:492
TMath::ACosH
Double_t ACosH(Double_t)
Returns the nonnegative area hyperbolic cosine of x.
Definition TMath.cxx:81
TMath::Log
Double_t Log(Double_t x)
Returns the natural logarithm of x.
Definition TMath.h:767
TMath::Power
LongDouble_t Power(LongDouble_t x, LongDouble_t y)
Returns x raised to the power y.
Definition TMath.h:732
TMath::Min
Short_t Min(Short_t a, Short_t b)
Returns the smallest of a and b.
Definition TMathBase.h:199
TMath::ATanH
Double_t ATanH(Double_t)
Returns the area hyperbolic tangent of x.
Definition TMath.cxx:95
TMath::Log10
Double_t Log10(Double_t x)
Returns the common (base-10) logarithm of x.
Definition TMath.h:773
TMath::Abs
Short_t Abs(Short_t d)
Returns the absolute value of parameter Short_t d.
Definition TMathBase.h:124