Quick Links: ROOT Homepage Class Index Class Hierarchy

Sections: class description function members data members class charts

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::AdaptiveIntegratorMultiDim	AdaptiveIntegratorMultiDim(const ROOT::Math::AdaptiveIntegratorMultiDim&)
ROOT::Math::AdaptiveIntegratorMultiDim	AdaptiveIntegratorMultiDim(double absTol = 1.E-6, double relTol = 1E-6, unsigned int maxpts = 100000, unsigned int size = 0)
ROOT::Math::AdaptiveIntegratorMultiDim	AdaptiveIntegratorMultiDim(const ROOT::Math::IMultiGenFunction& f, double absTol = 1.E-9, double relTol = 1E-6, unsigned int maxcall = 100000, unsigned int size = 0)
virtual double	Error() const
virtual double	Integral(const double* xmin, const double* xmax)
double	Integral(const ROOT::Math::IMultiGenFunction& f, const double* xmin, const double* xmax)
virtual int	NEval() const
ROOT::Math::VirtualIntegratorMultiDim&	ROOT::Math::VirtualIntegratorMultiDim::operator=(const ROOT::Math::VirtualIntegratorMultiDim&)
virtual ROOT::Math::IntegratorMultiDimOptions	Options() const
double	RelError() const
virtual double	Result() const
virtual void	SetAbsTolerance(double absTol)
virtual void	SetFunction(const ROOT::Math::IMultiGenFunction& f)
void	SetMaxPts(unsigned int n)
void	SetMinPts(unsigned int n)
virtual void	SetOptions(const ROOT::Math::IntegratorMultiDimOptions& opt)
virtual void	SetRelTolerance(double relTol)
void	SetSize(unsigned int size)
virtual int	Status() const
virtual ROOT::Math::IntegrationMultiDim::Type	ROOT::Math::VirtualIntegratorMultiDim::Type() const

protected:

double

DoIntegral(const double* xmin, const double* xmax, bool absVal = false)

Data Members

private:

double	fAbsTol	absolute tolerance
unsigned int	fDim	dimentionality of integrand
double	fError	integration error
const ROOT::Math::IMultiGenFunction*	fFun	pointer to integrand function
unsigned int	fMaxPts	maximum number of function evaluation requested
unsigned int	fMinPts	minimum number of function evaluation requested
int	fNEval	number of function evaluation
double	fRelError	Relative error
double	fRelTol	relative tolerance
double	fResult	last integration result
unsigned int	fSize	max size of working array (explode with dimension)
int	fStatus	status of algorithm (error if not zero)

Class Charts

Inheritance Inherited Members Includes Libraries

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