arx.h

Go to the documentation of this file.

#ifndef AR_H
#define AR_H

#include "../math/functions.h"
#include "../stat/exp_family.h"
#include "../base/user_info.h"
//#include "../estim/kalman.h"
#include "arx_straux.h"

namespace bdm {

class ARX: public BMEF {
protected:
        int dimx;
        RV _yrv;
        RV rgrrv;
        egiw est;
        ldmat &V;
        double ν
        bool have_constant;
        vec _dt;
        egiw alter_est;
public:
        ARX ( const double frg0 = 1.0 ) : BMEF ( frg0 ), est (), V ( est._V() ), nu ( est._nu() ), have_constant(true), _dt() {};
        ARX ( const ARX &A0 ) : BMEF (A0.frg), est (A0.est), V ( est._V() ), nu ( est._nu() ), have_constant(A0.have_constant), _dt(A0._dt) {
                dimx = A0.dimx;
                _yrv = A0._yrv;
                rgrrv = A0.rgrrv;
                set_drv(A0._drv());
        };
        ARX* _copy_() const;
        void set_parameters ( double frg0 ) {
                frg = frg0;
        }
        void set_constant ( bool const0 ) {
                have_constant=const0;
        }
        void set_statistics ( int dimx0, const ldmat V0, double nu0 = -1.0 ) {
                est.set_parameters ( dimx0, V0, nu0 );
                last_lognc = est.lognc();
                dimx = dimx0;
        }

        void set_statistics ( const BMEF* BM0 );


        void bayes ( const vec &dt, const double w );
        void bayes ( const vec &dt ) {
                bayes ( dt, 1.0 );
        };
        double logpred ( const vec &dt ) const;
        void flatten ( const BMEF* B ) {
                const ARX* A = dynamic_cast<const ARX*> ( B );
                // nu should be equal to B.nu
                est.pow ( A->nu / nu );
                if ( evalll ) {
                        last_lognc = est.lognc();
                }
        }
        enorm<ldmat>* epredictor ( const vec &rgr ) const;
        enorm<ldmat>* epredictor() const {
                bdm_assert_debug ( dimx == V.rows() - 1, "Regressor is not only 1" );
                return epredictor ( vec_1 ( 1.0 ) );
        }
        mlnorm<ldmat>* predictor() const;
        mlstudent* predictor_student() const;
        ivec structure_est ( egiw Eg0 );
        ivec structure_est_LT ( egiw Eg0 );

        const egiw& posterior() const {
                return est;
        }

        void set_rv ( const RV &yrv0 , const RV &rgrrv0 ) {
                _yrv = yrv0;
                rgrrv=rgrrv0;
                set_drv(concat(yrv0, rgrrv));
        }

        RV& get_yrv() {
                //if yrv is not ready create it
                if ( _yrv._dsize() != dimx ) {
                        int i = 0;
                        while ( _yrv._dsize() < dimx ) {
                                _yrv.add ( drv ( vec_1 ( i ) ) );
                                i++;
                        }
                }
                //yrv should be ready by now
                bdm_assert_debug ( _yrv._dsize() == dimx, "incompatible drv" );
                return _yrv;
        }

        void from_setting ( const Setting &set );

        void validate() {
                bdm_assert(dimx == _yrv._dsize(), "RVs of parameters and regressor do not match");
                
        }
};

UIREGISTER ( ARX );
SHAREDPTR ( ARX );

class ARXfrg : public ARX{
        public:
                ARXfrg():ARX(){};
                ARXfrg(const ARXfrg &A0):ARX(A0){};
                ARXfrg* _copy_() const {ARXfrg *A = new ARXfrg(*this); return A;}
        void condition(const vec &val){
                frg = val(0);
        }
};
UIREGISTER(ARXfrg);
};
#endif // AR_H

---