Public Types
typedef MatrixType::Index	Index

typedef NumTraits< Scalar >::Real	RealScalar
	Real scalar type for `MatrixType`. More...

typedef internal::plain_col_type< MatrixType, RealScalar >::type	RealVectorType
	Type for vector of eigenvalues as returned by eigenvalues(). More...

typedef MatrixType::Scalar	Scalar
	Scalar type for matrices of type `MatrixType`. More...

Public Member Functions
	ArpackGeneralizedSelfAdjointEigenSolver ()
	Default constructor. More...

	ArpackGeneralizedSelfAdjointEigenSolver (const MatrixType &A, const MatrixType &B, Index nbrEigenvalues, std::string eigs_sigma="LM", int options=ComputeEigenvectors, RealScalar tol=0.0)
	Constructor; computes generalized eigenvalues of given matrix with respect to another matrix. More...

	ArpackGeneralizedSelfAdjointEigenSolver (const MatrixType &A, Index nbrEigenvalues, std::string eigs_sigma="LM", int options=ComputeEigenvectors, RealScalar tol=0.0)
	Constructor; computes eigenvalues of given matrix. More...

ArpackGeneralizedSelfAdjointEigenSolver &	compute (const MatrixType &A, const MatrixType &B, Index nbrEigenvalues, std::string eigs_sigma="LM", int options=ComputeEigenvectors, RealScalar tol=0.0)
	Computes generalized eigenvalues / eigenvectors of given matrix using the external ARPACK library. More...

ArpackGeneralizedSelfAdjointEigenSolver &	compute (const MatrixType &A, Index nbrEigenvalues, std::string eigs_sigma="LM", int options=ComputeEigenvectors, RealScalar tol=0.0)
	Computes eigenvalues / eigenvectors of given matrix using the external ARPACK library. More...

const Matrix< Scalar, Dynamic, 1 > &	eigenvalues () const
	Returns the eigenvalues of given matrix. More...

const Matrix< Scalar, Dynamic, Dynamic > &	eigenvectors () const
	Returns the eigenvectors of given matrix. More...

size_t	getNbrConvergedEigenValues () const

size_t	getNbrIterations () const

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

Matrix< Scalar, Dynamic, Dynamic >	operatorInverseSqrt () const
	Computes the inverse square root of the matrix. More...

Matrix< Scalar, Dynamic, Dynamic >	operatorSqrt () const
	Computes the positive-definite square root of the matrix. More...

Protected Attributes
bool	m_eigenvectorsOk

Matrix< Scalar, Dynamic, 1 >	m_eivalues

Matrix< Scalar, Dynamic, Dynamic >	m_eivec

ComputationInfo	m_info

bool	m_isInitialized

size_t	m_nbrConverged

size_t	m_nbrIterations

Detailed Description

template<typename MatrixType, typename MatrixSolver = SimplicialLLT<MatrixType>, bool BisSPD = false>
class Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >

Definition at line 27 of file ArpackSelfAdjointEigenSolver.h.

Member Typedef Documentation

◆ Index

template<typename MatrixType , typename MatrixSolver = SimplicialLLT<MatrixType>, bool BisSPD = false>

typedef MatrixType::Index Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::Index

Definition at line 34 of file ArpackSelfAdjointEigenSolver.h.

◆ RealScalar

template<typename MatrixType , typename MatrixSolver = SimplicialLLT<MatrixType>, bool BisSPD = false>

typedef NumTraits<Scalar>::Real Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::RealScalar

Real scalar type for MatrixType.

This is just Scalar if Scalar is real (e.g., float or Scalar), and the type of the real part of Scalar if Scalar is complex.

Definition at line 42 of file ArpackSelfAdjointEigenSolver.h.

◆ RealVectorType

template<typename MatrixType , typename MatrixSolver = SimplicialLLT<MatrixType>, bool BisSPD = false>

typedef internal::plain_col_type<MatrixType, RealScalar>::type Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::RealVectorType

Type for vector of eigenvalues as returned by eigenvalues().

This is a column vector with entries of type RealScalar. The length of the vector is the size of nbrEigenvalues.

Definition at line 49 of file ArpackSelfAdjointEigenSolver.h.

◆ Scalar

template<typename MatrixType , typename MatrixSolver = SimplicialLLT<MatrixType>, bool BisSPD = false>

typedef MatrixType::Scalar Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::Scalar

Scalar type for matrices of type MatrixType.

Definition at line 33 of file ArpackSelfAdjointEigenSolver.h.

Constructor & Destructor Documentation

◆ ArpackGeneralizedSelfAdjointEigenSolver() [1/3]

template<typename MatrixType , typename MatrixSolver = SimplicialLLT<MatrixType>, bool BisSPD = false>

Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::ArpackGeneralizedSelfAdjointEigenSolver ( )

inline

Default constructor.

The default constructor is for cases in which the user intends to perform decompositions via compute().

Definition at line 57 of file ArpackSelfAdjointEigenSolver.h.

    : m_eivec(),
      m_eivalues(),
      m_isInitialized(false),
      m_eigenvectorsOk(false),
      m_nbrConverged(0),
      m_nbrIterations(0)
   { }

◆ ArpackGeneralizedSelfAdjointEigenSolver() [2/3]

template<typename MatrixType , typename MatrixSolver = SimplicialLLT<MatrixType>, bool BisSPD = false>

Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::ArpackGeneralizedSelfAdjointEigenSolver	(	const MatrixType &	A,
		const MatrixType &	B,
		Index	nbrEigenvalues,
		std::string	eigs_sigma = `"LM"`,
		int	options = `ComputeEigenvectors`,
		RealScalar	tol = `0.0`
	)

inline

Constructor; computes generalized eigenvalues of given matrix with respect to another matrix.

Parameters

[in]	A	Self-adjoint matrix whose eigenvalues / eigenvectors will computed. By default, the upper triangular part is used, but can be changed through the template parameter.
[in]	B	Self-adjoint matrix for the generalized eigenvalue problem.
[in]	nbrEigenvalues	The number of eigenvalues / eigenvectors to compute. Must be less than the size of the input matrix, or an error is returned.
[in]	eigs_sigma	String containing either "LM", "SM", "LA", or "SA", with respective meanings to find the largest magnitude , smallest magnitude, largest algebraic, or smallest algebraic eigenvalues. Alternatively, this value can contain floating point value in string form, in which case the eigenvalues closest to this value will be found.
[in]	options	Can be ComputeEigenvectors (default) or EigenvaluesOnly.
[in]	tol	What tolerance to find the eigenvalues to. Default is 0, which means machine precision.

This constructor calls compute(const MatrixType&, const MatrixType&, Index, string, int, RealScalar) to compute the eigenvalues of the matrix A with respect to B. The eigenvectors are computed if options equals ComputeEigenvectors.

Definition at line 88 of file ArpackSelfAdjointEigenSolver.h.

     : m_eivec(),
       m_eivalues(),
       m_isInitialized(false),
       m_eigenvectorsOk(false),
       m_nbrConverged(0),
       m_nbrIterations(0)
   {
     compute(A, B, nbrEigenvalues, eigs_sigma, options, tol);
   }

◆ ArpackGeneralizedSelfAdjointEigenSolver() [3/3]

template<typename MatrixType , typename MatrixSolver = SimplicialLLT<MatrixType>, bool BisSPD = false>

Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::ArpackGeneralizedSelfAdjointEigenSolver	(	const MatrixType &	A,
		Index	nbrEigenvalues,
		std::string	eigs_sigma = `"LM"`,
		int	options = `ComputeEigenvectors`,
		RealScalar	tol = `0.0`
	)

inline

Constructor; computes eigenvalues of given matrix.

Parameters

[in]	A	Self-adjoint matrix whose eigenvalues / eigenvectors will computed. By default, the upper triangular part is used, but can be changed through the template parameter.
[in]	nbrEigenvalues	The number of eigenvalues / eigenvectors to compute. Must be less than the size of the input matrix, or an error is returned.
[in]	eigs_sigma	String containing either "LM", "SM", "LA", or "SA", with respective meanings to find the largest magnitude , smallest magnitude, largest algebraic, or smallest algebraic eigenvalues. Alternatively, this value can contain floating point value in string form, in which case the eigenvalues closest to this value will be found.
[in]	options	Can be ComputeEigenvectors (default) or EigenvaluesOnly.
[in]	tol	What tolerance to find the eigenvalues to. Default is 0, which means machine precision.

This constructor calls compute(const MatrixType&, Index, string, int, RealScalar) to compute the eigenvalues of the matrix A. The eigenvectors are computed if options equals ComputeEigenvectors.

Definition at line 123 of file ArpackSelfAdjointEigenSolver.h.

     : m_eivec(),
       m_eivalues(),
       m_isInitialized(false),
       m_eigenvectorsOk(false),
       m_nbrConverged(0),
       m_nbrIterations(0)
   {
     compute(A, nbrEigenvalues, eigs_sigma, options, tol);
   }

Member Function Documentation

◆ compute() [1/2]

template<typename MatrixType , typename MatrixSolver , bool BisSPD>

ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD > & Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::compute	(	const MatrixType &	A,
		const MatrixType &	B,
		Index	nbrEigenvalues,
		std::string	eigs_sigma = `"LM"`,
		int	options = `ComputeEigenvectors`,
		RealScalar	tol = `0.0`
	)

Computes generalized eigenvalues / eigenvectors of given matrix using the external ARPACK library.

Parameters

[in]	A	Selfadjoint matrix whose eigendecomposition is to be computed.
[in]	B	Selfadjoint matrix for generalized eigenvalues.
[in]	nbrEigenvalues	The number of eigenvalues / eigenvectors to compute. Must be less than the size of the input matrix, or an error is returned.
[in]	eigs_sigma	String containing either "LM", "SM", "LA", or "SA", with respective meanings to find the largest magnitude , smallest magnitude, largest algebraic, or smallest algebraic eigenvalues. Alternatively, this value can contain floating point value in string form, in which case the eigenvalues closest to this value will be found.
[in]	options	Can be ComputeEigenvectors (default) or EigenvaluesOnly.
[in]	tol	What tolerance to find the eigenvalues to. Default is 0, which means machine precision.

Returns: Reference to *this

This function computes the generalized eigenvalues of A with respect to B using ARPACK. The eigenvalues() function can be used to retrieve them. If options equals ComputeEigenvectors, then the eigenvectors are also computed and can be retrieved by calling eigenvectors().

Definition at line 335 of file ArpackSelfAdjointEigenSolver.h.

 {
   eigen_assert(A.cols() == A.rows());
   eigen_assert(B.cols() == B.rows());
   eigen_assert(B.rows() == 0 || A.cols() == B.rows());
   eigen_assert((options &~ (EigVecMask | GenEigMask)) == 0
             && (options & EigVecMask) != EigVecMask
             && "invalid option parameter");
  
   bool isBempty = (B.rows() == 0) || (B.cols() == 0);
  
   // For clarity, all parameters match their ARPACK name
   //
   // Always 0 on the first call
   //
   int ido = 0;
  
   int n = (int)A.cols();
  
   // User options: "LA", "SA", "SM", "LM", "BE"
   //
   char whch[3] = "LM";
     
   // Specifies the shift if iparam[6] = { 3, 4, 5 }, not used if iparam[6] = { 1, 2 }
   //
   RealScalar sigma = 0.0;
  
   if (eigs_sigma.length() >= 2 && isalpha(eigs_sigma[0]) && isalpha(eigs_sigma[1]))
   {
       eigs_sigma[0] = toupper(eigs_sigma[0]);
       eigs_sigma[1] = toupper(eigs_sigma[1]);
  
       // In the following special case we're going to invert the problem, since solving
       // for larger magnitude is much much faster
       // i.e., if 'SM' is specified, we're going to really use 'LM', the default
       //
       if (eigs_sigma.substr(0,2) != "SM")
       {
           whch[0] = eigs_sigma[0];
           whch[1] = eigs_sigma[1];
       }
   }
   else
   {
       eigen_assert(false && "Specifying clustered eigenvalues is not yet supported!");
  
       // If it's not scalar values, then the user may be explicitly
       // specifying the sigma value to cluster the evs around
       //
       sigma = atof(eigs_sigma.c_str());
  
       // If atof fails, it returns 0.0, which is a fine default
       //
   }
  
   // "I" means normal eigenvalue problem, "G" means generalized
   //
   char bmat[2] = "I";
   if (eigs_sigma.substr(0,2) == "SM" || !(isalpha(eigs_sigma[0]) && isalpha(eigs_sigma[1])) || (!isBempty && !BisSPD))
       bmat[0] = 'G';
  
   // Now we determine the mode to use
   //
   int mode = (bmat[0] == 'G') + 1;
   if (eigs_sigma.substr(0,2) == "SM" || !(isalpha(eigs_sigma[0]) && isalpha(eigs_sigma[1])))
   {
       // We're going to use shift-and-invert mode, and basically find
       // the largest eigenvalues of the inverse operator
       //
       mode = 3;
   }
  
   // The user-specified number of eigenvalues/vectors to compute
   //
   int nev = (int)nbrEigenvalues;
  
   // Allocate space for ARPACK to store the residual
   //
   Scalar *resid = new Scalar[n];
  
   // Number of Lanczos vectors, must satisfy nev < ncv <= n
   // Note that this indicates that nev != n, and we cannot compute
   // all eigenvalues of a mtrix
   //
   int ncv = std::min(std::max(2*nev, 20), n);
  
   // The working n x ncv matrix, also store the final eigenvectors (if computed)
   //
   Scalar *v = new Scalar[n*ncv];
   int ldv = n;
  
   // Working space
   //
   Scalar *workd = new Scalar[3*n];
   int lworkl = ncv*ncv+8*ncv; // Must be at least this length
   Scalar *workl = new Scalar[lworkl];
  
   int *iparam= new int[11];
   iparam[0] = 1; // 1 means we let ARPACK perform the shifts, 0 means we'd have to do it
   iparam[2] = std::max(300, (int)std::ceil(2*n/std::max(ncv,1)));
   iparam[6] = mode; // The mode, 1 is standard ev problem, 2 for generalized ev, 3 for shift-and-invert
  
   // Used during reverse communicate to notify where arrays start
   //
   int *ipntr = new int[11]; 
  
   // Error codes are returned in here, initial value of 0 indicates a random initial
   // residual vector is used, any other values means resid contains the initial residual
   // vector, possibly from a previous run
   //
   int info = 0;
  
   Scalar scale = 1.0;
   //if (!isBempty)
   //{
   //Scalar scale = B.norm() / std::sqrt(n);
   //scale = std::pow(2, std::floor(std::log(scale+1)));
   //for (size_t i=0; i<(size_t)B.outerSize(); i++)
   //    for (typename MatrixType::InnerIterator it(B, i); it; ++it)
   //        it.valueRef() /= scale;
   //}
  
   MatrixSolver OP;
   if (mode == 1 || mode == 2)
   {
       if (!isBempty)
           OP.compute(B);
   }
   else if (mode == 3)
   {
       if (sigma == 0.0)
       {
           OP.compute(A);
       }
       else
       {
           // Note: We will never enter here because sigma must be 0.0
           //
           if (isBempty)
           {
             MatrixType AminusSigmaB(A);
             for (Index i=0; i<A.rows(); ++i)
                 AminusSigmaB.coeffRef(i,i) -= sigma;
             
             OP.compute(AminusSigmaB);
           }
           else
           {
               MatrixType AminusSigmaB = A - sigma * B;
               OP.compute(AminusSigmaB);
           }
       }
   }
  
   if (!(mode == 1 && isBempty) && !(mode == 2 && isBempty) && OP.info() != Success)
       std::cout << "Error factoring matrix" << std::endl;
  
   do
   {
     internal::arpack_wrapper<Scalar, RealScalar>::saupd(&ido, bmat, &n, whch, &nev, &tol, resid, 
                                                         &ncv, v, &ldv, iparam, ipntr, workd, workl,
                                                         &lworkl, &info);
  
     if (ido == -1 || ido == 1)
     {
       Scalar *in  = workd + ipntr[0] - 1;
       Scalar *out = workd + ipntr[1] - 1;
  
       if (ido == 1 && mode != 2)
       {
           Scalar *out2 = workd + ipntr[2] - 1;
           if (isBempty || mode == 1)
             Matrix<Scalar, Dynamic, 1>::Map(out2, n) = Matrix<Scalar, Dynamic, 1>::Map(in, n);
           else
             Matrix<Scalar, Dynamic, 1>::Map(out2, n) = B * Matrix<Scalar, Dynamic, 1>::Map(in, n);
           
           in = workd + ipntr[2] - 1;
       }
  
       if (mode == 1)
       {
         if (isBempty)
         {
           // OP = A
           //
           Matrix<Scalar, Dynamic, 1>::Map(out, n) = A * Matrix<Scalar, Dynamic, 1>::Map(in, n);
         }
         else
         {
           // OP = L^{-1}AL^{-T}
           //
           internal::OP<MatrixSolver, MatrixType, Scalar, BisSPD>::applyOP(OP, A, n, in, out);
         }
       }
       else if (mode == 2)
       {
         if (ido == 1)
           Matrix<Scalar, Dynamic, 1>::Map(in, n)  = A * Matrix<Scalar, Dynamic, 1>::Map(in, n);
         
         // OP = B^{-1} A
         //
         Matrix<Scalar, Dynamic, 1>::Map(out, n) = OP.solve(Matrix<Scalar, Dynamic, 1>::Map(in, n));
       }
       else if (mode == 3)
       {
         // OP = (A-\sigmaB)B (\sigma could be 0, and B could be I)
         // The B * in is already computed and stored at in if ido == 1
         //
         if (ido == 1 || isBempty)
           Matrix<Scalar, Dynamic, 1>::Map(out, n) = OP.solve(Matrix<Scalar, Dynamic, 1>::Map(in, n));
         else
           Matrix<Scalar, Dynamic, 1>::Map(out, n) = OP.solve(B * Matrix<Scalar, Dynamic, 1>::Map(in, n));
       }
     }
     else if (ido == 2)
     {
       Scalar *in  = workd + ipntr[0] - 1;
       Scalar *out = workd + ipntr[1] - 1;
  
       if (isBempty || mode == 1)
         Matrix<Scalar, Dynamic, 1>::Map(out, n) = Matrix<Scalar, Dynamic, 1>::Map(in, n);
       else
         Matrix<Scalar, Dynamic, 1>::Map(out, n) = B * Matrix<Scalar, Dynamic, 1>::Map(in, n);
     }
   } while (ido != 99);
  
   if (info == 1)
     m_info = NoConvergence;
   else if (info == 3)
     m_info = NumericalIssue;
   else if (info < 0)
     m_info = InvalidInput;
   else if (info != 0)
     eigen_assert(false && "Unknown ARPACK return value!");
   else
   {
     // Do we compute eigenvectors or not?
     //
     int rvec = (options & ComputeEigenvectors) == ComputeEigenvectors;
  
     // "A" means "All", use "S" to choose specific eigenvalues (not yet supported in ARPACK))
     //
     char howmny[2] = "A"; 
  
     // if howmny == "S", specifies the eigenvalues to compute (not implemented in ARPACK)
     //
     int *select = new int[ncv];
  
     // Final eigenvalues
     //
     m_eivalues.resize(nev, 1);
  
     internal::arpack_wrapper<Scalar, RealScalar>::seupd(&rvec, howmny, select, m_eivalues.data(), v, &ldv,
                                                         &sigma, bmat, &n, whch, &nev, &tol, resid, &ncv,
                                                         v, &ldv, iparam, ipntr, workd, workl, &lworkl, &info);
  
     if (info == -14)
       m_info = NoConvergence;
     else if (info != 0)
       m_info = InvalidInput;
     else
     {
       if (rvec)
       {
         m_eivec.resize(A.rows(), nev);
         for (int i=0; i<nev; i++)
           for (int j=0; j<n; j++)
             m_eivec(j,i) = v[i*n+j] / scale;
       
         if (mode == 1 && !isBempty && BisSPD)
           internal::OP<MatrixSolver, MatrixType, Scalar, BisSPD>::project(OP, n, nev, m_eivec.data());
  
         m_eigenvectorsOk = true;
       }
  
       m_nbrIterations = iparam[2];
       m_nbrConverged  = iparam[4];
  
       m_info = Success;
     }
  
     delete[] select;
   }
  
   delete[] v;
   delete[] iparam;
   delete[] ipntr;
   delete[] workd;
   delete[] workl;
   delete[] resid;
  
   m_isInitialized = true;
  
   return *this;
 }

◆ compute() [2/2]

template<typename MatrixType , typename MatrixSolver , bool BisSPD>

ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD > & Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::compute	(	const MatrixType &	A,
		Index	nbrEigenvalues,
		std::string	eigs_sigma = `"LM"`,
		int	options = `ComputeEigenvectors`,
		RealScalar	tol = `0.0`
	)

Computes eigenvalues / eigenvectors of given matrix using the external ARPACK library.

Parameters

[in]	A	Selfadjoint matrix whose eigendecomposition is to be computed.
[in]	nbrEigenvalues	The number of eigenvalues / eigenvectors to compute. Must be less than the size of the input matrix, or an error is returned.
[in]	eigs_sigma	String containing either "LM", "SM", "LA", or "SA", with respective meanings to find the largest magnitude , smallest magnitude, largest algebraic, or smallest algebraic eigenvalues. Alternatively, this value can contain floating point value in string form, in which case the eigenvalues closest to this value will be found.
[in]	options	Can be ComputeEigenvectors (default) or EigenvaluesOnly.
[in]	tol	What tolerance to find the eigenvalues to. Default is 0, which means machine precision.

Returns: Reference to *this

This function computes the eigenvalues of A using ARPACK. The eigenvalues() function can be used to retrieve them. If options equals ComputeEigenvectors, then the eigenvectors are also computed and can be retrieved by calling eigenvectors().

Definition at line 322 of file ArpackSelfAdjointEigenSolver.h.

 {
     MatrixType B(0,0);
     compute(A, B, nbrEigenvalues, eigs_sigma, options, tol);
     
     return *this;
 }

◆ eigenvalues()

template<typename MatrixType , typename MatrixSolver = SimplicialLLT<MatrixType>, bool BisSPD = false>

const Matrix<Scalar, Dynamic, 1>& Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::eigenvalues ( ) const

inline

Returns the eigenvalues of given matrix.

Returns: A const reference to the column vector containing the eigenvalues.

Precondition: The eigenvalues have been computed before.

The eigenvalues are repeated according to their algebraic multiplicity, so there are as many eigenvalues as rows in the matrix. The eigenvalues are sorted in increasing order.

Example:

MatrixXd ones = MatrixXd::Ones(3,3);
SelfAdjointEigenSolver<MatrixXd> es(ones);
cout << "The eigenvalues of the 3x3 matrix of ones are:" 
     << endl << es.eigenvalues() << endl;

Output:

The eigenvalues of the 3x3 matrix of ones are:
-3.09e-16
        0
        3

See also: eigenvectors(), MatrixBase::eigenvalues()

Definition at line 232 of file ArpackSelfAdjointEigenSolver.h.

   {
     eigen_assert(m_isInitialized && "ArpackGeneralizedSelfAdjointEigenSolver is not initialized.");
     return m_eivalues;
   }

◆ eigenvectors()

template<typename MatrixType , typename MatrixSolver = SimplicialLLT<MatrixType>, bool BisSPD = false>

const Matrix<Scalar, Dynamic, Dynamic>& Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::eigenvectors ( ) const

inline

Returns the eigenvectors of given matrix.

Returns: A const reference to the matrix whose columns are the eigenvectors.

Precondition: The eigenvectors have been computed before.

Column \( k \) of the returned matrix is an eigenvector corresponding to eigenvalue number \( k \) as returned by eigenvalues(). The eigenvectors are normalized to have (Euclidean) norm equal to one. If this object was used to solve the eigenproblem for the selfadjoint matrix \( A \), then the matrix returned by this function is the matrix \( V \) in the eigendecomposition \( A V = D V \). For the generalized eigenproblem, the matrix returned is the solution \( A V = D B V \)

Example:

MatrixXd ones = MatrixXd::Ones(3,3);
SelfAdjointEigenSolver<MatrixXd> es(ones);
cout << "The first eigenvector of the 3x3 matrix of ones is:" 
     << endl << es.eigenvectors().col(0) << endl;

Output:

The first eigenvector of the 3x3 matrix of ones is:
-0.816
 0.408
 0.408

See also: eigenvalues()

Definition at line 210 of file ArpackSelfAdjointEigenSolver.h.

   {
     eigen_assert(m_isInitialized && "ArpackGeneralizedSelfAdjointEigenSolver is not initialized.");
     eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
     return m_eivec;
   }

◆ getNbrConvergedEigenValues()

template<typename MatrixType , typename MatrixSolver = SimplicialLLT<MatrixType>, bool BisSPD = false>

size_t Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::getNbrConvergedEigenValues ( ) const

inline

Definition at line 298 of file ArpackSelfAdjointEigenSolver.h.

299 { return m_nbrConverged; }

◆ getNbrIterations()

template<typename MatrixType , typename MatrixSolver = SimplicialLLT<MatrixType>, bool BisSPD = false>

size_t Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::getNbrIterations ( ) const

inline

Definition at line 301 of file ArpackSelfAdjointEigenSolver.h.

302 { return m_nbrIterations; }

◆ info()

template<typename MatrixType , typename MatrixSolver = SimplicialLLT<MatrixType>, bool BisSPD = false>

ComputationInfo Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::info ( ) const

inline

Reports whether previous computation was successful.

Returns: Success if computation was successful, NoConvergence otherwise.

Definition at line 292 of file ArpackSelfAdjointEigenSolver.h.

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

◆ operatorInverseSqrt()

template<typename MatrixType , typename MatrixSolver = SimplicialLLT<MatrixType>, bool BisSPD = false>

Matrix<Scalar, Dynamic, Dynamic> Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::operatorInverseSqrt ( ) const

inline

Computes the inverse square root of the matrix.

Returns: the inverse positive-definite square root of the matrix

Precondition: The eigenvalues and eigenvectors of a positive-definite matrix have been computed before.

This function uses the eigendecomposition \( A = V D V^{-1} \) to compute the inverse square root as \( V D^{-1/2} V^{-1} \). This is cheaper than first computing the square root with operatorSqrt() and then its inverse with MatrixBase::inverse().

Example:

MatrixXd X = MatrixXd::Random(4,4);
MatrixXd A = X * X.transpose();
cout << "Here is a random positive-definite matrix, A:" << endl << A << endl << endl;
 
SelfAdjointEigenSolver<MatrixXd> es(A);
cout << "The inverse square root of A is: " << endl;
cout << es.operatorInverseSqrt() << endl;
cout << "We can also compute it with operatorSqrt() and inverse(). That yields: " << endl;
cout << es.operatorSqrt().inverse() << endl;

Output:

Here is a random positive-definite matrix, A:
  1.41 -0.697 -0.111  0.508
-0.697  0.423 0.0991   -0.4
-0.111 0.0991   1.25  0.902
 0.508   -0.4  0.902    1.4

The inverse square root of A is: 
  1.88   2.78 -0.546  0.605
  2.78   8.61   -2.3   2.74
-0.546   -2.3   1.92  -1.36
 0.605   2.74  -1.36   2.18
We can also compute it with operatorSqrt() and inverse(). That yields: 
  1.88   2.78 -0.546  0.605
  2.78   8.61   -2.3   2.74
-0.546   -2.3   1.92  -1.36
 0.605   2.74  -1.36   2.18

See also: operatorSqrt(), MatrixBase::inverse(), MatrixFunctions Module

Definition at line 281 of file ArpackSelfAdjointEigenSolver.h.

   {
     eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized.");
     eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
     return m_eivec * m_eivalues.cwiseInverse().cwiseSqrt().asDiagonal() * m_eivec.adjoint();
   }

◆ operatorSqrt()

template<typename MatrixType , typename MatrixSolver = SimplicialLLT<MatrixType>, bool BisSPD = false>

Matrix<Scalar, Dynamic, Dynamic> Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::operatorSqrt ( ) const

inline

Computes the positive-definite square root of the matrix.

Returns: the positive-definite square root of the matrix

Precondition: The eigenvalues and eigenvectors of a positive-definite matrix have been computed before.

The square root of a positive-definite matrix \( A \) is the positive-definite matrix whose square equals \( A \). This function uses the eigendecomposition \( A = V D V^{-1} \) to compute the square root as \( A^{1/2} = V D^{1/2} V^{-1} \).

Example:

MatrixXd X = MatrixXd::Random(4,4);
MatrixXd A = X * X.transpose();
cout << "Here is a random positive-definite matrix, A:" << endl << A << endl << endl;
 
SelfAdjointEigenSolver<MatrixXd> es(A);
MatrixXd sqrtA = es.operatorSqrt();
cout << "The square root of A is: " << endl << sqrtA << endl;
cout << "If we square this, we get: " << endl << sqrtA*sqrtA << endl;

Output:

Here is a random positive-definite matrix, A:
  1.41 -0.697 -0.111  0.508
-0.697  0.423 0.0991   -0.4
-0.111 0.0991   1.25  0.902
 0.508   -0.4  0.902    1.4

The square root of A is: 
   1.09  -0.432 -0.0685     0.2
 -0.432   0.379   0.141  -0.269
-0.0685   0.141       1   0.468
    0.2  -0.269   0.468    1.04
If we square this, we get: 
  1.41 -0.697 -0.111  0.508
-0.697  0.423 0.0991   -0.4
-0.111 0.0991   1.25  0.902
 0.508   -0.4  0.902    1.4

See also: operatorInverseSqrt(), MatrixFunctions Module

Definition at line 256 of file ArpackSelfAdjointEigenSolver.h.

   {
     eigen_assert(m_isInitialized && "SelfAdjointEigenSolver is not initialized.");
     eigen_assert(m_eigenvectorsOk && "The eigenvectors have not been computed together with the eigenvalues.");
     return m_eivec * m_eivalues.cwiseSqrt().asDiagonal() * m_eivec.adjoint();
   }

Member Data Documentation

◆ m_eigenvectorsOk

template<typename MatrixType , typename MatrixSolver = SimplicialLLT<MatrixType>, bool BisSPD = false>

bool Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::m_eigenvectorsOk

protected

Definition at line 309 of file ArpackSelfAdjointEigenSolver.h.

◆ m_eivalues

template<typename MatrixType , typename MatrixSolver = SimplicialLLT<MatrixType>, bool BisSPD = false>

Matrix<Scalar, Dynamic, 1> Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::m_eivalues

protected

Definition at line 306 of file ArpackSelfAdjointEigenSolver.h.

◆ m_eivec

template<typename MatrixType , typename MatrixSolver = SimplicialLLT<MatrixType>, bool BisSPD = false>

Matrix<Scalar, Dynamic, Dynamic> Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::m_eivec

protected

Definition at line 305 of file ArpackSelfAdjointEigenSolver.h.

◆ m_info

template<typename MatrixType , typename MatrixSolver = SimplicialLLT<MatrixType>, bool BisSPD = false>

ComputationInfo Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::m_info

protected

Definition at line 307 of file ArpackSelfAdjointEigenSolver.h.

◆ m_isInitialized

template<typename MatrixType , typename MatrixSolver = SimplicialLLT<MatrixType>, bool BisSPD = false>

bool Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::m_isInitialized

protected

Definition at line 308 of file ArpackSelfAdjointEigenSolver.h.

◆ m_nbrConverged

template<typename MatrixType , typename MatrixSolver = SimplicialLLT<MatrixType>, bool BisSPD = false>

size_t Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::m_nbrConverged

protected

Definition at line 311 of file ArpackSelfAdjointEigenSolver.h.

◆ m_nbrIterations

template<typename MatrixType , typename MatrixSolver = SimplicialLLT<MatrixType>, bool BisSPD = false>

size_t Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::m_nbrIterations

protected

Definition at line 312 of file ArpackSelfAdjointEigenSolver.h.

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

ArpackSelfAdjointEigenSolver.h

Public Types

Public Member Functions

Protected Attributes

Detailed Description

template<typename MatrixType, typename MatrixSolver = SimplicialLLT<MatrixType>, bool BisSPD = false> class Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >

Member Typedef Documentation

◆ Index

◆ RealScalar

◆ RealVectorType

◆ Scalar

Constructor & Destructor Documentation

◆ ArpackGeneralizedSelfAdjointEigenSolver() [1/3]

◆ ArpackGeneralizedSelfAdjointEigenSolver() [2/3]

◆ ArpackGeneralizedSelfAdjointEigenSolver() [3/3]

Member Function Documentation

◆ compute() [1/2]

◆ compute() [2/2]

◆ eigenvalues()

◆ eigenvectors()

◆ getNbrConvergedEigenValues()

◆ getNbrIterations()

◆ info()

◆ operatorInverseSqrt()

◆ operatorSqrt()

Member Data Documentation

◆ m_eigenvectorsOk

◆ m_eivalues

◆ m_eivec

◆ m_info

◆ m_isInitialized

◆ m_nbrConverged

◆ m_nbrIterations

template<typename MatrixType, typename MatrixSolver = SimplicialLLT<MatrixType>, bool BisSPD = false>
class Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >