ComparisonDistribution1D.hh

Go to the documentation of this file.

#ifndef NPSTAT_COMPARISONDISTRIBUTION1D_HH_
#define NPSTAT_COMPARISONDISTRIBUTION1D_HH_
 
/*!
// \file ComparisonDistribution1D.hh
//
// \brief Comparison distributions in one dimension
//
// Author: I. Volobouev
//
// September 2019
*/
 
#include <vector>
 
#include "npstat/stat/AbsDistribution1D.hh"
 
namespace npstat {
    class ComparisonDistribution1D : public AbsDistribution1D
    {
    public:
        ComparisonDistribution1D(const AbsDistribution1D& compared,
                                 const AbsDistribution1D& baseline);
 
        ComparisonDistribution1D(const ComparisonDistribution1D&);
        ComparisonDistribution1D& operator=(const ComparisonDistribution1D&);
 
        inline virtual ~ComparisonDistribution1D() {cleanup();}
 
        /** Probability density */
        double density(const double u) const;
 
        /**
        // Coefficient of expansion of the density into
        // shifted Legendre polynomials (that is, Legendre
        // polynomials orthonormal on [0, 1]).
        */
        double legendreCoeff(unsigned degree) const;
 
        /**
        // All coefficients of the Legendre polynomial expansion
        // of the density, up to the degree requested. The array
        // "coeffs" should have at least maxDeg+1 elements.
        */
        void legendreSeriesCoeffs(double* coeffs, unsigned maxDeg) const;
 
        /**
        // Coefficient of expansion of this function into
        // trigonometric functions, that is, sqrt(2)*sin(2 k Pi x)
        // and sqrt(2)*cos(2 k Pi x). The integration is performed
        // using the rectangle integration rule, with nInteg
        // intervals. nInteg should be substantially larger than k,
        // something like 32*k should work reasonably well.
        */
        double trigCoeff(unsigned k, bool isCosine, unsigned nInteg) const;
 
        /**
        // Coefficient of expansion of this function into cosine
        // basis, that is, sqrt(2)*cos(k Pi x). The integration
        // is performed using the rectangle integration rule, with
        // nInteg intervals. nInteg should be substantially larger
        // than k, something like 16*k should work reasonably well.
        */
        double cosCoeff(unsigned k, unsigned nInteg) const;
 
        /** Cumulative distribution function */
        inline double cdf(const double u) const
        {
            if (u <= 0.0)
                return 0.0;
            else if (u >= 1.0)
                return 1.0;
            else
                return pF_->cdf(pH_->quantile(u));
        }
 
        /** Exceedance (i.e., 1 - cdf) */
        inline double exceedance(const double u) const
        {
            if (u <= 0.0)
                return 1.0;
            else if (u >= 1.0)
                return 0.0;
            else
                return pF_->exceedance(pH_->quantile(u));
        }
 
        /** Quantile function */
        inline double quantile(const double x) const
            {return pH_->cdf(pF_->quantile(x));}
 
        /** "Virtual copy constructor" */
        inline virtual ComparisonDistribution1D* clone() const
            {return new ComparisonDistribution1D(*this);}
 
        /** Fetch the compared distribution */
        inline const AbsDistribution1D& compared() const {return *pF_;}
 
        /** Fetch the base line distribution */
        inline const AbsDistribution1D& baseline() const {return *pH_;}
 
        //@{
        /** Method needed for "geners" I/O */
        virtual gs::ClassId classId() const {return gs::ClassId(*this);}
        virtual bool write(std::ostream& os) const;
        //@}
 
        static inline const char* classname()
            {return "npstat::ComparisonDistribution1D";}
        static inline unsigned version() {return 1;}
        static ComparisonDistribution1D* read(
            const gs::ClassId& id, std::istream& in);
 
    protected:
        virtual bool isEqual(const AbsDistribution1D&) const;
 
        ComparisonDistribution1D();
 
        const AbsDistribution1D* pF_;
        const AbsDistribution1D* pH_;
 
    private:
        void cleanup();
 
#ifdef SWIG
    public:
        inline std::vector<double>
        legendreSeriesCoeffs2(const unsigned maxDeg) const
        {
            std::vector<double> tmp(maxDeg+1U);
            legendreSeriesCoeffs(&tmp[0], maxDeg);
            return tmp;
        }
#endif // SWIG
    };
}
 
#endif // NPSTAT_COMPARISONDISTRIBUTION1D_HH_