Sequence of Householder reflections acting on subspaces with decreasing size. More...

#include <HouseholderSequence.h>

Inheritance diagram for Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >:

Public Types
enum	{ RowsAtCompileTime = internal::traits<HouseholderSequence>::RowsAtCompileTime , ColsAtCompileTime = internal::traits<HouseholderSequence>::ColsAtCompileTime , MaxRowsAtCompileTime = internal::traits<HouseholderSequence>::MaxRowsAtCompileTime , MaxColsAtCompileTime = internal::traits<HouseholderSequence>::MaxColsAtCompileTime }

typedef internal::traits< HouseholderSequence >::Scalar	Scalar

typedef HouseholderSequence< std::conditional_t< NumTraits< Scalar >::IsComplex, internal::remove_all_t< typename VectorsType::ConjugateReturnType >, VectorsType >, std::conditional_t< NumTraits< Scalar >::IsComplex, internal::remove_all_t< typename CoeffsType::ConjugateReturnType >, CoeffsType >, Side >	ConjugateReturnType

typedef HouseholderSequence< VectorsType, std::conditional_t< NumTraits< Scalar >::IsComplex, internal::remove_all_t< typename CoeffsType::ConjugateReturnType >, CoeffsType >, Side >	AdjointReturnType

typedef HouseholderSequence< std::conditional_t< NumTraits< Scalar >::IsComplex, internal::remove_all_t< typename VectorsType::ConjugateReturnType >, VectorsType >, CoeffsType, Side >	TransposeReturnType

typedef HouseholderSequence< std::add_const_t< VectorsType >, std::add_const_t< CoeffsType >, Side >	ConstHouseholderSequence

Public Types inherited from Eigen::EigenBase< HouseholderSequence< VectorsType, CoeffsType, Side > >
typedef Eigen::Index	Index
	The interface type of indices. More...

typedef internal::traits< HouseholderSequence< VectorsType, CoeffsType, Side > >::StorageKind	StorageKind

Public Member Functions
EIGEN_DEVICE_FUNC	HouseholderSequence (const VectorsType &v, const CoeffsType &h)
	Constructor. More...

EIGEN_DEVICE_FUNC	HouseholderSequence (const HouseholderSequence &other)
	Copy constructor. More...

EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index	rows () const EIGEN_NOEXCEPT
	Number of rows of transformation viewed as a matrix. More...

EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index	cols () const EIGEN_NOEXCEPT
	Number of columns of transformation viewed as a matrix. More...

EIGEN_DEVICE_FUNC const EssentialVectorType	essentialVector (Index k) const
	Essential part of a Householder vector. More...

TransposeReturnType	transpose () const
	Transpose of the Householder sequence. More...

ConjugateReturnType	conjugate () const
	Complex conjugate of the Householder sequence. More...

template<bool Cond>
EIGEN_DEVICE_FUNC std::conditional_t< Cond, ConjugateReturnType, ConstHouseholderSequence >	conjugateIf () const

AdjointReturnType	adjoint () const
	Adjoint (conjugate transpose) of the Householder sequence. More...

AdjointReturnType	inverse () const
	Inverse of the Householder sequence (equals the adjoint). More...

template<typename DestType >
EIGEN_DEVICE_FUNC void	evalTo (DestType &dst) const

template<typename Dest , typename Workspace >
EIGEN_DEVICE_FUNC void	evalTo (Dest &dst, Workspace &workspace) const

template<typename Dest >
void	applyThisOnTheRight (Dest &dst) const

template<typename Dest , typename Workspace >
void	applyThisOnTheRight (Dest &dst, Workspace &workspace) const

template<typename Dest >
void	applyThisOnTheLeft (Dest &dst, bool inputIsIdentity=false) const

template<typename Dest , typename Workspace >
void	applyThisOnTheLeft (Dest &dst, Workspace &workspace, bool inputIsIdentity=false) const

template<typename OtherDerived >
internal::matrix_type_times_scalar_type< Scalar, OtherDerived >::Type	operator* (const MatrixBase< OtherDerived > &other) const
	Computes the product of a Householder sequence with a matrix. More...

EIGEN_DEVICE_FUNC HouseholderSequence &	setLength (Index length)
	Sets the length of the Householder sequence. More...

EIGEN_DEVICE_FUNC HouseholderSequence &	setShift (Index shift)
	Sets the shift of the Householder sequence. More...

EIGEN_DEVICE_FUNC Index	length () const
	Returns the length of the Householder sequence. More...

EIGEN_DEVICE_FUNC Index	shift () const
	Returns the shift of the Householder sequence. More...

Public Member Functions inherited from Eigen::EigenBase< HouseholderSequence< VectorsType, CoeffsType, Side > >
constexpr EIGEN_DEVICE_FUNC HouseholderSequence< VectorsType, CoeffsType, Side > &	derived ()

constexpr EIGEN_DEVICE_FUNC const HouseholderSequence< VectorsType, CoeffsType, Side > &	derived () const

EIGEN_DEVICE_FUNC HouseholderSequence< VectorsType, CoeffsType, Side > &	const_cast_derived () const

EIGEN_DEVICE_FUNC const HouseholderSequence< VectorsType, CoeffsType, Side > &	const_derived () const

EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index	rows () const EIGEN_NOEXCEPT

EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index	cols () const EIGEN_NOEXCEPT

EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index	size () const EIGEN_NOEXCEPT

EIGEN_DEVICE_FUNC void	evalTo (Dest &dst) const

EIGEN_DEVICE_FUNC void	addTo (Dest &dst) const

EIGEN_DEVICE_FUNC void	subTo (Dest &dst) const

EIGEN_DEVICE_FUNC void	applyThisOnTheRight (Dest &dst) const

EIGEN_DEVICE_FUNC void	applyThisOnTheLeft (Dest &dst) const

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DeviceWrapper< HouseholderSequence< VectorsType, CoeffsType, Side >, Device >	device (Device &device)

EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE DeviceWrapper< const HouseholderSequence< VectorsType, CoeffsType, Side >, Device >	device (Device &device) const

Protected Types
enum	{ BlockSize = 48 }

Protected Member Functions
HouseholderSequence &	setReverseFlag (bool reverse)
	Sets the reverse flag. More...

bool	reverseFlag () const
	Returns the reverse flag. More...

Protected Attributes
VectorsType::Nested	m_vectors

CoeffsType::Nested	m_coeffs

bool	m_reverse

Index	m_length

Index	m_shift

Private Types
typedef internal::hseq_side_dependent_impl< VectorsType, CoeffsType, Side >::EssentialVectorType	EssentialVectorType

Friends
template<typename VectorsType_ , typename CoeffsType_ , int Side_>
struct	internal::hseq_side_dependent_impl

template<typename VectorsType2 , typename CoeffsType2 , int Side2>
class	HouseholderSequence

Detailed Description

template<typename VectorsType, typename CoeffsType, int Side>
class Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >

Sequence of Householder reflections acting on subspaces with decreasing size.

\householder_module

Template Parameters

VectorsType	type of matrix containing the Householder vectors
CoeffsType	type of vector containing the Householder coefficients
Side	either OnTheLeft (the default) or OnTheRight

This class represents a product sequence of Householder reflections where the first Householder reflection acts on the whole space, the second Householder reflection leaves the one-dimensional subspace spanned by the first unit vector invariant, the third Householder reflection leaves the two-dimensional subspace spanned by the first two unit vectors invariant, and so on up to the last reflection which leaves all but one dimensions invariant and acts only on the last dimension. Such sequences of Householder reflections are used in several algorithms to zero out certain parts of a matrix. Indeed, the methods HessenbergDecomposition::matrixQ(), Tridiagonalization::matrixQ(), HouseholderQR::householderQ(), and ColPivHouseholderQR::householderQ() all return a HouseholderSequence.

More precisely, the class HouseholderSequence represents an \( n \times n \) matrix \( H \) of the form \( H = \prod_{i=0}^{n-1} H_i \) where the i-th Householder reflection is \( H_i = I - h_i v_i v_i^* \). The i-th Householder coefficient \( h_i \) is a scalar and the i-th Householder vector \( v_i \) is a vector of the form

\[ v_i = [\underbrace{0, \ldots, 0}_{i-1\mbox{ zeros}}, 1, \underbrace{*, \ldots,*}_{n-i\mbox{ arbitrary entries}} ]. \]

The last \( n-i \) entries of \( v_i \) are called the essential part of the Householder vector.

Typical usages are listed below, where H is a HouseholderSequence:

A.applyOnTheRight(H);             // A = A * H
A.applyOnTheLeft(H);              // A = H * A
A.applyOnTheRight(H.adjoint());   // A = A * H^*
A.applyOnTheLeft(H.adjoint());    // A = H^* * A
MatrixXd Q = H;                   // conversion to a dense matrix

In addition to the adjoint, you can also apply the inverse (=adjoint), the transpose, and the conjugate operators.

See the documentation for HouseholderSequence(const VectorsType&, const CoeffsType&) for an example.

See also: MatrixBase::applyOnTheLeft(), MatrixBase::applyOnTheRight()

Member Typedef Documentation

◆ AdjointReturnType

template<typename VectorsType , typename CoeffsType , int Side>

typedef HouseholderSequence< VectorsType, std::conditional_t<NumTraits<Scalar>::IsComplex, internal::remove_all_t<typename CoeffsType::ConjugateReturnType>, CoeffsType>, Side> Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::AdjointReturnType

◆ ConjugateReturnType

template<typename VectorsType , typename CoeffsType , int Side>

typedef HouseholderSequence< std::conditional_t<NumTraits<Scalar>::IsComplex, internal::remove_all_t<typename VectorsType::ConjugateReturnType>, VectorsType>, std::conditional_t<NumTraits<Scalar>::IsComplex, internal::remove_all_t<typename CoeffsType::ConjugateReturnType>, CoeffsType>, Side> Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::ConjugateReturnType

◆ ConstHouseholderSequence

template<typename VectorsType , typename CoeffsType , int Side>

typedef HouseholderSequence<std::add_const_t<VectorsType>, std::add_const_t<CoeffsType>, Side> Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::ConstHouseholderSequence

◆ EssentialVectorType

template<typename VectorsType , typename CoeffsType , int Side>

typedef internal::hseq_side_dependent_impl<VectorsType, CoeffsType, Side>::EssentialVectorType Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::EssentialVectorType

private

◆ Scalar

template<typename VectorsType , typename CoeffsType , int Side>

typedef internal::traits<HouseholderSequence>::Scalar Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::Scalar

◆ TransposeReturnType

template<typename VectorsType , typename CoeffsType , int Side>

typedef HouseholderSequence< std::conditional_t<NumTraits<Scalar>::IsComplex, internal::remove_all_t<typename VectorsType::ConjugateReturnType>, VectorsType>, CoeffsType, Side> Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::TransposeReturnType

Member Enumeration Documentation

◆ anonymous enum

template<typename VectorsType , typename CoeffsType , int Side>

anonymous enum

Enumerator
RowsAtCompileTime
ColsAtCompileTime
MaxRowsAtCompileTime
MaxColsAtCompileTime

        {
     RowsAtCompileTime = internal::traits<HouseholderSequence>::RowsAtCompileTime,
     ColsAtCompileTime = internal::traits<HouseholderSequence>::ColsAtCompileTime,
     MaxRowsAtCompileTime = internal::traits<HouseholderSequence>::MaxRowsAtCompileTime,
     MaxColsAtCompileTime = internal::traits<HouseholderSequence>::MaxColsAtCompileTime
   };

◆ anonymous enum

template<typename VectorsType , typename CoeffsType , int Side>

anonymous enum

protected

Enumerator
BlockSize

458 { BlockSize = 48 };

Eigen::HouseholderSequence::BlockSize

@ BlockSize

Definition: HouseholderSequence.h:458

Constructor & Destructor Documentation

◆ HouseholderSequence() [1/2]

template<typename VectorsType , typename CoeffsType , int Side>

EIGEN_DEVICE_FUNC Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::HouseholderSequence	(	const VectorsType &	v,
		const CoeffsType &	h
	)

inline

Constructor.

Parameters

[in]	v	Matrix containing the essential parts of the Householder vectors
[in]	h	Vector containing the Householder coefficients

Constructs the Householder sequence with coefficients given by h and vectors given by v. The i-th Householder coefficient \( h_i \) is given by h(i) and the essential part of the i-th Householder vector \( v_i \) is given by v(k,i) with k > i (the subdiagonal part of the i-th column). If v has fewer columns than rows, then the Householder sequence contains as many Householder reflections as there are columns.

Note: The HouseholderSequence object stores v and h by reference.

Example:

Matrix3d v = Matrix3d::Random();
cout << "The matrix v is:" << endl;
cout << v << endl;
 
Vector3d v0(1, v(1, 0), v(2, 0));
cout << "The first Householder vector is: v_0 = " << v0.transpose() << endl;
Vector3d v1(0, 1, v(2, 1));
cout << "The second Householder vector is: v_1 = " << v1.transpose() << endl;
Vector3d v2(0, 0, 1);
cout << "The third Householder vector is: v_2 = " << v2.transpose() << endl;
 
Vector3d h = Vector3d::Random();
cout << "The Householder coefficients are: h = " << h.transpose() << endl;
 
Matrix3d H0 = Matrix3d::Identity() - h(0) * v0 * v0.adjoint();
cout << "The first Householder reflection is represented by H_0 = " << endl;
cout << H0 << endl;
Matrix3d H1 = Matrix3d::Identity() - h(1) * v1 * v1.adjoint();
cout << "The second Householder reflection is represented by H_1 = " << endl;
cout << H1 << endl;
Matrix3d H2 = Matrix3d::Identity() - h(2) * v2 * v2.adjoint();
cout << "The third Householder reflection is represented by H_2 = " << endl;
cout << H2 << endl;
cout << "Their product is H_0 H_1 H_2 = " << endl;
cout << H0 * H1 * H2 << endl;
 
HouseholderSequence<Matrix3d, Vector3d> hhSeq(v, h);
Matrix3d hhSeqAsMatrix(hhSeq);
cout << "If we construct a HouseholderSequence from v and h" << endl;
cout << "and convert it to a matrix, we get:" << endl;
cout << hhSeqAsMatrix << endl;

Output:

See also: setLength(), setShift()

172 : m_vectors(v), m_coeffs(h), m_reverse(false), m_length(v.diagonalSize()), m_shift(0) {}

Eigen::HouseholderSequence::m_length

Index m_length

Definition: HouseholderSequence.h:456

Eigen::HouseholderSequence::m_reverse

bool m_reverse

Definition: HouseholderSequence.h:455

Eigen::HouseholderSequence::m_coeffs

CoeffsType::Nested m_coeffs

Definition: HouseholderSequence.h:454

Eigen::HouseholderSequence::m_vectors

VectorsType::Nested m_vectors

Definition: HouseholderSequence.h:453

Eigen::HouseholderSequence::m_shift

Index m_shift

Definition: HouseholderSequence.h:457

◆ HouseholderSequence() [2/2]

template<typename VectorsType , typename CoeffsType , int Side>

EIGEN_DEVICE_FUNC Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::HouseholderSequence ( const HouseholderSequence< VectorsType, CoeffsType, Side > & other )

inline

Copy constructor.

       : m_vectors(other.m_vectors),
         m_coeffs(other.m_coeffs),
         m_reverse(other.m_reverse),
         m_length(other.m_length),
         m_shift(other.m_shift) {}

Member Function Documentation

◆ adjoint()

template<typename VectorsType , typename CoeffsType , int Side>

AdjointReturnType Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::adjoint ( ) const

inline

Adjoint (conjugate transpose) of the Householder sequence.

                                     {
     return AdjointReturnType(m_vectors, m_coeffs.conjugate())
         .setReverseFlag(!m_reverse)
         .setLength(m_length)
         .setShift(m_shift);
   }

References Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_coeffs, Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_length, Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_reverse, Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_shift, and Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_vectors.

Referenced by householder(), Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::inverse(), and selfadjointeigensolver().

◆ applyThisOnTheLeft() [1/2]

template<typename VectorsType , typename CoeffsType , int Side>

template<typename Dest >

void Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::applyThisOnTheLeft	(	Dest &	dst,
		bool	inputIsIdentity = `false`
	)		const

inline

                                                                                 {
     Matrix<Scalar, 1, Dest::ColsAtCompileTime, RowMajor, 1, Dest::MaxColsAtCompileTime> workspace;
     applyThisOnTheLeft(dst, workspace, inputIsIdentity);
   }

Referenced by Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::evalTo(), and Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::operator*().

◆ applyThisOnTheLeft() [2/2]

template<typename VectorsType , typename CoeffsType , int Side>

template<typename Dest , typename Workspace >

void Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::applyThisOnTheLeft	(	Dest &	dst,
		Workspace &	workspace,
		bool	inputIsIdentity = `false`
	)		const

inline

                                                                                                       {
     if (inputIsIdentity && m_reverse) inputIsIdentity = false;
     // if the entries are large enough, then apply the reflectors by block
     if (m_length >= BlockSize && dst.cols() > 1) {
       // Make sure we have at least 2 useful blocks, otherwise it is point-less:
       Index blockSize = m_length < Index(2 * BlockSize) ? (m_length + 1) / 2 : Index(BlockSize);
       for (Index i = 0; i < m_length; i += blockSize) {
         Index end = m_reverse ? (std::min)(m_length, i + blockSize) : m_length - i;
         Index k = m_reverse ? i : (std::max)(Index(0), end - blockSize);
         Index bs = end - k;
         Index start = k + m_shift;
  
         typedef Block<internal::remove_all_t<VectorsType>, Dynamic, Dynamic> SubVectorsType;
         SubVectorsType sub_vecs1(m_vectors.const_cast_derived(), Side == OnTheRight ? k : start,
                                  Side == OnTheRight ? start : k, Side == OnTheRight ? bs : m_vectors.rows() - start,
                                  Side == OnTheRight ? m_vectors.cols() - start : bs);
         std::conditional_t<Side == OnTheRight, Transpose<SubVectorsType>, SubVectorsType&> sub_vecs(sub_vecs1);
  
         Index dstRows = rows() - m_shift - k;
  
         if (inputIsIdentity) {
           Block<Dest, Dynamic, Dynamic> sub_dst = dst.bottomRightCorner(dstRows, dstRows);
           apply_block_householder_on_the_left(sub_dst, sub_vecs, m_coeffs.segment(k, bs), !m_reverse);
         } else {
           auto sub_dst = dst.bottomRows(dstRows);
           apply_block_householder_on_the_left(sub_dst, sub_vecs, m_coeffs.segment(k, bs), !m_reverse);
         }
       }
     } else {
       workspace.resize(dst.cols());
       for (Index k = 0; k < m_length; ++k) {
         Index actual_k = m_reverse ? k : m_length - k - 1;
         Index dstRows = rows() - m_shift - actual_k;
  
         if (inputIsIdentity) {
           Block<Dest, Dynamic, Dynamic> sub_dst = dst.bottomRightCorner(dstRows, dstRows);
           sub_dst.applyHouseholderOnTheLeft(essentialVector(actual_k), m_coeffs.coeff(actual_k), workspace.data());
         } else {
           auto sub_dst = dst.bottomRows(dstRows);
           sub_dst.applyHouseholderOnTheLeft(essentialVector(actual_k), m_coeffs.coeff(actual_k), workspace.data());
         }
       }
     }
   }

◆ applyThisOnTheRight() [1/2]

template<typename VectorsType , typename CoeffsType , int Side>

template<typename Dest >

void Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::applyThisOnTheRight ( Dest & dst ) const

inline

                                                    {
     Matrix<Scalar, 1, Dest::RowsAtCompileTime, RowMajor, 1, Dest::MaxRowsAtCompileTime> workspace(dst.rows());
     applyThisOnTheRight(dst, workspace);
   }

Referenced by Eigen::operator*().

◆ applyThisOnTheRight() [2/2]

template<typename VectorsType , typename CoeffsType , int Side>

template<typename Dest , typename Workspace >

void Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::applyThisOnTheRight	(	Dest &	dst,
		Workspace &	workspace
	)		const

inline

                                                                          {
     workspace.resize(dst.rows());
     for (Index k = 0; k < m_length; ++k) {
       Index actual_k = m_reverse ? m_length - k - 1 : k;
       dst.rightCols(rows() - m_shift - actual_k)
           .applyHouseholderOnTheRight(essentialVector(actual_k), m_coeffs.coeff(actual_k), workspace.data());
     }
   }

References Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::essentialVector(), k, Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_coeffs, Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_length, Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_reverse, Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_shift, and Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::rows().

◆ cols()

template<typename VectorsType , typename CoeffsType , int Side>

EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::cols ( ) const

inline

Number of columns of transformation viewed as a matrix.

Returns: Number of columns

This equals the dimension of the space that the transformation acts on.

194 { return rows(); }

References Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::rows().

Referenced by gdb.printers._MatrixEntryIterator::__next__(), gdb.printers.EigenMatrixPrinter::children(), gdb.printers.EigenSparseMatrixPrinter::children(), Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::evalTo(), gdb.printers.EigenMatrixPrinter::to_string(), and gdb.printers.EigenSparseMatrixPrinter::to_string().

◆ conjugate()

template<typename VectorsType , typename CoeffsType , int Side>

ConjugateReturnType Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::conjugate ( void ) const

inline

Complex conjugate of the Householder sequence.

                                         {
     return ConjugateReturnType(m_vectors.conjugate(), m_coeffs.conjugate())
         .setReverseFlag(m_reverse)
         .setLength(m_length)
         .setShift(m_shift);
   }

References Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_coeffs, Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_length, Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_reverse, Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_shift, and Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_vectors.

Referenced by householder().

◆ conjugateIf()

template<typename VectorsType , typename CoeffsType , int Side>

template<bool Cond>

EIGEN_DEVICE_FUNC std::conditional_t<Cond, ConjugateReturnType, ConstHouseholderSequence> Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::conjugateIf ( ) const

inline

Returns: an expression of the complex conjugate of *this if Cond==true, returns *this otherwise.

                                                                                                                      {
     typedef std::conditional_t<Cond, ConjugateReturnType, ConstHouseholderSequence> ReturnType;
     return ReturnType(m_vectors.template conjugateIf<Cond>(), m_coeffs.template conjugateIf<Cond>());
   }

References Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_coeffs, and Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_vectors.

◆ essentialVector()

template<typename VectorsType , typename CoeffsType , int Side>

EIGEN_DEVICE_FUNC const EssentialVectorType Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::essentialVector ( Index k ) const

inline

Essential part of a Householder vector.

Parameters

[in] k Index of Householder reflection

Returns: Vector containing non-trivial entries of k-th Householder vector

This function returns the essential part of the Householder vector \( v_i \). This is a vector of length \( n-i \) containing the last \( n-i \) entries of the vector

\[ v_i = [\underbrace{0, \ldots, 0}_{i-1\mbox{ zeros}}, 1, \underbrace{*, \ldots,*}_{n-i\mbox{ arbitrary entries}} ]. \]

The index \( i \) equals k + shift(), corresponding to the k-th column of the matrix v passed to the constructor.

See also: setShift(), shift()

                                                                              {
     eigen_assert(k >= 0 && k < m_length);
     return internal::hseq_side_dependent_impl<VectorsType, CoeffsType, Side>::essentialVector(*this, k);
   }

References eigen_assert, Eigen::internal::hseq_side_dependent_impl< VectorsType, CoeffsType, Side >::essentialVector(), k, and Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_length.

Referenced by Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::applyThisOnTheLeft(), Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::applyThisOnTheRight(), and Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::evalTo().

◆ evalTo() [1/2]

template<typename VectorsType , typename CoeffsType , int Side>

template<typename Dest , typename Workspace >

EIGEN_DEVICE_FUNC void Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::evalTo	(	Dest &	dst,
		Workspace &	workspace
	)		const

inline

                                                                        {
     workspace.resize(rows());
     Index vecs = m_length;
     if (internal::is_same_dense(dst, m_vectors)) {
       // in-place
       dst.diagonal().setOnes();
       dst.template triangularView<StrictlyUpper>().setZero();
       for (Index k = vecs - 1; k >= 0; --k) {
         Index cornerSize = rows() - k - m_shift;
         if (m_reverse)
           dst.bottomRightCorner(cornerSize, cornerSize)
               .applyHouseholderOnTheRight(essentialVector(k), m_coeffs.coeff(k), workspace.data());
         else
           dst.bottomRightCorner(cornerSize, cornerSize)
               .applyHouseholderOnTheLeft(essentialVector(k), m_coeffs.coeff(k), workspace.data());
  
         // clear the off diagonal vector
         dst.col(k).tail(rows() - k - 1).setZero();
       }
       // clear the remaining columns if needed
       for (Index k = 0; k < cols() - vecs; ++k) dst.col(k).tail(rows() - k - 1).setZero();
     } else if (m_length > BlockSize) {
       dst.setIdentity(rows(), rows());
       if (m_reverse)
         applyThisOnTheLeft(dst, workspace, true);
       else
         applyThisOnTheLeft(dst, workspace, true);
     } else {
       dst.setIdentity(rows(), rows());
       for (Index k = vecs - 1; k >= 0; --k) {
         Index cornerSize = rows() - k - m_shift;
         if (m_reverse)
           dst.bottomRightCorner(cornerSize, cornerSize)
               .applyHouseholderOnTheRight(essentialVector(k), m_coeffs.coeff(k), workspace.data());
         else
           dst.bottomRightCorner(cornerSize, cornerSize)
               .applyHouseholderOnTheLeft(essentialVector(k), m_coeffs.coeff(k), workspace.data());
       }
     }
   }

◆ evalTo() [2/2]

template<typename VectorsType , typename CoeffsType , int Side>

template<typename DestType >

EIGEN_DEVICE_FUNC void Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::evalTo ( DestType & dst ) const

inline

                                                             {
     Matrix<Scalar, DestType::RowsAtCompileTime, 1, AutoAlign | ColMajor, DestType::MaxRowsAtCompileTime, 1> workspace(
         rows());
     evalTo(dst, workspace);
   }

References Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::rows().

Referenced by Eigen::internal::tridiagonalization_inplace_selector< MatrixType, Size, IsComplex >::run().

◆ inverse()

template<typename VectorsType , typename CoeffsType , int Side>

AdjointReturnType Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::inverse ( ) const

inline

Inverse of the Householder sequence (equals the adjoint).

249 { return adjoint(); }

Eigen::HouseholderSequence::adjoint

AdjointReturnType adjoint() const

Adjoint (conjugate transpose) of the Householder sequence.

Definition: HouseholderSequence.h:241

References Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::adjoint().

Referenced by randomMatrixWithRealEivals(), randomMatrixWithImagEivals< MatrixType, 0 >::run(), and randomMatrixWithImagEivals< MatrixType, 1 >::run().

◆ length()

template<typename VectorsType , typename CoeffsType , int Side>

EIGEN_DEVICE_FUNC Index Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::length ( ) const

inline

Returns the length of the Householder sequence.

References Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_length.

Referenced by householder(), and Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::setLength().

◆ operator*()

template<typename VectorsType , typename CoeffsType , int Side>

template<typename OtherDerived >

internal::matrix_type_times_scalar_type<Scalar, OtherDerived>::Type Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::operator* ( const MatrixBase< OtherDerived > & other ) const

inline

Computes the product of a Householder sequence with a matrix.

Parameters

[in] other Matrix being multiplied.

Returns: Expression object representing the product.

This function computes \( HM \) where \( H \) is the Householder sequence represented by *this and \( M \) is the matrix other.

                                                    {
     typename internal::matrix_type_times_scalar_type<Scalar, OtherDerived>::Type res(
         other.template cast<typename internal::matrix_type_times_scalar_type<Scalar, OtherDerived>::ResultScalar>());
     applyThisOnTheLeft(res, internal::is_identity<OtherDerived>::value && res.rows() == res.cols());
     return res;
   }

References Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::applyThisOnTheLeft(), Eigen::internal::cast(), and res.

◆ reverseFlag()

template<typename VectorsType , typename CoeffsType , int Side>

bool Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::reverseFlag ( ) const

inlineprotected

Returns the reverse flag.

References Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_reverse.

◆ rows()

template<typename VectorsType , typename CoeffsType , int Side>

EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::rows ( ) const

inline

Number of rows of transformation viewed as a matrix.

Returns: Number of rows

This equals the dimension of the space that the transformation acts on.

                                                                       {
     return Side == OnTheLeft ? m_vectors.rows() : m_vectors.cols();
   }

References Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_vectors, and Eigen::OnTheLeft.

Referenced by gdb.printers._MatrixEntryIterator::__next__(), Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::applyThisOnTheLeft(), Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::applyThisOnTheRight(), gdb.printers.EigenMatrixPrinter::children(), gdb.printers.EigenSparseMatrixPrinter::children(), Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::cols(), Eigen::internal::hseq_side_dependent_impl< VectorsType, CoeffsType, Side >::essentialVector(), Eigen::internal::hseq_side_dependent_impl< VectorsType, CoeffsType, OnTheRight >::essentialVector(), Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::evalTo(), gdb.printers.EigenMatrixPrinter::to_string(), and gdb.printers.EigenSparseMatrixPrinter::to_string().

◆ setLength()

template<typename VectorsType , typename CoeffsType , int Side>

EIGEN_DEVICE_FUNC HouseholderSequence& Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::setLength ( Index length )

inline

Sets the length of the Householder sequence.

Parameters

[in] length New value for the length.

By default, the length \( n \) of the Householder sequence \( H = H_0 H_1 \ldots H_{n-1} \) is set to the number of columns of the matrix v passed to the constructor, or the number of rows if that is smaller. After this function is called, the length equals length.

See also: length()

                                                                  {
     m_length = length;
     return *this;
   }

References Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::length(), and Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_length.

Referenced by householder(), and Eigen::internal::tridiagonalization_inplace_selector< MatrixType, Size, IsComplex >::run().

◆ setReverseFlag()

template<typename VectorsType , typename CoeffsType , int Side>

HouseholderSequence& Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::setReverseFlag ( bool reverse )

inlineprotected

Sets the reverse flag.

Parameters

[in] reverse New value of the reverse flag.

By default, the reverse flag is not set. If the reverse flag is set, then this object represents \( H^r = H_{n-1} \ldots H_1 H_0 \) instead of \( H = H_0 H_1 \ldots H_{n-1} \).

Note: For real valued HouseholderSequence this is equivalent to transposing \( H \).

See also: reverseFlag(), transpose(), adjoint()

                                                     {
     m_reverse = reverse;
     return *this;
   }

References Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_reverse, and reverse().

◆ setShift()

template<typename VectorsType , typename CoeffsType , int Side>

EIGEN_DEVICE_FUNC HouseholderSequence& Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::setShift ( Index shift )

inline

Sets the shift of the Householder sequence.

Parameters

[in] shift New value for the shift.

By default, a HouseholderSequence object represents \( H = H_0 H_1 \ldots H_{n-1} \) and the i-th column of the matrix v passed to the constructor corresponds to the i-th Householder reflection. After this function is called, the object represents \( H = H_{\mathrm{shift}} H_{\mathrm{shift}+1} \ldots H_{n-1} \) and the i-th column of v corresponds to the (shift+i)-th Householder reflection.

See also: shift()

                                                                {
     m_shift = shift;
     return *this;
   }

References Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_shift, and Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::shift().

Referenced by householder(), and Eigen::internal::tridiagonalization_inplace_selector< MatrixType, Size, IsComplex >::run().

◆ shift()

template<typename VectorsType , typename CoeffsType , int Side>

EIGEN_DEVICE_FUNC Index Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::shift ( ) const

inline

Returns the shift of the Householder sequence.

References Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_shift.

Referenced by householder(), and Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::setShift().

◆ transpose()

template<typename VectorsType , typename CoeffsType , int Side>

TransposeReturnType Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::transpose ( ) const

inline

Transpose of the Householder sequence.

                                         {
     return TransposeReturnType(m_vectors.conjugate(), m_coeffs)
         .setReverseFlag(!m_reverse)
         .setLength(m_length)
         .setShift(m_shift);
   }

References Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_coeffs, Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_length, Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_reverse, Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_shift, and Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_vectors.

Referenced by householder(), Eigen::HybridNonLinearSolver< FunctorType, Scalar >::solveNumericalDiffOneStep(), and Eigen::HybridNonLinearSolver< FunctorType, Scalar >::solveOneStep().

Friends And Related Function Documentation

◆ HouseholderSequence

template<typename VectorsType , typename CoeffsType , int Side>

template<typename VectorsType2 , typename CoeffsType2 , int Side2>

friend class HouseholderSequence

friend

◆ internal::hseq_side_dependent_impl

template<typename VectorsType , typename CoeffsType , int Side>

template<typename VectorsType_ , typename CoeffsType_ , int Side_>

friend struct internal::hseq_side_dependent_impl

friend

Member Data Documentation

◆ m_coeffs

template<typename VectorsType , typename CoeffsType , int Side>

CoeffsType::Nested Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_coeffs

protected

Referenced by Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::adjoint(), Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::applyThisOnTheLeft(), Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::applyThisOnTheRight(), Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::conjugate(), Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::conjugateIf(), Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::evalTo(), and Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::transpose().

◆ m_length

template<typename VectorsType , typename CoeffsType , int Side>

Index Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_length

protected

◆ m_reverse

template<typename VectorsType , typename CoeffsType , int Side>

bool Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_reverse

protected

◆ m_shift

template<typename VectorsType , typename CoeffsType , int Side>

Index Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_shift

protected

◆ m_vectors

template<typename VectorsType , typename CoeffsType , int Side>

VectorsType::Nested Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::m_vectors

protected

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

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Types

Friends

Detailed Description

template<typename VectorsType, typename CoeffsType, int Side> class Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >

Member Typedef Documentation

◆ AdjointReturnType

◆ ConjugateReturnType

◆ ConstHouseholderSequence

◆ EssentialVectorType

◆ Scalar

◆ TransposeReturnType

Member Enumeration Documentation

◆ anonymous enum

◆ anonymous enum

Constructor & Destructor Documentation

◆ HouseholderSequence() [1/2]

◆ HouseholderSequence() [2/2]

Member Function Documentation

◆ adjoint()

◆ applyThisOnTheLeft() [1/2]

◆ applyThisOnTheLeft() [2/2]

◆ applyThisOnTheRight() [1/2]

◆ applyThisOnTheRight() [2/2]

◆ cols()

◆ conjugate()

◆ conjugateIf()

◆ essentialVector()

◆ evalTo() [1/2]

◆ evalTo() [2/2]

◆ inverse()

◆ length()

◆ operator*()

◆ reverseFlag()

◆ rows()

◆ setLength()

◆ setReverseFlag()

◆ setShift()

◆ shift()

◆ transpose()

Friends And Related Function Documentation

◆ HouseholderSequence

◆ internal::hseq_side_dependent_impl

Member Data Documentation

◆ m_coeffs

◆ m_length

◆ m_reverse

◆ m_shift

◆ m_vectors

template<typename VectorsType, typename CoeffsType, int Side>
class Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >