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 inv(fsqmat &Inv);
        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;};
};

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

---