Sparse linear algebra (`scipy.sparse.linalg`)¶

Warning

This documentation is work-in-progress and unorganized.

Sparse Linear Algebra¶

The submodules of sparse.linalg:

eigen: sparse eigenvalue problem solvers
isolve: iterative methods for solving linear systems
dsolve: direct factorization methods for solving linear systems

Examples¶

class scipy.sparse.linalg.LinearOperator(shape, matvec, rmatvec=None, matmat=None, dtype=None)¶

Common interface for performing matrix vector products

Many iterative methods (e.g. cg, gmres) do not need to know the individual entries of a matrix to solve a linear system A*x=b. Such solvers only require the computation of matrix vector products, A*v where v is a dense vector. This class serves as an abstract interface between iterative solvers and matrix-like objects.

Parameters:

shape : tuple

Matrix dimensions (M,N)

matvec : callable f(v)

Returns returns A * v.

See also

aslinearoperator: Construct LinearOperators

Notes

The user-defined matvec() function must properly handle the case where v has shape (N,) as well as the (N,1) case. The shape of the return type is handled internally by LinearOperator.

Examples

>>> from scipy.sparse.linalg import LinearOperator
>>> from scipy import *
>>> def mv(v):
...     return array([ 2*v[0], 3*v[1]])
...
>>> A = LinearOperator( (2,2), matvec=mv )
>>> A
<2x2 LinearOperator with unspecified dtype>
>>> A.matvec( ones(2) )
array([ 2.,  3.])
>>> A * ones(2)
array([ 2.,  3.])

matmat(X)¶

Matrix-matrix multiplication

Performs the operation y=A*X where A is an MxN linear operator and X dense N*K matrix or ndarray.

Parameters:

X : {matrix, ndarray}

An array with shape (N,K).

Returns:

Y : {matrix, ndarray}

A matrix or ndarray with shape (M,K) depending on the type of the X argument.

Notes

This matmat wraps any user-specified matmat routine to ensure that y has the correct type.

matvec(x)¶

Matrix-vector multiplication

Performs the operation y=A*x where A is an MxN linear operator and x is a column vector or rank-1 array.

Parameters:

x : {matrix, ndarray}

An array with shape (N,) or (N,1).

Returns:

y : {matrix, ndarray}

A matrix or ndarray with shape (M,) or (M,1) depending on the type and shape of the x argument.

Notes

This matvec wraps the user-specified matvec routine to ensure that y has the correct shape and type.

class scipy.sparse.linalg.Tester(package=None)¶

Nose test runner.

Usage: NoseTester(<package>).test()

<package> is package path or module Default for package is None. A value of None finds the calling module path.

This class is made available as numpy.testing.Tester, and a test function is typically added to a package’s __init__.py like so:

>>> from numpy.testing import Tester
>>> test = Tester().test

Calling this test function finds and runs all tests associated with the package and all its subpackages.

bench(label='fast', verbose=1, extra_argv=None)¶

Run benchmarks for module using nose

Parameters:

label : {‘fast’, ‘full’, ‘’, attribute identifer}

Identifies the benchmarks to run. This can be a string to pass to the nosetests executable with the ‘-A’ option, or one of several special values. Special values are:

‘fast’ - the default - which corresponds to nosetests -A option

of ‘not slow’.

‘full’ - fast (as above) and slow benchmarks as in the

no -A option to nosetests - same as ‘’

None or ‘’ - run all benchmarks attribute_identifier - string passed directly to nosetests as ‘-A’

verbose : integer

verbosity value for test outputs, 1-10

extra_argv : list

List with any extra args to pass to nosetests

prepare_test_args(label='fast', verbose=1, extra_argv=None, doctests=False, coverage=False)¶

Run tests for module using nose

%(test_header)s doctests : boolean

If True, run doctests in module, default False

coverage : boolean: If True, report coverage of NumPy code, default False (Requires the coverage module:

http://nedbatchelder.com/code/modules/coverage.html)

test(label='fast', verbose=1, extra_argv=None, doctests=False, coverage=False)¶

Run tests for module using nose

Parameters:

label : {‘fast’, ‘full’, ‘’, attribute identifer}

Identifies the tests to run. This can be a string to pass to the nosetests executable with the ‘-A’ option, or one of several special values. Special values are:

‘fast’ - the default - which corresponds to nosetests -A option

of ‘not slow’.

‘full’ - fast (as above) and slow tests as in the

no -A option to nosetests - same as ‘’

None or ‘’ - run all tests attribute_identifier - string passed directly to nosetests as ‘-A’

verbose : integer

verbosity value for test outputs, 1-10

extra_argv : list

List with any extra args to pass to nosetests

doctests : boolean

If True, run doctests in module, default False

coverage : boolean

If True, report coverage of NumPy code, default False (Requires the coverage module:

http://nedbatchelder.com/code/modules/coverage.html)

scipy.sparse.linalg.aslinearoperator(A)¶

Return A as a LinearOperator.

‘A’ may be any of the following types:

ndarray
matrix
sparse matrix (e.g. csr_matrix, lil_matrix, etc.)
LinearOperator
An object with .shape and .matvec attributes

See the LinearOperator documentation for additonal information.

Examples

>>> from scipy import matrix
>>> M = matrix( [[1,2,3],[4,5,6]], dtype='int32' )
>>> aslinearoperator( M )
<2x3 LinearOperator with dtype=int32>

scipy.sparse.linalg.bicg(A, b, x0=None, tol=1.0000000000000001e-05, maxiter=None, xtype=None, M=None, callback=None)¶

Use BIConjugate Gradient iteration to solve A x = b

Parameters:

A : {sparse matrix, dense matrix, LinearOperator}

The N-by-N matrix of the linear system.

b : {array, matrix}

Right hand side of the linear system. Has shape (N,) or (N,1).

scipy.sparse.linalg.bicgstab(A, b, x0=None, tol=1.0000000000000001e-05, maxiter=None, xtype=None, M=None, callback=None)¶

Use BIConjugate Gradient STABilized iteration to solve A x = b

Parameters:

A : {sparse matrix, dense matrix, LinearOperator}

The N-by-N matrix of the linear system.

b : {array, matrix}

Right hand side of the linear system. Has shape (N,) or (N,1).

scipy.sparse.linalg.cg(A, b, x0=None, tol=1.0000000000000001e-05, maxiter=None, xtype=None, M=None, callback=None)¶

Use Conjugate Gradient iteration to solve A x = b

Parameters:

A : {sparse matrix, dense matrix, LinearOperator}

The N-by-N matrix of the linear system.

b : {array, matrix}

Right hand side of the linear system. Has shape (N,) or (N,1).

scipy.sparse.linalg.cgs(A, b, x0=None, tol=1.0000000000000001e-05, maxiter=None, xtype=None, M=None, callback=None)¶

Use Conjugate Gradient Squared iteration to solve A x = b

Parameters:

A : {sparse matrix, dense matrix, LinearOperator}

The N-by-N matrix of the linear system.

b : {array, matrix}

Right hand side of the linear system. Has shape (N,) or (N,1).

scipy.sparse.linalg.factorized(A)¶

Return a fuction for solving a sparse linear system, with A pre-factorized.

Example:: solve = factorized( A ) # Makes LU decomposition. x1 = solve( rhs1 ) # Uses the LU factors. x2 = solve( rhs2 ) # Uses again the LU factors.

scipy.sparse.linalg.gmres(A, b, x0=None, tol=1.0000000000000001e-05, restrt=20, maxiter=None, xtype=None, M=None, callback=None)¶

Use Generalized Minimal RESidual iteration to solve A x = b

Parameters:

A : {sparse matrix, dense matrix, LinearOperator}

The N-by-N matrix of the linear system.

b : {array, matrix}

Right hand side of the linear system. Has shape (N,) or (N,1).

Sparse linear algebra (`scipy.sparse.linalg`)¶