(phwLSSKJrJrJr SSKrSSKJr SSKJrJ r J r J r J r J r SSKJrJrJrJr SSKJr SSKrSSKrSSKJr S rSSKJr \R:"5q/S Qr"S S \ 5r!Sr"Sr#SSjr$SSjr%SSjr&Sr'SSjr(Sr)Sr*g!\a S rNTf=f))warncatch_warnings simplefilterN)asarray)issparseSparseEfficiencyWarning csr_array csc_array eye_array diags_array)is_pydata_spmatrixconvert_pydata_sparse_to_scipyget_index_dtypesafely_cast_index_arrays) LinAlgError)_superluFT) use_solverspsolvespluspilu factorizedMatrixRankWarningspsolve_triangularis_sptriangular spbandwidthc\rSrSrSrg)rN)__name__ __module__ __qualname____firstlineno____static_attributes__rW/var/www/html/venv/lib/python3.13/site-packages/scipy/sparse/linalg/_dsolve/linsolve.pyrrsr%rc SU;aUS[l[R(aSU;a[R"USS9 ggg)a 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_array >>> R = np.random.randn(5, 5) >>> A = csc_array(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)r)N)r(uumfpack configure)kwargss r&rr sC|vl+ ||-7f5J.KL8|r%c[R[R4S[R[R4S[R[R4S[R[R4S0n[ [UR R5n[ [URR R5nXU4nUS S -n[R"U5n[R"UR[RS 9Ul [R"UR[RS 9UlXG4$![anSUSUS3n[U5UeSnAff=f) 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 complex128int64getattrr6nameindicesKeyError ValueErrorcopyrindptr)A _familiesf_typei_typefamilyemsgA_news r&_get_umf_familyrKcs( RXX !4 RXX !4 IR &FR-- .F%F+,AY_F IIaLE::ahhbhh7ELJJqyy9EM = %77=hk&QRTo1$%sE!! F+FFc 2 [U5nU(a UROSn[U5n[U5n[U5(aURS;d[ U5n[ S[SS9 [U5nU(d [U5nURS:H=(d( URS:H=(a URSS:HnUR5 UR5n[R"URUR5nURU:waUR!U5nURU:waUR!U5nURupX:wa[#SX4S35eXRS :wa)[#S URS URS S35e[%[&S 5(d[((+[&lU=(a [&R*nU(aU(aU(aUR-5n OUn [XRS 9R/5n [((a [1S5eURR2S;a [#S5e[5U5up[6R8"U 5n U R;[6R<X SS9nU$U(aU(aUR-5nSnU(dURS:XaSnOS nUR>R![R@SS9nURBR![R@SS9n[EUS9n[FRH"XRJURLUUXUS9unnUS :wa.[ S[NSS9 URQ[RR5 U(aUR/5nU$[UU5nURS:Xd*[U5(d[ S[SS9 [ U5n/n/n/n[WURS5HnUSS2U4R-5R/5nU"U5n[RX"U5nURS nUR[U5 UR[[R\"UU[^S 95 UR[[R"UUURS 95 M [R`"U5n[c[eUR5S9n[R`"UUS 9n[R`"UUS 9n URUUU 44URURS9nU(aURgU5nU$)a Solve the sparse linear system Ax=b, where b may be a vector or a matrix. Parameters ---------- A : ndarray or sparse array or matrix The square matrix A will be converted into CSC or CSR form b : ndarray or sparse array or 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 array or 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_array >>> from scipy.sparse.linalg import spsolve >>> A = csc_array([[3, 2, 0], [1, -1, 0], [0, 5, 1]], dtype=float) >>> B = csc_array([[2, 0], [-1, 0], [2, 0]], dtype=float) >>> x = spsolve(A, B) >>> np.allclose(A.dot(x).toarray(), B.toarray()) True Ncsccsrz.spsolve requires A be CSC or CSR matrix format stacklevelrz!matrix must be square (has shape r3rz!matrix - rhs dimension mismatch (z - r*r5Scikits.umfpack not installed.dD\convert matrix data to double, please, using .astype(), or set linsolve.useUmfpack.u = FalseT autoTransposeFrN)rA)ColPerm)optionszMatrix is exactly singularzCspsolve is more efficient when sparse b is in the CSC matrix format)maxval)shaper6)4r __class__rrformatr rrrndimr[sum_duplicates _asfptyper7 promote_typesr6astyper@hasattrr(noScikitr*toarrayravel RuntimeErrorcharrKr+UmfpackContextlinsolve UMFPACK_Ar>intcrBdictrgssvnnzdatarfillnanrrange flatnonzeroappendfullint concatenatermaxfrom_scipy_sparse)!rCb permc_spec use_umfpackis_pydata_sparsepydata_sparse_cls b_is_sparse b_is_vector result_dtypeMNb_vec umf_familyumfxflagr>rBrYinfo Afactsolve data_segsrow_segscol_segsjbjxjwsegment_length sparse_data idx_dtype sparse_row sparse_cols! r&rrsd*!,'7 T&q)A&q)A QKKAHH6 aL = $ 41+K  AJFFaKEQVVq[%DQWWQZ1_K A##AGGQWW5Lww, HH\ "ww, HH\ " 77DA GAtqy13DQRSrvvGGID H?$AJHH%);A)>)>3,<aLIHH1771:&q!tW__&,,.^NN2&!"" EF  BqE!AB'..3K's177|>> import numpy as np >>> from scipy.sparse import csc_array >>> from scipy.sparse.linalg import splu >>> A = csc_array([[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.]) clsc0UR[U65$Nrzr ras r&csc_construct_func splu..csc_construct_func((A7 7r%rN&splu converted its input to CSC formatrPrQcan only factor square matricesSuperLU)DiagPivotThreshrX PanelSizeRelaxrXNATURALT SymmetricModeFrilurYr typeto_scipy_sparsetocscr rr]rrr_r`r[r@rr7rlrmupdatergstrfrorp) rCr|diag_pivot_threshrelax panel_sizerYA_clsrrrr>rB_optionss r&rrHsH!Q', 8    % % '& QKKAHH- aL 5 $ 4 A 77DA :;;.q"''9EOG$5(7H  y($(! >>!UUAFFG-?#X 77r%c p[U5(a1[U5n U S.Sjn UR5R5nO[n [ U5(aUR S:Xd[ U5n[S[SS9 UR5 UR5nURupX:wa [S5e[U[RS5up[!X1UXTXvS 9nUbUR#U5 US S :XaS US '[$R&"XR(UR*XU S US9$)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 array 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_array >>> from scipy.sparse.linalg import spilu >>> A = csc_array([[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.]) rc0UR[U65$rrrs r&r!spilu..csc_construct_funcrr%rNz'spilu converted its input to CSC formatrPrQrr) ILU_DropRule ILU_DropTolILU_FillFactorrrXrrrXrTrrr)rCdrop_tol fill_factor drop_ruler|rrrrYrrrrr>rBrs r&rrsv!Q', 8    % % '& QKKAHH- aL 6 $ 4 A 77DA :;;.q"''9EOG#.$5(7H  y($(! >>!UUAFFG-?"H 66r%c^^[T5(aTR5R5m[[S5(d[ (+[l[R (a[ (a [S5e[T5(aTRS:Xd[T5m[S[SS9 TR5mTRRS;a [!S5e[#T5unm[$R&"U5mTR)T5 UU4S jnU$[+T5R,$) 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_array >>> A = np.array([[ 3. , 2. , -1. ], ... [ 2. , -2. , 4. ], ... [-1. , 0.5, -1. ]]) >>> solve = factorized(csc_array(A)) # Makes LU decomposition. >>> rhs1 = np.array([1, -2, 0]) >>> solve(rhs1) # Uses the LU factors. array([ 1., -2., -2.]) r*rSrNrrPrQrTrUc>[R"SSS9 TR[RTUSS9nSSS5 U$!,(df  W$=f)Nignore)divideinvalidTrV)r7errstatesolver+rk)r{resultrCrs r&rfactorized..solveLsKHh?7#4#4a$O@M @?Ms !A A)r rrrcr(rdr*rgrr]r rrr`r6rhr@rKr+rinumericrr)rCrrrs` @r&rrs<!    % % ' :s # ##| || 8?@ @ E 1! A 9(Q 8 KKM 77<U R@U RBXR<U R>U R@U RBU5 upU(a [%S5eU(d1W RD"S/S /[GUR5S - -Q76n X-nU$!,(df  GN-=f)a Solve the equation ``A x = b`` for `x`, assuming A is a triangular matrix. Parameters ---------- A : (M, M) sparse array or matrix A sparse square triangular matrix. Should be in CSR or CSC format. b : (M,) or (M, N) array_like Right-hand side matrix in ``A x = b`` lower : bool, optional Whether `A` is a lower or upper triangular matrix. Default is lower triangular matrix. overwrite_A : bool, optional Allow changing `A`. Enabling gives a performance gain. Default is False. overwrite_b : bool, optional Allow overwriting data in `b`. Enabling gives a performance gain. Default is False. If `overwrite_b` is True, it should be ensured that `b` has an appropriate dtype to be able to store the result. unit_diagonal : bool, optional If True, diagonal elements of `a` are assumed to be 1. .. versionadded:: 1.4.0 Returns ------- x : (M,) or (M, N) ndarray Solution to the system ``A x = b``. Shape of return matches shape of `b`. Raises ------ LinAlgError If `A` is singular or not triangular. ValueError If shape of `A` or shape of `b` do not match the requirements. Notes ----- .. versionadded:: 0.19.0 Examples -------- >>> import numpy as np >>> from scipy.sparse import csc_array >>> from scipy.sparse.linalg import spsolve_triangular >>> A = csc_array([[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 rrOTrNz?CSC or CSR matrix format is required. Converting to CSC matrix.rPrQz+A must be a square matrix but its shape is .rrNrz&A is singular: zero entry on diagonal.)rrPz)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 r5)r6r]zA is singular.)$r rrrr]rrrr rAr[r@rrsetdiagdiagonalr7anyrr r_ asanyarrayr^rar6float32rbr rgstrsrorpr>rBreshapelen)rCr{lower overwrite_A overwrite_b unit_diagonaltransrrdiaginvdiagrLUrrs r&rrXs p!    % % ' E{{qxx5( CC  QKKAHH- N $ 4 aL  FFH 77DAv9!''! DF F   #: ; IIaL zz| 66$!)  8: :D& C<K((A{7++..A aAvvV7y BD DGGAJ Jwwi.qwwiq :  ##B$4$4QWWbjj$I177SLww, HH\ "ww, HH\ "  FFH  qfL 1 aE :  ! nnUqvvqyy!((qvvqyy!(( GA *++ //"Bs177|a/?(@B K Hq s 5"N33 Oc[U5(aURS;d[S[SS9 [ U5nURS:Xa:UR R 5S:*UR R5S:4$URS:Xa2URupX!:*R5X!:R54$URS:Xa@[S UR555[S UR5554$URS :XaM[S [UR555n[S [UR555nX44$URURpe[U5S- nSup4US-SS4HWnXeUXXS-nU=(a X:R5nU=(a X:*R5nU(aMNU(aMW g [ R""[ R$"U5[ R&"U55nUnU=(a X!:R5nU=(a X!:*R5nURS:XaXC4$X44$)aXReturns 2-tuple indicating lower/upper triangular structure for sparse ``A`` Checks for triangular structure in ``A``. The result is summarized in two boolean values ``lower`` and ``upper`` to designate whether ``A`` is lower triangular or upper triangular respectively. Diagonal ``A`` will result in both being True. Non-triangular structure results in False for both. Only the sparse structure is used here. Values are not checked for zeros. This function will convert a copy of ``A`` to CSC format if it is not already CSR or CSC format. So it may be more efficient to convert it yourself if you have other uses for the CSR/CSC version. If ``A`` is not square, the portions outside the upper left square of the matrix do not affect its triangular structure. You probably want to work with the square portion of the matrix, though it is not requred here. Parameters ---------- A : SciPy sparse array or matrix A sparse matrix preferrably in CSR or CSC format. Returns ------- lower, upper : 2-tuple of bool .. versionadded:: 1.15.0 Examples -------- >>> import numpy as np >>> from scipy.sparse import csc_array, eye_array >>> from scipy.sparse.linalg import is_sptriangular >>> A = csc_array([[3, 0, 0], [1, -1, 0], [2, 0, 1]], dtype=float) >>> is_sptriangular(A) (True, False) >>> D = eye_array(3, format='csr') >>> is_sptriangular(D) (True, True) )rNrOcoodiadoklilzCis_sptriangular needs sparse and not BSR format. Converting to CSR.rPrQrrrrc3.# UH upX!:*v M g7frr.0rcs r& "is_sptriangular..s/hda16hc3.# UH upX!:v M g7frrrs r&rrs4QQVrrc3B# UHupUH o3U:*v M M g7frrrrowcolscols r&rrR0A93Tc3JTJ0Ac3B# UHupUH o3U:v M M g7frrrs r&rrrrr)TTr)FFrO)rr]rrr offsetsrymincoordsallkeys enumeraterowsrBr>rr7repeatarangediff) rCrrrupperrBr>rrs r&rrsR QKKAHH(RR R $ 4 aL xx5yy}}!#QYY]]_%999 U XX  !!#dl%7%7%999 U /affh//4Q4Q1QQQ U R !&&0ARRR !&&0ARR|hh G F aALEQ2c{6'?3-3;++--3;++-uUU  99RYYq\2776? 3D D  *t|((*E  *t|((*Exx5| <r%c@[U5(aURS;d[S[SS9 [ U5nURS:Xae[ SUR R5R5*5[ SUR R 5R554$URS;a{URURp![U5S- n[R"[R"U5[R"U55U- nURS :XaU*nOURS :Xa UR SUR S- nORURS :XaBUR#5VVs/sH upVXe- PM snnS/-n[U5*[ U54$[ [R"W5R5*S5[ [R "U5R5S54$s snnf) aReturn the lower and upper bandwidth of a 2D numeric array. Computes the lower and upper limits on the bandwidth of the sparse 2D array ``A``. The result is summarized as a 2-tuple of positive integers ``(lo, hi)``. A zero denotes no sub/super diagonal entries on that side (tringular). The maximum value for ``lo``(``hi``) is one less than the number of rows(cols). Only the sparse structure is used here. Values are not checked for zeros. Parameters ---------- A : SciPy sparse array or matrix A sparse matrix preferrably in CSR or CSC format. Returns ------- below, above : 2-tuple of int The distance to the farthest non-zero diagonal below/above the main diagonal. .. versionadded:: 1.15.0 Examples -------- >>> import numpy as np >>> from scipy.sparse.linalg import spbandwidth >>> from scipy.sparse import csc_array, eye_array >>> A = csc_array([[3, 0, 0], [1, -1, 0], [2, 0, 1]], dtype=float) >>> spbandwidth(A) (2, 0) >>> D = eye_array(3, format='csr') >>> spbandwidth(D) (0, 0) )rNrOrrrzCspbandwidth needs sparse format not LIL and BSR. Converting to CSR.rPrQrrrMrrOrr)rr]rrr ryrritemrBr>rr7rrrrr)rCrBr>rgaprrs r&rr2sH QKKAHH(KK R $ 4 aL xx51qyy}}++--.Aqyy}}7K7K7M0NNNxx>!((AII K!Oii ! bggfo6@ 88u $C U hhqkAHHQK' U #$668,8418,s2Cy#c("" s   ""A &BFF3K,<,<,>(B BB-sH)NT)NNNNN)NNNNNNNN)TFFF)+warningsrrrnumpyr7r scipy.sparserrr r r r scipy.sparse._sputilsr rrr scipy.linalgrrA threadingrrdscikits.umfpackr+ ImportErrorlocalr(__all__ UserWarningrrrKrrrrrrrrr%r&rs77HHNN$  %__   X  AMF D@ F04.2f7RJNGK_6DBJIN%*G TM`7CAHsBB#"B#