Logo ROOT   6.19/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 
19 #include "Math/IntegratorOptions.h"
20 
21 #include "Math/IFunction.h"
22 
23 #include "Math/VirtualIntegrator.h"
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 
41 Classes for numerical integration of functions.
42 These classes provide algorithms for integration of one-dimensional functions, with several adaptive and non-adaptive methods
43 and for integration of multi-dimensional function using an adaptive method or MonteCarlo Integration (GSLMCIntegrator).
44 The basic classes ROOT::Math::IntegratorOneDim provides a common interface for the one-dimensional methods while the class
45 ROOT::Math::IntegratorMultiDim provides the interface for the multi-dimensional ones.
46 The methods can be configured (e.g setting the default method with its defult parameters) using the ROOT::Math::IntegratorOneDimOptions and
47 ROOT::Math::IntegratorMultiDimOptions classes.
48 
49 @ingroup NumAlgo
50 
51 */
52 
53 
54 
55 namespace ROOT {
56 namespace Math {
57 
58 
59 
60 
61 //____________________________________________________________________________________________
62 /**
63 
64 User Class for performing numerical integration of a function in one dimension.
65 It uses the plug-in manager to load advanced numerical integration algorithms from GSL, which reimplements the
66 algorithms used in the QUADPACK, a numerical integration package written in Fortran.
67 
68 Various types of adaptive and non-adaptive integration are supported. These include
69 integration over infinite and semi-infinite ranges and singular integrals.
70 
71 The integration type is selected using the Integration::type enumeration
72 in the class constructor.
73 The default type is adaptive integration with singularity
74 (ADAPTIVESINGULAR or QAGS in the QUADPACK convention) applying a Gauss-Kronrod 21-point integration rule.
75 In the case of ADAPTIVE type, the integration rule can also be specified via the
76 Integration::GKRule. The default rule is 31 points.
77 
78 In the case of integration over infinite and semi-infinite ranges, the type used is always
79 ADAPTIVESINGULAR applying a transformation from the original interval into (0,1).
80 
81 The ADAPTIVESINGULAR type is the most sophicticated type. When performances are
82 important, it is then recommened to use the NONADAPTIVE type in case of smooth functions or
83  ADAPTIVE with a lower Gauss-Kronrod rule.
84 
85 For 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 
96 public:
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)
169  virtual ~IntegratorOneDim() {
170  if (fIntegrator) delete fIntegrator;
171  if (fFunc) delete fFunc;
172  }
173 
174  // disable copy constructur and assignment operator
175 
176 private:
178  IntegratorOneDim & operator=(const IntegratorOneDim &) { return *this; }
179 
180 public:
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 
464 protected:
465 
466  VirtualIntegratorOneDim * CreateIntegrator(IntegrationOneDim::Type type , double absTol, double relTol, unsigned int size, int rule);
467 
468 private:
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 
488 template<class Function>
491  // need to copy the wrapper function, the instance created here will be deleted after SetFunction()
492  SetFunction(wf, true);
493 }
494 
495 template<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 
525 template<class Function>
526 double 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 
532 template<class Function>
533 double 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 */
IntegratorOneDim & operator=(const IntegratorOneDim &)
Definition: Integrator.h:178
virtual void SetRelTolerance(double)=0
set the desired relative Error
Interface (abstract) class for 1D numerical integration It must be implemented by the concrate Integr...
void SetRelTolerance(double relTolerance)
set the desired relative Error
Definition: Integrator.h:431
Interface (abstract class) for generic functions objects of one-dimension Provides a method to evalua...
Definition: IFunction.h:135
double Integral()
evaluate the Integral over the infinite interval (-inf,+inf) using the function previously set with I...
Definition: Integrator.h:360
void SetFunction(const IGenFunction &f, bool copy=false)
set one dimensional function for 1D integration
Definition: Integrator.h:198
double operator()(double x)
define operator() for IntegralLow
Definition: Integrator.h:382
Namespace for new ROOT classes and functions.
Definition: StringConv.hxx:21
int Status() const
return the Error Status of the last Integral calculation
Definition: Integrator.h:417
IntegratorOneDim Integrator
Definition: Integrator.h:476
virtual double Result() const =0
return the Result of the last Integral calculation
#define f(i)
Definition: RSha256.hxx:104
virtual void SetFunction(const IGenFunction &)=0
set integration function
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 std::vector< double > &pts)
evaluate the Integral over the defined interval (a,b) using the function previously set with Integrat...
Definition: Integrator.h:392
virtual ROOT::Math::IntegratorOneDimOptions Options() const =0
get the option used for the integration must be implemented by derived class
virtual double Error() const =0
return the estimate of the absolute Error of the last Integral calculation
void SetAbsTolerance(double absTolerance)
set the desired absolute Error
Definition: Integrator.h:437
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
Template class to wrap any C++ callable object which takes one argument i.e.
virtual double IntegralLow(double b)=0
evaluate integral over the (-inf, b)
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
Double_t x[n]
Definition: legend1.C:17
IntegratorOneDim(const IntegratorOneDim &)
Definition: Integrator.h:177
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
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 IntegralCauchy(double a, double b, double c)=0
evaluate Cauchy integral
double Error() const
return the estimate of the absolute Error of the last Integral calculation
Definition: Integrator.h:412
virtual double Integral(double a, double b)=0
evaluate integral
double IntegralLow(double b)
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.
Definition: Integrator.h:376
double IntegralLow(const IGenFunction &f, double b)
evaluate the Integral of a function f over the over the semi-infinite interval (-inf,b)
Definition: Integrator.h:292
Documentation for the abstract class IBaseFunctionMultiDim.
Definition: IFunction.h:62
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
IntegrationOneDim::Type Type
Definition: Integrator.h:98
Double_t(* Function)(Double_t)
Definition: Functor.C:4
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
auto * a
Definition: textangle.C:12
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
Numerical one dimensional integration options.
static IntegrationOneDim::Type GetType(const char *name)
static function to get the enumeration from a string
Definition: Integrator.cxx:53
User Class for performing numerical integration of a function in one dimension.
Definition: Integrator.h:94
VirtualIntegratorOneDim * GetIntegrator()
return a pointer to integrator object
Definition: Integrator.h:442
VirtualIntegratorOneDim * fIntegrator
Definition: Integrator.h:470
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
double Integral(const IGenFunction &f)
evaluate the Integral of a function f over the infinite interval (-inf,+inf)
Definition: Integrator.h:254
virtual int Status() const =0
return the Error Status of the last Integral calculation
void SetOptions(const ROOT::Math::IntegratorOneDimOptions &opt)
set the options
Definition: Integrator.h:447
Type
enumeration specifying the integration types.
virtual int NEval() const
return number of function evaluations in calculating the integral (if integrator do not implement thi...
ROOT::Math::IntegratorOneDimOptions Options() const
retrieve the options
Definition: Integrator.h:452
std::string Name() const
return name of integrator
Definition: Integrator.h:455
virtual ~IntegratorOneDim()
destructor (will delete contained pointers)
Definition: Integrator.h:169
int type
Definition: TGX11.cxx:120
static std::string GetName(IntegrationOneDim::Type)
static function to get a string from the enumeration
Definition: Integrator.cxx:66
std::string Integrator() const
name of 1D integrator
Namespace for new Math classes and functions.
virtual double IntegralUp(double a)=0
evaluate integral over the (a, +inf)
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
virtual void SetAbsTolerance(double)=0
set the desired absolute Error
void SetFunction(Function &f)
method to set the a generic integration function
Definition: Integrator.h:489
int NEval() const
return number of function evaluations in calculating the integral (if integrator do not implement thi...
Definition: Integrator.h:423
you should not use this method at all Int_t Int_t Double_t Double_t Double_t Int_t Double_t Double_t Double_t Double_t b
Definition: TRolke.cxx:630
#define c(i)
Definition: RSha256.hxx:101
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 Result() const
return the Result of the last Integral calculation
Definition: Integrator.h:407
VirtualIntegratorOneDim * CreateIntegrator(IntegrationOneDim::Type type, double absTol, double relTol, unsigned int size, int rule)
Definition: Integrator.cxx:114
char name[80]
Definition: TGX11.cxx:109
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