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/**
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(nullptr), fFunc(nullptr)
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(nullptr), fFunc(nullptr)
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(nullptr), fFunc(nullptr)
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:
181 IntegratorOneDim(const IntegratorOneDim &) : fIntegrator(nullptr), fFunc(nullptr) {}
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 : 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 : 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 : 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 : 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 : 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 : 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 : 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 : fIntegrator->Error(); }
417
418 /**
419 return the Error Status of the last Integral calculation
420 */
421 int Status() const { return !fIntegrator ? -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 ? -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
488
489#include "Math/WrappedFunction.h"
490
491template<class Function>
494 // need to copy the wrapper function, the instance created here will be deleted after SetFunction()
495 SetFunction(wf, true);
496}
497
498template<class Function>
501 SetFunction(wf,false); // no copy is needed in this case
502 return Integral(a,b);
503}
504
505// remove because can create ambiguities
506
507// template<class Function>
508// double ROOT::Math::IntegratorOneDim::Integral(const Function & f) {
509// ROOT::Math::WrappedFunction<const Function &> wf(f);
510// SetFunction(wf,false); // no copy is needed in this case
511// return Integral();
512// }
513
514// template<class Function>
515// double ROOT::Math::IntegratorOneDim::IntegralLow(Function & f, double x) {
516// ROOT::Math::WrappedFunction< Function &> wf(f);
517// SetFunction(wf,false); // no copy is needed in this case
518// return IntegralLow(x);
519// }
520
521// template<class Function>
522// double ROOT::Math::IntegratorOneDim::IntegralUp(Function & f, double x) {
523// ROOT::Math::WrappedFunction<Function &> wf(f);
524// SetFunction(wf,false); // no copy is needed in this case
525// return IntegralUp(x);
526// }
527
528template<class Function>
529double ROOT::Math::IntegratorOneDim::Integral(Function & f, const std::vector<double> & pts) {
531 SetFunction(wf,false); // no copy is needed in this case
532 return Integral(pts);
533}
534
535template<class Function>
536double ROOT::Math::IntegratorOneDim::IntegralCauchy(Function & f, double a, double b, double c) {
538 SetFunction(wf,false); // no copy is needed in this case
539 return IntegralCauchy(a,b,c);
540}
541
542
543
544
545
546#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
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:61
Interface (abstract class) for generic functions objects of one-dimension Provides a method to evalua...
Definition IFunction.h:112
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: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
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
IntegratorOneDim & operator=(const IntegratorOneDim &)
Definition Integrator.h:182
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)
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:492
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:536
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
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:480
This file contains a specialised ROOT message handler to test for diagnostic in unit tests.