ConvolutionDensity1D.hh

Go to the documentation of this file.

#ifndef NPSTAT_CONVOLUTIONDENSITY1D_HH_
#define NPSTAT_CONVOLUTIONDENSITY1D_HH_
 
/*!
// \file ConvolutionDensity1D.hh
//
// \brief Calculates densities of the kind f(y) = Int K(x, y) f(x) dx,
//        where f(x) can also be an empirical density (collection of points)
//
// Author: I. Volobouev
//
// December 2022
*/
 
#include <vector>
#include <utility>
 
#include "npstat/nm/SimpleFunctors.hh"
 
namespace npstat {
    template <class Kernel>
    class ConvolutionDensity1D : public Functor1<long double,long double>
    {
    public:
        typedef Kernel kernel_type;
 
        /**
        // In the following constructor, the input functor "fcn" must represent
        // a smooth 1-d density. If it is not normalized, it will be normalized
        // internally. xmin and xmax represent the interval on which the integration
        // is performed used Gauss-Legendre quadrature with nIntegPointsX points.
        // Provide arguments nIntegPointsY, ymin, and ymax if you want automatic
        // kernel normalization in the y direction (also with a Gauss-Legendre
        // quadrature).
        */
        template<class Functor1D>
        ConvolutionDensity1D(const Functor1D& fcn, const Kernel& kernel,
                             unsigned nIntegPointsX, double xmin, double xmax,
                             unsigned nIntegPointsY=0, double ymin=0., double ymax=0.);
 
        /**
        // KDE. Provide arguments nIntegPointsY, ymin, and ymax if you
        // want automatic kernel normalization in the y direction
        // (that is, if you want to create a baloon estimator).
        */
        template<typename Numeric>
        ConvolutionDensity1D(const Kernel& kernel,
                             const Numeric* coords, unsigned lenCoords,
                             unsigned nIntegPointsY=0, double ymin=0., double ymax=0.);
 
        /**
        // KDE with weighted points. Provide arguments nIntegPointsY,
        // ymin, and ymax if you want automatic kernel normalization
        // in the y direction (that is, if you want to create a baloon estimator).
        */
        template<typename Numeric1, typename Numeric2>
        ConvolutionDensity1D(const Kernel& kernel,
                             const Numeric1* coords, unsigned lenCoords,
                             const Numeric2* weights, unsigned lenWeights,
                             unsigned nIntegPointsY=0, double ymin=0., double ymax=0.);
 
        /**
        // KDE with weighted points. The first argument of
        // the pair is the coordinate and the second is the weight.
        // Provide arguments nIntegPointsY, ymin, and ymax if you want
        // automatic kernel normalization in the y direction (that is,
        // if you want to create a baloon estimator).
        */
        template<typename Numeric1, typename Numeric2>
        ConvolutionDensity1D(const Kernel& kernel,
                             const std::vector<std::pair<Numeric1,Numeric2> >& points,
                             unsigned nIntegPointsY=0, double ymin=0., double ymax=0.);
 
        inline virtual ~ConvolutionDensity1D() {}
 
        /** Convolution density at y */
        long double operator()(const long double& y) const;
 
        /** Expected density variance at y for the unweighted sample of given size */
        long double variance(long double y, long double sampleSize) const;
 
        /**
        // Expected density covariance at (y, z)
        // for the unweighted sample of given size
        */
        long double covariance(long double y, long double z,
                               long double sampleSize) const;
    private:
        void normalizeKernel(unsigned nIntegPointsY, double ymin, double ymax);
 
        Kernel kernel_;
        std::vector<long double> xLocations_;
        std::vector<long double> xDensity_;
        std::vector<long double> norms_;
    };
 
    // Helper class for calculating the variance part of the MISE.
    // Do not use this class directly in the application code. Use
    // "ConvolutionVarianceFunctor" instead.
    template <class Kernel>
    class ConvolutionVarianceFunctorHlp : public npstat::Functor1<long double,long double>
    {
    public:
        inline ConvolutionVarianceFunctorHlp(const ConvolutionDensity1D<Kernel>& conv,
                                             const long double sampleSize)
            : conv_(conv), sampleSize_(sampleSize) {}
 
        inline virtual ~ConvolutionVarianceFunctorHlp() {}
 
        inline virtual long double operator()(const long double& y) const
            {return conv_.variance(y, sampleSize_);}
 
    private:
        const ConvolutionDensity1D<Kernel>& conv_;
        long double sampleSize_;
    };
 
    // Functor for calculating the variance part of the MISE
    template <class Kernel>
    inline ConvolutionVarianceFunctorHlp<Kernel> ConvolutionVarianceFunctor(
        const ConvolutionDensity1D<Kernel>& conv, const long double sampleSize)
    {
        return ConvolutionVarianceFunctorHlp<Kernel>(conv, sampleSize);
    }
 
    // Do not use this class directly in the application code. Use
    // "ConvolutionCovarianceFunctor" instead.
    template <class Kernel>
    class ConvolutionCovarianceFunctorHlp : public npstat::Functor2<long double,long double,long double>
    {
    public:
        inline ConvolutionCovarianceFunctorHlp(const ConvolutionDensity1D<Kernel>& conv,
                                               const long double sampleSize)
            : conv_(conv), sampleSize_(sampleSize) {}
    
        inline virtual ~ConvolutionCovarianceFunctorHlp() {}
 
        inline virtual long double operator()(const long double& y, const long double& z) const
            {return conv_.covariance(y, z, sampleSize_);}
 
    private:
        const ConvolutionDensity1D<Kernel>& conv_;
        long double sampleSize_;
    };
 
    template <class Kernel>
    inline ConvolutionCovarianceFunctorHlp<Kernel> ConvolutionCovarianceFunctor(
        const ConvolutionDensity1D<Kernel>& conv, const long double sampleSize)
    {
        return ConvolutionCovarianceFunctorHlp<Kernel>(conv, sampleSize);
    }
}
 
#include "npstat/nm/ConvolutionDensity1D.icc"
 
#endif // NPSTAT_CONVOLUTIONDENSITY1D_HH_