Џkh3~dZddlmZddlmZmZddlZddlmZddl m Z ddl m Z m Z dd lmZdd lmZej$d Dcic]6}|d j'd Dcgc]}ej(||s|c}8c}}ZgdZe dddZddZe ddddZ ddZycc}wcc}}w)zLU decomposition functions.)warn)asarrayasarray_chkfiniteN)product)_apply_over_batch) _datacopied LinAlgWarning)get_lapack_funcs) lu_dispatcherAllfdFD)lulu_solve lu_factor)ac|r t|}n t|}|jdk(r>tj|}tj dtj }||fS|xs t||}td|f\}|||\}}}|dkrtd| d|dkDrtd|dtd ||fS) 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 rdtype)getrf) overwrite_aillegal value in z)th argument of internal getrf (lu_factor)zDiagonal number z" is exactly zero. Singular matrix.r) stacklevel) rrsizenp empty_likearangeint32r r ValueErrorrr )rr check_finitea1rpivrinfos S/var/www/teggl/fontify/venv/lib/python3.12/site-packages/scipy/linalg/_decomp_lu.pyrrsl q ! QZ ww!| ]]2 ii*3w5+b!"4K j2% 0FE"+6MBT axw&O P   ax tf$F G  s7Nc.|\}}t||||||S)aUSolve 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 )trans overwrite_br") _lu_solve) lu_and_pivbr)r*r"rr$s r&rrs(`IR Rau+". 00r')rr)r$r)r-z1|2cH|r t|}n t|}|xs t||}|jd|jdk7r&t d|jd|jd|j dk(rot tjd|jddgftjd|j}tj||jStd||f\}|||||| \} } | dk(r| St d | d ) Nrz Shapes of lu z and b z are incompatiblerrr)getrs)r)r*rz!th argument of internal gesv|posv) rrr shaper!rrreyeronesrr ) rr$r-r)r*r"b1mr/xr%s r&r+r+s q ! QZ3R!3K xx{bhhqk!= '"((CTUVV ww!| bffQbhh/!Q8"''!177:S T}}Rqww// j2r( 3FEBRu+FGAt qy ($/PQ RRr'c> |rtj|ntj|}|jdkr t d|j j dvrNt|j j }|std|j d|j|d}d}|j^}}} t|| } |j j dvrd nd } t|jdk(r|rRtjg||| |j } tjg|| | |j } | | fS|r)tjg|dtj ntjg|dd| }tjg||| |j }tjg|| | |j } ||| fS|jd ddk(r|r*tj||r|fS|jfS|rtj g||t" ntj|}|tj||r|fS|jfSt%||s|s|jd}|j&dr|j&ds|jd}|sktj|tj }tj | | g|j }t)|||||| kDr|||fn|||f\}}} ntjg||tj }|| kDrrtj g|| | |j } t+|jdd Dcgc] }t-|c}D]}t)||| |||||}nqtj g|| | |j }t+|jdd Dcgc] }t-|c}D]}t)||||||||} |s|s|rttj g|||| }tj.|Dcgc]}tj0|c}tj0|gz}d|g||<|}n5tj ||g| }d|tj0||f<|}|r|| fS||| fScc}wcc}wcc}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 rz1The input array must be at least two-dimensional.rz The dtype z5 cannot be cast to float(32, 64) or complex(64, 128).rTfFfd)r0rrN)rrC)order C_CONTIGUOUS WRITEABLEr)rrrndimr!rcharlapack_cast_dict TypeErrorastyper0minemptyr ones_likecopyzerosintr flagsr rrangeix_r)r permute_lrr" p_indicesr# dtype_charndr4nk real_dcharPLUPLpur5indPand_ixs r&rrs@%1  a bjjmB ww{LMM xx}}F"%bhhmm4 j 3DDE EYYz!} % IRA Aq A -3J BHH~  " a  288 WW3W  HHQbhh ' HHaV288 ,b!Q * !A1b!*Aq":1a HHXrX1XRXX . q52q!BHH5A288CR= Aaq AB BbgqvqvyA BA2q!BHH5A288CR= Aaq AB BbgqvqvyA BA  +B++1+Z8BFFB7qbiil71FHEB{{{OA1a& 3B"#Bryy|Q AAq6-Q1I-1!B !B8s0T"T T)FT)rFT)FFTF)__doc__warningsrnumpyrrr itertoolsrscipy._lib._utilr_miscr r lapackr _decomp_lu_cythonr typecodesjoincan_castrA__all__rrr+r)r5ys00r&rjs!,..$, \\%02rww6Ga[R[[A5FGHH2 *8nnb20j9j,7S8S.<@|.K H2sB9B45B49 B94B9