Ë
    âQ(h�2  ã                   ó<  — d Z ddlmZ ddlmZmZ ddlZddlmZ ddl	m
Z
mZ ddlmZ dd	lmZ ej                   d
   D � �ci c]6  } | dj#                  dD �cg c]  } ej$                  | |«      sŒ|‘Œ c}«      “Œ8 c}} Zg d¢Zdd„Zdd„Z	 	 dd„Zyc c}w c c}} w )zLU decomposition functions.é    )Úwarn)ÚasarrayÚasarray_chkfiniteN)Úproducté   )Ú_datacopiedÚLinAlgWarning)Úget_lapack_funcs)Úlu_dispatcherÚAllÚ ÚfdFD)ÚluÚlu_solveÚ	lu_factorc                 óŒ  — |rt        | «      }nt        | «      }|j                  dk(  r>t        j                  |«      }t        j
                  dt        j                  ¬«      }||fS |xs t        || «      }t        d|f«      \  } |||¬«      \  }}}|dk  rt        d| z  «      ‚|dkD  rt        d|z  t        d¬«       ||fS )	al
  
    Compute pivoted LU decomposition of a matrix.

    The decomposition is::

        A = P L U

    where P is a permutation matrix, L lower triangular with unit
    diagonal elements, and U upper triangular.

    Parameters
    ----------
    a : (M, N) array_like
        Matrix to decompose
    overwrite_a : bool, optional
        Whether to overwrite data in A (may increase performance)
    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.

    Returns
    -------
    lu : (M, N) ndarray
        Matrix containing U in its upper triangle, and L in its lower triangle.
        The unit diagonal elements of L are not stored.
    piv : (K,) ndarray
        Pivot indices representing the permutation matrix P:
        row i of matrix was interchanged with row piv[i].
        Of shape ``(K,)``, with ``K = min(M, N)``.

    See Also
    --------
    lu : gives lu factorization in more user-friendly format
    lu_solve : solve an equation system using the LU factorization of a matrix

    Notes
    -----
    This is a wrapper to the ``*GETRF`` routines from LAPACK. Unlike
    :func:`lu`, it outputs the L and U factors into a single array
    and returns pivot indices instead of a permutation matrix.

    While the underlying ``*GETRF`` routines return 1-based pivot indices, the
    ``piv`` array returned by ``lu_factor`` contains 0-based indices.

    Examples
    --------
    >>> import numpy as np
    >>> from scipy.linalg import lu_factor
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> lu, piv = lu_factor(A)
    >>> piv
    array([2, 2, 3, 3], dtype=int32)

    Convert LAPACK's ``piv`` array to NumPy index and test the permutation

    >>> def pivot_to_permutation(piv):
    ...     perm = np.arange(len(piv))
    ...     for i in range(len(piv)):
    ...         perm[i], perm[piv[i]] = perm[piv[i]], perm[i]
    ...     return perm
    ...
    >>> p_inv = pivot_to_permutation(piv)
    >>> p_inv
    array([2, 0, 3, 1])
    >>> L, U = np.tril(lu, k=-1) + np.eye(4), np.triu(lu)
    >>> np.allclose(A[p_inv] - L @ U, np.zeros((4, 4)))
    True

    The P matrix in P L U is defined by the inverse permutation and
    can be recovered using argsort:

    >>> p = np.argsort(p_inv)
    >>> p
    array([1, 3, 0, 2])
    >>> np.allclose(A - L[p] @ U, np.zeros((4, 4)))
    True

    or alternatively:

    >>> P = np.eye(4)[p]
    >>> np.allclose(A - P @ L @ U, np.zeros((4, 4)))
    True
    r   ©Údtype)Úgetrf)Úoverwrite_az<illegal value in %dth argument of internal getrf (lu_factor)z4Diagonal number %d is exactly zero. Singular matrix.é   )Ú
stacklevel)r   r   ÚsizeÚnpÚ
empty_likeÚarangeÚint32r   r
   Ú
ValueErrorr   r	   )Úar   Úcheck_finiteÚa1r   Úpivr   Úinfos           úU/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/scipy/linalg/_decomp_lu.pyr   r      sÎ   € ñj Ü˜qÓ!‰ä�Q‹Zˆð 
‡w�w�!‚|Ü�]‰]˜2ÓˆÜ�i‰i˜¤§¡Ô*ˆØ�3ˆwˆàÒ5¤+¨b°!Ó"4€Kä˜j¨2¨%Ó0�F€EÙ˜"¨+Ô6�M€BˆˆTØˆa‚xÜð 6Ø9=¸ñ>ó ?ð 	?àˆa‚xÜÐCÀdÑJÜ qõ	*àˆsˆ7€Nó    c                 óP  — | \  }}|rt        |«      }nt        |«      }|xs t        ||«      }|j                  d   |j                  d   k7  r&t	        d|j                  › d|j                  › d�«      ‚|j
                  dk(  rot        t        j                  d|j                  ¬«      ddgft        j                  d|j                  ¬«      «      }t        j                  ||j                  ¬«      S t        d||f«      \  }	 |	|||||¬	«      \  }
}|dk(  r|
S t	        d
| z  «      ‚)aU  Solve an equation system, a x = b, given the LU factorization of a

    Parameters
    ----------
    (lu, piv)
        Factorization of the coefficient matrix a, as given by lu_factor.
        In particular piv are 0-indexed pivot indices.
    b : array
        Right-hand side
    trans : {0, 1, 2}, optional
        Type of system to solve:

        =====  =========
        trans  system
        =====  =========
        0      a x   = b
        1      a^T x = b
        2      a^H x = b
        =====  =========
    overwrite_b : bool, optional
        Whether to overwrite data in b (may increase 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 : array
        Solution to the system

    See Also
    --------
    lu_factor : LU factorize a matrix

    Examples
    --------
    >>> import numpy as np
    >>> from scipy.linalg import lu_factor, lu_solve
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> b = np.array([1, 1, 1, 1])
    >>> lu, piv = lu_factor(A)
    >>> x = lu_solve((lu, piv), b)
    >>> np.allclose(A @ x - b, np.zeros((4,)))
    True

    r   zShapes of lu z and b z are incompatibler   r   r   )Úgetrs)ÚtransÚoverwrite_bz4illegal value in %dth argument of internal gesv|posv)r   r   r   Úshaper   r   r   r   Úeyer   Úonesr   r
   )Ú
lu_and_pivÚbr(   r)   r    r   r"   Úb1Úmr'   Úxr#   s               r$   r   r   �   s  € ð` �I€RˆÙÜ˜qÓ!‰ä�Q‹ZˆàÒ3¤¨R°Ó!3€Kà	‡x�x��{�b—h‘h˜q‘kÒ!Ü˜=¨¯©¨
°'¸"¿(¹(¸ÐCTÐUÓVÐVð 
‡w�w�!‚|Ü”b—f‘f˜Q b§h¡hÔ/°!°Q°Ð8¼"¿'¹'À!È1Ï7É7Ô:SÓTˆÜ�}‰}˜R q§w¡wÔ/Ð/ä˜j¨2¨r¨(Ó3�F€EÙ�B˜˜R u¸+ÔF�G€A€tØˆq‚yØˆÜ
ÐKØ�uñó ð r%   c                 ó>
  — |rt        j                  | «      nt        j                  | «      }|j                  dk  rt	        d«      ‚|j
                  j                  dvrNt        |j
                  j                     }|st        d|j
                  › d�«      ‚|j                  |d   «      }d}|j                  �^ }}}	t        ||	«      }
|j
                  j                  dv rd	nd
}t        |j                  Ž dk(  rï|rRt        j                  g |¢|‘|
‘|j
                  ¬«      }t        j                  g |¢|
‘|	‘|j
                  ¬«      }||fS |r)t        j                  g |¢d‘t         j                  ¬«      nt        j                  g |¢d‘d‘|¬«      }t        j                  g |¢|‘|
‘|j
                  ¬«      }t        j                  g |¢|
‘|	‘|j
                  ¬«      }|||fS |j                  dd dk(  r�|r*t        j                  |«      |r|fS |j                  «       fS |rt        j                   g |¢|‘t"        ¬«      nt        j                  |«      }|t        j                  |«      |r|fS |j                  «       fS t%        || «      s|s|j                  d¬«      }|j&                  d   r|j&                  d   s|j                  d¬«      }|skt        j                  |t         j                  ¬«      }t        j                   |
|
g|j
                  ¬«      }t)        ||||«       ||	kD  r|||fn|||f\  }}}�nt        j                  g |¢|‘t         j                  ¬«      }||	kD  rrt        j                   g |¢|
‘|
‘|j
                  ¬«      }t+        |j                  dd D �cg c]  }t-        |«      ‘Œ c}Ž D ]  }t)        ||   ||   ||   |«       Œ |}nqt        j                   g |¢|
‘|
‘|j
                  ¬«      }t+        |j                  dd D �cg c]  }t-        |«      ‘Œ c}Ž D ]  }t)        ||   ||   ||   |«       Œ |}|s­|s«|rtt        j                   g |¢|‘|‘|¬«      }t        j.                  |D �cg c]  }t        j0                  |«      ‘Œ c}t        j0                  |«      gz   Ž }d|g |¢|‘­<   |}n5t        j                   ||g|¬«      }d|t        j0                  |«      |f<   |}|r||fS |||fS c c}w c c}w c c}w )ar  
    Compute LU decomposition of a matrix with partial pivoting.

    The decomposition satisfies::

        A = P @ L @ U

    where ``P`` is a permutation matrix, ``L`` lower triangular with unit
    diagonal elements, and ``U`` upper triangular. If `permute_l` is set to
    ``True`` then ``L`` is returned already permuted and hence satisfying
    ``A = L @ U``.

    Parameters
    ----------
    a : (M, N) array_like
        Array to decompose
    permute_l : bool, optional
        Perform the multiplication P*L (Default: do not permute)
    overwrite_a : bool, optional
        Whether to overwrite data in a (may improve performance)
    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.
    p_indices : bool, optional
        If ``True`` the permutation information is returned as row indices.
        The default is ``False`` for backwards-compatibility reasons.

    Returns
    -------
    **(If `permute_l` is ``False``)**

    p : (..., M, M) ndarray
        Permutation arrays or vectors depending on `p_indices`
    l : (..., M, K) ndarray
        Lower triangular or trapezoidal array with unit diagonal.
        ``K = min(M, N)``
    u : (..., K, N) ndarray
        Upper triangular or trapezoidal array

    **(If `permute_l` is ``True``)**

    pl : (..., M, K) ndarray
        Permuted L matrix.
        ``K = min(M, N)``
    u : (..., K, N) ndarray
        Upper triangular or trapezoidal array

    Notes
    -----
    Permutation matrices are costly since they are nothing but row reorder of
    ``L`` and hence indices are strongly recommended to be used instead if the
    permutation is required. The relation in the 2D case then becomes simply
    ``A = L[P, :] @ U``. In higher dimensions, it is better to use `permute_l`
    to avoid complicated indexing tricks.

    In 2D case, if one has the indices however, for some reason, the
    permutation matrix is still needed then it can be constructed by
    ``np.eye(M)[P, :]``.

    Examples
    --------

    >>> import numpy as np
    >>> from scipy.linalg import lu
    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
    >>> p, l, u = lu(A)
    >>> np.allclose(A, p @ l @ u)
    True
    >>> p  # Permutation matrix
    array([[0., 1., 0., 0.],  # Row index 1
           [0., 0., 0., 1.],  # Row index 3
           [1., 0., 0., 0.],  # Row index 0
           [0., 0., 1., 0.]]) # Row index 2
    >>> p, _, _ = lu(A, p_indices=True)
    >>> p
    array([1, 3, 0, 2], dtype=int32)  # as given by row indices above
    >>> np.allclose(A, l[p, :] @ u)
    True

    We can also use nd-arrays, for example, a demonstration with 4D array:

    >>> rng = np.random.default_rng()
    >>> A = rng.uniform(low=-4, high=4, size=[3, 2, 4, 8])
    >>> p, l, u = lu(A)
    >>> p.shape, l.shape, u.shape
    ((3, 2, 4, 4), (3, 2, 4, 4), (3, 2, 4, 8))
    >>> np.allclose(A, p @ l @ u)
    True
    >>> PL, U = lu(A, permute_l=True)
    >>> np.allclose(A, PL @ U)
    True

    r   z1The input array must be at least two-dimensional.r   z
The dtype z5 cannot be cast to float(32, 64) or complex(64, 128).r   TÚfFÚfÚd)r*   r   r   éþÿÿÿN)r   r   ÚC)ÚorderÚC_CONTIGUOUSÚ	WRITEABLEr   )r   r   r   Úndimr   r   ÚcharÚlapack_cast_dictÚ	TypeErrorÚastyper*   ÚminÚemptyr   Ú	ones_likeÚcopyÚzerosÚintr   Úflagsr   r   ÚrangeÚix_r   )r   Ú	permute_lr   r    Ú	p_indicesr!   Ú
dtype_charÚndr0   ÚnÚkÚ
real_dcharÚPLÚUÚPÚLÚpÚur1   ÚindÚPaÚnd_ixs                         r$   r   r   É   s¥  € ñ@ %1Œ×	Ñ	˜aÔ	 ´b·j±jÀ³m€BØ	‡w�w�‚{ÜÐLÓMÐMð 
‡x�x‡}�}˜FÑ"Ü% b§h¡h§m¡mÑ4ˆ
ÙÜ˜j¨¯©¨
ð 3Dð Dó Eð Eð �Y‰Y�z !‘}Ó%ˆØˆà—‘�I€RˆˆAÜˆAˆq‹	€AØŸ™Ÿ™¨Ñ-‘°3€Jô ˆB�H‰H€~˜ÒÙÜ—‘  "  a ¨ °2·8±8Ô<ˆBÜ—‘˜{ ˜{ Q˜{¨˜{°"·(±(Ô;ˆAØ�q�5ˆLá7@”—‘˜(˜B˜( ˜(¬"¯(©(Õ3Ü—‘˜+˜B˜+ ˜+ 1˜+¨ZÔ8ð ä—‘˜{ ˜{ Q˜{¨˜{°"·(±(Ô;ˆAÜ—‘˜{ ˜{ Q˜{¨˜{°"·(±(Ô;ˆAØ�a˜�7ˆNð 
‡x�x��€}˜ÒÙÜ—<‘< Ó#©K bÐGÐG¸R¿W¹W»YÐGÐGá8A”—‘  "  a ´Õ4Ü—l‘l 2Ó&ð à”b—l‘l 2Ó&©{¨ÐJÐJÀÇÁÃ	ÐJÐJô �r˜1ÔÙà—‘˜s�Ó#ˆBð �H‰H�^Ò$¨¯©°+Ò)>Ø�W‰W˜3ˆWÓˆáä�H‰H�QœbŸh™hÔ'ˆÜ�H‰H�a˜�V 2§8¡8Ô,ˆÜ�b˜!˜Q 	Ô*Ø ! A¢�1�b˜!‘*¨A¨q°"¨:‰ˆˆ1Šaô
 �H‰H�X�r�X˜1�X¤R§X¡XÔ.ˆàˆqŠ5Ü—‘˜˜2˜˜q˜ !˜¨B¯H©HÔ5ˆAÜ°2·8±8¸C¸R°=Ö A¨a¤ q¥Ò AÐBò B�Ü˜b ™g q¨¡v¨q°©v°yÕAðBà‰Aô —‘˜˜2˜˜q˜ !˜¨B¯H©HÔ5ˆAÜ°2·8±8¸C¸R°=Ö A¨a¤ q¥Ò AÐBò B�Ü˜b ™g q¨¡v¨q°©v°yÕAðBàˆAñ ¡	ÙÜ—‘˜+˜B˜+ ˜+ 1˜+¨ZÔ8ˆBä—F‘F°BÖ7¨qœbŸi™i¨�lÒ7¼¿¹À1»¸ÑFÐHˆEØˆBˆ{�ˆ{˜‰{‰OØ‰Aä—‘˜1˜a˜&¨
Ô3ˆBØ"#ˆBŒr�y‰y˜‹|˜QˆÑØˆAáˆAˆqˆ6Ð- Q¨¨1 IÐ-ùò1 !Bùò !Bùò 8s   Î0TÐ"TÒT)FT)r   FT)FFTF)Ú__doc__Úwarningsr   Únumpyr   r   r   Ú	itertoolsr   Ú_miscr   r	   Úlapackr
   Ú_decomp_lu_cythonr   Ú	typecodesÚjoinÚcan_castr=   Ú__all__r   r   r   )r1   Úys   00r$   ú<module>re      s›   ðÙ !å ç ,Û Ý ÷ .Ý $Ý ,ð  Ÿ\™\¨%Ñ0÷2Øð �r—w‘w¨6ÖG a°[°R·[±[ÀÀAÕ5F¢ÒGÓHÑHó 2Ð ò *€ójóZEðP <@Øô|.ùòw  Hùó 2s   ÁBÁBÁ/BÁ3	BÂB