RectangleQuadrature1D.hh

Go to the documentation of this file.

#ifndef NPSTAT_RECTANGLEQUADRATURE1D_HH_
#define NPSTAT_RECTANGLEQUADRATURE1D_HH_
 
/*!
// \file RectangleQuadrature1D.hh
//
// \brief Trivial rectangle quadrature. Works well on certain functions.
//
// Author: I. Volobouev
//
// November 2020
*/
 
#include <vector>
#include <utility>
 
#include "npstat/nm/SimpleFunctors.hh"
#include "npstat/nm/AbsIntervalQuadrature1D.hh"
 
namespace npstat {
    class RectangleQuadrature1D : public AbsIntervalQuadrature1D
    {
    public:
        enum {interval_quadrature = 1};
 
        explicit RectangleQuadrature1D(unsigned npoints);
 
        inline virtual ~RectangleQuadrature1D() {}
 
        inline unsigned npoints() const {return npoints_;}
        void getAllAbscissae(long double* abscissae, unsigned len) const;
        void getAllWeights(long double* weights, unsigned len) const;
 
        /** Perform the quadrature on the [a, b] interval */
        template <typename FcnResult, typename FcnArg>
        long double integrate(const Functor1<FcnResult,FcnArg>& fcn,
                              long double a, long double b) const;
    private:
        RectangleQuadrature1D();
 
        mutable std::vector<std::pair<long double, long double> > buf_;
        unsigned npoints_;
 
#ifdef SWIG
    public:
        inline std::vector<double> allabscissae2() const
        {
            std::vector<double> abscissae(npoints_);
            const long double step = 2.0L/npoints_;
            for (unsigned i=0; i<npoints_; ++i)
                abscissae[i] = -1.0L + step*(i + 0.5L);
            return abscissae;
        }
 
        inline std::vector<double> allweights2() const
        {
            std::vector<double> weights(npoints_);
            const long double w = 2.0L/npoints_;
            for (unsigned i=0; i<npoints_; ++i)
                weights[i] = w;
            return weights;
        }
 
        template <typename FcnResult, typename FcnArg>
        inline double integrate2(const Functor1<FcnResult,FcnArg>& fcn,
                                 const double a, const double b) const
        {
            return integrate(fcn, a, b);
        }
#endif // SWIG
    };
}
 
#include "npstat/nm/RectangleQuadrature1D.icc"
 
#endif // NPSTAT_RECTANGLEQUADRATURE1D_HH_