Eigen::HouseholderSequence< VectorsType, CoeffsType, Side > Class Template Reference

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

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

Public Types
enum	{   RowsAtCompileTime ,   ColsAtCompileTime ,   MaxRowsAtCompileTime ,   MaxColsAtCompileTime }
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 >, std::conditional_t< NumTraits< Scalar >::IsComplex, internal::remove_all_t< typename CoeffsType::ConjugateReturnType >, CoeffsType >, Side >	ConjugateReturnType
typedef HouseholderSequence< std::add_const_t< VectorsType >, std::add_const_t< CoeffsType >, Side >	ConstHouseholderSequence
typedef internal::traits< HouseholderSequence >::Scalar	Scalar
typedef HouseholderSequence< std::conditional_t< NumTraits< Scalar >::IsComplex, internal::remove_all_t< typename VectorsType::ConjugateReturnType >, VectorsType >, CoeffsType, Side >	TransposeReturnType
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
AdjointReturnType	adjoint () const
	Adjoint (conjugate transpose) of the Householder sequence. More...
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 Dest >
void	applyThisOnTheRight (Dest &dst) const
template<typename Dest , typename Workspace >
void	applyThisOnTheRight (Dest &dst, Workspace &workspace) const
EIGEN_CONSTEXPR Index	cols () const EIGEN_NOEXCEPT
	Number of columns of transformation viewed as a matrix. More...
ConjugateReturnType	conjugate () const
	Complex conjugate of the Householder sequence. More...
template<bool Cond>
std::conditional_t< Cond, ConjugateReturnType, ConstHouseholderSequence >	conjugateIf () const
const EssentialVectorType	essentialVector (Index k) const
	Essential part of a Householder vector. More...
template<typename Dest , typename Workspace >
void	evalTo (Dest &dst, Workspace &workspace) const
template<typename DestType >
void	evalTo (DestType &dst) const
	HouseholderSequence (const HouseholderSequence &other)
	Copy constructor. More...
	HouseholderSequence (const VectorsType &v, const CoeffsType &h)
	Constructor. More...
AdjointReturnType	inverse () const
	Inverse of the Householder sequence (equals the adjoint). More...
Index	length () const
	Returns the length of the Householder sequence. More...
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_CONSTEXPR Index	rows () const EIGEN_NOEXCEPT
	Number of rows of transformation viewed as a matrix. More...
HouseholderSequence &	setLength (Index length)
	Sets the length of the Householder sequence. More...
HouseholderSequence &	setShift (Index shift)
	Sets the shift of the Householder sequence. More...
Index	shift () const
	Returns the shift of the Householder sequence. More...
TransposeReturnType	transpose () const
	Transpose of the Householder sequence. More...
Public Member Functions inherited from Eigen::EigenBase< HouseholderSequence< VectorsType, CoeffsType, Side > >
void	addTo (Dest &dst) const
void	applyThisOnTheLeft (Dest &dst) const
void	applyThisOnTheRight (Dest &dst) const
EIGEN_CONSTEXPR Index	cols () const EIGEN_NOEXCEPT
HouseholderSequence< VectorsType, CoeffsType, Side > &	const_cast_derived () const
const HouseholderSequence< VectorsType, CoeffsType, Side > &	const_derived () const
HouseholderSequence< VectorsType, CoeffsType, Side > &	derived ()
const HouseholderSequence< VectorsType, CoeffsType, Side > &	derived () const
void	evalTo (Dest &dst) const
EIGEN_CONSTEXPR Index	rows () const EIGEN_NOEXCEPT
EIGEN_CONSTEXPR Index	size () const EIGEN_NOEXCEPT
void	subTo (Dest &dst) const

Protected Types
enum	{ BlockSize }

Protected Member Functions
bool	reverseFlag () const
HouseholderSequence &	setReverseFlag (bool reverse)

Protected Attributes
CoeffsType::Nested	m_coeffs
Index	m_length
bool	m_reverse
Index	m_shift
VectorsType::Nested	m_vectors

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

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.

This is defined in the Householder module.

#include <Eigen/Householder> 

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

Definition at line 121 of file HouseholderSequence.h.

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

Definition at line 151 of file HouseholderSequence.h.

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

Definition at line 143 of file HouseholderSequence.h.

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

Definition at line 165 of file HouseholderSequence.h.

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

Definition at line 124 of file HouseholderSequence.h.

Scalar

template<typename VectorsType , typename CoeffsType , int Side>

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

Definition at line 133 of file HouseholderSequence.h.

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

Definition at line 159 of file HouseholderSequence.h.

Member Enumeration Documentation

anonymous enum

template<typename VectorsType , typename CoeffsType , int Side>

anonymous enum

Enumerator
RowsAtCompileTime
ColsAtCompileTime
MaxRowsAtCompileTime
MaxColsAtCompileTime

Definition at line 127 of file HouseholderSequence.h.

         {
      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

Definition at line 516 of file HouseholderSequence.h.

{ BlockSize = 48 };

Constructor & Destructor Documentation

HouseholderSequence() [1/2]

template<typename VectorsType , typename CoeffsType , int Side>

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:

The matrix v is:
  0.68  0.597  -0.33
-0.211  0.823  0.536
 0.566 -0.605 -0.444
The first Householder vector is: v_0 =      1 -0.211  0.566
The second Householder vector is: v_1 =      0      1 -0.605
The third Householder vector is: v_2 = 0 0 1
The Householder coefficients are: h =   0.108 -0.0452   0.258
The first Householder reflection is represented by H_0 = 
  0.892  0.0228 -0.0611
 0.0228   0.995  0.0129
-0.0611  0.0129   0.965
The second Householder reflection is represented by H_1 = 
      1       0       0
      0    1.05 -0.0273
      0 -0.0273    1.02
The third Householder reflection is represented by H_2 = 
    1     0     0
    0     1     0
    0     0 0.742
Their product is H_0 H_1 H_2 = 
  0.892  0.0255 -0.0466
 0.0228    1.04 -0.0105
-0.0611 -0.0129   0.728
If we construct a HouseholderSequence from v and h
and convert it to a matrix, we get:
  0.892  0.0255 -0.0466
 0.0228    1.04 -0.0105
-0.0611 -0.0129   0.728

See also

setLength(), setShift()

Definition at line 185 of file HouseholderSequence.h.

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

HouseholderSequence() [2/2]

template<typename VectorsType , typename CoeffsType , int Side>

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

inline

Copy constructor.

Definition at line 193 of file HouseholderSequence.h.

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

Definition at line 268 of file HouseholderSequence.h.

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

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

Definition at line 363 of file HouseholderSequence.h.

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

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

Definition at line 371 of file HouseholderSequence.h.

    {
      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

Definition at line 343 of file HouseholderSequence.h.

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

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

Definition at line 351 of file HouseholderSequence.h.

    {
      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());
      }
    }

cols()

template<typename VectorsType , typename CoeffsType , int Side>

EIGEN_CONSTEXPR Index Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::cols ( void  ) 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.

Definition at line 214 of file HouseholderSequence.h.

{ return rows(); }

conjugate()

template<typename VectorsType , typename CoeffsType , int Side>

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

inline

Complex conjugate of the Householder sequence.

Definition at line 247 of file HouseholderSequence.h.

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

conjugateIf()

template<typename VectorsType , typename CoeffsType , int Side>

template<bool Cond>

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.

Definition at line 261 of file HouseholderSequence.h.

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

essentialVector()

template<typename VectorsType , typename CoeffsType , int Side>

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

Definition at line 231 of file HouseholderSequence.h.

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

evalTo() [1/2]

template<typename VectorsType , typename CoeffsType , int Side>

template<typename Dest , typename Workspace >

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

inline

Definition at line 292 of file HouseholderSequence.h.

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

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

inline

Definition at line 282 of file HouseholderSequence.h.

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

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

Definition at line 277 of file HouseholderSequence.h.

{ return adjoint(); }

length()

template<typename VectorsType , typename CoeffsType , int Side>

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

inline

Returns the length of the Householder sequence.

Definition at line 483 of file HouseholderSequence.h.

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.

Definition at line 438 of file HouseholderSequence.h.

    {
      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;
    }

reverseFlag()

template<typename VectorsType , typename CoeffsType , int Side>

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

inlineprotected

Definition at line 509 of file HouseholderSequence.h.

rows()

template<typename VectorsType , typename CoeffsType , int Side>

EIGEN_CONSTEXPR Index Eigen::HouseholderSequence< VectorsType, CoeffsType, Side >::rows ( void  ) 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.

Definition at line 207 of file HouseholderSequence.h.

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

setLength()

template<typename VectorsType , typename CoeffsType , int Side>

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

Definition at line 458 of file HouseholderSequence.h.

    {
      m_length = length;
      return *this;
    }

setReverseFlag()

template<typename VectorsType , typename CoeffsType , int Side>

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

inlineprotected

Definition at line 503 of file HouseholderSequence.h.

    {
      m_reverse = reverse;
      return *this;
    }

setShift()

template<typename VectorsType , typename CoeffsType , int Side>

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

Definition at line 476 of file HouseholderSequence.h.

    {
      m_shift = shift;
      return *this;
    }

shift()

template<typename VectorsType , typename CoeffsType , int Side>

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

inline

Returns the shift of the Householder sequence.

Definition at line 486 of file HouseholderSequence.h.

transpose()

template<typename VectorsType , typename CoeffsType , int Side>

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

inline

Transpose of the Householder sequence.

Definition at line 238 of file HouseholderSequence.h.

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

Member Data Documentation

m_coeffs

template<typename VectorsType , typename CoeffsType , int Side>

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

protected

Definition at line 512 of file HouseholderSequence.h.

m_length

template<typename VectorsType , typename CoeffsType , int Side>

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

protected

Definition at line 514 of file HouseholderSequence.h.

m_reverse

template<typename VectorsType , typename CoeffsType , int Side>

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

protected

Definition at line 513 of file HouseholderSequence.h.

m_shift

template<typename VectorsType , typename CoeffsType , int Side>

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

protected

Definition at line 515 of file HouseholderSequence.h.

m_vectors

template<typename VectorsType , typename CoeffsType , int Side>

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

protected

Definition at line 511 of file HouseholderSequence.h.

---

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

• ForwardDeclarations.h
• HouseholderSequence.h