#include <VtMatrix.hh>

Inheritance diagram for MATRIX::VtMatrix:

[legend]

Classes
class	VtMatrix_row

class	VtMatrix_row_const

Public Member Functions
— Constructors —
	VtMatrix (const unsigned int row, const unsigned int col)

	VtMatrix (const VtMatrix &rhs)

virtual	~VtMatrix ()

— Access functions —
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)

— Matrix operations —
void	VtT (void)
	transform into transpose matrix More...

const VtMatrix	T (void) const
	return transpose 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...

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)

virtual const VtMatrix &	operator+= (const double rhs)
	$\textbf{A} = (a_{\mu\nu} + \alpha)$ More...

virtual const VtMatrix &	operator-= (const double rhs)
	$\textbf{A} = (a_{\mu\nu} - \alpha)$ More...

virtual const VtMatrix &	operator*= (const double rhs)
	$\textbf{A} = (a_{\mu\nu} \cdot\alpha)$ More...

virtual const VtMatrix &	operator/= (const double rhs)
	$\textbf{A} = (a_{\mu\nu} / \alpha)$ More...

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...

— Expert functions —
double *	m

double *	work

unsigned int	m_nrow

unsigned int	m_ncol

class	VtMatrix_row

class	VtMatrix_row_const

int	m_size

double *	array () const
	return pointer to internal array More...

virtual void	print (std::ostream &os) const

Detailed Description

Simple Matrix computation base class

Constructor & Destructor Documentation

◆ VtMatrix() [1/2]

MATRIX::VtMatrix::VtMatrix	(	const unsigned int	row,
		const unsigned int	col
	)

                                                                   :
     m_nrow(row),
     m_ncol(col),
     m_size(row*col) {
     m    = new double[m_size];
     work = new double[m_size];
     memset(m, 0, m_size * sizeof(double));
   }

◆ VtMatrix() [2/2]

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

                                        :
     m_nrow(rhs.nrow()),
     m_ncol(rhs.ncol()),
     m_size(rhs.size()) {
     m    = new double[m_size];
     work = new double[m_size];
     memcpy(m, rhs.m, m_size * sizeof(double));
   }

◆ ~VtMatrix()

MATRIX::VtMatrix::~VtMatrix ( )

virtual

                       {
     delete[] m;
     delete[] work;
   }

Member Function Documentation

◆ array()

double* MATRIX::VtMatrix::array ( ) const

inline

return pointer to internal array

166 { return m; }

◆ clear()

void MATRIX::VtMatrix::clear ( void )

set matrix elements to 0

                            {
     memset(m, 0, m_size * sizeof(double));
     return;
   }

◆ copy()

void MATRIX::VtMatrix::copy ( const VtMatrix & rhs )

to be used if matrix dimensions are not equal

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

◆ get() [1/2]

double& MATRIX::VtMatrix::get	(	unsigned int	row,
		unsigned int	col
	)

inline

                                                            {
       return *(m + row*m_ncol + col);
     }

◆ get() [2/2]

double MATRIX::VtMatrix::get	(	unsigned int	row,
		unsigned int	col
	)		const

inline

                                                                 {
       return *(m + row*m_ncol + col);
     }

◆ ncol()

unsigned int MATRIX::VtMatrix::ncol ( ) const

inline

no of columns $m$

63 { return m_ncol; }

◆ nrow()

unsigned int MATRIX::VtMatrix::nrow ( ) const

inline

no of rows $n$

61 { return m_nrow; }

◆ operator()() [1/2]

double & MATRIX::VtMatrix::operator()	(	const unsigned int	row,
		const unsigned int	col
	)

virtual

Reimplemented in MATRIX::VtNegMatrix.

                                                                              {
     return *(m + row*m_ncol + col);
   }

◆ operator()() [2/2]

double MATRIX::VtMatrix::operator()	(	unsigned int	row,
		unsigned int	col
	)		const

virtual

Reimplemented in MATRIX::VtNegMatrix.

                                                                        {
     return *(m + row*m_ncol + col);
   }

◆ operator*() [1/2]

const VtMatrix MATRIX::VtMatrix::operator* ( const VtMatrix & rhs ) const

$\textbf{A}\cdot\textbf{B} = \sum_{\nu=1}^n a_{\mu\nu}b_{\nu\lambda}$

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

◆ operator*() [2/2]

const VtVector MATRIX::VtMatrix::operator* ( const VtVector & rhs ) const

$\textbf{A}\cdot\vec{v} = (\sum_{\nu=1}^n a_{\mu\nu}v_{\nu})$

                                                               {
  
 #ifndef VtFAST
     assert(ncol() == rhs.nrow());
 #endif
  
     VtVector tmp(m_nrow);
     
     for(unsigned int i=0; i<m_nrow; ++i) {
       for(unsigned int j=0; j<m_ncol; ++j) {
     //  tmp[i] += operator()(i,j) * rhs[j];
     tmp[i] += get(i,j) * rhs[j];
       }
     }
  
     return tmp;
   }

◆ operator*=()

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

virtual

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

Reimplemented in MATRIX::VtSymMatrix, and MATRIX::VtNegMatrix.

                                                        {
     for(int i=0; i<m_size; ++i) m[i] *= rhs;
     return *this;
   }

◆ operator+() [1/2]

const VtMatrix MATRIX::VtMatrix::operator+ ( const VtMatrix & rhs ) const

$\textbf{A} + \textbf{B}$

                                                               {
  
 #ifndef VtFAST
     assert(ncol() == rhs.ncol() && nrow() == rhs.nrow());
 #endif
     
     VtMatrix tmp(*this);
  
     return tmp += rhs;
   }

◆ operator+() [2/2]

const VtMatrix MATRIX::VtMatrix::operator+ ( const VtNegMatrix & rhs ) const

                                                                  {
     
 #ifndef VtFAST
     assert(ncol() == rhs.ncol() && nrow() == rhs.nrow());
 #endif
  
     VtMatrix tmp(*this);
     return tmp -= rhs;
   }

◆ operator+=() [1/2]

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

virtual

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

Reimplemented in MATRIX::VtSymMatrix, and MATRIX::VtNegMatrix.

                                                        {
     for(int i=0; i<m_size; ++i) m[i] += rhs;
     return *this;
   }

◆ operator+=() [2/2]

const VtMatrix & MATRIX::VtMatrix::operator+= ( const VtMatrix & rhs )

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

                                                           {
  
 #ifndef VtFAST
     assert(size() == rhs.size());
 #endif
  
     for(int i=0; i<m_size; ++i) m[i] += rhs.m[i];
     return *this;
   }

◆ operator-() [1/3]

const VtMatrix MATRIX::VtMatrix::operator- ( const VtMatrix & rhs ) const

$\textbf{A} - \textbf{B}$

                                                               {
  
 #ifndef VtFAST
     assert(ncol() == rhs.ncol() && nrow() == rhs.nrow());
 #endif
     
     VtMatrix tmp(*this);
  
     return tmp -= rhs;
   }

◆ operator-() [2/3]

const VtMatrix MATRIX::VtMatrix::operator- ( const VtNegMatrix & rhs ) const

                                                                  {
  
 #ifndef VtFAST
     assert(ncol() == rhs.ncol() && nrow() == rhs.nrow());
 #endif
     
     VtMatrix tmp(*this);
  
     return tmp += rhs;
   }

◆ operator-() [3/3]

const VtNegMatrix MATRIX::VtMatrix::operator- ( void ) const

$-\textbf{A}$

                                               {
  
 #ifdef VtDEBUG
     cout << "VtMatrix::operator- (unary) called!" << endl;
 #endif
  
     return VtNegMatrix(*this);
   }

◆ operator-=() [1/2]

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

virtual

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

Reimplemented in MATRIX::VtSymMatrix, and MATRIX::VtNegMatrix.

                                                        {
     for(int i=0; i<m_size; ++i) m[i] -= rhs;
     return *this;
   }

◆ operator-=() [2/2]

const VtMatrix & MATRIX::VtMatrix::operator-= ( const VtMatrix & rhs )

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

                                                           {
  
 #ifndef VtFAST
     assert(size() == rhs.size());
 #endif
  
     for(int i=0; i<m_size; ++i) m[i] -= rhs.m[i];
     return *this;
   }

◆ operator/=()

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

virtual

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

Reimplemented in MATRIX::VtSymMatrix, and MATRIX::VtNegMatrix.

                                                        {
     for(int i=0; i<m_size; ++i) m[i] /= rhs;
     return *this;
   }

◆ operator=() [1/2]

const VtMatrix & MATRIX::VtMatrix::operator= ( const VtMatrix & rhs )

$\textbf{A} = \textbf{B}$

                                                          {
     if(this == &rhs) return *this;
  
 #ifndef VtFAST
     assert(size() == rhs.size());
 #endif
  
     m_nrow = rhs.nrow();
     m_ncol = rhs.ncol();
     m_size = rhs.size();
     
     memcpy(m, rhs.m, m_size * sizeof(double)); 
     
     return *this;
   }

◆ operator=() [2/2]

const VtMatrix & MATRIX::VtMatrix::operator= ( const VtNegMatrix & rhs )

                                                             {
     
 #ifndef VtFAST
     assert(size() == rhs.size());
 #endif
     
     m_nrow = rhs.nrow();
     m_ncol = rhs.ncol();
     m_size = rhs.size();
     
     for(int i=0; i<m_size; ++i)  m[i] = -rhs.m[i];
     
     return *this;
   }

◆ operator[]() [1/2]

VtMatrix_row MATRIX::VtMatrix::operator[] ( int row )

inline

                                             {
       return VtMatrix_row(*this, row);
     }

◆ operator[]() [2/2]

VtMatrix_row_const MATRIX::VtMatrix::operator[] ( int row ) const

inline

                                                         {
       return VtMatrix_row_const(*this, row);
     }

◆ place_at() [1/2]

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

virtual

copy a smaller matrix at a certain place

Reimplemented in MATRIX::VtSymMatrix.

                                       {
 #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) {
     operator()(nr,nc) = rhs(i,j);
       }
     }
  
     return;
   }

◆ place_at() [2/2]

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

virtual

copy a vector at a certain place

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

◆ print()

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

virtual

Reimplemented in MATRIX::VtSymMatrix.

                                            {
     /* Fixed format needs 3 extra characters for field, while scientific needs 7 */
     int width;
     os << std::endl;
     if(os.flags() & std::ios::fixed)
       width = os.precision()+3;
     else
       width = os.precision()+7;
     for(unsigned int row = 0; row < m_nrow; ++row) {
       for(unsigned int col = 0; col < m_ncol; ++col) {
     os.width(width);
     os << operator()(row,col) << " ";
       }
       os << std::endl;
     }
     return;
   }

◆ size()

int MATRIX::VtMatrix::size ( ) const

inline

$m\times n$

65 { return m_size; }

◆ T()

const VtMatrix MATRIX::VtMatrix::T ( void ) const

return transpose

                                        {
     VtMatrix tmp(*this);
     tmp.VtT();
     return tmp;
   }

◆ VtT()

void MATRIX::VtMatrix::VtT ( void )

transform into transpose matrix

                          {
  
     memcpy( work, m, size() * sizeof(double) );
     for(unsigned int i=0; i<m_nrow; ++i) {
       for(unsigned int j=0; j<m_ncol; ++j) {
     m[j*m_nrow+i] = work[i*m_ncol+j];
       }
     }
     const int tmp = m_nrow;
     m_nrow = m_ncol;
     m_ncol = tmp;
  
     return;
   }

Friends And Related Function Documentation

◆ VtMatrix_row

friend class VtMatrix_row

friend

◆ VtMatrix_row_const

friend class VtMatrix_row_const

friend

Member Data Documentation

◆ m

double* MATRIX::VtMatrix::m

protected

◆ m_ncol

unsigned int MATRIX::VtMatrix::m_ncol

protected

◆ m_nrow

unsigned int MATRIX::VtMatrix::m_nrow

protected

◆ m_size

int MATRIX::VtMatrix::m_size

private

◆ work

double* MATRIX::VtMatrix::work

protected

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

src/libVt++/vt++/include/VtMatrix.hh
src/libVt++/vt++/VtMatrix.C

Classes

Public Member Functions

— Expert functions —

Detailed Description

Constructor & Destructor Documentation

◆ VtMatrix() [1/2]

◆ VtMatrix() [2/2]

◆ ~VtMatrix()

Member Function Documentation

◆ array()

◆ clear()

◆ copy()

◆ get() [1/2]

◆ get() [2/2]

◆ ncol()

◆ nrow()

◆ operator()() [1/2]

◆ operator()() [2/2]

◆ operator*() [1/2]

◆ operator*() [2/2]

◆ operator*=()

◆ operator+() [1/2]

◆ operator+() [2/2]

◆ operator+=() [1/2]

◆ operator+=() [2/2]

◆ operator-() [1/3]

◆ operator-() [2/3]

◆ operator-() [3/3]

◆ operator-=() [1/2]

◆ operator-=() [2/2]

◆ operator/=()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ place_at() [1/2]

◆ place_at() [2/2]

◆ print()

◆ size()

◆ T()

◆ VtT()

Friends And Related Function Documentation

◆ VtMatrix_row

◆ VtMatrix_row_const

Member Data Documentation

◆ m

◆ m_ncol

◆ m_nrow

◆ m_size

◆ work