MATRIX::VtNegMatrix Class Reference

#include <VtNegMatrix.hh>

Inheritance diagram for MATRIX::VtNegMatrix:

Collaboration diagram for MATRIX::VtNegMatrix:

Public Member Functions
— Constructors —
	VtNegMatrix (const unsigned int row, const unsigned int col)
	VtNegMatrix (const VtNegMatrix &rhs)
	VtNegMatrix (const VtMatrix &rhs)
	~VtNegMatrix ()
double	operator() (unsigned int row, unsigned int col) const
double &	operator() (const unsigned int row, const unsigned int col)
double	nget (unsigned int row, unsigned int col) const
double &	nget (unsigned int row, unsigned int col)
— Matrix operations —
const VtNegMatrix	T (void) const
	return transposed matrix More...
const VtNegMatrix &	operator+= (const double rhs)
	$\textbf{A} = (a_{\mu\nu} + \alpha)$ More...
const VtNegMatrix &	operator-= (const double rhs)
	$\textbf{A} = (a_{\mu\nu} - \alpha)$ More...
const VtNegMatrix &	operator*= (const double rhs)
	$\textbf{A} = (a_{\mu\nu} \cdot\alpha)$ More...
const VtNegMatrix &	operator/= (const double rhs)
	$\textbf{A} = (a_{\mu\nu} / \alpha)$ More...
const VtNegMatrix &	operator+= (const VtMatrix &rhs)
const VtNegMatrix &	operator+= (const VtNegMatrix &rhs)
const VtNegMatrix &	operator-= (const VtMatrix &rhs)
const VtNegMatrix &	operator-= (const VtNegMatrix &rhs)
const VtMatrix	operator+ (const VtMatrix &rhs) const
const VtMatrix	operator+ (const VtNegMatrix &rhs) const
const VtMatrix	operator- (const VtMatrix &rhs) const
const VtMatrix	operator- (void) const
const VtMatrix	operator* (const VtMatrix &rhs) const
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
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 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)
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...
virtual void	print (std::ostream &os) const

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

Detailed Description

A class for negative matrices to optimize expressions like $C = -A * B$. For internal use only! @memo Negative matrix class

Constructor & Destructor Documentation

VtNegMatrix() [1/3]

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

                                                                        :
    VtMatrix(row,col) {}

VtNegMatrix() [2/3]

MATRIX::VtNegMatrix::VtNegMatrix

(

const VtNegMatrix &

rhs

)

                                                :
    VtMatrix(rhs) {}

VtNegMatrix() [3/3]

MATRIX::VtNegMatrix::VtNegMatrix

(

const VtMatrix &

rhs

)

                                             :
    VtMatrix(rhs) {}

~VtNegMatrix()

MATRIX::VtNegMatrix::~VtNegMatrix ( )

inline

{}

Member Function Documentation

nget() [1/2]

double& MATRIX::VtNegMatrix::nget ( unsigned int  row, unsigned int  col  )

inline

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

nget() [2/2]

double MATRIX::VtNegMatrix::nget ( unsigned int  row, unsigned int  col  ) const

inline

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

operator()() [1/2]

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

virtual

Reimplemented from MATRIX::VtMatrix.

                                                                                {
    //    cout << "VtNegMatrix::operator() const called!" << endl;
    return *(m + row*m_ncol + col);
  }

operator()() [2/2]

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

virtual

Reimplemented from MATRIX::VtMatrix.

                                                                         {
    //    cout << "VtNegMatrix::operator() const called!" << endl;
    return -*(m + row*m_ncol + col);
  }

operator*() [1/2]

const VtMatrix MATRIX::VtNegMatrix::operator*

(

const VtMatrix &

rhs

)

const

                                                                 {
 
#ifndef VtFAST
    assert(ncol() == rhs.nrow());
#endif
 
    const unsigned int lnrow = nrow();
    const unsigned int rncol = rhs.ncol();
    const unsigned int rnrow = rhs.nrow();
 
    VtMatrix tmp(lnrow, rncol);
 
    // the trick is that operator()(i,k) returns the
    // negative!
    for(unsigned int i=0; i<lnrow; ++i) {
      for(unsigned int j=0; j<rncol; ++j) {
    for(unsigned int k=0; k<rnrow; ++k) {
      // tmp(i,j) += operator()(i,k) * rhs(k,j);
      tmp.get(i,j) += nget(i,k) * rhs.get(k,j);
    }
      }
    }
 
    return tmp;
  }

operator*() [2/2]

const VtVector MATRIX::VtNegMatrix::operator*

(

const VtVector &

rhs

)

const

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

operator*=()

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

virtual

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

Reimplemented from MATRIX::VtMatrix.

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

operator+() [1/2]

const VtMatrix MATRIX::VtNegMatrix::operator+

(

const VtMatrix &

rhs

)

const

                                                                 {
 
    return VtMatrix(rhs - *this);
  }

operator+() [2/2]

const VtMatrix MATRIX::VtNegMatrix::operator+

(

const VtNegMatrix &

rhs

)

const

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

operator+=() [1/3]

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

virtual

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

Reimplemented from MATRIX::VtMatrix.

                                                             {
    VtMatrix::operator-=(rhs);
    return *this;
  }

operator+=() [2/3]

const VtNegMatrix & MATRIX::VtNegMatrix::operator+=

(

const VtMatrix &

rhs

)

                                                                {
    cout << "VtNegMatrix::operator+=(VtMatrix) called" << endl;
    VtMatrix::operator-=(rhs);
    return *this;
  }

operator+=() [3/3]

const VtNegMatrix & MATRIX::VtNegMatrix::operator+=

(

const VtNegMatrix &

rhs

)

                                                                   {
    cout << "VtNegMatrix::operator+=(VtNegMatrix) called" << endl;
    VtMatrix::operator+=(rhs);
    return *this;
  }

operator-() [1/2]

const VtMatrix MATRIX::VtNegMatrix::operator-

(

const VtMatrix &

rhs

)

const

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

operator-() [2/2]

const VtMatrix MATRIX::VtNegMatrix::operator-

(

void

)

const

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

operator-=() [1/3]

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

virtual

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

Reimplemented from MATRIX::VtMatrix.

                                                             {
    VtMatrix::operator+=(rhs);
    return *this;
  }

operator-=() [2/3]

const VtNegMatrix & MATRIX::VtNegMatrix::operator-=

(

const VtMatrix &

rhs

)

                                                                {
    cout << "VtNegMatrix::operator-=(VtMatrix) called" << endl;
    VtMatrix::operator+=(rhs);
    return *this;
  }

operator-=() [3/3]

const VtNegMatrix & MATRIX::VtNegMatrix::operator-=

(

const VtNegMatrix &

rhs

)

                                                                   {
    cout << "VtNegMatrix::operator-=(VtNegMatrix) called" << endl;
    VtMatrix::operator-=(rhs);
    return *this;
  }

operator/=()

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

virtual

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

Reimplemented from MATRIX::VtMatrix.

                                                             {
    VtMatrix::operator/=(rhs);
    return *this;
  }

T()

const VtNegMatrix MATRIX::VtNegMatrix::T

(

void

)

const

return transposed matrix

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

---

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

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