Performs a real QZ decomposition of a pair of square matrices. More...

#include <RealQZ.h>

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 std::complex< typename NumTraits< Scalar >::Real >	ComplexScalar

typedef MatrixType::Index	Index

typedef Matrix< ComplexScalar, ColsAtCompileTime, 1, Options &~RowMajor, MaxColsAtCompileTime, 1 >	EigenvalueType

typedef Matrix< Scalar, ColsAtCompileTime, 1, Options &~RowMajor, MaxColsAtCompileTime, 1 >	ColumnVectorType

Public Member Functions
	RealQZ (Index size=RowsAtCompileTime==Dynamic?1:RowsAtCompileTime)
	Default constructor. More...

	RealQZ (const MatrixType &A, const MatrixType &B, bool computeQZ=true)
	Constructor; computes real QZ decomposition of given matrices. More...

const MatrixType &	matrixQ () const
	Returns matrix Q in the QZ decomposition. More...

const MatrixType &	matrixZ () const
	Returns matrix Z in the QZ decomposition. More...

const MatrixType &	matrixS () const
	Returns matrix S in the QZ decomposition. More...

const MatrixType &	matrixT () const
	Returns matrix S in the QZ decomposition. More...

RealQZ &	compute (const MatrixType &A, const MatrixType &B, bool computeQZ=true)
	Computes QZ decomposition of given matrix. More...

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

Index	iterations () const
	Returns number of performed QR-like iterations.

RealQZ &	setMaxIterations (Index maxIters)

Detailed Description

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

Performs a real QZ decomposition of a pair of square matrices.

Template Parameters

_MatrixType the type of the matrix of which we are computing the real QZ decomposition; this is expected to be an instantiation of the Matrix class template.

Given a real square matrices A and B, this class computes the real QZ decomposition: $ A = Q S Z $ , $ B = Q T Z $ where Q and Z are real orthogonal matrixes, T is upper-triangular matrix, and S is upper quasi-triangular matrix. An orthogonal matrix is a matrix whose inverse is equal to its transpose, $U^{-1} = U^T$ . A quasi-triangular matrix is a block-triangular matrix whose diagonal consists of 1-by-1 blocks and 2-by-2 blocks where further reduction is impossible due to complex eigenvalues.

The eigenvalues of the pencil $ A - z B $ can be obtained from 1x1 and 2x2 blocks on the diagonals of S and T.

Call the function compute() to compute the real QZ decomposition of a given pair of matrices. Alternatively, you can use the RealQZ(const MatrixType& B, const MatrixType& B, bool computeQZ) constructor which computes the real QZ decomposition at construction time. Once the decomposition is computed, you can use the matrixS(), matrixT(), matrixQ() and matrixZ() functions to retrieve the matrices S, T, Q and Z in the decomposition. If computeQZ==false, some time is saved by not computing matrices Q and Z.

Example:

Output:

Note: The implementation is based on the algorithm in "Matrix Computations" by Gene H. Golub and Charles F. Van Loan, and a paper "An algorithm for generalized eigenvalue problems" by C.B.Moler and G.W.Stewart.

See also: class RealSchur, class ComplexSchur, class EigenSolver, class ComplexEigenSolver

Definition at line 57 of file RealQZ.h.

Constructor & Destructor Documentation

template<typename _MatrixType>

Eigen::RealQZ< _MatrixType >::RealQZ ( Index size = RowsAtCompileTime==Dynamic ? 1 : RowsAtCompileTime )

inline

Default constructor.

Parameters

[in] size Positive integer, size of the matrix whose QZ decomposition will be computed.

The default constructor is useful in cases in which the user intends to perform decompositions via compute(). The size parameter is only used as a hint. It is not an error to give a wrong size, but it may impair performance.

See also: compute() for an example.

Definition at line 86 of file RealQZ.h.

                                                          : RowsAtCompileTime) : 
         m_S(size, size),
         m_T(size, size),
         m_Q(size, size),
         m_Z(size, size),
         m_workspace(size*2),
         m_maxIters(400),
         m_isInitialized(false)
         { }

template<typename _MatrixType>

Eigen::RealQZ< _MatrixType >::RealQZ	(	const MatrixType &	A,
		const MatrixType &	B,
		bool	computeQZ = `true`
	)

inline

Constructor; computes real QZ decomposition of given matrices.

Parameters

[in]	A	Matrix A.
[in]	B	Matrix B.
[in]	computeQZ	If false, A and Z are not computed.

This constructor calls compute() to compute the QZ decomposition.

Definition at line 104 of file RealQZ.h.

                                                                               :
         m_S(A.rows(),A.cols()),
         m_T(A.rows(),A.cols()),
         m_Q(A.rows(),A.cols()),
         m_Z(A.rows(),A.cols()),
         m_workspace(A.rows()*2),
         m_maxIters(400),
         m_isInitialized(false) {
           compute(A, B, computeQZ);
         }

Member Function Documentation

template<typename MatrixType >

RealQZ< MatrixType > & Eigen::RealQZ< MatrixType >::compute	(	const MatrixType &	A,
		const MatrixType &	B,
		bool	computeQZ = `true`
	)

Computes QZ decomposition of given matrix.

Parameters

[in]	A	Matrix A.
[in]	B	Matrix B.
[in]	computeQZ	If false, A and Z are not computed.

Returns: Reference to *this

Definition at line 557 of file RealQZ.h.

     {
 
       const Index dim = A_in.cols();
 
       eigen_assert (A_in.rows()==dim && A_in.cols()==dim 
           && B_in.rows()==dim && B_in.cols()==dim 
           && "Need square matrices of the same dimension");
 
       m_isInitialized = true;
       m_computeQZ = computeQZ;
       m_S = A_in; m_T = B_in;
       m_workspace.resize(dim*2);
       m_global_iter = 0;
 
       // entrance point: hessenberg triangular decomposition
       hessenbergTriangular();
       // compute L1 vector norms of T, S into m_normOfS, m_normOfT
       computeNorms();
 
       Index l = dim-1, 
             f, 
             local_iter = 0;
 
       while (l>0 && local_iter<m_maxIters)
       {
         f = findSmallSubdiagEntry(l);
         // now rows and columns f..l (including) decouple from the rest of the problem
         if (f>0) m_S.coeffRef(f,f-1) = Scalar(0.0);
         if (f == l) // One root found
         {
           l--;
           local_iter = 0;
         }
         else if (f == l-1) // Two roots found
         {
           splitOffTwoRows(f);
           l -= 2;
           local_iter = 0;
         }
         else // No convergence yet
         {
           // if there's zero on diagonal of T, we can isolate an eigenvalue with Givens rotations
           Index z = findSmallDiagEntry(f,l);
           if (z>=f)
           {
             // zero found
             pushDownZero(z,f,l);
           }
           else
           {
             // We are sure now that S.block(f,f, l-f+1,l-f+1) is underuced upper-Hessenberg 
             // and T.block(f,f, l-f+1,l-f+1) is invertible uper-triangular, which allows to
             // apply a QR-like iteration to rows and columns f..l.
             step(f,l, local_iter);
             local_iter++;
             m_global_iter++;
           }
         }
       }
       // check if we converged before reaching iterations limit
       m_info = (local_iter<m_maxIters) ? Success : NoConvergence;
       return *this;
     } // end compute

template<typename _MatrixType>

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

inline

Reports whether previous computation was successful.

Returns: Success if computation was succesful, NoConvergence otherwise.

Definition at line 166 of file RealQZ.h.

       {
         eigen_assert(m_isInitialized && "RealQZ is not initialized.");
         return m_info;
       }

template<typename _MatrixType>

const MatrixType& Eigen::RealQZ< _MatrixType >::matrixQ ( void ) const

inline

Returns matrix Q in the QZ decomposition.

Returns: A const reference to the matrix Q.

Definition at line 119 of file RealQZ.h.

                                         {
         eigen_assert(m_isInitialized && "RealQZ is not initialized.");
         eigen_assert(m_computeQZ && "The matrices Q and Z have not been computed during the QZ decomposition.");
         return m_Q;
       }

template<typename _MatrixType>

const MatrixType& Eigen::RealQZ< _MatrixType >::matrixS ( ) const

inline

Returns matrix S in the QZ decomposition.

Returns: A const reference to the matrix S.

Definition at line 139 of file RealQZ.h.

                                         {
         eigen_assert(m_isInitialized && "RealQZ is not initialized.");
         return m_S;
       }

template<typename _MatrixType>

const MatrixType& Eigen::RealQZ< _MatrixType >::matrixT ( ) const

inline

Returns matrix S in the QZ decomposition.

Returns: A const reference to the matrix S.

Definition at line 148 of file RealQZ.h.

                                         {
         eigen_assert(m_isInitialized && "RealQZ is not initialized.");
         return m_T;
       }

template<typename _MatrixType>

const MatrixType& Eigen::RealQZ< _MatrixType >::matrixZ ( ) const

inline

Returns matrix Z in the QZ decomposition.

Returns: A const reference to the matrix Z.

Definition at line 129 of file RealQZ.h.

                                         {
         eigen_assert(m_isInitialized && "RealQZ is not initialized.");
         eigen_assert(m_computeQZ && "The matrices Q and Z have not been computed during the QZ decomposition.");
         return m_Z;
       }

template<typename _MatrixType>

RealQZ& Eigen::RealQZ< _MatrixType >::setMaxIterations ( Index maxIters )

inline

Sets the maximal number of iterations allowed to converge to one eigenvalue or decouple the problem.

Definition at line 183 of file RealQZ.h.

       {
         m_maxIters = maxIters;
         return *this;
       }

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

C:/Users/Brig/Documents/ShapeWorksStudio/src/Surfworks/Eigen/src/Eigenvalues/RealQZ.h

Public Types

Public Member Functions

Detailed Description

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

Constructor & Destructor Documentation

Member Function Documentation

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