Numpy mat I 求非奇异矩阵的逆矩阵

a = np.mat([[1,0,3],
           [2,3,4],
           [1,4,6]])

# 相关知识
#   奇异矩阵
#   非奇异矩阵
#   求逆 np.linalg.inv
#   求伪逆 np.linalg.pinv

b = a.I
c = np.linalg.inv(a)
print("a",a)
print("b",b)
print("c",c)

a [[1 0 3]
 [2 3 4]
 [1 4 6]]
b [[ 0.11764706  0.70588235 -0.52941176]
 [-0.47058824  0.17647059  0.11764706]
 [ 0.29411765 -0.23529412  0.17647059]]
c [[ 0.11764706  0.70588235 -0.52941176]
 [-0.47058824  0.17647059  0.11764706]
 [ 0.29411765 -0.23529412  0.17647059]]

doc = '''
 |  I
 |      Returns the (multiplicative) inverse of invertible `self`.
 |      
 |      Parameters
 |      ----------
 |      None
 |      
 |      Returns
 |      -------
 |      ret : matrix object
 |          If `self` is non-singular, `ret` is such that ``ret * self`` ==
 |          ``self * ret`` == ``np.matrix(np.eye(self[0,:].size))`` all return
 |          ``True``.
 |      
 |      Raises
 |      ------
 |      numpy.linalg.LinAlgError: Singular matrix
 |          If `self` is singular.
 |      
 |      See Also
 |      --------
 |      linalg.inv
 |      
 |      Examples
 |      --------
 |      >>> m = np.matrix('[1, 2; 3, 4]'); m
 |      matrix([[1, 2],
 |              [3, 4]])
 |      >>> m.getI()
 |      matrix([[-2. ,  1. ],
 |              [ 1.5, -0.5]])
 |      >>> m.getI() * m
 |      matrix([[ 1.,  0.], # may vary
 |              [ 0.,  1.]])
'''

help(np.linalg.inv)  # 求逆

Help on function inv in module numpy.linalg:

inv(a)
    Compute the (multiplicative) inverse of a matrix.
    
    Given a square matrix `a`, return the matrix `ainv` satisfying
    ``dot(a, ainv) = dot(ainv, a) = eye(a.shape[0])``.
    
    Parameters
    ----------
    a : (..., M, M) array_like
        Matrix to be inverted.
    
    Returns
    -------
    ainv : (..., M, M) ndarray or matrix
        (Multiplicative) inverse of the matrix `a`.
    
    Raises
    ------
    LinAlgError
        If `a` is not square or inversion fails.
    
    See Also
    --------
    scipy.linalg.inv : Similar function in SciPy.
    
    Notes
    -----
    
    .. versionadded:: 1.8.0
    
    Broadcasting rules apply, see the `numpy.linalg` documentation for
    details.
    
    Examples
    --------
    >>> from numpy.linalg import inv
    >>> a = np.array([[1., 2.], [3., 4.]])
    >>> ainv = inv(a)
    >>> np.allclose(np.dot(a, ainv), np.eye(2))
    True
    >>> np.allclose(np.dot(ainv, a), np.eye(2))
    True
    
    If a is a matrix object, then the return value is a matrix as well:
    
    >>> ainv = inv(np.matrix(a))
    >>> ainv
    matrix([[-2. ,  1. ],
            [ 1.5, -0.5]])
    
    Inverses of several matrices can be computed at once:
    
    >>> a = np.array([[[1., 2.], [3., 4.]], [[1, 3], [3, 5]]])
    >>> inv(a)
    array([[[-2.  ,  1.  ],
            [ 1.5 , -0.5 ]],
           [[-1.25,  0.75],
            [ 0.75, -0.25]]])

help(np.linalg.pinv)  # 求伪逆

Help on function pinv in module numpy.linalg:

pinv(a, rcond=1e-15, hermitian=False)
    Compute the (Moore-Penrose) pseudo-inverse of a matrix.
    
    Calculate the generalized inverse of a matrix using its
    singular-value decomposition (SVD) and including all
    *large* singular values.
    
    .. versionchanged:: 1.14
       Can now operate on stacks of matrices
    
    Parameters
    ----------
    a : (..., M, N) array_like
        Matrix or stack of matrices to be pseudo-inverted.
    rcond : (...) array_like of float
        Cutoff for small singular values.
        Singular values less than or equal to
        ``rcond * largest_singular_value`` are set to zero.
        Broadcasts against the stack of matrices.
    hermitian : bool, optional
        If True, `a` is assumed to be Hermitian (symmetric if real-valued),
        enabling a more efficient method for finding singular values.
        Defaults to False.
    
        .. versionadded:: 1.17.0
    
    Returns
    -------
    B : (..., N, M) ndarray
        The pseudo-inverse of `a`. If `a` is a `matrix` instance, then so
        is `B`.
    
    Raises
    ------
    LinAlgError
        If the SVD computation does not converge.
    
    See Also
    --------
    scipy.linalg.pinv : Similar function in SciPy.
    scipy.linalg.pinv2 : Similar function in SciPy (SVD-based).
    scipy.linalg.pinvh : Compute the (Moore-Penrose) pseudo-inverse of a
                         Hermitian matrix.
    
    Notes
    -----
    The pseudo-inverse of a matrix A, denoted :math:`A^+`, is
    defined as: "the matrix that 'solves' [the least-squares problem]
    :math:`Ax = b`," i.e., if :math:`\bar{x}` is said solution, then
    :math:`A^+` is that matrix such that :math:`\bar{x} = A^+b`.
    
    It can be shown that if :math:`Q_1 \Sigma Q_2^T = A` is the singular
    value decomposition of A, then
    :math:`A^+ = Q_2 \Sigma^+ Q_1^T`, where :math:`Q_{1,2}` are
    orthogonal matrices, :math:`\Sigma` is a diagonal matrix consisting
    of A's so-called singular values, (followed, typically, by
    zeros), and then :math:`\Sigma^+` is simply the diagonal matrix
    consisting of the reciprocals of A's singular values
    (again, followed by zeros). [1]_
    
    References
    ----------
    .. [1] G. Strang, *Linear Algebra and Its Applications*, 2nd Ed., Orlando,
           FL, Academic Press, Inc., 1980, pp. 139-142.
    
    Examples
    --------
    The following example checks that ``a * a+ * a == a`` and
    ``a+ * a * a+ == a+``:
    
    >>> a = np.random.randn(9, 6)
    >>> B = np.linalg.pinv(a)
    >>> np.allclose(a, np.dot(a, np.dot(B, a)))
    True
    >>> np.allclose(B, np.dot(B, np.dot(a, B)))
    True