Please, help us to better know about our user community by answering the following short survey: https://forms.gle/wpyrxWi18ox9Z5ae9
Eigen  3.4.99 (git rev 10c77b0ff44d0b9cb0b252cfa0ccaaa39d3c5da4)
RealQZ.h
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2012 Alexey Korepanov <kaikaikai@yandex.ru>
5 //
6 // This Source Code Form is subject to the terms of the Mozilla
7 // Public License v. 2.0. If a copy of the MPL was not distributed
8 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
9 
10 #ifndef EIGEN_REAL_QZ_H
11 #define EIGEN_REAL_QZ_H
12 
13 namespace Eigen {
14 
57  template<typename _MatrixType> class RealQZ
58  {
59  public:
60  typedef _MatrixType MatrixType;
61  enum {
62  RowsAtCompileTime = MatrixType::RowsAtCompileTime,
63  ColsAtCompileTime = MatrixType::ColsAtCompileTime,
64  Options = MatrixType::Options,
65  MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
66  MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
67  };
68  typedef typename MatrixType::Scalar Scalar;
69  typedef std::complex<typename NumTraits<Scalar>::Real> ComplexScalar;
70  typedef Eigen::Index Index;
71 
74 
86  explicit RealQZ(Index size = RowsAtCompileTime==Dynamic ? 1 : RowsAtCompileTime) :
87  m_S(size, size),
88  m_T(size, size),
89  m_Q(size, size),
90  m_Z(size, size),
91  m_workspace(size*2),
92  m_maxIters(400),
93  m_isInitialized(false),
94  m_computeQZ(true)
95  {}
96 
105  RealQZ(const MatrixType& A, const MatrixType& B, bool computeQZ = true) :
106  m_S(A.rows(),A.cols()),
107  m_T(A.rows(),A.cols()),
108  m_Q(A.rows(),A.cols()),
109  m_Z(A.rows(),A.cols()),
110  m_workspace(A.rows()*2),
111  m_maxIters(400),
112  m_isInitialized(false),
113  m_computeQZ(true)
114  {
115  compute(A, B, computeQZ);
116  }
117 
122  const MatrixType& matrixQ() const {
123  eigen_assert(m_isInitialized && "RealQZ is not initialized.");
124  eigen_assert(m_computeQZ && "The matrices Q and Z have not been computed during the QZ decomposition.");
125  return m_Q;
126  }
127 
132  const MatrixType& matrixZ() const {
133  eigen_assert(m_isInitialized && "RealQZ is not initialized.");
134  eigen_assert(m_computeQZ && "The matrices Q and Z have not been computed during the QZ decomposition.");
135  return m_Z;
136  }
137 
142  const MatrixType& matrixS() const {
143  eigen_assert(m_isInitialized && "RealQZ is not initialized.");
144  return m_S;
145  }
146 
151  const MatrixType& matrixT() const {
152  eigen_assert(m_isInitialized && "RealQZ is not initialized.");
153  return m_T;
154  }
155 
163  RealQZ& compute(const MatrixType& A, const MatrixType& B, bool computeQZ = true);
164 
170  {
171  eigen_assert(m_isInitialized && "RealQZ is not initialized.");
172  return m_info;
173  }
174 
178  {
179  eigen_assert(m_isInitialized && "RealQZ is not initialized.");
180  return m_global_iter;
181  }
182 
187  {
188  m_maxIters = maxIters;
189  return *this;
190  }
191 
192  private:
193 
194  MatrixType m_S, m_T, m_Q, m_Z;
195  Matrix<Scalar,Dynamic,1> m_workspace;
196  ComputationInfo m_info;
197  Index m_maxIters;
198  bool m_isInitialized;
199  bool m_computeQZ;
200  Scalar m_normOfT, m_normOfS;
201  Index m_global_iter;
202 
203  typedef Matrix<Scalar,3,1> Vector3s;
204  typedef Matrix<Scalar,2,1> Vector2s;
205  typedef Matrix<Scalar,2,2> Matrix2s;
206  typedef JacobiRotation<Scalar> JRs;
207 
208  void hessenbergTriangular();
209  void computeNorms();
210  Index findSmallSubdiagEntry(Index iu);
211  Index findSmallDiagEntry(Index f, Index l);
212  void splitOffTwoRows(Index i);
213  void pushDownZero(Index z, Index f, Index l);
214  void step(Index f, Index l, Index iter);
215 
216  }; // RealQZ
217 
219  template<typename MatrixType>
220  void RealQZ<MatrixType>::hessenbergTriangular()
221  {
222 
223  const Index dim = m_S.cols();
224 
225  // perform QR decomposition of T, overwrite T with R, save Q
226  HouseholderQR<MatrixType> qrT(m_T);
227  m_T = qrT.matrixQR();
228  m_T.template triangularView<StrictlyLower>().setZero();
229  m_Q = qrT.householderQ();
230  // overwrite S with Q* S
231  m_S.applyOnTheLeft(m_Q.adjoint());
232  // init Z as Identity
233  if (m_computeQZ)
234  m_Z = MatrixType::Identity(dim,dim);
235  // reduce S to upper Hessenberg with Givens rotations
236  for (Index j=0; j<=dim-3; j++) {
237  for (Index i=dim-1; i>=j+2; i--) {
238  JRs G;
239  // kill S(i,j)
240  if(m_S.coeff(i,j) != 0)
241  {
242  G.makeGivens(m_S.coeff(i-1,j), m_S.coeff(i,j), &m_S.coeffRef(i-1, j));
243  m_S.coeffRef(i,j) = Scalar(0.0);
244  m_S.rightCols(dim-j-1).applyOnTheLeft(i-1,i,G.adjoint());
245  m_T.rightCols(dim-i+1).applyOnTheLeft(i-1,i,G.adjoint());
246  // update Q
247  if (m_computeQZ)
248  m_Q.applyOnTheRight(i-1,i,G);
249  }
250  // kill T(i,i-1)
251  if(m_T.coeff(i,i-1)!=Scalar(0))
252  {
253  G.makeGivens(m_T.coeff(i,i), m_T.coeff(i,i-1), &m_T.coeffRef(i,i));
254  m_T.coeffRef(i,i-1) = Scalar(0.0);
255  m_S.applyOnTheRight(i,i-1,G);
256  m_T.topRows(i).applyOnTheRight(i,i-1,G);
257  // update Z
258  if (m_computeQZ)
259  m_Z.applyOnTheLeft(i,i-1,G.adjoint());
260  }
261  }
262  }
263  }
264 
266  template<typename MatrixType>
267  inline void RealQZ<MatrixType>::computeNorms()
268  {
269  const Index size = m_S.cols();
270  m_normOfS = Scalar(0.0);
271  m_normOfT = Scalar(0.0);
272  for (Index j = 0; j < size; ++j)
273  {
274  m_normOfS += m_S.col(j).segment(0, (std::min)(size,j+2)).cwiseAbs().sum();
275  m_normOfT += m_T.row(j).segment(j, size - j).cwiseAbs().sum();
276  }
277  }
278 
279 
281  template<typename MatrixType>
282  inline Index RealQZ<MatrixType>::findSmallSubdiagEntry(Index iu)
283  {
284  using std::abs;
285  Index res = iu;
286  while (res > 0)
287  {
288  Scalar s = abs(m_S.coeff(res-1,res-1)) + abs(m_S.coeff(res,res));
289  if (s == Scalar(0.0))
290  s = m_normOfS;
291  if (abs(m_S.coeff(res,res-1)) < NumTraits<Scalar>::epsilon() * s)
292  break;
293  res--;
294  }
295  return res;
296  }
297 
299  template<typename MatrixType>
300  inline Index RealQZ<MatrixType>::findSmallDiagEntry(Index f, Index l)
301  {
302  using std::abs;
303  Index res = l;
304  while (res >= f) {
305  if (abs(m_T.coeff(res,res)) <= NumTraits<Scalar>::epsilon() * m_normOfT)
306  break;
307  res--;
308  }
309  return res;
310  }
311 
313  template<typename MatrixType>
314  inline void RealQZ<MatrixType>::splitOffTwoRows(Index i)
315  {
316  using std::abs;
317  using std::sqrt;
318  const Index dim=m_S.cols();
319  if (abs(m_S.coeff(i+1,i))==Scalar(0))
320  return;
321  Index j = findSmallDiagEntry(i,i+1);
322  if (j==i-1)
323  {
324  // block of (S T^{-1})
325  Matrix2s STi = m_T.template block<2,2>(i,i).template triangularView<Upper>().
326  template solve<OnTheRight>(m_S.template block<2,2>(i,i));
327  Scalar p = Scalar(0.5)*(STi(0,0)-STi(1,1));
328  Scalar q = p*p + STi(1,0)*STi(0,1);
329  if (q>=0) {
330  Scalar z = sqrt(q);
331  // one QR-like iteration for ABi - lambda I
332  // is enough - when we know exact eigenvalue in advance,
333  // convergence is immediate
334  JRs G;
335  if (p>=0)
336  G.makeGivens(p + z, STi(1,0));
337  else
338  G.makeGivens(p - z, STi(1,0));
339  m_S.rightCols(dim-i).applyOnTheLeft(i,i+1,G.adjoint());
340  m_T.rightCols(dim-i).applyOnTheLeft(i,i+1,G.adjoint());
341  // update Q
342  if (m_computeQZ)
343  m_Q.applyOnTheRight(i,i+1,G);
344 
345  G.makeGivens(m_T.coeff(i+1,i+1), m_T.coeff(i+1,i));
346  m_S.topRows(i+2).applyOnTheRight(i+1,i,G);
347  m_T.topRows(i+2).applyOnTheRight(i+1,i,G);
348  // update Z
349  if (m_computeQZ)
350  m_Z.applyOnTheLeft(i+1,i,G.adjoint());
351 
352  m_S.coeffRef(i+1,i) = Scalar(0.0);
353  m_T.coeffRef(i+1,i) = Scalar(0.0);
354  }
355  }
356  else
357  {
358  pushDownZero(j,i,i+1);
359  }
360  }
361 
363  template<typename MatrixType>
364  inline void RealQZ<MatrixType>::pushDownZero(Index z, Index f, Index l)
365  {
366  JRs G;
367  const Index dim = m_S.cols();
368  for (Index zz=z; zz<l; zz++)
369  {
370  // push 0 down
371  Index firstColS = zz>f ? (zz-1) : zz;
372  G.makeGivens(m_T.coeff(zz, zz+1), m_T.coeff(zz+1, zz+1));
373  m_S.rightCols(dim-firstColS).applyOnTheLeft(zz,zz+1,G.adjoint());
374  m_T.rightCols(dim-zz).applyOnTheLeft(zz,zz+1,G.adjoint());
375  m_T.coeffRef(zz+1,zz+1) = Scalar(0.0);
376  // update Q
377  if (m_computeQZ)
378  m_Q.applyOnTheRight(zz,zz+1,G);
379  // kill S(zz+1, zz-1)
380  if (zz>f)
381  {
382  G.makeGivens(m_S.coeff(zz+1, zz), m_S.coeff(zz+1,zz-1));
383  m_S.topRows(zz+2).applyOnTheRight(zz, zz-1,G);
384  m_T.topRows(zz+1).applyOnTheRight(zz, zz-1,G);
385  m_S.coeffRef(zz+1,zz-1) = Scalar(0.0);
386  // update Z
387  if (m_computeQZ)
388  m_Z.applyOnTheLeft(zz,zz-1,G.adjoint());
389  }
390  }
391  // finally kill S(l,l-1)
392  G.makeGivens(m_S.coeff(l,l), m_S.coeff(l,l-1));
393  m_S.applyOnTheRight(l,l-1,G);
394  m_T.applyOnTheRight(l,l-1,G);
395  m_S.coeffRef(l,l-1)=Scalar(0.0);
396  // update Z
397  if (m_computeQZ)
398  m_Z.applyOnTheLeft(l,l-1,G.adjoint());
399  }
400 
402  template<typename MatrixType>
403  inline void RealQZ<MatrixType>::step(Index f, Index l, Index iter)
404  {
405  using std::abs;
406  const Index dim = m_S.cols();
407 
408  // x, y, z
409  Scalar x, y, z;
410  if (iter==10)
411  {
412  // Wilkinson ad hoc shift
413  const Scalar
414  a11=m_S.coeff(f+0,f+0), a12=m_S.coeff(f+0,f+1),
415  a21=m_S.coeff(f+1,f+0), a22=m_S.coeff(f+1,f+1), a32=m_S.coeff(f+2,f+1),
416  b12=m_T.coeff(f+0,f+1),
417  b11i=Scalar(1.0)/m_T.coeff(f+0,f+0),
418  b22i=Scalar(1.0)/m_T.coeff(f+1,f+1),
419  a87=m_S.coeff(l-1,l-2),
420  a98=m_S.coeff(l-0,l-1),
421  b77i=Scalar(1.0)/m_T.coeff(l-2,l-2),
422  b88i=Scalar(1.0)/m_T.coeff(l-1,l-1);
423  Scalar ss = abs(a87*b77i) + abs(a98*b88i),
424  lpl = Scalar(1.5)*ss,
425  ll = ss*ss;
426  x = ll + a11*a11*b11i*b11i - lpl*a11*b11i + a12*a21*b11i*b22i
427  - a11*a21*b12*b11i*b11i*b22i;
428  y = a11*a21*b11i*b11i - lpl*a21*b11i + a21*a22*b11i*b22i
429  - a21*a21*b12*b11i*b11i*b22i;
430  z = a21*a32*b11i*b22i;
431  }
432  else if (iter==16)
433  {
434  // another exceptional shift
435  x = m_S.coeff(f,f)/m_T.coeff(f,f)-m_S.coeff(l,l)/m_T.coeff(l,l) + m_S.coeff(l,l-1)*m_T.coeff(l-1,l) /
436  (m_T.coeff(l-1,l-1)*m_T.coeff(l,l));
437  y = m_S.coeff(f+1,f)/m_T.coeff(f,f);
438  z = 0;
439  }
440  else if (iter>23 && !(iter%8))
441  {
442  // extremely exceptional shift
443  x = internal::random<Scalar>(-1.0,1.0);
444  y = internal::random<Scalar>(-1.0,1.0);
445  z = internal::random<Scalar>(-1.0,1.0);
446  }
447  else
448  {
449  // Compute the shifts: (x,y,z,0...) = (AB^-1 - l1 I) (AB^-1 - l2 I) e1
450  // where l1 and l2 are the eigenvalues of the 2x2 matrix C = U V^-1 where
451  // U and V are 2x2 bottom right sub matrices of A and B. Thus:
452  // = AB^-1AB^-1 + l1 l2 I - (l1+l2)(AB^-1)
453  // = AB^-1AB^-1 + det(M) - tr(M)(AB^-1)
454  // Since we are only interested in having x, y, z with a correct ratio, we have:
455  const Scalar
456  a11 = m_S.coeff(f,f), a12 = m_S.coeff(f,f+1),
457  a21 = m_S.coeff(f+1,f), a22 = m_S.coeff(f+1,f+1),
458  a32 = m_S.coeff(f+2,f+1),
459 
460  a88 = m_S.coeff(l-1,l-1), a89 = m_S.coeff(l-1,l),
461  a98 = m_S.coeff(l,l-1), a99 = m_S.coeff(l,l),
462 
463  b11 = m_T.coeff(f,f), b12 = m_T.coeff(f,f+1),
464  b22 = m_T.coeff(f+1,f+1),
465 
466  b88 = m_T.coeff(l-1,l-1), b89 = m_T.coeff(l-1,l),
467  b99 = m_T.coeff(l,l);
468 
469  x = ( (a88/b88 - a11/b11)*(a99/b99 - a11/b11) - (a89/b99)*(a98/b88) + (a98/b88)*(b89/b99)*(a11/b11) ) * (b11/a21)
470  + a12/b22 - (a11/b11)*(b12/b22);
471  y = (a22/b22-a11/b11) - (a21/b11)*(b12/b22) - (a88/b88-a11/b11) - (a99/b99-a11/b11) + (a98/b88)*(b89/b99);
472  z = a32/b22;
473  }
474 
475  JRs G;
476 
477  for (Index k=f; k<=l-2; k++)
478  {
479  // variables for Householder reflections
480  Vector2s essential2;
481  Scalar tau, beta;
482 
483  Vector3s hr(x,y,z);
484 
485  // Q_k to annihilate S(k+1,k-1) and S(k+2,k-1)
486  hr.makeHouseholderInPlace(tau, beta);
487  essential2 = hr.template bottomRows<2>();
488  Index fc=(std::max)(k-1,Index(0)); // first col to update
489  m_S.template middleRows<3>(k).rightCols(dim-fc).applyHouseholderOnTheLeft(essential2, tau, m_workspace.data());
490  m_T.template middleRows<3>(k).rightCols(dim-fc).applyHouseholderOnTheLeft(essential2, tau, m_workspace.data());
491  if (m_computeQZ)
492  m_Q.template middleCols<3>(k).applyHouseholderOnTheRight(essential2, tau, m_workspace.data());
493  if (k>f)
494  m_S.coeffRef(k+2,k-1) = m_S.coeffRef(k+1,k-1) = Scalar(0.0);
495 
496  // Z_{k1} to annihilate T(k+2,k+1) and T(k+2,k)
497  hr << m_T.coeff(k+2,k+2),m_T.coeff(k+2,k),m_T.coeff(k+2,k+1);
498  hr.makeHouseholderInPlace(tau, beta);
499  essential2 = hr.template bottomRows<2>();
500  {
501  Index lr = (std::min)(k+4,dim); // last row to update
502  Map<Matrix<Scalar,Dynamic,1> > tmp(m_workspace.data(),lr);
503  // S
504  tmp = m_S.template middleCols<2>(k).topRows(lr) * essential2;
505  tmp += m_S.col(k+2).head(lr);
506  m_S.col(k+2).head(lr) -= tau*tmp;
507  m_S.template middleCols<2>(k).topRows(lr) -= (tau*tmp) * essential2.adjoint();
508  // T
509  tmp = m_T.template middleCols<2>(k).topRows(lr) * essential2;
510  tmp += m_T.col(k+2).head(lr);
511  m_T.col(k+2).head(lr) -= tau*tmp;
512  m_T.template middleCols<2>(k).topRows(lr) -= (tau*tmp) * essential2.adjoint();
513  }
514  if (m_computeQZ)
515  {
516  // Z
517  Map<Matrix<Scalar,1,Dynamic> > tmp(m_workspace.data(),dim);
518  tmp = essential2.adjoint()*(m_Z.template middleRows<2>(k));
519  tmp += m_Z.row(k+2);
520  m_Z.row(k+2) -= tau*tmp;
521  m_Z.template middleRows<2>(k) -= essential2 * (tau*tmp);
522  }
523  m_T.coeffRef(k+2,k) = m_T.coeffRef(k+2,k+1) = Scalar(0.0);
524 
525  // Z_{k2} to annihilate T(k+1,k)
526  G.makeGivens(m_T.coeff(k+1,k+1), m_T.coeff(k+1,k));
527  m_S.applyOnTheRight(k+1,k,G);
528  m_T.applyOnTheRight(k+1,k,G);
529  // update Z
530  if (m_computeQZ)
531  m_Z.applyOnTheLeft(k+1,k,G.adjoint());
532  m_T.coeffRef(k+1,k) = Scalar(0.0);
533 
534  // update x,y,z
535  x = m_S.coeff(k+1,k);
536  y = m_S.coeff(k+2,k);
537  if (k < l-2)
538  z = m_S.coeff(k+3,k);
539  } // loop over k
540 
541  // Q_{n-1} to annihilate y = S(l,l-2)
542  G.makeGivens(x,y);
543  m_S.applyOnTheLeft(l-1,l,G.adjoint());
544  m_T.applyOnTheLeft(l-1,l,G.adjoint());
545  if (m_computeQZ)
546  m_Q.applyOnTheRight(l-1,l,G);
547  m_S.coeffRef(l,l-2) = Scalar(0.0);
548 
549  // Z_{n-1} to annihilate T(l,l-1)
550  G.makeGivens(m_T.coeff(l,l),m_T.coeff(l,l-1));
551  m_S.applyOnTheRight(l,l-1,G);
552  m_T.applyOnTheRight(l,l-1,G);
553  if (m_computeQZ)
554  m_Z.applyOnTheLeft(l,l-1,G.adjoint());
555  m_T.coeffRef(l,l-1) = Scalar(0.0);
556  }
557 
558  template<typename MatrixType>
559  RealQZ<MatrixType>& RealQZ<MatrixType>::compute(const MatrixType& A_in, const MatrixType& B_in, bool computeQZ)
560  {
561 
562  const Index dim = A_in.cols();
563 
564  eigen_assert (A_in.rows()==dim && A_in.cols()==dim
565  && B_in.rows()==dim && B_in.cols()==dim
566  && "Need square matrices of the same dimension");
567 
568  m_isInitialized = true;
569  m_computeQZ = computeQZ;
570  m_S = A_in; m_T = B_in;
571  m_workspace.resize(dim*2);
572  m_global_iter = 0;
573 
574  // entrance point: hessenberg triangular decomposition
575  hessenbergTriangular();
576  // compute L1 vector norms of T, S into m_normOfS, m_normOfT
577  computeNorms();
578 
579  Index l = dim-1,
580  f,
581  local_iter = 0;
582 
583  while (l>0 && local_iter<m_maxIters)
584  {
585  f = findSmallSubdiagEntry(l);
586  // now rows and columns f..l (including) decouple from the rest of the problem
587  if (f>0) m_S.coeffRef(f,f-1) = Scalar(0.0);
588  if (f == l) // One root found
589  {
590  l--;
591  local_iter = 0;
592  }
593  else if (f == l-1) // Two roots found
594  {
595  splitOffTwoRows(f);
596  l -= 2;
597  local_iter = 0;
598  }
599  else // No convergence yet
600  {
601  // if there's zero on diagonal of T, we can isolate an eigenvalue with Givens rotations
602  Index z = findSmallDiagEntry(f,l);
603  if (z>=f)
604  {
605  // zero found
606  pushDownZero(z,f,l);
607  }
608  else
609  {
610  // We are sure now that S.block(f,f, l-f+1,l-f+1) is underuced upper-Hessenberg
611  // and T.block(f,f, l-f+1,l-f+1) is invertible uper-triangular, which allows to
612  // apply a QR-like iteration to rows and columns f..l.
613  step(f,l, local_iter);
614  local_iter++;
615  m_global_iter++;
616  }
617  }
618  }
619  // check if we converged before reaching iterations limit
620  m_info = (local_iter<m_maxIters) ? Success : NoConvergence;
621 
622  // For each non triangular 2x2 diagonal block of S,
623  // reduce the respective 2x2 diagonal block of T to positive diagonal form using 2x2 SVD.
624  // This step is not mandatory for QZ, but it does help further extraction of eigenvalues/eigenvectors,
625  // and is in par with Lapack/Matlab QZ.
626  if(m_info==Success)
627  {
628  for(Index i=0; i<dim-1; ++i)
629  {
630  if(m_S.coeff(i+1, i) != Scalar(0))
631  {
632  JacobiRotation<Scalar> j_left, j_right;
633  internal::real_2x2_jacobi_svd(m_T, i, i+1, &j_left, &j_right);
634 
635  // Apply resulting Jacobi rotations
636  m_S.applyOnTheLeft(i,i+1,j_left);
637  m_S.applyOnTheRight(i,i+1,j_right);
638  m_T.applyOnTheLeft(i,i+1,j_left);
639  m_T.applyOnTheRight(i,i+1,j_right);
640  m_T(i+1,i) = m_T(i,i+1) = Scalar(0);
641 
642  if(m_computeQZ) {
643  m_Q.applyOnTheRight(i,i+1,j_left.transpose());
644  m_Z.applyOnTheLeft(i,i+1,j_right.transpose());
645  }
646 
647  i++;
648  }
649  }
650  }
651 
652  return *this;
653  } // end compute
654 
655 } // end namespace Eigen
656 
657 #endif //EIGEN_REAL_QZ
Rotation given by a cosine-sine pair.
Definition: Jacobi.h:35
JacobiRotation transpose() const
Definition: Jacobi.h:63
Performs a real QZ decomposition of a pair of square matrices.
Definition: RealQZ.h:58
const MatrixType & matrixZ() const
Returns matrix Z in the QZ decomposition.
Definition: RealQZ.h:132
const MatrixType & matrixQ() const
Returns matrix Q in the QZ decomposition.
Definition: RealQZ.h:122
RealQZ & compute(const MatrixType &A, const MatrixType &B, bool computeQZ=true)
Computes QZ decomposition of given matrix.
Definition: RealQZ.h:559
RealQZ & setMaxIterations(Index maxIters)
Definition: RealQZ.h:186
ComputationInfo info() const
Reports whether previous computation was successful.
Definition: RealQZ.h:169
Eigen::Index Index
Definition: RealQZ.h:70
const MatrixType & matrixT() const
Returns matrix S in the QZ decomposition.
Definition: RealQZ.h:151
RealQZ(const MatrixType &A, const MatrixType &B, bool computeQZ=true)
Constructor; computes real QZ decomposition of given matrices.
Definition: RealQZ.h:105
const MatrixType & matrixS() const
Returns matrix S in the QZ decomposition.
Definition: RealQZ.h:142
RealQZ(Index size=RowsAtCompileTime==Dynamic ? 1 :RowsAtCompileTime)
Default constructor.
Definition: RealQZ.h:86
Index iterations() const
Returns number of performed QR-like iterations.
Definition: RealQZ.h:177
ComputationInfo
Definition: Constants.h:440
@ Success
Definition: Constants.h:442
@ NoConvergence
Definition: Constants.h:446
Namespace containing all symbols from the Eigen library.
Definition: Core:134
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition: Meta.h:74
const int Dynamic
Definition: Constants.h:22