S_fvgddlmZddlZddlmZddlmZmZmZm Z ddl m Z m Z ddl mZddlZddlmZd Z ddlmZe Zgd ZGd d eZdZdZdZddZddddefdZ ddZ dZ! ddZ"y#e$rd ZYFwxYw))warnN)asarray)issparseSparseEfficiencyWarning csc_matrix csr_matrix)is_pydata_spmatrixconvert_pydata_sparse_to_scipy) LinAlgError)_superluFT) use_solverspsolvespluspilu factorizedMatrixRankWarningspsolve_triangularc eZdZy)rN)__name__ __module__ __qualname__Dlib/python3.12/site-packages/scipy/sparse/linalg/_dsolve/linsolve.pyrrsrrc vd|vr|dtd<trd|vrtj|dyyy)as Select default sparse direct solver to be used. Parameters ---------- useUmfpack : bool, optional Use UMFPACK [1]_, [2]_, [3]_, [4]_. over SuperLU. Has effect only if ``scikits.umfpack`` is installed. Default: True assumeSortedIndices : bool, optional Allow UMFPACK to skip the step of sorting indices for a CSR/CSC matrix. Has effect only if useUmfpack is True and ``scikits.umfpack`` is installed. Default: False Notes ----- The default sparse solver is UMFPACK when available (``scikits.umfpack`` is installed). This can be changed by passing useUmfpack = False, which then causes the always present SuperLU based solver to be used. UMFPACK requires a CSR/CSC matrix to have sorted column/row indices. If sure that the matrix fulfills this, pass ``assumeSortedIndices=True`` to gain some speed. References ---------- .. [1] T. A. Davis, Algorithm 832: UMFPACK - an unsymmetric-pattern multifrontal method with a column pre-ordering strategy, ACM Trans. on Mathematical Software, 30(2), 2004, pp. 196--199. https://dl.acm.org/doi/abs/10.1145/992200.992206 .. [2] T. A. Davis, A column pre-ordering strategy for the unsymmetric-pattern multifrontal method, ACM Trans. on Mathematical Software, 30(2), 2004, pp. 165--195. https://dl.acm.org/doi/abs/10.1145/992200.992205 .. [3] T. A. Davis and I. S. Duff, A combined unifrontal/multifrontal method for unsymmetric sparse matrices, ACM Trans. on Mathematical Software, 25(1), 1999, pp. 1--19. https://doi.org/10.1145/305658.287640 .. [4] T. A. Davis and I. S. Duff, An unsymmetric-pattern multifrontal method for sparse LU factorization, SIAM J. Matrix Analysis and Computations, 18(1), 1997, pp. 140--158. https://doi.org/10.1137/S0895479894246905T. Examples -------- >>> import numpy as np >>> from scipy.sparse.linalg import use_solver, spsolve >>> from scipy.sparse import csc_matrix >>> R = np.random.randn(5, 5) >>> A = csc_matrix(R) >>> b = np.random.randn(5) >>> use_solver(useUmfpack=False) # enforce superLU over UMFPACK >>> x = spsolve(A, b) >>> np.allclose(A.dot(x), b) True >>> use_solver(useUmfpack=True) # reset umfPack usage to default useUmfpackassumeSortedIndices)rN)globalsrumfpack configure)kwargss rrrsDzv"("6 ,+v5f5J.KL6zrctjtjfdtjtjfdtjtjfdtjtjfdi}t t|j j}t t|jj j} |||f}|d d z}tj|}tj|jtj |_ tj|jtj |_||fS#t$r}d|d|d}t||d}~wwxYw) z8Get umfpack family string given the sparse matrix dtype.dizidlzlz]only float64 or complex128 matrices with int32 or int64 indices are supported! (got: matrix: z , indices: )Nrldtype)npfloat64int32 complex128int64getattrr+nameindicesKeyError ValueErrorcopyrindptr)A _familiesf_typei_typefamilyemsgA_news r_get_umf_familyr@_s, RXX !4 RXX !4 IR &FR-- .F%FF+,AY_F IIaLE::ahhbhh7ELJJqyy9EM 5= %77=hk&QRTo1$%sE&& F /FF ctjtjj}|jd|kDr t dt|j |kDr-tj|j|kDr t d|jjtjd}|jjtjd}||fS)Nz#indptr values too large for SuperLUz$indices values too large for SuperLUFr6) r,iinfointcmaxr7r5shapeanyr3astype)r8 max_valuer3r7s r_safe_downcast_indicesrKs!%%Ixx|i>?? AGG}y 66!))i' (CD DiirwwU3G XX__RWW5_ 1F F?rc ( t|}|r |jnd}t|}t|}t|r|jdvst |}t dtdt|}|s t|}|jdk(xs#|jdk(xr|jddk(}|j|j}tj|j|j}|j|k7r|j!|}|j|k7r|j!|}|j\} } | | k7rt#d| | fd| |jd k7r)t#d |jd |jd d|xrt$}|r|r|r|j'} n|} t| |j j)} t*r t-d |jj.dvr t#dt1|\} }t3j4| } | j7t2j8|| d}|S|r|r|j'}d}|s|jdk(rd}nd }|j:j!tj<d}|j>j!tj<d}tA|}tCjD| |jF|jH|||||\}}|d k7r1t dtJd|jMtjN|r|j)}|StQ|}|jdk(s(t|st dtdt |}g}g}g}tS|jdD]}|dd|gfj'j)}||}tjT|}|jd }|jW||jWtjX||tZ |jWtj|||j tj\|}tj\|}tj\|}|j|||ff|j|j}|r|j_|}|S)a Solve the sparse linear system Ax=b, where b may be a vector or a matrix. Parameters ---------- A : ndarray or sparse matrix The square matrix A will be converted into CSC or CSR form b : ndarray or sparse matrix The matrix or vector representing the right hand side of the equation. If a vector, b.shape must be (n,) or (n, 1). permc_spec : str, optional How to permute the columns of the matrix for sparsity preservation. (default: 'COLAMD') - ``NATURAL``: natural ordering. - ``MMD_ATA``: minimum degree ordering on the structure of A^T A. - ``MMD_AT_PLUS_A``: minimum degree ordering on the structure of A^T+A. - ``COLAMD``: approximate minimum degree column ordering [1]_, [2]_. use_umfpack : bool, optional if True (default) then use UMFPACK for the solution [3]_, [4]_, [5]_, [6]_ . This is only referenced if b is a vector and ``scikits.umfpack`` is installed. Returns ------- x : ndarray or sparse matrix the solution of the sparse linear equation. If b is a vector, then x is a vector of size A.shape[1] If b is a matrix, then x is a matrix of size (A.shape[1], b.shape[1]) Notes ----- For solving the matrix expression AX = B, this solver assumes the resulting matrix X is sparse, as is often the case for very sparse inputs. If the resulting X is dense, the construction of this sparse result will be relatively expensive. In that case, consider converting A to a dense matrix and using scipy.linalg.solve or its variants. References ---------- .. [1] T. A. Davis, J. R. Gilbert, S. Larimore, E. Ng, Algorithm 836: COLAMD, an approximate column minimum degree ordering algorithm, ACM Trans. on Mathematical Software, 30(3), 2004, pp. 377--380. :doi:`10.1145/1024074.1024080` .. [2] T. A. Davis, J. R. Gilbert, S. Larimore, E. Ng, A column approximate minimum degree ordering algorithm, ACM Trans. on Mathematical Software, 30(3), 2004, pp. 353--376. :doi:`10.1145/1024074.1024079` .. [3] T. A. Davis, Algorithm 832: UMFPACK - an unsymmetric-pattern multifrontal method with a column pre-ordering strategy, ACM Trans. on Mathematical Software, 30(2), 2004, pp. 196--199. https://dl.acm.org/doi/abs/10.1145/992200.992206 .. [4] T. A. Davis, A column pre-ordering strategy for the unsymmetric-pattern multifrontal method, ACM Trans. on Mathematical Software, 30(2), 2004, pp. 165--195. https://dl.acm.org/doi/abs/10.1145/992200.992205 .. [5] T. A. Davis and I. S. Duff, A combined unifrontal/multifrontal method for unsymmetric sparse matrices, ACM Trans. on Mathematical Software, 25(1), 1999, pp. 1--19. https://doi.org/10.1145/305658.287640 .. [6] T. A. Davis and I. S. Duff, An unsymmetric-pattern multifrontal method for sparse LU factorization, SIAM J. Matrix Analysis and Computations, 18(1), 1997, pp. 140--158. https://doi.org/10.1137/S0895479894246905T. Examples -------- >>> import numpy as np >>> from scipy.sparse import csc_matrix >>> from scipy.sparse.linalg import spsolve >>> A = csc_matrix([[3, 2, 0], [1, -1, 0], [0, 5, 1]], dtype=float) >>> B = csc_matrix([[2, 0], [-1, 0], [2, 0]], dtype=float) >>> x = spsolve(A, B) >>> np.allclose(A.dot(x).toarray(), B.toarray()) True N)csccsrz.spsolve requires A be CSC or CSR matrix format stacklevelr z!matrix must be square (has shape r(rz!matrix - rhs dimension mismatch (z - r*Scikits.umfpack not installed.dDZconvert matrix data to double, please, using .astype(), or set linsolve.useUmfpack = FalseT autoTransposeFrMrC)ColPerm)optionszMatrix is exactly singularzCspsolve is more efficient when sparse b is in the CSC matrix format)rGr+)0r __class__r rformatrrrrndimrGsum_duplicates _asfptyper, promote_typesr+rIr5rtoarrayravelnoScikit RuntimeErrorcharr@r UmfpackContextlinsolve UMFPACK_Ar3rEr7dictr gssvnnzdatarfillnanrrange flatnonzeroappendfullint concatenatefrom_scipy_sparse) r8b permc_spec use_umfpackis_pydata_sparsepydata_sparse_cls b_is_sparse b_is_vector result_dtypeMNb_vec umf_familyumfxflagr3r7rXinfo Afactsolve data_segsrow_segscol_segsjbjxjwsegment_length sparse_data sparse_row sparse_cols rrrsid*!,'7 T&q)A&q)A QKAHH6 qM = $ 41+K  AJFFaKEQVVq[%DQWWQZ1_K A##AGGQWW5Lww, HH\ "ww, HH\ " 77DAq QGAtqy13DQRSrvvGGIJ HE$AJHH%);A)>3,<qMIHH1771:& C q1#vY&&(..0^NN2&!"" EF  BqE!AB C..3K1J1J [:z*BC!"9A %77: Hrc Ht|r.t|dd}|jj}nt}t |r|j dk(st |}tdtd|j|j}|j\}}||k7r tdt|\} } t||||} || j|| d d k(rd | d <t!j"||j$|j&| | |d | S)a Compute the LU decomposition of a sparse, square matrix. Parameters ---------- A : sparse matrix Sparse matrix to factorize. Most efficient when provided in CSC format. Other formats will be converted to CSC before factorization. permc_spec : str, optional How to permute the columns of the matrix for sparsity preservation. (default: 'COLAMD') - ``NATURAL``: natural ordering. - ``MMD_ATA``: minimum degree ordering on the structure of A^T A. - ``MMD_AT_PLUS_A``: minimum degree ordering on the structure of A^T+A. - ``COLAMD``: approximate minimum degree column ordering diag_pivot_thresh : float, optional Threshold used for a diagonal entry to be an acceptable pivot. See SuperLU user's guide for details [1]_ relax : int, optional Expert option for customizing the degree of relaxing supernodes. See SuperLU user's guide for details [1]_ panel_size : int, optional Expert option for customizing the panel size. See SuperLU user's guide for details [1]_ options : dict, optional Dictionary containing additional expert options to SuperLU. See SuperLU user guide [1]_ (section 2.4 on the 'Options' argument) for more details. For example, you can specify ``options=dict(Equil=False, IterRefine='SINGLE'))`` to turn equilibration off and perform a single iterative refinement. Returns ------- invA : scipy.sparse.linalg.SuperLU Object, which has a ``solve`` method. See also -------- spilu : incomplete LU decomposition Notes ----- This function uses the SuperLU library. References ---------- .. [1] SuperLU https://portal.nersc.gov/project/sparse/superlu/ Examples -------- >>> import numpy as np >>> from scipy.sparse import csc_matrix >>> from scipy.sparse.linalg import splu >>> A = csc_matrix([[1., 0., 0.], [5., 0., 2.], [0., -1., 0.]], dtype=float) >>> B = splu(A) >>> x = np.array([1., 2., 3.], dtype=float) >>> B.solve(x) array([ 1. , -3. , -1.5]) >>> A.dot(B.solve(x)) array([ 1., 2., 3.]) >>> B.solve(A.dot(x)) array([ 1., 2., 3.]) clsc0|jt|SNrsrras rcsc_construct_funcz splu..csc_construct_func((Q8 8rrM&splu converted its input to CSC formatrOrPcan only factor square matrices)DiagPivotThreshrW PanelSizeRelaxrWNATURALT SymmetricModeFrilurXr typeto_scipy_sparsetocscrrrZrrr\r]rGr5rKrgupdater gstrfrirj) r8rudiag_pivot_threshrelax panel_sizerXrr|r}r3r7_optionss rrrSsH!'+Aw 9    % % '' QKAHH- qM 5 $ 4 A 77DAq Q:;;,Q/OGV$5z(7H  y($(! >>!QUUAFFGV-?#X 77rc Nt|r.t|dd} |jj}nt} t |r|j dk(st |}tdtd|j|j}|j\} } | | k7r tdt|\} } t|||||||}||j||d d k(rd |d <t!j"| |j$|j&| | | d | S)a Compute an incomplete LU decomposition for a sparse, square matrix. The resulting object is an approximation to the inverse of `A`. Parameters ---------- A : (N, N) array_like Sparse matrix to factorize. Most efficient when provided in CSC format. Other formats will be converted to CSC before factorization. drop_tol : float, optional Drop tolerance (0 <= tol <= 1) for an incomplete LU decomposition. (default: 1e-4) fill_factor : float, optional Specifies the fill ratio upper bound (>= 1.0) for ILU. (default: 10) drop_rule : str, optional Comma-separated string of drop rules to use. Available rules: ``basic``, ``prows``, ``column``, ``area``, ``secondary``, ``dynamic``, ``interp``. (Default: ``basic,area``) See SuperLU documentation for details. Remaining other options Same as for `splu` Returns ------- invA_approx : scipy.sparse.linalg.SuperLU Object, which has a ``solve`` method. See also -------- splu : complete LU decomposition Notes ----- To improve the better approximation to the inverse, you may need to increase `fill_factor` AND decrease `drop_tol`. This function uses the SuperLU library. Examples -------- >>> import numpy as np >>> from scipy.sparse import csc_matrix >>> from scipy.sparse.linalg import spilu >>> A = csc_matrix([[1., 0., 0.], [5., 0., 2.], [0., -1., 0.]], dtype=float) >>> B = spilu(A) >>> x = np.array([1., 2., 3.], dtype=float) >>> B.solve(x) array([ 1. , -3. , -1.5]) >>> A.dot(B.solve(x)) array([ 1., 2., 3.]) >>> B.solve(A.dot(x)) array([ 1., 2., 3.]) rc0|jt|Srrrs rrz!spilu..csc_construct_funcrrrMz'spilu converted its input to CSC formatrOrPr) ILU_DropRule ILU_DropTolILU_FillFactorrrWrrrWrTrrr)r8drop_tol fill_factor drop_rulerurrrrXrr|r}r3r7rs rrrsv!'+Aw 9    % % '' QKAHH- qM 6 $ 4 A 77DAq Q:;;,Q/OGV#.$5z(7H  y($(! >>!QUUAFFGV-?"H 66rctrjjtrtr t dt rjdk(sttdtdjjjdvr tdt\}t!j"|j%fd}|St'j(S) a Return a function for solving a sparse linear system, with A pre-factorized. Parameters ---------- A : (N, N) array_like Input. A in CSC format is most efficient. A CSR format matrix will be converted to CSC before factorization. Returns ------- solve : callable To solve the linear system of equations given in `A`, the `solve` callable should be passed an ndarray of shape (N,). Examples -------- >>> import numpy as np >>> from scipy.sparse.linalg import factorized >>> from scipy.sparse import csc_matrix >>> A = np.array([[ 3. , 2. , -1. ], ... [ 2. , -2. , 4. ], ... [-1. , 0.5, -1. ]]) >>> solve = factorized(csc_matrix(A)) # Makes LU decomposition. >>> rhs1 = np.array([1, -2, 0]) >>> solve(rhs1) # Uses the LU factors. array([ 1., -2., -2.]) rRrMrrOrPrSrTctjdd5jtj|d}ddd|S#1swYSxYw)Nignore)divideinvalidTrU)r,errstatesolver rf)rtresultr8rs rrzfactorized..solveRsNHh? P7#4#4a$O PM  PMs $AA)r rrrrarbrrZrrrr]r+rcr5r@r rdnumericrr)r8rrrs` @rrrs<!    % % ' ?@ @ E 11 A 9(Q 8 KKM 77<>> import numpy as np >>> from scipy.sparse import csr_matrix >>> from scipy.sparse.linalg import spsolve_triangular >>> A = csr_matrix([[3, 0, 0], [1, -1, 0], [2, 0, 1]], dtype=float) >>> B = np.array([[2, 0], [-1, 0], [2, 0]], dtype=float) >>> x = spsolve_triangular(A, B) >>> np.allclose(A.dot(x), B) True rNz8CSR matrix format is required. Converting to CSR matrix.rOrPrr z+A must be a square matrix but its shape is .)r rOz)b must have 1 or 2 dims but its shape is zlThe size of the dimensions of A must be equal to the size of the first dimension of b but the shape of A is z and the shape of b is same_kind)castingzCannot overwrite b (dtype z) with result of type TrCrBzA is singular: diagonal z is zero.z*A is not triangular: A[{}, {}] is nonzero.)r rtocsrrrZrrrr6rGr5r\r, asanyarrayr[ result_typerjr-can_castr+rIrmlenr7slicer3r dotT)r8rtlower overwrite_A overwrite_b unit_diagonalx_dtyper row_indicesi indptr_start indptr_stopA_diagonal_index_row_iA_off_diagonal_indices_row_iA_column_indices_in_row_iA_values_in_row_is rrr^s t!    % % ' QKAHH- G $ 4 qM  FFHwwqzQWWQZ9!''! DF F aAvvV7y BD DwwqzQWWQZ Jwwi.qwwiq :  nnQVVQ 3G ;;qww =A,QWWI6")1&  HHW4H ( CFm CFQJB/ 3xx{ hhq1uo %01_ "+0{Q+O (%1 "+01A;+O (+"=%&YY/E%F%J*1#Y79 9+A!BQ!F6!QYY'=>?A A %&II.J$K!FF#?@ !q23557HII aDAFF12 2D=3@ Hr)NT)NNNNNNNN)TFFF)#warningsrnumpyr,r scipy.sparserrrrscipy.sparse._sputilsr r scipy.linalgr r6r rascikits.umfpackr ImportErrorr__all__ UserWarningrrr@rKrrgrrrrrrrrsKKT$  %\  6  @MD D @ Ftdfe7PJNGK^6B?DIN%*L ]HsA;;BB