work/mixpp/bdm/math/libDC.h

Go to the documentation of this file.

#ifndef DC_H
#define DC_H

#include <itpp/itbase.h>

using namespace itpp;

class sqmat
{
        public:
                virtual void opupdt ( const vec &v, double w ) =0;

                virtual mat to_mat() =0;

                virtual void mult_sym ( const mat &C, bool trans=true ) =0;


                virtual double logdet() =0;

                virtual vec sqrt_mult ( vec &v ) =0;

                virtual double qform ( vec &v ) =0;

//      //! easy version of the
//      sqmat inv();

                virtual void clear() =0;

                int cols() const {return dim;};

                int rows() const {return dim;};

        protected:
                int dim;
};


class fsqmat: public sqmat
{
        protected:
                mat M;
        public:
                void opupdt ( const vec &v, double w );
                mat to_mat() ;
                void mult_sym ( const mat &C, bool trans=false );
                void mult_sym ( const mat &C, fsqmat &U, bool trans=false );
                void clear();


                fsqmat(); // mat will be initialized OK
                fsqmat ( const mat &M );

                virtual void inv ( fsqmat &Inv );

                double logdet() {return log ( det ( M ) );};
                double qform ( vec &v ) {return ( v* ( M*v ) );};
                vec sqrt_mult ( vec &v ) {it_error ( "not implemented" );return v;};

                fsqmat& operator += ( const fsqmat &A ) {M+=A.M;return *this;};
                fsqmat& operator -= ( const fsqmat &A ) {M-=A.M;return *this;};
                fsqmat& operator *= ( double x ) {M*=x;return *this;};
//              fsqmat& operator = ( const fsqmat &A) {M=A.M; return *this;};
};

class ldmat: sqmat
{
        public:

                ldmat ( const mat &L, const vec &D );
                ldmat ( mat V );
                ldmat ( vec D0 );
                ldmat ();

                // Reimplementation of compulsory operatios

                void opupdt ( const vec &v, double w );
                mat to_mat();
                void mult_sym ( const mat &C, bool trans=false );
                void add ( const ldmat &ld2, double w=1.0 );
                double logdet();
                double qform ( vec &v );
//      sqmat& operator -= ( const sqmat & ld2 );
                void clear();
                int cols();
                int rows();
                vec sqrt_mult ( vec &v );

                virtual void inv ( ldmat &Inv );

                void mult_sym ( const mat &C, ldmat &U, bool trans=false );

                void ldform ( mat &A, vec &D0 );

                ldmat& operator += ( const ldmat &ldA );
                ldmat& operator -= ( const ldmat &ldA );
                ldmat& operator *= ( double x );

                friend std::ostream &operator<< ( std::ostream &os, ldmat &sq );

        protected:
                vec D;
                mat L;

};


inline ldmat& ldmat::operator += ( const ldmat &ldA )  {this->add ( ldA );return *this;}
inline ldmat& ldmat::operator -= ( const ldmat &ldA )  {this->add ( ldA,-1.0 );return *this;}
inline int ldmat::cols() {return dim;}
inline int ldmat::rows() {return dim;}

#endif // DC_H

---