EllipticalDistribution.hh

Go to the documentation of this file.

#ifndef NPSTAT_ELLIPTICALDISTRIBUTION_HH_
#define NPSTAT_ELLIPTICALDISTRIBUTION_HH_
 
/*!
// \file EllipticalDistribution.hh
//
// \brief Multivariate elliptical ditributions
//
// Author: I. Volobouev
//
// September 2022
*/
 
#include <vector>
 
#include "npstat/nm/Matrix.hh"
 
#include "npstat/stat/AbsDistribution1D.hh"
#include "npstat/stat/AbsDistributionND.hh"
 
namespace npstat {
    class EllipticalDistribution : public AbsDistributionND
    {
    public:
        /**
        // The constructor arguments are as follows:
        //
        // location, dim         The shift and the dimensionality of
        //                       the distribution. The array "location"
        //                       must have at least "dim" elements.
        //
        // transformationMatrix  The square matrix for generating random
        //                       variables from this density according to
        //                       x = location + transformationMatrix*y,
        //                       where y is a spherically distributed
        //                       random variable. For multivariate normal,
        //                       transformationMatrix is the square root
        //                       of the covariance matrix.
        //
        // gDistro               The "generator" distribution. The
        //                       multivariate density is going to be
        //                       proportional to gDistro.density(chi-square),
        //                       where chi-square variable is constructed
        //                       as in the multivariate normal.
        //                       Must have gDistro.quantile(0.0) = 0.0.
        //
        // hDistro               Distribution of the r^2 variable. Must have
        //                       hDistro.quantile(0.0) = 0.0.
        */
        EllipticalDistribution(const double* location, unsigned dim,
                               const Matrix<double>& transformationMatrix,
                               const AbsDistribution1D& gDistro,
                               const AbsDistribution1D& hDistro);
 
        EllipticalDistribution(const EllipticalDistribution&);
        EllipticalDistribution& operator=(const EllipticalDistribution&);
 
        inline virtual EllipticalDistribution* clone() const
            {return new EllipticalDistribution(*this);}
 
        inline virtual ~EllipticalDistribution() {cleanup();}
 
        virtual double density(const double* x, unsigned dim) const;
        virtual void unitMap(const double* rnd, unsigned bufLen, double* x) const;
        inline virtual bool mappedByQuantiles() const {return false;}
        virtual unsigned random(AbsRandomGenerator& g,
                                double* x, unsigned lenX) const;
 
        /** This function returns the value of the quadratic form */
        double chiSquare(const double* x, unsigned dim) const;
 
        inline const AbsDistribution1D& getGDistro() const {return *g_;}
        inline const AbsDistribution1D& getHDistro() const {return *h_;}
        inline const Matrix<double>& getTransformationMatrix() const
            {return A_;}
        inline const std::vector<double>& getShift() const {return mu_;}
 
        // Methods needed for I/O
        inline virtual gs::ClassId classId() const {return gs::ClassId(*this);}
        virtual bool write(std::ostream& os) const;
 
        static inline const char* classname()
            {return "npstat::EllipticalDistribution";}
        static inline unsigned version() {return 1;}
        static EllipticalDistribution* read(const gs::ClassId& id,
                                            std::istream& in);
    protected:
        virtual bool isEqual(const AbsDistributionND&) const;
 
        std::vector<double> mu_;
        Matrix<double> A_;
        Matrix<double> InvCovmat_;
        AbsDistribution1D* g_;
        AbsDistribution1D* h_;
        double det_;
        double gNorm_;
 
    private:
        EllipticalDistribution();
        void initialize(const AbsDistribution1D& g, const AbsDistribution1D& h);
        void cleanup();
 
        mutable std::vector<double> buf_;
 
#ifdef SWIG
    public:
        inline EllipticalDistribution(const double* location1, unsigned dim1,
                                      const double* transform, unsigned nrows, unsigned ncols,
                                      const AbsDistribution1D& gDistro,
                                      const AbsDistribution1D& hDistro)
            : AbsDistributionND(dim1),
              mu_(location1, location1+dim1),
              A_(nrows, ncols, transform),
              g_(0),
              h_(0),
              det_(0.0),
              gNorm_(0.0),
              buf_(dim1)
        {
            assert(location1);
            assert(dim1);
            assert(transform);
            initialize(gDistro, hDistro);
        }
 
        inline AbsDistribution1D* getGDistro2() const {return g_->clone();}
        inline AbsDistribution1D* getHDistro2() const {return h_->clone();}
        inline Matrix<double> getTransformationMatrix2() const
            {return A_;}
        inline std::vector<double> getShift2() const {return mu_;}
#endif // SWIG
    };
}
 
#endif // NPSTAT_ELLIPTICALDISTRIBUTION_HH_