Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
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@defgroup NumAlgo Numerical Algorithms
31
32Numerical Algorithm classes from the \ref MathCore and \ref MathMore libraries.
33
34@ingroup MathCore
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 default 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 sophisticated type. When performances are
82important, it is then recommended 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(nullptr), fFunc(nullptr)
121 {
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(nullptr), fFunc(nullptr)
140 {
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(nullptr), fFunc(nullptr)
163 {
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 constructor and assignment operator
175
176private:
177 IntegratorOneDim(const IntegratorOneDim &) : fIntegrator(nullptr), fFunc(nullptr) {}
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 assignment 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 : 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 : 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 : 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 : 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 : 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 : 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 : 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 : fIntegrator->Error(); }
413
414 /**
415 return the Error Status of the last Integral calculation
416 */
417 int Status() const { return !fIntegrator ? -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 ? -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 */
432
433
434 /**
435 set the desired absolute Error
436 */
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
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
484
485#include "Math/WrappedFunction.h"
486
487template<class Function>
490 // need to copy the wrapper function, the instance created here will be deleted after SetFunction()
491 SetFunction(wf, true);
492}
493
494template<class Function>
497 SetFunction(wf,false); // no copy is needed in this case
498 return Integral(a,b);
499}
500
501// remove because can create ambiguities
502
503// template<class Function>
504// double ROOT::Math::IntegratorOneDim::Integral(const Function & f) {
505// ROOT::Math::WrappedFunction<const Function &> wf(f);
506// SetFunction(wf,false); // no copy is needed in this case
507// return Integral();
508// }
509
510// template<class Function>
511// double ROOT::Math::IntegratorOneDim::IntegralLow(Function & f, double x) {
512// ROOT::Math::WrappedFunction< Function &> wf(f);
513// SetFunction(wf,false); // no copy is needed in this case
514// return IntegralLow(x);
515// }
516
517// template<class Function>
518// double ROOT::Math::IntegratorOneDim::IntegralUp(Function & f, double x) {
519// ROOT::Math::WrappedFunction<Function &> wf(f);
520// SetFunction(wf,false); // no copy is needed in this case
521// return IntegralUp(x);
522// }
523
524template<class Function>
525double ROOT::Math::IntegratorOneDim::Integral(Function & f, const std::vector<double> & pts) {
527 SetFunction(wf,false); // no copy is needed in this case
528 return Integral(pts);
529}
530
531template<class Function>
532double ROOT::Math::IntegratorOneDim::IntegralCauchy(Function & f, double a, double b, double c) {
534 SetFunction(wf,false); // no copy is needed in this case
535 return IntegralCauchy(a,b,c);
536}
537
538
539
540
541
542#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
#define a(i)
Definition RSha256.hxx:99
size_t size(const MatrixT &matrix)
retrieve the size of a square matrix
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t Float_t Float_t Int_t Int_t UInt_t UInt_t Rectangle_t Int_t Int_t Window_t TString Int_t GCValues_t GetPrimarySelectionOwner GetDisplay GetScreen GetColormap GetNativeEvent const char const char dpyName wid window const char font_name cursor keysym reg const char only_if_exist regb h Point_t winding char text const char depth char const char Int_t count const char ColorStruct_t color const char Pixmap_t Pixmap_t PictureAttributes_t attr const char char ret_data h unsigned char height h Atom_t Int_t ULong_t ULong_t unsigned char prop_list Atom_t Atom_t Atom_t Time_t type
char name[80]
Definition TGX11.cxx:110
Double_t(* Function)(Double_t)
Definition Functor.C:4
Documentation for the abstract class IBaseFunctionMultiDim.
Definition IFunction.h:63
Interface (abstract class) for generic functions objects of one-dimension Provides a method to evalua...
Definition IFunction.h:170
virtual IBaseFunctionOneDim * Clone() const =0
Clone a function.
Numerical one dimensional integration options.
std::string Integrator() const override
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
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
pointer to integrator interface class
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)
void SetOptions(const ROOT::Math::IntegratorOneDimOptions &opt)
set the options
Definition Integrator.h:447
IGenFunction * fFunc
pointer to owned function
Definition Integrator.h:471
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:488
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:532
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
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 specified in the static options
Double_t x[n]
Definition legend1.C:17
Namespace for new Math classes and functions.
IntegratorOneDim Integrator
Definition Integrator.h:476