RooIntegrator1D

class RooIntegrator1D : public RooAbsIntegrator

    protected:

         Double_t addMidpoints(Int_t n)
         Double_t addTrapezoids(Int_t n)
             void extrapolate(Int_t n)
           Bool_t initialize()
      static void registerIntegrator(RooNumIntFactory& fact)
        Double_t* xvec(Double_t& xx)

    public:

                                RooIntegrator1D()
                                RooIntegrator1D(const RooAbsFunc& function, RooIntegrator1D::SummationRule rule = Trapezoid, Int_t maxSteps = 0, Double_t eps = 0)
                                RooIntegrator1D(const RooAbsFunc& function, Double_t xmin, Double_t xmax, RooIntegrator1D::SummationRule rule = Trapezoid, Int_t maxSteps = 0, Double_t eps = 0)
                                RooIntegrator1D(const RooAbsFunc& function, const RooNumIntConfig& config)
                                RooIntegrator1D(const RooAbsFunc& function, Double_t xmin, Double_t xmax, const RooNumIntConfig& config)
                                RooIntegrator1D(const RooIntegrator1D&)
                        virtual ~RooIntegrator1D()
                 virtual Bool_t canIntegrate1D() const
                 virtual Bool_t canIntegrate2D() const
                 virtual Bool_t canIntegrateND() const
                 virtual Bool_t canIntegrateOpenEnded() const
                 virtual Bool_t checkLimits() const
                 static TClass* Class()
      virtual RooAbsIntegrator* clone(const RooAbsFunc& function, const RooNumIntConfig& config) const
               virtual Double_t integral(const Double_t* yvec = 0)
                virtual TClass* IsA() const
                 virtual Bool_t setLimits(Double_t xmin, Double_t xmax)
                 virtual Bool_t setUseIntegrandLimits(Bool_t flag)
                   virtual void ShowMembers(TMemberInspector& insp, char* parent)
                   virtual void Streamer(TBuffer& b)
                           void StreamerNVirtual(TBuffer& b)

Data Members

    protected:

                              Bool_t _useIntegrandLimits  
      RooIntegrator1D::SummationRule _rule                
                               Int_t _maxSteps            
                               Int_t _minStepsZero        
                               Int_t _fixSteps            
                            Double_t _epsAbs              
                            Double_t _epsRel              
                              Bool_t _doExtrap            
                            Double_t _xmin                ! do not persist
                            Double_t _xmax                ! do not persist
                            Double_t _range               ! do not persist
                            Double_t _extrapValue         ! do not persist
                            Double_t _extrapError         ! do not persist
                           Double_t* _h                   ! do not persist
                           Double_t* _s                   ! do not persist
                           Double_t* _c                   ! do not persist
                           Double_t* _d                   ! do not persist
                            Double_t _savedResult         ! do not persist
                           Double_t* _x                   ! do not persist

    public:

      static const RooIntegrator1D::SummationRule Trapezoid  
      static const RooIntegrator1D::SummationRule Midpoint   
              static const enum RooIntegrator1D:: _nPoints   

 Use this form of the constructor to integrate over the function's default range.

 Use this form of the constructor to override the function's default range.

 Use this form of the constructor to integrate over the function's default range.

 Use this form of the constructor to override the function's default range.

 apply defaults if necessary

 Release integrator workspace

 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.

 Check that our integration range is finite and otherwise return kFALSE.
 Update the limits from the integrand if requested.

 Calculate the n-th stage of refinement of the Second Euler-Maclaurin
 summation rule which has the useful property of not evaluating the
 integrand at either of its endpoints but requires more function
 evaluations than the trapezoidal rule. This rule can be used with
 a suitable change of variables to estimate improper integrals.

 Calculate the n-th stage of refinement of the extended trapezoidal
 summation rule. This is the most efficient rule for a well behaved
 integrand that can be evaluated over its entire range, including the
 endpoints.