AbsUnbinnedGOFTest1D.hh

Go to the documentation of this file.

#ifndef NPSTAT_ABSUNBINNEDGOFTEST1D_HH_
#define NPSTAT_ABSUNBINNEDGOFTEST1D_HH_
 
/*!
// \file AbsUnbinnedGOFTest1D.hh
//
// \brief Interface definition for goodness-of-fit tests for 1-d distributions
//
// Author: I. Volobouev
//
// November 2020
*/
 
#include <vector>
#include <stdexcept>
#include <string>
 
#include "npstat/nm/SimpleFunctors.hh"
#include "npstat/rng/AbsRandomGenerator.hh"
#include "npstat/stat/AbsDistribution1D.hh"
 
namespace npstat {
    class AbsUnbinnedGOFTest1D
    {
    public:
        inline explicit AbsUnbinnedGOFTest1D(const AbsDistribution1D& d)
            : distro_(d.clone()) {}
 
        inline AbsUnbinnedGOFTest1D(const AbsUnbinnedGOFTest1D& r)
            : distro_(r.distro_->clone()) {}
 
        inline AbsUnbinnedGOFTest1D& operator=(const AbsUnbinnedGOFTest1D& r)
        {
            if (this != &r)
            {
                delete distro_;
                distro_ = 0;
                distro_ = r.distro_->clone();
            }
            return *this;
        }
 
        inline virtual ~AbsUnbinnedGOFTest1D() {delete distro_;}
 
        inline const AbsDistribution1D& getNull() const {return *distro_;}
 
        virtual std::string shortName() const=0;
 
        virtual double testStatistic(
            const double* data, unsigned long sz,
            bool isDataSorted) const=0;
 
        virtual double testStatistic(
            const float* data, unsigned long sz,
            bool isDataSorted) const=0;
 
        inline virtual double analyticPValue(
            double /* stat */, unsigned long /* sz */) const
        {
            throw std::runtime_error(
                "In npstat::AbsUnbinnedGOFTest1D::analyticPValue: "
                "this function is not implemented by the derived class");
        }
        inline virtual bool hasAnalyticPValue() const {return false;}
 
        /** This is the inverse function to "analyticPValue" */
        virtual double inverseExceedance(double pvalue, unsigned long sz,
                                         double smin, double smax) const;
 
        inline void simulateStatistic(
            AbsRandomGenerator& g, unsigned long sz,
            unsigned nPseudo, std::vector<double>* stats) const
        {
            simulateAltStatistic(*distro_, g, sz, nPseudo, stats);
        }
 
        // The following method should sort the returned statistic values
        // in the increasing order
        virtual void simulateAltStatistic(
            const AbsDistribution1D& alternative,
            AbsRandomGenerator& g, unsigned long sz,
            unsigned nPseudo, std::vector<double>* stats) const;
 
    protected:
        AbsDistribution1D* distro_;
 
#ifdef SWIG
    public:
        inline std::vector<double> simulateStatistic2(
            AbsRandomGenerator& g, const unsigned long sz,
            const unsigned nPseudo) const
        {
            std::vector<double> tmp;
            simulateStatistic(g, sz, nPseudo, &tmp);
            return tmp;
        }
 
        inline std::vector<double> simulateAltStatistic2(
            const AbsDistribution1D& alternative,
            AbsRandomGenerator& g, const unsigned long sz,
            const unsigned nPseudo) const
        {
            std::vector<double> tmp;
            simulateAltStatistic(alternative, g, sz, nPseudo, &tmp);
            return tmp;
        }
#endif // SWIG
    };
 
 
    class GOFTest1DPVFunctor : public Functor1<double, double>
    {
    public:
        inline GOFTest1DPVFunctor(const AbsUnbinnedGOFTest1D& goftest,
                                  const unsigned long sz)
            : goftest_(goftest), sz_(sz) {}
 
        inline virtual ~GOFTest1DPVFunctor() {}
 
        inline virtual double operator()(const double& a) const
            {return goftest_.analyticPValue(a, sz_);}
 
    private:
        const AbsUnbinnedGOFTest1D& goftest_;
        unsigned long sz_;
    };
}
 
#endif // NPSTAT_ABSUNBINNEDGOFTEST1D_HH_