ROOT logo
ROOT » MATH » MATHCORE » ROOT::Math::AdaptiveIntegratorMultiDim

class ROOT::Math::AdaptiveIntegratorMultiDim: public ROOT::Math::VirtualIntegratorMultiDim


   class for adaptive quadrature integration in multi-dimensions
   Algorithm from  A.C. Genz, A.A. Malik, An adaptive algorithm for numerical integration over
   an N-dimensional rectangular region, J. Comput. Appl. Math. 6 (1980) 295-302.

   Converted/adapted by R.Brun to C++ from Fortran CERNLIB routine RADMUL (D120)
   The new code features many changes compared to the Fortran version.

   @ingroup Integration



Function Members (Methods)

public:
virtual~AdaptiveIntegratorMultiDim()
ROOT::Math::AdaptiveIntegratorMultiDimAdaptiveIntegratorMultiDim(const ROOT::Math::AdaptiveIntegratorMultiDim&)
ROOT::Math::AdaptiveIntegratorMultiDimAdaptiveIntegratorMultiDim(double absTol = 1.E-6, double relTol = 1E-6, unsigned int maxpts = 100000, unsigned int size = 0)
ROOT::Math::AdaptiveIntegratorMultiDimAdaptiveIntegratorMultiDim(const ROOT::Math::IMultiGenFunction& f, double absTol = 1.E-9, double relTol = 1E-6, unsigned int maxcall = 100000, unsigned int size = 0)
virtual doubleError() const
virtual doubleIntegral(const double* xmin, const double* xmax)
doubleIntegral(const ROOT::Math::IMultiGenFunction& f, const double* xmin, const double* xmax)
virtual intNEval() const
ROOT::Math::VirtualIntegratorMultiDim&ROOT::Math::VirtualIntegratorMultiDim::operator=(const ROOT::Math::VirtualIntegratorMultiDim&)
virtual ROOT::Math::IntegratorMultiDimOptionsOptions() const
doubleRelError() const
virtual doubleResult() const
virtual voidSetAbsTolerance(double absTol)
virtual voidSetFunction(const ROOT::Math::IMultiGenFunction& f)
voidSetMaxPts(unsigned int n)
voidSetMinPts(unsigned int n)
virtual voidSetOptions(const ROOT::Math::IntegratorMultiDimOptions& opt)
virtual voidSetRelTolerance(double relTol)
voidSetSize(unsigned int size)
virtual intStatus() const
virtual ROOT::Math::IntegrationMultiDim::TypeROOT::Math::VirtualIntegratorMultiDim::Type() const
protected:
doubleDoIntegral(const double* xmin, const double* xmax, bool absVal = false)

Data Members

private:
doublefAbsTolabsolute tolerance
unsigned intfDimdimentionality of integrand
doublefErrorintegration error
const ROOT::Math::IMultiGenFunction*fFunpointer to integrand function
unsigned intfMaxPtsmaximum number of function evaluation requested
unsigned intfMinPtsminimum number of function evaluation requested
intfNEvalnumber of function evaluation
doublefRelErrorRelative error
doublefRelTolrelative tolerance
doublefResultlast integration result
unsigned intfSizemax size of working array (explode with dimension)
intfStatusstatus of algorithm (error if not zero)

Class Charts

Inheritance Inherited Members Includes Libraries
Class Charts

Function documentation

AdaptiveIntegratorMultiDim(double absTol = 1.E-6, double relTol = 1E-6, unsigned int maxpts = 100000, unsigned int size = 0)
      construct given optionally tolerance (absolute and relative), maximum number of function evaluation (maxpts)  and
      size of the working array.
      The size of working array represents the number of sub-division used for calculating the integral.
      Higher the dimension, larger sizes are required for getting the same accuracy.
      The size must be larger than  >= (2N + 3) * (1 + MAXPTS/(2**N + 2N(N + 1) + 1))/2). For smaller value passed, the
      minimum allowed will be used

AdaptiveIntegratorMultiDim(const ROOT::Math::IMultiGenFunction& f, double absTol = 1.E-9, double relTol = 1E-6, unsigned int maxcall = 100000, unsigned int size = 0)
      Construct with a reference to the integrand function and given optionally
      tolerance (absolute and relative), maximum number of function evaluation (maxpts)  and
      size of the working array.

virtual ~AdaptiveIntegratorMultiDim()
      destructor (no operations)

{}
double Integral(const double* xmin, const double* xmax)
      evaluate the integral with the previously given function between xmin[] and xmax[]

return DoIntegral(const double* xmin, const double* xmax, bool absVal = false)
double Integral(const ROOT::Math::IMultiGenFunction& f, const double* xmin, const double* xmax)
 evaluate the integral passing a new function
void SetFunction(const ROOT::Math::IMultiGenFunction& f)
 set the integration function (must implement multi-dim function interface: IBaseFunctionMultiDim)
double Result() const
 return result of integration
{ return fResult; }
double Error() const
 return integration error
{ return fError; }
double RelError() const
 return relative error
{ return fRelError; }
int Status() const
 return status of integration
{ return fStatus; }
int NEval() const
 return number of function evaluations in calculating the integral
{ return fNEval; }
void SetRelTolerance(double relTol)
 set relative tolerance
void SetAbsTolerance(double absTol)
 set absolute tolerance
void SetSize(unsigned int size)
set workspace size
{ fSize = size; }
void SetMinPts(unsigned int n)
set min points
{ fMinPts = n; }
void SetMaxPts(unsigned int n)
set max points
{ fMaxPts = n; }
void SetOptions(const ROOT::Math::IntegratorMultiDimOptions& opt)
 set the options