Logo ROOT  
Reference Guide
Integrator.h
Go to the documentation of this file.
1// @(#)root/mathmore:$Id$
2// Authors: L. Moneta, M. Slawinska 10/2007
3
4 /**********************************************************************
5 * *
6 * Copyright (c) 2007 ROOT Foundation, CERN/PH-SFT *
7 * *
8 * *
9 **********************************************************************/
10
11// Header file for class Integrator
12//
13//
14#ifndef ROOT_Math_Integrator
15#define ROOT_Math_Integrator
16
18
20
21#include "Math/IFunction.h"
22
24
25#include <memory>
26#include <vector>
27#include <string>
28
29
30/**
31@defgroup NumAlgo Numerical Algorithms
32
33Numerical Algorithm classes from the \ref MathCore and \ref MathMore libraries.
34
35@ingroup MathCore
36@ingroup MathMore
37
38*/
39
40
41/**
42
43@defgroup Integration Numerical Integration
44
45Classes for numerical integration of functions.
46These classes provide algorithms for integration of one-dimensional functions, with several adaptive and non-adaptive methods
47and for integration of multi-dimensional function using an adaptive method or MonteCarlo Integration (GSLMCIntegrator).
48The basic classes ROOT::Math::IntegratorOneDim provides a common interface for the one-dimensional methods while the class
49ROOT::Math::IntegratorMultiDim provides the interface for the multi-dimensional ones.
50The methods can be configured (e.g setting the default method with its default parameters) using the ROOT::Math::IntegratorOneDimOptions and
51ROOT::Math::IntegratorMultiDimOptions classes.
52
53@ingroup NumAlgo
54
55*/
56
57
58
59namespace ROOT {
60namespace Math {
61
62
63
64
65//____________________________________________________________________________________________
66/**
67
68User Class for performing numerical integration of a function in one dimension.
69It uses the plug-in manager to load advanced numerical integration algorithms from GSL, which reimplements the
70algorithms used in the QUADPACK, a numerical integration package written in Fortran.
71
72Various types of adaptive and non-adaptive integration are supported. These include
73integration over infinite and semi-infinite ranges and singular integrals.
74
75The integration type is selected using the Integration::type enumeration
76in the class constructor.
77The default type is adaptive integration with singularity
78(ADAPTIVESINGULAR or QAGS in the QUADPACK convention) applying a Gauss-Kronrod 21-point integration rule.
79In the case of ADAPTIVE type, the integration rule can also be specified via the
80Integration::GKRule. The default rule is 31 points.
81
82In the case of integration over infinite and semi-infinite ranges, the type used is always
83ADAPTIVESINGULAR applying a transformation from the original interval into (0,1).
84
85The ADAPTIVESINGULAR type is the most sophisticated type. When performances are
86important, it is then recommended to use the NONADAPTIVE type in case of smooth functions or
87 ADAPTIVE with a lower Gauss-Kronrod rule.
88
89For detailed description on GSL integration algorithms see the
90<A HREF="http://www.gnu.org/software/gsl/manual/gsl-ref_16.html#SEC248">GSL Manual</A>.
91
92
93@ingroup Integration
94
95*/
96
97
99
100public:
101
102 typedef IntegrationOneDim::Type Type; // for the enumerations defining the types
103
104 // constructors
105
106
107 /**
108 Constructor of one dimensional Integrator, default type is adaptive
109
110 @param type integration type (adaptive, non-adaptive, etc..)
111 @param absTol desired absolute Error
112 @param relTol desired relative Error
113 @param size maximum number of sub-intervals
114 @param rule Gauss-Kronrod integration rule (only for GSL kADAPTIVE type)
115
116 Possible type values are : kGAUSS (simple Gauss method), kADAPTIVE (from GSL), kADAPTIVESINGULAR (from GSL), kNONADAPTIVE (from GSL)
117 Possible rule values are kGAUS15 (rule = 1), kGAUS21( rule = 2), kGAUS31(rule =3), kGAUS41 (rule=4), kGAUS51 (rule =5), kGAUS61(rule =6)
118 lower rules are indicated for singular functions while higher for smooth functions to get better accuracies
119
120 NOTE: When the default values are passed, the values used are taken from the default defined in ROOT::Math::IntegratorOneDimOptions
121 */
122 explicit
123 IntegratorOneDim(IntegrationOneDim::Type type = IntegrationOneDim::kDEFAULT, double absTol = -1, double relTol = -1, unsigned int size = 0, unsigned int rule = 0) :
124 fIntegrator(0), fFunc(0)
125 {
126 fIntegrator = CreateIntegrator(type, absTol, relTol, size, rule);
127 }
128
129 /**
130 Constructor of one dimensional Integrator passing a function interface
131
132 @param f integration function (1D interface). It is copied inside
133 @param type integration type (adaptive, non-adaptive, etc..)
134 @param absTol desired absolute tolerance. The algorithm will stop when either the absolute OR the relative tolerance are satisfied.
135 @param relTol desired relative tolerance
136 @param size maximum number of sub-intervals
137 @param rule Gauss-Kronrod integration rule (only for GSL ADAPTIVE type)
138
139 NOTE: When no values are passed, the values used are taken from the default defined in ROOT::Math::IntegratorOneDimOptions
140 */
141 explicit
142 IntegratorOneDim(const IGenFunction &f, IntegrationOneDim::Type type = IntegrationOneDim::kDEFAULT, double absTol = -1, double relTol = -1, unsigned int size = 0, int rule = 0) :
143 fIntegrator(0), fFunc(0)
144 {
145 fIntegrator = CreateIntegrator(type, absTol, relTol, size, rule);
146 SetFunction(f,true);
147 }
148
149 /**
150 Template Constructor of one dimensional Integrator passing a generic function object
151
152 @param f integration function (any C++ callable object implementing operator()(double x)
153 @param type integration type (adaptive, non-adaptive, etc..)
154 @param absTol desired absolute tolerance. The algorithm will stop when either the absolute OR the relative tolerance are satisfied.
155 @param relTol desired relative tolerance
156 @param size maximum number of sub-intervals
157 @param rule Gauss-Kronrod integration rule (only for GSL ADAPTIVE type)
158
159 NOTE: When no values are passed, the values used are taken from the default defined in ROOT::Math::IntegratorOneDimOptions
160
161 */
162
163 template<class Function>
164 explicit
165 IntegratorOneDim(Function & f, IntegrationOneDim::Type type = IntegrationOneDim::kDEFAULT, double absTol = -1, double relTol = -1, unsigned int size = 0, int rule = 0) :
166 fIntegrator(0), fFunc(0)
167 {
168 fIntegrator = CreateIntegrator(type, absTol, relTol, size, rule);
169 SetFunction(f);
170 }
171
172 /// destructor (will delete contained pointers)
174 if (fIntegrator) delete fIntegrator;
175 if (fFunc) delete fFunc;
176 }
177
178 // disable copy constructor and assignment operator
179
180private:
182 IntegratorOneDim & operator=(const IntegratorOneDim &) { return *this; }
183
184public:
185
186
187 // template methods for generic functors
188
189 /**
190 method to set the a generic integration function
191 @param f integration function. The function type must implement the assignment operator, <em> double operator() ( double x ) </em>
192
193 */
194
195
196 template<class Function>
197 inline void SetFunction(Function & f);
198
199 /**
200 set one dimensional function for 1D integration
201 */
202 void SetFunction (const IGenFunction &f, bool copy = false) {
203 if (!fIntegrator) return;
204 if (copy) {
205 if (fFunc) delete fFunc;
206 fFunc = f.Clone();
208 return;
209 }
211 }
212
213
214 /**
215 Set integration function from a multi-dim function type.
216 Can be used in case of having 1D function implementing the generic interface
217 @param f integration function
218 @param icoord index of coordinate on which the integration is performed
219 @param x array of the passed variables values. In case of dim=1 a 0 can be passed
220 */
221 void SetFunction(const IMultiGenFunction &f, unsigned int icoord , const double * x );
222
223 // integration methods using a function
224
225 /**
226 evaluate the Integral of a function f over the defined interval (a,b)
227 @param f integration function. The function type must be a C++ callable object implementing operator()(double x)
228 @param a lower value of the integration interval
229 @param b upper value of the integration interval
230 */
231 template<class Function>
232 double Integral(Function & f, double a, double b);
233
234
235 /**
236 evaluate the Integral of a function f over the defined interval (a,b)
237 @param f integration function. The function type must implement the mathlib::IGenFunction interface
238 @param a lower value of the integration interval
239 @param b upper value of the integration interval
240 */
241 double Integral(const IGenFunction & f, double a, double b) {
242 SetFunction(f,false);
243 return Integral(a,b);
244 }
245
246
247 /**
248 evaluate the Integral of a function f over the infinite interval (-inf,+inf)
249 @param f integration function. The function type must be a C++ callable object implementing operator()(double x)
250 */
251// template<class Function>
252// double Integral(const Function & f);
253
254 /**
255 evaluate the Integral of a function f over the infinite interval (-inf,+inf)
256 @param f integration function. The function type must implement the mathlib::IGenFunction interface
257 */
258 double Integral(const IGenFunction & f) {
259 SetFunction(f,false);
260 return Integral();
261 }
262
263
264 /**
265 evaluate the Integral of a function f over the semi-infinite interval (a,+inf)
266 @param f integration function. The function type must be a C++ callable object implementing operator()(double x)
267 @param a lower value of the integration interval
268 */
269// template<class Function>
270// double IntegralUp(Function & f, double a);
271
272 /**
273 evaluate the Integral of a function f over the semi-infinite interval (a,+inf)
274 @param f integration function. The function type must implement the mathlib::IGenFunction interface
275 @param a lower value of the integration interval
276
277 */
278 double IntegralUp(const IGenFunction & f, double a ) {
279 SetFunction(f,false);
280 return IntegralUp(a);
281 }
282
283 /**
284 evaluate the Integral of a function f over the over the semi-infinite interval (-inf,b)
285 @param f integration function. The function type must be a C++ callable object implementing operator()(double x)
286 @param b upper value of the integration interval
287 */
288// template<class Function>
289// double IntegralLow(Function & f, double b);
290
291 /**
292 evaluate the Integral of a function f over the over the semi-infinite interval (-inf,b)
293 @param f integration function. The function type must implement the mathlib::IGenFunction interface
294 @param b upper value of the integration interval
295 */
296 double IntegralLow(const IGenFunction & f, double b ) {
297 SetFunction(f,false);
298 return IntegralLow(b);
299 }
300
301 /**
302 evaluate the Integral of a function f with known singular points over the defined Integral (a,b)
303 @param f integration function. The function type must be a C++ callable object implementing operator()(double x)
304 @param pts vector containing both the function singular points and the lower/upper edges of the interval. The vector must have as first element the lower edge of the integration Integral ( \a a) and last element the upper value.
305
306 */
307 template<class Function>
308 double Integral(Function & f, const std::vector<double> & pts );
309
310 /**
311 evaluate the Integral of a function f with known singular points over the defined Integral (a,b)
312 @param f integration function. The function type must implement the mathlib::IGenFunction interface
313 @param pts vector containing both the function singular points and the lower/upper edges of the interval. The vector must have as first element the lower edge of the integration Integral ( \a a) and last element the upper value.
314
315 */
316 double Integral(const IGenFunction & f, const std::vector<double> & pts ) {
317 SetFunction(f,false);
318 return Integral(pts);
319 }
320
321 /**
322 evaluate the Cauchy principal value of the integral of a function f over the defined interval (a,b) with a singularity at c
323 @param f integration function. The function type must be a C++ callable object implementing operator()(double x)
324 @param a lower value of the integration interval
325 @param b upper value of the integration interval
326 @param c position of singularity
327
328 */
329 template<class Function>
330 double IntegralCauchy(Function & f, double a, double b, double c);
331
332 /**
333 evaluate the Cauchy principal value of the integral of a function f over the defined interval (a,b) with a singularity at c
334 @param f integration function. The function type must implement the mathlib::IGenFunction interface
335 @param a lower value of the integration interval
336 @param b upper value of the integration interval
337 @param c position of singularity
338
339 */
340 double IntegralCauchy(const IGenFunction & f, double a, double b, double c) {
341 SetFunction(f,false);
342 return IntegralCauchy(a,b,c);
343 }
344
345
346
347 // integration method using cached function
348
349 /**
350 evaluate the Integral over the defined interval (a,b) using the function previously set with Integrator::SetFunction method
351 @param a lower value of the integration interval
352 @param b upper value of the integration interval
353 */
354
355 double Integral(double a, double b) {
356 return fIntegrator == 0 ? 0 : fIntegrator->Integral(a,b);
357 }
358
359
360 /**
361 evaluate the Integral over the infinite interval (-inf,+inf) using the function previously set with Integrator::SetFunction method.
362 */
363
364 double Integral( ) {
365 return fIntegrator == 0 ? 0 : fIntegrator->Integral();
366 }
367
368 /**
369 evaluate the Integral of a function f over the semi-infinite interval (a,+inf) using the function previously set with Integrator::SetFunction method.
370 @param a lower value of the integration interval
371 */
372 double IntegralUp(double a ) {
373 return fIntegrator == 0 ? 0 : fIntegrator->IntegralUp(a);
374 }
375
376 /**
377 evaluate the Integral of a function f over the over the semi-infinite interval (-inf,b) using the function previously set with Integrator::SetFunction method.
378 @param b upper value of the integration interval
379 */
380 double IntegralLow( double b ) {
381 return fIntegrator == 0 ? 0 : fIntegrator->IntegralLow(b);
382 }
383 /**
384 define operator() for IntegralLow
385 */
386 double operator() (double x) {
387 return IntegralLow(x);
388 }
389
390
391 /**
392 evaluate the Integral over the defined interval (a,b) using the function previously set with Integrator::SetFunction method. The function has known singular points.
393 @param pts vector containing both the function singular points and the lower/upper edges of the interval. The vector must have as first element the lower edge of the integration Integral ( \a a) and last element the upper value.
394
395 */
396 double Integral( const std::vector<double> & pts) {
397 return fIntegrator == 0 ? 0 : fIntegrator->Integral(pts);
398 }
399
400 /**
401 evaluate the Cauchy principal value of the integral of a function f over the defined interval (a,b) with a singularity at c
402
403 */
404 double IntegralCauchy(double a, double b, double c) {
405 return fIntegrator == 0 ? 0 : fIntegrator->IntegralCauchy(a,b,c);
406 }
407
408 /**
409 return the Result of the last Integral calculation
410 */
411 double Result() const { return fIntegrator == 0 ? 0 : fIntegrator->Result(); }
412
413 /**
414 return the estimate of the absolute Error of the last Integral calculation
415 */
416 double Error() const { return fIntegrator == 0 ? 0 : fIntegrator->Error(); }
417
418 /**
419 return the Error Status of the last Integral calculation
420 */
421 int Status() const { return fIntegrator == 0 ? -1 : fIntegrator->Status(); }
422
423 /**
424 return number of function evaluations in calculating the integral
425 (if integrator do not implement this function returns -1)
426 */
427 int NEval() const { return fIntegrator == 0 ? -1 : fIntegrator->NEval(); }
428
429
430 // setter for control Parameters (getters are not needed so far )
431
432 /**
433 set the desired relative Error
434 */
435 void SetRelTolerance(double relTolerance) { if (fIntegrator) fIntegrator->SetRelTolerance(relTolerance); }
436
437
438 /**
439 set the desired absolute Error
440 */
441 void SetAbsTolerance(double absTolerance) { if (fIntegrator) fIntegrator->SetAbsTolerance(absTolerance); }
442
443 /**
444 return a pointer to integrator object
445 */
447
448 /**
449 set the options
450 */
452
453 /**
454 retrieve the options
455 */
457
458 /// return name of integrator
459 std::string Name() const { return (fIntegrator) ? Options().Integrator() : std::string(""); }
460
461 /// static function to get the enumeration from a string
462 static IntegrationOneDim::Type GetType(const char * name);
463
464 /// static function to get a string from the enumeration
465 static std::string GetName(IntegrationOneDim::Type);
466
467
468protected:
469
470 VirtualIntegratorOneDim * CreateIntegrator(IntegrationOneDim::Type type , double absTol, double relTol, unsigned int size, int rule);
471
472private:
473
474 VirtualIntegratorOneDim * fIntegrator; ///< pointer to integrator interface class
475 IGenFunction * fFunc; ///< pointer to owned function
476
477};
478
479
481
482
483} // namespace Math
484} // namespace ROOT
485
486
487#ifndef __CINT__
488
489
490#include "Math/WrappedFunction.h"
491
492template<class Function>
495 // need to copy the wrapper function, the instance created here will be deleted after SetFunction()
496 SetFunction(wf, true);
497}
498
499template<class Function>
502 SetFunction(wf,false); // no copy is needed in this case
503 return Integral(a,b);
504}
505
506// remove because can create ambiguities
507
508// template<class Function>
509// double ROOT::Math::IntegratorOneDim::Integral(const Function & f) {
510// ROOT::Math::WrappedFunction<const Function &> wf(f);
511// SetFunction(wf,false); // no copy is needed in this case
512// return Integral();
513// }
514
515// template<class Function>
516// double ROOT::Math::IntegratorOneDim::IntegralLow(Function & f, double x) {
517// ROOT::Math::WrappedFunction< Function &> wf(f);
518// SetFunction(wf,false); // no copy is needed in this case
519// return IntegralLow(x);
520// }
521
522// template<class Function>
523// double ROOT::Math::IntegratorOneDim::IntegralUp(Function & f, double x) {
524// ROOT::Math::WrappedFunction<Function &> wf(f);
525// SetFunction(wf,false); // no copy is needed in this case
526// return IntegralUp(x);
527// }
528
529template<class Function>
530double ROOT::Math::IntegratorOneDim::Integral(Function & f, const std::vector<double> & pts) {
532 SetFunction(wf,false); // no copy is needed in this case
533 return Integral(pts);
534}
535
536template<class Function>
537double ROOT::Math::IntegratorOneDim::IntegralCauchy(Function & f, double a, double b, double c) {
539 SetFunction(wf,false); // no copy is needed in this case
540 return IntegralCauchy(a,b,c);
541}
542
543
544#endif
545
546
547
548#endif /* ROOT_Math_Integrator */
#define b(i)
Definition: RSha256.hxx:100
#define f(i)
Definition: RSha256.hxx:104
#define c(i)
Definition: RSha256.hxx:101
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
int type
Definition: TGX11.cxx:121
Double_t(* Function)(Double_t)
Definition: Functor.C:4
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
Numerical one dimensional integration options.
std::string Integrator() const
name of 1D integrator
User Class for performing numerical integration of a function in one dimension.
Definition: Integrator.h:98
void SetAbsTolerance(double absTolerance)
set the desired absolute Error
Definition: Integrator.h:441
static std::string GetName(IntegrationOneDim::Type)
static function to get a string from the enumeration
Definition: Integrator.cxx:66
void SetFunction(const IGenFunction &f, bool copy=false)
set one dimensional function for 1D integration
Definition: Integrator.h:202
double Integral(const IGenFunction &f)
evaluate the Integral of a function f over the infinite interval (-inf,+inf)
Definition: Integrator.h:258
IntegratorOneDim(IntegrationOneDim::Type type=IntegrationOneDim::kDEFAULT, double absTol=-1, double relTol=-1, unsigned int size=0, unsigned int rule=0)
Constructor of one dimensional Integrator, default type is adaptive.
Definition: Integrator.h:123
double IntegralCauchy(const IGenFunction &f, double a, double b, double c)
evaluate the Cauchy principal value of the integral of a function f over the defined interval (a,...
Definition: Integrator.h:340
double operator()(double x)
define operator() for IntegralLow
Definition: Integrator.h:386
void SetRelTolerance(double relTolerance)
set the desired relative Error
Definition: Integrator.h:435
VirtualIntegratorOneDim * fIntegrator
pointer to integrator interface class
Definition: Integrator.h:474
std::string Name() const
return name of integrator
Definition: Integrator.h:459
VirtualIntegratorOneDim * GetIntegrator()
return a pointer to integrator object
Definition: Integrator.h:446
double IntegralLow(double b)
evaluate the Integral of a function f over the over the semi-infinite interval (-inf,...
Definition: Integrator.h:380
double IntegralUp(double a)
evaluate the Integral of a function f over the semi-infinite interval (a,+inf) using the function pre...
Definition: Integrator.h:372
int Status() const
return the Error Status of the last Integral calculation
Definition: Integrator.h:421
double Result() const
return the Result of the last Integral calculation
Definition: Integrator.h:411
virtual ~IntegratorOneDim()
destructor (will delete contained pointers)
Definition: Integrator.h:173
VirtualIntegratorOneDim * CreateIntegrator(IntegrationOneDim::Type type, double absTol, double relTol, unsigned int size, int rule)
Definition: Integrator.cxx:114
void SetOptions(const ROOT::Math::IntegratorOneDimOptions &opt)
set the options
Definition: Integrator.h:451
IGenFunction * fFunc
pointer to owned function
Definition: Integrator.h:475
ROOT::Math::IntegratorOneDimOptions Options() const
retrieve the options
Definition: Integrator.h:456
double IntegralUp(const IGenFunction &f, double a)
evaluate the Integral of a function f over the semi-infinite interval (a,+inf)
Definition: Integrator.h:278
void SetFunction(Function &f)
method to set the a generic integration function
Definition: Integrator.h:493
double Integral(const IGenFunction &f, double a, double b)
evaluate the Integral of a function f over the defined interval (a,b)
Definition: Integrator.h:241
int NEval() const
return number of function evaluations in calculating the integral (if integrator do not implement thi...
Definition: Integrator.h:427
double IntegralCauchy(Function &f, double a, double b, double c)
evaluate the Cauchy principal value of the integral of a function f over the defined interval (a,...
Definition: Integrator.h:537
double IntegralCauchy(double a, double b, double c)
evaluate the Cauchy principal value of the integral of a function f over the defined interval (a,...
Definition: Integrator.h:404
IntegrationOneDim::Type Type
Definition: Integrator.h:102
double Error() const
return the estimate of the absolute Error of the last Integral calculation
Definition: Integrator.h:416
double Integral(double a, double b)
evaluate the Integral over the defined interval (a,b) using the function previously set with Integrat...
Definition: Integrator.h:355
IntegratorOneDim(Function &f, IntegrationOneDim::Type type=IntegrationOneDim::kDEFAULT, double absTol=-1, double relTol=-1, unsigned int size=0, int rule=0)
Template Constructor of one dimensional Integrator passing a generic function object.
Definition: Integrator.h:165
IntegratorOneDim(const IGenFunction &f, IntegrationOneDim::Type type=IntegrationOneDim::kDEFAULT, double absTol=-1, double relTol=-1, unsigned int size=0, int rule=0)
Constructor of one dimensional Integrator passing a function interface.
Definition: Integrator.h:142
double Integral(const IGenFunction &f, const std::vector< double > &pts)
evaluate the Integral of a function f with known singular points over the defined Integral (a,...
Definition: Integrator.h:316
IntegratorOneDim(const IntegratorOneDim &)
Definition: Integrator.h:181
double Integral(const std::vector< double > &pts)
evaluate the Integral over the defined interval (a,b) using the function previously set with Integrat...
Definition: Integrator.h:396
double IntegralLow(const IGenFunction &f, double b)
evaluate the Integral of a function f over the over the semi-infinite interval (-inf,...
Definition: Integrator.h:296
double Integral()
evaluate the Integral over the infinite interval (-inf,+inf) using the function previously set with I...
Definition: Integrator.h:364
IntegratorOneDim & operator=(const IntegratorOneDim &)
Definition: Integrator.h:182
static IntegrationOneDim::Type GetType(const char *name)
static function to get the enumeration from a string
Definition: Integrator.cxx:53
Interface (abstract) class for 1D numerical integration It must be implemented by the concrete Integr...
virtual ROOT::Math::IntegratorOneDimOptions Options() const =0
get the option used for the integration must be implemented by derived class
virtual void SetFunction(const IGenFunction &)=0
set integration function
virtual double IntegralCauchy(double a, double b, double c)=0
evaluate Cauchy integral
virtual double IntegralLow(double b)=0
evaluate integral over the (-inf, b)
virtual void SetOptions(const ROOT::Math::IntegratorOneDimOptions &opt)
set the options (should be re-implemented by derived classes -if more options than tolerance exist
virtual double Integral(double a, double b)=0
evaluate integral
virtual double IntegralUp(double a)=0
evaluate integral over the (a, +inf)
virtual void SetRelTolerance(double)=0
set the desired relative Error
virtual void SetAbsTolerance(double)=0
set the desired absolute Error
virtual double Error() const =0
return the estimate of the absolute Error of the last Integral calculation
virtual int NEval() const
return number of function evaluations in calculating the integral (if integrator do not implement thi...
virtual double Result() const =0
return the Result of the last Integral calculation
virtual int Status() const =0
return the Error Status of the last Integral calculation
Template class to wrap any C++ callable object which takes one argument i.e.
Type
enumeration specifying the integration types.
@ kDEFAULT
default type specifiend in the static options
Double_t x[n]
Definition: legend1.C:17
Namespace for new Math classes and functions.
IntegratorOneDim Integrator
Definition: Integrator.h:480
static const std::string name("name")
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...
Definition: RNumpyDS.hxx:30
auto * a
Definition: textangle.C:12