Skip to main content
`Ctrl`+`K`
scipy.linalg.

# solve_banded

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

  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_ab bool, optional

      Discard data in ab (may enhance performance)

    overwrite_b bool, optional

      Discard data in b (may enhance performance)

    check_finite bool, 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 ])