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

#include <src/eigen/Eigen/src/SPQRSupport/SuiteSparseQRSupport.h>

Inheritance diagram for Eigen::SPQR< _MatrixType >:

Collaboration 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.

PermutationType	colsPermutation () const
	Get the permutation that was applied to columns of A.

Index	rank () const

void	setSPQROrdering (int ord)
	Set the fill-reducing ordering method to be used.

void	setPivotThreshold (const RealScalar &tol)
	Set the tolerance tol to treat columns with 2-norm < =tol as zero.

cholmod_common *	cholmodCommon () const

ComputationInfo	info () const
	Reports whether previous computation was successful.

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

MatrixType	m_R

StorageIndex *	m_E

cholmod_sparse *	m_H

StorageIndex *	m_HPinv

cholmod_dense *	m_HTau

Index	m_rank

cholmod_common	m_cc

bool	m_useDefaultThreshold

Index	m_rows

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_ordering(SPQR_ORDERING_DEFAULT), m_allow_tol(SPQR_DEFAULT_TOL), m_tolerance (NumTraits<Scalar>::epsilon()), 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_ordering(SPQR_ORDERING_DEFAULT), m_allow_tol(SPQR_DEFAULT_TOL), m_tolerance (NumTraits<Scalar>::epsilon()), m_useDefaultThreshold(true)
    {
      cholmod_l_start(&m_cc);
      compute(matrix);
    }

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

Here is the call graph for this function:

◆ ~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().

Here is the call graph for this function:

Member Function Documentation

◆ _solve_impl() [1/2]

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 Eigen::SPQR< _MatrixType >::cols(), eigen_assert, Eigen::SPQR< _MatrixType >::m_E, Eigen::SPQR< _MatrixType >::m_info, Eigen::SparseSolverBase< SPQR< _MatrixType > >::m_isInitialized, Eigen::SPQR< _MatrixType >::matrixQ(), Eigen::SPQR< _MatrixType >::matrixR(), Eigen::SPQR< _MatrixType >::rank(), Eigen::DenseBase< Derived >::setZero(), and Eigen::Success.

Here is the call graph for this function:

◆ _solve_impl() [2/2]

void Eigen::SparseSolverBase< SPQR< _MatrixType > >::_solve_impl	(	const SparseMatrixBase< Rhs > &	b,
		SparseMatrixBase< Dest > &	dest
	)		const

inlineinherited

    {
      internal::solve_sparse_through_dense_panels(derived(), b.derived(), dest.derived());
    }

◆ cholmodCommon()

template<typename _MatrixType >

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

inline

Returns: a pointer to the SPQR workspace

218{ 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.

147{ return m_cR->ncol; }

Eigen::SPQR::m_cR

cholmod_sparse * m_cR

Definition SuiteSparseQRSupport.h:239

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

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

Here is the caller graph for this function:

◆ 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(max2Norm==RealScalar(0))
          max2Norm = RealScalar(1);
        pivotThreshold = 20 * (mat.rows() + mat.cols()) * max2Norm * NumTraits<RealScalar>::epsilon();
      }
      cholmod_sparse A; 
      A = viewAsCholmod(mat);
      m_rows = matrix.rows();
      Index col = matrix.cols();
      m_rank = SuiteSparseQR<Scalar>(m_ordering, pivotThreshold, col, &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;
    }

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ derived() [1/2]

SPQR< _MatrixType > & Eigen::SparseSolverBase< SPQR< _MatrixType > >::derived ( )

inlineinherited

79{ return *static_cast<Derived*>(this); }

◆ derived() [2/2]

const SPQR< _MatrixType > & Eigen::SparseSolverBase< SPQR< _MatrixType > >::derived ( ) const

inlineinherited

80{ return *static_cast<const Derived*>(this); }

◆ info()

template<typename _MatrixType >

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

inline

Reports whether previous computation was successful.

Returns: Success if computation was succesful, 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 ( ) const

inline

Get an expression of the matrix Q.

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

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

Here is the caller graph for this function:

◆ 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,ColMajor, typename MatrixType::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().

Here is the caller graph for this function:

◆ 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().

Here is the caller graph for this function:

◆ rows()

template<typename _MatrixType >

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

inline

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

142{return m_rows; }

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

◆ 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.

209{ m_ordering = ord;}

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

◆ solve() [1/2]

const Solve< SPQR< _MatrixType > , Rhs > Eigen::SparseSolverBase< SPQR< _MatrixType > >::solve ( const MatrixBase< Rhs > & b ) const

inlineinherited

Returns: an expression of the solution x of using the current decomposition of A.

See also: compute()

    {
      eigen_assert(m_isInitialized && "Solver is not initialized.");
      eigen_assert(derived().rows()==b.rows() && "solve(): invalid number of rows of the right hand side matrix b");
      return Solve<Derived, Rhs>(derived(), b.derived());
    }

◆ solve() [2/2]

const Solve< SPQR< _MatrixType > , Rhs > Eigen::SparseSolverBase< SPQR< _MatrixType > >::solve ( const SparseMatrixBase< Rhs > & b ) const

inlineinherited

Returns: an expression of the solution x of using the current decomposition of A.

See also: compute()

    {
      eigen_assert(m_isInitialized && "Solver is not initialized.");
      eigen_assert(derived().rows()==b.rows() && "solve(): invalid number of rows of the right hand side matrix b");
      return Solve<Derived, Rhs>(derived(), b.derived());
    }

◆ 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 >::~SPQR(), and Eigen::SPQR< _MatrixType >::compute().

Here is the caller graph for this function:

Friends And Related Symbol 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 >::SPQR(), Eigen::SPQR< _MatrixType >::SPQR(), Eigen::SPQR< _MatrixType >::~SPQR(), Eigen::SPQR< _MatrixType >::cholmodCommon(), Eigen::SPQR< _MatrixType >::compute(), Eigen::SPQR< _MatrixType >::rank(), and Eigen::SPQR< _MatrixType >::SPQR_free().

◆ m_cR

template<typename _MatrixType >

cholmod_sparse* Eigen::SPQR< _MatrixType >::m_cR

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

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

mutableprotected

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

◆ m_HPinv

template<typename _MatrixType >

StorageIndex* Eigen::SPQR< _MatrixType >::m_HPinv

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

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_isInitialized

bool Eigen::SparseSolverBase< SPQR< _MatrixType > >::m_isInitialized

mutableprotectedinherited

◆ 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:

src/eigen/Eigen/src/SPQRSupport/SuiteSparseQRSupport.h

Public Types

Public Member Functions

Protected Types

Protected Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ Base

◆ MatrixType

◆ PermutationType

◆ RealScalar

◆ Scalar

◆ StorageIndex

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ SPQR() [1/2]

◆ SPQR() [2/2]

◆ ~SPQR()

Member Function Documentation

◆ _solve_impl() [1/2]

◆ _solve_impl() [2/2]

◆ cholmodCommon()

◆ cols()

◆ colsPermutation()

◆ compute()

◆ derived() [1/2]

◆ derived() [2/2]

◆ info()

◆ matrixQ()

◆ matrixR()

◆ rank()

◆ rows()

◆ setPivotThreshold()

◆ setSPQROrdering()

◆ solve() [1/2]

◆ solve() [2/2]

◆ SPQR_free()

Friends And Related Symbol Documentation

◆ SPQR_QProduct

Member Data Documentation

◆ m_allow_tol

◆ m_analysisIsOk

◆ m_cc

◆ m_cR

◆ m_E

◆ m_factorizationIsOk

◆ m_H

◆ m_HPinv

◆ m_HTau

◆ m_info

◆ m_isInitialized

◆ m_isRUpToDate

◆ m_ordering

◆ m_R

◆ m_rank

◆ m_rows

◆ m_tolerance

◆ m_useDefaultThreshold