`scipy.sparse.linalg._dsolve.linsolve:splu`

source: /scipy/sparse/linalg/_dsolve/linsolve.py :329

Signature

   def     splu (    A    ,    permc_spec    =  None   ,    diag_pivot_thresh    =  None   ,    relax    =  None   ,    panel_size    =  None   ,    options    =  None     )

Summary

Compute the LU decomposition of a sparse, square matrix.

Parameters

A : sparse array or matrix

Sparse array to factorize. Most efficient when provided in CSC format. Other formats will be converted to CSC before factorization.

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.

Returns

invA : scipy.sparse.linalg.SuperLU: Object, which has a solve method.

Notes

When a real array is factorized and the returned SuperLU object's solve() method is used with complex arguments an error is generated. Instead, cast the initial array to complex and then factorize.

This function uses the SuperLU library.

Examples

import numpy as np
from scipy.sparse import csc_array
from scipy.sparse.linalg import splu
A = csc_array([[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)

✓

A.dot(B.solve(x))
B.solve(A.dot(x))

✗

Aliases

scipy.integrate._bvp.splu