doi4SrSSKJr SSKJrJr SSKrSSKJr SSK J r SSK J r J r SS KJrJr SS KJr /S Qr\ "S 5SS j5rSSjr\ "SSS5S5rSSjrg)zLU decomposition functions.)warn)asarrayasarray_chkfiniteN)product)_apply_over_batch) _datacopied LinAlgWarning)get_lapack_funcs_normalize_lapack_dtype) lu_dispatcher)lulu_solve lu_factor)acU(a [U5nO [U5nURS:Xa<[R"U5n[R "S[R S9nXE4$U=(d [X05n[SU45unU"X1S9upEnUS:a[SU*S35eUS:a[SUS3[S S 9 XE4$) a\ 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/html/land-ocr/venv/lib/python3.13/site-packages/scipy/linalg/_decomp_lu.pyrrsl q ! QZ ww!| ]]2 ii*w5+b"4K j2% 0FE"6MBT axw&O P   ax tf$F G  7Nc "UupV[XVXUUS9$)aSolve an equation system, a x = b, given the LU factorization of a The documentation is written assuming array arguments are of specified "core" shapes. However, array argument(s) of this function 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 :ref:`linalg_batch` for details. 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"jIR Ra+". 00r%)rr)r"r)r+z1|2cDU(a [U5nO [U5nU=(d [Xb5nURSURS:wa&[ SURSURS35eUR S:Xah[ [R"SURS9SS/4[R"SURS95n[R"XgRS9$[SX45unU"XXcUS 9upU S:XaU $[ S U *S 35e) Nrz Shapes of lu z and b z are incompatiblerrr)getrs)r'r(rz!th argument of internal gesv|posv) rrr shaperrrreyeronesrr ) rr"r+r'r(r b1mr-xr#s r$r)r)s q ! QZ3R!3K xx{bhhqk!= '"((CTUVV ww!| bffQbhh/!Q8"''!177:S T}}Rww// j2( 3FEBR+FGA qy ($/PQ RRr%c U(a[R"U5O[R"U5nURS:a [ S5e[ XR5upRUR Gtpgn[Xx5n URRS;aSOSn [UR 6S:XaU(aM[R"/UQUPU PURS9n [R"/UQU PUPURS9n X4$U(a'[R"/UQSP[RS9O[R"/UQSPSPU S9n [R"/UQUPU PURS9n[R"/UQU PUPURS9n XU 4$UR S S S :XaU(a0[R"U5U(aU4$UR54$U(a[R"/UQUP[S9O[R"U5n U [R"U5U(aU4$UR54$[!XP5(dU(dURS S 9nUR"S(aUR"S(dURS S 9nU(dc[R"U[RS9n[R"X/URS9n[%UUX5 Xx:aXU4OUUU4upn GO[R"/UQUP[RS9n Xx:au[R"/UQU PU PURS9n ['UR S S Vs/sHn[)U5PM sn6Hn[%UUU UU UU5 M UnOt[R"/UQU PU PURS9n['UR S S Vs/sHn[)U5PM sn6Hn[%UUUUU UU5 M Un U(dU(dU(ax[R"/UQUPUPU S9n[R*"UVs/sHn[R,"U5PM sn[R,"U5/-6nSU/UQU P7'Un O3[R"Xw/U S9nSU[R,"U5U 4'Un U(aX4$XU 4$s snfs snfs snf)a{ 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``. Array argument(s) of this function 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 :ref:`linalg_batch` for details. 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 ------- (p, l, u) | (pl, u): The tuple `(p, l, u)` is returned if `permute_l` is ``False`` (default) else the tuple `(pl, u)` is returned, where: p : (..., M, M) ndarray Permutation arrays or vectors depending on `p_indices`. l : (..., M, K) ndarray Lower triangular or trapezoidal array with unit diagonal, where the last dimension is ``K = min(M, N)``. pl : (..., M, K) ndarray Permuted L matrix with last dimension being ``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.fFfdr)r.rrN)rrC)order C_CONTIGUOUS WRITEABLEr)rrrndimrr r.minrcharemptyr ones_likecopyzerosintr flagsr rrangeix_r)r permute_lrr p_indicesr!ndr2nk real_dcharPLUPLpur3indPand_ixs r$rrs5@%1  a bjjmB ww{LMM.b>OBIRA A A -3J BHH~  " a  288 WW3W  HHQbhh ' HHaV288 ,b!Q* !1!*Aq":a HHXrX1XRXX . 52q!BHH5A288CR= A=aq= ABbgqvqvyACA2q!BHH5A288CR= A=aq= ABbgqvqvyACA  +B++1+Z8BFFB7BqbiilB71FHEB{{{OA1& 3B"#Bryy|Q AA6-Q1I-1!B !B8s8S4-S9* S>)FT)rFT)FFTF)__doc__warningsrnumpyrrr itertoolsrscipy._lib._utilr_miscr r lapackr r _decomp_lu_cythonr __all__rrr)rr%r$rasy!,..=, *8nnb70t9j,7S8S.<@u.r%