AbsMarginalSmootherBase.hh

Go to the documentation of this file.

#ifndef NPSTAT_ABSMARGINALSMOOTHERBASE_HH_
#define NPSTAT_ABSMARGINALSMOOTHERBASE_HH_
 
/*!
// \file AbsMarginalSmootherBase.hh
//
// \brief Interface definition for 1-d nonparametric density estimation
//
// Author: I. Volobouev
//
// June 2015
*/
 
#include <vector>
#include <utility>
#include <limits>
 
#include "geners/AbsArchive.hh"
#include "npstat/stat/HistoND.hh"
 
#ifdef SWIG
#include <stdexcept>
#include "npstat/wrap/arrayNDToNumpy.hh"
#include "npstat/wrap/histoBinCoords.hh"
#endif // SWIG
 
namespace npstat {
    class AbsMarginalSmootherBase
    {
    public:
        /** Constructor takes binning parameters for the internal histogram */
        AbsMarginalSmootherBase(unsigned nbins, double xmin, double xmax,
                                const char* axisLabel = 0);
 
        inline virtual ~AbsMarginalSmootherBase() {delete histo_;}
 
        void setAxisLabel(const char* axisLabel);
 
        //@{
        /** Simple inspector of the object properties */
        inline unsigned nBins() const {return nbins_;}
        inline double xMin() const {return xmin_;}
        inline double xMax() const {return xmax_;}
        inline double binWidth() const {return (xmax_ - xmin_)/nbins_;}
        inline const std::string& getAxisLabel() const {return axlabel_;}
        inline gs::AbsArchive* getArchive() const {return ar_;}
        inline const std::string& getArchiveCategory() const
            {return category_;}
        //@}
 
        /**
        // The bandwidth used by the most recent "smooth" or
        // "weightedSmooth" call
        */
        inline double lastBandwidth() const {return lastBw_;}
 
        /** Set the archive for storing original and smoothed histograms */
        void setArchive(gs::AbsArchive* ar, const char* category = 0);
 
        /** Stop storing histograms */
        inline void unsetArchive() {setArchive(0);}
 
        /**
        // Smoothing function for unweighted samples. The region
        // used for smoothing will be defined by the overlap of
        // the intervals [minValue, maxValue) and [xMin(), xMax()).
        */
        template <typename Numeric>
        const HistoND<double>& smooth(
            const std::vector<Numeric>& inputPoints,
            double minValue = -std::numeric_limits<double>::max(),
            double maxValue =  std::numeric_limits<double>::max(),
            double* bandwidthUsed = 0);
 
        /**
        // Smoothing function for unweighted samples. The region
        // used for smoothing will be defined by the overlap of
        // the intervals [minValue, maxValue) and [xMin(), xMax()).
        // Parameters "uniqueId" and "dimNumber" are used for
        // identification purposes only -- they will be used to
        // create the item name in the archive if the archive is set.
        */
        template <typename Numeric>
        const HistoND<double>& smooth(
            unsigned long uniqueId, unsigned dimNumber,
            const std::vector<Numeric>& inputPoints,
            double minValue = -std::numeric_limits<double>::max(),
            double maxValue =  std::numeric_limits<double>::max(),
            double* bandwidthUsed = 0);
 
        /** 
        // Smoothing function for weighted samples. The region
        // used for smoothing will be defined by the overlap of
        // the intervals [minValue, maxValue) and [xMin(), xMax()).
        */
        template <typename Numeric>
        const HistoND<double>& weightedSmooth(
            const std::vector<std::pair<Numeric,double> >& inputPoints,
            double minValue = -std::numeric_limits<double>::max(),
            double maxValue =  std::numeric_limits<double>::max(),
            double* bandwidthUsed = 0);
 
        /** 
        // Smoothing function for weighted samples. The region
        // used for smoothing will be defined by the overlap of
        // the intervals [minValue, maxValue) and [xMin(), xMax()).
        // Parameters "uniqueId" and "multivariatePointDimNumber"
        // are used for identification purposes only -- they will be used
        // to create the item name in the archive if the archive is set.
        */
        template <typename Numeric>
        const HistoND<double>& weightedSmooth(
            unsigned long uniqueId, unsigned multivariatePointDimNumber,
            const std::vector<std::pair<Numeric,double> >& inputPoints,
            double minValue = -std::numeric_limits<double>::max(),
            double maxValue =  std::numeric_limits<double>::max(),
            double* bandwidthUsed = 0);
 
    private:
        AbsMarginalSmootherBase();
        AbsMarginalSmootherBase(const AbsMarginalSmootherBase&);
        AbsMarginalSmootherBase& operator=(const AbsMarginalSmootherBase&);
 
        HistoND<double>& clearHisto(double xmin, double xmax);
        void storeHisto(unsigned long uniqueId, unsigned dim, double bw) const;
 
        // Method to implement in derived classes
        virtual void smoothHisto(HistoND<double>& histo,
                                 double effectiveSampleSize,
                                 double* bandwidthUsed,
                                 bool isSampleWeighted) = 0;
        HistoND<double>* histo_;
        double xmin_;
        double xmax_;
        double lastBw_;
        gs::AbsArchive* ar_;
        std::string category_;
        std::string axlabel_;
        unsigned nbins_;
 
#ifdef SWIG
        inline PyObject* buildResultFromHisto(const HistoND<double>& h)
        {
             PyObject* x = 0;
             PyObject* array = 0;
             try 
             {
                 x = histoBinCenters(h.axis(0));
                 array = arrayNDToNumpy(h.binContents());
             }
             catch (const std::exception& e)
             {
                 Py_XDECREF(x);
                 Py_XDECREF(array);
                 throw e;
             }
             return Py_BuildValue("(OOd)", x, array, lastBw_);
        }
 
    public:
        /** Simplified smooth method without archiving */
        template <typename Vec>
        inline PyObject* smooth2(const Vec& inputPoints)
        {
             const HistoND<double>& h = smooth(inputPoints);
             return buildResultFromHisto(h);
        }
 
        /** Simplified smooth method with archiving */
        template <typename Vec>
        inline PyObject* smoothArch(
            const Vec& inputPoints, unsigned long uniqueId, unsigned dimNumber)
        {
            if (!ar_) throw std::runtime_error(
                "In npstat::AbsMarginalSmootherBase::smoothArch: "
                "archive is not set");
            const HistoND<double>& h = smooth(uniqueId, dimNumber, inputPoints);
            return buildResultFromHisto(h);
        }
 
        /** Simplified smooth method for weigted samples without archiving */
        template <typename Vec>
        inline PyObject* weightedSmooth2(const Vec& inputPoints)
        {
             const HistoND<double>& h = weightedSmooth(inputPoints);
             return buildResultFromHisto(h);
        }
 
        /** Simplified smooth method for weigted samples with archiving */
        template <typename Vec>
        inline PyObject* weightedSmoothArch(
            const Vec& inputPoints, unsigned long uniqueId, unsigned dimNumber)
        {
            if (!ar_) throw std::runtime_error(
                "In npstat::AbsMarginalSmootherBase::weightedSmoothArch: "
                "archive is not set");
            const HistoND<double>& h = weightedSmooth(uniqueId, dimNumber, inputPoints);
            return buildResultFromHisto(h);
        }
#endif // SWIG
    };
}
 
#include "npstat/stat/AbsMarginalSmootherBase.icc"
 
#endif // NPSTAT_ABSMARGINALSMOOTHERBASE_HH_