Householder QR decomposition of a matrix. More...

Public Types
enum	{ RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime }
typedef internal::plain_diag_type < MatrixType >::type	HCoeffsType
typedef HouseholderSequence < MatrixType, HCoeffsType > ::ConjugateReturnType	HouseholderSequenceType
typedef MatrixType::Index	Index
typedef Matrix< Scalar, RowsAtCompileTime, RowsAtCompileTime,(MatrixType::Flags &RowMajorBit)?RowMajor:ColMajor, MaxRowsAtCompileTime, MaxRowsAtCompileTime >	MatrixQType
typedef _MatrixType	MatrixType
typedef MatrixType::RealScalar	RealScalar
typedef internal::plain_row_type < MatrixType >::type	RowVectorType
typedef MatrixType::Scalar	Scalar
Public Member Functions
MatrixType::RealScalar	absDeterminant () const
Index	cols () const
HouseholderQR &	compute (const MatrixType &matrix)
const HCoeffsType &	hCoeffs () const
HouseholderSequenceType	householderQ () const
	HouseholderQR ()
	Default Constructor.
	HouseholderQR (Index rows, Index cols)
	Default Constructor with memory preallocation.
	HouseholderQR (const MatrixType &matrix)
MatrixType::RealScalar	logAbsDeterminant () const
const MatrixType &	matrixQR () const
Index	rows () const
template<typename Rhs >
const internal::solve_retval < HouseholderQR, Rhs >	solve (const MatrixBase< Rhs > &b) const
Protected Attributes
HCoeffsType	m_hCoeffs
bool	m_isInitialized
MatrixType	m_qr
RowVectorType	m_temp

Detailed Description

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

Householder QR decomposition of a matrix.

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

Member Typedef Documentation

typedef internal::plain_diag_type<MatrixType>::type HCoeffsType

typedef HouseholderSequence<MatrixType,HCoeffsType>::ConjugateReturnType HouseholderSequenceType

typedef MatrixType::Index Index

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

typedef _MatrixType MatrixType

typedef MatrixType::RealScalar RealScalar

typedef internal::plain_row_type<MatrixType>::type RowVectorType

typedef MatrixType::Scalar Scalar

Member Enumeration Documentation

anonymous enum

Enumerator:

RowsAtCompileTime
ColsAtCompileTime
Options
MaxRowsAtCompileTime
MaxColsAtCompileTime

Constructor & Destructor Documentation

HouseholderQR ( ) [inline]

Default Constructor.

The default constructor is useful in cases in which the user intends to perform decompositions via HouseholderQR::compute(const 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()

HouseholderQR ( const MatrixType & matrix ) [inline]

Member Function Documentation

MatrixType::RealScalar 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()

Index cols ( void ) const [inline]

HouseholderQR< MatrixType > & compute ( const MatrixType & matrix )

const HCoeffsType& hCoeffs ( ) const [inline]

HouseholderSequenceType householderQ ( ) const [inline]

MatrixType::RealScalar 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()

const MatrixType& matrixQR ( ) const [inline]

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

Index rows ( void ) const [inline]

const internal::solve_retval<HouseholderQR, Rhs> 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.

This method just tries to find as good a solution as possible. If you want to check whether a solution exists or if it is accurate, just call this function to get a result and then compute the error of this result, or use MatrixBase::isApprox() directly, for instance like this:

 bool a_solution_exists = (A*result).isApprox(b, precision);

This method avoids dividing by zero, so that the non-existence of a solution doesn't by itself mean that you'll get inf or nan values.

If there exists more than one solution, this method will arbitrarily choose one.

Example:

typedef Matrix<float,3,3> Matrix3x3;
Matrix3x3 m = Matrix3x3::Random();
Matrix3f y = Matrix3f::Random();
cout << "Here is the matrix m:" << endl << m << endl;
cout << "Here is the matrix y:" << endl << y << endl;
Matrix3f x;
x = m.householderQr().solve(y);
assert(y.isApprox(m*x));
cout << "Here is a solution x to the equation mx=y:" << endl << x << endl;

Output:

Here is the matrix m:
  0.68  0.597  -0.33
-0.211  0.823  0.536
 0.566 -0.605 -0.444
Here is the matrix y:
 0.108  -0.27  0.832
-0.0452 0.0268  0.271
 0.258  0.904  0.435
Here is a solution x to the equation mx=y:
 0.609   2.68   1.67
-0.231  -1.57 0.0713
  0.51   3.51   1.05

Member Data Documentation

HCoeffsType m_hCoeffs [protected]

bool m_isInitialized [protected]

MatrixType m_qr [protected]

RowVectorType m_temp [protected]

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

Public Types

Public Member Functions

Protected Attributes