EIC code displayed by LXR master/​include/​eigen3/​Eigen/​src/​Eigenvalues/​EigenSolver.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

Warning, file /include/eigen3/Eigen/src/Eigenvalues/EigenSolver.h was not indexed or was modified since last indexation (in which case cross-reference links may be missing, inaccurate or erroneous).

 // 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_eigenvectorsOk(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 occurred. 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

This page was automatically generated by the 2.3.7 LXR engine. The LXR team