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