Changeset 263

Timestamp:

02/09/09 23:11:35 (16 years ago)

Author:

smidl

Message:

UIArxDS test

Files:

• bdm/itpp_ext.cpp (modified) (1 diff)
• bdm/itpp_ext.h (modified) (1 diff)
• bdm/stat/libBM.cpp (modified) (1 diff)
• bdm/stat/libBM.h (modified) (2 diffs)
• bdm/stat/libDS.cpp (modified) (1 diff)
• bdm/stat/libDS.h (modified) (1 diff)
• bdm/stat/loggers.h (modified) (2 diffs)
• bdm/stat/loggers_ui.h (modified) (1 diff)
• bdm/uibuilder.h (modified) (1 diff)
• bdm/userinfo.cpp_old (moved) (moved from bdm/userinfo.cpp)
• bdm/userinfo.h_old (moved) (moved from bdm/userinfo.h)
• tests/UI/CMakeLists.txt (modified) (1 diff)
• tests/UI/UIArxDS_test.cfg (added)
• tests/UI/UIArxDS_test.cpp (added)
• tests/arx_test.cpp (modified) (1 diff)

bdm/itpp_ext.cpp

@@ -287 +287 @@
         }
 
+
+        std::string num2str(double d){
+                char tmp[20];//that should do
+                sprintf(tmp,"%f",d);
+                return std::string(tmp);
+        };
+        std::string num2str(int i){
+                char tmp[10];//that should do
+                sprintf(tmp,"%d",i);
+                return std::string(tmp);
+        };
 }

bdm/itpp_ext.h

@@ -76 +76 @@
         bool qr ( const mat &A, mat &R );
 
+        //! reimplementation of matlab num2str
+        std::string num2str(double d);
+
+        //! reimplementation of matlabs num2str
+        std::string num2str(int i);
 }
 

bdm/stat/libBM.cpp

@@ -51 +51 @@
 
 RV::RV() : tsize ( 0 ), len ( 0 ), ids ( 0 ),  sizes ( 0 ), times ( 0 ),names ( 0 ) {};
+
+RV::RV(string name, int id){
+        it_assert(id>=RVcounter,"RV::This id is already taken");
+        RVcounter=id;
+        Array<string> A(1); A(0)=name;
+        init(vec_1(id),A,vec_1(1),vec_1(0));
+}
 
 bool RV::add ( const RV &rv2 ) {

bdm/stat/libBM.h

@@ -18 +18 @@
 #define BM_H
 
-#include <itpp/itbase.h>
+
 #include "../itpp_ext.h"
 //#include <std>
 
-namespace bdm{
-using namespace itpp;
+namespace bdm {
+        using namespace itpp;
+        using std::string;
 
 //! Root class of BDM objects
-class bdmroot{
-        virtual void print(){}
-};
+        class bdmroot {
+                virtual void print() {}
+        };
 
 //! Structure of RV (used internally), i.e. expanded RVs
-class str {
-public:
-        //! vector id ids (non-unique!)
-        ivec ids;
-        //! vector of times
-        ivec times;
-        //!Default constructor
-        str ( ivec ids0, ivec times0 ) :ids ( ids0 ),times ( times0 ) {
-                it_assert_debug ( times0.length() ==ids0.length(),"Incompatible input" );
-        };
-};
-
-/*!
-* \brief Class representing variables, most often random variables
-
-* More?...
-*/
-
-class RV :public bdmroot{
-protected:
-        //! size = sum of sizes
-        int tsize;
-        //! len = number of individual rvs
-        int len;
-        //! Vector of unique IDs
-        ivec ids;
-        //! Vector of sizes
-        ivec sizes;
-        //! Vector of shifts from current time
-        ivec times;
-        //! Array of names
-        Array<std::string> names;
-
-private:
-        //! auxiliary function used in constructor
-        void init ( ivec in_ids, Array<std::string> in_names, ivec in_sizes, ivec in_times );
-public:
-        //! Full constructor
-        RV ( Array<std::string> in_names, ivec in_sizes, ivec in_times );
-        //! Constructor with times=0
-        RV ( Array<std::string> in_names, ivec in_sizes );
-        //! Constructor with sizes=1, times=0
-        RV ( Array<std::string> in_names );
-        //! Constructor of empty RV
-        RV ();
-
-        //! Printing output e.g. for debugging.
-        friend std::ostream &operator<< ( std::ostream &os, const RV &rv );
-
-        //! Return number of scalars in the RV.
-        int count() const {return tsize;} ;
-        //! Return length (number of entries) of the RV.
-        int length() const {return len;} ;
-
-        //TODO why not inline and later??
-
-        //! Find indexes of self in another rv, \return ivec of the same size as self.
-        ivec findself ( const RV &rv2 ) const;
-        //! Compare if \c rv2 is identical to this \c RV
-        bool equal ( const RV &rv2 ) const;
-        //! Add (concat) another variable to the current one, \return true if all rv2 were added, false if rv2 is in conflict
-        bool add ( const RV &rv2 );
-        //! Subtract  another variable from the current one
-        RV subt ( const RV &rv2 ) const;
-        //! Select only variables at indeces ind
-        RV subselect ( const ivec &ind ) const;
-        //! Select only variables at indeces ind
-        RV operator() ( const ivec &ind ) const;
-        //! Shift \c time shifted by delta.
-        void t ( int delta );
-        //! generate \c str from rv, by expanding sizes
-        str tostr() const;
-        //! when this rv is a part of bigger rv, this function returns indeces of self in the data vector of the bigger crv.
-        //! Then, data can be copied via: data_of_this = cdata(ind);
-        ivec dataind ( const RV &crv ) const;
-        //! generate mutual indeces when copying data betwenn self and crv.
-        //! Data are copied via: data_of_this(selfi) = data_of_rv2(rv2i)
-        void dataind ( const RV &rv2, ivec &selfi, ivec &rv2i ) const;
-
-        //!access function
-        Array<std::string>& _names() {return names;};
-
-        //!access function
-        int id ( int at ) {return ids ( at );};
-        //!access function
-        int size ( int at ) {return sizes ( at );};
-        //!access function
-        int time ( int at ) {return times ( at );};
-        //!access function
-        std::string name ( int at ) {return names ( at );};
-
-        //!access function
-        void set_id ( int at, int id0 ) {ids ( at ) =id0;};
-        //!access function
-        void set_size ( int at, int size0 ) {sizes ( at ) =size0; tsize=sum ( sizes );};
-        //!access function
-        void set_time ( int at, int time0 ) {times ( at ) =time0;};
-
-        //!Assign unused ids to this rv
-        void newids();
-};
+        class str {
+        public:
+                //! vector id ids (non-unique!)
+                ivec ids;
+                //! vector of times
+                ivec times;
+                //!Default constructor
+                str ( ivec ids0, ivec times0 ) :ids ( ids0 ),times ( times0 ) {
+                        it_assert_debug ( times0.length() ==ids0.length(),"Incompatible input" );
+                };
+        };
+
+        /*!
+        * \brief Class representing variables, most often random variables
+
+        * More?...
+        */
+
+        class RV :public bdmroot {
+        protected:
+                //! size = sum of sizes
+                int tsize;
+                //! len = number of individual rvs
+                int len;
+                //! Vector of unique IDs
+                ivec ids;
+                //! Vector of sizes
+                ivec sizes;
+                //! Vector of shifts from current time
+                ivec times;
+                //! Array of names
+                Array<std::string> names;
+
+        private:
+                //! auxiliary function used in constructor
+                void init ( ivec in_ids, Array<std::string> in_names, ivec in_sizes, ivec in_times );
+        public:
+                //! Full constructor
+                RV ( Array<std::string> in_names, ivec in_sizes, ivec in_times );
+                //! Constructor with times=0
+                RV ( Array<std::string> in_names, ivec in_sizes );
+                //! Constructor with sizes=1, times=0
+                RV ( Array<std::string> in_names );
+                //! Constructor of empty RV
+                RV ();
+                //! Constructor of a single RV with given id
+                RV (string name, int id);
+
+                //! Printing output e.g. for debugging.
+                friend std::ostream &operator<< ( std::ostream &os, const RV &rv );
+
+                //! Return number of scalars in the RV.
+                int count() const {return tsize;} ;
+                //! Return length (number of entries) of the RV.
+                int length() const {return len;} ;
+
+                //TODO why not inline and later??
+
+                //! Find indexes of self in another rv, \return ivec of the same size as self.
+                ivec findself ( const RV &rv2 ) const;
+                //! Compare if \c rv2 is identical to this \c RV
+                bool equal ( const RV &rv2 ) const;
+                //! Add (concat) another variable to the current one, \return true if all rv2 were added, false if rv2 is in conflict
+                bool add ( const RV &rv2 );
+                //! Subtract  another variable from the current one
+                RV subt ( const RV &rv2 ) const;
+                //! Select only variables at indeces ind
+                RV subselect ( const ivec &ind ) const;
+                //! Select only variables at indeces ind
+                RV operator() ( const ivec &ind ) const;
+                //! Shift \c time shifted by delta.
+                void t ( int delta );
+                //! generate \c str from rv, by expanding sizes
+                str tostr() const;
+                //! when this rv is a part of bigger rv, this function returns indeces of self in the data vector of the bigger crv.
+                //! Then, data can be copied via: data_of_this = cdata(ind);
+                ivec dataind ( const RV &crv ) const;
+                //! generate mutual indeces when copying data betwenn self and crv.
+                //! Data are copied via: data_of_this(selfi) = data_of_rv2(rv2i)
+                void dataind ( const RV &rv2, ivec &selfi, ivec &rv2i ) const;
+                //! Minimum time-offset
+                int mint () const {return min ( times );};
+
+                //!access function
+                Array<std::string>& _names() {return names;};
+
+                //!access function
+                int id ( int at ) {return ids ( at );};
+                //!access function
+                int size ( int at ) {return sizes ( at );};
+                //!access function
+                int time ( int at ) {return times ( at );};
+                //!access function
+                std::string name ( int at ) {return names ( at );};
+
+                //!access function
+                void set_id ( int at, int id0 ) {ids ( at ) =id0;};
+                //!access function
+                void set_size ( int at, int size0 ) {sizes ( at ) =size0; tsize=sum ( sizes );};
+                //!access function
+                void set_time ( int at, int time0 ) {times ( at ) =time0;};
+
+                //!Assign unused ids to this rv
+                void newids();
+        };
 
 //! Concat two random variables
-RV concat ( const RV &rv1, const RV &rv2 );
+        RV concat ( const RV &rv1, const RV &rv2 );
 
 //!Default empty RV that can be used as default argument
-extern RV RV0;
+        extern RV RV0;
 
 //! Class representing function \f$f(x)\f$ of variable \f$x\f$ represented by \c rv
 
-class fnc :public bdmroot{
-protected:
-        //! Length of the output vector
-        int dimy;
-public:
-        //!default constructor
-        fnc ( int dy ) :dimy ( dy ) {};
-        //! function evaluates numerical value of \f$f(x)\f$ at \f$x=\f$ \c cond
-        virtual vec eval ( const vec &cond ) {
-                return vec ( 0 );
-        };
-        
-        //! function substitutes given value into an appropriate position 
-        virtual void condition(const vec &val){};
-
-        //! access function
-        int _dimy() const{return dimy;}
-
-        //! Destructor for future use;
-        virtual ~fnc() {};
-};
-
-class mpdf;
+        class fnc :public bdmroot {
+        protected:
+                //! Length of the output vector
+                int dimy;
+        public:
+                //!default constructor
+                fnc ( int dy ) :dimy ( dy ) {};
+                //! function evaluates numerical value of \f$f(x)\f$ at \f$x=\f$ \c cond
+                virtual vec eval ( const vec &cond ) {
+                        return vec ( 0 );
+                };
+
+                //! function substitutes given value into an appropriate position
+                virtual void condition ( const vec &val ) {};
+
+                //! access function
+                int _dimy() const{return dimy;}
+
+                //! Destructor for future use;
+                virtual ~fnc() {};
+        };
+
+        class mpdf;
 
 //! Probability density function with numerical statistics, e.g. posterior density.
 
-class epdf :public bdmroot {
-protected:
-        //! Identified of the random variable
-        RV rv;
-public:
-        //!default constructor
-        epdf() :rv ( ) {};
-
-        //!default constructor
-        epdf ( const RV &rv0 ) :rv ( rv0 ) {};
+        class epdf :public bdmroot {
+        protected:
+                //! Identified of the random variable
+                RV rv;
+        public:
+                //!default constructor
+                epdf() :rv ( ) {};
+
+                //!default constructor
+                epdf ( const RV &rv0 ) :rv ( rv0 ) {};
 
 //      //! Returns the required moment of the epdf
 //      virtual vec moment ( const int order = 1 );
 
-        //! Returns a sample, \f$x\f$ from density \f$epdf(rv)\f$
-        virtual vec sample () const =0;
-        //! Returns N samples from density \f$epdf(rv)\f$
-        virtual mat sample_m ( int N ) const;
-        
-        //! Compute log-probability of argument \c val
-        virtual double evallog ( const vec &val ) const =0;
-
-        //! Compute log-probability of multiple values argument \c val
-        virtual vec evallog_m ( const mat &Val ) const {
-                vec x ( Val.cols() );
-                for ( int i=0;i<Val.cols();i++ ) {x ( i ) =evallog ( Val.get_col ( i ) ) ;}
-                return x;
-        }
-        //! Return conditional density on the given RV, the remaining rvs will be in conditioning
-        virtual mpdf* condition ( const RV &rv ) const  {it_warning ( "Not implemented" ); return NULL;}
-        //! Return marginal density on the given RV, the remainig rvs are intergrated out
-        virtual epdf* marginal ( const RV &rv ) const {it_warning ( "Not implemented" ); return NULL;}
-
-        //! return expected value
-        virtual vec mean() const =0;
-
-        //! return expected variance (not covariance!)
-        virtual vec variance() const = 0;
-        
-        //! Destructor for future use;
-        virtual ~epdf() {};
-        //! access function, possibly dangerous!
-        const RV& _rv() const {return rv;}
-        //! modifier function - useful when copying epdfs
-        void _renewrv ( const RV &in_rv ) {rv=in_rv;}
-        //!
-};
+                //! Returns a sample, \f$x\f$ from density \f$epdf(rv)\f$
+                virtual vec sample () const =0;
+                //! Returns N samples from density \f$epdf(rv)\f$
+                virtual mat sample_m ( int N ) const;
+
+                //! Compute log-probability of argument \c val
+                virtual double evallog ( const vec &val ) const =0;
+
+                //! Compute log-probability of multiple values argument \c val
+                virtual vec evallog_m ( const mat &Val ) const {
+                        vec x ( Val.cols() );
+                        for ( int i=0;i<Val.cols();i++ ) {x ( i ) =evallog ( Val.get_col ( i ) ) ;}
+                        return x;
+                }
+                //! Return conditional density on the given RV, the remaining rvs will be in conditioning
+                virtual mpdf* condition ( const RV &rv ) const  {it_warning ( "Not implemented" ); return NULL;}
+                //! Return marginal density on the given RV, the remainig rvs are intergrated out
+                virtual epdf* marginal ( const RV &rv ) const {it_warning ( "Not implemented" ); return NULL;}
+
+                //! return expected value
+                virtual vec mean() const =0;
+
+                //! return expected variance (not covariance!)
+                virtual vec variance() const = 0;
+
+                //! Destructor for future use;
+                virtual ~epdf() {};
+                //! access function, possibly dangerous!
+                const RV& _rv() const {return rv;}
+                //! modifier function - useful when copying epdfs
+                void _renewrv ( const RV &in_rv ) {rv=in_rv;}
+                //!
+        };
 
 
@@ -219 +224 @@
 //TODO Samplecond can be generalized
 
-class mpdf : public bdmroot{
-protected:
-        //! modeled random variable
-        RV rv;
-        //! random variable in condition
-        RV rvc;
-        //! pointer to internal epdf
-        epdf* ep;
-public:
-
-        //! Returns a sample from the density conditioned on \c cond, \f$x \sim epdf(rv|cond)\f$. \param cond is numeric value of \c rv \param ll is a return value of log-likelihood of the sample.
-        virtual vec samplecond ( const vec &cond, double &ll ) {
-                this->condition ( cond );
-                vec temp= ep->sample();
-                ll=ep->evallog ( temp );return temp;
-        };
-        //! Returns \param N samples from the density conditioned on \c cond, \f$x \sim epdf(rv|cond)\f$. \param cond is numeric value of \c rv \param ll is a return value of log-likelihood of the sample.
-        virtual mat samplecond_m ( const vec &cond, vec &ll, int N ) {
-                this->condition ( cond );
-                mat temp ( rv.count(),N ); vec smp ( rv.count() );
-                for ( int i=0;i<N;i++ ) {smp=ep->sample() ;temp.set_col ( i, smp );ll ( i ) =ep->evallog ( smp );}
-                return temp;
-        };
-        //! Update \c ep so that it represents this mpdf conditioned on \c rvc = cond
-        virtual void condition ( const vec &cond ) {it_error ( "Not implemented" );};
-
-        //! Shortcut for conditioning and evaluation of the internal epdf. In some cases,  this operation can be implemented efficiently.
-        virtual double evallogcond ( const vec &dt, const vec &cond ) {double tmp; this->condition ( cond );tmp = ep->evallog ( dt );           it_assert_debug(std::isfinite(tmp),"Infinite value"); return tmp;
-        };
-
-        //! Matrix version of evallogcond
-        virtual vec evallogcond_m ( const mat &Dt, const vec &cond ) {this->condition ( cond );return ep->evallog_m ( Dt );};
-
-        //! Destructor for future use;
-        virtual ~mpdf() {};
-
-        //! Default constructor
-        mpdf ( const RV &rv0, const RV &rvc0 ) :rv ( rv0 ),rvc ( rvc0 ) {};
-        //! access function
-        RV _rvc() const {return rvc;}
-        //! access function
-        RV _rv() const {return rv;}
-        //!access function
-        epdf& _epdf() {return *ep;}
-        //!access function
-        epdf* _e() {return ep;}
-};
-
-//!DataLink is a connection between an epdf and its superordinate epdf (Up)
-//! It is assumed that my val is fully present in "Up"
-class datalink_e2e {
-protected:
-        //! Remember how long val should be
-        int valsize;
-        //! Remember how long val of "Up" should be
-        int valupsize;
-        //! val-to-val link, indeces of the upper val
-        ivec v2v_up;
-public:
-        //! Constructor
-        datalink_e2e ( const RV &rv, const RV &rv_up ) :
-                        valsize ( rv.count() ), valupsize ( rv_up.count() ), v2v_up ( rv.dataind ( rv_up ) )  {
-                it_assert_debug ( v2v_up.length() ==valsize,"rv is not fully in rv_up" );
+        class mpdf : public bdmroot {
+        protected:
+                //! modeled random variable
+                RV rv;
+                //! random variable in condition
+                RV rvc;
+                //! pointer to internal epdf
+                epdf* ep;
+        public:
+
+                //! Returns a sample from the density conditioned on \c cond, \f$x \sim epdf(rv|cond)\f$. \param cond is numeric value of \c rv \param ll is a return value of log-likelihood of the sample.
+                virtual vec samplecond ( const vec &cond, double &ll ) {
+                        this->condition ( cond );
+                        vec temp= ep->sample();
+                        ll=ep->evallog ( temp );return temp;
+                };
+                //! Returns \param N samples from the density conditioned on \c cond, \f$x \sim epdf(rv|cond)\f$. \param cond is numeric value of \c rv \param ll is a return value of log-likelihood of the sample.
+                virtual mat samplecond_m ( const vec &cond, vec &ll, int N ) {
+                        this->condition ( cond );
+                        mat temp ( rv.count(),N ); vec smp ( rv.count() );
+                        for ( int i=0;i<N;i++ ) {smp=ep->sample() ;temp.set_col ( i, smp );ll ( i ) =ep->evallog ( smp );}
+                        return temp;
+                };
+                //! Update \c ep so that it represents this mpdf conditioned on \c rvc = cond
+                virtual void condition ( const vec &cond ) {it_error ( "Not implemented" );};
+
+                //! Shortcut for conditioning and evaluation of the internal epdf. In some cases,  this operation can be implemented efficiently.
+                virtual double evallogcond ( const vec &dt, const vec &cond ) {
+                        double tmp; this->condition ( cond );tmp = ep->evallog ( dt );          it_assert_debug ( std::isfinite ( tmp ),"Infinite value" ); return tmp;
+                };
+
+                //! Matrix version of evallogcond
+                virtual vec evallogcond_m ( const mat &Dt, const vec &cond ) {this->condition ( cond );return ep->evallog_m ( Dt );};
+
+                //! Destructor for future use;
+                virtual ~mpdf() {};
+
+                //! Default constructor
+                mpdf ( const RV &rv0, const RV &rvc0 ) :rv ( rv0 ),rvc ( rvc0 ) {};
+                //! access function
+                RV _rvc() const {return rvc;}
+                //! access function
+                RV _rv() const {return rv;}
+                //!access function
+                epdf& _epdf() {return *ep;}
+                //!access function
+                epdf* _e() {return ep;}
+        };
+
+        /*! \brief DataLink is a connection between two data vectors Up and Down
+
+        Up can be longer than Down. Down must be fully present in Up (TODO optional)
+        See chart:
+        \dot
+        digraph datalink {
+                node [shape=record];
+                subgraph cluster0 {
+                        label = "Up";
+                up [label="<1>|<2>|<3>|<4>|<5>"];
+                        color = "white"
         }
-        //! Get val for myself from val of "Up"
-        vec get_val ( const vec &val_up ) {it_assert_debug ( valupsize==val_up.length(),"Wrong val_up" ); return get_vec ( val_up,v2v_up );}
-        //! Fill val of "Up" by my pieces
-        void fill_val ( vec &val_up, const vec &val ) {
-                it_assert_debug ( valsize==val.length(),"Wrong val" );
-                it_assert_debug ( valupsize==val_up.length(),"Wrong val_up" );
-                set_subvector ( val_up, v2v_up, val );
+                subgraph cluster1{
+                        label = "Down";
+                        labelloc = b;
+                down [label="<1>|<2>|<3>"];
+                        color = "white"
         }
-};
+            up:1 -> down:1;
+            up:3 -> down:2;
+            up:5 -> down:3;
+        }
+        \enddot
+
+        */
+
+        /*!
+        @brief Class for storing results (and semi-results) of an experiment
+
+        This class abstracts logging of results from implementation. This class replaces direct logging of results (e.g. to files or to global variables) by calling methods of a logger. Specializations of this abstract class for specific storage method are designed.
+        */
+        class logger : public bdmroot {
+        protected:
+                //! RVs of all logged variables.
+                Array<RV> entries;
+                //! Names of logged quantities, e.g. names of algorithm variants
+                Array<string> names;
+        public:
+                //!Default constructor
+                logger ( ) : entries ( 0 ),names ( 0 ) {}
+
+                //! returns an identifier which will be later needed for calling the log() function
+                virtual int add ( const RV &rv, string name="" ) {
+                        int id=entries.length();
+                        names=concat ( names, name ); // diff
+                        entries.set_length ( id+1,true );
+                        entries ( id ) = rv;
+                        return id; // identifier of the last entry
+                }
+
+                //! log this vector
+                virtual void logit ( int id, const vec &v ) =0;
+
+                //! Shifts storage position for another time step.
+                virtual void step() =0;
+
+                //! Finalize storing information
+                virtual void finalize() {};
+
+                //! Initialize the storage
+                virtual void init() {};
+
+                //! for future use
+                virtual ~logger() {};
+        };
+
+        class datalink_e2e {
+        protected:
+                //! Remember how long val should be
+                int valsize;
+                //! Remember how long val of "Up" should be
+                int valupsize;
+                //! val-to-val link, indeces of the upper val
+                ivec v2v_up;
+        public:
+                //! Constructor
+                datalink_e2e ( const RV &rv, const RV &rv_up ) :
+                                valsize ( rv.count() ), valupsize ( rv_up.count() ), v2v_up ( rv.dataind ( rv_up ) )  {
+                        it_assert_debug ( v2v_up.length() ==valsize,"rv is not fully in rv_up" );
+                }
+                //! Get val for myself from val of "Up"
+                vec get_val ( const vec &val_up ) {it_assert_debug ( valupsize==val_up.length(),"Wrong val_up" ); return get_vec ( val_up,v2v_up );}
+                //! Fill val of "Up" by my pieces
+                void fill_val ( vec &val_up, const vec &val ) {
+                        it_assert_debug ( valsize==val.length(),"Wrong val" );
+                        it_assert_debug ( valupsize==val_up.length(),"Wrong val_up" );
+                        set_subvector ( val_up, v2v_up, val );
+                }
+        };
 
 //! data link between
-class datalink_m2e: public datalink_e2e {
-protected:
-        //! Remember how long cond should be
-        int condsize;
-        //!upper_val-to-local_cond link, indeces of the upper val
-        ivec v2c_up;
-        //!upper_val-to-local_cond link, ideces of the local cond
-        ivec v2c_lo;
-
-public:
-        //! Constructor
-        datalink_m2e ( const RV &rv,  const RV &rvc, const RV &rv_up ) :
-                        datalink_e2e ( rv,rv_up ), condsize ( rvc.count() ) {
-                //establish v2c connection
-                rvc.dataind ( rv_up, v2c_lo, v2c_up );
-        }
-        //!Construct condition
-        vec get_cond ( const vec &val_up ) {
-                vec tmp ( condsize );
-                set_subvector ( tmp,v2c_lo,val_up ( v2c_up ) );
-                return tmp;
-        }
-        void fill_val_cond ( vec &val_up, const vec &val, const vec &cond ) {
-                it_assert_debug ( valsize==val.length(),"Wrong val" );
-                it_assert_debug ( valupsize==val_up.length(),"Wrong val_up" );
-                set_subvector ( val_up, v2v_up, val );
-                set_subvector ( val_up, v2c_up, cond );
-        }
-};
+        class datalink_m2e: public datalink_e2e {
+        protected:
+                //! Remember how long cond should be
+                int condsize;
+                //!upper_val-to-local_cond link, indeces of the upper val
+                ivec v2c_up;
+                //!upper_val-to-local_cond link, ideces of the local cond
+                ivec v2c_lo;
+
+        public:
+                //! Constructor
+                datalink_m2e ( const RV &rv,  const RV &rvc, const RV &rv_up ) :
+                                datalink_e2e ( rv,rv_up ), condsize ( rvc.count() ) {
+                        //establish v2c connection
+                        rvc.dataind ( rv_up, v2c_lo, v2c_up );
+                }
+                //!Construct condition
+                vec get_cond ( const vec &val_up ) {
+                        vec tmp ( condsize );
+                        set_subvector ( tmp,v2c_lo,val_up ( v2c_up ) );
+                        return tmp;
+                }
+                void fill_val_cond ( vec &val_up, const vec &val, const vec &cond ) {
+                        it_assert_debug ( valsize==val.length(),"Wrong val" );
+                        it_assert_debug ( valupsize==val_up.length(),"Wrong val_up" );
+                        set_subvector ( val_up, v2v_up, val );
+                        set_subvector ( val_up, v2c_up, cond );
+                }
+        };
 //!DataLink is a connection between mpdf and its superordinate (Up)
 //! This class links
-class datalink_m2m: public datalink_m2e {
-protected:
-        //!cond-to-cond link, indeces of the upper cond
-        ivec c2c_up;
-        //!cond-to-cond link, indeces of the local cond
-        ivec c2c_lo;
-public:
-        //! Constructor
-        datalink_m2m ( const RV &rv, const RV &rvc, const RV &rv_up, const RV &rvc_up ) :
-                        datalink_m2e ( rv, rvc, rv_up) {
-                //establish c2c connection
-                rvc.dataind ( rvc_up, c2c_lo, c2c_up );
-                it_assert_debug(c2c_lo.length()+v2c_lo.length()==condsize, "cond is not fully given");
-        }
-        //! Get cond for myself from val and cond of "Up"
-        vec get_cond ( const vec &val_up, const vec &cond_up ) {
-                vec tmp ( condsize );
-                set_subvector ( tmp,v2c_lo,val_up ( v2c_up ) );
-                set_subvector ( tmp,c2c_lo,cond_up ( c2c_up ) );
-                return tmp;
-        }
-        //! Fill
-
-};
-
-/*! \brief Unconditional mpdf, allows using epdf in the role of mpdf.
-
-*/
-class mepdf : public mpdf {
-public:
-        //!Default constructor
-        mepdf (const epdf* em ) :mpdf ( em->_rv(),RV() ) {ep=const_cast<epdf*>(em);};
-        void condition ( const vec &cond ) {}
-};
+        class datalink_m2m: public datalink_m2e {
+        protected:
+                //!cond-to-cond link, indeces of the upper cond
+                ivec c2c_up;
+                //!cond-to-cond link, indeces of the local cond
+                ivec c2c_lo;
+        public:
+                //! Constructor
+                datalink_m2m ( const RV &rv, const RV &rvc, const RV &rv_up, const RV &rvc_up ) :
+                                datalink_m2e ( rv, rvc, rv_up ) {
+                        //establish c2c connection
+                        rvc.dataind ( rvc_up, c2c_lo, c2c_up );
+                        it_assert_debug ( c2c_lo.length() +v2c_lo.length() ==condsize, "cond is not fully given" );
+                }
+                //! Get cond for myself from val and cond of "Up"
+                vec get_cond ( const vec &val_up, const vec &cond_up ) {
+                        vec tmp ( condsize );
+                        set_subvector ( tmp,v2c_lo,val_up ( v2c_up ) );
+                        set_subvector ( tmp,c2c_lo,cond_up ( c2c_up ) );
+                        return tmp;
+                }
+                //! Fill
+
+        };
+
+        /*! \brief Unconditional mpdf, allows using epdf in the role of mpdf.
+
+        */
+        class mepdf : public mpdf {
+        public:
+                //!Default constructor
+                mepdf ( const epdf* em ) :mpdf ( em->_rv(),RV() ) {ep=const_cast<epdf*> ( em );};
+                void condition ( const vec &cond ) {}
+        };
 
 //!\brief Abstract composition of pdfs, will be used for specific classes
 //!this abstract class is common to epdf and mpdf
-class compositepdf {
-protected:
-        //!Number of mpdfs in the composite
-        int n;
-        //! Elements of composition
-        Array<mpdf*> mpdfs;
-public:
-        compositepdf ( Array<mpdf*> A0 ) : n ( A0.length() ), mpdfs ( A0 ) {};
-        //! find common rv, flag \param checkoverlap modifies whether overlaps are acceptable
-        RV getrv ( bool checkoverlap=false );
-        //! common rvc of all mpdfs is written to rvc
-        void setrvc ( const RV &rv, RV &rvc );
-};
-
-/*! \brief Abstract class for discrete-time sources of data.
-
-The class abstracts operations of: (i) data aquisition, (ii) data-preprocessing, (iii) scaling of data, and (iv) data resampling from the task of estimation and control.
-Moreover, for controlled systems, it is able to receive the desired control action and perform it in the next step. (Or as soon as possible).
-
-*/
-
-class DS : public bdmroot{
-protected:
-        //!Observed variables, returned by \c getdata().
-        RV Drv;
-        //!Action variables, accepted by \c write().
-        RV Urv; //
-public:
-        DS():Drv(RV0),Urv(RV0) {};
-        //! Returns full vector of observed data
-        void getdata ( vec &dt );
-        //! Returns data records at indeces.
-        void getdata ( vec &dt, ivec &indeces );
-        //! Accepts action variable and schedule it for application.
-        void write ( vec &ut );
-        //! Accepts action variables at specific indeces
-        void write ( vec &ut, ivec &indeces );
-        /*! \brief Method that assigns random variables to the datasource.
-        Typically, the datasource will be constructed without knowledge of random variables. This method will associate existing variables with RVs.
-
-        (Inherited from m3k, may be deprecated soon).
-        */
-        void linkrvs ( RV &drv, RV &urv );
-
-        //! Moves from \f$t\f$ to \f$t+1\f$, i.e. perfroms the actions and reads response of the system.
-        void step();
-
-};
-
-/*! \brief Bayesian Model of the world, i.e. all uncertainty is modeled by probabilities.
-
-*/
-
-class BM :public bdmroot{
-protected:
-        //!Random variable of the posterior
-        RV rv;
-        //!Logarithm of marginalized data likelihood.
-        double ll;
-        //!  If true, the filter will compute likelihood of the data record and store it in \c ll . Set to false if you want to save computational time.
-        bool evalll;
-public:
-
-        //!Default constructor
-        BM ( const RV &rv0, double ll0=0,bool evalll0=true ) :rv ( rv0 ), ll ( ll0 ),evalll ( evalll0 ) {//Fixme: test rv
-        };
-        //!Copy constructor
-        BM ( const BM &B ) : rv ( B.rv ), ll ( B.ll ), evalll ( B.evalll ) {}
-
-        /*! \brief Incremental Bayes rule
-        @param dt vector of input data
-        */
-        virtual void bayes ( const vec &dt ) = 0;
-        //! Batch Bayes rule (columns of Dt are observations)
-        virtual void bayesB ( const mat &Dt );
-        //! Returns a reference to the epdf representing posterior density on parameters. 
-        virtual const epdf& _epdf() const =0;
-
-        //! Returns a pointer to the epdf representing posterior density on parameters. Use with care!
-        virtual const epdf* _e() const =0;
-
-        //! Evaluates predictive log-likelihood of the given data record
-        //! I.e. marginal likelihood of the data with the posterior integrated out.
-        virtual double logpred ( const vec &dt ) const{it_error ( "Not implemented" );return 0.0;}
-        //! Matrix version of logpred
-        vec logpred_m ( const mat &dt ) const{vec tmp ( dt.cols() );for ( int i=0;i<dt.cols();i++ ) {tmp ( i ) =logpred ( dt.get_col ( i ) );}return tmp;}
-
-        //!Constructs a predictive density (marginal density on data)
-        virtual epdf* predictor ( const RV &rv ) const {it_error ( "Not implemented" );return NULL;};
-
-        //! Destructor for future use;
-        virtual ~BM() {};
-        //!access function
-        const RV& _rv() const {return rv;}
-        //!access function
-        double _ll() const {return ll;}
-        //!access function
-        void set_evalll ( bool evl0 ) {evalll=evl0;}
-
-        //! Copy function required in vectors, Arrays of BM etc. Have to be DELETED manually!
-        //! Prototype: BM* _copy_(){BM Tmp*=new Tmp(this*);  return Tmp; }
-        virtual BM* _copy_ ( bool changerv=false ) {it_error ( "function _copy_ not implemented for this BM" ); return NULL;};
-};
-
-/*!
-\brief Conditional Bayesian Filter
-
-Evaluates conditional filtering density \f$f(rv|rvc,data)\f$ for a given \c rvc which is specified in each step by calling function \c condition.
-
-This is an interface class used to assure that certain BM has operation \c condition .
-
-*/
-
-class BMcond :public bdmroot{
-protected:
-        //! Identificator of the conditioning variable
-        RV rvc;
-public:
-        //! Substitute \c val for \c rvc.
-        virtual void condition ( const vec &val ) =0;
-        //! Default constructor
-        BMcond ( RV &rv0 ) :rvc ( rv0 ) {};
-        //! Destructor for future use
-        virtual ~BMcond() {};
-        //! access function
-        const RV& _rvc() const {return rvc;}
-};
+        class compositepdf {
+        protected:
+                //!Number of mpdfs in the composite
+                int n;
+                //! Elements of composition
+                Array<mpdf*> mpdfs;
+        public:
+                compositepdf ( Array<mpdf*> A0 ) : n ( A0.length() ), mpdfs ( A0 ) {};
+                //! find common rv, flag \param checkoverlap modifies whether overlaps are acceptable
+                RV getrv ( bool checkoverlap=false );
+                //! common rvc of all mpdfs is written to rvc
+                void setrvc ( const RV &rv, RV &rvc );
+        };
+
+        /*! \brief Abstract class for discrete-time sources of data.
+
+        The class abstracts operations of: (i) data aquisition, (ii) data-preprocessing, (iii) scaling of data, and (iv) data resampling from the task of estimation and control.
+        Moreover, for controlled systems, it is able to receive the desired control action and perform it in the next step. (Or as soon as possible).
+
+        */
+
+        class DS : public bdmroot {
+        protected:
+                //!Observed variables, returned by \c getdata().
+                RV Drv;
+                //!Action variables, accepted by \c write().
+                RV Urv; //
+                //! Remember its own index in Logger L
+                int L_dt, L_ut;
+        public:
+                DS() :Drv ( RV0 ),Urv ( RV0 ) {};
+                DS ( const RV &Drv0, const RV &Urv0 ) :Drv ( Drv0 ),Urv ( Urv0 ) {};
+                //! Returns full vector of observed data=[output, input]
+                virtual void getdata ( vec &dt ) {it_error ( "abstract class" );};
+                //! Returns data records at indeces.
+                virtual void getdata ( vec &dt, const ivec &indeces ) {it_error ( "abstract class" );};
+                //! Accepts action variable and schedule it for application.
+                virtual void write ( vec &ut ) {it_error ( "abstract class" );};
+                //! Accepts action variables at specific indeces
+                virtual void write ( vec &ut, const ivec &indeces ) {it_error ( "abstract class" );};
+
+                //! Moves from \f$t\f$ to \f$t+1\f$, i.e. perfroms the actions and reads response of the system.
+                virtual void step() =0;
+
+                //! Register DS for logging into logger L
+                virtual void log_add ( logger &L ) {
+                        L_dt=L.add ( Drv,"" );
+                        L_ut=L.add ( Urv,"" );
+                }
+                //! Register DS for logging into logger L
+                virtual void logit ( logger &L ) {
+                        vec tmp(Drv.count()+Urv.count());
+                        getdata(tmp);
+                        // d is first in getdata
+                        L.logit ( L_dt,tmp.left ( Drv.count() ) );
+                        // u follows after d in getdata
+                        L.logit ( L_ut,tmp.mid ( Drv.count(), Urv.count() ) );
+                }
+        };
+
+        /*! \brief Bayesian Model of the world, i.e. all uncertainty is modeled by probabilities.
+
+        */
+
+        class BM :public bdmroot {
+        protected:
+                //!Random variable of the posterior
+                RV rv;
+                //!Logarithm of marginalized data likelihood.
+                double ll;
+                //!  If true, the filter will compute likelihood of the data record and store it in \c ll . Set to false if you want to save computational time.
+                bool evalll;
+        public:
+
+                //!Default constructor
+                BM ( const RV &rv0, double ll0=0,bool evalll0=true ) :rv ( rv0 ), ll ( ll0 ),evalll ( evalll0 ) {//Fixme: test rv
+                };
+                //!Copy constructor
+                BM ( const BM &B ) : rv ( B.rv ), ll ( B.ll ), evalll ( B.evalll ) {}
+
+                /*! \brief Incremental Bayes rule
+                @param dt vector of input data
+                */
+                virtual void bayes ( const vec &dt ) = 0;
+                //! Batch Bayes rule (columns of Dt are observations)
+                virtual void bayesB ( const mat &Dt );
+                //! Returns a reference to the epdf representing posterior density on parameters.
+                virtual const epdf& _epdf() const =0;
+
+                //! Returns a pointer to the epdf representing posterior density on parameters. Use with care!
+                virtual const epdf* _e() const =0;
+
+                //! Evaluates predictive log-likelihood of the given data record
+                //! I.e. marginal likelihood of the data with the posterior integrated out.
+                virtual double logpred ( const vec &dt ) const{it_error ( "Not implemented" );return 0.0;}
+                //! Matrix version of logpred
+                vec logpred_m ( const mat &dt ) const{vec tmp ( dt.cols() );for ( int i=0;i<dt.cols();i++ ) {tmp ( i ) =logpred ( dt.get_col ( i ) );}return tmp;}
+
+                //!Constructs a predictive density (marginal density on data)
+                virtual epdf* predictor ( const RV &rv ) const {it_error ( "Not implemented" );return NULL;};
+
+                //! Destructor for future use;
+                virtual ~BM() {};
+                //!access function
+                const RV& _rv() const {return rv;}
+                //!access function
+                double _ll() const {return ll;}
+                //!access function
+                void set_evalll ( bool evl0 ) {evalll=evl0;}
+
+                //! Copy function required in vectors, Arrays of BM etc. Have to be DELETED manually!
+                //! Prototype: BM* _copy_(){BM Tmp*=new Tmp(this*);  return Tmp; }
+                virtual BM* _copy_ ( bool changerv=false ) {it_error ( "function _copy_ not implemented for this BM" ); return NULL;};
+        };
+
+        /*!
+        \brief Conditional Bayesian Filter
+
+        Evaluates conditional filtering density \f$f(rv|rvc,data)\f$ for a given \c rvc which is specified in each step by calling function \c condition.
+
+        This is an interface class used to assure that certain BM has operation \c condition .
+
+        */
+
+        class BMcond :public bdmroot {
+        protected:
+                //! Identificator of the conditioning variable
+                RV rvc;
+        public:
+                //! Substitute \c val for \c rvc.
+                virtual void condition ( const vec &val ) =0;
+                //! Default constructor
+                BMcond ( RV &rv0 ) :rvc ( rv0 ) {};
+                //! Destructor for future use
+                virtual ~BMcond() {};
+                //! access function
+                const RV& _rvc() const {return rvc;}
+        };
 
 }; //namespace

bdm/stat/libDS.cpp

@@ -1 @@
-#include <itpp/itbase.h>
+
 #include "libDS.h"
 
 using namespace bdm;
 
-void MemDS::getdata(vec &dt){
+void MemDS::getdata ( vec &dt ) {
         int i;
-        
-        it_assert_debug(dt.length()==rowid.length(), "MemDS:getdata incompatible dt");
-        for(i=0;i<rowid.length();i++){
-                dt(i) = Data(rowid(i),time-delays(i));
+
+        it_assert_debug ( dt.length() ==rowid.length(), "MemDS:getdata incompatible dt" );
+        for ( i=0;i<rowid.length();i++ ) {
+                dt ( i ) = Data ( rowid ( i ),time-delays ( i ) );
         }
 }
 
-void MemDS::getdata(vec &dt,ivec &indeces){
+void MemDS::getdata ( vec &dt,const ivec &indeces ) {
         int j,i;
-        it_assert_debug(dt.length()==indeces.length(), "MemDS:getdata incompatible dt");
-        for(i=0;i<indeces.length();i++){
-                j = indeces (i);
-                dt(i) = Data(rowid(j),time-delays(j));
+        it_assert_debug ( dt.length() ==indeces.length(), "MemDS:getdata incompatible dt" );
+        for ( i=0;i<indeces.length();i++ ) {
+                j = indeces ( i );
+                dt ( i ) = Data ( rowid ( j ),time-delays ( j ) );
         }
 }
 
 void MemDS::step() {
-        if (time<Data.cols()) {time++;}
+        if ( time<Data.cols() ) {time++;}
 }
 
-void MemDS::linkrvs(RV &drv, RV &urv) {
-        it_assert_debug(drv.count()==rowid.length(),"MemDS::linkrvs incompatible drv");
-        it_assert_debug(urv.count()==0,"MemDS does not support urv.");
-        
+void MemDS::linkrvs ( RV &drv, RV &urv ) {
+        it_assert_debug ( drv.count() ==rowid.length(),"MemDS::linkrvs incompatible drv" );
+        it_assert_debug ( urv.count() ==0,"MemDS does not support urv." );
+
         Drv = drv;
         Urv = urv;
 }
 
-MemDS::MemDS(mat &Dat, ivec &rowid, ivec &delays){
-        it_assert_debug(max(rowid)<=Dat.rows(),"MemDS rowid is too high for given Dat.");
-        it_assert_debug(max(delays)<Dat.cols(),"MemDS delays are too high.");
-        
-        time = max(delays); 
+MemDS::MemDS ( mat &Dat, ivec &rowid, ivec &delays ) {
+        it_assert_debug ( max ( rowid ) <=Dat.rows(),"MemDS rowid is too high for given Dat." );
+        it_assert_debug ( max ( delays ) <Dat.cols(),"MemDS delays are too high." );
+
+        time = max ( delays );
         Data = Dat;
 }
+
+void ArxDS::step() {
+        double tmp;
+        //get regressor
+        rgr = rgrlnk.get_val ( H );
+        // Eval Y
+        Y = model.samplecond ( rgr,tmp );
+
+        //shift history
+        H.shift_right ( 0, Drv.count() +Urv.count() );
+        //fill new data
+        H.set_subvector ( Drv.count(),Y );
+
+        //Leaving U.length() empty slots - these will be filled by write()
+}
+
+//! Auxiliary function building full history of rv0
+RV fullrgr ( const RV &drv0, const RV &urv0, const RV &rrv0 ) {
+        RV T ( urv0 );
+        RV pom = concat(drv0, urv0);
+        int mint = rrv0.mint();
+        for ( int i=0; i>mint; i-- ) {
+                pom.t ( -1 );
+                T.add ( pom );
+        }
+        return T;
+}
+
+ArxDS::ArxDS ( RV &drv, RV &urv, RV &rrv ) : 
+                DS(drv,urv), Rrv(rrv), Hrv( fullrgr ( drv,urv,rrv )), //RVs
+                Y(drv.count()), H(Hrv.count()) ,rgr ( rrv.count() ),  //tmp variables
+                rgrlnk (Hrv ,rrv ) ,model ( drv,rrv ) {
+}

bdm/stat/libDS.h

@@ -14 +14 @@
 #define DS_H
 
-#include <itpp/itbase.h>
+
 #include "libBM.h"
+#include "libEF.h"
 
-namespace bdm{
-/*!
-* \brief Class representing off-line data stored in memory
 
-The data are stored in an internal matrix \c Data . Each column of Data corresponds to one discrete time observation \f$t\f$. Access to this matrix is via indexes \c rowid and \c delays.
+namespace bdm {
+        /*!
+        * \brief Memory storage of off-line data column-wise
 
-The data can be loaded from a file.
-*/
-class MemDS : public DS {
-mat Data;
-int time;
-ivec rowid;
-ivec delays;
+        The data are stored in an internal matrix \c Data . Each column of Data corresponds to one discrete time observation \f$t\f$. Access to this matrix is via indexes \c rowid and \c delays.
 
-public:
-        void getdata(vec &dt);
-        void getdata(vec &dt, ivec &indeces);
-        void linkrvs(RV &drv, RV &urv);
-        void write(vec &ut){it_error("MemDS::write is not supported");}
-        void write(vec &ut,ivec &indexes){it_error("MemDS::write is not supported");}
-        void step();
-        //!Default constructor
-        MemDS(mat &Dat, ivec &rowid, ivec &delays);
-};
+        The data can be loaded from a file.
+        */
+        class MemDS : public DS {
+                //! internal matrix of data
+                mat Data;
+                //! active column in the Data matrix
+                int time;
+                //!  vector of rows that are presented in Dt
+                ivec rowid;
+                //! vector of delays that are presented in Dt
+                ivec delays;
+
+        public:
+                void getdata ( vec &dt );
+                void getdata ( vec &dt, const ivec &indeces );
+                void linkrvs ( RV &drv, RV &urv );
+                void write ( vec &ut ) {it_error ( "MemDS::write is not supported" );}
+                void write ( vec &ut,ivec &indexes ) {it_error ( "MemDS::write is not supported" );}
+                void step();
+                //!Default constructor
+                MemDS ( mat &Dat, ivec &rowid, ivec &delays );
+        };
+
+        /*!
+        \brief Generator of ARX data
+
+        */
+        class ArxDS : public DS {
+                //! Rv of the regressor
+                RV Rrv;
+                //! Rv of the history (full regressor)
+                RV Hrv;
+                //! Internal storage of results
+                vec Y;
+                //! History, ordered as \f$[u_t, y_{t-1 }, u_{t-1}, \ldots]\f$ 
+                vec H;
+                //! temporary variable for regressor
+                vec rgr;
+                //! data link: val = y, cond = u; local = rgr;
+                datalink_e2e rgrlnk;
+                //! model of Y - linear Gaussian 
+                mlnorm<chmat> model;
+                public:
+                void getdata ( vec &dt ){it_assert_debug(dt.length()==Y.length(),"ArxDS"); 
+                        dt=concat(Y,H.left(Urv.count()));};
+                void getdata ( vec &dt, const ivec &indexes ){it_assert_debug(dt.length()==Y.length(),"ArxDS"); dt=Y(indexes);};
+                void write ( vec &ut ){it_assert_debug(ut.length()==Urv.count(),"ArxDS"); H.set_subvector(0,ut);};
+                void write ( vec &ut, const ivec &indexes ){it_assert_debug(ut.length()==Urv.count(),"ArxDS"); set_subvector(H,indexes,ut);};
+                void step();
+                //!Default constructor
+                ArxDS ( RV &drv, RV &urv, RV &rrv);
+                //! Set parameters of the internal model
+                void set_parameters(const mat &Th0, const vec mu0, const chmat &sqR0)
+                {model.set_parameters(Th0, mu0, sqR0); };
+        };
 
 }; //namespace

bdm/stat/loggers.h

@@ -18 +18 @@
 namespace bdm{
 using std::string;
-
-/*!
-@brief Class for storing results (and semi-results) of an experiment
-
-This class abstracts logging of results from implementation. This class replaces direct logging of results (e.g. to files or to global variables) by calling methods of a logger. Specializations of this abstract class for specific storage method are designed.
-*/
-class logger : public bdmroot{
-protected:
-        //! RVs of all logged variables. 
-        Array<RV> entries;
-        //! Names of logged quantities, e.g. names of algorithm variants
-        Array<string> names;
-public:
-        //!Default constructor
-        logger ( ) : entries(0),names ( 0 ) {}
-
-        //! returns an identifier which will be later needed for calling the log() function
-        virtual int add (const RV &rv, string name="" ) {
-                int id=entries.length();
-                names=concat ( names, name ); // diff
-                entries.set_length(id+1,true);
-                entries(id)= rv;
-                return id; // identifier of the last entry
-        }
-
-        //! log this vector
-        virtual void logit ( int id, const vec &v ) =0;
-
-        //! Shifts storage position for another time step.
-        virtual void step() =0;
-
-        //! Finalize storing information
-        virtual void finalize() {};
-
-        //! Initialize the storage
-        virtual void init(){};
-        
-        //! for future use
-        virtual ~logger() {};
-};
-
 
 /*!
@@ -124 +83 @@
 };
 
-}
+};
 #endif // LGR_H

bdm/stat/loggers_ui.h

@@ -17 +17 @@
 #include "uibuilder.h"
 
-using namespace itpp;
-using std::string;
+using namespace bdm;
 
-class UIdirfilelog : public UIbuilder{
+class UIdirfilelog : public UIbuilder {
         public:
         UIdirfilelog():UIbuilder("dirfilelog"){};

bdm/uibuilder.h

@@ -54 +54 @@
                                         default: it_error ( "libconfig error?" );
                                 }
+                        }
+                        return tmp;
+                };
+                const mat getmat ( Setting& S , int ncols) const {
+                        CHECK_UITYPE ( S,TypeArray );
+                        mat tmp;
+                        int nrows=S.getLength()/ncols;
+                        int r=0,c=0;
+                        tmp.set_size ( nrows, ncols );
+                        // Build matrix row-wise
+                        for ( int i=0;i<S.getLength();i++ ) {
+                                switch ( S[i].getType() ) {
+                                        case Setting::TypeFloat :
+                                                tmp(r,c)=double ( S[i] );break;
+                                        case Setting::TypeInt :
+                                                tmp(r,c)=int ( S[i] );break;
+                                        case Setting::TypeBoolean :
+                                                tmp(r,c)=bool ( S[i] );break;
+                                        default: it_error ( "libconfig error?" );
+                                }
+                                c++; if (c==ncols) {c=0;r++;}
                         }
                         return tmp;

tests/UI/CMakeLists.txt

@@ -1 +1 @@
 EXEC(UIbuilder_test)
+EXEC(UIArxDS_test)

tests/arx_test.cpp

@@ +1 @@
+/*!
+\file 
+\brief Test of basic elements of the ARX class
+
+See file \ref arx for mathematical background.
+
+This class tests functions ARX::bayes (Bayes rule) ARX::structure_est and ARX::predictor_student
+
+Untested functions: none.
+
+ */
+
 #include <estim/arx.h>
-#include <stat/libEF.h>
 using namespace bdm;
-
-//These lines are needed for use of cout and endl
-using std::cout;
-using std::endl;
 
 int main() {
         // Setup model
-        vec th("0.8 -0.3 0.4 0.01");
-        int ord=th.length();
+        vec th ( "0.8 -0.3 0.4 0.01" );
+        int ord=th.length(); //auxiliary variable
         double sqr=0.1;
-        
+
         //Test constructor
-        mat V0 = 0.00001*eye(ord+1); V0(0.0)*= 100; //
-        double nu0 = ord+4;
-        
-        RV thr("{theta_and_r }",vec_1(ord+1));
-        ARX Ar(thr, V0, nu0);
-        const epdf& Ar_ep = Ar._epdf();
-                                
+        mat V0 = 0.00001*eye ( ord+1 ); V0 ( 0.0 ) = 1; //
+        double nu0 = ord+5.0;
+
+        RV thr ( "{theta_and_r }",vec_1 ( ord+1 ) );   // Descriptive random variable
+        ARX Ar ( thr, V0, nu0 );                 // Estimator
+        const epdf& f_thr = Ar._epdf();          // refrence to posterior of the estimator
+
         //Test estimation
-        int ndat = 100;
-        int t,j;
-        vec Yt(ndat);
-        vec LL(ndat);
-        Yt.set_subvector(0,randn(ord)); //initial values
-        vec rgr(ord);
-        
-        
-        cout << Ar_ep.mean()<<endl;
-        for (t=ord; t<ndat; t++) {
-                for(j=0;j<(ord);j++){rgr(j)=Yt(t-j-1);}
-                Yt(t) = th*rgr + sqr * NorRNG();
-                
-                vec Psi = concat(Yt(t), rgr);
-                Ar.bayes(Psi);
-                LL(t) = Ar._ll();
-                
-                cout << "y: " << Yt(t) << endl;
-                mlstudent*      Pr = Ar.predictor_student(RV("{y }"),RV("{y1 y2 y3 y4 }"));
-                cout << Ar._ll() <<" , " << log(Pr->evallogcond(vec_1(Yt(t)),rgr)) <<endl;
+        int ndat = 100;                 // number of data records
+        vec Yt ( ndat );                // Store generated data
+        Yt.set_subvector ( 0,randn ( ord ) ); //initial values
+        vec rgr ( ord );                // regressor
+        vec Psi ( ord+1 );              // extended regressor
+
+        //print moments of the prior distribution
+        cout << "prior mean: " << f_thr.mean() <<endl;
+        cout << "prior variance: " << f_thr.variance() <<endl;
+
+        // cycle over time:
+        for ( int t=ord; t<ndat; t++ ) {
+                //Generate regressor
+                for ( int j=0;j< ( ord );j++ ) {rgr ( j ) =Yt ( t-j-1 );}
+                //model
+                Yt ( t ) = th*rgr + sqr * NorRNG();
+
+                Psi = concat ( Yt ( t ), rgr ); // Inefficient! Used for compatibility with Matlab!
+                Ar.bayes ( Psi );             // Bayes rule
+
+                // Build predictor
+                mlstudent*      Pr = Ar.predictor_student ( RV ( "{y }" ),RV ( "{y1 y2 y3 y4 }" ) );
+                // Test similarity of likelihoods from the Bayes rule and the predictor
+                cout << "BR log-lik: " << Ar._ll();
+                cout <<" , predictor ll: " <<  Pr->evallogcond ( vec_1 ( Yt ( t ) ),rgr )  <<endl;
                 delete Pr;
         }
-        cout << Ar_ep.mean()<<endl;
+        //print posterior moments
+        cout << "posterior mean: " << f_thr.mean() <<endl;
+        cout << "posterior variance: " << f_thr.variance() <<endl;
+
+        // Test brute-froce structure estimation
         
-        // Test brute-froce structure estimation
-        cout << Ar.structure_est(egiw(thr,V0,nu0)) <<endl;
+        cout << "Structure estimation: " <<endl;
+        cout <<Ar.structure_est ( egiw ( thr,V0,nu0 ) ) <<endl;
 }