datasources.h

Go to the documentation of this file.

#ifndef DATASOURCE_H
#define DATASOURCE_H


#include "../base/bdmbase.h"
#include "../stat/exp_family.h"
#include "../base/user_info.h"

namespace bdm {
class MemDS : public DS {
protected:
        mat Data;
        int time;
        ivec rowid;
        ivec delays;

public:
        void getdata ( vec &dt );
        void getdata ( vec &dt, const ivec &indeces );
        void set_rvs ( RV &drv, RV &urv );
        void write ( vec &ut ) {
                it_error ( "MemDS::write is not supported" );
        }
        void write ( vec &ut, ivec &indices ) {
                it_error ( "MemDS::write is not supported" );
        }
        void step();
        MemDS () {};
        MemDS ( mat &Dat, ivec &rowid0, ivec &delays0 );
};

class FileDS: public MemDS {

public:
        void getdata ( vec &dt ) {
                it_assert_debug ( dt.length() == Data.rows(), "" );
                dt = Data.get_col ( time );
        };
        void getdata ( vec &dt, const ivec &indeces ) {
                it_assert_debug ( dt.length() == indeces.length(), "" );
                vec tmp ( indeces.length() );
                tmp = Data.get_col ( time );
                dt = tmp ( indeces );
        };
        int ndat() {
                return Data.cols();
        }
        void log_add ( logger &L ) {};
        void logit ( logger &L ) {};
};

class ITppFileDS: public FileDS {

public:
        ITppFileDS ( const string &fname, const string &varname ) : FileDS() {
                it_file it ( fname );
                it << Name ( varname );
                it >> Data;
                time = 0;
                //rowid and delays are ignored
        };

        ITppFileDS () : FileDS() {
        };

        void from_setting ( const Setting &set );

        // TODO dodelat void to_setting( Setting &set ) const;

};

UIREGISTER ( ITppFileDS );
SHAREDPTR ( ITppFileDS );

class CsvFileDS: public FileDS {

public:
        CsvFileDS ( const string& fname, const string& orientation = "BY_COL" );
};



class ArxDS : public DS {
protected:
        RV Rrv;
        vec H;
        vec U;
        vec rgr;
        datalink rgrlnk;
        mlnorm<chmat> model;
        bool opt_L_theta;
        int L_theta;
        int L_R;
        int dt_size;
public:
        void getdata ( vec &dt ) {
                //it_assert_debug ( dt.length() ==Drv.count(),"ArxDS" );
                dt = H;
        };
        void getdata ( vec &dt, const ivec &indices ) {
                it_assert_debug ( dt.length() == indices.length(), "ArxDS" );
                dt = H ( indices );
        };
        void write ( vec &ut ) {
                //it_assert_debug ( ut.length() ==Urv.count(),"ArxDS" );
                U = ut;
        };
        void write ( vec &ut, const ivec &indices ) {
                it_assert_debug ( ut.length() == indices.length(), "ArxDS" );
                set_subvector ( U, indices, ut );
        };
        void step();
        ArxDS ( ) {};
        void set_parameters ( const mat &Th0, const vec mu0, const chmat &sqR0 ) {
                model.set_parameters ( Th0, mu0, sqR0 );
        };
        void set_drv ( const RV &yrv, const RV &urv, const RV &rrv ) {
                Rrv = rrv;
                Urv = urv;
                dt_size = yrv._dsize() + urv._dsize();

                RV drv = concat ( yrv, urv );
                Drv = drv;
                int td = rrv.mint();
                H.set_size ( drv._dsize() * ( -td + 1 ) );
                U.set_size ( Urv._dsize() );
                for ( int i = -1; i >= td; i-- ) {
                        drv.t ( -1 );
                        Drv.add ( drv ); //shift u1
                }
                rgrlnk.set_connection ( rrv, Drv );

                dtsize = Drv._dsize();
                utsize = Urv._dsize();
        }
        void set_options ( const string &s ) {
                opt_L_theta = ( s.find ( "L_theta" ) != string::npos );
        };
        virtual void log_add ( logger &L ) {
                //DS::log_add ( L ); too long!!
                L_dt = L.add ( Drv ( 0, dt_size ), "" );
                L_ut = L.add ( Urv, "" );

                mat &A = model._A();
                mat R = model._R();
                if ( opt_L_theta ) {
                        L_theta = L.add ( RV ( "{th }", vec_1 ( A.rows() * A.cols() ) ), "t" );
                }
                if ( opt_L_theta ) {
                        L_R = L.add ( RV ( "{R }", vec_1 ( R.rows() * R.cols() ) ), "r" );
                }
        }
        virtual void logit ( logger &L ) {
                //DS::logit ( L );
                L.logit ( L_dt, H.left ( dt_size ) );
                L.logit ( L_ut, U );

                mat &A = model._A();
                mat R = model._R();
                if ( opt_L_theta ) {
                        L.logit ( L_theta, vec ( A._data(), A.rows() *A.cols() ) );
                };
                if ( opt_L_theta ) {
                        L.logit ( L_R, vec ( R._data(), R.rows() *R.rows() ) );
                };
        }

        // TODO dokumentace - aktualizovat
        void from_setting ( const Setting &set );

        // TODO dodelat void to_setting( Setting &set ) const;
};

UIREGISTER ( ArxDS );
SHAREDPTR ( ArxDS );

class stateDS : public DS {
private:
        shared_ptr<mpdf> IM;

        shared_ptr<mpdf> OM;

protected:
        vec dt;
        vec xt;
        vec ut;
        int L_xt;

public:
        void getdata ( vec &dt0 ) {
                dt0 = dt;
        }
        void getdata ( vec &dt0, const ivec &indeces ) {
                dt0 = dt ( indeces );
        }

        stateDS ( const shared_ptr<mpdf> &IM0, const shared_ptr<mpdf> &OM0, int usize ) : IM ( IM0 ), OM ( OM0 ),
                dt ( OM0->dimension() ), xt ( IM0->dimension() ),
                ut ( usize ), L_xt(0) { }

        stateDS() : L_xt(0) { }

        virtual void step() {
                xt = IM->samplecond ( concat ( xt, ut ) );
                dt = OM->samplecond ( concat ( xt, ut ) );
        }

        virtual void log_add ( logger &L ) {
                DS::log_add ( L );
                L_xt = L.add ( IM->_rv(), "true" );
        }
        virtual void logit ( logger &L ) {
                DS::logit ( L );
                L.logit ( L_xt, xt );
        }

        void from_setting ( const Setting &set );

        // TODO dodelat void to_setting( Setting &set ) const;

};

UIREGISTER ( stateDS );
SHAREDPTR ( stateDS );

}; //namespace

#endif // DS_H

---