Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD > Class Template Reference

#include <ArpackSelfAdjointEigenSolver.h>

Public Types
typedef MatrixType::Scalar	Scalar
	Scalar type for matrices of type MatrixType. More...
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...

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, Dynamic > &	eigenvectors () const
	Returns the eigenvectors of given matrix. More...
const Matrix< Scalar, Dynamic, 1 > &	eigenvalues () const
	Returns the eigenvalues of given matrix. More...
Matrix< Scalar, Dynamic, Dynamic >	operatorSqrt () const
	Computes the positive-definite square root of the matrix. More...
Matrix< Scalar, Dynamic, Dynamic >	operatorInverseSqrt () const
	Computes the inverse square root of the matrix. More...
ComputationInfo	info () const
	Reports whether previous computation was successful. More...
size_t	getNbrConvergedEigenValues () const
size_t	getNbrIterations () const

Protected Attributes
Matrix< Scalar, Dynamic, Dynamic >	m_eivec
Matrix< Scalar, Dynamic, 1 >	m_eivalues
ComputationInfo	m_info
bool	m_isInitialized
bool	m_eigenvectorsOk
size_t	m_nbrConverged
size_t	m_nbrIterations

Member Typedef Documentation

Index

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

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

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.

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.

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.

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().

      : 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.

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

References Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::compute().

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.

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

References Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::compute().

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().

                                                                                                   {
  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;
}

References Eigen::internal::OP< MatrixSolver, MatrixType, Scalar, BisSPD >::applyOP(), Eigen::bfloat16_impl::ceil(), Eigen::PlainObjectBase< Derived >::cols(), Eigen::ComputeEigenvectors, eigen_assert, Eigen::EigVecMask, Eigen::GenEigMask, i, info, int(), Eigen::InvalidInput, j, Eigen::PlainObjectBase< Matrix< Scalar_, Rows_, Cols_, Options_, MaxRows_, MaxCols_ > >::Map(), max, min, n, Eigen::NoConvergence, Eigen::NumericalIssue, OP, out(), Eigen::internal::OP< MatrixSolver, MatrixType, Scalar, BisSPD >::project(), Eigen::PlainObjectBase< Derived >::rows(), Eigen::internal::arpack_wrapper< Scalar, RealScalar >::saupd(), Eigen::internal::arpack_wrapper< Scalar, RealScalar >::seupd(), calibrate::sigma, Eigen::Success, and v.

Referenced by Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::ArpackGeneralizedSelfAdjointEigenSolver().

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().

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

References compute().

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:

See also

eigenvectors(), MatrixBase::eigenvalues()

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

References eigen_assert, Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::m_eivalues, and Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::m_isInitialized.

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:

See also

eigenvalues()

                                                               {
    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;
  }

References eigen_assert, Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::m_eigenvectorsOk, Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::m_eivec, and Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::m_isInitialized.

getNbrConvergedEigenValues()

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

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

inline

{ return m_nbrConverged; }

References Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::m_nbrConverged.

getNbrIterations()

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

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

inline

{ return m_nbrIterations; }

References Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::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.

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

References eigen_assert, Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::m_info, and Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::m_isInitialized.

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:

See also

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

                                                               {
    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();
  }

References eigen_assert, Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::m_eigenvectorsOk, Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::m_eivalues, Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::m_eivec, and Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::m_isInitialized.

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:

See also

operatorInverseSqrt(), MatrixFunctions Module

                                                        {
    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();
  }

References eigen_assert, Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::m_eigenvectorsOk, Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::m_eivalues, Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::m_eivec, and Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::m_isInitialized.

Member Data Documentation

m_eigenvectorsOk

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

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

protected

Referenced by Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::eigenvectors(), Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::operatorInverseSqrt(), and Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::operatorSqrt().

m_eivalues

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

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

protected

Referenced by Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::eigenvalues(), Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::operatorInverseSqrt(), and Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::operatorSqrt().

m_eivec

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

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

protected

Referenced by Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::eigenvectors(), Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::operatorInverseSqrt(), and Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::operatorSqrt().

m_info

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

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

protected

Referenced by Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::info().

m_isInitialized

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

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

protected

Referenced by Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::eigenvalues(), Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::eigenvectors(), Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::info(), Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::operatorInverseSqrt(), and Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::operatorSqrt().

m_nbrConverged

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

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

protected

Referenced by Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::getNbrConvergedEigenValues().

m_nbrIterations

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

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

protected

Referenced by Eigen::ArpackGeneralizedSelfAdjointEigenSolver< MatrixType, MatrixSolver, BisSPD >::getNbrIterations().

---

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

• ArpackSelfAdjointEigenSolver.h