ExpTiltedDistribution1D.hh

Go to the documentation of this file.

#ifndef NPSTAT_EXPTILTEDDISTRIBUTION1D_HH_
#define NPSTAT_EXPTILTEDDISTRIBUTION1D_HH_
 
/*!
// \file ExpTiltedDistribution1D.hh
//
// \brief Exponentially tilted distribution. Only density calculation
//        is currently implemented but not cdf, quantile, I/O, etc.
//
// Author: I. Volobouev
//
// December 2019
*/
 
#include "npstat/stat/AbsDistribution1D.hh"
#include "npstat/stat/AbsCGF1D.hh"
 
namespace npstat {
    class ExpTiltedDistribution1D : public AbsDistribution1D
    {
    public:
        /**
        // The cumulant generating function argument, "cgf", should
        // be the CGF of the distribution "distro"
        */
        ExpTiltedDistribution1D(const AbsCGF1D& cgf,
                                const AbsDistribution1D& distro,
                                double s_tilt);
        ExpTiltedDistribution1D(const ExpTiltedDistribution1D&);
        ExpTiltedDistribution1D& operator=(const ExpTiltedDistribution1D&);
 
        inline virtual ExpTiltedDistribution1D* clone() const
            {return new ExpTiltedDistribution1D(*this);}
 
        inline virtual ~ExpTiltedDistribution1D() {cleanup();}
 
        /** Set the s-tilt parameter */
        void setTilt(double s);
 
        inline double tilt() const {return s_;}
        inline double Ks() const {return Ks_;}
 
        inline AbsCGF1D& getCGF() {return *cgf_;}
        inline const AbsCGF1D& getCGF() const {return *cgf_;}
 
        inline AbsDistribution1D& getUnderlyingDistro() {return *d_;}
        inline const AbsDistribution1D& getUnderlyingDistro() const
            {return *d_;}
 
        inline double mean() const {return cgf_->derivative(1U, s_);}
        inline double variance() const {return cgf_->derivative(2U, s_);}
 
        /** Probability density */
        virtual double density(double x) const;
 
        /** Cumulative distribution function */
        virtual double cdf(double x) const;
 
        /** 1 - cdf, implementations should avoid subtractive cancellation */
        virtual double exceedance(double x) const;
 
        /** The quantile function */
        virtual double quantile(double x) const;
 
        /** Prototype needed for I/O */
        inline virtual gs::ClassId classId() const {return gs::ClassId(*this);}
        virtual bool write(std::ostream&) const;
        //@}
 
        static inline const char* classname()
            {return "npstat::ExpTiltedDistribution1D";}
        static inline unsigned version() {return 1;}
        static ExpTiltedDistribution1D* read(
            const gs::ClassId& id, std::istream& is);
 
    protected:
        virtual bool isEqual(const AbsDistribution1D&) const;
 
    private:
        ExpTiltedDistribution1D();
        void cleanup();
 
        AbsCGF1D* cgf_;
        AbsDistribution1D* d_;
        double s_;
        double Ks_;
    };
}
 
#endif // NPSTAT_EXPTILTEDDISTRIBUTION1D_HH_