All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines
Public Member Functions | Protected Attributes
QGpCoreTools::MatrixData< T > Class Template Reference

Brief description of class still missing. More...

#include <MatrixData.h>

List of all members.

Public Member Functions

T & at (int row, int col)
const T & at (int row, int col) const
int columnCount () const
void copyAt (int row, int col, const MatrixData< T > &m)
const T * data () const
T * data ()
void fill (const T &v)
bool fromString (const StringSection &s)
void identity ()
 MatrixData ()
 MatrixData (const MatrixData< T > &m)
void mergeColumn (const MatrixData< T > &col1, const MatrixData< T > &col2)
void mergeRow (const MatrixData< T > &row1, const MatrixData< T > &row2)
int nextNullRow (int startRow) const
Matrix< T > operator* (const MatrixData< T > &m) const
Matrix< T > operator+ (const MatrixData< T > &m) const
Matrix< T > operator- (const MatrixData< T > &m) const
void operator= (const MatrixData< T > &m)
bool operator== (const MatrixData< T > &m) const
void resize (int ndim)
void resize (int nrow, int ncol)
int rowCount () const
Matrix< T > sortedColumns (const PermutationVector &p)
Matrix< T > sortedRows (const PermutationVector &p)
Matrix< T > subMatrix (int rowStart, int colStart, int rowEnd, int colEnd) const
void swapRowColumn ()
QString toString () const
QString toUserString (int precision=6, char format='g') const
Matrix< T > transposed () const
T * values ()
const T * values () const
void zero ()
 ~MatrixData ()

Protected Attributes

int _ncol
int _nrow
T * _values

Detailed Description

template<typename T>
class QGpCoreTools::MatrixData< T >

Brief description of class still missing.

Full description of class still missing

Constructor & Destructor Documentation

template<typename T >
QGpCoreTools::MatrixData< T >::MatrixData ( ) [inline]

References QGpCoreTools::MatrixData< T >::_ncol, QGpCoreTools::MatrixData< T >::_nrow, and QGpCoreTools::MatrixData< T >::_values.

   : QSharedData()
{
  _nrow=0;
  _ncol=0;
  _values=0;
}
template<typename T >
QGpCoreTools::MatrixData< T >::MatrixData ( const MatrixData< T > &  m) [inline]

References QGpCoreTools::MatrixData< T >::_ncol, QGpCoreTools::MatrixData< T >::_nrow, QGpCoreTools::MatrixData< T >::_values, and QGpCoreTools::MatrixData< T >::resize().

   : QSharedData()
{
  _values=0;
  resize(m._nrow, m._ncol);
  memcpy(_values, m._values, sizeof(T)*_nrow * _ncol);
}
template<typename T >
QGpCoreTools::MatrixData< T >::~MatrixData ( ) [inline] 
{
  delete [] _values;
}

Member Function Documentation

template<typename T >
T & QGpCoreTools::MatrixData< T >::at ( int  row,
int  col 
) [inline] 
{
  ASSERT(row>=0 && row<_nrow);
  ASSERT(col>=0 && col<_ncol);
  return _values[col*_nrow+row];
}
template<typename T >
const T & QGpCoreTools::MatrixData< T >::at ( int  row,
int  col 
) const [inline] 
{
  ASSERT(row>=0 && row<_nrow);
  ASSERT(col>=0 && col<_ncol);
  return _values[col*_nrow+row];
}
template<typename T>
int QGpCoreTools::MatrixData< T >::columnCount ( ) const [inline]

References QGpCoreTools::MatrixData< T >::_ncol.

Referenced by QGpCoreTools::MatrixData< T >::copyAt().

{return _ncol;}
template<typename T >
void QGpCoreTools::MatrixData< T >::copyAt ( int  row,
int  col,
const MatrixData< T > &  m 
)

References QGpCoreTools::MatrixData< T >::_values, QGpCoreTools::MatrixData< T >::columnCount(), and QGpCoreTools::MatrixData< T >::rowCount().

{
  ASSERT(row>=0 && row+m.rowCount()<=rowCount());
  ASSERT(col>=0 && col+m.columnCount()<=columnCount());
  int mrow=m.rowCount();
  int length=sizeof(T)*mrow;
  T * values=m._values;
  T * lastValue=values+mrow*m.columnCount();
  T * thisValues=_values+row+col*_nrow;
  while(values<lastValue) {
    memcpy(thisValues, values, length);
    values+=mrow;
    thisValues+=_nrow;
  }
}
template<typename T>
const T* QGpCoreTools::MatrixData< T >::data ( ) const [inline]

References QGpCoreTools::MatrixData< T >::_values.

{return _values;}
template<typename T>
T* QGpCoreTools::MatrixData< T >::data ( ) [inline]

References QGpCoreTools::MatrixData< T >::_values.

{return _values;}
template<typename T >
void QGpCoreTools::MatrixData< T >::fill ( const T &  v) 
{
  for(int i=_nrow*_ncol-1; i>=0; i--) {
    _values[i]=v;
  }
}
template<typename T >
bool QGpCoreTools::MatrixData< T >::fromString ( const StringSection &  s)

References QGpCoreTools::StringSection::nextNumber().

{
  const QChar * ptr=0;
  int n=_nrow*_ncol;
  for(int i=0; i<n; i++) {
    if(!s.nextNumber(_values[i], ptr)) {
      return false;
    }
  }
  return true;
}
template<typename T >
void QGpCoreTools::MatrixData< T >::identity ( ) [inline] 
{
  zero();
  int offset=_ncol + 1;
  int n=_nrow * _ncol;
  for(int i=0; i<n;i+=offset) _values[i]=1.0;
}
template<typename T >
void QGpCoreTools::MatrixData< T >::mergeColumn ( const MatrixData< T > &  col1,
const MatrixData< T > &  col2 
)

References QGpCoreTools::MatrixData< T >::_ncol, QGpCoreTools::MatrixData< T >::_nrow, and QGpCoreTools::MatrixData< T >::_values.

{
  ASSERT(col1._nrow==col2._nrow);
  resize(col1._nrow, col1._ncol+col2._ncol);
  int offset=_nrow*col1._ncol;
  memcpy(_values, col1._values, sizeof(T)*offset);
  memcpy(_values+offset, col2._values, sizeof(T)*_nrow*col2._ncol);
}
template<typename T >
void QGpCoreTools::MatrixData< T >::mergeRow ( const MatrixData< T > &  row1,
const MatrixData< T > &  row2 
)

References QGpCoreTools::MatrixData< T >::_ncol, QGpCoreTools::MatrixData< T >::_nrow, and QGpCoreTools::MatrixData< T >::_values.

{
  ASSERT(row1._ncol==row2._ncol);
  resize(row1._nrow+row2._nrow, row1._ncol);
  int length1=sizeof(T)*row1._nrow;
  int length2=sizeof(T)*row2._nrow;
  T * values=_values;
  T * lastValue=_values+_nrow*_ncol;
  T * row1Values=row1._values;
  T * row2Values=row2._values;
  while(values<lastValue) {
    memcpy(values, row1Values, length1);
    values+=row1._nrow;
    row1Values+=row1._nrow;
    memcpy(values, row2Values, length2);
    values+=row2._nrow;
    row2Values+=row2._nrow;
  }
}
template<typename T >
int QGpCoreTools::MatrixData< T >::nextNullRow ( int  startRow) const 
{
  for(int ir=startRow; ir<_nrow; ir++) {
    int ic=0;
    for(; ic<_ncol; ic++) {
      if(_values[ic*_nrow+ir]!=0.0) {
        break;
      }
    }
    if(ic==_ncol) {
      return ir;
    }
  }
  return -1;
}
template<typename T >
Matrix< T > QGpCoreTools::MatrixData< T >::operator* ( const MatrixData< T > &  m) const

References QGpCoreTools::Matrix< T >::_d, QGpCoreTools::MatrixData< T >::_ncol, QGpCoreTools::MatrixData< T >::_nrow, QGpCoreTools::MatrixData< T >::_values, QGpCoreTools::MatrixMultiply::begin(), QGpCoreTools::AbstractNumericalCache::end(), QGpCoreTools::MatrixMultiply::IndexMap::factor1Index(), QGpCoreTools::MatrixMultiply::IndexMap::factor2Index(), QGpCoreTools::MatrixMultiply::indexCount(), QGpCoreTools::MatrixMultiply::indexMap(), QGpCoreTools::MatrixMultiply::isValid(), QGpCoreTools::MatrixMultiply::IndexMap::resultIndex(), and QGpCoreTools::Matrix< T >::zero().

  {
    ASSERT(_ncol==m._nrow);
    Matrix<T> r(_nrow, m._ncol);
    r.zero();
    T * rValues=r._d->_values;
    const T * thisValues=_values;
    const T * mValues=m._values;
    if(MatrixMultiply::isValid(_nrow, _ncol, m._ncol)) {
      const MatrixMultiply& multiplier=*MatrixMultiply::begin(_nrow, _ncol, m._ncol);
      int n=multiplier.indexCount();
      for(int i=0;i<n;i++) {
        const MatrixMultiply::IndexMap& index=multiplier.indexMap(i);
        rValues[index.resultIndex()]+=thisValues[index.factor1Index()]*mValues[index.factor2Index()];
      }
      MatrixMultiply::end(&multiplier);
    } else {
      // Slower method because cache would be too big for matrix>256*256
      for(int i=0; i<_nrow; i++) {
        for(int j=0; j<m._ncol; j++) {
          int resultIndex=i+j*_nrow;
          int mIndex=j*_ncol;
          for(int k=0; k<_ncol; k++) {
            rValues[resultIndex]+=thisValues[i+k*_nrow]*mValues[k+mIndex];
          }
        }
      }
    }
    return r;
  }
template<typename T >
Matrix< T > QGpCoreTools::MatrixData< T >::operator+ ( const MatrixData< T > &  m) const

References QGpCoreTools::Matrix< T >::_d, QGpCoreTools::MatrixData< T >::_ncol, QGpCoreTools::MatrixData< T >::_nrow, and QGpCoreTools::MatrixData< T >::_values.

  {
    ASSERT(_nrow==m._nrow && _ncol==m._ncol);
    Matrix<T> r(_nrow, _ncol);
    T * rValues=r._d->values();
    for(int i=_nrow*_ncol-1; i>=0; i--) {
      rValues[i]=_values[i]+m._values[i];
    }
    return r;
  }
template<typename T >
Matrix< T > QGpCoreTools::MatrixData< T >::operator- ( const MatrixData< T > &  m) const

References QGpCoreTools::Matrix< T >::_d, QGpCoreTools::MatrixData< T >::_ncol, QGpCoreTools::MatrixData< T >::_nrow, and QGpCoreTools::MatrixData< T >::_values.

  {
    ASSERT(_nrow==m._nrow && _ncol==m._ncol);
    Matrix<T> r(_nrow, _ncol);
    T * rValues=r._d->values();
    for(int i=_nrow*_ncol-1; i>=0; i--) {
      rValues[i]=_values[i]-m._values[i];
    }
    return r;
  }
template<typename T >
void QGpCoreTools::MatrixData< T >::operator= ( const MatrixData< T > &  m) [inline]

References QGpCoreTools::MatrixData< T >::_ncol, QGpCoreTools::MatrixData< T >::_nrow, and QGpCoreTools::MatrixData< T >::_values.

{
  resize(m._nrow, m._ncol);
  memcpy(_values, m._values, sizeof(T)*_nrow * _ncol);
}
template<typename T >
bool QGpCoreTools::MatrixData< T >::operator== ( const MatrixData< T > &  m) const [inline]

References QGpCoreTools::MatrixData< T >::_ncol, QGpCoreTools::MatrixData< T >::_nrow, and QGpCoreTools::MatrixData< T >::_values.

{
  if(_nrow!=m._nrow || _ncol!=m._ncol) return false;
  for(int i=_nrow * _ncol-1; i>=0;i--) {
    if(_values[i]!=m._values[i]) return false;
  }
  return true;
}
template<typename T>
void QGpCoreTools::MatrixData< T >::resize ( int  ndim) [inline]

References QGpCoreTools::MatrixData< T >::resize().

Referenced by QGpCoreTools::Matrix< Complex >::Matrix(), QGpCoreTools::MatrixData< T >::MatrixData(), and QGpCoreTools::MatrixData< T >::resize().

{resize(ndim, ndim);}
template<typename T >
void QGpCoreTools::MatrixData< T >::resize ( int  nrow,
int  ncol 
) [inline] 
{
  ASSERT(nrow>0 && ncol>0);
  _nrow=nrow;
  _ncol=ncol;
  delete [] _values;
  _values=new T[_nrow*_ncol];
}
template<typename T>
int QGpCoreTools::MatrixData< T >::rowCount ( ) const [inline]

References QGpCoreTools::MatrixData< T >::_nrow.

Referenced by QGpCoreTools::MatrixData< T >::copyAt().

{return _nrow;}
template<typename T >
Matrix< T > QGpCoreTools::MatrixData< T >::sortedColumns ( const PermutationVector &  p)

References QGpCoreTools::Matrix< T >::_d, and QGpCoreTools::PermutationVector::newIndex().

  {
    Matrix<T> m(_nrow, _ncol);
    T * values=m._d->_values;
    for(int i=0; i<_ncol; i++) {
      memcpy(values+p.newIndex(i)*_nrow, _values+i*_nrow, sizeof(T)*_nrow);
    }
    return m;
  }
template<typename T >
Matrix< T > QGpCoreTools::MatrixData< T >::sortedRows ( const PermutationVector &  p)

References QGpCoreTools::Matrix< T >::_d, and QGpCoreTools::PermutationVector::newIndex().

  {
    Matrix<T> m(_nrow, _ncol);
    for(int i=0; i<_ncol; i++) {
      int offset=i*_nrow;
      T * values=m._d->_values+offset;
      T * thisValues=_values+offset;
      for(int j=0; j<_nrow; j++) {
        values[p.newIndex(j)]=thisValues[j];
      }
    }
    return m;
  }
template<typename T >
Matrix< T > QGpCoreTools::MatrixData< T >::subMatrix ( int  rowStart,
int  colStart,
int  rowEnd,
int  colEnd 
) const

References QGpCoreTools::Matrix< T >::_d.

  {
    ASSERT(rowStart>=0 && rowStart<=rowEnd && rowEnd<_nrow);
    ASSERT(colStart>=0 && colStart<=colEnd && colEnd<_ncol);
    int mnrow=rowEnd-rowStart+1;
    int mncol=colEnd-colStart+1;
    Matrix<T> m(mnrow, mncol);
    int length=sizeof(T)*mnrow;
    T * values=m._d->_values;
    T * lastValue=values+mnrow*mncol;
    T * thisValues=_values+rowStart+colStart*_nrow;
    while(values<lastValue) {
      memcpy(values, thisValues, length);
      values+=mnrow;
      thisValues+=_nrow;
    }
    return m;
  }
template<typename T >
void QGpCoreTools::MatrixData< T >::swapRowColumn ( ) [inline] 
{
  qSwap(_nrow, _ncol);
}
template<typename T >
QString QGpCoreTools::MatrixData< T >::toString ( ) const

References str, and QGpCoreTools::Number::toString().

{
  QString str;
  int n=_nrow*_ncol;
  for(int i=0; i<n; i++) {
    str+=Number::toString(_values[i], 20);
    str+=" ";
  }
  return str;
}
template<typename T >
QString QGpCoreTools::MatrixData< T >::toUserString ( int  precision = 6,
char  format = 'g' 
) const

References str, and QGpCoreTools::Number::toDouble().

{
  QString str("    | ");
  for(int j=0; j<_ncol; j++) {
    str+=QString(" %1 |").arg(j, 12, 10, QChar(' '));
  }
  str+="\n----|-";
  for(int j=0; j<_ncol; j++) {
    str+="--------------|";
  }
  str+="\n";
  for(int i=0; i<_nrow; i++) {
    str+=QString("%1 | ").arg(i, 3, 10, QChar(' '));
    for(int j=0; j<_ncol; j++) {
      str+=QString(" %1 |").arg(Number::toDouble(at(i, j)), 12, format, precision, QChar(' '));
    }
    str+="\n";
  }
  str+="----|-";
  for(int j=0; j<_ncol; j++) {
    str+="--------------|";
  }
  str+="\n";
  return str;
}
template<typename T >
Matrix< T > QGpCoreTools::MatrixData< T >::transposed ( ) const

References QGpCoreTools::Matrix< T >::_d.

  {
    Matrix<T> t(_ncol, _nrow);
    T * pt=t._d->_values;
    for(int i=0; i<_nrow; i++) {
      for(int j=0; j<_ncol; j++) {
        (*pt++)=_values[j*_nrow+i];
      }
    }
    return t;
  }
template<typename T>
T* QGpCoreTools::MatrixData< T >::values ( ) [inline]

References QGpCoreTools::MatrixData< T >::_values.

{return _values;}
template<typename T>
const T* QGpCoreTools::MatrixData< T >::values ( ) const [inline]

References QGpCoreTools::MatrixData< T >::_values.

{return _values;}
template<typename T >
void QGpCoreTools::MatrixData< T >::zero ( ) [inline] 
{
  memset(_values, 0, sizeof(T)*_nrow*_ncol);
}

Member Data Documentation

template<typename T>
int QGpCoreTools::MatrixData< T >::_ncol [protected]

Referenced by QGpCoreTools::MatrixData< T >::columnCount(), QGpCoreTools::MatrixData< T >::MatrixData(), QGpCoreTools::MatrixData< T >::mergeColumn(), QGpCoreTools::MatrixData< T >::mergeRow(), QGpCoreTools::MatrixData< T >::operator*(), QGpCoreTools::MatrixData< T >::operator+(), QGpCoreTools::MatrixData< T >::operator-(), QGpCoreTools::MatrixData< T >::operator=(), and QGpCoreTools::MatrixData< T >::operator==().

template<typename T>
int QGpCoreTools::MatrixData< T >::_nrow [protected]

Referenced by QGpCoreTools::MatrixData< T >::MatrixData(), QGpCoreTools::MatrixData< T >::mergeColumn(), QGpCoreTools::MatrixData< T >::mergeRow(), QGpCoreTools::MatrixData< T >::operator*(), QGpCoreTools::MatrixData< T >::operator+(), QGpCoreTools::MatrixData< T >::operator-(), QGpCoreTools::MatrixData< T >::operator=(), QGpCoreTools::MatrixData< T >::operator==(), and QGpCoreTools::MatrixData< T >::rowCount().

template<typename T>
T* QGpCoreTools::MatrixData< T >::_values [protected]

Referenced by QGpCoreTools::MatrixData< T >::copyAt(), QGpCoreTools::MatrixData< T >::data(), QGpCoreTools::MatrixData< T >::MatrixData(), QGpCoreTools::MatrixData< T >::mergeColumn(), QGpCoreTools::MatrixData< T >::mergeRow(), QGpCoreTools::MatrixData< T >::operator*(), QGpCoreTools::MatrixData< T >::operator+(), QGpCoreTools::MatrixData< T >::operator-(), QGpCoreTools::MatrixData< T >::operator=(), QGpCoreTools::MatrixData< T >::operator==(), and QGpCoreTools::MatrixData< T >::values().

The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Defines

Modified 2013-10-22

Valid CSS! Valid XHTML 1.0!