work/mixpp/bdm/stat/libEF.h

Go to the documentation of this file.

#ifndef EF_H
#define EF_H

#include <itpp/itbase.h>
#include "../math/libDC.h"
#include "libBM.h"
#include "../itpp_ext.h"
//#include <std>

using namespace itpp;


extern Uniform_RNG UniRNG;
extern Normal_RNG NorRNG;
extern Gamma_RNG GamRNG;


class eEF : public epdf {

public:
        eEF() :epdf() {};

        eEF ( const RV &rv ) :epdf ( rv ) {};

        virtual void tupdate ( double phi, mat &vbar, double nubar ) {};

        virtual void dupdate ( mat &v,double nu=1.0 ) {};
};

class mEF : public mpdf {

public:
        mEF ( const RV &rv0, const RV &rvc0 ) :mpdf ( rv0,rvc0 ) {};
};

template<class sq_T>

class enorm : public eEF {
protected:
        vec mu;
        sq_T R;
        sq_T _iR;
        bool cached;
        int dim;
public:
        enorm() :eEF() {};

        enorm ( RV &rv );
        void set_parameters ( const vec &mu,const sq_T &R );
        void tupdate ( double phi, mat &vbar, double nubar );
        void dupdate ( mat &v,double nu=1.0 );

        vec sample();
        mat sample ( int N );
        double eval ( const vec &val );
        double evalpdflog ( const vec &val );
        vec mean(){return mu;}

//Access methods
        vec* _mu() {return &mu;}

        void _R ( sq_T* &pR, sq_T* &piR ) {
                pR=&R;
                piR=&_iR;
        }

        void _cached ( bool what ) {cached=what;}
};

class egamma : public eEF {
protected:
        vec alpha;
        vec beta;
public :
        egamma ( const RV &rv ) :eEF ( rv ) {};
        void set_parameters ( const vec &a, const vec &b ) {alpha=a,beta=b;};
        vec sample();
        mat sample ( int N );
        double evalpdflog ( const vec val );
        void _param ( vec* &a, vec* &b ) {a=&alpha;b=&beta;};
        vec mean(){vec pom(alpha); pom/=beta; return pom;}
};

class emix : public epdf {
protected:
        int n;
        vec &w;
        Array<epdf*> Coms;
public:
        emix ( const RV &rv, vec &w0): epdf(rv), n(w0.length()), w(w0), Coms(n) {};
        void set_parameters( int &i, epdf* ep){Coms(i)=ep;}
        vec mean(){vec pom; for(int i=0;i<n;i++){pom+=Coms(i)->mean()*w(i);} return pom;};
        vec sample() {it_error ( "Not implemented" );return 0;}
};


class euni: public epdf {
protected:
        vec low;
        vec high;
        vec distance;
        double nk,lnk;
public:
        euni ( const RV rv ) :epdf ( rv ) {}
        double eval ( const vec &val ) {return nk;}
        double evalpdflog ( const vec &val ) {return lnk;}
        vec sample() {
                vec smp ( rv.count() ); UniRNG.sample_vector ( rv.count(),smp );
                return low+distance*smp;
        }
        void set_parameters ( const vec &low0, const vec &high0 ) {
                distance = high0-low0;
                it_assert_debug ( min ( distance ) >0.0,"bad support" );
                low = low0;
                high = high0;
                nk = prod ( 1.0/distance );
                lnk = log ( nk );
        }
        vec mean(){vec pom=high; pom-=low; pom/=2.0; return pom;}
};


template<class sq_T>
class mlnorm : public mEF {
        enorm<sq_T> epdf;
        vec* _mu; //cached epdf.mu;
        mat A;
public:
        mlnorm ( RV &rv,RV &rvc );
        void set_parameters ( const  mat &A, const sq_T &R );
        vec samplecond ( vec &cond, double &lik );
        mat samplecond ( vec &cond, vec &lik, int n );
        void condition ( vec &cond );
};

class mgamma : public mEF {
        egamma epdf;
        double k;
        vec* _beta;

public:
        mgamma ( const RV &rv,const RV &rvc );
        void set_parameters ( double k );
        vec samplecond ( vec &cond, double &lik );
        mat samplecond ( vec &cond, vec &lik, int n );
        void condition ( const vec &val ) {*_beta=k/val;};
};

enum RESAMPLING_METHOD { MULTINOMIAL = 0, STRATIFIED = 1, SYSTEMATIC = 3 };
class eEmp: public epdf {
protected :
        int n;
        vec w;
        Array<vec> samples;
public:
        eEmp ( const RV &rv0 ) :epdf ( rv0 ) {};
        void set_parameters ( const vec &w0, epdf* pdf0 );
        vec& _w()  {return w;};
        Array<vec>& _samples() {return samples;};
        ivec resample ( RESAMPLING_METHOD method = SYSTEMATIC );
        vec sample() {it_error ( "Not implemented" );return 0;}
        vec mean(){vec pom; 
                for (int i=0;i<n;i++){pom+=samples(i)*w(i);}
                return pom;
        }
};



template<class sq_T>
enorm<sq_T>::enorm ( RV &rv ) :eEF(), mu ( rv.count() ),R ( rv.count() ),_iR ( rv.count() ),cached ( false ),dim ( rv.count() ) {};

template<class sq_T>
void enorm<sq_T>::set_parameters ( const vec &mu0, const sq_T &R0 ) {
//Fixme test dimensions of mu0 and R0;
        mu = mu0;
        R = R0;
        if ( _iR.rows() !=R.rows() ) _iR=R; // memory allocation!
        R.inv ( _iR ); //update cache
        cached=true;
};

template<class sq_T>
void enorm<sq_T>::dupdate ( mat &v, double nu ) {
        //
};

template<class sq_T>
void enorm<sq_T>::tupdate ( double phi, mat &vbar, double nubar ) {
        //
};

template<class sq_T>
vec enorm<sq_T>::sample() {
        vec x ( dim );
        NorRNG.sample_vector ( dim,x );
        vec smp = R.sqrt_mult ( x );

        smp += mu;
        return smp;
};

template<class sq_T>
mat enorm<sq_T>::sample ( int N ) {
        mat X ( dim,N );
        vec x ( dim );
        vec pom;
        int i;

        for ( i=0;i<N;i++ ) {
                NorRNG.sample_vector ( dim,x );
                pom = R.sqrt_mult ( x );
                pom +=mu;
                X.set_col ( i, pom );
        }

        return X;
};

template<class sq_T>
double enorm<sq_T>::eval ( const vec &val ) {
        double pdfl,e;
        pdfl = evalpdflog ( val );
        e = exp ( pdfl );
        return e;
};

template<class sq_T>
double enorm<sq_T>::evalpdflog ( const vec &val ) {
        if ( !cached ) {R.inv ( _iR );cached=true;}

        return -0.5* ( R.cols() *0.79817986835811504957 +R.logdet() +_iR.qform ( mu-val ) );
};


template<class sq_T>
mlnorm<sq_T>::mlnorm ( RV &rv0,RV &rvc0 ) :mEF ( rv0,rvc0 ),epdf ( rv ),A ( rv0.count(),rv0.count() ) {
        _mu = epdf._mu();
}

template<class sq_T>
void mlnorm<sq_T>::set_parameters ( const mat &A0, const sq_T &R0 ) {
        epdf.set_parameters ( zeros ( rv.count() ),R0 );
        A = A0;
}

template<class sq_T>
vec mlnorm<sq_T>::samplecond ( vec &cond, double &lik ) {
        this->condition ( cond );
        vec smp = epdf.sample();
        lik = epdf.eval ( smp );
        return smp;
}

template<class sq_T>
mat mlnorm<sq_T>::samplecond ( vec &cond, vec &lik, int n ) {
        int i;
        int dim = rv.count();
        mat Smp ( dim,n );
        vec smp ( dim );
        this->condition ( cond );

        for ( i=0; i<n; i++ ) {
                smp = epdf.sample();
                lik ( i ) = epdf.eval ( smp );
                Smp.set_col ( i ,smp );
        }

        return Smp;
}

template<class sq_T>
void mlnorm<sq_T>::condition ( vec &cond ) {
        *_mu = A*cond;
//R is already assigned;
}



#endif //EF_H

---