merger.h

Go to the documentation of this file.

#ifndef MER_H
#define MER_H


#include "mixef.h"

namespace bdm
{
        using std::string;

        class merger : public compositepdf, public epdf
        {
                protected:
                        MixEF Mix;
                        Array<datalink_m2e*> dls;
                        Array<RV> rvzs;
                        Array<datalink_m2e*> zdls;

                        int Ns;
                        int Nc;
                        double beta;
                        eEmp eSmp;

                        bool DBG;
                        it_file* dbg;
                        bool fix_smp;
                public:
                        merger ( const Array<mpdf*> &S ) :
                                        compositepdf ( S ), epdf ( ),
                                        Mix ( Array<BMEF*> ( 0 ),vec ( 0 ) ), dls ( n ), rvzs ( n ), zdls ( n ), eSmp()
                        {
                                RV ztmp;
                                rv = getrv ( false );
                                RV rvc; setrvc ( rv,rvc ); // Extend rv by rvc!
                                rv.add ( rvc );
                                // get dimension
                                dim = rv._dsize();

                                for ( int i=0;i<n;i++ )
                                {
                                        //Establich connection between mpdfs and merger
                                        dls ( i ) = new datalink_m2e;dls ( i )->set_connection ( mpdfs ( i )->_rv(), mpdfs ( i )->_rvc(), rv );
                                        // find out what is missing in each mpdf
                                        ztmp= mpdfs ( i )->_rv();
                                        ztmp.add ( mpdfs ( i )->_rvc() );
                                        rvzs ( i ) =rv.subt ( ztmp );
                                        zdls ( i ) = new datalink_m2e; zdls ( i )->set_connection ( rvzs ( i ), ztmp, rv ) ;
                                };
                                //Set Default values of parameters
                                beta=2.0;
                                Ns=100;
                                Nc=10;
                                Mix.set_method ( EM );
                                DBG = false;
                                fix_smp = false;
                        }
                        void debug_file ( const string fname ) { if ( DBG ) delete dbg; dbg = new it_file ( fname ); if ( dbg ) DBG=true;}
                        void set_parameters ( double beta0, int Ns0, int Nc0 ) {beta=beta0;Ns=Ns0;Nc=Nc0;eSmp.set_parameters ( Ns0,false );}
                        void set_grid ( Array<vec> &XYZ )
                        {
                                int dim=XYZ.length(); ivec szs ( dim );
                                for(int i=0; i<dim;i++){szs=XYZ(i).length();}
                                Ns=prod(szs);
                                eSmp.set_parameters(Ns,false);
                                Array<vec> &samples=eSmp._samples();
                                eSmp._w()=ones(Ns)/Ns;
                                                
                                //set samples
                                ivec is=zeros_i(dim);//indeces of dimensions in for cycle;
                                vec smpi(dim);
                                for(int i=0; i<Ns; i++){
                                        for(int j=0; j<dim; j++){smpi(j)=XYZ(j)(is(j)); /* jty vector*/ }
                                        samples(i)=smpi;
                                        // shift indeces
                                        for (int j=0;j<dim;j++){
                                                if (is(j)==szs(j)-1) { //j-th index is full
                                                        is(j)=0; //shift back
                                                        is(j+1)++; //increase th next dimension;
                                                        if (is(j+1)<szs(j+1)-1) break;
                                                } else {
                                                        is(j)++; break;
                                                }
                                        }
                                }
                                
                                fix_smp = true;
                        }
                        void init()   
                        {
                                Array<vec> Smps ( n );
                                //Gibbs sampling
                                for ( int i=0;i<n;i++ ) {Smps ( i ) =zeros ( 0 );}
                        }
                        void merge ( const epdf* g0 );
                        void merge () {merge ( & ( Mix.posterior() ) );};

                        vec lognorm_merge ( mat &lW );
                        vec sample ( ) const { return Mix.posterior().sample();}
                        double evallog ( const vec &dt ) const
                        {
                                vec dtf=ones ( dt.length() +1 );
                                dtf.set_subvector ( 0,dt );
                                return Mix.logpred ( dtf );
                        }
                        vec mean() const
                        {
                                const Vec<double> &w = eSmp._w();
                                const Array<vec> &S = eSmp._samples();
                                vec tmp=zeros ( dim );
                                for ( int i=0; i<Ns; i++ )
                                {
                                        tmp+=w ( i ) *S ( i );
                                }
                                return tmp;
                        }
                        mat covariance() const
                        {
                                const vec &w = eSmp._w();
                                const Array<vec> &S = eSmp._samples();

                                vec mea = mean();

                                cout << sum ( w ) << "," << w*w <<endl;

                                mat Tmp=zeros ( dim, dim );
                                for ( int i=0; i<Ns; i++ )
                                {
                                        Tmp+=w ( i ) *outer_product ( S ( i ), S ( i ) );
                                }
                                return Tmp-outer_product ( mea,mea );
                        }
                        vec variance() const
                        {
                                const vec &w = eSmp._w();
                                const Array<vec> &S = eSmp._samples();

                                vec tmp=zeros ( dim );
                                for ( int i=0; i<Ns; i++ )
                                {
                                        tmp+=w ( i ) *pow ( S ( i ),2 );
                                }
                                return tmp-pow ( mean(),2 );
                        }
                        virtual ~merger()
                        {
                                for ( int i=0; i<n; i++ )
                                {
                                        delete dls ( i );
                                        delete zdls ( i );
                                }
                                if ( DBG ) delete dbg;
                        };

                        MixEF& _Mix() {return Mix;}
                        eEmp& _Smp() {return eSmp;}
        };

}

#endif // MER_H

---