Spectra

https://spectralib.org/doc/index.html
Admin
Spectra is a header-only C++ library designed for solving large-scale eigenvalue problems by...
Tokens:2,162
Snippets:15
Trust Score:8.7
Update:4 months ago
Show doc for...
Tokens:
Raw
### Custom Matrix Operation for Spectra Eigen Solver

Source: https://spectralib.org/doc/index.html

Demonstrates using a user-supplied class for matrix operations with SymEigsSolver. The custom class must define Scalar, rows(), cols(), and perform_op().

```cpp
#include <Eigen/Core>
#include <Spectra/SymEigsSolver.h>
#include <iostream>
using namespace Spectra;
// M = diag(1, 2, ..., 10)
class MyDiagonalTen
{
public:
using Scalar = double; // A typedef named "Scalar" is required
int rows() const { return 10; }
int cols() const { return 10; }
// y_out = M * x_in
void perform_op(const double *x_in, double *y_out) const
{
for(int i = 0; i < rows(); i++)
{
y_out[i] = x_in[i] * (i + 1);
}
}
};
int main()
{
MyDiagonalTen op;
SymEigsSolver<MyDiagonalTen> eigs(op, 3, 6);
eigs.init();
eigs.compute(SortRule::LargestAlge);
if(eigs.info() == CompInfo::Successful)
{
Eigen::VectorXd evalues = eigs.eigenvalues();
std::cout << "Eigenvalues found:\n" << evalues << std::endl;
}
return 0;
}
```

--------------------------------

### Solve Sparse General Eigenvalue Problem with Spectra

Source: https://spectralib.org/doc/index.html

Use GenEigsSolver for sparse matrices. Requires Eigen/SparseCore and Spectra headers. Computes the largest magnitude eigenvalues.

```cpp
#include <Eigen/Core>
#include <Eigen/SparseCore>
#include <Spectra/GenEigsSolver.h>
#include <Spectra/MatOp/SparseGenMatProd.h>
#include <iostream>
using namespace Spectra;
int main()
{
// A band matrix with 1 on the main diagonal, 2 on the below-main subdiagonal,
// and 3 on the above-main subdiagonal
const int n = 10;
Eigen::SparseMatrix<double> M(n, n);
M.reserve(Eigen::VectorXi::Constant(n, 3));
for(int i = 0; i < n; i++)
{
M.insert(i, i) = 1.0;
if(i > 0)
M.insert(i - 1, i) = 3.0;
if(i < n - 1)
M.insert(i + 1, i) = 2.0;
}
// Construct matrix operation object using the wrapper class SparseGenMatProd
SparseGenMatProd<double> op(M);
// Construct eigen solver object, requesting the largest three eigenvalues
GenEigsSolver<SparseGenMatProd<double>> eigs(op, 3, 6);
// Initialize and compute
eigs.init();
int nconv = eigs.compute(SortRule::LargestMagn);
// Retrieve results
Eigen::VectorXcd evalues;
if(eigs.info() == CompInfo::Successful)
evalues = eigs.eigenvalues();
std::cout << "Eigenvalues found:\n" << evalues << std::endl;
return 0;
}
```

--------------------------------

### Complex Matrix Eigenvalue Calculation

Source: https://spectralib.org/doc/index.html

Demonstrates calculating eigenvalues and eigenvectors for both Hermitian and general complex-valued matrices using Spectra's HermEigsSolver and GenEigsSolver. Requires Eigen library for matrix operations.

```cpp
#include <Eigen/Core>
#include <Spectra/HermEigsSolver.h>
#include <Spectra/GenEigsSolver.h>
#include <iostream>
using namespace Spectra;
int main()
{
std::srand(0);
// We are going to calculate the eigenvalues of H and G
Eigen::MatrixXcd G = Eigen::MatrixXcd::Random(10, 10);
// H is Hermitian
Eigen::MatrixXcd H = G + G.adjoint();
// Construct matrix operation objects using the wrapper
// classes DenseHermMatProd and DenseGenMatProd
using OpHType = DenseHermMatProd<std::complex<double>>;
using OpGType = DenseGenMatProd<std::complex<double>>;
OpHType opH(H);
OpGType opG(G);
// Construct solver object for H, requesting the largest three eigenvalues
HermEigsSolver<OpHType> eigsH(opH, 3, 6);
// Initialize and compute
eigsH.init();
int nconvH = eigsH.compute(SortRule::LargestAlge);
// Retrieve results
// Eigenvalues are real-valued, and eigenvectors are complex-valued
if (eigsH.info() == CompInfo::Successful)
{
Eigen::VectorXd evaluesH = eigsH.eigenvalues();
std::cout << "Eigenvalues of H found:\n" << evaluesH << std::endl;
Eigen::MatrixXcd evecsH = eigsH.eigenvectors();
std::cout << "Eigenvectors of H:\n" << evecsH << std::endl;
}
// Similar procedure for matrix G
GenEigsSolver<OpGType> eigsG(opG, 3, 6);
eigsG.init();
int nconvG = eigsG.compute(SortRule::LargestMagn);
if (eigsG.info() == CompInfo::Successful)
{
Eigen::VectorXcd evaluesG = eigsG.eigenvalues();
std::cout << "Eigenvalues of G found:\n" << evaluesG << std::endl;
Eigen::MatrixXcd evecsG = eigsG.eigenvectors();
std::cout << "Eigenvectors of G:\n" << evecsG << std::endl;
}
return 0;
}
```

--------------------------------

### Solve Dense Symmetric Eigenvalue Problem with Spectra

Source: https://spectralib.org/doc/index.html

Use SymEigsSolver for dense symmetric matrices. Requires Eigen library and Spectra headers. Computes the largest algebraic eigenvalues.

```cpp
#include <Eigen/Core>
#include <Spectra/SymEigsSolver.h>
// <Spectra/MatOp/DenseSymMatProd.h> is implicitly included
#include <iostream>
using namespace Spectra;
int main()
{
// We are going to calculate the eigenvalues of M
Eigen::MatrixXd A = Eigen::MatrixXd::Random(10, 10);
Eigen::MatrixXd M = A + A.transpose();
// Construct matrix operation object using the wrapper class DenseSymMatProd
DenseSymMatProd<double> op(M);
// Construct eigen solver object, requesting the largest three eigenvalues
SymEigsSolver<DenseSymMatProd<double>> eigs(op, 3, 6);
// Initialize and compute
eigs.init();
int nconv = eigs.compute(SortRule::LargestAlge);
// Retrieve results
Eigen::VectorXd evalues;
if(eigs.info() == CompInfo::Successful)
evalues = eigs.eigenvalues();
std::cout << "Eigenvalues found:\n" << evalues << std::endl;
return 0;
}
```
Tokens:
Raw