work/git/mixpp/bdm/stat/emix.h

Go to the documentation of this file.

#ifndef MX_H
#define MX_H

#include "libBM.h"
#include "libEF.h"
//#include <std>

using namespace itpp;

//this comes first because it is used inside emix!

class mratio: public mpdf {
protected:
        const epdf* nom;
        epdf* den;
        bool destroynom;
        datalink_m2e dl;
public:
        mratio ( const epdf* nom0, const RV &rv, bool copy=false ) :mpdf ( rv,nom0->_rv().subt ( rv ) ), dl ( rv,rvc,nom0->_rv() ) {
                if ( copy ) {
//                      nom = nom0->_copy_();
                        it_error ( "todo" );
                        destroynom=true;
                }
                else {
                        nom = nom0;
                        destroynom = false;
                }
                it_assert_debug ( rvc.length() >0,"Makes no sense to use this object!" );
                den = nom->marginal ( rvc );
        };
        double evalcond ( const vec &val, const vec &cond ) {
                vec nom_val ( rv.count() +rvc.count() );
                dl.fill_val_cond ( nom_val,val,cond );
                return exp ( nom->evalpdflog ( nom_val ) - den->evalpdflog ( cond ) );
        }
        void ownnom() {destroynom=true;}
        ~mratio() {delete den; if ( destroynom ) {delete nom;}}
};

class emix : public epdf {
protected:
        vec w;
        Array<epdf*> Coms;
        bool destroyComs;
public:
        emix ( const RV &rv ) : epdf ( rv ) {};
        void set_parameters ( const vec &w, const Array<epdf*> &Coms, bool copy=true );

        vec sample() const;
        vec mean() const {
                int i; vec mu = zeros ( rv.count() );
                for ( i = 0;i < w.length();i++ ) {mu += w ( i ) * Coms ( i )->mean(); }
                return mu;
        }
        double evalpdflog ( const vec &val ) const {
                int i;
                double sum = 0.0;
                for ( i = 0;i < w.length();i++ ) {sum += w ( i ) * exp ( Coms ( i )->evalpdflog ( val ) );}
                return log ( sum );
        };
        vec evalpdflog_m ( const mat &Val ) const {
                vec x=zeros ( Val.cols() );
                for ( int i = 0; i < w.length(); i++ ) {
                        x+= w ( i ) *exp ( Coms ( i )->evalpdflog_m ( Val ) );
                }
                return log ( x );
        };
        mat evalpdflog_M ( const mat &Val ) const {
                mat X ( w.length(), Val.cols() );
                for ( int i = 0; i < w.length(); i++ ) {
                        X.set_row ( i, w ( i ) *exp ( Coms ( i )->evalpdflog_m ( Val ) ) );
                }
                return X;
        };

        emix* marginal ( const RV &rv ) const;
        mratio* condition ( const RV &rv ) const; //why not mratio!!

//Access methods
        vec& _w() {return w;}
        virtual ~emix() {if ( destroyComs ) {for ( int i=0;i<Coms.length();i++ ) {delete Coms ( i );}}}
        void ownComs() {destroyComs=true;}

        epdf* _Coms ( int i ) {return Coms ( i );}
};

class mprod: public compositepdf, public mpdf {
protected:
        Array<epdf*> epdfs;
        Array<datalink_m2m*> dls;
public:
        mprod ( Array<mpdf*> mFacs ) : compositepdf ( mFacs ), mpdf ( getrv ( true ),RV() ), epdfs ( n ), dls ( n ) {
                setrvc ( rv,rvc );
                // rv and rvc established = > we can link them with mpdfs
                for ( int i = 0;i < n;i++ ) {
                        dls ( i ) = new datalink_m2m ( mpdfs ( i )->_rv(), mpdfs ( i )->_rvc(), rv, rvc );
                }

                for ( int i=0;i<n;i++ ) {
                        epdfs ( i ) =& ( mpdfs ( i )->_epdf() );
                }
        };

        double evalcond ( const vec &val, const vec &cond ) {
                int i;
                double res = 1.0;
                for ( i = n - 1;i >= 0;i-- ) {
                        /*                      if ( mpdfs(i)->_rvc().count() >0) {
                                                        mpdfs ( i )->condition ( dls ( i )->get_cond ( val,cond ) );
                                                }
                                                // add logarithms
                                                res += epdfs ( i )->evalpdflog ( dls ( i )->get_val ( val ) );*/
                        res *= mpdfs ( i )->evalcond (
                                   dls ( i )->get_val ( val ),
                                   dls ( i )->get_cond ( val, cond )
                               );
                }
                return res;
        }
        vec samplecond ( const vec &cond, double &ll ) {
                vec smp= std::numeric_limits<double>::infinity() * ones ( rv.count() );
                vec smpi;
                ll = 0;
                // Hard assumption here!!! We are going backwards, to assure that samples that are needed from smp are already generated!
                for ( int i = ( n - 1 );i >= 0;i-- ) {
                        if ( mpdfs ( i )->_rvc().count() ) {
                                mpdfs ( i )->condition ( dls ( i )->get_cond ( smp ,cond ) ); // smp is val here!!
                        }
                        smpi = epdfs ( i )->sample();
                        // copy contribution of this pdf into smp
                        dls ( i )->fill_val ( smp, smpi );
                        // add ith likelihood contribution
                        ll+=epdfs ( i )->evalpdflog ( smpi );
                }
                return smp;
        }
        mat samplecond ( const vec &cond, vec &ll, int N ) {
                mat Smp ( rv.count(),N );
                for ( int i=0;i<N;i++ ) {Smp.set_col ( i,samplecond ( cond,ll ( i ) ) );}
                return Smp;
        }

        ~mprod() {};
};

class eprod: public epdf {
protected:
        Array<const epdf*> epdfs;
        Array<datalink_e2e*> dls;
public:
        eprod ( const Array<const epdf*> epdfs0 ) : epdf ( RV() ),epdfs ( epdfs0 ),dls ( epdfs.length() ) {
                bool independent=true;
                for ( int i=0;i<epdfs.length();i++ ) {
                        independent=rv.add ( epdfs ( i )->_rv() );
                        it_assert_debug ( independent==true, "eprod:: given components are not independent ." );
                }
                for ( int i=0;i<epdfs.length();i++ ) {
                        dls ( i ) = new datalink_e2e ( epdfs ( i )->_rv() , rv );
                }
        }

        vec mean() const {
                vec tmp ( rv.count() );
                for ( int i=0;i<epdfs.length();i++ ) {
                        vec pom = epdfs ( i )->mean();
                        dls ( i )->fill_val ( tmp, pom );
                }
                return tmp;
        }
        vec sample() const {
                vec tmp ( rv.count() );
                for ( int i=0;i<epdfs.length();i++ ) {
                        vec pom = epdfs ( i )->sample();
                        dls ( i )->fill_val ( tmp, pom );
                }
                return tmp;
        }
        double evalpdflog ( const vec &val ) const {
                double tmp=0;
                for ( int i=0;i<epdfs.length();i++ ) {
                        tmp+=epdfs ( i )->evalpdflog ( dls ( i )->get_val ( val ) );
                }
                return tmp;
        }
        const epdf* operator () ( int i ) const {it_assert_debug ( i<epdfs.length(),"wrong index" );return epdfs ( i );}

        ~eprod() {for ( int i=0;i<epdfs.length();i++ ) {delete dls ( i );}}
};


class mmix : public mpdf {
protected:
        Array<mpdf*> Coms;
        emix Epdf;
public:
        mmix ( RV &rv, RV &rvc ) : mpdf ( rv, rvc ), Epdf ( rv ) {ep = &Epdf;};
        void set_parameters ( const vec &w, const Array<mpdf*> &Coms ) {
                Array<epdf*> Eps ( Coms.length() );

                for ( int i = 0;i < Coms.length();i++ ) {
                        Eps ( i ) = & ( Coms ( i )->_epdf() );
                }
                Epdf.set_parameters ( w, Eps );
        };

        void condition ( const vec &cond ) {
                for ( int i = 0;i < Coms.length();i++ ) {Coms ( i )->condition ( cond );}
        };
};

#endif //MX_H

---