libMesh::DenseMatrix< T > Class Template Reference

Defines a dense matrix for use in Finite Element-type computations. More...

#include <dof_map.h>

Inheritance diagram for libMesh::DenseMatrix< T >:

Public Member Functions
	DenseMatrix (const unsigned int new_m=0, const unsigned int new_n=0)
	Constructor. More...
	DenseMatrix (DenseMatrix &&)=default
	The 5 special functions can be defaulted for this class, as it does not manage any memory itself. More...
	DenseMatrix (const DenseMatrix &)=default
DenseMatrix &	operator= (const DenseMatrix &)=default
DenseMatrix &	operator= (DenseMatrix &&)=default
virtual	~DenseMatrix ()=default
virtual void	zero () override
	Set every element in the matrix to 0. More...
T	operator() (const unsigned int i, const unsigned int j) const
T &	operator() (const unsigned int i, const unsigned int j)
virtual T	el (const unsigned int i, const unsigned int j) const override
virtual T &	el (const unsigned int i, const unsigned int j) override
virtual void	left_multiply (const DenseMatrixBase< T > &M2) override
	Performs the operation: (*this) <- M2 * (*this) More...
template<typename T2 >
void	left_multiply (const DenseMatrixBase< T2 > &M2)
	Left multiplies by the matrix M2 of different type. More...
virtual void	right_multiply (const DenseMatrixBase< T > &M2) override
	Performs the operation: (*this) <- (*this) * M3. More...
template<typename T2 >
void	right_multiply (const DenseMatrixBase< T2 > &M2)
	Right multiplies by the matrix M2 of different type. More...
void	vector_mult (DenseVector< T > &dest, const DenseVector< T > &arg) const
	Performs the matrix-vector multiplication, dest := (*this) * arg. More...
template<typename T2 >
void	vector_mult (DenseVector< typename CompareTypes< T, T2 >::supertype > &dest, const DenseVector< T2 > &arg) const
	Performs the matrix-vector multiplication, dest := (*this) * arg on mixed types. More...
void	vector_mult_transpose (DenseVector< T > &dest, const DenseVector< T > &arg) const
	Performs the matrix-vector multiplication, dest := (*this)^T * arg. More...
template<typename T2 >
void	vector_mult_transpose (DenseVector< typename CompareTypes< T, T2 >::supertype > &dest, const DenseVector< T2 > &arg) const
	Performs the matrix-vector multiplication, dest := (*this)^T * arg. More...
void	vector_mult_add (DenseVector< T > &dest, const T factor, const DenseVector< T > &arg) const
	Performs the scaled matrix-vector multiplication, dest += factor * (*this) * arg. More...
template<typename T2 , typename T3 >
void	vector_mult_add (DenseVector< typename CompareTypes< T, typename CompareTypes< T2, T3 >::supertype >::supertype > &dest, const T2 factor, const DenseVector< T3 > &arg) const
	Performs the scaled matrix-vector multiplication, dest += factor * (*this) * arg. More...
void	get_principal_submatrix (unsigned int sub_m, unsigned int sub_n, DenseMatrix< T > &dest) const
	Put the sub_m x sub_n principal submatrix into dest. More...
void	get_principal_submatrix (unsigned int sub_m, DenseMatrix< T > &dest) const
	Put the sub_m x sub_m principal submatrix into dest. More...
void	outer_product (const DenseVector< T > &a, const DenseVector< T > &b)
	Computes the outer (dyadic) product of two vectors and stores in (*this). More...
template<typename T2 >
DenseMatrix< T > &	operator= (const DenseMatrix< T2 > &other_matrix)
	Assignment-from-other-matrix-type operator. More...
void	swap (DenseMatrix< T > &other_matrix)
	STL-like swap method. More...
void	resize (const unsigned int new_m, const unsigned int new_n)
	Resize the matrix. More...
void	scale (const T factor)
	Multiplies every element in the matrix by factor. More...
void	scale_column (const unsigned int col, const T factor)
	Multiplies every element in the column col matrix by factor. More...
DenseMatrix< T > &	operator*= (const T factor)
	Multiplies every element in the matrix by factor. More...
template<typename T2 , typename T3 >
boostcopy::enable_if_c< ScalarTraits< T2 >::value, void >::type	add (const T2 factor, const DenseMatrix< T3 > &mat)
	Adds factor times mat to this matrix. More...
bool	operator== (const DenseMatrix< T > &mat) const
bool	operator!= (const DenseMatrix< T > &mat) const
DenseMatrix< T > &	operator+= (const DenseMatrix< T > &mat)
	Adds mat to this matrix. More...
DenseMatrix< T > &	operator-= (const DenseMatrix< T > &mat)
	Subtracts mat from this matrix. More...
Real	min () const
Real	max () const
Real	l1_norm () const
Real	linfty_norm () const
void	left_multiply_transpose (const DenseMatrix< T > &A)
	Left multiplies by the transpose of the matrix A. More...
template<typename T2 >
void	left_multiply_transpose (const DenseMatrix< T2 > &A)
	Left multiplies by the transpose of the matrix A which contains a different numerical type. More...
void	right_multiply_transpose (const DenseMatrix< T > &A)
	Right multiplies by the transpose of the matrix A. More...
template<typename T2 >
void	right_multiply_transpose (const DenseMatrix< T2 > &A)
	Right multiplies by the transpose of the matrix A which contains a different numerical type. More...
T	transpose (const unsigned int i, const unsigned int j) const
void	get_transpose (DenseMatrix< T > &dest) const
	Put the tranposed matrix into dest. More...
std::vector< T > &	get_values ()
const std::vector< T > &	get_values () const
void	condense (const unsigned int i, const unsigned int j, const T val, DenseVector< T > &rhs)
	Condense-out the (i,j) entry of the matrix, forcing it to take on the value val. More...
void	lu_solve (const DenseVector< T > &b, DenseVector< T > &x)
	Solve the system Ax=b given the input vector b. More...
template<typename T2 >
void	cholesky_solve (const DenseVector< T2 > &b, DenseVector< T2 > &x)
	For symmetric positive definite (SPD) matrices. More...
void	svd (DenseVector< Real > &sigma)
	Compute the singular value decomposition of the matrix. More...
void	svd (DenseVector< Real > &sigma, DenseMatrix< Number > &U, DenseMatrix< Number > &VT)
	Compute the "reduced" singular value decomposition of the matrix. More...
void	svd_solve (const DenseVector< T > &rhs, DenseVector< T > &x, Real rcond=std::numeric_limits< Real >::epsilon()) const
	Solve the system of equations for in the least-squares sense. More...
void	evd (DenseVector< T > &lambda_real, DenseVector< T > &lambda_imag)
	Compute the eigenvalues (both real and imaginary parts) of a general matrix. More...
void	evd_left (DenseVector< T > &lambda_real, DenseVector< T > &lambda_imag, DenseMatrix< T > &VL)
	Compute the eigenvalues (both real and imaginary parts) and left eigenvectors of a general matrix, . More...
void	evd_right (DenseVector< T > &lambda_real, DenseVector< T > &lambda_imag, DenseMatrix< T > &VR)
	Compute the eigenvalues (both real and imaginary parts) and right eigenvectors of a general matrix, . More...
void	evd_left_and_right (DenseVector< T > &lambda_real, DenseVector< T > &lambda_imag, DenseMatrix< T > &VL, DenseMatrix< T > &VR)
	Compute the eigenvalues (both real and imaginary parts) as well as the left and right eigenvectors of a general matrix. More...
T	det ()
unsigned int	m () const
unsigned int	n () const
void	print (std::ostream &os=libMesh::out) const
	Pretty-print the matrix, by default to libMesh::out. More...
void	print_scientific (std::ostream &os, unsigned precision=8) const
	Prints the matrix entries with more decimal places in scientific notation. More...
template<typename T2 , typename T3 >
boostcopy::enable_if_c< ScalarTraits< T2 >::value, void >::type	add (const T2 factor, const DenseMatrixBase< T3 > &mat)
	Adds factor to every element in the matrix. More...

Public Attributes
bool	use_blas_lapack
	Computes the inverse of the dense matrix (assuming it is invertible) by first computing the LU decomposition and then performing multiple back substitution steps. More...

Protected Member Functions
void	condense (const unsigned int i, const unsigned int j, const T val, DenseVectorBase< T > &rhs)
	Condense-out the (i,j) entry of the matrix, forcing it to take on the value val. More...

Static Protected Member Functions
static void	multiply (DenseMatrixBase< T > &M1, const DenseMatrixBase< T > &M2, const DenseMatrixBase< T > &M3)
	Helper function - Performs the computation M1 = M2 * M3 where: M1 = (m x n) M2 = (m x p) M3 = (p x n) More...

Protected Attributes
unsigned int	_m
	The row dimension. More...
unsigned int	_n
	The column dimension. More...

Private Types
enum	DecompositionType { LU =0, CHOLESKY =1, LU_BLAS_LAPACK, NONE }
	The decomposition schemes above change the entries of the matrix A. More...
enum	_BLAS_Multiply_Flag { LEFT_MULTIPLY = 0, RIGHT_MULTIPLY, LEFT_MULTIPLY_TRANSPOSE, RIGHT_MULTIPLY_TRANSPOSE }
	Enumeration used to determine the behavior of the _multiply_blas function. More...
typedef PetscBLASInt	pivot_index_t
	Array used to store pivot indices. More...
typedef int	pivot_index_t

Private Member Functions
void	_lu_decompose ()
	Form the LU decomposition of the matrix. More...
void	_lu_back_substitute (const DenseVector< T > &b, DenseVector< T > &x) const
	Solves the system Ax=b through back substitution. More...
void	_cholesky_decompose ()
	Decomposes a symmetric positive definite matrix into a product of two lower triangular matrices according to A = LL^T. More...
template<typename T2 >
void	_cholesky_back_substitute (const DenseVector< T2 > &b, DenseVector< T2 > &x) const
	Solves the equation Ax=b for the unknown value x and rhs b based on the Cholesky factorization of A. More...
void	_multiply_blas (const DenseMatrixBase< T > &other, _BLAS_Multiply_Flag flag)
	The _multiply_blas function computes A <- op(A) * op(B) using BLAS gemm function. More...
void	_lu_decompose_lapack ()
	Computes an LU factorization of the matrix using the Lapack routine "getrf". More...
void	_svd_lapack (DenseVector< Real > &sigma)
	Computes an SVD of the matrix using the Lapack routine "getsvd". More...
void	_svd_lapack (DenseVector< Real > &sigma, DenseMatrix< Number > &U, DenseMatrix< Number > &VT)
	Computes a "reduced" SVD of the matrix using the Lapack routine "getsvd". More...
void	_svd_solve_lapack (const DenseVector< T > &rhs, DenseVector< T > &x, Real rcond) const
	Called by svd_solve(rhs). More...
void	_svd_helper (char JOBU, char JOBVT, std::vector< Real > &sigma_val, std::vector< Number > &U_val, std::vector< Number > &VT_val)
	Helper function that actually performs the SVD. More...
void	_evd_lapack (DenseVector< T > &lambda_real, DenseVector< T > &lambda_imag, DenseMatrix< T > *VL=nullptr, DenseMatrix< T > *VR=nullptr)
	Computes the eigenvalues of the matrix using the Lapack routine "DGEEV". More...
void	_lu_back_substitute_lapack (const DenseVector< T > &b, DenseVector< T > &x)
	Companion function to _lu_decompose_lapack(). More...
void	_matvec_blas (T alpha, T beta, DenseVector< T > &dest, const DenseVector< T > &arg, bool trans=false) const
	Uses the BLAS GEMV function (through PETSc) to compute. More...

Private Attributes
std::vector< T >	_val
	The actual data values, stored as a 1D array. More...
DecompositionType	_decomposition_type
	This flag keeps track of which type of decomposition has been performed on the matrix. More...
std::vector< pivot_index_t >	_pivots

Detailed Description

template<typename T>
class libMesh::DenseMatrix< T >

Defines a dense matrix for use in Finite Element-type computations.

Useful for storing element stiffness matrices before summation into a global matrix. All overridden virtual functions are documented in dense_matrix_base.h.

Author

Benjamin S. Kirk

Date

2002 A matrix object used for finite element assembly and numerics.

Definition at line 74 of file dof_map.h.

Member Typedef Documentation

pivot_index_t [1/2]

template<typename T>

typedef PetscBLASInt libMesh::DenseMatrix< T >::pivot_index_t

private

Array used to store pivot indices.

May be used by whatever factorization is currently active, clients of the class should not rely on it for any reason.

Definition at line 668 of file dense_matrix.h.

pivot_index_t [2/2]

template<typename T>

typedef int libMesh::DenseMatrix< T >::pivot_index_t

private

Definition at line 670 of file dense_matrix.h.

Member Enumeration Documentation

_BLAS_Multiply_Flag

template<typename T>

enum libMesh::DenseMatrix::_BLAS_Multiply_Flag

private

Enumeration used to determine the behavior of the _multiply_blas function.

Enumerator
LEFT_MULTIPLY
RIGHT_MULTIPLY
LEFT_MULTIPLY_TRANSPOSE
RIGHT_MULTIPLY_TRANSPOSE

Definition at line 588 of file dense_matrix.h.

                           {
    LEFT_MULTIPLY = 0,
    RIGHT_MULTIPLY,
    LEFT_MULTIPLY_TRANSPOSE,
    RIGHT_MULTIPLY_TRANSPOSE
  };

DecompositionType

template<typename T>

enum libMesh::DenseMatrix::DecompositionType

private

The decomposition schemes above change the entries of the matrix A.

It is therefore an error to call A.lu_solve() and subsequently call A.cholesky_solve() since the result will probably not match any desired outcome. This typedef keeps track of which decomposition has been called for this matrix.

Enumerator
LU
CHOLESKY
LU_BLAS_LAPACK
NONE

Definition at line 576 of file dense_matrix.h.

{LU=0, CHOLESKY=1, LU_BLAS_LAPACK, NONE};

Constructor & Destructor Documentation

DenseMatrix() [1/3]

template<typename T >

libMesh::DenseMatrix< T >::DenseMatrix	(	const unsigned int	new_m = 0,
		const unsigned int	new_n = 0
	)

Constructor.

Creates a dense matrix of dimension m by n.

Definition at line 744 of file dense_matrix.h.

                                                      :
  DenseMatrixBase<T>(new_m,new_n),
#if defined(LIBMESH_HAVE_PETSC) && defined(LIBMESH_USE_REAL_NUMBERS) && defined(LIBMESH_DEFAULT_DOUBLE_PRECISION)
  use_blas_lapack(true),
#else
  use_blas_lapack(false),
#endif
  _val(),
  _decomposition_type(NONE)
{
  this->resize(new_m,new_n);
}

DenseMatrix() [2/3]

template<typename T>

libMesh::DenseMatrix< T >::DenseMatrix ( DenseMatrix< T > &&  )

default

The 5 special functions can be defaulted for this class, as it does not manage any memory itself.

DenseMatrix() [3/3]

template<typename T>

libMesh::DenseMatrix< T >::DenseMatrix ( const DenseMatrix< T > &  )

default

~DenseMatrix()

template<typename T>

virtual libMesh::DenseMatrix< T >::~DenseMatrix ( )

virtualdefault

Member Function Documentation

_cholesky_back_substitute()

template<typename T >

template<typename T2 >

void libMesh::DenseMatrix< T >::_cholesky_back_substitute ( const DenseVector< T2 > &  b, DenseVector< T2 > &  x  ) const

private

Solves the equation Ax=b for the unknown value x and rhs b based on the Cholesky factorization of A.

Note

This method may be used when A is real-valued and b and x are complex-valued.

Definition at line 1007 of file dense_matrix_impl.h.

{
  // Shorthand notation for number of rows and columns.
  const unsigned int
    n_rows = this->m(),
    n_cols = this->n();

  // Just to be really sure...
  libmesh_assert_equal_to (n_rows, n_cols);

  // A convenient reference to *this
  const DenseMatrix<T> & A = *this;

  // Now compute the solution to Ax =b using the factorization.
  x.resize(n_rows);

  // Solve for Ly=b
  for (unsigned int i=0; i<n_cols; ++i)
    {
      T2 temp = b(i);

      for (unsigned int k=0; k<i; ++k)
        temp -= A(i,k)*x(k);

      x(i) = temp / A(i,i);
    }

  // Solve for L^T x = y
  for (unsigned int i=0; i<n_cols; ++i)
    {
      const unsigned int ib = (n_cols-1)-i;

      for (unsigned int k=(ib+1); k<n_cols; ++k)
        x(ib) -= A(k,ib) * x(k);

      x(ib) /= A(ib,ib);
    }
}

_cholesky_decompose()

template<typename T >

void libMesh::DenseMatrix< T >::_cholesky_decompose ( )

private

Decomposes a symmetric positive definite matrix into a product of two lower triangular matrices according to A = LL^T.

Note

This program generates an error if the matrix is not SPD.

Definition at line 961 of file dense_matrix_impl.h.

{
  // If we called this function, there better not be any
  // previous decomposition of the matrix.
  libmesh_assert_equal_to (this->_decomposition_type, NONE);

  // Shorthand notation for number of rows and columns.
  const unsigned int
    n_rows = this->m(),
    n_cols = this->n();

  // Just to be really sure...
  libmesh_assert_equal_to (n_rows, n_cols);

  // A convenient reference to *this
  DenseMatrix<T> & A = *this;

  for (unsigned int i=0; i<n_rows; ++i)
    {
      for (unsigned int j=i; j<n_cols; ++j)
        {
          for (unsigned int k=0; k<i; ++k)
            A(i,j) -= A(i,k) * A(j,k);

          if (i == j)
            {
#ifndef LIBMESH_USE_COMPLEX_NUMBERS
              if (A(i,j) <= 0.0)
                libmesh_error_msg("Error! Can only use Cholesky decomposition with symmetric positive definite matrices.");
#endif

              A(i,i) = std::sqrt(A(i,j));
            }
          else
            A(j,i) = A(i,j) / A(i,i);
        }
    }

  // Set the flag for CHOLESKY decomposition
  this->_decomposition_type = CHOLESKY;
}

_evd_lapack()

template<typename T>

void libMesh::DenseMatrix< T >::_evd_lapack ( DenseVector< T > &  lambda_real, DenseVector< T > &  lambda_imag, DenseMatrix< T > *  VL = nullptr, DenseMatrix< T > *  VR = nullptr  )

private

Computes the eigenvalues of the matrix using the Lapack routine "DGEEV".

If VR and/or VL are not nullptr, then the matrix of right and/or left eigenvectors is also computed and returned by this function.

[ Implementation in dense_matrix_blas_lapack.C ]

_lu_back_substitute()

template<typename T>

void libMesh::DenseMatrix< T >::_lu_back_substitute ( const DenseVector< T > &  b, DenseVector< T > &  x  ) const

private

Solves the system Ax=b through back substitution.

This function is private since it is only called as part of the implementation of the lu_solve(...) function.

Definition at line 666 of file dense_matrix_impl.h.

{
  const unsigned int
    n_cols = this->n();

  libmesh_assert_equal_to (this->m(), n_cols);
  libmesh_assert_equal_to (this->m(), b.size());

  x.resize (n_cols);

  // A convenient reference to *this
  const DenseMatrix<T> & A = *this;

  // Temporary vector storage.  We use this instead of
  // modifying the RHS.
  DenseVector<T> z = b;

  // Lower-triangular "top to bottom" solve step, taking into account pivots
  for (unsigned int i=0; i<n_cols; ++i)
    {
      // Swap
      if (_pivots[i] != static_cast<pivot_index_t>(i))
        std::swap( z(i), z(_pivots[i]) );

      x(i) = z(i);

      for (unsigned int j=0; j<i; ++j)
        x(i) -= A(i,j)*x(j);

      x(i) /= A(i,i);
    }

  // Upper-triangular "bottom to top" solve step
  const unsigned int last_row = n_cols-1;

  for (int i=last_row; i>=0; --i)
    {
      for (int j=i+1; j<static_cast<int>(n_cols); ++j)
        x(i) -= A(i,j)*x(j);
    }
}

_lu_back_substitute_lapack()

template<typename T>

void libMesh::DenseMatrix< T >::_lu_back_substitute_lapack ( const DenseVector< T > &  b, DenseVector< T > &  x  )

private

Companion function to _lu_decompose_lapack().

Do not use directly, called through the public lu_solve() interface. This function is logically const in that it does not modify the matrix, but since we are just calling LAPACK routines, it's less const_cast hassle to just declare the function non-const. [ Implementation in dense_matrix_blas_lapack.C ]

_lu_decompose()

template<typename T >

void libMesh::DenseMatrix< T >::_lu_decompose ( )

private

Form the LU decomposition of the matrix.

This function is private since it is only called as part of the implementation of the lu_solve(...) function.

Definition at line 717 of file dense_matrix_impl.h.

{
  // If this function was called, there better not be any
  // previous decomposition of the matrix.
  libmesh_assert_equal_to (this->_decomposition_type, NONE);

  // Get the matrix size and make sure it is square
  const unsigned int
    n_rows = this->m();

  // A convenient reference to *this
  DenseMatrix<T> & A = *this;

  _pivots.resize(n_rows);

  for (unsigned int i=0; i<n_rows; ++i)
    {
      // Find the pivot row by searching down the i'th column
      _pivots[i] = i;

      // std::abs(complex) must return a Real!
      Real the_max = std::abs( A(i,i) );
      for (unsigned int j=i+1; j<n_rows; ++j)
        {
          Real candidate_max = std::abs( A(j,i) );
          if (the_max < candidate_max)
            {
              the_max = candidate_max;
              _pivots[i] = j;
            }
        }

      // libMesh::out << "the_max=" << the_max << " found at row " << _pivots[i] << std::endl;

      // If the max was found in a different row, interchange rows.
      // Here we interchange the *entire* row, in Gaussian elimination
      // you would only interchange the subrows A(i,j) and A(p(i),j), for j>i
      if (_pivots[i] != static_cast<pivot_index_t>(i))
        {
          for (unsigned int j=0; j<n_rows; ++j)
            std::swap( A(i,j), A(_pivots[i], j) );
        }


      // If the max abs entry found is zero, the matrix is singular
      if (A(i,i) == libMesh::zero)
        libmesh_error_msg("Matrix A is singular!");

      // Scale upper triangle entries of row i by the diagonal entry
      // Note: don't scale the diagonal entry itself!
      const T diag_inv = 1. / A(i,i);
      for (unsigned int j=i+1; j<n_rows; ++j)
        A(i,j) *= diag_inv;

      // Update the remaining sub-matrix A[i+1:m][i+1:m]
      // by subtracting off (the diagonal-scaled)
      // upper-triangular part of row i, scaled by the
      // i'th column entry of each row.  In terms of
      // row operations, this is:
      // for each r > i
      //   SubRow(r) = SubRow(r) - A(r,i)*SubRow(i)
      //
      // If we were scaling the i'th column as well, like
      // in Gaussian elimination, this would 'zero' the
      // entry in the i'th column.
      for (unsigned int row=i+1; row<n_rows; ++row)
        for (unsigned int col=i+1; col<n_rows; ++col)
          A(row,col) -= A(row,i) * A(i,col);

    } // end i loop

  // Set the flag for LU decomposition
  this->_decomposition_type = LU;
}

_lu_decompose_lapack()

template<typename T>

void libMesh::DenseMatrix< T >::_lu_decompose_lapack ( )

private

Computes an LU factorization of the matrix using the Lapack routine "getrf".

This routine should only be used by the "use_blas_lapack" branch of the lu_solve() function. After the call to this function, the matrix is replaced by its factorized version, and the DecompositionType is set to LU_BLAS_LAPACK. [ Implementation in dense_matrix_blas_lapack.C ]

_matvec_blas()

template<typename T>

void libMesh::DenseMatrix< T >::_matvec_blas ( T  alpha, T  beta, DenseVector< T > &  dest, const DenseVector< T > &  arg, bool  trans = false  ) const

private

Uses the BLAS GEMV function (through PETSc) to compute.

dest := alpha*A*arg + beta*dest

where alpha and beta are scalars, A is this matrix, and arg and dest are input vectors of appropriate size. If trans is true, the transpose matvec is computed instead. By default, trans==false.

[ Implementation in dense_matrix_blas_lapack.C ]

_multiply_blas()

template<typename T>

void libMesh::DenseMatrix< T >::_multiply_blas ( const DenseMatrixBase< T > &  other, _BLAS_Multiply_Flag  flag  )

private

The _multiply_blas function computes A <- op(A) * op(B) using BLAS gemm function.

Used in the right_multiply(), left_multiply(), right_multiply_transpose(), and left_multiply_transpose() routines. [ Implementation in dense_matrix_blas_lapack.C ]

_svd_helper()

template<typename T>

void libMesh::DenseMatrix< T >::_svd_helper ( char  JOBU, char  JOBVT, std::vector< Real > &  sigma_val, std::vector< Number > &  U_val, std::vector< Number > &  VT_val  )

private

Helper function that actually performs the SVD.

[ Implementation in dense_matrix_blas_lapack.C ]

_svd_lapack() [1/2]

template<typename T>

void libMesh::DenseMatrix< T >::_svd_lapack ( DenseVector< Real > &  sigma )

private

Computes an SVD of the matrix using the Lapack routine "getsvd".

[ Implementation in dense_matrix_blas_lapack.C ]

_svd_lapack() [2/2]

template<typename T>

void libMesh::DenseMatrix< T >::_svd_lapack ( DenseVector< Real > &  sigma, DenseMatrix< Number > &  U, DenseMatrix< Number > &  VT  )

private

Computes a "reduced" SVD of the matrix using the Lapack routine "getsvd".

[ Implementation in dense_matrix_blas_lapack.C ]

_svd_solve_lapack()

template<typename T>

void libMesh::DenseMatrix< T >::_svd_solve_lapack ( const DenseVector< T > &  rhs, DenseVector< T > &  x, Real  rcond  ) const

private

Called by svd_solve(rhs).

add() [1/2]

template<typename T >

template<typename T2 , typename T3 >

boostcopy::enable_if_c< ScalarTraits< T2 >::value, void >::type libMesh::DenseMatrixBase< T >::add ( const T2  factor, const DenseMatrixBase< T3 > &  mat  )

inherited

Adds factor to every element in the matrix.

This should only work if T += T2 * T3 is valid C++ and if T2 is scalar. Return type is void

Definition at line 188 of file dense_matrix_base.h.

References libMesh::DenseMatrixBase< T >::el(), libMesh::DenseMatrixBase< T >::m(), and libMesh::DenseMatrixBase< T >::n().

{
  libmesh_assert_equal_to (this->m(), mat.m());
  libmesh_assert_equal_to (this->n(), mat.n());

  for (unsigned int j=0; j<this->n(); j++)
    for (unsigned int i=0; i<this->m(); i++)
      this->el(i,j) += factor*mat.el(i,j);
}

add() [2/2]

template<typename T >

template<typename T2 , typename T3 >

boostcopy::enable_if_c< ScalarTraits< T2 >::value, void >::type libMesh::DenseMatrix< T >::add	(	const T2	factor,
		const DenseMatrix< T3 > &	mat
	)

Adds factor times mat to this matrix.

Returns

A reference to *this.

Definition at line 884 of file dense_matrix.h.

{
  libmesh_assert_equal_to (this->m(), mat.m());
  libmesh_assert_equal_to (this->n(), mat.n());

  for (unsigned int i=0; i<this->m(); i++)
    for (unsigned int j=0; j<this->n(); j++)
      (*this)(i,j) += factor * mat(i,j);
}

cholesky_solve()

template<typename T >

template<typename T2 >

void libMesh::DenseMatrix< T >::cholesky_solve	(	const DenseVector< T2 > &	b,
		DenseVector< T2 > &	x
	)

For symmetric positive definite (SPD) matrices.

A Cholesky factorization of A such that A = L L^T is about twice as fast as a standard LU factorization. Therefore you can use this method if you know a-priori that the matrix is SPD. If the matrix is not SPD, an error is generated. One nice property of Cholesky decompositions is that they do not require pivoting for stability.

Note

This method may also be used when A is real-valued and x and b are complex-valued.

Definition at line 929 of file dense_matrix_impl.h.

Referenced by libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::operator()().

{
  // Check for a previous decomposition
  switch(this->_decomposition_type)
    {
    case NONE:
      {
        this->_cholesky_decompose ();
        break;
      }

    case CHOLESKY:
      {
        // Already factored, just need to call back_substitute.
        break;
      }

    default:
      libmesh_error_msg("Error! This matrix already has a different decomposition...");
    }

  // Perform back substitution
  this->_cholesky_back_substitute (b, x);
}

condense() [1/2]

template<typename T>

void libMesh::DenseMatrixBase< T >::condense ( const unsigned int  i, const unsigned int  j, const T  val, DenseVectorBase< T > &  rhs  )

protectedinherited

Condense-out the (i,j) entry of the matrix, forcing it to take on the value val.

This is useful in numerical simulations for applying boundary conditions. Preserves the symmetry of the matrix.

Referenced by libMesh::DenseMatrix< Real >::condense().

condense() [2/2]

template<typename T>

void libMesh::DenseMatrix< T >::condense	(	const unsigned int	i,
		const unsigned int	j,
		const T	val,
		DenseVector< T > &	rhs
	)

Condense-out the (i,j) entry of the matrix, forcing it to take on the value val.

This is useful in numerical simulations for applying boundary conditions. Preserves the symmetry of the matrix.

Definition at line 354 of file dense_matrix.h.

  { DenseMatrixBase<T>::condense (i, j, val, rhs); }

det()

template<typename T >

T libMesh::DenseMatrix< T >::det

(

)

Returns

The determinant of the matrix.

Note

Implemented by computing an LU decomposition and then taking the product of the diagonal terms. Therefore this is a non-const method which modifies the entries of the matrix.

Definition at line 868 of file dense_matrix_impl.h.

{
  switch(this->_decomposition_type)
    {
    case NONE:
      {
        // First LU decompose the matrix.
        // Note that the lu_decompose routine will check to see if the
        // matrix is square so we don't worry about it.
        if (this->use_blas_lapack)
          this->_lu_decompose_lapack();
        else
          this->_lu_decompose ();
      }
    case LU:
    case LU_BLAS_LAPACK:
      {
        // Already decomposed, don't do anything
        break;
      }
    default:
      libmesh_error_msg("Error! Can't compute the determinant under the current decomposition.");
    }

  // A variable to keep track of the running product of diagonal terms.
  T determinant = 1.;

  // Loop over diagonal terms, computing the product.  In practice,
  // be careful because this value could easily become too large to
  // fit in a double or float.  To be safe, one should keep track of
  // the power (of 10) of the determinant in a separate variable
  // and maintain an order 1 value for the determinant itself.
  unsigned int n_interchanges = 0;
  for (unsigned int i=0; i<this->m(); i++)
    {
      if (this->_decomposition_type==LU)
        if (_pivots[i] != static_cast<pivot_index_t>(i))
          n_interchanges++;

      // Lapack pivots are 1-based!
      if (this->_decomposition_type==LU_BLAS_LAPACK)
        if (_pivots[i] != static_cast<pivot_index_t>(i+1))
          n_interchanges++;

      determinant *= (*this)(i,i);
    }

  // Compute sign of determinant, depends on number of row interchanges!
  // The sign should be (-1)^{n}, where n is the number of interchanges.
  Real sign = n_interchanges % 2 == 0 ? 1. : -1.;

  return sign*determinant;
}

el() [1/2]

template<typename T>

virtual T libMesh::DenseMatrix< T >::el ( const unsigned int  i, const unsigned int  j  ) const

overridevirtual

Returns

The (i,j) element of the matrix. Since internal data representations may differ, you must redefine this function.

Implements libMesh::DenseMatrixBase< T >.

Definition at line 88 of file dense_matrix.h.

  { return (*this)(i,j); }

el() [2/2]

template<typename T>

virtual T& libMesh::DenseMatrix< T >::el ( const unsigned int  i, const unsigned int  j  )

overridevirtual

Returns

The (i,j) element of the matrix as a writable reference. Since internal data representations may differ, you must redefine this function.

Implements libMesh::DenseMatrixBase< T >.

Definition at line 92 of file dense_matrix.h.

  { return (*this)(i,j); }

evd()

template<typename T>

void libMesh::DenseMatrix< T >::evd	(	DenseVector< T > &	lambda_real,
		DenseVector< T > &	lambda_imag
	)

Compute the eigenvalues (both real and imaginary parts) of a general matrix.

Warning: the contents of *this are overwritten by this function!

The implementation requires the LAPACKgeev_ function which is wrapped by PETSc.

Definition at line 824 of file dense_matrix_impl.h.

{
  // We use the LAPACK eigenvalue problem implementation
  _evd_lapack(lambda_real, lambda_imag);
}

evd_left()

template<typename T>

void libMesh::DenseMatrix< T >::evd_left	(	DenseVector< T > &	lambda_real,
		DenseVector< T > &	lambda_imag,
		DenseMatrix< T > &	VL
	)

Compute the eigenvalues (both real and imaginary parts) and left eigenvectors of a general matrix, .

Warning: the contents of *this are overwritten by this function!

The left eigenvector of satisfies: where denotes the conjugate-transpose of .

If the j-th and (j+1)-st eigenvalues form a complex conjugate pair, then the j-th and (j+1)-st columns of VL "share" their real-valued storage in the following way: u_j = VL(:,j) + i*VL(:,j+1) and u_{j+1} = VL(:,j) - i*VL(:,j+1).

The implementation requires the LAPACKgeev_ routine which is provided by PETSc.

Definition at line 834 of file dense_matrix_impl.h.

{
  // We use the LAPACK eigenvalue problem implementation
  _evd_lapack(lambda_real, lambda_imag, &VL, nullptr);
}

evd_left_and_right()

template<typename T>

void libMesh::DenseMatrix< T >::evd_left_and_right	(	DenseVector< T > &	lambda_real,
		DenseVector< T > &	lambda_imag,
		DenseMatrix< T > &	VL,
		DenseMatrix< T > &	VR
	)

Compute the eigenvalues (both real and imaginary parts) as well as the left and right eigenvectors of a general matrix.

Warning: the contents of *this are overwritten by this function!

See the documentation of the evd_left() and evd_right() functions for more information. The implementation requires the LAPACKgeev_ routine which is provided by PETSc.

Definition at line 856 of file dense_matrix_impl.h.

{
  // We use the LAPACK eigenvalue problem implementation
  _evd_lapack(lambda_real, lambda_imag, &VL, &VR);
}

evd_right()

template<typename T>

void libMesh::DenseMatrix< T >::evd_right	(	DenseVector< T > &	lambda_real,
		DenseVector< T > &	lambda_imag,
		DenseMatrix< T > &	VR
	)

Compute the eigenvalues (both real and imaginary parts) and right eigenvectors of a general matrix, .

Warning: the contents of *this are overwritten by this function!

The right eigenvector of satisfies: where is its corresponding eigenvalue.

Note

If the j-th and (j+1)-st eigenvalues form a complex conjugate pair, then the j-th and (j+1)-st columns of VR "share" their real-valued storage in the following way: v_j = VR(:,j) + i*VR(:,j+1) and v_{j+1} = VR(:,j) - i*VR(:,j+1).

The implementation requires the LAPACKgeev_ routine which is provided by PETSc.

Definition at line 845 of file dense_matrix_impl.h.

{
  // We use the LAPACK eigenvalue problem implementation
  _evd_lapack(lambda_real, lambda_imag, nullptr, &VR);
}

get_principal_submatrix() [1/2]

template<typename T>

void libMesh::DenseMatrix< T >::get_principal_submatrix	(	unsigned int	sub_m,
		unsigned int	sub_n,
		DenseMatrix< T > &	dest
	)		const

Put the sub_m x sub_n principal submatrix into dest.

Definition at line 556 of file dense_matrix_impl.h.

{
  libmesh_assert( (sub_m <= this->m()) && (sub_n <= this->n()) );

  dest.resize(sub_m, sub_n);
  for (unsigned int i=0; i<sub_m; i++)
    for (unsigned int j=0; j<sub_n; j++)
      dest(i,j) = (*this)(i,j);
}

get_principal_submatrix() [2/2]

template<typename T>

void libMesh::DenseMatrix< T >::get_principal_submatrix	(	unsigned int	sub_m,
		DenseMatrix< T > &	dest
	)		const

Put the sub_m x sub_m principal submatrix into dest.

Definition at line 586 of file dense_matrix_impl.h.

{
  get_principal_submatrix(sub_m, sub_m, dest);
}

get_transpose()

template<typename T>

void libMesh::DenseMatrix< T >::get_transpose

(

DenseMatrix< T > &

dest

)

const

Put the tranposed matrix into dest.

Definition at line 594 of file dense_matrix_impl.h.

{
  dest.resize(this->n(), this->m());

  for (unsigned int i=0; i<dest.m(); i++)
    for (unsigned int j=0; j<dest.n(); j++)
      dest(i,j) = (*this)(j,i);
}

get_values() [1/2]

template<typename T>

std::vector<T>& libMesh::DenseMatrix< T >::get_values

(

)

Returns

A reference to the underlying data storage vector.

This should be used with caution (i.e. one should not change the size of the vector, etc.) but is useful for interoperating with low level BLAS routines which expect a simple array.

Definition at line 341 of file dense_matrix.h.

{ return _val; }

get_values() [2/2]

template<typename T>

const std::vector<T>& libMesh::DenseMatrix< T >::get_values

(

)

const

Returns

A constant reference to the underlying data storage vector.

Definition at line 346 of file dense_matrix.h.

{ return _val; }

l1_norm()

template<typename T >

Real libMesh::DenseMatrix< T >::l1_norm

(

)

const

Returns

The l1-norm of the matrix, that is, the max column sum:

,

This is the natural matrix norm that is compatible to the l1-norm for vectors, i.e. .

Definition at line 991 of file dense_matrix.h.

{
  libmesh_assert (this->_m);
  libmesh_assert (this->_n);

  Real columnsum = 0.;
  for (unsigned int i=0; i!=this->_m; i++)
    {
      columnsum += std::abs((*this)(i,0));
    }
  Real my_max = columnsum;
  for (unsigned int j=1; j!=this->_n; j++)
    {
      columnsum = 0.;
      for (unsigned int i=0; i!=this->_m; i++)
        {
          columnsum += std::abs((*this)(i,j));
        }
      my_max = (my_max > columnsum? my_max : columnsum);
    }
  return my_max;
}

left_multiply() [1/2]

template<typename T>

void libMesh::DenseMatrix< T >::left_multiply ( const DenseMatrixBase< T > &  M2 )

overridevirtual

Performs the operation: (*this) <- M2 * (*this)

Implements libMesh::DenseMatrixBase< T >.

Definition at line 40 of file dense_matrix_impl.h.

{
  if (this->use_blas_lapack)
    this->_multiply_blas(M2, LEFT_MULTIPLY);
  else
    {
      // (*this) <- M2 * (*this)
      // Where:
      // (*this) = (m x n),
      // M2      = (m x p),
      // M3      = (p x n)

      // M3 is a copy of *this before it gets resize()d
      DenseMatrix<T> M3(*this);

      // Resize *this so that the result can fit
      this->resize (M2.m(), M3.n());

      // Call the multiply function in the base class
      this->multiply(*this, M2, M3);
    }
}

left_multiply() [2/2]

template<typename T >

template<typename T2 >

void libMesh::DenseMatrix< T >::left_multiply

(

const DenseMatrixBase< T2 > &

M2

)

Left multiplies by the matrix M2 of different type.

Definition at line 67 of file dense_matrix_impl.h.

{
  // (*this) <- M2 * (*this)
  // Where:
  // (*this) = (m x n),
  // M2      = (m x p),
  // M3      = (p x n)

  // M3 is a copy of *this before it gets resize()d
  DenseMatrix<T> M3(*this);

  // Resize *this so that the result can fit
  this->resize (M2.m(), M3.n());

  // Call the multiply function in the base class
  this->multiply(*this, M2, M3);
}

left_multiply_transpose() [1/2]

template<typename T>

void libMesh::DenseMatrix< T >::left_multiply_transpose

(

const DenseMatrix< T > &

A

)

Left multiplies by the transpose of the matrix A.

Definition at line 88 of file dense_matrix_impl.h.

{
  if (this->use_blas_lapack)
    this->_multiply_blas(A, LEFT_MULTIPLY_TRANSPOSE);
  else
    {
      //Check to see if we are doing (A^T)*A
      if (this == &A)
        {
          //libmesh_here();
          DenseMatrix<T> B(*this);

          // Simple but inefficient way
          // return this->left_multiply_transpose(B);

          // More efficient, but more code way
          // If A is mxn, the result will be a square matrix of Size n x n.
          const unsigned int n_rows = A.m();
          const unsigned int n_cols = A.n();

          // resize() *this and also zero out all entries.
          this->resize(n_cols,n_cols);

          // Compute the lower-triangular part
          for (unsigned int i=0; i<n_cols; ++i)
            for (unsigned int j=0; j<=i; ++j)
              for (unsigned int k=0; k<n_rows; ++k) // inner products are over n_rows
                (*this)(i,j) += B(k,i)*B(k,j);

          // Copy lower-triangular part into upper-triangular part
          for (unsigned int i=0; i<n_cols; ++i)
            for (unsigned int j=i+1; j<n_cols; ++j)
              (*this)(i,j) = (*this)(j,i);
        }

      else
        {
          DenseMatrix<T> B(*this);

          this->resize (A.n(), B.n());

          libmesh_assert_equal_to (A.m(), B.m());
          libmesh_assert_equal_to (this->m(), A.n());
          libmesh_assert_equal_to (this->n(), B.n());

          const unsigned int m_s = A.n();
          const unsigned int p_s = A.m();
          const unsigned int n_s = this->n();

          // Do it this way because there is a
          // decent chance (at least for constraint matrices)
          // that A.transpose(i,k) = 0.
          for (unsigned int i=0; i<m_s; i++)
            for (unsigned int k=0; k<p_s; k++)
              if (A.transpose(i,k) != 0.)
                for (unsigned int j=0; j<n_s; j++)
                  (*this)(i,j) += A.transpose(i,k)*B(k,j);
        }
    }

}

left_multiply_transpose() [2/2]

template<typename T >

template<typename T2 >

void libMesh::DenseMatrix< T >::left_multiply_transpose

(

const DenseMatrix< T2 > &

A

)

Left multiplies by the transpose of the matrix A which contains a different numerical type.

Definition at line 154 of file dense_matrix_impl.h.

{
  //Check to see if we are doing (A^T)*A
  if (this == &A)
    {
      //libmesh_here();
      DenseMatrix<T> B(*this);

      // Simple but inefficient way
      // return this->left_multiply_transpose(B);

      // More efficient, but more code way
      // If A is mxn, the result will be a square matrix of Size n x n.
      const unsigned int n_rows = A.m();
      const unsigned int n_cols = A.n();

      // resize() *this and also zero out all entries.
      this->resize(n_cols,n_cols);

      // Compute the lower-triangular part
      for (unsigned int i=0; i<n_cols; ++i)
        for (unsigned int j=0; j<=i; ++j)
          for (unsigned int k=0; k<n_rows; ++k) // inner products are over n_rows
            (*this)(i,j) += B(k,i)*B(k,j);

      // Copy lower-triangular part into upper-triangular part
      for (unsigned int i=0; i<n_cols; ++i)
        for (unsigned int j=i+1; j<n_cols; ++j)
          (*this)(i,j) = (*this)(j,i);
    }

  else
    {
      DenseMatrix<T> B(*this);

      this->resize (A.n(), B.n());

      libmesh_assert_equal_to (A.m(), B.m());
      libmesh_assert_equal_to (this->m(), A.n());
      libmesh_assert_equal_to (this->n(), B.n());

      const unsigned int m_s = A.n();
      const unsigned int p_s = A.m();
      const unsigned int n_s = this->n();

      // Do it this way because there is a
      // decent chance (at least for constraint matrices)
      // that A.transpose(i,k) = 0.
      for (unsigned int i=0; i<m_s; i++)
        for (unsigned int k=0; k<p_s; k++)
          if (A.transpose(i,k) != 0.)
            for (unsigned int j=0; j<n_s; j++)
              (*this)(i,j) += A.transpose(i,k)*B(k,j);
    }
}

linfty_norm()

template<typename T >

Real libMesh::DenseMatrix< T >::linfty_norm

(

)

const

Returns

The linfty-norm of the matrix, that is, the max row sum:

,

This is the natural matrix norm that is compatible to the linfty-norm of vectors, i.e. .

Definition at line 1018 of file dense_matrix.h.

{
  libmesh_assert (this->_m);
  libmesh_assert (this->_n);

  Real rowsum = 0.;
  for (unsigned int j=0; j!=this->_n; j++)
    {
      rowsum += std::abs((*this)(0,j));
    }
  Real my_max = rowsum;
  for (unsigned int i=1; i!=this->_m; i++)
    {
      rowsum = 0.;
      for (unsigned int j=0; j!=this->_n; j++)
        {
          rowsum += std::abs((*this)(i,j));
        }
      my_max = (my_max > rowsum? my_max : rowsum);
    }
  return my_max;
}

lu_solve()

template<typename T>

void libMesh::DenseMatrix< T >::lu_solve	(	const DenseVector< T > &	b,
		DenseVector< T > &	x
	)

Solve the system Ax=b given the input vector b.

Partial pivoting is performed by default in order to keep the algorithm stable to the effects of round-off error.

Definition at line 607 of file dense_matrix_impl.h.

{
  // Check to be sure that the matrix is square before attempting
  // an LU-solve.  In general, one can compute the LU factorization of
  // a non-square matrix, but:
  //
  // Overdetermined systems (m>n) have a solution only if enough of
  // the equations are linearly-dependent.
  //
  // Underdetermined systems (m<n) typically have infinitely many
  // solutions.
  //
  // We don't want to deal with either of these ambiguous cases here...
  libmesh_assert_equal_to (this->m(), this->n());

  switch(this->_decomposition_type)
    {
    case NONE:
      {
        if (this->use_blas_lapack)
          this->_lu_decompose_lapack();
        else
          this->_lu_decompose ();
        break;
      }

    case LU_BLAS_LAPACK:
      {
        // Already factored, just need to call back_substitute.
        if (this->use_blas_lapack)
          break;
      }
      libmesh_fallthrough();

    case LU:
      {
        // Already factored, just need to call back_substitute.
        if (!(this->use_blas_lapack))
          break;
      }
      libmesh_fallthrough();

    default:
      libmesh_error_msg("Error! This matrix already has a different decomposition...");
    }

  if (this->use_blas_lapack)
    this->_lu_back_substitute_lapack (b, x);
  else
    this->_lu_back_substitute (b, x);
}

m()

template<typename T>

unsigned int libMesh::DenseMatrixBase< T >::m ( ) const

inherited

Returns

The row-dimension of the matrix.

Definition at line 102 of file dense_matrix_base.h.

References libMesh::DenseMatrixBase< T >::_m.

Referenced by libMesh::DenseMatrixBase< T >::add(), libMesh::DenseMatrix< Real >::get_transpose(), libMesh::DenseMatrix< Real >::left_multiply(), libMesh::DenseMatrix< Real >::left_multiply_transpose(), libMesh::DenseMatrix< Real >::right_multiply(), and libMesh::DenseMatrix< Real >::right_multiply_transpose().

{ return _m; }

max()

template<typename T >

Real libMesh::DenseMatrix< T >::max

(

)

const

Returns

The maximum entry in the matrix, or the maximum real part in the case of complex numbers.

Definition at line 970 of file dense_matrix.h.

{
  libmesh_assert (this->_m);
  libmesh_assert (this->_n);
  Real my_max = libmesh_real((*this)(0,0));

  for (unsigned int i=0; i!=this->_m; i++)
    {
      for (unsigned int j=0; j!=this->_n; j++)
        {
          Real current = libmesh_real((*this)(i,j));
          my_max = (my_max > current? my_max : current);
        }
    }
  return my_max;
}

min()

template<typename T >

Real libMesh::DenseMatrix< T >::min

(

)

const

Returns

The minimum entry in the matrix, or the minimum real part in the case of complex numbers.

Definition at line 949 of file dense_matrix.h.

{
  libmesh_assert (this->_m);
  libmesh_assert (this->_n);
  Real my_min = libmesh_real((*this)(0,0));

  for (unsigned int i=0; i!=this->_m; i++)
    {
      for (unsigned int j=0; j!=this->_n; j++)
        {
          Real current = libmesh_real((*this)(i,j));
          my_min = (my_min < current? my_min : current);
        }
    }
  return my_min;
}

multiply()

template<typename T>

static void libMesh::DenseMatrixBase< T >::multiply ( DenseMatrixBase< T > &  M1, const DenseMatrixBase< T > &  M2, const DenseMatrixBase< T > &  M3  )

staticprotectedinherited

Helper function - Performs the computation M1 = M2 * M3 where: M1 = (m x n) M2 = (m x p) M3 = (p x n)

n()

template<typename T>

unsigned int libMesh::DenseMatrixBase< T >::n ( ) const

inherited

Returns

The column-dimension of the matrix.

Definition at line 107 of file dense_matrix_base.h.

References libMesh::DenseMatrixBase< T >::_n.

Referenced by libMesh::DenseMatrixBase< T >::add(), libMesh::DenseMatrix< Real >::get_transpose(), libMesh::DenseMatrix< Real >::left_multiply(), libMesh::DenseMatrix< Real >::left_multiply_transpose(), libMesh::DenseMatrix< Real >::right_multiply(), and libMesh::DenseMatrix< Real >::right_multiply_transpose().

{ return _n; }

operator!=()

template<typename T>

bool libMesh::DenseMatrix< T >::operator!=

(

const DenseMatrix< T > &

mat

)

const

Returns

true if mat is not exactly equal to this matrix, false otherwise.

Definition at line 912 of file dense_matrix.h.

{
  for (std::size_t i=0; i<_val.size(); i++)
    if (_val[i] != mat._val[i])
      return true;

  return false;
}

operator()() [1/2]

template<typename T >

T libMesh::DenseMatrix< T >::operator()	(	const unsigned int	i,
		const unsigned int	j
	)		const

Returns

The (i,j) element of the matrix.

Definition at line 819 of file dense_matrix.h.

{
  libmesh_assert_less (i*j, _val.size());
  libmesh_assert_less (i, this->_m);
  libmesh_assert_less (j, this->_n);


  //  return _val[(i) + (this->_m)*(j)]; // col-major
  return _val[(i)*(this->_n) + (j)]; // row-major
}

operator()() [2/2]

template<typename T >

T & libMesh::DenseMatrix< T >::operator()	(	const unsigned int	i,
		const unsigned int	j
	)

Returns

The (i,j) element of the matrix as a writable reference.

Definition at line 835 of file dense_matrix.h.

{
  libmesh_assert_less (i*j, _val.size());
  libmesh_assert_less (i, this->_m);
  libmesh_assert_less (j, this->_n);

  //return _val[(i) + (this->_m)*(j)]; // col-major
  return _val[(i)*(this->_n) + (j)]; // row-major
}

operator*=()

template<typename T>

DenseMatrix< T > & libMesh::DenseMatrix< T >::operator*=

(

const T

factor

)

Multiplies every element in the matrix by factor.

Returns

A reference to *this.

Definition at line 871 of file dense_matrix.h.

{
  this->scale(factor);
  return *this;
}

operator+=()

template<typename T>

DenseMatrix< T > & libMesh::DenseMatrix< T >::operator+=

(

const DenseMatrix< T > &

mat

)

Adds mat to this matrix.

Returns

A reference to *this.

Definition at line 925 of file dense_matrix.h.

{
  for (std::size_t i=0; i<_val.size(); i++)
    _val[i] += mat._val[i];

  return *this;
}

operator-=()

template<typename T>

DenseMatrix< T > & libMesh::DenseMatrix< T >::operator-=

(

const DenseMatrix< T > &

mat

)

Subtracts mat from this matrix.

Returns

A reference to *this.

Definition at line 937 of file dense_matrix.h.

{
  for (std::size_t i=0; i<_val.size(); i++)
    _val[i] -= mat._val[i];

  return *this;
}

operator=() [1/3]

template<typename T>

DenseMatrix& libMesh::DenseMatrix< T >::operator= ( const DenseMatrix< T > &  )

default

operator=() [2/3]

template<typename T>

DenseMatrix& libMesh::DenseMatrix< T >::operator= ( DenseMatrix< T > &&  )

default

operator=() [3/3]

template<typename T >

template<typename T2 >

DenseMatrix< T > & libMesh::DenseMatrix< T >::operator=

(

const DenseMatrix< T2 > &

other_matrix

)

Assignment-from-other-matrix-type operator.

Copies the dense matrix of type T2 into the present matrix. This is useful for copying real matrices into complex ones for further operations.

Returns

A reference to *this.

Definition at line 777 of file dense_matrix.h.

{
  unsigned int mat_m = mat.m(), mat_n = mat.n();
  this->resize(mat_m, mat_n);
  for (unsigned int i=0; i<mat_m; i++)
    for (unsigned int j=0; j<mat_n; j++)
      (*this)(i,j) = mat(i,j);

  return *this;
}

operator==()

template<typename T>

bool libMesh::DenseMatrix< T >::operator==

(

const DenseMatrix< T > &

mat

)

const

Returns

true if mat is exactly equal to this matrix, false otherwise.

Definition at line 899 of file dense_matrix.h.

{
  for (std::size_t i=0; i<_val.size(); i++)
    if (_val[i] != mat._val[i])
      return false;

  return true;
}

outer_product()

template<typename T>

void libMesh::DenseMatrix< T >::outer_product	(	const DenseVector< T > &	a,
		const DenseVector< T > &	b
	)

Computes the outer (dyadic) product of two vectors and stores in (*this).

The outer product of two real-valued vectors and is

The outer product of two complex-valued vectors and is

where denotes the conjugate transpose of the vector and denotes the complex conjugate.

Parameters

[in]	a	Vector whose entries correspond to rows in the product matrix.
[in]	b	Vector whose entries correspond to columns in the product matrix.

Definition at line 571 of file dense_matrix_impl.h.

{
  const unsigned int m = a.size();
  const unsigned int n = b.size();

  this->resize(m, n);
  for (unsigned int i = 0; i < m; ++i)
    for (unsigned int j = 0; j < n; ++j)
      (*this)(i,j) = a(i) * libmesh_conj(b(j));
}

print()

template<typename T>

void libMesh::DenseMatrixBase< T >::print ( std::ostream &  os = libMesh::out ) const

inherited

Pretty-print the matrix, by default to libMesh::out.

print_scientific()

template<typename T>

void libMesh::DenseMatrixBase< T >::print_scientific ( std::ostream &  os, unsigned  precision = 8  ) const

inherited

Prints the matrix entries with more decimal places in scientific notation.

resize()

template<typename T >

void libMesh::DenseMatrix< T >::resize	(	const unsigned int	new_m,
		const unsigned int	new_n
	)

Resize the matrix.

Will never free memory, but may allocate more. Sets all elements to 0.

Definition at line 792 of file dense_matrix.h.

Referenced by libMesh::DenseMatrix< Real >::_lu_decompose(), libMesh::DenseMatrix< Real >::get_principal_submatrix(), libMesh::DenseMatrix< Real >::get_transpose(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::operator()(), and libMesh::DenseMatrix< Real >::resize().

{
  _val.resize(new_m*new_n);

  this->_m = new_m;
  this->_n = new_n;

  // zero and set decomposition_type to NONE
  this->zero();
}

right_multiply() [1/2]

template<typename T>

void libMesh::DenseMatrix< T >::right_multiply ( const DenseMatrixBase< T > &  M3 )

overridevirtual

Performs the operation: (*this) <- (*this) * M3.

Implements libMesh::DenseMatrixBase< T >.

Definition at line 213 of file dense_matrix_impl.h.

{
  if (this->use_blas_lapack)
    this->_multiply_blas(M3, RIGHT_MULTIPLY);
  else
    {
      // (*this) <- M3 * (*this)
      // Where:
      // (*this) = (m x n),
      // M2      = (m x p),
      // M3      = (p x n)

      // M2 is a copy of *this before it gets resize()d
      DenseMatrix<T> M2(*this);

      // Resize *this so that the result can fit
      this->resize (M2.m(), M3.n());

      this->multiply(*this, M2, M3);
    }
}

right_multiply() [2/2]

template<typename T >

template<typename T2 >

void libMesh::DenseMatrix< T >::right_multiply

(

const DenseMatrixBase< T2 > &

M2

)

Right multiplies by the matrix M2 of different type.

Definition at line 239 of file dense_matrix_impl.h.

{
  // (*this) <- M3 * (*this)
  // Where:
  // (*this) = (m x n),
  // M2      = (m x p),
  // M3      = (p x n)

  // M2 is a copy of *this before it gets resize()d
  DenseMatrix<T> M2(*this);

  // Resize *this so that the result can fit
  this->resize (M2.m(), M3.n());

  this->multiply(*this, M2, M3);
}

right_multiply_transpose() [1/2]

template<typename T>

void libMesh::DenseMatrix< T >::right_multiply_transpose

(

const DenseMatrix< T > &

A

)

Right multiplies by the transpose of the matrix A.

Definition at line 260 of file dense_matrix_impl.h.

{
  if (this->use_blas_lapack)
    this->_multiply_blas(B, RIGHT_MULTIPLY_TRANSPOSE);
  else
    {
      //Check to see if we are doing B*(B^T)
      if (this == &B)
        {
          //libmesh_here();
          DenseMatrix<T> A(*this);

          // Simple but inefficient way
          // return this->right_multiply_transpose(A);

          // More efficient, more code
          // If B is mxn, the result will be a square matrix of Size m x m.
          const unsigned int n_rows = B.m();
          const unsigned int n_cols = B.n();

          // resize() *this and also zero out all entries.
          this->resize(n_rows,n_rows);

          // Compute the lower-triangular part
          for (unsigned int i=0; i<n_rows; ++i)
            for (unsigned int j=0; j<=i; ++j)
              for (unsigned int k=0; k<n_cols; ++k) // inner products are over n_cols
                (*this)(i,j) += A(i,k)*A(j,k);

          // Copy lower-triangular part into upper-triangular part
          for (unsigned int i=0; i<n_rows; ++i)
            for (unsigned int j=i+1; j<n_rows; ++j)
              (*this)(i,j) = (*this)(j,i);
        }

      else
        {
          DenseMatrix<T> A(*this);

          this->resize (A.m(), B.m());

          libmesh_assert_equal_to (A.n(), B.n());
          libmesh_assert_equal_to (this->m(), A.m());
          libmesh_assert_equal_to (this->n(), B.m());

          const unsigned int m_s = A.m();
          const unsigned int p_s = A.n();
          const unsigned int n_s = this->n();

          // Do it this way because there is a
          // decent chance (at least for constraint matrices)
          // that B.transpose(k,j) = 0.
          for (unsigned int j=0; j<n_s; j++)
            for (unsigned int k=0; k<p_s; k++)
              if (B.transpose(k,j) != 0.)
                for (unsigned int i=0; i<m_s; i++)
                  (*this)(i,j) += A(i,k)*B.transpose(k,j);
        }
    }
}

right_multiply_transpose() [2/2]

template<typename T >

template<typename T2 >

void libMesh::DenseMatrix< T >::right_multiply_transpose

(

const DenseMatrix< T2 > &

A

)

Right multiplies by the transpose of the matrix A which contains a different numerical type.

Definition at line 325 of file dense_matrix_impl.h.

{
  //Check to see if we are doing B*(B^T)
  if (this == &B)
    {
      //libmesh_here();
      DenseMatrix<T> A(*this);

      // Simple but inefficient way
      // return this->right_multiply_transpose(A);

      // More efficient, more code
      // If B is mxn, the result will be a square matrix of Size m x m.
      const unsigned int n_rows = B.m();
      const unsigned int n_cols = B.n();

      // resize() *this and also zero out all entries.
      this->resize(n_rows,n_rows);

      // Compute the lower-triangular part
      for (unsigned int i=0; i<n_rows; ++i)
        for (unsigned int j=0; j<=i; ++j)
          for (unsigned int k=0; k<n_cols; ++k) // inner products are over n_cols
            (*this)(i,j) += A(i,k)*A(j,k);

      // Copy lower-triangular part into upper-triangular part
      for (unsigned int i=0; i<n_rows; ++i)
        for (unsigned int j=i+1; j<n_rows; ++j)
          (*this)(i,j) = (*this)(j,i);
    }

  else
    {
      DenseMatrix<T> A(*this);

      this->resize (A.m(), B.m());

      libmesh_assert_equal_to (A.n(), B.n());
      libmesh_assert_equal_to (this->m(), A.m());
      libmesh_assert_equal_to (this->n(), B.m());

      const unsigned int m_s = A.m();
      const unsigned int p_s = A.n();
      const unsigned int n_s = this->n();

      // Do it this way because there is a
      // decent chance (at least for constraint matrices)
      // that B.transpose(k,j) = 0.
      for (unsigned int j=0; j<n_s; j++)
        for (unsigned int k=0; k<p_s; k++)
          if (B.transpose(k,j) != 0.)
            for (unsigned int i=0; i<m_s; i++)
              (*this)(i,j) += A(i,k)*B.transpose(k,j);
    }
}

scale()

template<typename T>

void libMesh::DenseMatrix< T >::scale

(

const T

factor

)

Multiplies every element in the matrix by factor.

Definition at line 852 of file dense_matrix.h.

{
  for (std::size_t i=0; i<_val.size(); i++)
    _val[i] *= factor;
}

scale_column()

template<typename T>

void libMesh::DenseMatrix< T >::scale_column	(	const unsigned int	col,
		const T	factor
	)

Multiplies every element in the column col matrix by factor.

Definition at line 861 of file dense_matrix.h.

{
  for (unsigned int i=0; i<this->m(); i++)
    (*this)(i, col) *= factor;
}

svd() [1/2]

template<typename T >

void libMesh::DenseMatrix< T >::svd

(

DenseVector< Real > &

sigma

)

Compute the singular value decomposition of the matrix.

On exit, sigma holds all of the singular values (in descending order).

The implementation uses PETSc's interface to BLAS/LAPACK. If this is not available, this function throws an error.

Definition at line 795 of file dense_matrix_impl.h.

{
  // We use the LAPACK svd implementation
  _svd_lapack(sigma);
}

svd() [2/2]

template<typename T >

void libMesh::DenseMatrix< T >::svd	(	DenseVector< Real > &	sigma,
		DenseMatrix< Number > &	U,
		DenseMatrix< Number > &	VT
	)

Compute the "reduced" singular value decomposition of the matrix.

On exit, sigma holds all of the singular values (in descending order), U holds the left singular vectors, and VT holds the transpose of the right singular vectors. In the reduced SVD, U has min(m,n) columns and VT has min(m,n) rows. (In the "full" SVD, U and VT would be square.)

The implementation uses PETSc's interface to BLAS/LAPACK. If this is not available, this function throws an error.

Definition at line 803 of file dense_matrix_impl.h.

{
  // We use the LAPACK svd implementation
  _svd_lapack(sigma, U, VT);
}

svd_solve()

template<typename T>

void libMesh::DenseMatrix< T >::svd_solve	(	const DenseVector< T > &	rhs,
		DenseVector< T > &	x,
		Real	rcond = std::numeric_limits<Real>::epsilon()
	)		const

Solve the system of equations for in the least-squares sense.

may be non-square and/or rank-deficient. You can control which singular values are treated as zero by changing the "rcond" parameter. Singular values S(i) for which S(i) <= rcond*S(1) are treated as zero for purposes of the solve. Passing a negative number for rcond forces a "machine precision" value to be used instead.

This function is marked const, since due to various implementation details, we do not need to modify the contents of A in order to compute the SVD (a copy is made internally instead).

Requires PETSc >= 3.1 since this was the first version to provide the LAPACKgelss_ wrapper.

Definition at line 814 of file dense_matrix_impl.h.

{
  _svd_solve_lapack(rhs, x, rcond);
}

swap()

template<typename T>

void libMesh::DenseMatrix< T >::swap

(

DenseMatrix< T > &

other_matrix

)

STL-like swap method.

Definition at line 762 of file dense_matrix.h.

{
  std::swap(this->_m, other_matrix._m);
  std::swap(this->_n, other_matrix._n);
  _val.swap(other_matrix._val);
  DecompositionType _temp = _decomposition_type;
  _decomposition_type = other_matrix._decomposition_type;
  other_matrix._decomposition_type = _temp;
}

transpose()

template<typename T >

T libMesh::DenseMatrix< T >::transpose	(	const unsigned int	i,
		const unsigned int	j
	)		const

Returns

The (i,j) element of the transposed matrix.

Definition at line 1045 of file dense_matrix.h.

Referenced by libMesh::DenseMatrix< Real >::left_multiply_transpose().

{
  // Implement in terms of operator()
  return (*this)(j,i);
}

vector_mult() [1/2]

template<typename T>

void libMesh::DenseMatrix< T >::vector_mult	(	DenseVector< T > &	dest,
		const DenseVector< T > &	arg
	)		const

Performs the matrix-vector multiplication, dest := (*this) * arg.

Definition at line 385 of file dense_matrix_impl.h.

{
  // Make sure the input sizes are compatible
  libmesh_assert_equal_to (this->n(), arg.size());

  // Resize and clear dest.
  // Note: DenseVector::resize() also zeros the vector.
  dest.resize(this->m());

  // Short-circuit if the matrix is empty
  if(this->m() == 0 || this->n() == 0)
    return;

  if (this->use_blas_lapack)
    this->_matvec_blas(1., 0., dest, arg);
  else
    {
      const unsigned int n_rows = this->m();
      const unsigned int n_cols = this->n();

      for (unsigned int i=0; i<n_rows; i++)
        for (unsigned int j=0; j<n_cols; j++)
          dest(i) += (*this)(i,j)*arg(j);
    }
}

vector_mult() [2/2]

template<typename T>

template<typename T2 >

void libMesh::DenseMatrix< T >::vector_mult	(	DenseVector< typename CompareTypes< T, T2 >::supertype > &	dest,
		const DenseVector< T2 > &	arg
	)		const

Performs the matrix-vector multiplication, dest := (*this) * arg on mixed types.

Definition at line 416 of file dense_matrix_impl.h.

{
  // Make sure the input sizes are compatible
  libmesh_assert_equal_to (this->n(), arg.size());

  // Resize and clear dest.
  // Note: DenseVector::resize() also zeros the vector.
  dest.resize(this->m());

  // Short-circuit if the matrix is empty
  if (this->m() == 0 || this->n() == 0)
    return;

  const unsigned int n_rows = this->m();
  const unsigned int n_cols = this->n();

  for (unsigned int i=0; i<n_rows; i++)
    for (unsigned int j=0; j<n_cols; j++)
      dest(i) += (*this)(i,j)*arg(j);
}

vector_mult_add() [1/2]

template<typename T>

void libMesh::DenseMatrix< T >::vector_mult_add	(	DenseVector< T > &	dest,
		const T	factor,
		const DenseVector< T > &	arg
	)		const

Performs the scaled matrix-vector multiplication, dest += factor * (*this) * arg.

Definition at line 511 of file dense_matrix_impl.h.

{
  // Short-circuit if the matrix is empty
  if (this->m() == 0)
    {
      dest.resize(0);
      return;
    }

  if (this->use_blas_lapack)
    this->_matvec_blas(factor, 1., dest, arg);
  else
    {
      DenseVector<T> temp(arg.size());
      this->vector_mult(temp, arg);
      dest.add(factor, temp);
    }
}

vector_mult_add() [2/2]

template<typename T>

template<typename T2 , typename T3 >

void libMesh::DenseMatrix< T >::vector_mult_add	(	DenseVector< typename CompareTypes< T, typename CompareTypes< T2, T3 >::supertype >::supertype > &	dest,
		const T2	factor,
		const DenseVector< T3 > &	arg
	)		const

Performs the scaled matrix-vector multiplication, dest += factor * (*this) * arg.

on mixed types

Definition at line 536 of file dense_matrix_impl.h.

{
  // Short-circuit if the matrix is empty
  if (this->m() == 0)
    {
      dest.resize(0);
      return;
    }

  DenseVector<typename CompareTypes<T,T3>::supertype>
    temp(arg.size());
  this->vector_mult(temp, arg);
  dest.add(factor, temp);
}

vector_mult_transpose() [1/2]

template<typename T>

void libMesh::DenseMatrix< T >::vector_mult_transpose	(	DenseVector< T > &	dest,
		const DenseVector< T > &	arg
	)		const

Performs the matrix-vector multiplication, dest := (*this)^T * arg.

Definition at line 441 of file dense_matrix_impl.h.

{
  // Make sure the input sizes are compatible
  libmesh_assert_equal_to (this->m(), arg.size());

  // Resize and clear dest.
  // Note: DenseVector::resize() also zeros the vector.
  dest.resize(this->n());

  // Short-circuit if the matrix is empty
  if (this->m() == 0)
    return;

  if (this->use_blas_lapack)
    {
      this->_matvec_blas(1., 0., dest, arg, /*trans=*/true);
    }
  else
    {
      const unsigned int n_rows = this->m();
      const unsigned int n_cols = this->n();

      // WORKS
      // for (unsigned int j=0; j<n_cols; j++)
      //   for (unsigned int i=0; i<n_rows; i++)
      //     dest(j) += (*this)(i,j)*arg(i);

      // ALSO WORKS, (i,j) just swapped
      for (unsigned int i=0; i<n_cols; i++)
        for (unsigned int j=0; j<n_rows; j++)
          dest(i) += (*this)(j,i)*arg(j);
    }
}

vector_mult_transpose() [2/2]

template<typename T>

template<typename T2 >

void libMesh::DenseMatrix< T >::vector_mult_transpose	(	DenseVector< typename CompareTypes< T, T2 >::supertype > &	dest,
		const DenseVector< T2 > &	arg
	)		const

Performs the matrix-vector multiplication, dest := (*this)^T * arg.

on mixed types

Definition at line 480 of file dense_matrix_impl.h.

{
  // Make sure the input sizes are compatible
  libmesh_assert_equal_to (this->m(), arg.size());

  // Resize and clear dest.
  // Note: DenseVector::resize() also zeros the vector.
  dest.resize(this->n());

  // Short-circuit if the matrix is empty
  if (this->m() == 0)
    return;

  const unsigned int n_rows = this->m();
  const unsigned int n_cols = this->n();

  // WORKS
  // for (unsigned int j=0; j<n_cols; j++)
  //   for (unsigned int i=0; i<n_rows; i++)
  //     dest(j) += (*this)(i,j)*arg(i);

  // ALSO WORKS, (i,j) just swapped
  for (unsigned int i=0; i<n_cols; i++)
    for (unsigned int j=0; j<n_rows; j++)
      dest(i) += (*this)(j,i)*arg(j);
}

zero()

template<typename T >

void libMesh::DenseMatrix< T >::zero ( )

overridevirtual

Set every element in the matrix to 0.

You must redefine what you mean by zeroing the matrix since it depends on how your values are stored.

Implements libMesh::DenseMatrixBase< T >.

Definition at line 808 of file dense_matrix.h.

Referenced by libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::operator()().

{
  _decomposition_type = NONE;

  std::fill (_val.begin(), _val.end(), static_cast<T>(0));
}

Member Data Documentation

_decomposition_type

template<typename T>

DecompositionType libMesh::DenseMatrix< T >::_decomposition_type

private

This flag keeps track of which type of decomposition has been performed on the matrix.

Definition at line 582 of file dense_matrix.h.

_m

template<typename T>

unsigned int libMesh::DenseMatrixBase< T >::_m

protectedinherited

The row dimension.

Definition at line 169 of file dense_matrix_base.h.

Referenced by libMesh::DenseMatrixBase< T >::m().

_n

template<typename T>

unsigned int libMesh::DenseMatrixBase< T >::_n

protectedinherited

The column dimension.

Definition at line 174 of file dense_matrix_base.h.

Referenced by libMesh::DenseMatrixBase< T >::n().

_pivots

template<typename T>

std::vector<pivot_index_t> libMesh::DenseMatrix< T >::_pivots

private

Definition at line 672 of file dense_matrix.h.

_val

template<typename T>

std::vector<T> libMesh::DenseMatrix< T >::_val

private

The actual data values, stored as a 1D array.

Definition at line 532 of file dense_matrix.h.

Referenced by libMesh::DenseMatrix< Real >::get_values().

use_blas_lapack

template<typename T>

bool libMesh::DenseMatrix< T >::use_blas_lapack

Computes the inverse of the dense matrix (assuming it is invertible) by first computing the LU decomposition and then performing multiple back substitution steps.

Follows the algorithm from Numerical Recipes in C that is available on the web.

This routine is commented out since it is not really a memory- or computationally- efficient implementation. Also, you typically don't need the actual inverse for anything, and can use something like lu_solve() instead. Run-time selectable option to turn on/off BLAS support. This was primarily used for testing purposes, and could be removed...

Definition at line 525 of file dense_matrix.h.

---

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

• include/base/dof_map.h
• include/numerics/dense_matrix.h
• include/numerics/dense_matrix_impl.h