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 size = 100000)
ROOT::Math::AdaptiveIntegratorMultiDim	AdaptiveIntegratorMultiDim(const ROOT::Math::IMultiGenFunction& f, double absTol = 1.E-9, double relTol = 1E-6, unsigned int size = 100000)
virtual double	Error() const
virtual double	ROOT::Math::VirtualIntegrator::Error() const
virtual double	Integral(const double* xmin, const double* xmax)
virtual double	ROOT::Math::VirtualIntegratorMultiDim::Integral(const double, const double)
double	Integral(const ROOT::Math::IMultiGenFunction& f, const double* xmin, const double* xmax)
unsigned int	NEval() const
ROOT::Math::VirtualIntegratorMultiDim&	ROOT::Math::VirtualIntegratorMultiDim::operator=(const ROOT::Math::VirtualIntegratorMultiDim&)
ROOT::Math::VirtualIntegrator&	ROOT::Math::VirtualIntegrator::operator=(const ROOT::Math::VirtualIntegrator&)
double	RelError() const
virtual double	Result() const
virtual double	ROOT::Math::VirtualIntegrator::Result() const
virtual void	SetAbsTolerance(double absTol)
virtual void	ROOT::Math::VirtualIntegrator::SetAbsTolerance(double)
virtual void	SetFunction(const ROOT::Math::IMultiGenFunction& f)
virtual void	ROOT::Math::VirtualIntegratorMultiDim::SetFunction(const ROOT::Math::IMultiGenFunction&)
virtual void	SetRelTolerance(double relTol)
virtual void	ROOT::Math::VirtualIntegrator::SetRelTolerance(double)
virtual int	Status() const
virtual int	ROOT::Math::VirtualIntegrator::Status() const

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	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 size = 100000)

      construct given optionally tolerance (absolute and relative) and maximum size of 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.

AdaptiveIntegratorMultiDim(const ROOT::Math::IMultiGenFunction& f, double absTol = 1.E-9, double relTol = 1E-6, unsigned int size = 100000)

      construct with a reference to the integrand function and given optionally
      tolerance (absolute and relative) and maximum size of 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[]

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 funciton 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; }

unsigned 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