AbsSmoothGOFTest1D.hh

Go to the documentation of this file.

#ifndef NPSTAT_ABSSMOOTHGOFTEST1D_HH_
#define NPSTAT_ABSSMOOTHGOFTEST1D_HH_
 
/*!
// \file AbsSmoothGOFTest1D.hh
//
// \brief Base class for smooth tests for goodness-of-fit
//
// Author: I. Volobouev
//
// October 2022
*/
 
#include <vector>
 
#include "npstat/stat/AbsUnbinnedGOFTest1D.hh"
 
namespace npstat {
    class AbsSmoothGOFTest1D : public AbsUnbinnedGOFTest1D
    {
    public:
        // mask and lenMask arguments can both be 0
        AbsSmoothGOFTest1D(const AbsDistribution1D& distro,
                           unsigned maxdeg,
                           const unsigned char* mask, unsigned lenMask);
 
        AbsSmoothGOFTest1D(const AbsDistribution1D& distro,
                           const std::vector<int>& mask);
 
        inline virtual ~AbsSmoothGOFTest1D() {}
 
        inline unsigned maxDegree() const {return maxdeg_;}
        inline unsigned nDegreesUsed() const {return nUnmasked_;}
        inline bool isDegreeUsed(const unsigned n) const
        {
            if (!n) return false;
            const unsigned i = n - 1U;
            return i >= maxdeg_ ? false : !mask_[i];
        }
 
        virtual double testStatistic(
            const double* data, unsigned long sz,
            bool isDataSorted) const;
 
        virtual double testStatistic(
            const float* data, unsigned long sz,
            bool isDataSorted) const;
 
        inline virtual bool hasAnalyticPValue() const {return true;}
 
        /**
        // p-value calculated by this method is valid asymptotically
        // for the statistic returned by the "testStatistic" method,
        // not "directedStatistic".
        */
        virtual double analyticPValue(double stat, unsigned long sz) const;
 
        virtual double inverseExceedance(double pvalue, unsigned long sz,
                                         double statMin, double statMax) const;
 
        //@{
        /**
        // Get individual normalized deviations from which
        // the test statistics are constructed. Only unmasked
        // deviations are returned. The return value of this
        // function is the number of such deviations.
        */
        virtual unsigned normalizedDeviations(
            const double* data, unsigned long sz,
            bool isDataSorted,
            double* deviations, unsigned lenDeviations) const=0;
 
        virtual unsigned normalizedDeviations(
            const float* data, unsigned long sz,
            bool isDataSorted,
            double* deviations, unsigned lenDeviations) const=0;
        //@}
 
        //@{
        /**
        // It is expected that the asymptotic distribution of
        // the directed test statistic for the null hypothesis
        // is the standard normal.
        */
        inline virtual double directedStatistic(
            const double* direction, unsigned lenDirection,
            const double* data, unsigned long sz,
            bool isDataSorted) const
        {
            return directedStat(direction, lenDirection, data, sz, isDataSorted);
        }
 
        inline virtual double directedStatistic(
            const double* direction, unsigned lenDirection,
            const float* data, unsigned long sz,
            bool isDataSorted) const
        {
            return directedStat(direction, lenDirection, data, sz, isDataSorted);
        }
        //@}
 
        inline void simulateDirectedStatistic(
            const double* direction, unsigned lenDirection,
            AbsRandomGenerator& g, unsigned long sz,
            unsigned nPseudo, std::vector<double>* stats) const
        {
            simulateAltDirectedStatistic(direction, lenDirection,
                                         *distro_, g, sz, nPseudo, stats);
        }
 
        // The following method should sort the returned statistic values
        // in the increasing order
        virtual void simulateAltDirectedStatistic(
            const double* direction, unsigned lenDirection,
            const AbsDistribution1D& alternative,
            AbsRandomGenerator& g, unsigned long sz,
            unsigned nPseudo, std::vector<double>* stats) const;
 
    protected:
        std::string testNameWithMask(const char* prefix) const;
 
        std::vector<unsigned char> mask_;
        unsigned maxdeg_;
        unsigned nUnmasked_;
 
    private:
        template<typename Numeric>
        double directedStat(const double* direction, unsigned lenDirection,
                            const Numeric* data, unsigned long sz,
                            bool isDataSorted) const;
 
        template<typename Numeric>
        void initMask(const Numeric* mask, unsigned lenMask);
 
        mutable std::vector<double> devBuf_;
 
#ifdef SWIG
    public:
        inline std::vector<double> normalizedDeviations2(
            const double* data, unsigned long sz,
            const bool dataIsSorted) const
        {
            std::vector<double> tmp(nUnmasked_);
            this->normalizedDeviations(data, sz, dataIsSorted,
                                       &tmp[0], nUnmasked_);
            return tmp;
        }
 
        inline std::vector<double> simulateDirectedStatistic2(
            const double* direction, unsigned lenDirection,
            AbsRandomGenerator& g, const unsigned long sz,
            const unsigned nPseudo) const
        {
            std::vector<double> tmp;
            simulateDirectedStatistic(direction, lenDirection,
                                      g, sz, nPseudo, &tmp);
            return tmp;
        }
 
        inline std::vector<double> simulateAltDirectedStatistic2(
            const double* direction, unsigned lenDirection,
            const AbsDistribution1D& alternative,
            AbsRandomGenerator& g, const unsigned long sz,
            const unsigned nPseudo) const
        {
            std::vector<double> tmp;
            simulateAltDirectedStatistic(direction, lenDirection,
                                         alternative, g, sz, nPseudo, &tmp);
            return tmp;
        }
#endif
    };
}
 
#include "npstat/stat/AbsSmoothGOFTest1D.icc"
 
#endif // NPSTAT_ABSSMOOTHGOFTEST1D_HH_