cusp::precond::diagonal< ValueType, MemorySpace > Class Template Reference

#include <diagonal.h>

Inheritance diagram for cusp::precond::diagonal< ValueType, MemorySpace >:

Public Methods
template<typename MatrixType >
	diagonal (const MatrixType &A)
template<typename VectorType1 , typename VectorType2 >
void	operator() (const VectorType1 &x, VectorType2 &y) const
Public Methods inherited from cusp::linear_operator< ValueType, MemorySpace, IndexType >
	linear_operator (void)
	linear_operator (IndexType num_rows, IndexType num_cols)
	linear_operator (IndexType num_rows, IndexType num_cols, IndexType num_entries)

Detailed description

template<typename ValueType, typename MemorySpace>
class cusp::precond::diagonal< ValueType, MemorySpace >

Diagonal preconditioner (aka Jacobi preconditioner)

Template Parameters

ValueType	Type used for matrix values (e.g. float or double).
MemorySpace	A memory space (e.g. cusp::host_memory or cusp::device_memory)

Overview

Given a matrix A to precondition, the diagonal preconditioner simply extracts the main diagonal D of a A and implements y = D^-1 x when applied to a vector x.

Diagonal preconditioning is very inexpensive to use, but has limited effectiveness. However, if the matrix A has poorly scaled rows then diagonal preconditioning can substantially reduce the number of solver iterations required to reach convergence.

Example

The following code snippet demonstrates how to use a diagonal preconditioner to solve a linear system.

#include <cusp/precond/diagonal.h>
 
int main(void)
{
  // 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);
 
  cusp::default_monitor<float> monitor(b, 100, 1e-6);
 
  // setup preconditioner
  cusp::precond::diagonal<float, cusp::device_memory> M(A);
 
  // solve
  cusp::krylov::bicgstab(A, x, b, monitor, M);
 
  return 0;
}

Definition at line 85 of file diagonal.h.

Constructor & Destructor Documentation

diagonal()

template<typename ValueType , typename MemorySpace >

template<typename MatrixType >

cusp::precond::diagonal< ValueType, MemorySpace >::diagonal

(

const MatrixType &

A

)

construct a diagonal preconditioner

Parameters

A	matrix to precondition

Template Parameters

MatrixType

matrix

Member Function Documentation

operator()()

template<typename ValueType , typename MemorySpace >

template<typename VectorType1 , typename VectorType2 >

void cusp::precond::diagonal< ValueType, MemorySpace >::operator()	(	const VectorType1 &	x,
		VectorType2 &	y
	)		const

apply the preconditioner to vector x and store the result in y

Parameters

x	input vector
y	output vector

Template Parameters

VectorType1	vector
VectorType2	vector