MATRIX::VtMatrix Class Reference

#include <VtMatrix.hh>

Inheritance diagram for MATRIX::VtMatrix:

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

{ 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$

{ return m_ncol; }

nrow()

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

inline

no of rows $n$

{ 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::VtNegMatrix, and MATRIX::VtSymMatrix.

                                                       {
    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::VtNegMatrix, and MATRIX::VtSymMatrix.

                                                       {
    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::VtNegMatrix, and MATRIX::VtSymMatrix.

                                                       {
    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::VtNegMatrix, and MATRIX::VtSymMatrix.

                                                       {
    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$

{ 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:

• /home/antonio/fedra_doxygen/src/libVt++/vt++/include/VtMatrix.hh
• /home/antonio/fedra_doxygen/src/libVt++/vt++/VtMatrix.C