Iterative Krylov methods for hermitian and non-hermitian linear systems. More...

Functions
template<typename LinearOperator , typename VectorType1 , typename VectorType2 , typename Monitor , typename Preconditioner >
void	cusp::krylov::bicg (const LinearOperator &A, const LinearOperator &At, VectorType1 &x, const VectorType2 &b, Monitor &monitor, Preconditioner &M, Preconditioner &Mt)
	Biconjugate Gradient method.

template<typename LinearOperator , typename VectorType1 , typename VectorType2 , typename Monitor , typename Preconditioner >
void	cusp::krylov::bicgstab (const LinearOperator &A, VectorType1 &x, const VectorType2 &b, Monitor &monitor, Preconditioner &M)
	Biconjugate Gradient Stabilized method.

template<class LinearOperator , class VectorType1 , class VectorType2 , class VectorType3 , class Monitor >
thrust::detail::enable_if_convertible_t< typename LinearOperator::format, cusp::known_format >	cusp::krylov::bicgstab_m (LinearOperator &A, VectorType1 &x, VectorType2 &b, VectorType3 &sigma, Monitor &monitor)
	Multi-mass Biconjugate Gradient stabilized method.

template<typename LinearOperator , typename VectorType1 , typename VectorType2 , typename Monitor , typename Preconditioner >
void	cusp::krylov::cg (const LinearOperator &A, VectorType1 &x, const VectorType2 &b, Monitor &monitor, Preconditioner &M)
	Conjugate Gradient method.

template<typename LinearOperator , typename VectorType1 , typename VectorType2 , typename VectorType3 , typename Monitor >
void	cusp::krylov::cg_m (const LinearOperator &A, VectorType1 &x, const VectorType2 &b, const VectorType3 &sigma, Monitor &monitor)
	Multi-mass Conjugate Gradient method.

template<typename LinearOperator , typename VectorType1 , typename VectorType2 , typename Monitor , typename Preconditioner >
void	cusp::krylov::cr (const LinearOperator &A, VectorType1 &x, const VectorType2 &b, Monitor &monitor, Preconditioner &M)
	Conjugate Residual method.

template<typename LinearOperator , typename VectorType1 , typename VectorType2 , typename Monitor , typename Preconditioner >
void	cusp::krylov::gmres (const LinearOperator &A, VectorType1 &x, const VectorType2 &b, const size_t restart, Monitor &monitor, Preconditioner &M)
	GMRES method.

Detailed Description

Iterative Krylov methods for hermitian and non-hermitian linear systems.

Function Documentation

◆ bicg()

template<typename LinearOperator , typename VectorType1 , typename VectorType2 , typename Monitor , typename Preconditioner >

void cusp::krylov::bicg	(	const LinearOperator &	A,
		const LinearOperator &	At,
		VectorType1 &	x,
		const VectorType2 &	b,
		Monitor &	monitor,
		Preconditioner &	M,
		Preconditioner &	Mt
	)

Biconjugate Gradient method.

Template Parameters

LinearOperator	is a matrix or subclass of `linear_operator`
VectorType1	vector
Monitor	is a `monitor`
Preconditioner	is a matrix or subclass of `linear_operator`

Parameters

A	matrix of the linear system
At	conjugate transpose of the matrix of the linear system
x	approximate solution of the linear system
b	right-hand side of the linear system
monitor	monitors iteration and determines stopping conditions
M	preconditioner for A
Mt	conjugate transpose of the preconditioner for A

Overview: Solves the linear system A x = b with preconditioner M.

Example

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

#include <cusp/csr_matrix.h>
#include <cusp/monitor.h>
#include <cusp/krylov/bicg.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 for solution (x) and right hand side (b)
    cusp::array1d<float, cusp::device_memory> x(A.num_rows, 0);
    cusp::array1d<float, cusp::device_memory> b(A.num_rows, 1);
 
    // set stopping criteria:
    //  iteration_limit    = 100
    //  relative_tolerance = 1e-6
    //  absolute_tolerance = 0
    //  verbose            = true
    cusp::monitor<float> monitor(b, 100, 1e-6, 0, true);
 
    // set preconditioner (identity)
    cusp::identity_operator<float, cusp::device_memory> M(A.num_rows, A.num_rows);
 
    // solve the linear system A x = b
    // because both A and M are hermitian we can use
    // them for their own conjugate transpose
    cusp::krylov::bicg(A, A, x, b, monitor, M, M);
 
    return 0;
}

See also: monitor

◆ bicgstab()

template<typename LinearOperator , typename VectorType1 , typename VectorType2 , typename Monitor , typename Preconditioner >

void cusp::krylov::bicgstab	(	const LinearOperator &	A,
		VectorType1 &	x,
		const VectorType2 &	b,
		Monitor &	monitor,
		Preconditioner &	M
	)

Biconjugate Gradient Stabilized method.

Template Parameters

LinearOperator	is a matrix or subclass of `linear_operator`
VectorType1	vector
Monitor	is a `monitor`
Preconditioner	is a matrix or subclass of `linear_operator`

Parameters

A	matrix of the linear system
x	approximate solution of the linear system
b	right-hand side of the linear system
monitor	monitors iteration and determines stopping conditions
M	preconditioner for A

Overview

Solves the linear system A x = b with preconditioner M.

Example

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

#include <cusp/csr_matrix.h>
#include <cusp/monitor.h>
#include <cusp/krylov/bicgstab.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 for solution (x) and right hand side (b)
    cusp::array1d<float, cusp::device_memory> x(A.num_rows, 0);
    cusp::array1d<float, cusp::device_memory> b(A.num_rows, 1);
 
    // set stopping criteria:
    //  iteration_limit    = 100
    //  relative_tolerance = 1e-6
    //  absolute_tolerance = 0
    //  verbose            = true
    cusp::monitor<float> monitor(b, 100, 1e-6, 0, true);
 
    // set preconditioner (identity)
    cusp::identity_operator<float, cusp::device_memory> M(A.num_rows, A.num_rows);
 
    // solve the linear system A x = b
    cusp::krylov::bicgstab(A, x, b, monitor, M);
 
    return 0;
}

See also: monitor

◆ bicgstab_m()

template<class LinearOperator , class VectorType1 , class VectorType2 , class VectorType3 , class Monitor >

thrust::detail::enable_if_convertible_t< typename LinearOperator::format, cusp::known_format > cusp::krylov::bicgstab_m	(	LinearOperator &	A,
		VectorType1 &	x,
		VectorType2 &	b,
		VectorType3 &	sigma,
		Monitor &	monitor
	)

Multi-mass Biconjugate Gradient stabilized method.

Template Parameters

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

Parameters

A	matrix of the linear system
x	approximate solution of the linear system
b	right-hand side of the linear system
sigma	array of shifts
monitor	monitors iteration and determines stopping conditions

Overview

This routine solves systems of the type

(A+sigma Id)x = b

for a number of different sigma, iteratively, for sparse A, without additional matrix-vector multiplication.

See also: http://arxiv.org/abs/hep-lat/9612014

Example

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

#include <cusp/csr_matrix.h>
#include <cusp/monitor.h>
#include <cusp/krylov/bicgstab_m.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 for solution (x) and right hand side (b)
    size_t N_s = 4;
    cusp::array1d<float, cusp::device_memory> x(A.num_rows*N_s, 0);
    cusp::array1d<float, cusp::device_memory> b(A.num_rows, 1);
 
    // set sigma values
    cusp::array1d<float, cusp::device_memory> sigma(N_s);
    sigma[0] = 0.1;
    sigma[1] = 0.5;
    sigma[2] = 1.0;
    sigma[3] = 5.0;
 
    // set stopping criteria:
    //  iteration_limit    = 100
    //  relative_tolerance = 1e-6
    //  absolute_tolerance = 0
    //  verbose            = true
    cusp::monitor<float> monitor(b, 100, 1e-6, 0, true);
 
    // solve the linear system A x = b
    cusp::krylov::bicgstab_m(A, x, b, sigma, monitor);
 
    return 0;
}

See also: monitor

◆ cg()

template<typename LinearOperator , typename VectorType1 , typename VectorType2 , typename Monitor , typename Preconditioner >

void cusp::krylov::cg	(	const LinearOperator &	A,
		VectorType1 &	x,
		const VectorType2 &	b,
		Monitor &	monitor,
		Preconditioner &	M
	)

Conjugate Gradient method.

Template Parameters

LinearOperator	is a matrix or subclass of `linear_operator`
VectorType1	x input vector type
VectorType2	b output vector type
Monitor	is a `monitor`
Preconditioner	is a matrix or subclass of `linear_operator`

Parameters

A	matrix of the linear system
x	approximate solution of the linear system
b	right-hand side of the linear system
monitor	monitors iteration and determines stopping conditions
M	preconditioner for A

Overview: Solves the symmetric, positive-definite linear system A x = b with preconditioner M.

Note: A and M must be symmetric and positive-definite.

Example: The following code snippet demonstrates how to use cg to solve a 10x10 Poisson problem.

#include <cusp/csr_matrix.h>
#include <cusp/monitor.h>
#include <cusp/krylov/cg.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 for solution (x) and right hand side (b)
    cusp::array1d<float, cusp::device_memory> x(A.num_rows, 0);
    cusp::array1d<float, cusp::device_memory> b(A.num_rows, 1);
 
    // set stopping criteria:
    //  iteration_limit    = 100
    //  relative_tolerance = 1e-6
    //  absolute_tolerance = 0
    //  verbose            = true
    cusp::monitor<float> monitor(b, 100, 1e-6, 0, true);
 
    // set preconditioner (identity)
    cusp::identity_operator<float, cusp::device_memory> M(A.num_rows, A.num_rows);
 
    // solve the linear system A x = b
    cusp::krylov::cg(A, x, b, monitor, M);
 
    return 0;
}

See also: monitor

◆ cg_m()

template<typename LinearOperator , typename VectorType1 , typename VectorType2 , typename VectorType3 , typename Monitor >

void cusp::krylov::cg_m	(	const LinearOperator &	A,
		VectorType1 &	x,
		const VectorType2 &	b,
		const VectorType3 &	sigma,
		Monitor &	monitor
	)

Multi-mass Conjugate Gradient method.

Parameters

A	matrix of the linear system
x	solutions of the system
b	right-hand side of the linear system
sigma	array of shifts
monitor	monitors iteration and determines stopping conditions

Overview

Solves the symmetric, positive-definited linear system (A+sigma) x = b for some set of constant shifts sigma for the price of the smallest shift iteratively, for sparse A, without additional matrix-vector multiplication.

See also: http://arxiv.org/abs/hep-lat/9612014

Example

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

#include <cusp/csr_matrix.h>
#include <cusp/monitor.h>
#include <cusp/krylov/cg_m.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 for solution (x) and right hand side (b)
    size_t N_s = 4;
    cusp::array1d<float, cusp::device_memory> x(A.num_rows*N_s, 0);
    cusp::array1d<float, cusp::device_memory> b(A.num_rows, 1);
 
    // set sigma values
    cusp::array1d<float, cusp::device_memory> sigma(N_s);
    sigma[0] = 0.1;
    sigma[1] = 0.5;
    sigma[2] = 1.0;
    sigma[3] = 5.0;
 
    // set stopping criteria:
    //  iteration_limit    = 100
    //  relative_tolerance = 1e-6
    //  absolute_tolerance = 0
    //  verbose            = true
    cusp::monitor<float> monitor(b, 100, 1e-6, 0, true);
 
    // solve the linear system A x = b
    cusp::krylov::cg_m(A, x, b, sigma, monitor);
 
    return 0;
}

See also: monitor

◆ cr()

template<typename LinearOperator , typename VectorType1 , typename VectorType2 , typename Monitor , typename Preconditioner >

void cusp::krylov::cr	(	const LinearOperator &	A,
		VectorType1 &	x,
		const VectorType2 &	b,
		Monitor &	monitor,
		Preconditioner &	M
	)

Conjugate Residual method.

Template Parameters

LinearOperator	is a matrix or subclass of `linear_operator`
VectorType1	vector
Monitor	is a `monitor`
Preconditioner	is a matrix or subclass of `linear_operator`

Parameters

A	matrix of the linear system
x	approximate solution of the linear system
b	right-hand side of the linear system
monitor	monitors iteration and determines stopping conditions
M	preconditioner for A

Overview: Solves a linear system using the conjugate residual method

Note: A and M must be symmetric and semi-definite.

Example: The following code snippet demonstrates how to use cr to solve a 10x10 Poisson problem.

#include <cusp/csr_matrix.h>
#include <cusp/monitor.h>
#include <cusp/krylov/cr.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 for solution (x) and right hand side (b)
    cusp::array1d<float, cusp::device_memory> x(A.num_rows, 0);
    cusp::array1d<float, cusp::device_memory> b(A.num_rows, 1);
 
    // set stopping criteria:
    //  iteration_limit    = 100
    //  relative_tolerance = 1e-6
    //  absolute_tolerance = 0
    //  verbose            = true
    cusp::monitor<float> monitor(b, 100, 1e-6, 0, true);
 
    // set preconditioner (identity)
    cusp::identity_operator<float, cusp::device_memory> M(A.num_rows, A.num_rows);
 
    // solve the linear system A x = b
    cusp::krylov::cr(A, x, b, monitor, M);
 
    return 0;
}

See also: monitor

◆ gmres()

template<typename LinearOperator , typename VectorType1 , typename VectorType2 , typename Monitor , typename Preconditioner >

void cusp::krylov::gmres	(	const LinearOperator &	A,
		VectorType1 &	x,
		const VectorType2 &	b,
		const size_t	restart,
		Monitor &	monitor,
		Preconditioner &	M
	)

GMRES method.

Template Parameters

LinearOperator	is a matrix or subclass of `linear_operator`
VectorType1	vector
Monitor	is a monitor such as `default_monitor` or `verbose_monitor`
Preconditioner	is a matrix or subclass of `linear_operator`

Parameters

A	matrix of the linear system
x	approximate solution of the linear system
b	right-hand side of the linear system
restart	the method every restart inner iterations
monitor	monitors iteration and determines stopping conditions
M	preconditioner for A

Overview: Solves the nonsymmetric, linear system A x = b with preconditioner M.

Example

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

#include <cusp/csr_matrix.h>
#include <cusp/monitor.h>
#include <cusp/krylov/gmres.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 for solution (x) and right hand side (b)
    cusp::array1d<float, cusp::device_memory> x(A.num_rows, 0);
    cusp::array1d<float, cusp::device_memory> b(A.num_rows, 1);
 
    // set stopping criteria:
    //  iteration_limit    = 100
    //  relative_tolerance = 1e-6
    //  absolute_tolerance = 0
    //  verbose            = true
    cusp::monitor<float> monitor(b, 100, 1e-6, 0, true);
    int restart = 50;
 
    // set preconditioner (identity)
    cusp::identity_operator<float, cusp::device_memory> M(A.num_rows, A.num_rows);
 
    // solve the linear system A x = b
    cusp::krylov::gmres(A, x, b,restart, monitor, M);
 
    return 0;
}

See also: monitor

Functions

Detailed Description

Function Documentation

◆ bicg()

◆ bicgstab()

◆ bicgstab_m()

◆ cg()

◆ cg_m()

◆ cr()

◆ gmres()