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

# inv

scipy.linalg.inv(a, overwrite_a=False, check_finite=True, *, assume_a=None, lower=False)

  Compute the inverse of a matrix.

  If the data matrix is known to be a particular type then supplying the corresponding string to `assume_a` key chooses the dedicated solver. The available options are

  general | ‘general’ (or ‘gen’)
  diagonal | ‘diagonal’
  upper triangular | ‘upper triangular’
  lower triangular | ‘lower triangular’
  symmetric positive definite | ‘pos’
  symmetric | ‘sym’
  Hermitian | ‘her’

  For the ‘pos’ option, only the triangle of the input matrix specified in the lower argument is used, and the other triangle is not referenced. Likewise, an explicit assume_a=’diagonal’ means that off-diagonal elements are not referenced.

  The a array argument 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:
    a array_like, shape (…, M, M)

      Square matrix (or a batch of matrices) to be inverted.

    overwrite_a bool, optional

      Discard data in a (may improve performance). Default is False. See overwrite_* arguments for details.

    check_finite bool, optional

      Whether to check that the input matrix contains 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.

    assume_a str, optional

      Valid entries are described above. If omitted or `None`, checks are performed to identify structure so the appropriate solver can be called.

    lower bool, optional

      Ignored unless assume_a is one of ‘sym’, ‘her’, or ‘pos’. If True, the calculation uses only the data in the lower triangle of a; entries above the diagonal are ignored. If False (default), the calculation uses only the data in the upper triangle of a; entries below the diagonal are ignored.

  Returns:
    ainv ndarray

      Inverse of the matrix a.

  Raises:
    LinAlgError

      If a is singular.

    ValueError

      If a is not square, or not 2D.

  Notes

  This routine checks the condition number of the a matrix and emits a `LinAlgWarning` for ill-conditioned inputs.

  Examples

      >>> import numpy as np
      >>> from scipy import linalg
      >>> a = np.array([[1., 2.], [3., 4.]])
      >>> linalg.inv(a)
      array([[-2. ,  1. ],
             [ 1.5, -0.5]])
      >>> a @ linalg.inv(a)
      array([[ 1.,  0.],
             [ 0.,  1.]])

  The input array `a` may represent a single matrix or a collection (a.k.a. a “batch”) of square matrices. For example, if `a.shape == (4, 3, 2, 2)`, it is interpreted as a `(4, 3)`-shaped batch of \(2\times 2\) matrices. See Batched Linear Operations for further details. To illustrate:

      >>> a = np.stack((np.eye(2), [[1, 2], [3, 4]]))
      >>> linalg.inv(a)
      array([[[ 1. ,  0. ],
              [ 0. ,  1. ]],
             [[-2. ,  1. ],
              [ 1.5, -0.5]]])

  Note that the structure detection runs per-slice: in the example above, each of the two slices will be independently discovered as being diagonal. Setting an explicit `assume_a` argument will bypass structure detection and use the provided value without checking:

      >>> a = np.stack((np.eye(2), [[1, 2], [3, 4]]))
      >>> linalg.inv(a, assume_a="diagonal")
      array([[[1.  , 0.  ],
              [0.  , 1.  ]],
             [[1.  , 2.  ],   # off-diagonal elements are incorrect
              [3.  , 0.25]]])