CdfTransform1D.hh

Go to the documentation of this file.

#ifndef NPSTAT_CDFTRANSFORM1D_HH_
#define NPSTAT_CDFTRANSFORM1D_HH_
 
/*!
// \file CdfTransform1D.hh
//
// \brief Coordinate transform y = a*cdf(x) + b, where cdf(x) is provided
//        by some cumulative distribution function
//
// Author: I. Volobouev
//
// February 2023
*/
 
#include "npstat/stat/AbsDistributionTransform1D.hh"
#include "npstat/stat/AbsDistribution1D.hh"
 
namespace npstat {
    class CdfTransform1D : public AbsDistributionTransform1D
    {
    public:
        CdfTransform1D(const AbsDistribution1D& distro, double a, double b);
 
        inline CdfTransform1D(const CdfTransform1D& r)
            : AbsDistributionTransform1D(r), distro_(r.distro_->clone()),
              a_(r.a_), b_(r.b_), xmin_(r.xmin_), xmax_(r.xmax_) {}
 
        CdfTransform1D& operator=(const CdfTransform1D& r);
 
        inline virtual ~CdfTransform1D() {delete distro_;}
 
        inline virtual CdfTransform1D* clone() const
            {return new CdfTransform1D(*this);}
 
        inline double a() const {return a_;}
        inline double b() const {return b_;}
        inline double xmin() const {return xmin_;}
        inline double xmax() const {return xmax_;}
 
        double transformForward(double x, double* dydx) const;
        double transformBack(double y) const;
        inline bool isIncreasing() const {return a_ > 0.0;}
 
        //@{
        /** 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::CdfTransform1D";}
        static inline unsigned version() {return 1;}
        static CdfTransform1D* read(const gs::ClassId& id, std::istream&);
 
    protected:
        inline bool isEqual(const AbsDistributionTransform1D& o) const
        {
            const CdfTransform1D& r = 
                static_cast<const CdfTransform1D&>(o);
            return *distro_ == *r.distro_ && a_ == r.a_&& b_ == r.b_;
        }
 
    private:
        inline void setParameterChecked(const unsigned which,
                                        const double value)
        {
            if (which)
                b_ = value;
            else
            {
                validateScale(value);
                a_ = value;
            }
        }
        inline void setAllParametersChecked(const double* p)
        {
            validateScale(p[0]);
            a_ = p[0];
            b_ = p[1];
        }
        inline double getParameterChecked(const unsigned which) const
            {return which ? b_ : a_;}
 
        void validateScale(double a);
 
        const AbsDistribution1D* distro_;
        double a_;
        double b_;
        double xmin_;
        double xmax_;
    };
}
 
#endif // NPSTAT_CDFTRANSFORM1D_HH_