Changeset 22 for bdm/stat

Timestamp:

02/18/08 17:50:37 (16 years ago)

Author:

smidl

Message:

upravy Kalmana

Location:

bdm/stat

Files:

• libBM.h (modified) (3 diffs)
• libEF.h (modified) (2 diffs)
• libFN.cpp (modified) (1 diff)
• libFN.h (modified) (2 diffs)

bdm/stat/libBM.h

@@ -73 +73 @@
 //! Class representing function $f(x)$ of variable $x$ represented by \c rv
 class fnc {
-        RV rv;
+protected:
+        int dimy;
 public: 
         //! function evaluates numerical value of $f(x)$ at $x=cond$
-        virtual vec eval(vec &cond){}; //Fixme: virtual?
+        virtual vec eval(const vec &cond){}; //Fixme: virtual?
+        //! access function
+        int _dimy()const{return dimy;}
 };
 
@@ -85 +88 @@
         double ll;
 
+        //!Default constructor
+        BM(){ll=0;};
+        
         /*! \brief Incremental Bayes rule
         @param dt vector of input data
@@ -100 +106 @@
         //! Returns the required moment of the epdf
 //      virtual vec moment ( const int order = 1 );
-        //! Returns a sample from the density, $x \sim epdf(rv)$
+        //! Returns a sample from the density, \f$x \sim epdf(rv)\f$
         virtual vec sample ()=0;
+        //! Compute probability of argument \c val
         virtual double eval(const vec &val){};
 };

bdm/stat/libEF.h

@@ -40 +40 @@
 
 /*!
-* \brief General exponential family density
+* \brief Gaussian density with positive definite (decomposed) covariance matrix.
 
 * More?...
@@ -52 +52 @@
         enorm( RV &rv, vec &mu, sq_T &R );
         enorm();
+        //! tupdate in exponential form (not really handy)
         void tupdate( double phi, mat &vbar, double nubar );
         void dupdate( mat &v,double nu=1.0 );
+        //!tupdate used in KF
+        void tupdate();
+        //!dupdate used in KF
+        double dupdate();
+         
         vec sample();
         mat sample(int N);

bdm/stat/libFN.cpp

@@ -9 +9 @@
 }
 
-bilinfn::bilinfn ( const RV &x0, const RV &u0, const mat &A0, const mat &B0 )
+bilinfn::bilinfn ( const RV &rvx0, const RV &rvu0, const mat &A0, const mat &B0 ) : diffbifn ( rvx0,rvu0 )
 {
-        it_assert_debug ( A0.cols() ==A0.rows() ==x0.count(), "linfn:: wrong A" );
-        it_assert_debug ( ( B0.rows() ==x0.count() ) & ( B0.cols() ==u0.count() ), "linfn:: wrong B" );
+        //check input
+        it_assert_debug ( ( A0.cols() ==dimx ) & ( A0.rows() ==B0.rows() ), "linfn:: wrong A" );
+        it_assert_debug ( ( B0.cols() ==dimu ), "linfn:: wrong B" );
 
+        // set dimensions
+        dimy = A0.rows();
+
+        //set internals
         A = A0;
         B = B0;
-        rv=x0; rv.add ( u0 );
-        indexlist=rv.indexlist();
 };
 
+inline vec bilinfn::eval ( const  vec &x0, const vec &u0 )
+{
+        it_assert_debug ( x0.length() ==dimx, "linfn::eval Wrong xcond." );
+        it_assert_debug ( u0.length() ==dimu, "linfn::eval Wrong ucond." );
+        return A*x0+B*u0;
+};

bdm/stat/libFN.h

@@ -20 +20 @@
                 RV rv;
                 vec val;
+
 
         public:
@@ -44 +45 @@
 };
 
+
+/*!
+\brief Class representing a differentiable function of two variables $f(x,u)$.
+
+Function of two variables.
+
+TODO:
+1) Technically, it could have a common parent (e.g. \c fnc ) with other functions. For now, we keep it as it is.
+2) It could be generalized into multivariate form, (which was original meaning of \c fnc ).
+*/
+class diffbifn: public fnc
+{
+        protected:
+                RV rvx,rvu;
+                int dimx;
+                int dimu;
+        public:
+                //! Evaluates $f(x0,u0)$ (VS: Do we really need common eval? )
+                vec eval ( const vec &cond )
+                {
+                        it_assert_debug ( cond.length() == ( dimx+dimu ), "linfn::eval Wrong cond." );
+                        return eval ( cond ( 0,dimx-1 ),cond ( dimx,dimx+dimu ) );//-1 = end (in matlab)
+                };
+
+                //! Evaluates $f(x0,u0)$
+                virtual vec eval ( const vec &x0, const vec &u0 ) {return zeros ( dimy );};
+                //! Evaluates \f$A=\frac{d}{dx}f(x,u)|_{x0,u0}\f$ and writes result into \c A . @param full denotes that even unchanged entries are to be rewritten. When, false only the changed elements are computed.
+                virtual void dfdx_cond ( const vec &x0, const vec &u0, mat &A , bool full=true ) {};
+                //! Evaluates \f$A=\frac{d}{du}f(x,u)|_{x0,u0}\f$ and writes result into \c A . @param full denotes that even unchanged entries are to be rewritten. When, false only the changed elements are computed.
+                virtual void dfdu_cond ( const vec &x0, const vec &u0, mat &A, bool full=true ) {};
+                //!Default constructor (dimy is not set!)
+                diffbifn ( const RV rvx0, const RV rvu0 ) : rvx ( rvx0 ),rvu ( rvu0 ) {dimx=rvx.count();dimu=rvu.count();};
+                //! access function
+                int _dimx() const{return dimx;}
+                //! access function
+                int _dimu() const{return dimu;}
+};
+
 //! Class representing function $f(x,u) = Ax+Bu$
-class bilinfn: public fnc
+//TODO can be generalized into multilinear form!
+class bilinfn: public diffbifn
 {
-                RV rv;
-                ivec indexlist; // needed by evalsome
                 mat A;
                 mat B;
         public :
-                vec eval ( vec &cond )
+                vec eval ( const  vec &x0, const vec &u0 );
+
+                //! Default constructor
+                bilinfn ( const RV &rvx0, const RV &rvu0 ) : diffbifn ( rvx0,rvu0 ) ,A ( eye ( dimx ) ),B ( zeros ( dimx,dimu ) )       {};
+                //
+                bilinfn ( const RV &rvx0, const RV &rvu0, const mat &A0, const mat &B0 );
+                //
+                void dfdx_cond ( const vec &x0, const vec &u0, mat &F, bool full )
                 {
-                        it_assert_debug ( cond.length() ==rv.count(), "linfn::eval Wrong cond." );
-                        int sizex = A.cols();
-                        return A*cond(0,sizex-1)+B*cond(sizex,-1);//-1 = end (in matlab)
-                };
-                vec eval ( vec &xcond, vec &ucond )
+                        it_assert_debug ( ( F.cols() ==A.cols() ) & ( F.rows() ==A.rows() ),"Allocated F is not compatible." );
+                        if ( full ) F=A;        //else : nothing has changed no need to regenerate
+                }
+                //
+                void dfdu_cond ( const vec &x0, const vec &u0, mat &F,  bool full=true )
                 {
-                        it_assert_debug ( xcond.length() ==rv.count(), "linfn::eval Wrong cond." );
-                        return A*xcond+B*ucond;
-                };
-
-                bilinfn evalsome ( ivec &rvind );
-                bilinfn ( const RV &x0, const RV &u0 ) :A ( eye ( x0.count() ) ),B ( zeros ( x0.count(),u0.count() ) )
-                {
-                        rv=x0; rv.add ( u0 );
-                        indexlist=rv.indexlist();
-                };
-                bilinfn ( const RV &x0, const RV &u0, const mat &A0, const mat &B0 );
+                        it_assert_debug ( ( F.cols() ==B.cols() ) & ( F.rows() ==B.rows() ),"Allocated F is not compatible." );
+                        if ( full ) F=B;        //else : nothing has changed no need to regenerate
+                }
 };