Trk::AlMat Class Reference

#include <AlMat.h>

Collaboration diagram for Trk::AlMat:

Classes
class	AlMat_row
class	AlMat_row_const

Public Member Functions
	AlMat (int N, int M)
	AlMat ()
	AlMat (const AlMat &m)
virtual	~AlMat ()
AlMat_row	operator[] (int)
AlMat_row_const	operator[] (int) const
long int	nrow () const
long int	ncol () const
const std::string	Print (const int NColsPerSet=10)
AlMat &	operator= (const double &)
AlMat &	operator= (const AlMat &m)
AlMat &	operator= (const AlSymMat &m)
AlMat	operator+ (const AlMat &m) const
AlMat &	operator+= (const AlMat &m)
AlMat	operator- (const AlMat &m) const
AlMat &	operator-= (const AlMat &m)
AlMat	operator* (const AlMat &m) const
AlMat	operator* (const AlSymMatBase &m) const
AlVec	operator* (const AlVec &v) const
AlMat &	operator*= (const double &d)
AlMat	T () const
AlMat &	Transpose ()
AlMat &	Normal ()
void	invertS (int &ierr, double Norm)
void	reSize (int Nnew, int Mnew)
StatusCode	ReadScalaPack (const std::string &)
void	SetPathBin (const std::string &)
void	SetPathTxt (const std::string &)
StatusCode	Write (const std::string &, bool, unsigned int precision=6)
double &	elemr (long int, long int)
double	elemc (long int, long int) const
const double *	ptrData () const
double *	ptrData ()
const std::string &	pathBin () const
const std::string &	pathTxt () const

Protected Member Functions
virtual long int	elem (long int, long int) const

Protected Attributes
int	m_ncol
int	m_nrow
int	m_nele
std::string	m_pathbin
std::string	m_pathtxt
double *	m_ptr_data
bool	m_transpose

Private Member Functions
void	copy (const AlMat &m)
void	copy (const AlSymMatBase &m)

Detailed Description

contains the implementation of the methods of class AlMat, for handling general NxM matrices

Definition at line 27 of file AlMat.h.

Constructor & Destructor Documentation

AlMat() [1/3]

Trk::AlMat::AlMat	(	int	N,
		int	M
	)

Definition at line 40 of file AlMat.cxx.

  : m_ncol(M)
  , m_nrow(N)
  , m_nele(N * M)
  , m_pathbin("./")
  , m_pathtxt("./")
  , m_ptr_data(new double[m_nele])
  , m_transpose(false)
{
 
  double*  p = m_ptr_data + m_nele;
  while (p > m_ptr_data) *(--p) = 0.;
}

AlMat() [2/3]

Trk::AlMat::AlMat

(

)

Definition at line 29 of file AlMat.cxx.

  : m_ncol(0)
  , m_nrow(0)
  , m_nele(0)
  , m_pathbin("./")
  , m_pathtxt("./")
  , m_ptr_data(nullptr)
  , m_transpose(false)
{
}

AlMat() [3/3]

Trk::AlMat::AlMat

(

const AlMat &

m

)

Definition at line 54 of file AlMat.cxx.

  : m_ncol(m.ncol())
  , m_nrow(m.nrow())
  , m_nele(m_nrow * m_ncol)
  , m_pathbin(m.m_pathbin)
  , m_pathtxt(m.m_pathtxt)
  , m_ptr_data(new double[m_nele])
  , m_transpose(false)
{
 
  copy(m);
}

~AlMat()

Trk::AlMat::~AlMat ( )

virtual

Definition at line 67 of file AlMat.cxx.

{if( m_ptr_data != nullptr ) delete [] m_ptr_data;}

Member Function Documentation

copy() [1/2]

void Trk::AlMat::copy ( const AlMat &  m )

private

Definition at line 70 of file AlMat.cxx.

                                {
  int  nr = nrow();
  int  nc = ncol();
  if( nr != m.nrow() || nc != m.ncol() ) {
    throw std::range_error( "AlMat::copy: sizes do not match!" );
  }
 
  for( int i=0; i<nr; i++ ) {
    for( int j=0; j<nc; j++ ) {
      elemr(i, j) = m.elemc(i, j);
    }
  }
}

copy() [2/2]

void Trk::AlMat::copy ( const AlSymMatBase &  m )

private

Definition at line 84 of file AlMat.cxx.

                                       {
  long int  n = m.size();
  if( nrow() != n || ncol() != n ) {
    throw std::range_error( "AlMat::copy: sizes do not match!" );
  }
 
  for( int i=0; i<n; i++ ) {
    for( int j=0; j<n; j++ ) {
      *(m_ptr_data+i*m_ncol+j) = m.elemc(i, j);
    }
  }
}

elem()

long int Trk::AlMat::elem ( long int  i, long int  j  ) const

protectedvirtual

Definition at line 121 of file AlMat.cxx.

                                                {
#ifdef _DEBUG
  if( i<0 )     { throw std::out_of_range( "AlMat::elemr: Index 1 < zero! " ); };
  if( i>=size ) { throw std::out_of_range( "AlMat::elemr: Index 1 too large!" ); };
  if( j<0 )     { throw std::out_of_range( "AlMat::elemr: Index 2 < zero! " ); };
  if( j>=size ) { throw std::out_of_range( "AlMat::elemr: Index 2 too large!" );  };
#endif
 
  if( m_transpose )   return  (j*m_ncol+i);
  return  (i*m_ncol+j);
}

elemc()

double Trk::AlMat::elemc	(	long int	i,
		long int	j
	)		const

Definition at line 109 of file AlMat.cxx.

                                               {
#ifdef _DEBUG
  if( i<0 )     { throw std::out_of_range( "AlMat::elemr: Index 1 < zero! " ); };
  if( i>=size ) { throw std::out_of_range( "AlMat::elemr: Index 1 too large!" ); };
  if( j<0 )     { throw std::out_of_range( "AlMat::elemr: Index 2 < zero! " ); };
  if( j>=size ) { throw std::out_of_range( "AlMat::elemr: Index 2 too large!" );  };
#endif
 
  if( m_transpose )   return  *(m_ptr_data+j*m_ncol+i);
  return  *(m_ptr_data+i*m_ncol+j);
}

elemr()

double & Trk::AlMat::elemr	(	long int	i,
		long int	j
	)

Definition at line 97 of file AlMat.cxx.

                                          {
#ifdef _DEBUG
  if( i<0 )     { throw std::out_of_range( "AlMat::elemr: Index 1 < zero! " ); };
  if( i>=size ) { throw std::out_of_range( "AlMat::elemr: Index 1 too large!" ); };
  if( j<0 )     { throw std::out_of_range( "AlMat::elemr: Index 2 < zero! " ); };
  if( j>=size ) { throw std::out_of_range( "AlMat::elemr: Index 2 too large!" );  };
#endif
 
  if( m_transpose )   return  *(m_ptr_data+j*m_ncol+i);
  return  *(m_ptr_data+i*m_ncol+j);
}

invertS()

void Trk::AlMat::invertS	(	int &	ierr,
		double	Norm = 1.
	)

Definition at line 325 of file AlMat.cxx.

                                               {
  if(m_nrow!=m_ncol) {
    throw std::range_error( "AlMat invertS: non-square matrix!" );
  }
 
  AlSymMat b(m_nrow);
  for( int i=0; i<b.size(); i++ ) {
    for( int j=0; j<=i; j++ ) {
      b.elemr(i, j) = elemc(i, j);
    }
  }
 
  b*=Norm;
  ierr = b.invert();
  b*=Norm;
 
  if (ierr==0) (*this).copy(b);
 
}

ncol()

long int Trk::AlMat::ncol ( ) const

inline

Definition at line 162 of file AlMat.h.

                                  {
  if( m_transpose ) return m_nrow;
  return m_ncol;
}

Normal()

AlMat & Trk::AlMat::Normal

(

)

Definition at line 316 of file AlMat.cxx.

                     {
 
  m_transpose = false;
 
  return *this;
}

nrow()

long int Trk::AlMat::nrow ( ) const

inline

Definition at line 157 of file AlMat.h.

                                  {
  if( m_transpose ) return m_ncol;
  return m_nrow;
}

operator*() [1/3]

AlMat Trk::AlMat::operator*

(

const AlMat &

m

)

const

Definition at line 229 of file AlMat.cxx.

                                           {
  if( ncol() != m.nrow() ) 
  {  
    throw std::range_error( "AlMat: operator*: size do not match!" );
  }
 
  int k(nrow());
  int l(m.ncol());
  int f(ncol());
 
  AlMat b( k, l);
  for( int i=0; i<k; i++ ) {
    for( int j=0; j<l; j++ ) {
      for( int n=0; n<f; n++) b.elemr(i, j) += elemc(i, n)*m.elemc(n, j);
    }
  }
  return b;
}

operator*() [2/3]

AlMat Trk::AlMat::operator*

(

const AlSymMatBase &

m

)

const

Definition at line 248 of file AlMat.cxx.

                                                  {
  if( ncol() != m.size()) 
  { 
    throw std::range_error( "AlMat: operator*: size do not match!" ); 
  }
 
  int k(nrow());
  int l(m.size());
 
  AlMat b( k, l);
  for( int i=0; i<k; i++ ) {
    for( int j=0; j<l; j++ ) {
      for( int n=0; n<l; n++) b.elemr(i, j) += elemc(i, n)*m.elemc(n, j);
    }
  }
  return b;
}

operator*() [3/3]

AlVec Trk::AlMat::operator*

(

const AlVec &

v

)

const

Definition at line 267 of file AlMat.cxx.

                                           {
  if( ncol() != v.size() )
  {  
    throw std::range_error( "AlMat: operator*: size do not match! " );
  }
 
  int k(nrow());
  int l(ncol());
  double* p;
  double* q;
 
  AlVec b(k);
  for( int i=0; i<k; i++ ) {
    p = b.ptrData()+i;
    q = m_ptr_data+i*l;
    for( int j=0; j<l; j++ )  *p += (*(q+j))*(*(v.ptrData()+j));
  }
 
  return b;
}

operator*=()

AlMat & Trk::AlMat::operator*=

(

const double &

d

)

Definition at line 288 of file AlMat.cxx.

                                          {
  double*  p = m_ptr_data+m_nele;
  while (p > m_ptr_data)
    *(--p) *= d;
 
  return *this;
}

operator+()

AlMat Trk::AlMat::operator+

(

const AlMat &

m

)

const

Definition at line 170 of file AlMat.cxx.

                                           {
  if( m_nrow != m.m_nrow || m_ncol != m.m_ncol )
  { 
    throw std::range_error( "AlMat: operator+: size do not match!" );
  }
 
  AlMat b( m_nrow, m_ncol );
 
  double*  p = m_ptr_data + m_nele;
  double*  q = m.m_ptr_data + m_nele;
  double*  r = b.m_ptr_data + m_nele;
  while (p > m_ptr_data) *(--r) = (*(--p))+(*(--q));
 
  return b;
}

operator+=()

AlMat & Trk::AlMat::operator+=

(

const AlMat &

m

)

Definition at line 186 of file AlMat.cxx.

                                        {
 
  if( m_nrow != m.m_nrow || m_ncol != m.m_ncol )
  {  
    throw std::range_error( "AlMat: operator+=: size do not match!" ); 
  }
 
  double*  p = m_ptr_data + m_nele;
  double*  q = m.m_ptr_data + m_nele;
  while (p > m_ptr_data) *(--p) += *(--q);
 
  return *this;
}

operator-()

AlMat Trk::AlMat::operator-

(

const AlMat &

m

)

const

Definition at line 200 of file AlMat.cxx.

                                             {
  if( m_nrow != m.m_nrow || m_ncol != m.m_ncol )
  {  
    throw std::range_error( "AlMat: operator-: size do not match!" ); 
  }
 
  AlMat b( m_nrow, m_ncol );
 
  double*  p = m_ptr_data + m_nele;
  double*  q = m.m_ptr_data + m_nele;
  double*  r = b.m_ptr_data + m_nele;
  while (p > m_ptr_data) *(--r) = (*(--p))-(*(--q));
 
  return b;
}

operator-=()

AlMat & Trk::AlMat::operator-=

(

const AlMat &

m

)

Definition at line 216 of file AlMat.cxx.

                                        {
  if( m_nrow != m.m_nrow || m_ncol != m.m_ncol )
  { 
    throw std::range_error( "AlMat: operator-=: size do not match!"); 
  }
 
  double*  p = m_ptr_data + m_nele;
  double*  q = m.m_ptr_data + m_nele;
  while (p > m_ptr_data) *(--p) -= *(--q);
 
  return *this;
}

operator=() [1/3]

AlMat & Trk::AlMat::operator=

(

const AlMat &

m

)

Definition at line 142 of file AlMat.cxx.

                                      {
  if (this==&m) return *this;
 
  if(( m_nrow!=0 || m_ncol!=0) && (m_nrow != m.nrow() || m_ncol != m.ncol() ))
  { 
    throw std::range_error( "AlMat=AlMat Assignment: size do not match!" );
  }
 
  if ( m_ptr_data != m.m_ptr_data ) {
    reSize(m.nrow(), m.ncol());
    copy(m);
  };
  return (*this);
}

operator=() [2/3]

AlMat & Trk::AlMat::operator=

(

const AlSymMat &

m

)

Definition at line 157 of file AlMat.cxx.

                                          {
  if( ( m_nrow!=0 || m_ncol!=0) && (m_nrow != m.size() || m_ncol != m.size() ))
  {
    throw std::range_error( "AlMat=AlSymMatBase Assignment: size do not match!" ); 
  }
 
  if ( m_ptr_data != m.ptrData() ) {
    reSize(m.size(), m.size());
    copy(m);
  }
  return (*this);
}

operator=() [3/3]

AlMat & Trk::AlMat::operator=

(

const double &

d

)

Definition at line 134 of file AlMat.cxx.

                                        {
 
  double*  p = m_ptr_data + m_nele;
  while (p > m_ptr_data) *(--p) = d;
 
  return *this;
}

operator[]() [1/2]

AlMat::AlMat_row Trk::AlMat::operator[] ( int  r )

inline

Definition at line 123 of file AlMat.h.

                                             {
  AlMat_row b(*this,r);
  return b;
}

operator[]() [2/2]

AlMat::AlMat_row_const Trk::AlMat::operator[] ( int  r ) const

inline

Definition at line 128 of file AlMat.h.

                                                         {
  const AlMat_row_const b(*this,r);
  return b;
}

pathBin()

const std::string & Trk::AlMat::pathBin ( ) const

inline

Definition at line 175 of file AlMat.h.

                                             {
  return m_pathbin;
}

pathTxt()

const std::string & Trk::AlMat::pathTxt ( ) const

inline

Definition at line 179 of file AlMat.h.

                                             {
  return m_pathtxt;
}

Print()

const std::string Trk::AlMat::Print

(

const int

NColsPerSet = 10

)

Definition at line 457 of file AlMat.cxx.

{
  std::ostringstream textmatrix;
  int FirstCol = 0;
  int LastCol = NColsPerSet;
 
  int NSets = (ncol()/NColsPerSet);
  if (ncol()%NColsPerSet>0) NSets++;
  textmatrix << std::endl;
  textmatrix << " ++++++++++++++ AlMat ++ "
        << nrow()
        << " x "
        << ncol()
        << " +++++++++++++++++++++++++++++"<< std::endl;
  for (int set=0; set < NSets; set++) {
    FirstCol = set*NColsPerSet;
    LastCol = (set+1)*NColsPerSet;
    if (LastCol>ncol()) LastCol = ncol();
    textmatrix << " |row\\col| ";
    for (int col=FirstCol; col < LastCol; col++) {
      textmatrix << std::setw(6) << col << " | ";
    }
    textmatrix << std::endl;
    textmatrix << " |-------|";
    for (int col=FirstCol; col < LastCol; col++) {
      textmatrix << "--------|";
    }
    textmatrix << std::endl;
    for (int row=0; row<nrow(); row++) {
      textmatrix << " |" << std::setw(6) << row << " | ";
      for (int col=FirstCol; col<LastCol; col++) {
    double melem =  *(m_ptr_data+row*ncol()+col);
    textmatrix << std::setprecision(5) << std:: setw(6) << melem << " | ";
      }
      textmatrix << std::endl;
    }
    if (set != (NSets-1)) textmatrix << std::endl;
  }
  textmatrix << " +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"<< std::endl;
  return textmatrix.str();
}

ptrData() [1/2]

double * Trk::AlMat::ptrData ( )

inline

Definition at line 171 of file AlMat.h.

                              {
  return m_ptr_data;
}

ptrData() [2/2]

const double * Trk::AlMat::ptrData ( ) const

inline

Definition at line 167 of file AlMat.h.

                                          {
  return m_ptr_data;
}

ReadScalaPack()

StatusCode Trk::AlMat::ReadScalaPack

(

const std::string &

filename

)

Definition at line 372 of file AlMat.cxx.

                                                        {
  std::ifstream inmat(filename.c_str(), std::ios::binary);
  if(inmat.fail())
    return StatusCode::FAILURE;
 
  int32_t mNrow = m_nrow;
  inmat.read(charAddress(mNrow), sizeof (mNrow));
  int32_t mNcol = m_ncol;
  inmat.read(charAddress(mNcol), sizeof (mNcol));
 
  m_nrow=std::abs(mNrow);
  m_ncol=std::abs(mNcol);
  m_nele=m_ncol*m_nrow;
  m_transpose = false;
 
 
 
  double melem=0;
  for(int i=0; i<m_nrow; i++) {
    for(int j=0; j<m_ncol; j++) {
      inmat.read(charAddress(melem), sizeof (melem));
      *(m_ptr_data+i*m_ncol+j) = melem;
    }
  }
 
  inmat.close();
  return StatusCode::SUCCESS;
}

reSize()

void Trk::AlMat::reSize	(	int	Nnew,
		int	Mnew
	)

Definition at line 346 of file AlMat.cxx.

                                     {
  if ( Nnew != m_nrow || Mnew != m_ncol ) {
 
    double*  p = m_ptr_data;
    m_nele = Nnew*Mnew;
    m_ptr_data = new double[m_nele];
    int nrow_old = m_nrow;
    int ncol_old = m_ncol;
    m_transpose = false;
 
    m_nrow = Nnew;
    m_ncol = Mnew;
    int k = m_nrow <= nrow_old ? m_nrow : nrow_old;
    int l = m_ncol <= ncol_old ? m_ncol : ncol_old;
 
    for( int i=0; i<k; i++ ) {
      for( int j=0; j<l; j++ ) {
        *(m_ptr_data+i*m_ncol+j) = *(p+i*ncol_old+j);
      }
    }
 
    delete [] p;
  }
}

SetPathBin()

void Trk::AlMat::SetPathBin

(

const std::string &

path

)

Definition at line 402 of file AlMat.cxx.

{
  m_pathbin.assign(path);
}

SetPathTxt()

void Trk::AlMat::SetPathTxt

(

const std::string &

path

)

Definition at line 408 of file AlMat.cxx.

{
  m_pathtxt.assign(path);
}

T()

AlMat Trk::AlMat::T

(

)

const

Definition at line 297 of file AlMat.cxx.

                     {
  AlMat b(m_ncol,m_nrow);
  for( int i=0; i<b.m_nrow; i++ ) {
    for( int j=0; j<b.m_ncol; j++ ) {
      b[i][j]= *(m_ptr_data+j*m_ncol+i);
    }
  }
  return b;
}

Transpose()

AlMat & Trk::AlMat::Transpose

(

)

Definition at line 308 of file AlMat.cxx.

                        {
 
  m_transpose = true;
 
  return *this;
}

Write()

StatusCode Trk::AlMat::Write	(	const std::string &	filename,
		bool	binary,
		unsigned int	precision = 6
	)

Definition at line 414 of file AlMat.cxx.

{
  std::ofstream outmat;
 
  if(binary) {
    outmat.open((m_pathbin+filename).c_str(), std::ios::binary);
    if(outmat.fail())
      return StatusCode::FAILURE;
 
    int32_t mNrow = m_nrow;
    outmat.write(charAddress(mNrow), sizeof (mNrow));
    int32_t mNcol = m_ncol;
    outmat.write(charAddress(mNcol), sizeof (mNcol));
  }
  else {
    outmat.open((m_pathtxt+filename).c_str());
    if(outmat.fail())
      return StatusCode::FAILURE;
    outmat.setf(std::ios::fixed);
    if(precision>0)
      outmat.setf(std::ios::showpoint);
    outmat.precision(precision);
  }
 
  double melem=0;
 
  for( int i=0; i<m_nrow; i++) {
    for( int j=0; j<m_ncol; j++) {
      melem =  *(m_ptr_data+i*m_ncol+j);
      if(binary)
        outmat.write(charAddress(melem), sizeof (melem));
      else
        outmat << " " << std::setw(12) << melem;
    }
    if(!binary)
      outmat << std::endl;
  }
 
  outmat.close();
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_ncol

int Trk::AlMat::m_ncol

protected

Definition at line 109 of file AlMat.h.

m_nele

int Trk::AlMat::m_nele

protected

Definition at line 111 of file AlMat.h.

m_nrow

int Trk::AlMat::m_nrow

protected

Definition at line 110 of file AlMat.h.

m_pathbin

std::string Trk::AlMat::m_pathbin

protected

Definition at line 112 of file AlMat.h.

m_pathtxt

std::string Trk::AlMat::m_pathtxt

protected

Definition at line 113 of file AlMat.h.

m_ptr_data

double* Trk::AlMat::m_ptr_data

protected

Definition at line 114 of file AlMat.h.

m_transpose

bool Trk::AlMat::m_transpose

protected

Definition at line 115 of file AlMat.h.

---

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

• AlMat.h
• AlMat.cxx