class ROOT::Math::GaussLegendreIntegrator: public ROOT::Math::GaussIntegrator


   User class for performing function integration.

   It will use the Gauss-Legendre Method for function integration in a given interval.
   This class is implemented from TF1::Integral().

   @ingroup Integration

Function Members (Methods)

public:

virtual	~GaussLegendreIntegrator()
void	ROOT::Math::GaussIntegrator::AbsValue(bool flag)
virtual double	ROOT::Math::GaussIntegrator::Error() const
ROOT::Math::GaussIntegrator	ROOT::Math::GaussIntegrator::GaussIntegrator(const ROOT::Math::GaussIntegrator&)
ROOT::Math::GaussIntegrator	ROOT::Math::GaussIntegrator::GaussIntegrator(double absTol = 0, double relTol = 0)
ROOT::Math::GaussLegendreIntegrator	GaussLegendreIntegrator(const ROOT::Math::GaussLegendreIntegrator&)
ROOT::Math::GaussLegendreIntegrator	GaussLegendreIntegrator(int num = 10, double eps = 9.9999999999999998E-13)
int	GetNumberPoints() const
void	GetWeightVectors(double* x, double* w) const
virtual double	ROOT::Math::GaussIntegrator::Integral()
virtual double	ROOT::Math::GaussIntegrator::Integral(const vector<double>& pts)
virtual double	ROOT::Math::GaussIntegrator::Integral(double a, double b)
virtual double	ROOT::Math::GaussIntegrator::IntegralCauchy(double a, double b, double c)
virtual double	ROOT::Math::GaussIntegrator::IntegralLow(double b)
virtual double	ROOT::Math::GaussIntegrator::IntegralUp(double a)
virtual int	NEval() const
ROOT::Math::GaussLegendreIntegrator&	operator=(const ROOT::Math::GaussLegendreIntegrator&)
virtual ROOT::Math::IntegratorOneDimOptions	Options() const
virtual double	ROOT::Math::GaussIntegrator::Result() const
virtual void	SetAbsTolerance(double)
virtual void	ROOT::Math::GaussIntegrator::SetFunction(const ROOT::Math::IGenFunction&)
void	SetNumberPoints(int num)
virtual void	SetOptions(const ROOT::Math::IntegratorOneDimOptions& opt)
virtual void	SetRelTolerance(double)
virtual int	ROOT::Math::GaussIntegrator::Status() const
virtual ROOT::Math::IntegrationOneDim::Type	ROOT::Math::VirtualIntegratorOneDim::Type() const
ROOT::Math::VirtualIntegrator	ROOT::Math::VirtualIntegrator::VirtualIntegrator()
ROOT::Math::VirtualIntegrator	ROOT::Math::VirtualIntegrator::VirtualIntegrator(const ROOT::Math::VirtualIntegrator&)
ROOT::Math::VirtualIntegratorOneDim	ROOT::Math::VirtualIntegratorOneDim::VirtualIntegratorOneDim()
ROOT::Math::VirtualIntegratorOneDim	ROOT::Math::VirtualIntegratorOneDim::VirtualIntegratorOneDim(const ROOT::Math::VirtualIntegratorOneDim&)

private:

void	CalcGaussLegendreSamplingPoints()
virtual double	DoIntegral(double a, double b, const ROOT::Math::IGenFunction* func)

Data Members

protected:

double	ROOT::Math::GaussIntegrator::fEpsAbs	Absolute error.
double	ROOT::Math::GaussIntegrator::fEpsRel	Relative error.
const ROOT::Math::IGenFunction*	ROOT::Math::GaussIntegrator::fFunction	Pointer to function used.
double	ROOT::Math::GaussIntegrator::fLastError	Error from the last stimation.
double	ROOT::Math::GaussIntegrator::fLastResult	Result from the last stimation.
int	fNum	Number of points used in the stimation of the integral.
bool	ROOT::Math::GaussIntegrator::fUsedOnce	Bool value to check if the function was at least called once.
double*	fW	Weights of the points used.
double*	fX	Abscisa of the points used.
static bool	ROOT::Math::GaussIntegrator::fgAbsValue	AbsValue used for the calculation of the integral

Class Charts

Inheritance Inherited Members Includes Libraries

Function documentation

GaussLegendreIntegrator(int num = 10, double eps = 9.9999999999999998E-13)

 Basic contructor of GaussLegendreIntegrator.
       \@param num Number of desired points to calculate the integration.
       \@param eps Desired relative error.

virtual ~GaussLegendreIntegrator()

 Default Destructor

void SetNumberPoints(int num)

 Set the number of points used in the calculation of the
integral

void SetRelTolerance(double )

 Set the desired relative Error.

void SetAbsTolerance(double )

 This method is not implemented.

void GetWeightVectors(double* x, double* w) const

 Returns the arrays x and w containing the abscissa and weight of
       the Gauss-Legendre n-point quadrature formula.

       Gauss-Legendre: W(x)=1 -1<x<1
                       (j+1)P_{j+1} = (2j+1)xP_j-jP_{j-1}

int GetNumberPoints() const

{ return fNum; }

int NEval() const

       return number of function evaluations in calculating the integral
       This is equivalent to the number of points

{ return fNum; }

void SetOptions(const ROOT::Math::IntegratorOneDimOptions& opt)

 set the options

double DoIntegral(double a, double b, const ROOT::Math::IGenFunction* func)

      Integration surrugate method. Return integral of passed function in  interval [a,b]
      Reimplement method of GaussIntegrator using CalcGaussLegendreSamplingPoints

void CalcGaussLegendreSamplingPoints()

      Type: unsafe but fast interface filling the arrays x and w (static method)

      Given the number of sampling points this routine fills the arrays x and w
      of length num, containing the abscissa and weight of the Gauss-Legendre
      n-point quadrature formula.

      Gauss-Legendre: W(x)=1  -1<x<1
                      (j+1)P_{j+1} = (2j+1)xP_j-jP_{j-1}

      num is the number of sampling points (>0)
      x and w are arrays of size num
      eps is the relative precision

      If num<=0 or eps<=0 no action is done.

      Reference: Numerical Recipes in C, Second Edition