MATRIX::VtSymMatrix Class Reference

#include <VtSymMatrix.hh>

Inheritance diagram for MATRIX::VtSymMatrix:

Collaboration diagram for MATRIX::VtSymMatrix:

Public Member Functions
— Constructors —
	VtSymMatrix (const unsigned int dim)
	VtSymMatrix (const unsigned int dim, double diag)
	initalize diagonal elements More...
	VtSymMatrix (const VtSymMatrix &rhs)
	copy constructor More...
	VtSymMatrix (const VtSqMatrix &rhs)
	VtSymMatrix (const VtMatrix &rhs)
virtual	~VtSymMatrix ()
— Matrix operations —
bool	invert (const bool use_momentum)
	calc inverse using momentum or not More...
bool	VtDsinv (int dim=0)
	transform to inverse More...
const VtSymMatrix	dsinv (int dim=0) const
	return inverse More...
virtual double	det () const
	compute determinant via CERNLIB dsfact() More...
double	product (const VtVector &rhs, unsigned int dim=0) const
	compute $v^t*A*v$ More...
const VtSymMatrix	product (const VtMatrix &rhs) const
	compute $B^t*A*B$ More...
virtual void	place_at (const VtMatrix &rhs, const unsigned int row, const unsigned int col)
	copy a smaller matrix at a certain place More...
void	copy (const VtSymMatrix &rhs)
	in case matrix dimensions differ More...
const VtSymMatrix &	operator= (const VtSymMatrix &rhs)
	copy More...
const VtSymMatrix &	operator+= (const double rhs)
	$\textbf{A} = (a_{\mu\nu} + \alpha)$ More...
const VtSymMatrix &	operator-= (const double rhs)
	$\textbf{A} = (a_{\mu\nu} - \alpha)$ More...
const VtSymMatrix &	operator*= (const double rhs)
	$\textbf{A} = (a_{\mu\nu} \cdot\alpha)$ More...
const VtSymMatrix &	operator/= (const double rhs)
	$\textbf{A} = (a_{\mu\nu} / \alpha)$ More...
const VtSymMatrix &	operator+= (const VtSymMatrix &rhs)
	$\textbf{A} = (a_{\mu\nu} + b_{\mu\nu})$ More...
const VtSymMatrix &	operator-= (const VtSymMatrix &rhs)
	$\textbf{A} = (a_{\mu\nu} - b_{\mu\nu})$ More...
const VtSymMatrix	operator+ (const VtSymMatrix &rhs) const
const VtSqMatrix	operator+ (const VtSqMatrix &rhs) const
const VtMatrix	operator+ (const VtMatrix &rhs) const
const VtSymMatrix	operator- (const VtSymMatrix &rhs) const
const VtSymMatrix	operator- (void) const
const VtSqMatrix	operator- (const VtSqMatrix &rhs) const
const VtMatrix	operator- (const VtMatrix &rhs) const
const VtSqMatrix	operator* (const VtSymMatrix &rhs) const
const VtSqMatrix	operator* (const VtSqMatrix &rhs) const
const VtMatrix	operator* (const VtMatrix &rhs) const
const VtVector	operator* (const VtVector &rhs) const
Public Member Functions inherited from MATRIX::VtSqMatrix
	VtSqMatrix (const int row)
	VtSqMatrix (const VtSqMatrix &rhs)
	VtSqMatrix (const VtMatrix &rhs)
virtual	~VtSqMatrix ()
bool	VtDinv (int dim=0)
	transform to inverse More...
const VtSqMatrix	dinv (int dim=0) const
	return inverse More...
virtual const VtMatrix	operator* (const VtMatrix &rhs)
const VtVector	operator* (const VtVector &rhs) const
Public Member Functions inherited from MATRIX::VtMatrix
	VtMatrix (const unsigned int row, const unsigned int col)
	VtMatrix (const VtMatrix &rhs)
virtual	~VtMatrix ()
unsigned int	nrow () const
	no of rows $n$ More...
unsigned int	ncol () const
	no of columns $m$ More...
int	size () const
	$m\times n$ More...
VtMatrix_row	operator[] (int row)
VtMatrix_row_const	operator[] (int row) const
virtual double	operator() (unsigned int row, unsigned int col) const
virtual double &	operator() (const unsigned int row, const unsigned int col)
double	get (unsigned int row, unsigned int col) const
double &	get (unsigned int row, unsigned int col)
void	VtT (void)
	transform into transpose matrix More...
const VtMatrix	T (void) const
	return transpose More...
virtual void	place_at (const VtVector &rhs, const unsigned int row, const unsigned int col)
	copy a vector at a certain place More...
void	copy (const VtMatrix &rhs)
	to be used if matrix dimensions are not equal More...
void	clear (void)
	set matrix elements to 0 More...
const VtMatrix &	operator= (const VtMatrix &rhs)
	$\textbf{A} = \textbf{B}$ More...
const VtMatrix &	operator= (const VtNegMatrix &rhs)
const VtMatrix &	operator+= (const VtMatrix &rhs)
	$\textbf{A} = (a_{\mu\nu} + b_{\mu\nu})$ More...
const VtMatrix &	operator-= (const VtMatrix &rhs)
	$\textbf{A} = (a_{\mu\nu} - b_{\mu\nu})$ More...
const VtMatrix	operator+ (const VtMatrix &rhs) const
	$\textbf{A} + \textbf{B}$ More...
const VtMatrix	operator+ (const VtNegMatrix &rhs) const
const VtMatrix	operator- (const VtMatrix &rhs) const
	$\textbf{A} - \textbf{B}$ More...
const VtMatrix	operator- (const VtNegMatrix &rhs) const
const VtNegMatrix	operator- (void) const
	$-\textbf{A}$ More...
const VtMatrix	operator* (const VtMatrix &rhs) const
	$\textbf{A}\cdot\textbf{B} = \sum_{\nu=1}^n a_{\mu\nu}b_{\nu\lambda}$ More...
const VtVector	operator* (const VtVector &rhs) const
	$\textbf{A}\cdot\vec{v} = (\sum_{\nu=1}^n a_{\mu\nu}v_{\nu})$ More...
double *	array () const
	return pointer to internal array More...

— Expert functions —
virtual void	print (std::ostream &os) const
void	VtAssert (void)

Additional Inherited Members
Protected Attributes inherited from MATRIX::VtMatrix
double *	m
double *	work
unsigned int	m_nrow
unsigned int	m_ncol

Detailed Description

Class for symmetric matrices

Constructor & Destructor Documentation

VtSymMatrix() [1/5]

MATRIX::VtSymMatrix::VtSymMatrix ( const unsigned int  dim )

inline

: VtSqMatrix(dim) {}

VtSymMatrix() [2/5]

MATRIX::VtSymMatrix::VtSymMatrix	(	const unsigned int	dim,
		double	diag
	)

initalize diagonal elements

                                                             : VtSqMatrix(dim) {
    for(unsigned int i=0; i<nrow(); ++i)
      operator()(i,i) = diag;
  }

VtSymMatrix() [3/5]

MATRIX::VtSymMatrix::VtSymMatrix

(

const VtSymMatrix &

rhs

)

copy constructor

                                                : VtSqMatrix(rhs.nrow()) {
    const unsigned int nrow = rhs.nrow();
 
    for(unsigned int i=0; i<nrow; ++i) {
      //      operator()(i,i) = rhs(i,i);
      get(i,i) = rhs.get(i,i);
      for(unsigned int j=i+1; j<nrow; ++j) {
    //  operator()(i,j) = operator()(j,i) = rhs(i,j);
    get(i,j) = get(j,i) = rhs.get(i,j);
      }
    }
  }

VtSymMatrix() [4/5]

MATRIX::VtSymMatrix::VtSymMatrix ( const VtSqMatrix &  rhs )

inline

                                       : VtSqMatrix(rhs) {
      //      Assert();
    }

VtSymMatrix() [5/5]

MATRIX::VtSymMatrix::VtSymMatrix ( const VtMatrix &  rhs )

inline

                                     : VtSqMatrix(rhs) {
      //      Assert();
    }

~VtSymMatrix()

MATRIX::VtSymMatrix::~VtSymMatrix ( )

virtual

{}

Member Function Documentation

copy()

void MATRIX::VtSymMatrix::copy

(

const VtSymMatrix &

rhs

)

in case matrix dimensions differ

                                               {
 
    const unsigned int nrow = (m_nrow < rhs.nrow()) ? m_nrow : rhs.nrow();
 
    for(unsigned int i=0; i<nrow; ++i) {
      operator()(i,i) = rhs(i,i);
      for(unsigned int j=i+1; j<nrow; ++j) {
    operator()(i,j) = operator()(j,i) = rhs(i,j);
      }
    }
 
    return;
  }

det()

double MATRIX::VtSymMatrix::det ( void  ) const

virtual

compute determinant via CERNLIB dsfact()

Reimplemented from MATRIX::VtSqMatrix.

                                    {
    
    int ifail, jfail;
    int n = nrow();
    double det;
 
    memcpy( work, m, size() * sizeof(double) );
 
    Dsfact1(&n, work, &n, &ifail, &det, &jfail);
    if(jfail != 0) {
      det = 0;
#ifdef VtDEBUG
      cout << "VtSymMatrix::det() error: Determinant computation failed!" << endl;
#endif
    }
 
    return det;
  }

dsinv()

const VtSymMatrix MATRIX::VtSymMatrix::dsinv

(

int

dim = 0

)

const

return inverse

                                                    {
    if(dim==0) {
      VtSymMatrix tmp(*this);
      tmp.VtDsinv(dim);
      return tmp;
    } else {
      VtSymMatrix tmp(dim);
      tmp.copy(*this);
      tmp.VtDsinv();
      return tmp;
    }
    //    return VtSymMatrix(*this).VtDsinv(dim);
  }

invert()

bool MATRIX::VtSymMatrix::invert

(

const bool

use_momentum

)

calc inverse using momentum or not

                                                  {
    if(use_momentum)
      return VtDsinv(nrow());
    else
      return VtDsinv(nrow() - 1);
  }

operator*() [1/4]

const VtMatrix MATRIX::VtSymMatrix::operator*

(

const VtMatrix &

rhs

)

const

                                                                 {
    
    return VtMatrix::operator*(rhs);
  }

operator*() [2/4]

const VtSqMatrix MATRIX::VtSymMatrix::operator*

(

const VtSqMatrix &

rhs

)

const

                                                                     {
 
    return VtMatrix::operator*(rhs);
  }

operator*() [3/4]

const VtSqMatrix MATRIX::VtSymMatrix::operator*

(

const VtSymMatrix &

rhs

)

const

                                                                      {
 
    return VtMatrix::operator*(rhs);
  }

operator*() [4/4]

const VtVector MATRIX::VtSymMatrix::operator*

(

const VtVector &

rhs

)

const

                                                                 {
 
    return VtMatrix::operator*(rhs);
  }

operator*=()

const VtSymMatrix & MATRIX::VtSymMatrix::operator*= ( const double  rhs )

virtual

$\textbf{A} = (a_{\mu\nu} \cdot\alpha)$

Reimplemented from MATRIX::VtMatrix.

                                                             {
    const unsigned int nrow = ncol();
 
    for(unsigned int i=0; i<nrow; ++i){
      for(unsigned int j=i; j<nrow; ++j) {
    operator()(i,j) = operator()(j,i) *= rhs;
      }
    }
    return *this;
  }

operator+() [1/3]

const VtMatrix MATRIX::VtSymMatrix::operator+

(

const VtMatrix &

rhs

)

const

                                                                 {
    
    return VtMatrix::operator+(rhs);
  }

operator+() [2/3]

const VtSqMatrix MATRIX::VtSymMatrix::operator+

(

const VtSqMatrix &

rhs

)

const

                                                                     {
 
    return VtMatrix::operator+(rhs);
  }

operator+() [3/3]

const VtSymMatrix MATRIX::VtSymMatrix::operator+

(

const VtSymMatrix &

rhs

)

const

                                                                       {
 
#ifndef VtFAST
    assert(ncol() == rhs.ncol());
#endif
 
#ifdef VtDEBUG
    cout << "VtSymMatrix::operator+ called!" << endl;
#endif
 
    VtSymMatrix tmp(*this);
    return tmp += rhs;
  }

operator+=() [1/2]

const VtSymMatrix & MATRIX::VtSymMatrix::operator+= ( const double  rhs )

virtual

$\textbf{A} = (a_{\mu\nu} + \alpha)$

Reimplemented from MATRIX::VtMatrix.

                                                             {
    const unsigned int nrow = ncol();
 
    for(unsigned int i=0; i<nrow; ++i){
      for(unsigned int j=i; j<nrow; ++j) {
    operator()(i,j) = operator()(j,i) += rhs;
      }
    }
    return *this;
  }

operator+=() [2/2]

const VtSymMatrix & MATRIX::VtSymMatrix::operator+=

(

const VtSymMatrix &

rhs

)

$\textbf{A} = (a_{\mu\nu} + b_{\mu\nu})$

                                                                   {
 
#ifndef VtFAST
    assert(ncol() == rhs.ncol());
#endif
    
    const unsigned int nrow = rhs.nrow();
 
    for(unsigned int i=0; i<nrow; ++i)
      for(unsigned int j=i; j<nrow; ++j)
    operator()(i,j) = operator()(j,i) += rhs(i,j);
 
    return *this;
  }

operator-() [1/4]

const VtMatrix MATRIX::VtSymMatrix::operator-

(

const VtMatrix &

rhs

)

const

                                                                 {
    
    return VtMatrix::operator-(rhs);
  }

operator-() [2/4]

const VtSqMatrix MATRIX::VtSymMatrix::operator-

(

const VtSqMatrix &

rhs

)

const

                                                                     {
 
    return VtMatrix::operator-(rhs);
  }

operator-() [3/4]

const VtSymMatrix MATRIX::VtSymMatrix::operator-

(

const VtSymMatrix &

rhs

)

const

                                                                       {
 
#ifndef VtFAST
    assert(ncol() == rhs.ncol());
#endif
    
#ifdef VtDEBUG
    cout << "VtSymMatrix::operator- called!" << endl;
#endif
 
    VtSymMatrix tmp(*this);
    return tmp -= rhs;
  }

operator-() [4/4]

const VtSymMatrix MATRIX::VtSymMatrix::operator-

(

void

)

const

                                                 {
 
#ifdef VtDEBUG
    cout << "VtSymMatrix::operator- (unary) called!" << endl;
#endif
 
    const unsigned int nrow = ncol();
    VtSymMatrix tmp(nrow);
 
    for(unsigned int i=0; i<nrow; ++i) {
      for(unsigned int j=i; j<nrow; ++j) {
    tmp(i,j) = tmp(j,i) = -get(i,j);
      }
    }
    
    return tmp;
  }

operator-=() [1/2]

const VtSymMatrix & MATRIX::VtSymMatrix::operator-= ( const double  rhs )

virtual

$\textbf{A} = (a_{\mu\nu} - \alpha)$

Reimplemented from MATRIX::VtMatrix.

                                                             {
    const unsigned int nrow = ncol();
 
    for(unsigned int i=0; i<nrow; ++i){
      for(unsigned int j=i; j<nrow; ++j) {
    operator()(i,j) = operator()(j,i) -= rhs;
      }
    }
    return *this;
  }

operator-=() [2/2]

const VtSymMatrix & MATRIX::VtSymMatrix::operator-=

(

const VtSymMatrix &

rhs

)

$\textbf{A} = (a_{\mu\nu} - b_{\mu\nu})$

                                                                   {
 
#ifndef VtFAST
    assert(ncol() == rhs.ncol());
#endif
    
    const unsigned int nrow = rhs.nrow();
 
    for(unsigned int i=0; i<nrow; ++i)
      for(unsigned int j=i; j<nrow; ++j)
    operator()(i,j) = operator()(j,i) -= rhs(i,j);
 
    return *this;
  }

operator/=()

const VtSymMatrix & MATRIX::VtSymMatrix::operator/= ( const double  rhs )

virtual

$\textbf{A} = (a_{\mu\nu} / \alpha)$

Reimplemented from MATRIX::VtMatrix.

                                                             {
    const unsigned int nrow = ncol();
 
    for(unsigned int i=0; i<nrow; ++i){
      for(unsigned int j=i; j<nrow; ++j) {
    operator()(i,j) = operator()(j,i) /= rhs;
      }
    }
    return *this;
  }

operator=()

const VtSymMatrix & MATRIX::VtSymMatrix::operator=

(

const VtSymMatrix &

rhs

)

copy

                                                                  {
    if(this == &rhs) return *this;
 
#ifndef VtFAST
    assert(ncol() == rhs.ncol());
#endif
 
#ifdef VtDEBUG
    cout << "use VtSymMatrix::operator=" << endl;
#endif
    const unsigned int nrow = ncol();
 
    for(unsigned int i=0; i<nrow; ++i) {
      //      operator()(i,i) = rhs(i,i);
      get(i,i) = rhs.get(i,i);
      for(unsigned int j=i+1; j<nrow; ++j) {
    //  operator()(i,j) = operator()(j,i) = rhs(i,j);
    get(i,j) = get(j,i) = rhs.get(i,j);
      }
    }
 
    return *this;
  }

place_at()

void MATRIX::VtSymMatrix::place_at ( const VtMatrix &  rhs, const unsigned int  row, const unsigned int  col  )

virtual

copy a smaller matrix at a certain place

Reimplemented from MATRIX::VtMatrix.

                                         {
#ifndef VtFAST
    assert(nrow() >= rhs.nrow()+row && ncol() >= rhs.ncol()+col);
#endif
 
    const unsigned int rnrow = rhs.nrow();
    const unsigned int rncol = rhs.ncol();
 
    for(unsigned int i=0; i<rnrow; ++i) {
      const unsigned int nr = i + row;
      for(unsigned int j=0, nc=col; j<rncol; ++j,++nc) {
    get(nr,nc) = get(nc,nr) = rhs(i,j);
      }
    }
 
    return;
  }

print()

void MATRIX::VtSymMatrix::print ( std::ostream &  os ) const

virtual

Reimplemented from MATRIX::VtMatrix.

                                              {
    os.setf(ios::scientific,ios::floatfield);
    VtMatrix::print(os);
  }

product() [1/2]

const VtSymMatrix MATRIX::VtSymMatrix::product

(

const VtMatrix &

rhs

)

const

compute $B^t*A*B$

                                                                  {
    
#ifndef VtFAST
    assert(ncol() == rhs.nrow());
#endif
 
    const unsigned int rncol = rhs.ncol();
 
    VtSymMatrix tmp(rncol);
    
    for(unsigned int i=0; i<rncol; ++i) {
      for(unsigned int j=i; j<rncol; ++j) {
    for(unsigned int k=0; k<m_ncol; ++k) {
      double sum = 0;
      for(unsigned int l=0; l<m_ncol; ++l)
        sum += get(k,l) * rhs(l,j);
      tmp(i,j) += rhs(k,i) * sum;
    }
    tmp(j,i) = tmp(i,j);
      }
    }
 
    return tmp;
  }

product() [2/2]

double MATRIX::VtSymMatrix::product	(	const VtVector &	rhs,
		unsigned int	dim = 0
	)		const

compute $v^t*A*v$

                                                                         {
 
#ifndef VtFAST
    assert(ncol() == rhs.nrow());
#endif
 
    if(dim == 0) dim = ncol();
#ifndef VtFAST
    else
      assert(dim <= ncol());
#endif
 
    double result = 0.;
 
    // contribution from diagonal elements
    for(unsigned int i=0; i<dim; ++i)
      result += get(i,i) * rhs[i]*rhs[i];
 
    // make use of fact that Matrix is symmetric
    for(unsigned int i=0; i<(dim-1); ++i) {
      double sum = 0.;
      for(unsigned int j=i+1; j<dim; ++j) {
    sum += get(i,j) * rhs[j];
      }
      result += 2. * rhs[i] * sum;
    }
 
    return result;
  }

VtAssert()

void MATRIX::VtSymMatrix::VtAssert ( void  )

private

                                 {
    for(unsigned int i=0; i<nrow(); ++i)
      for(unsigned int j=i+1; j<ncol(); ++j) {
    cout.setf(ios::scientific,ios::floatfield);
    double ij = operator()(i,j);
    double ji = operator()(j,i);
    double dd = 0.;
    if(fabs(ij) < 1e-20) 
      dd = ij - ji;
    else
      dd = (ij - ji)/ij;
//        cout << "i: " << i << " j: " << j 
//             << "(i,j): " << ij << " "
//             << "(j,i): " << ji << " "
//             << "diff: "  << fabs(dd) << endl;
    assert( dd < 1.e-6 );
      }
    return;
  }

VtDsinv()

bool MATRIX::VtSymMatrix::VtDsinv

(

int

dim = 0

)

transform to inverse

                                   {
    bool valid = false;
 
    if(dim == 0) dim = nrow();
#ifndef VtFAST
    else {
      assert(dim <= static_cast<int>(nrow()));
    }
#endif
 
    const size_t msize = size() * sizeof(double);
 
    memcpy( work, m, msize );
 
    int ifail = 0;
    int isize = nrow();
    Dsinv1(&dim, work, &isize, &ifail);
    
    if(ifail != -1) {
      memcpy( m, work, msize );
      valid = true;
    }
#ifdef VtDEBUG
    else {
      cout << "VtSymMatrix::dsinv() error: Matrix inversion failed!!!"
       << " (nrow=" << nrow() << ",ncol=" << ncol() 
       << ",size=" << size()
       << ",ifail=" << ifail << ")" << endl;
    } 
#endif
 
    return valid;
  }

---

The documentation for this class was generated from the following files:

• src/libVt++/vt++/include/VtSymMatrix.hh
• src/libVt++/vt++/VtSymMatrix.C