root/bdm/stat/libFN.h @ 22

//
// C++ Interface: itpp_ext
//
// Description:
//
//
// Author: smidl <smidl@utia.cas.cz>, (C) 2008
//
// Copyright: See COPYING file that comes with this distribution
//
//
#include <itpp/itbase.h>
#include "libBM.h"

using namespace itpp;

//! class representing function $f(x) = a$, here rv is empty
class constfn : public fnc
{
                RV rv;
                vec val;


        public:
                vec eval() {return val;};
                vec eval ( vec &cond ) {return val;};
                //!Default constructor
                constfn ( const vec &val0 ) :rv(),val ( val0 ) {};
};

//! Class representing function $f(x) = Ax+B$
class linfn: public fnc
{
                RV rv;
                ivec indexlist; // needed by evalsome
                mat A;
                vec B;
        public :
                vec eval ( vec &cond ) {it_assert_debug ( cond.length() ==rv.count(), "linfn::eval Wrong cond." );return A*cond+B;};

                linfn evalsome ( ivec &rvind );
                linfn ( const RV &rv0 ) :rv ( rv0 ),A ( eye ( rv0.count() ) ),B ( zeros ( rv0.count() ) ) { indexlist=rv.indexlist();};
                linfn ( const RV &rv0, const mat &A0 ) : rv ( rv0 ), A ( A0 ), B ( zeros ( rv0.count() ) ) { indexlist=rv.indexlist();};
                linfn ( const RV &rv0, const mat &A0, const vec &B0 ) :rv ( rv0 ), A ( A0 ), B ( B0 ) { indexlist=rv.indexlist();};
};


/*!
\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$
//TODO can be generalized into multilinear form!
class bilinfn: public diffbifn
{
                mat A;
                mat B;
        public :
                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 ( ( 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 ( ( 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
                }
};