QuOc

 

Public Types | Public Member Functions | Protected Member Functions | Protected Attributes

aol::Mat< numRows, numCols, _DataType > Class Template Reference
[Matrix]

#include <smallMat.h>

List of all members.

Public Types

typedef _DataType DataType

Public Member Functions

 Mat ()
 Constructor.
 Mat (const Mat< numRows, numCols, _DataType > &rhs)
 Copy-constructor.
 Mat (const Mat< numRows, numCols, _DataType > &rhs, CopyFlag copyFlag)
 Copy-constructor for structure or data copying.
Mat< numRows, numCols,
_DataType > & 
operator= (const Mat< numRows, numCols, _DataType > &rhs)
 operator=
Vec< numCols, _DataType > & operator[] (const int i)
const Vec< numCols, _DataType > & operator[] (const int i) const
_DataType get (const int I, const int J) const
void set (const int I, const int J, _DataType Value)
_DataType getDiag (const int I)
int getNumCols () const
int getNumRows () const
bool operator== (const Mat< numRows, numCols, _DataType > &other) const
 equality comparison of two Mats
bool operator!= (const Mat< numRows, numCols, _DataType > &other) const
 inequality comparison of two Mats
void add (const int I, const int J, const _DataType Value)
void setZero ()
void setIdentity ()
template<class T >
void setRow (const int Index, const Vec< numCols, T > &Vec)
template<class T >
void getRow (const int Index, Vec< numCols, T > &Dest) const
template<class T >
void getRow (const int Index, Vector< T > &Dest) const
void scaleRow (const int Index, const DataType Factor)
template<class T >
void setCol (const int Index, const Vec< numRows, T > &Vec)
template<class T >
void getCol (const int Index, Vec< numRows, T > &Dest) const
template<class T >
void getCol (const int Index, Vector< T > &Dest) const
template<class T >
void getColumn (const int Index, Vec< numRows, T > &Dest) const
template<class T >
void getColumn (const int Index, Vector< T > &Dest) const
template<class T >
void getSubColumn (int startRow, int col, Vector< T > &dest) const
template<class T , int size>
void getSubColumn (int startRow, int col, Vec< size, T > &dest) const
template<class T >
void getSubRow (int row, int startCol, Vector< T > &dest) const
template<class T , int size>
void getSubRow (int row, int startCol, Vec< size, T > &dest) const
template<class T >
void setSubColumn (int startRow, int col, const Vector< T > &subCol)
template<class T , int size>
void setSubColumn (int startRow, int col, const Vec< size, T > &subCol)
template<class T >
void setSubRow (int row, int startCol, const Vector< T > &subRow)
template<class T , int size>
void setSubRow (int row, int startCol, const Vec< size, T > &subRow)
template<class T , int rowsSubMatrix, int colsSubMatrix>
void getSubMatrix (int startRow, int startCol, Mat< rowsSubMatrix, colsSubMatrix, T > &subMatrix) const
template<class T , int rowsSubMatrix, int colsSubMatrix>
void setSubMatrix (int startRow, int startCol, const Mat< rowsSubMatrix, colsSubMatrix, T > &subMatrix)
template<class T >
void multAdd (const Vec< numCols, T > &Arg, Vec< numRows, T > &Dest) const
void symmetrize ()
 $ A \mapsto \frac{1}{2}(A + A^T) $
bool isExactlyDiagonal () const
template<class T >
void mult (const Vec< numCols, T > &Arg, Vec< numRows, T > &Dest) const
 $ x \mapsto Ax $
template<class T >
void multTransposed (const Vec< numRows, T > &Arg, Vec< numCols, T > &Dest) const
 $ x \mapsto A^Tx $
void elimRowColTo (const int Row, const int Col, Mat< numRows-1, numCols-1, _DataType > &subMat)
Mat< numRows, numCols,
_DataType > & 
operator+= (const Mat< numRows, numCols, _DataType > &Other)
 $ A \mapsto A + B $
Mat< numRows, numCols,
_DataType > & 
operator-= (const Mat< numRows, numCols, _DataType > &Other)
 $ A \mapsto A - B $
_DataType ddprod (const Mat< numRows, numCols, _DataType > &mat) const
 ":"-Product: returns *this : mat
_DataType dotProduct (const Mat< numRows, numCols, _DataType > &mat) const
 Frobenius dot product.
_DataType ddprodT (const Mat< numRows, numCols, _DataType > &mat) const
 ":^T"-Product : returns *this : mat^T
Vec< numRows, _DataType > operator* (const Vec< numCols, _DataType > &vec) const
Vector< _DataType > operator* (const Vector< _DataType > &vec) const
void transpose ()
void transposeFrom (const Mat< numCols, numRows, _DataType > &mat)
void transposeTo (Mat< numCols, numRows, _DataType > &mat) const
Mat< numCols, numRows, _DataType > transposed () const
Mat< numRows, numCols,
_DataType > & 
operator*= (const _DataType Alpha)
 $ A \mapsto \alpha A $
Mat< numRows, numCols,
_DataType > & 
operator/= (const _DataType Alpha)
 $ A \mapsto \alpha^{-1} A $
void makeTensorProduct (const Vec< numRows, _DataType > &A, const Vec< numCols, _DataType > &B)
void makeProjectionMatrix (const Vec< numRows, _DataType > &A)
 $ A = I-(a\otimes a) $
template<class AnotherType , int dimBoth>
void makeProduct (const Mat< numRows, dimBoth, AnotherType > &A, const Mat< dimBoth, numCols, AnotherType > &B)
template<class AnotherType , int dimBoth>
void makeProductAtransposedB (const Mat< dimBoth, numRows, AnotherType > &A, const Mat< dimBoth, numCols, AnotherType > &B)
template<class AnotherType , int dimBoth>
void makeProductABtransposed (const Mat< numRows, dimBoth, AnotherType > &A, const Mat< numCols, dimBoth, AnotherType > &B)
template<class AnotherType , int dimBoth>
void makeSymmetricProduct (const Mat< dimBoth, numRows, AnotherType > &A, const Mat< dimBoth, numCols, AnotherType > &B)
 $ \mbox{*this} \mapsto \frac{1}{2}(A^{T}B + B^{T}A) $
Mat< numRows, numRows, _DataType > daggerProduct (const Mat< numRows, numCols, _DataType > &A) const
Mat< numRows, numRows, _DataType > sharpProduct (const Mat< numRows, numCols, _DataType > &A) const
_DataType normSqr () const
_DataType norm () const
_DataType infinityNorm () const
ostream & print (ostream &out) const
istream & read (istream &in)
void swapRows (const int i, const int j)
 swap two rows
Mat< numRows, numCols,
_DataType > & 
operator*= (const Mat< numCols, numCols, _DataType > &mat)
 operator *=
void leftMult (const Mat< numRows, numRows, _DataType > &mat)
 $ A \mapsto BA $
Mat< numRows, numCols,
_DataType > & 
addMultiple (const Mat< numRows, numRows, _DataType > &mat, const _DataType &alpha)
 $ A \mapsto A + \alpha B $
void makeInverse (const Mat< numRows, numCols, _DataType > &a)

Protected Member Functions

void rowBoundsCheck (const int i, const char *fi, const int li) const

Protected Attributes

Vec< numCols, _DataType > _row [numRows]

Detailed Description

template<int numRows, int numCols, typename _DataType>
class aol::Mat< numRows, numCols, _DataType >

A Matrix of any x- and y- dimension (template-parameters) derived from the vec-class (no use of STL-vectors) (ON)

Definition at line 24 of file smallMat.h.


Member Typedef Documentation

template<int numRows, int numCols, typename _DataType>
typedef _DataType aol::Mat< numRows, numCols, _DataType >::DataType

Constructor & Destructor Documentation

template<int numRows, int numCols, typename _DataType>
aol::Mat< numRows, numCols, _DataType >::Mat (  )  [inline]

Constructor.

Definition at line 32 of file smallMat.h.

        {
    for ( int i = 0; i < numRows; ++i )
      for ( int j = 0; j < numCols; ++j )
        this->_row[i][j] = ZOTrait<_DataType>::zero;
  }

template<int numRows, int numCols, typename _DataType>
aol::Mat< numRows, numCols, _DataType >::Mat ( const Mat< numRows, numCols, _DataType > &  rhs  )  [inline]

Copy-constructor.

Definition at line 39 of file smallMat.h.

                                                      {
    for ( int i = 0; i < numRows; ++i )
      for ( int j = 0; j < numCols; ++j )
        this->_row[i][j] = rhs._row[i][j];
  }

template<int numRows, int numCols, typename _DataType>
aol::Mat< numRows, numCols, _DataType >::Mat ( const Mat< numRows, numCols, _DataType > &  rhs,
CopyFlag  copyFlag 
) [inline]

Copy-constructor for structure or data copying.

Definition at line 46 of file smallMat.h.

                                                                         {
    switch ( copyFlag ) {
      case DEEP_COPY:
        for ( int i = 0; i < numRows; ++i )
          for ( int j = 0; j < numCols; ++j )
            this->_row[i][j] = rhs._row[i][j];
        break;
      case STRUCT_COPY:
        for ( int i = 0; i < numRows; ++i )
          for ( int j = 0; j < numCols; ++j )
            this->_row[i][j] = ZOTrait<DataType>::zero;
        break;
      default:
        string errorMessage = strprintf( "Copying a Mat is not possible with copyFlag=%d", copyFlag );
        throw Exception( errorMessage, __FILE__, __LINE__);
    }
  }


Member Function Documentation

template<int numRows, int numCols, typename _DataType>
void aol::Mat< numRows, numCols, _DataType >::add ( const int  I,
const int  J,
const _DataType  Value 
) [inline]
template<int numRows, int numCols, typename _DataType>
Mat<numRows, numCols, _DataType>& aol::Mat< numRows, numCols, _DataType >::addMultiple ( const Mat< numRows, numRows, _DataType > &  mat,
const _DataType &  alpha 
) [inline]

$ A \mapsto A + \alpha B $

Definition at line 664 of file smallMat.h.

Referenced by qc::HyperelasticSubHessian< ConfiguratorType, HyperelasticEnergyDensityType >::elasticityTensor().

                                                                                                                         {
    if ( static_cast<const void*>(this) == static_cast<const void*>(&mat) ) 
      cerr << "Matrix<_DataType>::addMultiple :  don't add the same matrix!" << endl;
    else {
      for ( int j = 0; j < numCols; ++j ) 
        for ( int i = 0; i < numRows ; ++i ) 
            _row[i][j] += alpha * mat[i][j];
    }
    return *this;
  }

template<int numRows, int numCols, typename _DataType>
Mat<numRows, numRows, _DataType> aol::Mat< numRows, numCols, _DataType >::daggerProduct ( const Mat< numRows, numCols, _DataType > &  A  )  const [inline]

dagger product: returns *this dagger A with M dagger A = (M M^T)^-1 M A^T

Definition at line 535 of file smallMat.h.

  {
    Mat<numRows, numRows, _DataType> MMT;
    MMT.makeProductABtransposed(*this, *this);
    Mat<numRows, numRows, _DataType> MMTinv;
    MMTinv.makeInverse(MMT);

    // abuse MMT for *this * A^T
    MMT.makeProductABtransposed(*this, A);

    Mat<numRows, numRows, _DataType> erg;
    erg.makeProduct(MMTinv, MMT);
    return erg;
  }

template<int numRows, int numCols, typename _DataType>
_DataType aol::Mat< numRows, numCols, _DataType >::ddprod ( const Mat< numRows, numCols, _DataType > &  mat  )  const [inline]

":"-Product: returns *this : mat

Definition at line 367 of file smallMat.h.

Referenced by aol::Mat< Dim, Dim+1, RealType >::dotProduct().

                                                                         {
    _DataType result = 0;
    for ( int i = 0; i < numRows; ++i ) {
      for ( int j = 0; j < numCols; ++j ) {
        result += this->_row[i][j] * mat._row[i][j];
      }
    }
    return result;
  }

template<int numRows, int numCols, typename _DataType>
_DataType aol::Mat< numRows, numCols, _DataType >::ddprodT ( const Mat< numRows, numCols, _DataType > &  mat  )  const [inline]

":^T"-Product : returns *this : mat^T

Definition at line 383 of file smallMat.h.

                                                                          {
    _DataType result = 0;
    for ( int i = 0; i < numRows; ++i ) {
      for ( int j = 0; j < numCols; ++j ) {
        result += this->_row[i][j] * mat._row[j][i];
      }
    }
    return result;
  }

template<int numRows, int numCols, typename _DataType>
_DataType aol::Mat< numRows, numCols, _DataType >::dotProduct ( const Mat< numRows, numCols, _DataType > &  mat  )  const [inline]

Frobenius dot product.

Definition at line 378 of file smallMat.h.

                                                                             {
    return this->ddprod( mat );
  }

template<int numRows, int numCols, typename _DataType>
void aol::Mat< numRows, numCols, _DataType >::elimRowColTo ( const int  Row,
const int  Col,
Mat< numRows-1, numCols-1, _DataType > &  subMat 
) [inline]

Definition at line 327 of file smallMat.h.

                                                                                                          {
    for ( int row = 0; row < Row; ++row ) {
      for ( int col = 0; col < Col; ++col ) { 
        subMat[row][col] = ( *this ) [row][col];
      }
      for ( int col = Col; col < numCols - 1; ++col ) {
        subMat[row][col] = ( *this ) [row][col+1];
      }
    }
    for ( int row = Row; row < numRows - 1; ++row ) {
      for ( int col = 0; col < Col; ++col ) { 
        subMat[row][col] = ( *this ) [row+1][col];
      }
      for ( int col = Col; col < numCols - 1; ++col ) {
        subMat[row][col] = ( *this ) [row+1][col+1];
      }
    }
  }

template<int numRows, int numCols, typename _DataType>
_DataType aol::Mat< numRows, numCols, _DataType >::get ( const int  I,
const int  J 
) const [inline]
template<int numRows, int numCols, typename _DataType>
template<class T >
void aol::Mat< numRows, numCols, _DataType >::getCol ( const int  Index,
Vec< numRows, T > &  Dest 
) const [inline]
template<int numRows, int numCols, typename _DataType>
template<class T >
void aol::Mat< numRows, numCols, _DataType >::getCol ( const int  Index,
Vector< T > &  Dest 
) const [inline]

Definition at line 193 of file smallMat.h.

                                                         {
    for ( int j = 0; j < numRows; ++j )
      Dest[j] = static_cast<T> ( this->_row[j][Index] );
  }

template<int numRows, int numCols, typename _DataType>
template<class T >
void aol::Mat< numRows, numCols, _DataType >::getColumn ( const int  Index,
Vec< numRows, T > &  Dest 
) const [inline]

Definition at line 199 of file smallMat.h.

                                                                  {
    getCol(Index, Dest);
  }

template<int numRows, int numCols, typename _DataType>
template<class T >
void aol::Mat< numRows, numCols, _DataType >::getColumn ( const int  Index,
Vector< T > &  Dest 
) const [inline]

Definition at line 204 of file smallMat.h.

                                                            {
    getCol(Index, Dest);
  }

template<int numRows, int numCols, typename _DataType>
_DataType aol::Mat< numRows, numCols, _DataType >::getDiag ( const int  I  )  [inline]

Definition at line 101 of file smallMat.h.

                                    {
#ifdef BOUNDS_CHECK
    rowBoundsCheck ( I, __FILE__, __LINE__ );
#endif
    return get(I, I);
  }

template<int numRows, int numCols, typename _DataType>
int aol::Mat< numRows, numCols, _DataType >::getNumCols (  )  const [inline]

Definition at line 108 of file smallMat.h.

{ return numCols; }

template<int numRows, int numCols, typename _DataType>
int aol::Mat< numRows, numCols, _DataType >::getNumRows (  )  const [inline]

Definition at line 109 of file smallMat.h.

{ return numRows; }

template<int numRows, int numCols, typename _DataType>
template<class T >
void aol::Mat< numRows, numCols, _DataType >::getRow ( const int  Index,
Vector< T > &  Dest 
) const [inline]

Definition at line 164 of file smallMat.h.

                                                         {
#ifdef BOUNDS_CHECK
    rowBoundsCheck ( Index, __FILE__, __LINE__ );
#endif
    for ( int j = 0; j < numCols; ++j )
      Dest[j] = static_cast<T> ( this->_row[Index][j] );
  }

template<int numRows, int numCols, typename _DataType>
template<class T >
void aol::Mat< numRows, numCols, _DataType >::getRow ( const int  Index,
Vec< numCols, T > &  Dest 
) const [inline]

Definition at line 155 of file smallMat.h.

                                                               {
#ifdef BOUNDS_CHECK
    rowBoundsCheck ( Index, __FILE__, __LINE__ );
#endif
    for ( int j = 0; j < numCols; ++j )
      Dest[j] = static_cast<T> ( this->_row[Index][j] );
  }

template<int numRows, int numCols, typename _DataType>
template<class T >
void aol::Mat< numRows, numCols, _DataType >::getSubColumn ( int  startRow,
int  col,
Vector< T > &  dest 
) const [inline]

Definition at line 209 of file smallMat.h.

                                                                     {
    QUOC_ASSERT(startRow + dest.size() <= numRows);
    for (int i = 0; i < dest.size(); ++i)
      dest[i] = (*this)[startRow + i][col];
  }

template<int numRows, int numCols, typename _DataType>
template<class T , int size>
void aol::Mat< numRows, numCols, _DataType >::getSubColumn ( int  startRow,
int  col,
Vec< size, T > &  dest 
) const [inline]

Definition at line 216 of file smallMat.h.

                                                                        {
    QUOC_ASSERT(startRow + size <= numRows);
    for (int i = 0; i < size; ++i)
      dest[i] = (*this)[startRow + i][col];
  }

template<int numRows, int numCols, typename _DataType>
template<class T , int rowsSubMatrix, int colsSubMatrix>
void aol::Mat< numRows, numCols, _DataType >::getSubMatrix ( int  startRow,
int  startCol,
Mat< rowsSubMatrix, colsSubMatrix, T > &  subMatrix 
) const [inline]

Definition at line 265 of file smallMat.h.

Referenced by qc::RigidDisplacementProjectionGradient< ConfiguratorType >::applyAdd(), qc::AffineDisplacementProjectionGradient< ConfiguratorType >::applyAdd(), and qc::AffineDisplacementProjectionEnergy< ConfiguratorType >::applyAdd().

                                                                                                        {
    QUOC_ASSERT(startRow + rowsSubMatrix <= numRows);
    QUOC_ASSERT(startCol + colsSubMatrix <= numCols);
    for (int i = 0; i < rowsSubMatrix; ++i)
      for (int j = 0; j < colsSubMatrix; ++j)
        subMatrix[i][j] = (*this)[startRow + i][startCol + j];
  }

template<int numRows, int numCols, typename _DataType>
template<class T >
void aol::Mat< numRows, numCols, _DataType >::getSubRow ( int  row,
int  startCol,
Vector< T > &  dest 
) const [inline]

Definition at line 223 of file smallMat.h.

                                                                  {
    QUOC_ASSERT(startCol + dest.size() <= numCols);
    for (int i = 0; i < dest.size(); ++i)
      dest[i] = (*this)[row][startCol + i];
  }

template<int numRows, int numCols, typename _DataType>
template<class T , int size>
void aol::Mat< numRows, numCols, _DataType >::getSubRow ( int  row,
int  startCol,
Vec< size, T > &  dest 
) const [inline]

Definition at line 230 of file smallMat.h.

                                                                     {
    QUOC_ASSERT(startCol + size <= numCols);
    for (int i = 0; i < size; ++i)
      dest[i] = (*this)[row][startCol + i];
  }

template<int numRows, int numCols, typename _DataType>
_DataType aol::Mat< numRows, numCols, _DataType >::infinityNorm (  )  const [inline]

Definition at line 584 of file smallMat.h.

                                 {
    _DataType res = 0;
    for ( int i = 0; i < numRows; ++i ) {
      _DataType temp = 0;
      for ( int j = 0; j < numCols; ++j ) {
        temp += Abs ( this->_row[i][j] );
      }
      if ( temp > res ) res = temp;
    }
    return ( res );
  }

template<int numRows, int numCols, typename _DataType>
bool aol::Mat< numRows, numCols, _DataType >::isExactlyDiagonal (  )  const [inline]

Definition at line 299 of file smallMat.h.

                                  {
    bool ret = true;
    for ( int i = 0; i < numRows; ++i )
      for ( int j = 0; j < numCols; ++j )
        if ( i != j && this->_row[i][j] != ZOTrait<_DataType>::zero )
          ret = false;
    return ret;
  }

template<int numRows, int numCols, typename _DataType>
void aol::Mat< numRows, numCols, _DataType >::leftMult ( const Mat< numRows, numRows, _DataType > &  mat  )  [inline]

$ A \mapsto BA $

Definition at line 645 of file smallMat.h.

                                                                {
    if ( static_cast<const void*>(this) == static_cast<const void*>(&mat) ) 
      cerr << "Matrix<_DataType>::leftMult :  don't multiply with the same matrix!" << endl;
    else {
      aol::Vec<numRows, _DataType> vec;
      for ( int j = 0; j < numCols; ++j ) {
        // save j-th column in vec
        for ( int k = 0; k < numRows; ++k )
          vec[k] = _row[k][j];
        for ( int i = 0; i < numRows ; ++i ) {
          _row[i][j] = 0;
          for ( int k = 0; k < numRows; ++k ) 
            _row[i][j] += mat[i][k] * vec[k];
        }
      }
    }
  }

template<int numRows, int numCols, typename _DataType>
void aol::Mat< numRows, numCols, _DataType >::makeInverse ( const Mat< numRows, numCols, _DataType > &  a  )  [inline]

computes the inverse of the given argument matrix and stores it into this matrix. This method uses the Gauss-Jacobi Algorithm and throws an exception if the matrix is not invertible

Definition at line 680 of file smallMat.h.

Referenced by aol::Mat< Dim, Dim+1, RealType >::daggerProduct(), qc::TransformFunction< RealType, qc::QC_2D >::getLocalPreImage(), om::TriMeshWithGeomProps< RealType, TriMeshWithEdgeNormals< RealType > >::getShapeOperator(), om::TriMeshWithEdgeNormals< RealType >::getShapeOperatorFast(), and aol::Mat< Dim, Dim+1, RealType >::sharpProduct().

                                                                 {
    if ( numCols != numRows ) {
      throw aol::Exception ( "Mat<...>::makeInverse works only for quadratic matrices", __FILE__, __LINE__ );
    }

    const int N = numCols;
    int  indxc[numCols], indxr[numCols], ipiv[numCols] = { 0 };
    int  i, icol = 0, irow = 0, j, k, l, ll;
    _DataType big, dum, pivinv;

    ( *this ) = a;

    for ( i = 0; i < N; ++i ) {
      big = 0.0;
      for ( j = 0; j < N; ++j )
        if ( ipiv[j] != 1 ) {
          for ( k = 0; k < N; ++k ) {
            if ( ipiv[k] == 0 ) {
              if ( fabs ( this->_row[j][k] ) >= big ) {
                big = fabs ( this->_row[j][k] );
                irow = j;
                icol = k;
              }
            } else
              if ( ipiv[k] > 1 ) throw aol::Exception ( "Mat<...>::makeInverse: Singular Matrix-1", __FILE__, __LINE__ );
          }
        }
      ++ ( ipiv[icol] );
      if ( irow != icol ) {
        for ( l = 0; l < N; ++l ) std::swap ( this->_row[irow][l], this->_row[icol][l] );
      }
      indxr[i] = irow;
      indxc[i] = icol;
      if ( this->_row[icol][icol] == 0.0 ) throw aol::Exception ( "Mat<...>::makeInverse: Singular Matrix-2", __FILE__, __LINE__ );
      pivinv = aol::NumberTrait<_DataType>::one / this->_row[icol][icol];
      this->_row[icol][icol] = 1.0;

      for ( l = 0; l < N; ++l ) this->_row[icol][l] *= pivinv;
      for ( ll = 0; ll < N; ++ll )
        if ( ll != icol ) {
          dum = this->_row[ll][icol];
          this->_row[ll][icol] = 0.0;
          for ( l = 0; l < N; ++l ) this->_row[ll][l] -= this->_row[icol][l] * dum;
        }
    }
    for ( l = N - 1; l >= 0; l-- ) {
      if ( indxr[l] != indxc[l] )
        for ( k = 0; k < N; ++k )
          std::swap ( this->_row[k][indxr[l]], this->_row[k][indxc[l]] );
    }
  }

template<int numRows, int numCols, typename _DataType>
template<class AnotherType , int dimBoth>
void aol::Mat< numRows, numCols, _DataType >::makeProduct ( const Mat< numRows, dimBoth, AnotherType > &  A,
const Mat< dimBoth, numCols, AnotherType > &  B 
) [inline]
template<int numRows, int numCols, typename _DataType>
template<class AnotherType , int dimBoth>
void aol::Mat< numRows, numCols, _DataType >::makeProductABtransposed ( const Mat< numRows, dimBoth, AnotherType > &  A,
const Mat< numCols, dimBoth, AnotherType > &  B 
) [inline]

Definition at line 506 of file smallMat.h.

Referenced by aol::Mat< Dim, Dim+1, RealType >::daggerProduct(), and aol::Mat< Dim, Dim+1, RealType >::sharpProduct().

                                                                               {
    setZero( );
    for ( int i = 0; i < numRows; ++i ) {
      for ( int j = 0; j < numCols; ++j ) {
        for ( int k = 0; k < dimBoth; ++k ) {
          this->_row[i][j] += static_cast<_DataType> ( A[i][k] * B[j][k] );
        }
      }
    }
  }

template<int numRows, int numCols, typename _DataType>
template<class AnotherType , int dimBoth>
void aol::Mat< numRows, numCols, _DataType >::makeProductAtransposedB ( const Mat< dimBoth, numRows, AnotherType > &  A,
const Mat< dimBoth, numCols, AnotherType > &  B 
) [inline]

Definition at line 493 of file smallMat.h.

Referenced by tpcfe::CFEJCEMassOp< _ConfiguratorType >::CFEJCEMassOp(), om::TriMesh< _RealType >::getFirstFundForm(), qc::HyperelasticPrePostDeformGradientPreComp< ConfiguratorType, HyperelasticEnergyDensityType >::getNonlinearity(), and aol::Mat< Dim, Dim+1, RealType >::makeSymmetricProduct().

                                                                               {
    setZero( );
    for ( int i = 0; i < numRows; ++i ) {
      for ( int j = 0; j < numCols; ++j ) {
        for ( int k = 0; k < dimBoth; ++k ) {
          this->_row[i][j] += static_cast<_DataType> ( A[k][i] * B[k][j] );
        }
      }
    }
  }

template<int numRows, int numCols, typename _DataType>
void aol::Mat< numRows, numCols, _DataType >::makeProjectionMatrix ( const Vec< numRows, _DataType > &  A  )  [inline]

$ A = I-(a\otimes a) $

Definition at line 460 of file smallMat.h.

                                                                 {
#ifdef BOUNDS_CHECK
  if( numRows != numCols )
    throw aol::Exception( "makeProjectionMatrix needs numRows == numCols!", __FILE__, __LINE__ );
#endif
    for ( int i = 0; i < numRows; ++i ){
      this->_row[i][i] = aol::ZOTrait<_DataType>::one - aol::Sqr( A[i] );

      for( int j = i+1; j < numCols; ++j){
        this->_row[i][j] = - A[i] * A[j];
      }

      for( int j = 0; j < i; ++j){
        this->_row[i][j] = this->_row[j][i];
      }
    }
  }

template<int numRows, int numCols, typename _DataType>
template<class AnotherType , int dimBoth>
void aol::Mat< numRows, numCols, _DataType >::makeSymmetricProduct ( const Mat< dimBoth, numRows, AnotherType > &  A,
const Mat< dimBoth, numCols, AnotherType > &  B 
) [inline]

$ \mbox{*this} \mapsto \frac{1}{2}(A^{T}B + B^{T}A) $

Definition at line 520 of file smallMat.h.

Referenced by om::TriMeshWithVertexNormals< RealType >::getSecondFundForm().

                                                                               {
    if ( numCols != numRows ) {
      throw aol::Exception ( "Mat<...>::makeSymmetricProduct works only for quadratic matrices", __FILE__, __LINE__ );
    }
    setZero( );
    Mat<numRows, numCols, _DataType> aux;
    aux.makeProductAtransposedB( A, B );
    makeProductAtransposedB( B, A );
    (*this)+=aux;
    (*this)*=.5; 
  }

template<int numRows, int numCols, typename _DataType>
void aol::Mat< numRows, numCols, _DataType >::makeTensorProduct ( const Vec< numRows, _DataType > &  A,
const Vec< numCols, _DataType > &  B 
) [inline]
template<int numRows, int numCols, typename _DataType>
template<class T >
void aol::Mat< numRows, numCols, _DataType >::mult ( const Vec< numCols, T > &  Arg,
Vec< numRows, T > &  Dest 
) const [inline]
template<int numRows, int numCols, typename _DataType>
template<class T >
void aol::Mat< numRows, numCols, _DataType >::multAdd ( const Vec< numCols, T > &  Arg,
Vec< numRows, T > &  Dest 
) const [inline]

Definition at line 283 of file smallMat.h.

Referenced by aol::Mat< Dim, Dim+1, RealType >::mult().

                                                                           {
    for ( int i = 0; i < numRows; ++i ) {
      for ( int j = 0; j < numCols; ++j )
        Dest[i] += this->_row[i][j] * Arg.get ( j );
    }
  }

template<int numRows, int numCols, typename _DataType>
template<class T >
void aol::Mat< numRows, numCols, _DataType >::multTransposed ( const Vec< numRows, T > &  Arg,
Vec< numCols, T > &  Dest 
) const [inline]

$ x \mapsto A^Tx $

Definition at line 319 of file smallMat.h.

                                                                                  {
    Dest.setZero();
    for ( int i = 0; i < numCols; ++i ) {
      for ( int j = 0; j < numRows; ++j )
        Dest[i] += this->_row[j][i] * Arg.get ( j );
    }
  }

template<int numRows, int numCols, typename _DataType>
_DataType aol::Mat< numRows, numCols, _DataType >::norm (  )  const [inline]

Frobenius norm.

Author:
Wirth

Definition at line 580 of file smallMat.h.

                         {
    return sqrt( this->normSqr() );
  }

template<int numRows, int numCols, typename _DataType>
_DataType aol::Mat< numRows, numCols, _DataType >::normSqr (  )  const [inline]

Definition at line 567 of file smallMat.h.

Referenced by aol::Mat< Dim, Dim+1, RealType >::norm().

                            {
    _DataType res = 0;
    for ( int i = 0; i < numRows; ++i ) {
      res += this->_row[i].normSqr();
    }
    return res;
  }

template<int numRows, int numCols, typename _DataType>
bool aol::Mat< numRows, numCols, _DataType >::operator!= ( const Mat< numRows, numCols, _DataType > &  other  )  const [inline]

inequality comparison of two Mats

Definition at line 121 of file smallMat.h.

                                                                          {
    return ( ! ( *this == other ) );
  }

template<int numRows, int numCols, typename _DataType>
Vec<numRows, _DataType> aol::Mat< numRows, numCols, _DataType >::operator* ( const Vec< numCols, _DataType > &  vec  )  const [inline]

Definition at line 393 of file smallMat.h.

                                                                                  {
    Vec<numRows, _DataType> Res;
    for ( int i = 0; i < numRows; ++i )
      for ( int j = 0; j < numCols; ++j )
        Res[i] += this->_row[i][j] * vec[j];

    return Res;
  }

template<int numRows, int numCols, typename _DataType>
Vector<_DataType> aol::Mat< numRows, numCols, _DataType >::operator* ( const Vector< _DataType > &  vec  )  const [inline]

Definition at line 402 of file smallMat.h.

                                                                      {
    Vector<_DataType> Res(numRows);
    for ( int i = 0; i < numRows; ++i )
      for ( int j = 0; j < numCols; ++j )
        Res[i] += this->_row[i][j] * vec[j];

    return Res;
  }

template<int numRows, int numCols, typename _DataType>
Mat<numRows, numCols, _DataType>& aol::Mat< numRows, numCols, _DataType >::operator*= ( const Mat< numCols, numCols, _DataType > &  mat  )  [inline]

operator *=

Definition at line 621 of file smallMat.h.

                                                                                               {
    if ( static_cast<const void*>(this) == static_cast<const void*>(&mat) ) {
      cerr << "Matrix<_DataType>::operator*= :  don't multiply with the same matrix!" << endl;
    } else {
      aol::Vec<numCols, _DataType> vec;
      int i, j, k ;
      _DataType val;
      for ( i = 0; i < numRows ; ++i ) {
        vec = _row[i];

        for ( j = 0; j < numCols ; ++j ) {
          val = 0;
          for ( k = 0; k < numCols; ++k ) {
            // Note: vec[k] is a copy of this->_row[i][k]
            val += mat[k][j] * vec[k];
          }
          _row[i][j] = val;
        }
      }
    }
    return *this;
  }

template<int numRows, int numCols, typename _DataType>
Mat<numRows, numCols, _DataType>& aol::Mat< numRows, numCols, _DataType >::operator*= ( const _DataType  Alpha  )  [inline]

$ A \mapsto \alpha A $

Definition at line 440 of file smallMat.h.

                                                                         {
    for ( int i = 0; i < numRows; ++i )
      this->_row[i] *= Alpha;
    return *this;
  }

template<int numRows, int numCols, typename _DataType>
Mat<numRows, numCols, _DataType>& aol::Mat< numRows, numCols, _DataType >::operator+= ( const Mat< numRows, numCols, _DataType > &  Other  )  [inline]

$ A \mapsto A + B $

Definition at line 347 of file smallMat.h.

                                                                                                 {
    for ( int i = 0; i < numRows; ++i ) {
      for ( int j = 0; j < numCols; ++j ) {
        this->_row[i][j] += Other._row[i][j];
      }
    }
    return *this;
  }

template<int numRows, int numCols, typename _DataType>
Mat<numRows, numCols, _DataType>& aol::Mat< numRows, numCols, _DataType >::operator-= ( const Mat< numRows, numCols, _DataType > &  Other  )  [inline]

$ A \mapsto A - B $

Definition at line 357 of file smallMat.h.

                                                                                                 {
    for ( int i = 0; i < numRows; ++i ) {
      for ( int j = 0; j < numCols; ++j ) {
        this->_row[i][j] -= Other._row[i][j];
      }
    }
    return *this;
  }

template<int numRows, int numCols, typename _DataType>
Mat<numRows, numCols, _DataType>& aol::Mat< numRows, numCols, _DataType >::operator/= ( const _DataType  Alpha  )  [inline]

$ A \mapsto \alpha^{-1} A $

Definition at line 447 of file smallMat.h.

                                                                         {
    for ( int i = 0; i < numRows; ++i )
      this->_row[i] /= Alpha;
    return *this;
  }

template<int numRows, int numCols, typename _DataType>
Mat<numRows, numCols, _DataType>& aol::Mat< numRows, numCols, _DataType >::operator= ( const Mat< numRows, numCols, _DataType > &  rhs  )  [inline]

operator=

Definition at line 67 of file smallMat.h.

                                                                                              {
    for ( int i = 0; i < numRows; ++i )
      for ( int j = 0; j < numCols; ++j )
        this->_row[i][j] = rhs._row[i][j];
    return *this;
  }

template<int numRows, int numCols, typename _DataType>
bool aol::Mat< numRows, numCols, _DataType >::operator== ( const Mat< numRows, numCols, _DataType > &  other  )  const [inline]

equality comparison of two Mats

Definition at line 112 of file smallMat.h.

                                                                          {
    bool ret = true;
    for ( int i = 0; i < numRows; ++i )
      for ( int j = 0; j < numCols; ++j )
        ret &= (*this)[i][j] == other[i][j];
    return ( ret );
  }

template<int numRows, int numCols, typename _DataType>
Vec<numCols, _DataType>& aol::Mat< numRows, numCols, _DataType >::operator[] ( const int  i  )  [inline]

Definition at line 74 of file smallMat.h.

                                                                    {
#ifdef BOUNDS_CHECK
    rowBoundsCheck ( i, __FILE__, __LINE__ );
#endif
    return this->_row[i];
  }

template<int numRows, int numCols, typename _DataType>
const Vec<numCols, _DataType>& aol::Mat< numRows, numCols, _DataType >::operator[] ( const int  i  )  const [inline]

Definition at line 81 of file smallMat.h.

                                                                    {
#ifdef BOUNDS_CHECK
    rowBoundsCheck ( i, __FILE__, __LINE__ );
#endif
    return this->_row[i];
  }

template<int numRows, int numCols, typename _DataType>
ostream& aol::Mat< numRows, numCols, _DataType >::print ( ostream &  out  )  const [inline]

Definition at line 597 of file smallMat.h.

                                        {
    for ( int i = 0; i < numRows - 1; ++i )
      out << this->_row[i] << endl;
    out << this->_row[numRows-1];
    return ( out );
  }

template<int numRows, int numCols, typename _DataType>
istream& aol::Mat< numRows, numCols, _DataType >::read ( istream &  in  )  [inline]

Definition at line 604 of file smallMat.h.

Referenced by aol::operator>>().

                                {
    for ( int i = 0; i < numRows; ++i )
      in >> this->_row [i];
    return in;
  }

template<int numRows, int numCols, typename _DataType>
void aol::Mat< numRows, numCols, _DataType >::rowBoundsCheck ( const int  i,
const char fi,
const int  li 
) const [inline, protected]
template<int numRows, int numCols, typename _DataType>
void aol::Mat< numRows, numCols, _DataType >::scaleRow ( const int  Index,
const DataType  Factor 
) [inline]

Definition at line 172 of file smallMat.h.

                                                           { 
#ifdef BOUNDS_CHECK
    rowBoundsCheck ( Index, __FILE__, __LINE__ );
#endif
    for ( int j = 0; j < numCols; ++j )
      this->_row[Index][j] *= Factor;
  }

template<int numRows, int numCols, typename _DataType>
void aol::Mat< numRows, numCols, _DataType >::set ( const int  I,
const int  J,
_DataType  Value 
) [inline]
template<int numRows, int numCols, typename _DataType>
template<class T >
void aol::Mat< numRows, numCols, _DataType >::setCol ( const int  Index,
const Vec< numRows, T > &  Vec 
) [inline]

Definition at line 181 of file smallMat.h.

Referenced by om::TriangleBase< RealType, TriMesh< RealType > >::barToCartCoord(), tpcfe::determineElementAndTetraForWC(), and om::TriangleBase< RealType, TriMesh< RealType > >::getDx().

                                                              {
    for ( int j = 0; j < numRows; ++j )
      this->_row[j][Index] = static_cast<T> ( Vec.get ( j ) );
  }

template<int numRows, int numCols, typename _DataType>
void aol::Mat< numRows, numCols, _DataType >::setIdentity (  )  [inline]
template<int numRows, int numCols, typename _DataType>
template<class T >
void aol::Mat< numRows, numCols, _DataType >::setRow ( const int  Index,
const Vec< numCols, T > &  Vec 
) [inline]
template<int numRows, int numCols, typename _DataType>
template<class T , int size>
void aol::Mat< numRows, numCols, _DataType >::setSubColumn ( int  startRow,
int  col,
const Vec< size, T > &  subCol 
) [inline]

Definition at line 244 of file smallMat.h.

                                                                          {
    QUOC_ASSERT(startRow + size <= numRows);
    for (int i = 0; i < size; ++i)
      (*this)[startRow + i][col] = subCol[i];
  }

template<int numRows, int numCols, typename _DataType>
template<class T >
void aol::Mat< numRows, numCols, _DataType >::setSubColumn ( int  startRow,
int  col,
const Vector< T > &  subCol 
) [inline]

Definition at line 237 of file smallMat.h.

                                                                       {
    QUOC_ASSERT(startRow + subCol.size() <= numRows);
    for (int i = 0; i < subCol.size(); ++i)
      (*this)[startRow + i][col] = subCol[i];
  }

template<int numRows, int numCols, typename _DataType>
template<class T , int rowsSubMatrix, int colsSubMatrix>
void aol::Mat< numRows, numCols, _DataType >::setSubMatrix ( int  startRow,
int  startCol,
const Mat< rowsSubMatrix, colsSubMatrix, T > &  subMatrix 
) [inline]

Definition at line 274 of file smallMat.h.

Referenced by qc::RigidDisplacementProjectionGradient< ConfiguratorType >::applyAdd(), qc::RigidDisplacementProjectionEnergy< ConfiguratorType >::applyAdd(), and qc::meanZeroShiftAndRotationProjector< ConfiguratorType >::momentMatrixNonlinear().

                                                                                                        {
    QUOC_ASSERT(startRow + rowsSubMatrix <= numRows);
    QUOC_ASSERT(startCol + colsSubMatrix <= numCols);
    for (int i = 0; i < rowsSubMatrix; ++i)
      for (int j = 0; j < colsSubMatrix; ++j)
        (*this)[startRow + i][startCol + j] = subMatrix[i][j];
  }

template<int numRows, int numCols, typename _DataType>
template<class T >
void aol::Mat< numRows, numCols, _DataType >::setSubRow ( int  row,
int  startCol,
const Vector< T > &  subRow 
) [inline]

Definition at line 251 of file smallMat.h.

                                                                    {
    QUOC_ASSERT(startCol + subRow.size() <= numCols);
    for (int i = 0; i < subRow.size(); ++i)
      (*this)[row][startCol + i] = subRow[i];
  }

template<int numRows, int numCols, typename _DataType>
template<class T , int size>
void aol::Mat< numRows, numCols, _DataType >::setSubRow ( int  row,
int  startCol,
const Vec< size, T > &  subRow 
) [inline]

Definition at line 258 of file smallMat.h.

                                                                       {
    QUOC_ASSERT(startCol + size <= numCols);
    for (int i = 0; i < size; ++i)
      (*this)[row][startCol + i] = subRow[i];
  }

template<int numRows, int numCols, typename _DataType>
void aol::Mat< numRows, numCols, _DataType >::setZero (  )  [inline]

Definition at line 133 of file smallMat.h.

Referenced by aol::Tensor2222< RealType >::apply(), aol::ChanVeseEnergyParameterDerivativeInterface< ConfiguratorType, HeavisideFunctionType, NumberOfLevelsetFunctions, 1, MultiLevelsetVolumes< ConfiguratorType, HeavisideFunctionType, NumberOfLevelsetFunctions > >::applyAdd(), tpcfe::VoigtElasticityCoefficient< RealType >::averageFromAnisotropicTensor(), tpcfe::CFEStandardOp< _ConfiguratorType, CFEStiffOpWI< _ConfiguratorType > >::buildHexaMatrix(), tpcfe::CFEInterfaceTriangulationWithVonMisesStressGenerator< tpcfe::CFEGrid< _RealType, tpcfe::CFE_TPOSELAST, tpcfe::IsotropicElasticityCoefficient< _RealType > > >::computeStress(), qc::HyperelasticSubHessian< ConfiguratorType, HyperelasticEnergyDensityType >::elasticityTensor(), qc::HyperelasticGradient< ConfiguratorType, HyperelasticEnergyDensityType >::firstPiolaKirchhoffStress(), om::TriMeshWithVertexNormals< RealType >::getDn(), om::TriMesh< _RealType >::getDx(), qc::VariationOfSymmetricLengthEnergy< ConfiguratorType >::getNonlinearity(), qc::VolumeGradient< ConfiguratorType, Dim >::getNonlinearity(), qc::LinearBlendedAnisotropy2dGraph< ConfiguratorType, AnisoType1, AnisoType2 >::implicitPart(), aol::Mat< Dim, Dim+1, RealType >::makeProduct(), aol::Mat< Dim, Dim+1, RealType >::makeProductABtransposed(), aol::Mat< Dim, Dim+1, RealType >::makeProductAtransposedB(), aol::Mat< Dim, Dim+1, RealType >::makeSymmetricProduct(), qc::FELinBoundaryScalarWeightedMassInterface< ConfiguratorType, FELinBoundaryMassOp< ConfiguratorType, IteratorType >, IteratorType >::prepareLocalMatrix(), aol::FELinScalarWeightedMixedDiffInterface< ConfiguratorType, FEOpMixedDerivative< ConfiguratorType > >::prepareLocalMatrix(), aol::Mat< Dim, Dim+1, RealType >::setIdentity(), and aol::Mat< Dim, Dim+1, RealType >::setZero().

                  {
    for ( int i = 0; i < numRows; ++i )
      this->_row[i].setZero();
  }

template<int numRows, int numCols, typename _DataType>
Mat<numRows, numRows, _DataType> aol::Mat< numRows, numCols, _DataType >::sharpProduct ( const Mat< numRows, numCols, _DataType > &  A  )  const [inline]

sharp product: returns *this sharp A with M sharp A = (M M^T)^-1 A M^T

Definition at line 552 of file smallMat.h.

  {
    Mat<numRows, numRows, _DataType> MMT;
    MMT.makeProductABtransposed(*this, *this);
    Mat<numRows, numRows, _DataType> MMTinv;
    MMTinv.makeInverse(MMT);

    // abuse MMT for *this * A^T
    MMT.makeProductABtransposed(A, *this);

    Mat<numRows, numRows, _DataType> erg;
    erg.makeProduct(MMTinv, MMT);
    return erg;
  }

template<int numRows, int numCols, typename _DataType>
void aol::Mat< numRows, numCols, _DataType >::swapRows ( const int  i,
const int  j 
) [inline]

swap two rows

Definition at line 611 of file smallMat.h.

                                             {
    _DataType tmp;
    for ( int l = 0; l < numCols; ++l ) {
      tmp = this->_row[i][l];
      this->_row[i][l] = this->_row[j][l];
      this->_row[j][l] = tmp;
    }
  }

template<int numRows, int numCols, typename _DataType>
void aol::Mat< numRows, numCols, _DataType >::symmetrize (  )  [inline]

$ A \mapsto \frac{1}{2}(A + A^T) $

Definition at line 291 of file smallMat.h.

                      {
    if( numRows != numCols )
      throw aol::Exception( "symmetrize needs numRows == numCols!", __FILE__, __LINE__ );
    for ( int i = 1; i < numRows; ++i )
      for ( int j = 0; j < i; ++j )
        (*this) [i][j] = (*this) [j][i] = 0.5 * ( (*this) [i][j] + (*this) [j][i] );
  }

template<int numRows, int numCols, typename _DataType>
void aol::Mat< numRows, numCols, _DataType >::transpose (  )  [inline]

Writes the transpose of this to itself. See the other transpose* methods for the naming convention of data im/export

Reimplemented in aol::Matrix33< _DataType >, and aol::Matrix33< RealType >.

Definition at line 413 of file smallMat.h.

Referenced by qc::LinearTransformedAnisotropy2d< RealType, AnisoType >::LinearTransformedAnisotropy2d(), and aol::Intersector< AlignedCube< RealType >, Triangle< RealType > >::segments_intersect().

                    {
    inplaceTranspose ( *this );
  }

template<int numRows, int numCols, typename _DataType>
Mat<numCols, numRows, _DataType> aol::Mat< numRows, numCols, _DataType >::transposed (  )  const [inline]
template<int numRows, int numCols, typename _DataType>
void aol::Mat< numRows, numCols, _DataType >::transposeFrom ( const Mat< numCols, numRows, _DataType > &  mat  )  [inline]

Definition at line 419 of file smallMat.h.

Referenced by qc::HyperelasticSubHessian< ConfiguratorType, HyperelasticEnergyDensityType >::elasticityTensor().

                                                                     {
    for ( int i = 0; i < numRows; ++i )
      for ( int j = 0; j < numCols; ++j )
        (*this)[i][j] = mat[j][i];
  }

template<int numRows, int numCols, typename _DataType>
void aol::Mat< numRows, numCols, _DataType >::transposeTo ( Mat< numCols, numRows, _DataType > &  mat  )  const [inline]

Definition at line 426 of file smallMat.h.

Referenced by aol::Mat< Dim, Dim+1, RealType >::transposed().

                                                                   {
    for ( int i = 0; i < numCols; ++i )
      for ( int j = 0; j < numRows; ++j )
        mat[i][j] = (*this)[j][i];
  }


Member Data Documentation

template<int numRows, int numCols, typename _DataType>
Vec<numCols, _DataType> aol::Mat< numRows, numCols, _DataType >::_row[numRows] [protected]

Definition at line 26 of file smallMat.h.

Referenced by aol::Mat< Dim, Dim+1, RealType >::add(), aol::Mat< Dim, Dim+1, RealType >::addMultiple(), aol::Mat< Dim, Dim+1, RealType >::ddprod(), aol::Mat< Dim, Dim+1, RealType >::ddprodT(), aol::Mat< Dim, Dim+1, RealType >::get(), aol::Mat< Dim, Dim+1, RealType >::getCol(), aol::Mat< Dim, Dim+1, RealType >::getRow(), aol::Mat< Dim, Dim+1, RealType >::infinityNorm(), aol::Mat< Dim, Dim+1, RealType >::isExactlyDiagonal(), aol::Mat< Dim, Dim+1, RealType >::leftMult(), aol::Mat< Dim, Dim+1, RealType >::makeInverse(), aol::Mat< Dim, Dim+1, RealType >::makeProduct(), aol::Mat< Dim, Dim+1, RealType >::makeProductABtransposed(), aol::Mat< Dim, Dim+1, RealType >::makeProductAtransposedB(), aol::Mat< Dim, Dim+1, RealType >::makeProjectionMatrix(), aol::Mat< Dim, Dim+1, RealType >::makeTensorProduct(), aol::Mat< Dim, Dim+1, RealType >::Mat(), aol::Mat< Dim, Dim+1, RealType >::multAdd(), aol::Mat< Dim, Dim+1, RealType >::multTransposed(), aol::Mat< Dim, Dim+1, RealType >::normSqr(), aol::Mat< Dim, Dim+1, RealType >::operator*(), aol::Mat< Dim, Dim+1, RealType >::operator*=(), aol::Mat< Dim, Dim+1, RealType >::operator+=(), aol::Mat< Dim, Dim+1, RealType >::operator-=(), aol::Mat< Dim, Dim+1, RealType >::operator/=(), aol::Mat< Dim, Dim+1, RealType >::operator=(), aol::Mat< Dim, Dim+1, RealType >::operator[](), aol::Mat< Dim, Dim+1, RealType >::print(), aol::Mat< Dim, Dim+1, RealType >::read(), aol::Mat< Dim, Dim+1, RealType >::scaleRow(), aol::Mat< Dim, Dim+1, RealType >::set(), aol::Mat< Dim, Dim+1, RealType >::setCol(), aol::Mat< Dim, Dim+1, RealType >::setRow(), aol::Mat< Dim, Dim+1, RealType >::setZero(), and aol::Mat< Dim, Dim+1, RealType >::swapRows().


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

Generated on Fri Sep 9 2011 21:09:15 for QuocMesh by doxygen 1.7.1