U -e @stdZddlmZddlmZmZddlmZmZddl m Z ddl m Z dd d gZ dd d Zddd ZdddZdS)zLU decomposition functions.)warn)asarrayasarray_chkfinite) _datacopied LinAlgWarning)get_lapack_funcs)get_flinalg_funcslulu_solve lu_factorFTcCs||rt|}nt|}|p"t||}td|f\}|||d\}}}|dkrZtd| |dkrttd|tdd||fS)aJ 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 : (N,) ndarray Pivot indices representing the permutation matrix P: row i of matrix was interchanged with row piv[i]. 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. 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 >>> piv_py = [2, 0, 3, 1] >>> L, U = np.tril(lu, k=-1) + np.eye(4), np.triu(lu) >>> np.allclose(A[piv_py] - L @ U, np.zeros((4, 4))) True )getrf) overwrite_arz>> 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 rz)Shapes of lu {} and b {} are incompatible)getrs)trans overwrite_bz4illegal value in %dth argument of internal gesv|posvN)rrrshaperformatr) Z lu_and_pivbrrrr rb1rxrrrrr Ys"/ c Cs|rt|}nt|}t|jdkr,td|p8t||}td|f\}||||d\}}}} | dkrttd| |r||fS|||fS)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 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. Returns ------- **(If permute_l == False)** p : (M, M) ndarray Permutation matrix l : (M, K) ndarray Lower triangular or trapezoidal matrix with unit diagonal. K = min(M, N) u : (K, N) ndarray Upper triangular or trapezoidal matrix **(If permute_l == True)** pl : (M, K) ndarray Permuted L matrix. K = min(M, N) u : (K, N) ndarray Upper triangular or trapezoidal matrix Notes ----- This is a LU factorization routine written for SciPy. 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, np.zeros((4, 4))) True rzexpected matrix)r ) permute_lrrz3illegal value in %dth argument of internal lu.getrf)rrlenrrrr ) rr!rrrZfluplurrrrr s: N)FT)rFT)FFT)__doc__warningsrnumpyrrZ_miscrrZlapackrZ _flinalg_pyr __all__r r r rrrrs     J A