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

---