Ë
    ßÌPh2  ã                   ó°   — d dl mZ  eddd«        eddd«        eddd«        eddd«        eddd«        eddd	«        eddd
«        eddd«       y)é    )Ú
add_newdocz$scipy.sparse.linalg._dsolve._superluÚSuperLUa¦  
    LU factorization of a sparse matrix.

    Factorization is represented as::

        Pr @ A @ Pc = L @ U

    To construct these `SuperLU` objects, call the `splu` and `spilu`
    functions.

    Attributes
    ----------
    shape
    nnz
    perm_c
    perm_r
    L
    U

    Methods
    -------
    solve

    Notes
    -----

    .. versionadded:: 0.14.0

    Examples
    --------
    The LU decomposition can be used to solve matrix equations. Consider:

    >>> import numpy as np
    >>> from scipy.sparse import csc_array
    >>> from scipy.sparse.linalg import splu
    >>> A = csc_array([[1,2,0,4], [1,0,0,1], [1,0,2,1], [2,2,1,0.]])

    This can be solved for a given right-hand side:

    >>> lu = splu(A)
    >>> b = np.array([1, 2, 3, 4])
    >>> x = lu.solve(b)
    >>> A.dot(x)
    array([ 1.,  2.,  3.,  4.])

    The ``lu`` object also contains an explicit representation of the
    decomposition. The permutations are represented as mappings of
    indices:

    >>> lu.perm_r
    array([2, 1, 3, 0], dtype=int32)  # may vary
    >>> lu.perm_c
    array([0, 1, 3, 2], dtype=int32)  # may vary

    The L and U factors are sparse matrices in CSC format:

    >>> lu.L.toarray()
    array([[ 1. ,  0. ,  0. ,  0. ],  # may vary
           [ 0.5,  1. ,  0. ,  0. ],
           [ 0.5, -1. ,  1. ,  0. ],
           [ 0.5,  1. ,  0. ,  1. ]])
    >>> lu.U.toarray()
    array([[ 2. ,  2. ,  0. ,  1. ],  # may vary
           [ 0. , -1. ,  1. , -0.5],
           [ 0. ,  0. ,  5. , -1. ],
           [ 0. ,  0. ,  0. ,  2. ]])

    The permutation matrices can be constructed:

    >>> Pr = csc_array((np.ones(4), (lu.perm_r, np.arange(4))))
    >>> Pc = csc_array((np.ones(4), (np.arange(4), lu.perm_c)))

    We can reassemble the original matrix:

    >>> (Pr.T @ (lu.L @ lu.U) @ Pc.T).toarray()
    array([[ 1.,  2.,  0.,  4.],
           [ 1.,  0.,  0.,  1.],
           [ 1.,  0.,  2.,  1.],
           [ 2.,  2.,  1.,  0.]])
    )Úsolvea'  
    solve(rhs[, trans])

    Solves linear system of equations with one or several right-hand sides.

    Parameters
    ----------
    rhs : ndarray, shape (n,) or (n, k)
        Right hand side(s) of equation
    trans : {'N', 'T', 'H'}, optional
        Type of system to solve::

            'N':   A   @ x == rhs  (default)
            'T':   A^T @ x == rhs
            'H':   A^H @ x == rhs

        i.e., normal, transposed, and hermitian conjugate.

    Returns
    -------
    x : ndarray, shape ``rhs.shape``
        Solution vector(s)
    )ÚLzu
    Lower triangular factor with unit diagonal as a
    `scipy.sparse.csc_array`.

    .. versionadded:: 0.14.0
    )ÚUz^
    Upper triangular factor as a `scipy.sparse.csc_array`.

    .. versionadded:: 0.14.0
    )Úshapez:
    Shape of the original matrix as a tuple of ints.
    )Únnzz3
    Number of nonzero elements in the matrix.
    )Úperm_czj
    Permutation Pc represented as an array of indices.

    See the `SuperLU` docstring for details.
    )Úperm_rzj
    Permutation Pr represented as an array of indices.

    See the `SuperLU` docstring for details.
    N)Ú	numpy.libr   © ó    úsC:\Users\daisl\Desktop\realtime-object-detection\venv\Lib\site-packages\scipy/sparse/linalg/_dsolve/_add_newdocs.pyÚ<module>r      s©   ðÝ  á 
Ð1°9ðOôP	ñd Ð1°9ð ?	ô 
ñ2 Ð1°9ð ?	ô 
ñ Ð1°9ð ?	ô 
ñ Ð1°9ð ?	ô 
ñ
 Ð1°9ð ?	ô 
ñ
 Ð1°9ð ?	ô 
ñ Ð1°9ð ?	õ 
r   