AbsCGF1D.hh

Go to the documentation of this file.

#ifndef NPSTAT_ABSCGF1D_HH_
#define NPSTAT_ABSCGF1D_HH_
 
/*!
// \file AbsCGF1D.hh
//
// \brief Interface definition for univariate cumulant generating functions
//
// Author: I. Volobouev
//
// December 2019
*/
 
#include <typeinfo>
 
namespace npstat {
    struct AbsCGF1D
    {
        inline virtual ~AbsCGF1D() {}
 
        /** Virtual copy constructor */
        virtual AbsCGF1D* clone() const = 0;
 
        /**
        // CGF for the variable (X - mu)/sigma. Created on the
        // heap and must be later deleted by the user.
        */
        virtual AbsCGF1D* shiftAndScale(double mu, double sigma) const = 0;
 
        /** Infimum of the support */
        virtual double smin() const = 0;
 
        /** Supremum of the support */
        virtual double smax() const = 0;
 
        /** CGF value */
        inline double operator()(double s) const
            {return derivative(0U, s);}
 
        /** CGF derivatives. Get cum[order] by setting s to 0. */
        virtual double derivative(unsigned order, double s) const = 0;
 
        /** Solution of the saddlepoint equation CGF'(s) == x */
        virtual double saddlepoint(double x) const;
 
        /**
        // Search empirically for the maximum value of s
        // for which this CGF remains convex. This function
        // should search for the closest to 0 root of the
        // CGF second derivative on the interval [0, slimit].
        // It should return 0.0 if no such root was found.
        */
        virtual double convexLimit(double slimit, double stepSize) const;
 
        /** Standardized cumulant for s-tilted density */
        double standardizedCumulant(unsigned order, double s) const;
 
        /**
        // Saddlepoint density approximation. Parameter "order" is the
        // approximation order (e.g., order = 2 means O(N^-2)). This
        // parameter must be positive. The raw, unnormalized approximation
        // is returned.
        */
        double saddlepointDensityApprox(unsigned order, double x) const;
 
        /**
        // Lugannani-Rice approximation for the survival function.
        // The approximation employs a series which looks like
        // c0/N^{1/2} + c1/N^{3/2} + c2/N^{5/2} + ...
        // The parameter "nTerms" specifies the number of terms in
        // the series to use and, thereby, the approximation order.
        */
        double lugannaniRiceSFApprox(unsigned nTerms, double x) const;
 
        /**
        // Derived classes should not implement "operator==", implement
        // "isEqual" instead
        */
        inline bool operator==(const AbsCGF1D& r) const
            {return (typeid(*this) == typeid(r)) && this->isEqual(r);}
 
        /** Logical negation of operator== */
        inline bool operator!=(const AbsCGF1D& r) const
            {return !(*this == r);}
 
    protected:
        /** Comparison for equality. To be implemented by derived classes. */
        virtual bool isEqual(const AbsCGF1D&) const = 0;
    };
}
 
#endif // NPSTAT_ABSCGF1D_HH_