EigenSolvers

Iterative methods for computing eigenpairs of hermitian and non-hermitian linear systems. More...

Functions
template<typename Matrix , typename Array2d >
void	cusp::eigen::arnoldi (const Matrix &A, Array2d &H, size_t k=10)
	Approximate spectral radius of A using Arnoldi.
template<typename LinearOperator , typename Array1d , typename Array2d , typename LanczosOptions >
void	cusp::eigen::lanczos (const LinearOperator &A, Array1d &eigVals, Array2d &eigVecs, LanczosOptions &options)
	Lanczos method.
template<typename LinearOperator , typename Array1d , typename Array2d , typename Monitor , typename Preconditioner >
void	cusp::eigen::lobpcg (LinearOperator &A, Array1d &S, Array2d &X, Monitor &monitor, Preconditioner &M, bool largest=true)
	LOBPCG method.
template<typename MatrixType >
double	cusp::eigen::disks_spectral_radius (const MatrixType &A)
	Uses Gershgorin disks to approximate spectral radius.
template<typename MatrixType >
double	cusp::eigen::estimate_rho_Dinv_A (const MatrixType &A)
	Approximate spectral radius of (D^-1)A.
template<typename MatrixType >
double	cusp::eigen::estimate_spectral_radius (const MatrixType &A, size_t k=20)
	Approximate spectral radius of A using Lanczos.
template<typename MatrixType >
double	cusp::eigen::ritz_spectral_radius (const MatrixType &A, size_t k=10, bool symmetric=false)
	Approximate spectral radius of A using Lanczos or Arnoldi.

Detailed Description

Iterative methods for computing eigenpairs of hermitian and non-hermitian linear systems.

Function Documentation

arnoldi()

template<typename Matrix , typename Array2d >

void cusp::eigen::arnoldi	(	const Matrix &	A,
		Array2d &	H,
		size_t	k = 10
	)

Approximate spectral radius of A using Arnoldi.

Template Parameters

Matrix	type of a sparse or dense matrix
Array2d	type of dense matrix of partials

Parameters

A	matrix of the linear system
H	dense matrix of ritz values
k	maximum number of outer Arnoldi iterations

Overview

Approximates the spectral radius A using a specified number of Arnoldi iterations.

Example

The following code snippet demonstrates how to use arnoldi to compute the spectral radius of a 16x16 Laplacian matrix.

#include <cusp/csr_matrix.h>
#include <cusp/eigen/arnoldi.h>
#include <cusp/gallery/poisson.h>
 
int main(void)
{
    // create an empty sparse matrix structure (CSR format)
    cusp::csr_matrix<int, float, cusp::device_memory> A;
 
    // initialize matrix
    cusp::gallery::poisson5pt(A, 4, 4);
 
    // compute the largest eigenpair of A using 20 Arnoldi iterations
    float rho = cusp::eigen::arnoldi(A, 20);
    std::cout << "Spectral radius of A : " << rho << std::endl;
 
    return 0;
}

disks_spectral_radius()

template<typename MatrixType >

double cusp::eigen::disks_spectral_radius

(

const MatrixType &

A

)

Uses Gershgorin disks to approximate spectral radius.

Template Parameters

MatrixType

type of a sparse or dense matrix

Parameters

A	matrix of the linear system

Returns

spectral radius approximation

Overview

Approximates the spectral radius of a matrix using Gershgorin disks.

See also

https://en.wikipedia.org/wiki/Gershgorin_circle_theorem

Example

The following code snippet demonstrates how to use disks_spectral_radius to compute the spectral radius of a 16x16 Laplacian matrix.

#include <cusp/csr_matrix.h>
#include <cusp/monitor.h>
#include <cusp/eigen/spectral_radius.h>
#include <cusp/gallery/poisson.h>
 
int main(void)
{
    // create an empty sparse matrix structure (CSR format)
    cusp::csr_matrix<int, float, cusp::device_memory> A;
 
    // initialize matrix
    cusp::gallery::poisson5pt(A, 4, 4);
 
    // compute the largest eigenpair of A
    float rho = cusp::eigen::disks_spectral_radius(A);
    std::cout << "Spectral radius of A : " << rho << std::endl;
 
    return 0;
}

estimate_rho_Dinv_A()

template<typename MatrixType >

double cusp::eigen::estimate_rho_Dinv_A

(

const MatrixType &

A

)

Approximate spectral radius of (D^-1)A.

Template Parameters

MatrixType

type of a sparse or dense matrix

Parameters

A	matrix of the linear system

Returns

spectral radius approximation

Overview

Approximates the spectral radius (D^-1)A, where D is a diagonal matrix containing the diagonal entries of A. The spectral radius of (D^-1)A is computed using either Lanczos or Arnoldi.

Example

The following code snippet demonstrates how to use estimate_rho_Dinv_A to compute the spectral radius of a 16x16 Laplacian matrix.

#include <cusp/csr_matrix.h>
#include <cusp/monitor.h>
#include <cusp/eigen/spectral_radius.h>
#include <cusp/gallery/poisson.h>
 
int main(void)
{
    // create an empty sparse matrix structure (CSR format)
    cusp::csr_matrix<int, float, cusp::device_memory> A;
 
    // initialize matrix
    cusp::gallery::poisson5pt(A, 4, 4);
 
    // compute the largest eigenpair of A
    float rho = cusp::eigen::estimate_rho_Dinv_A(A);
    std::cout << "Spectral radius of (D^-1)A : " << rho << std::endl;
 
    return 0;
}

estimate_spectral_radius()

template<typename MatrixType >

double cusp::eigen::estimate_spectral_radius	(	const MatrixType &	A,
		size_t	k = 20
	)

Approximate spectral radius of A using Lanczos.

Template Parameters

MatrixType

type of a sparse or dense matrix

Parameters

A	matrix of the linear system
k	number of Lanczos iterations

Returns

spectral radius approximation

Overview

Approximates the spectral radius A using a specified number of Lanczos iterations.

Example

The following code snippet demonstrates how to use estimate_spectral_radius to compute the spectral radius of a 16x16 Laplacian matrix.

#include <cusp/csr_matrix.h>
#include <cusp/monitor.h>
#include <cusp/eigen/spectral_radius.h>
#include <cusp/gallery/poisson.h>
 
int main(void)
{
    // create an empty sparse matrix structure (CSR format)
    cusp::csr_matrix<int, float, cusp::device_memory> A;
 
    // initialize matrix
    cusp::gallery::poisson5pt(A, 4, 4);
 
    // compute the largest eigenpair of A using 20 Lanczos iterations
    float rho = cusp::eigen::estimate_spectral_radius(A, 20);
    std::cout << "Spectral radius of A : " << rho << std::endl;
 
    return 0;
}

lanczos()

template<typename LinearOperator , typename Array1d , typename Array2d , typename LanczosOptions >

void cusp::eigen::lanczos	(	const LinearOperator &	A,
		Array1d &	eigVals,
		Array2d &	eigVecs,
		LanczosOptions &	options
	)

Lanczos method.

Template Parameters

LinearOperator	is a matrix or subclass of linear_operator
Array1d	array of eigenvalues
Array2d	matrix of eigenvectors

Parameters

A	matrix of the linear system
eigVals	eigenvalues
eigVecs	eigenvectors
options	Lanczos solver options

Overview

Computes the extreme eigenpairs of hermitian linear systems A x = s x.

Note

A must be symmetric.

Example

The following code snippet demonstrates how to use lanczos to compute the eigenpairs of a 10x10 Laplacian matrix.

#include <cusp/csr_matrix.h>
#include <cusp/eigen/lanczos.h>
#include <cusp/gallery/poisson.h>
 
int main(void)
{
    // create an empty sparse matrix structure (CSR format)
    cusp::csr_matrix<int, float, cusp::device_memory> A;
 
    // initialize matrix
    cusp::gallery::poisson5pt(A, 10, 10);
 
    // allocate storage and initialize eigenpairs
    cusp::array1d<float, cusp::device_memory> eigvals(5,0);
    cusp::array2d<float, cusp::device_memory, cusp::column_major> eigvecs;
 
    // initialize Lanzcos option
    cusp::eigen::lanczos_options<float> options;
    options.tol             = 1e-6;
    options.maxIter         = 100;
    options.verbose         = true;
    options.computeEigVecs  = false;
    options.reorth          = cusp::eigen::Full;
 
    // compute the largest eigenpair of A
    cusp::eigen::lanczos(A, eigvals, eigvecs, options);
 
    // print largest eigenvalue
    std::cout << "Largest eigenvalue : " << eigvals.back() << std::endl;
 
    return 0;
}

lobpcg()

template<typename LinearOperator , typename Array1d , typename Array2d , typename Monitor , typename Preconditioner >

void cusp::eigen::lobpcg	(	LinearOperator &	A,
		Array1d &	S,
		Array2d &	X,
		Monitor &	monitor,
		Preconditioner &	M,
		bool	largest = true
	)

LOBPCG method.

Template Parameters

LinearOperator	is a matrix or subtypename of linear_operator
Vector	vector
Monitor	is a monitor
Preconditioner	is a matrix or subtypename of linear_operator

Parameters

A	matrix of the linear system
S	eigenvalues
X	eigenvectors
monitor	monitors iteration and determines stopping conditions
M	preconditioner for A
largest	If true compute the eigenpair corresponding to the largest eigenvalue otherwise compute the smallest.

Overview

Computes the extreme eigenpairs of hermitian linear systems A x = s x using LOBPCG.

Note

A and M must be symmetric.

See also

https://en.wikipedia.org/wiki/LOBPCG

Example

The following code snippet demonstrates how to use lobpcg to solve a 10x10 Poisson problem.

#include <cusp/csr_matrix.h>
#include <cusp/monitor.h>
#include <cusp/eigen/lobpcg.h>
#include <cusp/gallery/poisson.h>
 
int main(void)
{
    // create an empty sparse matrix structure (CSR format)
    cusp::csr_matrix<int, double, cusp::device_memory> A;
 
    // initialize matrix
    cusp::gallery::poisson5pt(A, 10, 10);
 
    // allocate storage and initialize eigenpairs
    cusp::random_array<double> randx(A.num_rows);
    cusp::array1d<double, cusp::device_memory> X(randx);
    cusp::array1d<double, cusp::device_memory> S(1,0);
 
    // set stopping criteria:
    //  iteration_limit    = 100
    //  relative_tolerance = 1e-6
    //  absolute_tolerance = 0
    //  verbose            = true
    cusp::monitor<double> monitor(X, 100, 1e-6, 0, true);
 
    // set preconditioner (identity)
    cusp::identity_operator<double, cusp::device_memory> M(A.num_rows, A.num_rows);
 
    // Compute the largest eigenpair of A
    cusp::eigen::lobpcg(A, S, X, monitor, M, true);
 
    std::cout << "Largest eigenvalue : " << S[0] << std::endl;
 
    return 0;
}

See also

monitor

ritz_spectral_radius()

template<typename MatrixType >

double cusp::eigen::ritz_spectral_radius	(	const MatrixType &	A,
		size_t	k = 10,
		bool	symmetric = false
	)

Approximate spectral radius of A using Lanczos or Arnoldi.

Template Parameters

MatrixType

type of a sparse or dense matrix

Parameters

A	matrix of the linear system
k	number of iterations
symmetric	if true use Lanczos, otherwise use Arnoldi

Returns

spectral radius approximation

Overview

Approximates the spectral radius A using a specified number of Lanczos or Arnoldi iterations.

Example

The following code snippet demonstrates how to use ritz_spectral_radius to compute the spectral radius of a 16x16 Laplacian matrix.

#include <cusp/csr_matrix.h>
#include <cusp/monitor.h>
#include <cusp/eigen/spectral_radius.h>
#include <cusp/gallery/poisson.h>
 
int main(void)
{
    // create an empty sparse matrix structure (CSR format)
    cusp::csr_matrix<int, float, cusp::device_memory> A;
 
    // initialize matrix
    cusp::gallery::poisson5pt(A, 4, 4);
 
    // compute the largest eigenpair of A using 20 Arnoldi iterations
    float rho = cusp::eigen::ritz_spectral_radius(A, 20, false);
    std::cout << "Spectral radius of A : " << rho << std::endl;
 
    return 0;
}