work/mixpp/bdm/stat/libBM.h

Go to the documentation of this file.

#ifndef BM_H
#define BM_H

#include <itpp/itbase.h>
//#include <std>

using namespace itpp;

class RV {
protected:
        int tsize;
        int len;
        ivec ids;
        ivec sizes;
        ivec times;
        Array<std::string> names;

private:
        void init ( ivec in_ids, Array<std::string> in_names, ivec in_sizes, ivec in_times);
public:
        RV ( ivec in_ids, Array<std::string> in_names, ivec in_sizes, ivec in_times);
        RV ( ivec ids );
        RV ();

        friend std::ostream &operator<< ( std::ostream &os, const RV &rv );

        int count() const {return tsize;} ;
        int length() const {return len;} ;

        //TODO why not inline and later??

        ivec find ( RV rv2 );
        void add (const RV &rv2 );
        friend RV concat (const RV &rv1, const RV &rv2 );
        RV subt ( RV rv2 );
        RV subselect ( ivec ind );
        RV operator() ( ivec ind );
        void t ( int delta );
        ivec indexlist();

        Array<std::string>& _names(){return names;};

        int id(int at){return ids(at);};
        int size(int at){return sizes(at);};
        int time(int at){return times(at);};
        std::string name(int at){return names(at);};
};



class fnc {
protected:
        int dimy;
public:
        fnc(int dy):dimy(dy){};
        virtual vec eval ( const vec &cond ) {
                return vec ( 0 );
        }; 

        int _dimy() const{return dimy;}

        virtual ~fnc() {};
};



class epdf {
protected:
        RV rv;
public:
        epdf() :rv ( ivec ( 0 ) ) {};

        epdf ( const RV &rv0 ) :rv ( rv0 ) {};

//      virtual vec moment ( const int order = 1 );
        virtual vec sample () const =0;
        virtual double eval ( const vec &val ) const {return exp(this->evalpdflog(val));};

        virtual double evalpdflog ( const vec &val ) const =0;

        virtual vec mean() const =0;
        
        virtual ~epdf() {};
        RV _rv() const {return rv;}
};


//TODO Samplecond can be generalized

class mpdf {
protected:
        RV rv;
        RV rvc;
        epdf* ep;
public:

//      virtual fnc moment ( const int order = 1 );
        virtual vec samplecond ( vec &cond, double &ll ) {this->condition(cond);vec temp= ep->sample();ll=ep->evalpdflog(temp);return temp;};
        virtual void condition ( const vec &cond ) {};
        
        virtual double evalcond (const vec &dt, const vec &cond ) {this->condition(cond);return ep->eval(dt);};

        virtual ~mpdf() {};

        mpdf ( const RV &rv0, const RV &rvc0 ) :rv ( rv0 ),rvc ( rvc0 ) {};
        RV _rvc(){return rvc;}
        epdf& _epdf(){return *ep;}
};

class DS {
protected:
        RV Drv;
        RV Urv; //
public:
        void getdata ( vec &dt );
        void getdata ( vec &dt, ivec &indeces );
        void write ( vec &ut );
        void write ( vec &ut, ivec &indeces );
        void linkrvs ( RV &drv, RV &urv );

        void step();

};

class BM {
protected:
        RV rv;
        double ll;
        bool evalll;
public:

        BM(const RV &rv0) :rv(rv0), ll ( 0 ),evalll ( true ) {//Fixme: test rv 
        };

        virtual void bayes ( const vec &dt ) = 0;
        void bayes ( mat Dt );
        virtual epdf& _epdf()=0;

        virtual ~BM() {};
        const RV& _rv() const {return rv;}
        double _ll() const {return ll;}
};

class BMcond {
protected:
        RV rvc;
public:
        virtual void condition ( const vec &val ) =0;
        BMcond(RV &rv0):rvc(rv0){};
        virtual ~BMcond(){};
        const RV& _rvc() const {return rvc;}
};

#endif // BM_H

---