Eigen::SPQR< MatrixType_ > Class Template Reference

Sparse QR factorization based on SuiteSparseQR library. More...

#include <SuiteSparseQRSupport.h>

Inheritance diagram for Eigen::SPQR< MatrixType_ >:

Public Types
enum	{ ColsAtCompileTime = Dynamic , MaxColsAtCompileTime = Dynamic }
typedef MatrixType_::Scalar	Scalar
typedef MatrixType_::RealScalar	RealScalar
typedef SuiteSparse_long	StorageIndex
typedef SparseMatrix< Scalar, ColMajor, StorageIndex >	MatrixType
typedef Map< PermutationMatrix< Dynamic, Dynamic, StorageIndex > >	PermutationType

Public Member Functions
	SPQR ()
	SPQR (const MatrixType_ &matrix)
	~SPQR ()
void	SPQR_free ()
void	compute (const MatrixType_ &matrix)
Index	rows () const
Index	cols () const
template<typename Rhs , typename Dest >
void	_solve_impl (const MatrixBase< Rhs > &b, MatrixBase< Dest > &dest) const
const MatrixType	matrixR () const
SPQRMatrixQReturnType< SPQR >	matrixQ () const
	Get an expression of the matrix Q. More...
PermutationType	colsPermutation () const
	Get the permutation that was applied to columns of A. More...
Index	rank () const
void	setSPQROrdering (int ord)
	Set the fill-reducing ordering method to be used. More...
void	setPivotThreshold (const RealScalar &tol)
	Set the tolerance tol to treat columns with 2-norm < =tol as zero. More...
cholmod_common *	cholmodCommon () const
ComputationInfo	info () const
	Reports whether previous computation was successful. More...
Public Member Functions inherited from Eigen::SparseSolverBase< SPQR< MatrixType_ > >
	SparseSolverBase ()
	SparseSolverBase (SparseSolverBase &&other)
	~SparseSolverBase ()
SPQR< MatrixType_ > &	derived ()
const SPQR< MatrixType_ > &	derived () const
const Solve< SPQR< MatrixType_ >, Rhs >	solve (const MatrixBase< Rhs > &b) const
const Solve< SPQR< MatrixType_ >, Rhs >	solve (const SparseMatrixBase< Rhs > &b) const
void	_solve_impl (const SparseMatrixBase< Rhs > &b, SparseMatrixBase< Dest > &dest) const

Protected Types
typedef SparseSolverBase< SPQR< MatrixType_ > >	Base

Protected Attributes
bool	m_analysisIsOk
bool	m_factorizationIsOk
bool	m_isRUpToDate
ComputationInfo	m_info
int	m_ordering
int	m_allow_tol
RealScalar	m_tolerance
cholmod_sparse *	m_cR = nullptr
MatrixType	m_R
StorageIndex *	m_E = nullptr
cholmod_sparse *	m_H = nullptr
StorageIndex *	m_HPinv = nullptr
cholmod_dense *	m_HTau = nullptr
Index	m_rank
cholmod_common	m_cc
bool	m_useDefaultThreshold
Index	m_rows
Protected Attributes inherited from Eigen::SparseSolverBase< SPQR< MatrixType_ > >
bool	m_isInitialized

Friends
template<typename , typename >
struct	SPQR_QProduct

Detailed Description

template<typename MatrixType_>
class Eigen::SPQR< MatrixType_ >

Sparse QR factorization based on SuiteSparseQR library.

This class is used to perform a multithreaded and multifrontal rank-revealing QR decomposition of sparse matrices. The result is then used to solve linear leasts_square systems. Clearly, a QR factorization is returned such that A*P = Q*R where :

P is the column permutation. Use colsPermutation() to get it.

Q is the orthogonal matrix represented as Householder reflectors. Use matrixQ() to get an expression and matrixQ().transpose() to get the transpose. You can then apply it to a vector.

R is the sparse triangular factor. Use matrixQR() to get it as SparseMatrix. NOTE : The Index type of R is always SuiteSparse_long. You can get it with SPQR::Index

Template Parameters

MatrixType_

The type of the sparse matrix A, must be a column-major SparseMatrix<>

\implsparsesolverconcept

Member Typedef Documentation

Base

template<typename MatrixType_ >

typedef SparseSolverBase<SPQR<MatrixType_> > Eigen::SPQR< MatrixType_ >::Base

protected

MatrixType

template<typename MatrixType_ >

typedef SparseMatrix<Scalar, ColMajor, StorageIndex> Eigen::SPQR< MatrixType_ >::MatrixType

PermutationType

template<typename MatrixType_ >

typedef Map<PermutationMatrix<Dynamic, Dynamic, StorageIndex> > Eigen::SPQR< MatrixType_ >::PermutationType

RealScalar

template<typename MatrixType_ >

typedef MatrixType_::RealScalar Eigen::SPQR< MatrixType_ >::RealScalar

Scalar

template<typename MatrixType_ >

typedef MatrixType_::Scalar Eigen::SPQR< MatrixType_ >::Scalar

StorageIndex

template<typename MatrixType_ >

typedef SuiteSparse_long Eigen::SPQR< MatrixType_ >::StorageIndex

Member Enumeration Documentation

anonymous enum

template<typename MatrixType_ >

anonymous enum

Enumerator
ColsAtCompileTime
MaxColsAtCompileTime

{ ColsAtCompileTime = Dynamic, MaxColsAtCompileTime = Dynamic };

Constructor & Destructor Documentation

SPQR() [1/2]

template<typename MatrixType_ >

Eigen::SPQR< MatrixType_ >::SPQR ( )

inline

      : m_analysisIsOk(false),
        m_factorizationIsOk(false),
        m_isRUpToDate(false),
        m_ordering(SPQR_ORDERING_DEFAULT),
        m_allow_tol(SPQR_DEFAULT_TOL),
        m_tolerance(NumTraits<Scalar>::epsilon()),
        m_cR(0),
        m_E(0),
        m_H(0),
        m_HPinv(0),
        m_HTau(0),
        m_useDefaultThreshold(true) {
    cholmod_l_start(&m_cc);
  }

References Eigen::SPQR< MatrixType_ >::m_cc.

SPQR() [2/2]

template<typename MatrixType_ >

Eigen::SPQR< MatrixType_ >::SPQR ( const MatrixType_ &  matrix )

inlineexplicit

      : m_analysisIsOk(false),
        m_factorizationIsOk(false),
        m_isRUpToDate(false),
        m_ordering(SPQR_ORDERING_DEFAULT),
        m_allow_tol(SPQR_DEFAULT_TOL),
        m_tolerance(NumTraits<Scalar>::epsilon()),
        m_cR(0),
        m_E(0),
        m_H(0),
        m_HPinv(0),
        m_HTau(0),
        m_useDefaultThreshold(true) {
    cholmod_l_start(&m_cc);
    compute(matrix);
  }

References Eigen::SPQR< MatrixType_ >::compute(), Eigen::SPQR< MatrixType_ >::m_cc, and matrix().

~SPQR()

template<typename MatrixType_ >

Eigen::SPQR< MatrixType_ >::~SPQR ( )

inline

          {
    SPQR_free();
    cholmod_l_finish(&m_cc);
  }

References Eigen::SPQR< MatrixType_ >::m_cc, and Eigen::SPQR< MatrixType_ >::SPQR_free().

Member Function Documentation

_solve_impl()

template<typename MatrixType_ >

template<typename Rhs , typename Dest >

void Eigen::SPQR< MatrixType_ >::_solve_impl ( const MatrixBase< Rhs > &  b, MatrixBase< Dest > &  dest  ) const

inline

                                                                           {
    eigen_assert(m_isInitialized && " The QR factorization should be computed first, call compute()");
    eigen_assert(b.cols() == 1 && "This method is for vectors only");
 
    // Compute Q^T * b
    typename Dest::PlainObject y, y2;
    y = matrixQ().transpose() * b;
 
    // Solves with the triangular matrix R
    Index rk = this->rank();
    y2 = y;
    y.resize((std::max)(cols(), Index(y.rows())), y.cols());
    y.topRows(rk) = this->matrixR().topLeftCorner(rk, rk).template triangularView<Upper>().solve(y2.topRows(rk));
 
    // Apply the column permutation
    // colsPermutation() performs a copy of the permutation,
    // so let's apply it manually:
    for (Index i = 0; i < rk; ++i) dest.row(m_E[i]) = y.row(i);
    for (Index i = rk; i < cols(); ++i) dest.row(m_E[i]).setZero();
 
    //       y.bottomRows(y.rows()-rk).setZero();
    //       dest = colsPermutation() * y.topRows(cols());
 
    m_info = Success;
  }

References b, Eigen::SPQR< MatrixType_ >::cols(), eigen_assert, i, Eigen::SPQR< MatrixType_ >::m_E, Eigen::SPQR< MatrixType_ >::m_info, Eigen::SparseSolverBase< SPQR< MatrixType_ > >::m_isInitialized, Eigen::SPQR< MatrixType_ >::matrixQ(), Eigen::SPQR< MatrixType_ >::matrixR(), max, Eigen::SPQR< MatrixType_ >::rank(), Eigen::DenseBase< Derived >::setZero(), Eigen::Success, and y.

cholmodCommon()

template<typename MatrixType_ >

cholmod_common* Eigen::SPQR< MatrixType_ >::cholmodCommon ( ) const

inline

Returns

a pointer to the SPQR workspace

{ return &m_cc; }

References Eigen::SPQR< MatrixType_ >::m_cc.

cols()

template<typename MatrixType_ >

Index Eigen::SPQR< MatrixType_ >::cols ( ) const

inline

Get the number of columns of the input matrix.

{ return m_cR->ncol; }

References Eigen::SPQR< MatrixType_ >::m_cR.

Referenced by gdb.printers._MatrixEntryIterator::__next__(), Eigen::SPQR< MatrixType_ >::_solve_impl(), gdb.printers.EigenMatrixPrinter::children(), gdb.printers.EigenSparseMatrixPrinter::children(), gdb.printers.EigenMatrixPrinter::to_string(), and gdb.printers.EigenSparseMatrixPrinter::to_string().

colsPermutation()

template<typename MatrixType_ >

PermutationType Eigen::SPQR< MatrixType_ >::colsPermutation ( ) const

inline

Get the permutation that was applied to columns of A.

                                          {
    eigen_assert(m_isInitialized && "Decomposition is not initialized.");
    return PermutationType(m_E, m_cR->ncol);
  }

References eigen_assert, Eigen::SPQR< MatrixType_ >::m_cR, Eigen::SPQR< MatrixType_ >::m_E, and Eigen::SparseSolverBase< SPQR< MatrixType_ > >::m_isInitialized.

compute()

template<typename MatrixType_ >

void Eigen::SPQR< MatrixType_ >::compute ( const MatrixType_ &  matrix )

inline

                                          {
    if (m_isInitialized) SPQR_free();
 
    MatrixType mat(matrix);
 
    /* Compute the default threshold as in MatLab, see:
     * Tim Davis, "Algorithm 915, SuiteSparseQR: Multifrontal Multithreaded Rank-Revealing
     * Sparse QR Factorization, ACM Trans. on Math. Soft. 38(1), 2011, Page 8:3
     */
    RealScalar pivotThreshold = m_tolerance;
    if (m_useDefaultThreshold) {
      RealScalar max2Norm = 0.0;
      for (int j = 0; j < mat.cols(); j++) max2Norm = numext::maxi(max2Norm, mat.col(j).norm());
      if (numext::is_exactly_zero(max2Norm)) max2Norm = RealScalar(1);
      pivotThreshold = 20 * (mat.rows() + mat.cols()) * max2Norm * NumTraits<RealScalar>::epsilon();
    }
    cholmod_sparse A;
    A = viewAsCholmod(mat);
    m_rows = matrix.rows();
    m_rank = SuiteSparseQR<Scalar>(m_ordering, pivotThreshold, internal::convert_index<StorageIndex>(matrix.cols()), &A,
                                   &m_cR, &m_E, &m_H, &m_HPinv, &m_HTau, &m_cc);
 
    if (!m_cR) {
      m_info = NumericalIssue;
      m_isInitialized = false;
      return;
    }
    m_info = Success;
    m_isInitialized = true;
    m_isRUpToDate = false;
  }

References Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::cols(), Eigen::numext::is_exactly_zero(), j, Eigen::SPQR< MatrixType_ >::m_cc, Eigen::SPQR< MatrixType_ >::m_cR, Eigen::SPQR< MatrixType_ >::m_E, Eigen::SPQR< MatrixType_ >::m_H, Eigen::SPQR< MatrixType_ >::m_HPinv, Eigen::SPQR< MatrixType_ >::m_HTau, Eigen::SPQR< MatrixType_ >::m_info, Eigen::SparseSolverBase< SPQR< MatrixType_ > >::m_isInitialized, Eigen::SPQR< MatrixType_ >::m_isRUpToDate, Eigen::SPQR< MatrixType_ >::m_ordering, Eigen::SPQR< MatrixType_ >::m_rank, Eigen::SPQR< MatrixType_ >::m_rows, Eigen::SPQR< MatrixType_ >::m_tolerance, Eigen::SPQR< MatrixType_ >::m_useDefaultThreshold, matrix(), Eigen::numext::maxi(), Eigen::SparseMatrixBase< Derived >::norm(), Eigen::NumericalIssue, Eigen::SparseMatrix< Scalar_, Options_, StorageIndex_ >::rows(), Eigen::SPQR< MatrixType_ >::SPQR_free(), Eigen::Success, and Eigen::viewAsCholmod().

Referenced by Eigen::SPQR< MatrixType_ >::SPQR().

info()

template<typename MatrixType_ >

ComputationInfo Eigen::SPQR< MatrixType_ >::info ( ) const

inline

Reports whether previous computation was successful.

Returns

Success if computation was successful, NumericalIssue if the sparse QR can not be computed

                               {
    eigen_assert(m_isInitialized && "Decomposition is not initialized.");
    return m_info;
  }

References eigen_assert, Eigen::SPQR< MatrixType_ >::m_info, and Eigen::SparseSolverBase< SPQR< MatrixType_ > >::m_isInitialized.

matrixQ()

template<typename MatrixType_ >

SPQRMatrixQReturnType<SPQR> Eigen::SPQR< MatrixType_ >::matrixQ ( void  ) const

inline

Get an expression of the matrix Q.

{ return SPQRMatrixQReturnType<SPQR>(*this); }

Referenced by Eigen::SPQR< MatrixType_ >::_solve_impl().

matrixR()

template<typename MatrixType_ >

const MatrixType Eigen::SPQR< MatrixType_ >::matrixR ( ) const

inline

Returns

the sparse triangular factor R. It is a sparse matrix

                                   {
    eigen_assert(m_isInitialized && " The QR factorization should be computed first, call compute()");
    if (!m_isRUpToDate) {
      m_R = viewAsEigen<Scalar, StorageIndex>(*m_cR);
      m_isRUpToDate = true;
    }
    return m_R;
  }

References eigen_assert, Eigen::SPQR< MatrixType_ >::m_cR, Eigen::SparseSolverBase< SPQR< MatrixType_ > >::m_isInitialized, Eigen::SPQR< MatrixType_ >::m_isRUpToDate, and Eigen::SPQR< MatrixType_ >::m_R.

Referenced by Eigen::SPQR< MatrixType_ >::_solve_impl().

rank()

template<typename MatrixType_ >

Index Eigen::SPQR< MatrixType_ >::rank ( ) const

inline

Gets the rank of the matrix. It should be equal to matrixQR().cols if the matrix is full-rank

                     {
    eigen_assert(m_isInitialized && "Decomposition is not initialized.");
    return m_cc.SPQR_istat[4];
  }

References eigen_assert, Eigen::SPQR< MatrixType_ >::m_cc, and Eigen::SparseSolverBase< SPQR< MatrixType_ > >::m_isInitialized.

Referenced by Eigen::SPQR< MatrixType_ >::_solve_impl().

rows()

template<typename MatrixType_ >

Index Eigen::SPQR< MatrixType_ >::rows ( ) const

inline

Get the number of rows of the input matrix and the Q matrix

{ return m_rows; }

References Eigen::SPQR< MatrixType_ >::m_rows.

Referenced by gdb.printers._MatrixEntryIterator::__next__(), gdb.printers.EigenMatrixPrinter::children(), gdb.printers.EigenSparseMatrixPrinter::children(), gdb.printers.EigenMatrixPrinter::to_string(), and gdb.printers.EigenSparseMatrixPrinter::to_string().

setPivotThreshold()

template<typename MatrixType_ >

void Eigen::SPQR< MatrixType_ >::setPivotThreshold ( const RealScalar &  tol )

inline

Set the tolerance tol to treat columns with 2-norm < =tol as zero.

                                                {
    m_useDefaultThreshold = false;
    m_tolerance = tol;
  }

References Eigen::SPQR< MatrixType_ >::m_tolerance, and Eigen::SPQR< MatrixType_ >::m_useDefaultThreshold.

setSPQROrdering()

template<typename MatrixType_ >

void Eigen::SPQR< MatrixType_ >::setSPQROrdering ( int  ord )

inline

Set the fill-reducing ordering method to be used.

{ m_ordering = ord; }

References Eigen::SPQR< MatrixType_ >::m_ordering.

SPQR_free()

template<typename MatrixType_ >

void Eigen::SPQR< MatrixType_ >::SPQR_free ( )

inline

                   {
    cholmod_l_free_sparse(&m_H, &m_cc);
    cholmod_l_free_sparse(&m_cR, &m_cc);
    cholmod_l_free_dense(&m_HTau, &m_cc);
    std::free(m_E);
    std::free(m_HPinv);
  }

References Eigen::SPQR< MatrixType_ >::m_cc, Eigen::SPQR< MatrixType_ >::m_cR, Eigen::SPQR< MatrixType_ >::m_E, Eigen::SPQR< MatrixType_ >::m_H, Eigen::SPQR< MatrixType_ >::m_HPinv, and Eigen::SPQR< MatrixType_ >::m_HTau.

Referenced by Eigen::SPQR< MatrixType_ >::compute(), and Eigen::SPQR< MatrixType_ >::~SPQR().

Friends And Related Function Documentation

SPQR_QProduct

template<typename MatrixType_ >

template<typename , typename >

friend struct SPQR_QProduct

friend

Member Data Documentation

m_allow_tol

template<typename MatrixType_ >

int Eigen::SPQR< MatrixType_ >::m_allow_tol

protected

m_analysisIsOk

template<typename MatrixType_ >

bool Eigen::SPQR< MatrixType_ >::m_analysisIsOk

protected

m_cc

template<typename MatrixType_ >

cholmod_common Eigen::SPQR< MatrixType_ >::m_cc

mutableprotected

Referenced by Eigen::SPQR< MatrixType_ >::cholmodCommon(), Eigen::SPQR< MatrixType_ >::compute(), Eigen::SPQR< MatrixType_ >::rank(), Eigen::SPQR< MatrixType_ >::SPQR(), Eigen::SPQR< MatrixType_ >::SPQR_free(), and Eigen::SPQR< MatrixType_ >::~SPQR().

m_cR

template<typename MatrixType_ >

cholmod_sparse* Eigen::SPQR< MatrixType_ >::m_cR = nullptr

mutableprotected

Referenced by Eigen::SPQR< MatrixType_ >::cols(), Eigen::SPQR< MatrixType_ >::colsPermutation(), Eigen::SPQR< MatrixType_ >::compute(), Eigen::SPQR< MatrixType_ >::matrixR(), and Eigen::SPQR< MatrixType_ >::SPQR_free().

m_E

template<typename MatrixType_ >

StorageIndex* Eigen::SPQR< MatrixType_ >::m_E = nullptr

mutableprotected

Referenced by Eigen::SPQR< MatrixType_ >::_solve_impl(), Eigen::SPQR< MatrixType_ >::colsPermutation(), Eigen::SPQR< MatrixType_ >::compute(), and Eigen::SPQR< MatrixType_ >::SPQR_free().

m_factorizationIsOk

template<typename MatrixType_ >

bool Eigen::SPQR< MatrixType_ >::m_factorizationIsOk

protected

m_H

template<typename MatrixType_ >

cholmod_sparse* Eigen::SPQR< MatrixType_ >::m_H = nullptr

mutableprotected

Referenced by Eigen::SPQR< MatrixType_ >::compute(), and Eigen::SPQR< MatrixType_ >::SPQR_free().

m_HPinv

template<typename MatrixType_ >

StorageIndex* Eigen::SPQR< MatrixType_ >::m_HPinv = nullptr

mutableprotected

Referenced by Eigen::SPQR< MatrixType_ >::compute(), and Eigen::SPQR< MatrixType_ >::SPQR_free().

m_HTau

template<typename MatrixType_ >

cholmod_dense* Eigen::SPQR< MatrixType_ >::m_HTau = nullptr

mutableprotected

Referenced by Eigen::SPQR< MatrixType_ >::compute(), and Eigen::SPQR< MatrixType_ >::SPQR_free().

m_info

template<typename MatrixType_ >

ComputationInfo Eigen::SPQR< MatrixType_ >::m_info

mutableprotected

Referenced by Eigen::SPQR< MatrixType_ >::_solve_impl(), Eigen::SPQR< MatrixType_ >::compute(), and Eigen::SPQR< MatrixType_ >::info().

m_isRUpToDate

template<typename MatrixType_ >

bool Eigen::SPQR< MatrixType_ >::m_isRUpToDate

mutableprotected

Referenced by Eigen::SPQR< MatrixType_ >::compute(), and Eigen::SPQR< MatrixType_ >::matrixR().

m_ordering

template<typename MatrixType_ >

int Eigen::SPQR< MatrixType_ >::m_ordering

protected

Referenced by Eigen::SPQR< MatrixType_ >::compute(), and Eigen::SPQR< MatrixType_ >::setSPQROrdering().

m_R

template<typename MatrixType_ >

MatrixType Eigen::SPQR< MatrixType_ >::m_R

mutableprotected

Referenced by Eigen::SPQR< MatrixType_ >::matrixR().

m_rank

template<typename MatrixType_ >

Index Eigen::SPQR< MatrixType_ >::m_rank

mutableprotected

Referenced by Eigen::SPQR< MatrixType_ >::compute().

m_rows

template<typename MatrixType_ >

Index Eigen::SPQR< MatrixType_ >::m_rows

protected

Referenced by Eigen::SPQR< MatrixType_ >::compute(), and Eigen::SPQR< MatrixType_ >::rows().

m_tolerance

template<typename MatrixType_ >

RealScalar Eigen::SPQR< MatrixType_ >::m_tolerance

protected

Referenced by Eigen::SPQR< MatrixType_ >::compute(), and Eigen::SPQR< MatrixType_ >::setPivotThreshold().

m_useDefaultThreshold

template<typename MatrixType_ >

bool Eigen::SPQR< MatrixType_ >::m_useDefaultThreshold

protected

Referenced by Eigen::SPQR< MatrixType_ >::compute(), and Eigen::SPQR< MatrixType_ >::setPivotThreshold().

---

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

• SuiteSparseQRSupport.h