np_suffies.h

Go to the documentation of this file.

#pragma once

#include <Eigen/Dense>
#include <map>

enum distribution_type_t { 
    // gamma
    Gamma,
    // normals
    Normal, Unity_Normal,
    // multivariate normals
    MultivariateNormal, Unity_MultivariateNormal, ZeroCentered_MultivariateNormal, ScalarNoise_MultivariateNormal,
    // inverse wisharts and alike, useful as priors for normals
    NormalInvWishart, InvWishart, NormalInvGamma, 
    // hierarchical priors
    Dirichlet
};

static std::map< distribution_type_t, const char * > distribution_type_str = {
    {Gamma,                            "gamma"},
    {Normal,                           "normal"},
    {Unity_Normal,                     "unity normal"},
    {MultivariateNormal,               "multivariate normal"},
    {Unity_MultivariateNormal,         "unity multivariate normal"},
    {ZeroCentered_MultivariateNormal,  "zero-centered multivariate normal"},
    {ScalarNoise_MultivariateNormal,   "zero-centered multivariate normal"},
    {NormalInvWishart,                 "normal inverse-Wishart"},
    {InvWishart,                       "inverse-Wishart"},
    {NormalInvGamma,                   "normal inverse-Gamma"},
    {Dirichlet,                        "Dirichlet"}
};

static Eigen::IOFormat CommaInitFmt(Eigen::StreamPrecision, Eigen::DontAlignCols, " ", "; ", "", "", "", "");

class Suffies {
    public:
        int D;

        distribution_type_t distribution_type;

        virtual ~Suffies() {
        };

        virtual void print(std::ostream& os) const {
            os << D << " (probably a copy by value rather than copy by reference somewhere?)";
        }

        friend std::ostream& operator<<(std::ostream& os, const Suffies& s);  
};

class Suffies_Gamma: public Suffies {
    public:
        double alpha;
        double beta;

        Suffies_Gamma() {
            distribution_type = Gamma;
        }
        
        void print(std::ostream& os) const {
            os << "g[alpha|beta]: " << alpha << " | " << beta;
        }
};

class Suffies_NormalInvWishart: public Suffies {
    public:
        Eigen::VectorXd mu;
        double kappa;
        double nu;
        Eigen::MatrixXd Lambda;
        
        Suffies_NormalInvWishart(int D): mu(D), Lambda(D,D) {
            Suffies::D = D;
            distribution_type = NormalInvWishart;
        }
        
        void print(std::ostream& os) const {
            os << "niw[nu|kappa|nu|Lambda]: " << nu << " | " << kappa << " | " << nu << " | " << Lambda.format(CommaInitFmt);
        }
};

class Suffies_InvWishart: public Suffies {
    public:
        double nu;
        Eigen::MatrixXd Lambda;
        
        Suffies_InvWishart(int D): Lambda(D,D) {
            Suffies::D = D;
            distribution_type = InvWishart;
        }
        
        void print(std::ostream& os) const {
            os << "iw[nu|Lambda]: " << nu << " | " << Lambda.format(CommaInitFmt);
        }
};

class Suffies_NormalInvGamma: public Suffies {
    public:
        Eigen::VectorXd mu;
        double alpha;
        double beta;
        //double gamma;
        Eigen::MatrixXd Lambda; // the multidimensional version
        
        Suffies_NormalInvGamma(int D): mu(D), Lambda(D,D) {
            Suffies::D = D;
            distribution_type = NormalInvGamma;
        }
        
        void print(std::ostream& os) const {
            os << "nig[mu|alpha|beta|gamma]: " << mu << " | " << alpha << " | " << beta << " | " << Lambda.format(CommaInitFmt);
        }
};

class Suffies_Normal: public Suffies {
    public:
        double mu;
        double sigma;
    
        Suffies_Normal() {
            distribution_type = Normal;
        }

        void print(std::ostream& os) const {
            os << "n[mu|sigma]: " << mu << " | " << sigma;
        }
};

class Suffies_Double: public Suffies {
    public:
        double val;

        void print(std::ostream& os) const {
            os << "[val]: " << val;
        }
};

class Suffies_Unity_MultivariateNormal: public Suffies {
    public:
        Eigen::VectorXd mu;

        Suffies_Unity_MultivariateNormal(int D): mu(D) {
            Suffies::D = D;
            distribution_type = Unity_MultivariateNormal;
        }
        
        void print(std::ostream& os) const {
            os << "mvn[mu]: " << mu;
        }
};

class Suffies_ZeroCentered_MultivariateNormal: public Suffies {
    public:
        Eigen::MatrixXd sigma;
        
        Suffies_ZeroCentered_MultivariateNormal(int D): sigma(D, D) {
            Suffies::D = D;
            distribution_type = ZeroCentered_MultivariateNormal;
        }
        
        void print(std::ostream& os) const {
            os << "mvn[sigma]: " << sigma.format(CommaInitFmt);
        }
};

class Suffies_MultivariateNormal: public Suffies {
    public:
        Eigen::VectorXd mu;
        Eigen::MatrixXd sigma;
        
        Suffies_MultivariateNormal(int D): mu(D), sigma(D,D) {
            Suffies::D = D;
            distribution_type = MultivariateNormal;
        }
        
        void print(std::ostream& os) const {
            os << "mvn[mu|sigma]: " << mu.transpose() << " | " << sigma.format(CommaInitFmt);
        }
};

class Suffies_ScalarNoise_MultivariateNormal: public Suffies {
    public:
        Eigen::VectorXd mu;
        double sigma;
        
        Suffies_ScalarNoise_MultivariateNormal(int D): mu(D)  {
            Suffies::D = D;
            distribution_type = ScalarNoise_MultivariateNormal;
        }
        
        void print(std::ostream& os) const {
            os << "mvn[mu|sigma]: " << mu.transpose() << " | " << sigma;
        }
};

class Suffies_Dirichlet: public Suffies {
    public:
        double alpha;
//      Suffies base_suffies;

        Suffies_Dirichlet() {
            distribution_type = Dirichlet;
        }

        void print(std::ostream& os) const {
            os << "d[alpha]: " << alpha;
        }
        
};