`scipy.linalg._basic:inv`

source: /scipy/linalg/_basic.py:984

Signature

def inv(a, overwrite_a = False, check_finite = True, *, assume_a = None, lower = False)

Summary

Compute the inverse of a matrix.

Extended Summary

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 linalg_batch 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 tutorial_linalg_overwrite 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 :math:`2\times 2` matrices. See :ref:`linalg_batch` 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.  ],
        [3.  , 0.25]]])

Aliases

scipy.linalg.inv