sparse.linalg.dsolve.linsolve

Module Contents

Functions

use_solver(**kwargs) Select default sparse direct solver to be used.
_get_umf_family(A) Get umfpack family string given the sparse matrix dtype.
spsolve(A,b,permc_spec=None,use_umfpack=True) Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
splu(A,permc_spec=None,diag_pivot_thresh=None,relax=None,panel_size=None,options=dict) Compute the LU decomposition of a sparse, square matrix.
spilu(A,drop_tol=None,fill_factor=None,drop_rule=None,permc_spec=None,diag_pivot_thresh=None,relax=None,panel_size=None,options=None) Compute an incomplete LU decomposition for a sparse, square matrix.
factorized(A) Return a function for solving a sparse linear system, with A pre-factorized.
spsolve_triangular(A,b,lower=True,overwrite_A=False,overwrite_b=False) Solve the equation A x = b for x, assuming A is a triangular matrix.
class MatrixRankWarning
use_solver(**kwargs)

Select default sparse direct solver to be used.

useUmfpack : bool, optional
Use UMFPACK over SuperLU. Has effect only if scikits.umfpack is installed. Default: True
assumeSortedIndices : bool, optional
Allow UMFPACK to skip the step of sorting indices for a CSR/CSC matrix. Has effect only if useUmfpack is True and scikits.umfpack is installed. Default: False

The default sparse solver is umfpack when available (scikits.umfpack is installed). This can be changed by passing useUmfpack = False, which then causes the always present SuperLU based solver to be used.

Umfpack requires a CSR/CSC matrix to have sorted column/row indices. If sure that the matrix fulfills this, pass assumeSortedIndices=True to gain some speed.

_get_umf_family(A)

Get umfpack family string given the sparse matrix dtype.

spsolve(A, b, permc_spec=None, use_umfpack=True)

Solve the sparse linear system Ax=b, where b may be a vector or a matrix.

A : ndarray or sparse matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse matrix
The matrix or vector representing the right hand side of the equation. If a vector, b.shape must be (n,) or (n, 1).
permc_spec : str, optional

How to permute the columns of the matrix for sparsity preservation. (default: ‘COLAMD’)

  • NATURAL: natural ordering.
  • MMD_ATA: minimum degree ordering on the structure of A^T A.
  • MMD_AT_PLUS_A: minimum degree ordering on the structure of A^T+A.
  • COLAMD: approximate minimum degree column ordering
use_umfpack : bool, optional
if True (default) then use umfpack for the solution. This is only referenced if b is a vector and scikit-umfpack is installed.
x : ndarray or sparse matrix
the solution of the sparse linear equation. If b is a vector, then x is a vector of size A.shape[1] If b is a matrix, then x is a matrix of size (A.shape[1], b.shape[1])

For solving the matrix expression AX = B, this solver assumes the resulting matrix X is sparse, as is often the case for very sparse inputs. If the resulting X is dense, the construction of this sparse result will be relatively expensive. In that case, consider converting A to a dense matrix and using scipy.linalg.solve or its variants.

>>> from scipy.sparse import csc_matrix
>>> from scipy.sparse.linalg import spsolve
>>> A = csc_matrix([[3, 2, 0], [1, -1, 0], [0, 5, 1]], dtype=float)
>>> B = csc_matrix([[2, 0], [-1, 0], [2, 0]], dtype=float)
>>> x = spsolve(A, B)
>>> np.allclose(A.dot(x).todense(), B.todense())
True
splu(A, permc_spec=None, diag_pivot_thresh=None, relax=None, panel_size=None, options=dict)

Compute the LU decomposition of a sparse, square matrix.

A : sparse matrix
Sparse matrix to factorize. Should be in CSR or CSC format.
permc_spec : str, optional

How to permute the columns of the matrix for sparsity preservation. (default: ‘COLAMD’)

  • NATURAL: natural ordering.
  • MMD_ATA: minimum degree ordering on the structure of A^T A.
  • MMD_AT_PLUS_A: minimum degree ordering on the structure of A^T+A.
  • COLAMD: approximate minimum degree column ordering
diag_pivot_thresh : float, optional
Threshold used for a diagonal entry to be an acceptable pivot. See SuperLU user’s guide for details [1]
relax : int, optional
Expert option for customizing the degree of relaxing supernodes. See SuperLU user’s guide for details [1]
panel_size : int, optional
Expert option for customizing the panel size. See SuperLU user’s guide for details [1]
options : dict, optional
Dictionary containing additional expert options to SuperLU. See SuperLU user guide [1] (section 2.4 on the ‘Options’ argument) for more details. For example, you can specify options=dict(Equil=False, IterRefine='SINGLE')) to turn equilibration off and perform a single iterative refinement.
invA : scipy.sparse.linalg.SuperLU
Object, which has a solve method.

spilu : incomplete LU decomposition

This function uses the SuperLU library.

[1](1, 2, 3, 4) SuperLU http://crd.lbl.gov/~xiaoye/SuperLU/
>>> from scipy.sparse import csc_matrix
>>> from scipy.sparse.linalg import splu
>>> A = csc_matrix([[1., 0., 0.], [5., 0., 2.], [0., -1., 0.]], dtype=float)
>>> B = splu(A)
>>> x = np.array([1., 2., 3.], dtype=float)
>>> B.solve(x)
array([ 1. , -3. , -1.5])
>>> A.dot(B.solve(x))
array([ 1.,  2.,  3.])
>>> B.solve(A.dot(x))
array([ 1.,  2.,  3.])
spilu(A, drop_tol=None, fill_factor=None, drop_rule=None, permc_spec=None, diag_pivot_thresh=None, relax=None, panel_size=None, options=None)

Compute an incomplete LU decomposition for a sparse, square matrix.

The resulting object is an approximation to the inverse of A.

A : (N, N) array_like
Sparse matrix to factorize
drop_tol : float, optional
Drop tolerance (0 <= tol <= 1) for an incomplete LU decomposition. (default: 1e-4)
fill_factor : float, optional
Specifies the fill ratio upper bound (>= 1.0) for ILU. (default: 10)
drop_rule : str, optional

Comma-separated string of drop rules to use. Available rules: basic, prows, column, area, secondary, dynamic, interp. (Default: basic,area)

See SuperLU documentation for details.

Remaining other options
Same as for splu
invA_approx : scipy.sparse.linalg.SuperLU
Object, which has a solve method.

splu : complete LU decomposition

To improve the better approximation to the inverse, you may need to increase fill_factor AND decrease drop_tol.

This function uses the SuperLU library.

>>> from scipy.sparse import csc_matrix
>>> from scipy.sparse.linalg import spilu
>>> A = csc_matrix([[1., 0., 0.], [5., 0., 2.], [0., -1., 0.]], dtype=float)
>>> B = spilu(A)
>>> x = np.array([1., 2., 3.], dtype=float)
>>> B.solve(x)
array([ 1. , -3. , -1.5])
>>> A.dot(B.solve(x))
array([ 1.,  2.,  3.])
>>> B.solve(A.dot(x))
array([ 1.,  2.,  3.])
factorized(A)

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

A : (N, N) array_like
Input.
solve : callable
To solve the linear system of equations given in A, the solve callable should be passed an ndarray of shape (N,).
>>> from scipy.sparse.linalg import factorized
>>> A = np.array([[ 3. ,  2. , -1. ],
...               [ 2. , -2. ,  4. ],
...               [-1. ,  0.5, -1. ]])
>>> solve = factorized(A) # Makes LU decomposition.
>>> rhs1 = np.array([1, -2, 0])
>>> solve(rhs1) # Uses the LU factors.
array([ 1., -2., -2.])
spsolve_triangular(A, b, lower=True, overwrite_A=False, overwrite_b=False)

Solve the equation A x = b for x, assuming A is a triangular matrix.

A : (M, M) sparse matrix
A sparse square triangular matrix. Should be in CSR format.
b : (M,) or (M, N) array_like
Right-hand side matrix in A x = b
lower : bool, optional
Whether A is a lower or upper triangular matrix. Default is lower triangular matrix.
overwrite_A : bool, optional
Allow changing A. The indices of A are going to be sorted and zero entries are going to be removed. Enabling gives a performance gain. Default is False.
overwrite_b : bool, optional
Allow overwriting data in b. Enabling gives a performance gain. Default is False. If overwrite_b is True, it should be ensured that b has an appropriate dtype to be able to store the result.
x : (M,) or (M, N) ndarray
Solution to the system A x = b. Shape of return matches shape of b.
LinAlgError
If A is singular or not triangular.
ValueError
If shape of A or shape of b do not match the requirements.

New in version 0.19.0.

>>> from scipy.sparse import csr_matrix
>>> from scipy.sparse.linalg import spsolve_triangular
>>> A = csr_matrix([[3, 0, 0], [1, -1, 0], [2, 0, 1]], dtype=float)
>>> B = np.array([[2, 0], [-1, 0], [2, 0]], dtype=float)
>>> x = spsolve_triangular(A, B)
>>> np.allclose(A.dot(x), B)
True