SmoothGOFTest1D.hh

Go to the documentation of this file.

#ifndef NPSTAT_SMOOTHGOFTEST1D_HH_
#define NPSTAT_SMOOTHGOFTEST1D_HH_
 
/*!
// \file SmoothGOFTest1D.hh
//
// \brief Smooth test for goodness-of-fit
//
// Author: I. Volobouev
//
// November 2020
*/
 
#include "npstat/stat/AbsSmoothGOFTest1D.hh"
 
namespace npstat {
    // "Poly" template parameter is expected either to be
    // ScalableClassicalOrthoPoly1D or to derive from (or
    // to be) AbsClassicalOrthoPoly1D.
    template<class Poly>
    class SmoothGOFTest1D : public AbsSmoothGOFTest1D
    {
    public:
        typedef Poly poly_type;
 
        // The polynomials provided in the constructor must be
        // orthonormal with the weight given by "distro.density(x)".
        //
        // The mask, if provided, should contain "maxdeg" elements.
        // Put some number in the mask in order to discard the
        // corresponding eigenvector and put 0 there to keep it.
        // mask[0] specifies whether to use polynomial of degree 1, etc.
        //
        inline SmoothGOFTest1D(const AbsDistribution1D& distro,
                               const Poly& poly,
                               const unsigned maxdeg,
                               const unsigned char* mask=0,
                               const unsigned lenMask=0)
            : AbsSmoothGOFTest1D(distro, maxdeg, mask, lenMask),
              poly_(poly.clone()), aveBuf_(maxdeg+1U) {}
 
        inline SmoothGOFTest1D(const AbsDistribution1D& distro,
                               const Poly& poly,
                               const std::vector<int>& mask)
            : AbsSmoothGOFTest1D(distro, mask),
              poly_(poly.clone()), aveBuf_(mask.size()+1U) {}
 
        inline SmoothGOFTest1D(const SmoothGOFTest1D& r)
            : AbsSmoothGOFTest1D(r),
              poly_(r.poly_->clone()), aveBuf_(r.aveBuf_) {}
 
        inline SmoothGOFTest1D& operator=(const SmoothGOFTest1D& r)
        {
            if (&r != this)
            {
                AbsSmoothGOFTest1D::operator=(r);
                aveBuf_ = r.aveBuf_;
                delete poly_; poly_ = 0;
                poly_ = r.poly_->clone();
            }
            return *this;
        }
 
        inline virtual ~SmoothGOFTest1D() {delete poly_;}
 
        inline virtual std::string shortName() const
            {return testNameWithMask("S");}
 
        virtual unsigned normalizedDeviations(
            const double* data, unsigned long sz,
            bool isDataSorted,
            double* deviations, unsigned lenDeviations) const;
 
        virtual unsigned normalizedDeviations(
            const float* data, unsigned long sz,
            bool isDataSorted,
            double* deviations, unsigned lenDeviations) const;
 
    private:
        template<typename Numeric>
        unsigned normalizedDeviationsHelper(
            const Numeric* data, unsigned long lenData,
            double* deviations) const;
 
        Poly* poly_;
        mutable std::vector<double> aveBuf_;
    };
}
 
#include "npstat/stat/SmoothGOFTest1D.icc"
 
#endif // NPSTAT_SMOOTHGOFTEST1D_HH_