class ROOT::Math::GaussLegendreIntegrator: public ROOT::Math::VirtualIntegratorOneDim


   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()
virtual double	Error() const
virtual double	ROOT::Math::VirtualIntegrator::Error() const
ROOT::Math::GaussLegendreIntegrator	GaussLegendreIntegrator(const ROOT::Math::GaussLegendreIntegrator&)
ROOT::Math::GaussLegendreIntegrator	GaussLegendreIntegrator(int num = 10, double eps = 1e-12)
void	GetWeightVectors(double* x, double* w)
virtual double	Integral()
virtual double	ROOT::Math::VirtualIntegratorOneDim::Integral()
virtual double	Integral(const vector<double>& pts)
virtual double	ROOT::Math::VirtualIntegratorOneDim::Integral(const vector<double>& pts)
virtual double	Integral(double a, double b)
virtual double	ROOT::Math::VirtualIntegratorOneDim::Integral(double a, double b)
virtual double	IntegralCauchy(double a, double b, double c)
virtual double	ROOT::Math::VirtualIntegratorOneDim::IntegralCauchy(double a, double b, double c)
virtual double	IntegralLow(double b)
virtual double	ROOT::Math::VirtualIntegratorOneDim::IntegralLow(double b)
virtual double	IntegralUp(double a)
virtual double	ROOT::Math::VirtualIntegratorOneDim::IntegralUp(double a)
ROOT::Math::VirtualIntegratorOneDim&	ROOT::Math::VirtualIntegratorOneDim::operator=(const ROOT::Math::VirtualIntegratorOneDim&)
ROOT::Math::VirtualIntegrator&	ROOT::Math::VirtualIntegrator::operator=(const ROOT::Math::VirtualIntegrator&)
virtual double	Result() const
virtual double	ROOT::Math::VirtualIntegrator::Result() const
virtual void	SetAbsTolerance(double)
virtual void	ROOT::Math::VirtualIntegrator::SetAbsTolerance(double)
virtual void	SetFunction(const ROOT::Math::IGenFunction&, bool copy = false)
virtual void	ROOT::Math::VirtualIntegratorOneDim::SetFunction(const ROOT::Math::IGenFunction&, bool copy = false)
void	SetNumberPoints(int num)
virtual void	SetRelTolerance(double)
virtual void	ROOT::Math::VirtualIntegrator::SetRelTolerance(double)
virtual int	Status() const
virtual int	ROOT::Math::VirtualIntegrator::Status() const

private:

void	CalcGaussLegendreSamplingPoints()

Data Members

protected:

double	fEpsilon	Desired relative error.
const ROOT::Math::IGenFunction*	fFunction	Pointer to function used.
bool	fFunctionCopied	Bool value to check if the function was copied when set.
double	fLastError	Error from the last stimation.
double	fLastResult	Result from the last stimation.
int	fNum	Number of points used in the stimation of the integral.
bool	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.

Class Charts

Inheritance Inherited Members Includes Libraries

Function documentation

GaussLegendreIntegrator(int num = 10, double eps = 1e-12)

 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 GetWeightVectors(double* x, double* w)

 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}

void SetRelTolerance(double )

 Implementing VirtualIntegrator Interface
 Set the desired relative Error.

void SetAbsTolerance(double )

 Absolute Tolerance is not used in this class.

double Result() const

 Returns the result of the last integral calculation.

double Error() const

 Return the estimate of the absolute Error of the last Integral calculation.

int Status() const

 This method is not implemented.

double Integral(double a, double b)

 Implementing VirtualIntegratorOneDim Interface
 Gauss-Legendre integral, see CalcGaussLegendreSamplingPoints.

void SetFunction(const ROOT::Math::IGenFunction& , bool copy = false)

 Set integration function (flag control if function must be copied inside).
       \@param f Function to be used in the calculations.
       \@param copy Indicates whether the function has to be copied.

double Integral()

 This method is not implemented.

double IntegralUp(double a)

 This method is not implemented.

double IntegralLow(double b)

This method is not implemented.

double Integral(const vector<double>& pts)

 This method is not implemented.

double IntegralCauchy(double a, double b, double c)

 This method is not implemented.

void CalcGaussLegendreSamplingPoints()

 Middle functions

      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