work/git/mixpp/bdm/stat/libFN.h

//
// C++ Interface: itpp_ext
//
// Description:
//
//
// Author: smidl <smidl@utia.cas.cz>, (C) 2008
//
// Copyright: See COPYING file that comes with this distribution
//
//
#ifndef FN_H
#define FN_H

#include <itpp/itbase.h>
#include "libBM.h"

using namespace itpp;

class constfn : public fnc
{
                vec val;

        public:
                //vec eval() {return val;};
                vec eval ( const vec &cond ) {return val;};
                constfn ( const vec &val0 ) :fnc(val0.length()), val ( val0 ) {};
};

class linfn: public fnc
{
                RV rv;
                mat A;
                vec B;
        public :
                vec eval (const 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 ) : fnc(rv0.count()), rv ( rv0 ),A ( eye ( rv0.count() ) ),B ( zeros ( rv0.count() ) ) { };
                void set_parameters ( const mat &A0 , const vec &B0 ) {A=A0; B=B0;};
};


class diffbifn: public fnc
{
        protected:
                RV rvx;
                RV rvu;
                int dimx;
                int dimu;
        public:
                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)
                };

                virtual vec eval ( const vec &x0, const vec &u0 ) {return zeros ( dimy );};
                virtual void dfdx_cond ( const vec &x0, const vec &u0, mat &A , bool full=true ) {};
                virtual void dfdu_cond ( const vec &x0, const vec &u0, mat &A, bool full=true ) {};
                diffbifn (int dimy, const RV rvx0, const RV rvu0 ) : fnc(dimy), rvx ( rvx0 ),rvu ( rvu0 ) {dimx=rvx.count();dimu=rvu.count();};
                int _dimx() const{return dimx;}
                int _dimu() const{return dimu;}
};

//TODO can be generalized into multilinear form!
class bilinfn: public diffbifn
{
                mat A;
                mat B;
        public :
                vec eval ( const  vec &x0, const vec &u0 );

                bilinfn ( const RV &rvx0, const RV &rvu0 ) : diffbifn (dimx, 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
                }
};

#endif // FN_H

---