scipy.linalg.

solve_banded#

scipy.linalg.solve_banded(l_and_u, ab, b, overwrite_ab=False, overwrite_b=False, check_finite=True)[source]#

Solve the equation a @ x = b for x, where a is the banded matrix defined by ab.

The matrix a is stored in ab using the matrix diagonal ordered form:

ab[u + i - j, j] == a[i,j]

Example of ab (shape of a is (6,6), u =1, l =2):

*    a01  a12  a23  a34  a45
a00  a11  a22  a33  a44  a55
a10  a21  a32  a43  a54   *
a20  a31  a42  a53   *    *

The documentation is written assuming array arguments are of specified “core” shapes. However, array argument(s) of this function may have additional “batch” dimensions prepended to the core shape. In this case, the array is treated as a batch of lower-dimensional slices; see Batched Linear Operations for details.

Parameters:

(l, u)(integer, integer): Number of non-zero lower and upper diagonals
ab(l + u + 1, M) array_like: Banded matrix
b(M,) or (M, K) array_like: Right-hand side
overwrite_abbool, optional: Discard data in ab (may enhance performance)
overwrite_bbool, optional: Discard data in b (may enhance performance)
check_finitebool, optional: Whether to check that the input matrices contain only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs.

Returns:

x(M,) or (M, K) ndarray: The solution to the system a x = b. Returned shape depends on the shape of b.

Examples

Solve the banded system a x = b, where:

    [5  2 -1  0  0]       [0]
    [1  4  2 -1  0]       [1]
a = [0  1  3  2 -1]   b = [2]
    [0  0  1  2  2]       [2]
    [0  0  0  1  1]       [3]

There is one nonzero diagonal below the main diagonal (l = 1), and two above (u = 2). The diagonal banded form of the matrix is:

     [*  * -1 -1 -1]
ab = [*  2  2  2  2]
     [5  4  3  2  1]
     [1  1  1  1  *]

>>> import numpy as np
>>> from scipy.linalg import solve_banded
>>> ab = np.array([[0,  0, -1, -1, -1],
...                [0,  2,  2,  2,  2],
...                [5,  4,  3,  2,  1],
...                [1,  1,  1,  1,  0]])
>>> b = np.array([0, 1, 2, 2, 3])
>>> x = solve_banded((1, 2), ab, b)
>>> x
array([-2.37288136,  3.93220339, -4.        ,  4.3559322 , -1.3559322 ])