Householder QR decomposition of a matrix. More...

#include <HouseholderQR.h>

Inheritance diagram for Eigen::HouseholderQR< _MatrixType >:

Collaboration diagram for Eigen::HouseholderQR< _MatrixType >:

Public Types
enum	{ RowsAtCompileTime = MatrixType::RowsAtCompileTime, ColsAtCompileTime = MatrixType::ColsAtCompileTime, Options = MatrixType::Options, MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime, MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime }
typedef _MatrixType	MatrixType
typedef MatrixType::Scalar	Scalar
typedef MatrixType::RealScalar	RealScalar
typedef MatrixType::StorageIndex	StorageIndex
typedef Matrix< Scalar, RowsAtCompileTime, RowsAtCompileTime,(MatrixType::Flags &RowMajorBit)?RowMajor:ColMajor, MaxRowsAtCompileTime, MaxRowsAtCompileTime >	MatrixQType
typedef internal::plain_diag_type < MatrixType >::type	HCoeffsType
typedef internal::plain_row_type < MatrixType >::type	RowVectorType
typedef HouseholderSequence < MatrixType, typename internal::remove_all< typename HCoeffsType::ConjugateReturnType > ::type >	HouseholderSequenceType
Public Member Functions
	HouseholderQR ()
	Default Constructor.
	HouseholderQR (Index rows, Index cols)
	Default Constructor with memory preallocation.
template<typename InputType >
	HouseholderQR (const EigenBase< InputType > &matrix)
	Constructs a QR factorization from a given matrix.
template<typename Rhs >
const Solve< HouseholderQR, Rhs >	solve (const MatrixBase< Rhs > &b) const
HouseholderSequenceType	householderQ () const
const MatrixType &	matrixQR () const
template<typename InputType >
HouseholderQR &	compute (const EigenBase< InputType > &matrix)
MatrixType::RealScalar	absDeterminant () const
MatrixType::RealScalar	logAbsDeterminant () const
Index	rows () const
Index	cols () const
const HCoeffsType &	hCoeffs () const
template<typename RhsType , typename DstType >
EIGEN_DEVICE_FUNC void	_solve_impl (const RhsType &rhs, DstType &dst) const
Static Protected Member Functions
static void	check_template_parameters ()
Protected Attributes
MatrixType	m_qr
HCoeffsType	m_hCoeffs
RowVectorType	m_temp
bool	m_isInitialized

Detailed Description

template<typename _MatrixType>
class Eigen::HouseholderQR< _MatrixType >

Householder QR decomposition of a matrix.

Template Parameters:

_MatrixType the type of the matrix of which we are computing the QR decomposition

This class performs a QR decomposition of a matrix A into matrices Q and R such that

$\mathbf{A} = \mathbf{Q} \, \mathbf{R}$

by using Householder transformations. Here, Q a unitary matrix and R an upper triangular matrix. The result is stored in a compact way compatible with LAPACK.

Note that no pivoting is performed. This is not a rank-revealing decomposition. If you want that feature, use FullPivHouseholderQR or ColPivHouseholderQR instead.

This Householder QR decomposition is faster, but less numerically stable and less feature-full than FullPivHouseholderQR or ColPivHouseholderQR.

See also:: MatrixBase::householderQr()

Definition at line 42 of file HouseholderQR.h.

Member Typedef Documentation

template<typename _MatrixType>

typedef internal::plain_diag_type<MatrixType>::type Eigen::HouseholderQR< _MatrixType >::HCoeffsType

Definition at line 59 of file HouseholderQR.h.

template<typename _MatrixType>

typedef HouseholderSequence<MatrixType,typename internal::remove_all<typename HCoeffsType::ConjugateReturnType>::type> Eigen::HouseholderQR< _MatrixType >::HouseholderSequenceType

Definition at line 61 of file HouseholderQR.h.

template<typename _MatrixType>

typedef Matrix<Scalar, RowsAtCompileTime, RowsAtCompileTime, (MatrixType::Flags&RowMajorBit) ? RowMajor : ColMajor, MaxRowsAtCompileTime, MaxRowsAtCompileTime> Eigen::HouseholderQR< _MatrixType >::MatrixQType

Definition at line 58 of file HouseholderQR.h.

template<typename _MatrixType>

typedef _MatrixType Eigen::HouseholderQR< _MatrixType >::MatrixType

Definition at line 46 of file HouseholderQR.h.

template<typename _MatrixType>

typedef MatrixType::RealScalar Eigen::HouseholderQR< _MatrixType >::RealScalar

Definition at line 55 of file HouseholderQR.h.

template<typename _MatrixType>

typedef internal::plain_row_type<MatrixType>::type Eigen::HouseholderQR< _MatrixType >::RowVectorType

Definition at line 60 of file HouseholderQR.h.

template<typename _MatrixType>

typedef MatrixType::Scalar Eigen::HouseholderQR< _MatrixType >::Scalar

Definition at line 54 of file HouseholderQR.h.

template<typename _MatrixType>

typedef MatrixType::StorageIndex Eigen::HouseholderQR< _MatrixType >::StorageIndex

Definition at line 57 of file HouseholderQR.h.

Member Enumeration Documentation

template<typename _MatrixType>

anonymous enum

Enumerator:

RowsAtCompileTime
ColsAtCompileTime
Options
MaxRowsAtCompileTime
MaxColsAtCompileTime

Definition at line 47 of file HouseholderQR.h.

         {
      RowsAtCompileTime = MatrixType::RowsAtCompileTime,
      ColsAtCompileTime = MatrixType::ColsAtCompileTime,
      Options = MatrixType::Options,
      MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
      MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
    };

Constructor & Destructor Documentation

template<typename _MatrixType>

Eigen::HouseholderQR< _MatrixType >::HouseholderQR ( ) [inline]

Default Constructor.

The default constructor is useful in cases in which the user intends to perform decompositions via HouseholderQR::compute(const MatrixType&).

Definition at line 69 of file HouseholderQR.h.

: m_qr(), m_hCoeffs(), m_temp(), m_isInitialized(false) {}

template<typename _MatrixType>

Eigen::HouseholderQR< _MatrixType >::HouseholderQR	(	Index	rows,
		Index	cols
	)		`[inline]`

Default Constructor with memory preallocation.

Like the default constructor but with preallocation of the internal data according to the specified problem size.

See also:: HouseholderQR()

Definition at line 77 of file HouseholderQR.h.

      : m_qr(rows, cols),
        m_hCoeffs((std::min)(rows,cols)),
        m_temp(cols),
        m_isInitialized(false) {}

template<typename _MatrixType>

template<typename InputType >

Eigen::HouseholderQR< _MatrixType >::HouseholderQR ( const EigenBase< InputType > & matrix ) [inline, explicit]

Constructs a QR factorization from a given matrix.

This constructor computes the QR factorization of the matrix matrix by calling the method compute(). It is a short cut for:

 HouseholderQR<MatrixType> qr(matrix.rows(), matrix.cols());
 qr.compute(matrix);

See also:: compute()

Definition at line 96 of file HouseholderQR.h.

      : m_qr(matrix.rows(), matrix.cols()),
        m_hCoeffs((std::min)(matrix.rows(),matrix.cols())),
        m_temp(matrix.cols()),
        m_isInitialized(false)
    {
      compute(matrix.derived());
    }

Member Function Documentation

template<typename _MatrixType >

template<typename RhsType , typename DstType >

void Eigen::HouseholderQR< _MatrixType >::_solve_impl	(	const RhsType &	rhs,
		DstType &	dst
	)		const

Definition at line 328 of file HouseholderQR.h.

{
  const Index rank = (std::min)(rows(), cols());
  eigen_assert(rhs.rows() == rows());

  typename RhsType::PlainObject c(rhs);

  // Note that the matrix Q = H_0^* H_1^*... so its inverse is Q^* = (H_0 H_1 ...)^T
  c.applyOnTheLeft(householderSequence(
    m_qr.leftCols(rank),
    m_hCoeffs.head(rank)).transpose()
  );

  m_qr.topLeftCorner(rank, rank)
      .template triangularView<Upper>()
      .solveInPlace(c.topRows(rank));

  dst.topRows(rank) = c.topRows(rank);
  dst.bottomRows(cols()-rank).setZero();
}

template<typename MatrixType >

MatrixType::RealScalar Eigen::HouseholderQR< MatrixType >::absDeterminant ( ) const

Returns:: the absolute value of the determinant of the matrix of which *this is the QR decomposition. It has only linear complexity (that is, O(n) where n is the dimension of the square matrix) as the QR decomposition has already been computed.

Note:: This is only for square matrices.

Warning:: a determinant can be very big or small, so for matrices of large enough dimension, there is a risk of overflow/underflow. One way to work around that is to use logAbsDeterminant() instead.

See also:: logAbsDeterminant(), MatrixBase::determinant()

Definition at line 214 of file HouseholderQR.h.

{
  using std::abs;
  eigen_assert(m_isInitialized && "HouseholderQR is not initialized.");
  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
  return abs(m_qr.diagonal().prod());
}

template<typename _MatrixType>

static void Eigen::HouseholderQR< _MatrixType >::check_template_parameters ( ) [inline, static, protected]

Definition at line 202 of file HouseholderQR.h.

    {
      EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
    }

template<typename _MatrixType>

Index Eigen::HouseholderQR< _MatrixType >::cols ( void ) const [inline]

Definition at line 186 of file HouseholderQR.h.

{ return m_qr.cols(); }

template<typename MatrixType >

template<typename InputType >

HouseholderQR< MatrixType > & Eigen::HouseholderQR< MatrixType >::compute ( const EigenBase< InputType > & matrix )

Performs the QR factorization of the given matrix matrix. The result of the factorization is stored into *this, and a reference to *this is returned.

See also:: class HouseholderQR, HouseholderQR(const MatrixType&)

Definition at line 358 of file HouseholderQR.h.

{
  check_template_parameters();
  
  Index rows = matrix.rows();
  Index cols = matrix.cols();
  Index size = (std::min)(rows,cols);

  m_qr = matrix.derived();
  m_hCoeffs.resize(size);

  m_temp.resize(cols);

  internal::householder_qr_inplace_blocked<MatrixType, HCoeffsType>::run(m_qr, m_hCoeffs, 48, m_temp.data());

  m_isInitialized = true;
  return *this;
}

template<typename _MatrixType>

const HCoeffsType& Eigen::HouseholderQR< _MatrixType >::hCoeffs ( ) const [inline]

Returns:: a const reference to the vector of Householder coefficients used to represent the factor Q.

For advanced uses only.

Definition at line 192 of file HouseholderQR.h.

{ return m_hCoeffs; }

template<typename _MatrixType>

HouseholderSequenceType Eigen::HouseholderQR< _MatrixType >::householderQ ( void ) const [inline]

This method returns an expression of the unitary matrix Q as a sequence of Householder transformations.

The returned expression can directly be used to perform matrix products. It can also be assigned to a dense Matrix object. Here is an example showing how to recover the full or thin matrix Q, as well as how to perform matrix products using operator*:

Example:

Output:

Definition at line 138 of file HouseholderQR.h.

    {
      eigen_assert(m_isInitialized && "HouseholderQR is not initialized.");
      return HouseholderSequenceType(m_qr, m_hCoeffs.conjugate());
    }

template<typename MatrixType >

MatrixType::RealScalar Eigen::HouseholderQR< MatrixType >::logAbsDeterminant ( ) const

Returns:: the natural log of the absolute value of the determinant of the matrix of which *this is the QR decomposition. It has only linear complexity (that is, O(n) where n is the dimension of the square matrix) as the QR decomposition has already been computed.

Note:: This is only for square matrices.; This method is useful to work around the risk of overflow/underflow that's inherent to determinant computation.

See also:: absDeterminant(), MatrixBase::determinant()

Definition at line 223 of file HouseholderQR.h.

{
  eigen_assert(m_isInitialized && "HouseholderQR is not initialized.");
  eigen_assert(m_qr.rows() == m_qr.cols() && "You can't take the determinant of a non-square matrix!");
  return m_qr.diagonal().cwiseAbs().array().log().sum();
}

template<typename _MatrixType>

const MatrixType& Eigen::HouseholderQR< _MatrixType >::matrixQR ( ) const [inline]

Returns:: a reference to the matrix where the Householder QR decomposition is stored in a LAPACK-compatible way.

Definition at line 147 of file HouseholderQR.h.

    {
        eigen_assert(m_isInitialized && "HouseholderQR is not initialized.");
        return m_qr;
    }

template<typename _MatrixType>

Index Eigen::HouseholderQR< _MatrixType >::rows ( void ) const [inline]

Definition at line 185 of file HouseholderQR.h.

{ return m_qr.rows(); }

template<typename _MatrixType>

template<typename Rhs >

const Solve<HouseholderQR, Rhs> Eigen::HouseholderQR< _MatrixType >::solve ( const MatrixBase< Rhs > & b ) const [inline]

This method finds a solution x to the equation Ax=b, where A is the matrix of which *this is the QR decomposition, if any exists.

Parameters:

b	the right-hand-side of the equation to solve.

Returns:: a solution.

Note:: The case where b is a matrix is not yet implemented. Also, this code is space inefficient.

Example:

Output:

Definition at line 124 of file HouseholderQR.h.

    {
      eigen_assert(m_isInitialized && "HouseholderQR is not initialized.");
      return Solve<HouseholderQR, Rhs>(*this, b.derived());
    }

Member Data Documentation

template<typename _MatrixType>

HCoeffsType Eigen::HouseholderQR< _MatrixType >::m_hCoeffs [protected]

Definition at line 208 of file HouseholderQR.h.

template<typename _MatrixType>

bool Eigen::HouseholderQR< _MatrixType >::m_isInitialized [protected]

Definition at line 210 of file HouseholderQR.h.

template<typename _MatrixType>

MatrixType Eigen::HouseholderQR< _MatrixType >::m_qr [protected]

Definition at line 207 of file HouseholderQR.h.

template<typename _MatrixType>

RowVectorType Eigen::HouseholderQR< _MatrixType >::m_temp [protected]

Definition at line 209 of file HouseholderQR.h.

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

HouseholderQR.h

Public Types

Public Member Functions

Static Protected Member Functions

Protected Attributes

Detailed Description

template<typename _MatrixType> class Eigen::HouseholderQR< _MatrixType >

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<typename _MatrixType>
class Eigen::HouseholderQR< _MatrixType >