```

```
RooAdaptiveGaussKronrodIntegrator1D implements the Gauss-Kronrod integration algorithm. An adaptive Gaussian quadrature method for numerical integration in which error is estimation based on evaluation at special points known as "Kronrod points." By suitably picking these points, abscissas from previous iterations can be reused as part of the new set of points, whereas usual Gaussian quadrature would require recomputation of all abscissas at each iteration. This class automatically handles (-inf,+inf) integrals by dividing the integration in three regions (-inf,-1), (-1,1), (1,inf) and calculating the 1st and 3rd term using a x -> 1/x coordinate transformation This class embeds the adaptive Gauss-Kronrod integrator from the GNU Scientific Library version 1.5 and applies a chosen rule ( 10-, 21-, 31-, 41, 51- or 61-point). The integration domain is subdivided and recursively integrated until the required precision is reached. For integrands with integrable singulaties the Wynn epsilon rule can be selected to speed up the converges of these integrals
```
```

## Function Members (Methods)

public:
protected:
 virtual void TObject::DoError(int level, const char* location, const char* fmt, va_list va) const Bool_t initialize() void TObject::MakeZombie() static void registerIntegrator(RooNumIntFactory& fact) Double_t* xvec(Double_t& xx)

## Data Members

public:
 static TObject::(anonymous) TObject::kBitMask static TObject::EStatusBits TObject::kCanDelete static TObject::EStatusBits TObject::kCannotPick static TObject::EStatusBits TObject::kHasUUID static TObject::EStatusBits TObject::kInvalidObject static TObject::(anonymous) TObject::kIsOnHeap static TObject::EStatusBits TObject::kIsReferenced static TObject::EStatusBits TObject::kMustCleanup static TObject::EStatusBits TObject::kNoContextMenu static TObject::(anonymous) TObject::kNotDeleted static TObject::EStatusBits TObject::kObjInCanvas static TObject::(anonymous) TObject::kOverwrite static TObject::(anonymous) TObject::kSingleKey static TObject::(anonymous) TObject::kWriteDelete static TObject::(anonymous) TObject::kZombie
protected:
 static RooAdaptiveGaussKronrodIntegrator1D::DomainType Closed static RooAdaptiveGaussKronrodIntegrator1D::DomainType Open static RooAdaptiveGaussKronrodIntegrator1D::DomainType OpenHi static RooAdaptiveGaussKronrodIntegrator1D::DomainType OpenLo RooAdaptiveGaussKronrodIntegrator1D::DomainType _domainType Double_t _epsAbs Absolute precision Double_t _epsRel Relative precision const RooAbsFunc* RooAbsIntegrator::_function Pointer to function binding of integrand Int_t _maxSeg Maximum number of segments Int_t _methodKey GSL method key Bool_t RooAbsIntegrator::_printEvalCounter If true print number of function evaluation required for integration Bool_t _useIntegrandLimits Bool_t RooAbsIntegrator::_valid Is integrator in valid state? void* _workspace GSL workspace Double_t* _x ! Current coordinate Double_t _xmax ! Upper integration bound Double_t _xmin ! Lower integration bound

## Function documentation

void registerIntegrator(RooNumIntFactory& fact)
``` Register this class with RooNumIntConfig as a possible choice of numeric
integrator for one-dimensional integrals over finite and infinite domains
```

``` coverity[UNINIT_CTOR]
Default constructor
```
RooAdaptiveGaussKronrodIntegrator1D(const RooAbsFunc& function, const RooNumIntConfig& config)
``` Constructor taking a function binding and a configuration object
```
RooAdaptiveGaussKronrodIntegrator1D(const RooAbsFunc& function, Double_t xmin, Double_t xmax, const RooNumIntConfig& config)
``` Constructor taking a function binding, an integration range and a configuration object
```
RooAbsIntegrator* clone(const RooAbsFunc& function, const RooNumIntConfig& config) const
``` Virtual constructor
```

``` Initialize integrator allocate buffers and setup GSL workspace
```

``` Destructor.
```
Bool_t setLimits(Double_t* xmin, Double_t* xmax)
``` Change our integration limits. Return kTRUE if the new limits are
ok, or otherwise kFALSE. Always returns kFALSE and does nothing
if this object was constructed to always use our integrand's limits.
```
Bool_t checkLimits() const
``` Check that our integration range is finite and otherwise return kFALSE.
Update the limits from the integrand if requested.
```
Double_t integral(const Double_t* yvec = 0)
``` Calculate and return integral at at given parameter values
```

``` Constructors, assignment etc
```

``` If flag is true, intergration limits are taken from definition in input function binding
```
Bool_t canIntegrate1D() const
``` We can integrate 1-dimensional functions
```
Bool_t canIntegrate2D() const
``` We can not integrate 2-dimensional functions
```
Bool_t canIntegrateND() const
``` We can not integrate >2-dimensional functions
```
Bool_t canIntegrateOpenEnded() const
``` We can integrate over open-ended domains
```
Double_t* xvec(Double_t& xx)
``` Return contents of xx in internal array pointer
```