functions.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 "../base/bdmbase.h"

namespace bdm{

class constfn : public fnc
{
                vec val;

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

class linfn: public fnc
{
                RV rv;
                mat A;
                vec B;
        public :
                vec eval (const vec &cond ) {it_assert_debug ( cond.length() ==A.cols(), "linfn::eval Wrong cond." );return A*cond+B;};

//              linfn evalsome ( ivec &rvind );
                linfn ( ) : fnc(), A ( ),B () { };
                void set_parameters ( const mat &A0 , const vec &B0 ) {A=A0; B=B0; dimy=A.rows();};
};


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 ) );//-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 () : fnc() {};
                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 :
                
                bilinfn () : diffbifn () ,A() ,B()      {};
                bilinfn (const mat A0, const mat B0) {set_parameters(A0,B0);};
                void set_parameters(const mat A0, const mat B0){
                        it_assert_debug(A0.rows()==B0.rows(),"");
                        A=A0;B=B0;
                        dimy=A.rows();
                        dimx=A.cols();
                        dimu=B.cols();
                }
                
                inline vec 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;
                }

                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
                }
};

} //namespace
#endif // FN_H

---