text: // This file is part of Eigen, a lightweight C++ template library
  // for linear algebra.
  //
  // Copyright (C) 2008 Gael Guennebaud <gael.guennebaud@inria.fr>
  // Copyright (C) 2010,2012 Jitse Niesen <jitse@maths.leeds.ac.uk>
  //
  // This Source Code Form is subject to the terms of the Mozilla
  // Public License v. 2.0. If a copy of the MPL was not distributed
  // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
  
  #ifndef EIGEN_EIGENSOLVER_H
  #define EIGEN_EIGENSOLVER_H
  
  #include "./RealSchur.h"
  
  namespace Eigen {
  
  /** \eigenvalues_module \ingroup Eigenvalues_Module
    *
    *
    * \class EigenSolver
    *
    * \brief Computes eigenvalues and eigenvectors of general matrices
    *
    * \tparam _MatrixType the type of the matrix of which we are computing the
    * eigendecomposition; this is expected to be an instantiation of the Matrix
    * class template. Currently, only real matrices are supported.
    *
    * The eigenvalues and eigenvectors of a matrix \f$ A \f$ are scalars
    * \f$ \lambda \f$ and vectors \f$ v \f$ such that \f$ Av = \lambda v \f$.  If
    * \f$ D \f$ is a diagonal matrix with the eigenvalues on the diagonal, and
    * \f$ V \f$ is a matrix with the eigenvectors as its columns, then \f$ A V =
    * V D \f$. The matrix \f$ V \f$ is almost always invertible, in which case we
    * have \f$ A = V D V^{-1} \f$. This is called the eigendecomposition.
    *
    * The eigenvalues and eigenvectors of a matrix may be complex, even when the
    * matrix is real. However, we can choose real matrices \f$ V \f$ and \f$ D
    * \f$ satisfying \f$ A V = V D \f$, just like the eigendecomposition, if the
    * matrix \f$ D \f$ is not required to be diagonal, but if it is allowed to
    * have blocks of the form
    * \f[ \begin{bmatrix} u & v \\ -v & u \end{bmatrix} \f]
    * (where \f$ u \f$ and \f$ v \f$ are real numbers) on the diagonal.  These
    * blocks correspond to complex eigenvalue pairs \f$ u \pm iv \f$. We call
    * this variant of the eigendecomposition the pseudo-eigendecomposition.
    *
    * Call the function compute() to compute the eigenvalues and eigenvectors of
    * a given matrix. Alternatively, you can use the 
    * EigenSolver(const MatrixType&, bool) constructor which computes the
    * eigenvalues and eigenvectors at construction time. Once the eigenvalue and
    * eigenvectors are computed, they can be retrieved with the eigenvalues() and
    * eigenvectors() functions. The pseudoEigenvalueMatrix() and
    * pseudoEigenvectors() methods allow the construction of the
    * pseudo-eigendecomposition.
    *
    * The documentation for EigenSolver(const MatrixType&, bool) contains an
    * example of the typical use of this class.
    *
    * \note The implementation is adapted from
    * <a href="http://math.nist.gov/javanumerics/jama/">JAMA</a> (public domain).
    * Their code is based on EISPACK.
    *
    * \sa MatrixBase::eigenvalues(), class ComplexEigenSolver, class SelfAdjointEigenSolver
    */
      template<typename _MatrixType>
      class EigenSolver {
      public:
  
          /** \brief Synonym for the template parameter \p _MatrixType. */
          typedef _MatrixType MatrixType;
  
          enum {
              RowsAtCompileTime = MatrixType::RowsAtCompileTime,
              ColsAtCompileTime = MatrixType::ColsAtCompileTime,
              Options = MatrixType::Options,
              MaxRowsAtCompileTime = MatrixType::MaxRowsAtCompileTime,
              MaxColsAtCompileTime = MatrixType::MaxColsAtCompileTime
          };
  
          /** \brief Scalar type for matrices of type #MatrixType. */
          typedef typename MatrixType::Scalar Scalar;
          typedef typename NumTraits<Scalar>::Real RealScalar;
          typedef Eigen::Index Index; ///< \deprecated since Eigen 3.3
  
          /** \brief Complex scalar type for #MatrixType.
            *
            * This is \c std::complex<Scalar> if #Scalar is real (e.g.,
            * \c float or \c double) and just \c Scalar if #Scalar is
            * complex.
            */
          typedef std::complex<RealScalar> ComplexScalar;
  
          /** \brief Type for vector of eigenvalues as returned by eigenvalues().
            *
            * This is a column vector with entries of type #ComplexScalar.
            * The length of the vector is the size of #MatrixType.
            */
          typedef Matrix<ComplexScalar, ColsAtCompileTime, 1,
                  Options & ~RowMajor, MaxColsAtCompileTime, 1> EigenvalueType;
  
          /** \brief Type for matrix of eigenvectors as returned by eigenvectors().
            *
            * This is a square matrix with entries of type #ComplexScalar.
            * The size is the same as the size of #MatrixType.
            */
          typedef Matrix <ComplexScalar, RowsAtCompileTime, ColsAtCompileTime, Options, MaxRowsAtCompileTime, MaxColsAtCompileTime> EigenvectorsType;
  
          /** \brief Default constructor.
            *
            * The default constructor is useful in cases in which the user intends to
            * perform decompositions via EigenSolver::compute(const MatrixType&, bool).
            *
            * \sa compute() for an example.
            */
          EigenSolver() : m_eivec(), m_eivalues(), m_isInitialized(false), m_realSchur(), m_matT(), m_tmp() {}
  
          /** \brief Default constructor with memory preallocation
            *
            * Like the default constructor but with preallocation of the internal data
            * according to the specified problem \a size.
            * \sa EigenSolver()
            */
          explicit EigenSolver(Index size)
                  : m_eivec(size, size),
                    m_eivalues(size),
                    m_isInitialized(false),
                    m_eigenvectorsOk(false),
                    m_realSchur(size),
                    m_matT(size, size),
                    m_tmp(size) {}
  
          /** \brief Constructor; computes eigendecomposition of given matrix.
            *
            * \param[in]  matrix  Square matrix whose eigendecomposition is to be computed.
            * \param[in]  computeEigenvectors  If true, both the eigenvectors and the
            *    eigenvalues are computed; if false, only the eigenvalues are
            *    computed.
            *
            * This constructor calls compute() to compute the eigenvalues
            * and eigenvectors.
            *
            * Example: \include EigenSolver_EigenSolver_MatrixType.cpp
            * Output: \verbinclude EigenSolver_EigenSolver_MatrixType.out
            *
            * \sa compute()
            */
          template<typename InputType>
          explicit EigenSolver(const EigenBase <InputType> &matrix, bool computeEigenvectors = true)
                  : m_eivec(matrix.rows(), matrix.cols()),
                    m_eivalues(matrix.cols()),
                    m_isInitialized(false),
                    m_eigenvectorsOk(false),
                    m_realSchur(matrix.cols()),
                    m_matT(matrix.rows(), matrix.cols()),
                    m_tmp(matrix.cols()) {
              compute(matrix.derived(), computeEigenvectors);
          }
  
          /** \brief Returns the eigenvectors of given matrix.
            *
            * \returns  %Matrix whose columns are the (possibly complex) eigenvectors.
            *
            * \pre Either the constructor
            * EigenSolver(const MatrixType&,bool) or the member function
            * compute(const MatrixType&, bool) has been called before, and
            * \p computeEigenvectors was set to true (the default).
            *
            * Column \f$ k \f$ of the returned matrix is an eigenvector corresponding
            * to eigenvalue number \f$ k \f$ as returned by eigenvalues().  The
            * eigenvectors are normalized to have (Euclidean) norm equal to one. The
            * matrix returned by this function is the matrix \f$ V \f$ in the
            * eigendecomposition \f$ A = V D V^{-1} \f$, if it exists.
            *
            * Example: \include EigenSolver_eigenvectors.cpp
            * Output: \verbinclude EigenSolver_eigenvectors.out
            *
            * \sa eigenvalues(), pseudoEigenvectors()
            */
          EigenvectorsType eigenvectors() const;
  
          /** \brief Returns the pseudo-eigenvectors of given matrix.
            *
            * \returns  Const reference to matrix whose columns are the pseudo-eigenvectors.
            *
            * \pre Either the constructor
            * EigenSolver(const MatrixType&,bool) or the member function
            * compute(const MatrixType&, bool) has been called before, and
            * \p computeEigenvectors was set to true (the default).
            *
            * The real matrix \f$ V \f$ returned by this function and the
            * block-diagonal matrix \f$ D \f$ returned by pseudoEigenvalueMatrix()
            * satisfy \f$ AV = VD \f$.
            *
            * Example: \include EigenSolver_pseudoEigenvectors.cpp
            * Output: \verbinclude EigenSolver_pseudoEigenvectors.out
            *
            * \sa pseudoEigenvalueMatrix(), eigenvectors()
            */
          const MatrixType &pseudoEigenvectors() const {
              eigen_assert(m_isInitialized && "EigenSolver is not initialized.");
              eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
              return m_eivec;
          }
  
          /** \brief Returns the block-diagonal matrix in the pseudo-eigendecomposition.
            *
            * \returns  A block-diagonal matrix.
            *
            * \pre Either the constructor
            * EigenSolver(const MatrixType&,bool) or the member function
            * compute(const MatrixType&, bool) has been called before.
            *
            * The matrix \f$ D \f$ returned by this function is real and
            * block-diagonal. The blocks on the diagonal are either 1-by-1 or 2-by-2
            * blocks of the form
            * \f$ \begin{bmatrix} u & v \\ -v & u \end{bmatrix} \f$.
            * These blocks are not sorted in any particular order.
            * The matrix \f$ D \f$ and the matrix \f$ V \f$ returned by
            * pseudoEigenvectors() satisfy \f$ AV = VD \f$.
            *
            * \sa pseudoEigenvectors() for an example, eigenvalues()
            */
          MatrixType pseudoEigenvalueMatrix() const;
  
          /** \brief Returns the eigenvalues of given matrix.
            *
            * \returns A const reference to the column vector containing the eigenvalues.
            *
            * \pre Either the constructor
            * EigenSolver(const MatrixType&,bool) or the member function
            * compute(const MatrixType&, bool) has been called before.
            *
            * The eigenvalues are repeated according to their algebraic multiplicity,
            * so there are as many eigenvalues as rows in the matrix. The eigenvalues
            * are not sorted in any particular order.
            *
            * Example: \include EigenSolver_eigenvalues.cpp
            * Output: \verbinclude EigenSolver_eigenvalues.out
            *
            * \sa eigenvectors(), pseudoEigenvalueMatrix(),
            *     MatrixBase::eigenvalues()
            */
          const EigenvalueType &eigenvalues() const {
              eigen_assert(m_isInitialized && "EigenSolver is not initialized.");
              return m_eivalues;
          }
  
          /** \brief Computes eigendecomposition of given matrix.
            *
            * \param[in]  matrix  Square matrix whose eigendecomposition is to be computed.
            * \param[in]  computeEigenvectors  If true, both the eigenvectors and the
            *    eigenvalues are computed; if false, only the eigenvalues are
            *    computed.
            * \returns    Reference to \c *this
            *
            * This function computes the eigenvalues of the real matrix \p matrix.
            * The eigenvalues() function can be used to retrieve them.  If
            * \p computeEigenvectors is true, then the eigenvectors are also computed
            * and can be retrieved by calling eigenvectors().
            *
            * The matrix is first reduced to real Schur form using the RealSchur
            * class. The Schur decomposition is then used to compute the eigenvalues
            * and eigenvectors.
            *
            * The cost of the computation is dominated by the cost of the
            * Schur decomposition, which is very approximately \f$ 25n^3 \f$
            * (where \f$ n \f$ is the size of the matrix) if \p computeEigenvectors
            * is true, and \f$ 10n^3 \f$ if \p computeEigenvectors is false.
            *
            * This method reuses of the allocated data in the EigenSolver object.
            *
            * Example: \include EigenSolver_compute.cpp
            * Output: \verbinclude EigenSolver_compute.out
            */
          template<typename InputType>
          EigenSolver &compute(const EigenBase <InputType> &matrix, bool computeEigenvectors = true);
  
          /** \returns NumericalIssue if the input contains INF or NaN values or overflow occured. Returns Success otherwise. */
          ComputationInfo info() const {
              eigen_assert(m_isInitialized && "EigenSolver is not initialized.");
              return m_info;
          }
  
          /** \brief Sets the maximum number of iterations allowed. */
          EigenSolver &setMaxIterations(Index maxIters) {
              m_realSchur.setMaxIterations(maxIters);
              return *this;
          }
  
          /** \brief Returns the maximum number of iterations. */
          Index getMaxIterations() {
              return m_realSchur.getMaxIterations();
          }
  
      private:
          void doComputeEigenvectors();
  
      protected:
  
          static void check_template_parameters() {
              EIGEN_STATIC_ASSERT_NON_INTEGER(Scalar);
              EIGEN_STATIC_ASSERT(!NumTraits<Scalar>::IsComplex, NUMERIC_TYPE_MUST_BE_REAL);
          }
  
          MatrixType m_eivec;
          EigenvalueType m_eivalues;
          bool m_isInitialized;
          bool m_eigenvectorsOk;
          ComputationInfo m_info;
          RealSchur <MatrixType> m_realSchur;
          MatrixType m_matT;
  
          typedef Matrix<Scalar, ColsAtCompileTime, 1, Options & ~RowMajor, MaxColsAtCompileTime, 1> ColumnVectorType;
          ColumnVectorType m_tmp;
      };
  
      template<typename MatrixType>
      MatrixType EigenSolver<MatrixType>::pseudoEigenvalueMatrix() const {
          eigen_assert(m_isInitialized && "EigenSolver is not initialized.");
          const RealScalar precision = RealScalar(2) * NumTraits<RealScalar>::epsilon();
          Index n = m_eivalues.rows();
          MatrixType matD = MatrixType::Zero(n, n);
          for (Index i = 0; i < n; ++i) {
              if (internal::isMuchSmallerThan(numext::imag(m_eivalues.coeff(i)), numext::real(m_eivalues.coeff(i)),
                                              precision))
                  matD.coeffRef(i, i) = numext::real(m_eivalues.coeff(i));
              else {
                  matD.template block<2, 2>(i, i) << numext::real(m_eivalues.coeff(i)), numext::imag(m_eivalues.coeff(i)),
                          -numext::imag(m_eivalues.coeff(i)), numext::real(m_eivalues.coeff(i));
                  ++i;
              }
          }
          return matD;
      }
  
      template<typename MatrixType>
      typename EigenSolver<MatrixType>::EigenvectorsType EigenSolver<MatrixType>::eigenvectors() const {
          eigen_assert(m_isInitialized && "EigenSolver is not initialized.");
          eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
          const RealScalar precision = RealScalar(2) * NumTraits<RealScalar>::epsilon();
          Index n = m_eivec.cols();
          EigenvectorsType matV(n, n);
          for (Index j = 0; j < n; ++j) {
              if (internal::isMuchSmallerThan(numext::imag(m_eivalues.coeff(j)), numext::real(m_eivalues.coeff(j)),
                                              precision) || j + 1 == n) {
                  // we have a real eigen value
                  matV.col(j) = m_eivec.col(j).template cast<ComplexScalar>();
                  matV.col(j).normalize();
              } else {
                  // we have a pair of complex eigen values
                  for (Index i = 0; i < n; ++i) {
                      matV.coeffRef(i, j) = ComplexScalar(m_eivec.coeff(i, j), m_eivec.coeff(i, j + 1));
                      matV.coeffRef(i, j + 1) = ComplexScalar(m_eivec.coeff(i, j), -m_eivec.coeff(i, j + 1));
                  }
                  matV.col(j).normalize();
                  matV.col(j + 1).normalize();
                  ++j;
              }
          }
          return matV;
      }
  
      template<typename MatrixType>
      template<typename InputType>
      EigenSolver<MatrixType> &
      EigenSolver<MatrixType>::compute(const EigenBase <InputType> &matrix, bool computeEigenvectors) {
          check_template_parameters();
  
          using std::sqrt;
          using std::abs;
          using numext::isfinite;
          eigen_assert(matrix.cols() == matrix.rows());
  
          // Reduce to real Schur form.
          m_realSchur.compute(matrix.derived(), computeEigenvectors);
  
          m_info = m_realSchur.info();
  
          if (m_info == Success) {
              m_matT = m_realSchur.matrixT();
              if (computeEigenvectors)
                  m_eivec = m_realSchur.matrixU();
  
              // Compute eigenvalues from matT
              m_eivalues.resize(matrix.cols());
              Index i = 0;
              while (i < matrix.cols()) {
                  if (i == matrix.cols() - 1 || m_matT.coeff(i + 1, i) == Scalar(0)) {
                      m_eivalues.coeffRef(i) = m_matT.coeff(i, i);
                      if (!(isfinite)(m_eivalues.coeffRef(i))) {
                          m_isInitialized = true;
                          m_eigenvectorsOk = false;
                          m_info = NumericalIssue;
                          return *this;
                      }
                      ++i;
                  } else {
                      Scalar p = Scalar(0.5) * (m_matT.coeff(i, i) - m_matT.coeff(i + 1, i + 1));
                      Scalar z;
                      // Compute z = sqrt(abs(p * p + m_matT.coeff(i+1, i) * m_matT.coeff(i, i+1)));
                      // without overflow
                      {
                          Scalar t0 = m_matT.coeff(i + 1, i);
                          Scalar t1 = m_matT.coeff(i, i + 1);
                          Scalar maxval = numext::maxi<Scalar>(abs(p), numext::maxi<Scalar>(abs(t0), abs(t1)));
                          t0 /= maxval;
                          t1 /= maxval;
                          Scalar p0 = p / maxval;
                          z = maxval * sqrt(abs(p0 * p0 + t0 * t1));
                      }
  
                      m_eivalues.coeffRef(i) = ComplexScalar(m_matT.coeff(i + 1, i + 1) + p, z);
                      m_eivalues.coeffRef(i + 1) = ComplexScalar(m_matT.coeff(i + 1, i + 1) + p, -z);
                      if (!((isfinite)(m_eivalues.coeffRef(i)) && (isfinite)(m_eivalues.coeffRef(i + 1)))) {
                          m_isInitialized = true;
                          m_eigenvectorsOk = false;
                          m_info = NumericalIssue;
                          return *this;
                      }
                      i += 2;
                  }
              }
  
              // Compute eigenvectors.
              if (computeEigenvectors)
                  doComputeEigenvectors();
          }
  
          m_isInitialized = true;
          m_eigenvectorsOk = computeEigenvectors;
  
          return *this;
      }
  
  
      template<typename MatrixType>
      void EigenSolver<MatrixType>::doComputeEigenvectors() {
          using std::abs;
          const Index size = m_eivec.cols();
          const Scalar eps = NumTraits<Scalar>::epsilon();
  
          // inefficient! this is already computed in RealSchur
          Scalar norm(0);
          for (Index j = 0; j < size; ++j) {
              norm += m_matT.row(j).segment((std::max)(j - 1, Index(0)),
                                            size - (std::max)(j - 1, Index(0))).cwiseAbs().sum();
          }
  
          // Backsubstitute to find vectors of upper triangular form
          if (norm == Scalar(0)) {
              return;
          }
  
          for (Index n = size - 1; n >= 0; n--) {
              Scalar p = m_eivalues.coeff(n).real();
              Scalar q = m_eivalues.coeff(n).imag();
  
              // Scalar vector
              if (q == Scalar(0)) {
                  Scalar lastr(0), lastw(0);
                  Index l = n;
  
                  m_matT.coeffRef(n, n) = Scalar(1);
                  for (Index i = n - 1; i >= 0; i--) {
                      Scalar w = m_matT.coeff(i, i) - p;
                      Scalar r = m_matT.row(i).segment(l, n - l + 1).dot(m_matT.col(n).segment(l, n - l + 1));
  
                      if (m_eivalues.coeff(i).imag() < Scalar(0)) {
                          lastw = w;
                          lastr = r;
                      } else {
                          l = i;
                          if (m_eivalues.coeff(i).imag() == Scalar(0)) {
                              if (w != Scalar(0))
                                  m_matT.coeffRef(i, n) = -r / w;
                              else
                                  m_matT.coeffRef(i, n) = -r / (eps * norm);
                          } else // Solve real equations
                          {
                              Scalar x = m_matT.coeff(i, i + 1);
                              Scalar y = m_matT.coeff(i + 1, i);
                              Scalar denom = (m_eivalues.coeff(i).real() - p) * (m_eivalues.coeff(i).real() - p) +
                                             m_eivalues.coeff(i).imag() * m_eivalues.coeff(i).imag();
                              Scalar t = (x * lastr - lastw * r) / denom;
                              m_matT.coeffRef(i, n) = t;
                              if (abs(x) > abs(lastw))
                                  m_matT.coeffRef(i + 1, n) = (-r - w * t) / x;
                              else
                                  m_matT.coeffRef(i + 1, n) = (-lastr - y * t) / lastw;
                          }
  
                          // Overflow control
                          Scalar t = abs(m_matT.coeff(i, n));
                          if ((eps * t) * t > Scalar(1))
                              m_matT.col(n).tail(size - i) /= t;
                      }
                  }
              } else if (q < Scalar(0) && n > 0) // Complex vector
              {
                  Scalar lastra(0), lastsa(0), lastw(0);
                  Index l = n - 1;
  
                  // Last vector component imaginary so matrix is triangular
                  if (abs(m_matT.coeff(n, n - 1)) > abs(m_matT.coeff(n - 1, n))) {
                      m_matT.coeffRef(n - 1, n - 1) = q / m_matT.coeff(n, n - 1);
                      m_matT.coeffRef(n - 1, n) = -(m_matT.coeff(n, n) - p) / m_matT.coeff(n, n - 1);
                  } else {
                      ComplexScalar cc = ComplexScalar(Scalar(0), -m_matT.coeff(n - 1, n)) /
                                         ComplexScalar(m_matT.coeff(n - 1, n - 1) - p, q);
                      m_matT.coeffRef(n - 1, n - 1) = numext::real(cc);
                      m_matT.coeffRef(n - 1, n) = numext::imag(cc);
                  }
                  m_matT.coeffRef(n, n - 1) = Scalar(0);
                  m_matT.coeffRef(n, n) = Scalar(1);
                  for (Index i = n - 2; i >= 0; i--) {
                      Scalar ra = m_matT.row(i).segment(l, n - l + 1).dot(m_matT.col(n - 1).segment(l, n - l + 1));
                      Scalar sa = m_matT.row(i).segment(l, n - l + 1).dot(m_matT.col(n).segment(l, n - l + 1));
                      Scalar w = m_matT.coeff(i, i) - p;
  
                      if (m_eivalues.coeff(i).imag() < Scalar(0)) {
                          lastw = w;
                          lastra = ra;
                          lastsa = sa;
                      } else {
                          l = i;
                          if (m_eivalues.coeff(i).imag() == RealScalar(0)) {
                              ComplexScalar cc = ComplexScalar(-ra, -sa) / ComplexScalar(w, q);
                              m_matT.coeffRef(i, n - 1) = numext::real(cc);
                              m_matT.coeffRef(i, n) = numext::imag(cc);
                          } else {
                              // Solve complex equations
                              Scalar x = m_matT.coeff(i, i + 1);
                              Scalar y = m_matT.coeff(i + 1, i);
                              Scalar vr = (m_eivalues.coeff(i).real() - p) * (m_eivalues.coeff(i).real() - p) +
                                          m_eivalues.coeff(i).imag() * m_eivalues.coeff(i).imag() - q * q;
                              Scalar vi = (m_eivalues.coeff(i).real() - p) * Scalar(2) * q;
                              if ((vr == Scalar(0)) && (vi == Scalar(0)))
                                  vr = eps * norm * (abs(w) + abs(q) + abs(x) + abs(y) + abs(lastw));
  
                              ComplexScalar cc =
                                      ComplexScalar(x * lastra - lastw * ra + q * sa, x * lastsa - lastw * sa - q * ra) /
                                      ComplexScalar(vr, vi);
                              m_matT.coeffRef(i, n - 1) = numext::real(cc);
                              m_matT.coeffRef(i, n) = numext::imag(cc);
                              if (abs(x) > (abs(lastw) + abs(q))) {
                                  m_matT.coeffRef(i + 1, n - 1) =
                                          (-ra - w * m_matT.coeff(i, n - 1) + q * m_matT.coeff(i, n)) / x;
                                  m_matT.coeffRef(i + 1, n) =
                                          (-sa - w * m_matT.coeff(i, n) - q * m_matT.coeff(i, n - 1)) / x;
                              } else {
                                  cc = ComplexScalar(-lastra - y * m_matT.coeff(i, n - 1),
                                                     -lastsa - y * m_matT.coeff(i, n)) / ComplexScalar(lastw, q);
                                  m_matT.coeffRef(i + 1, n - 1) = numext::real(cc);
                                  m_matT.coeffRef(i + 1, n) = numext::imag(cc);
                              }
                          }
  
                          // Overflow control
                          Scalar t = numext::maxi<Scalar>(abs(m_matT.coeff(i, n - 1)), abs(m_matT.coeff(i, n)));
                          if ((eps * t) * t > Scalar(1))
                              m_matT.block(i, n - 1, size - i, 2) /= t;
  
                      }
                  }
  
                  // We handled a pair of complex conjugate eigenvalues, so need to skip them both
                  n--;
              } else {
                  eigen_assert(0 &&
                               "Internal bug in EigenSolver (INF or NaN has not been detected)"); // this should not happen
              }
          }
  
          // Back transformation to get eigenvectors of original matrix
          for (Index j = size - 1; j >= 0; j--) {
              m_tmp.noalias() = m_eivec.leftCols(j + 1) * m_matT.col(j).segment(0, j + 1);
              m_eivec.col(j) = m_tmp;
          }
      }
  
  } // end namespace Eigen
  
  #endif // EIGEN_EIGENSOLVER_H
  