Q(hwBddlmZmZmZddlZddlmZddlmZm Z m Z m Z m Z m Z ddlmZmZmZmZddlmZddlZddlZddlmZd Z ddlmZej:agd ZGd d e Z!dZ"dZ#ddZ$ ddZ% ddZ&dZ' ddZ(dZ)dZ*y#e$rd ZYOwxYw))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 eZdZy)rN)__name__ __module__ __qualname__b/var/www/skyplay_api_hub/venv/lib/python3.12/site-packages/scipy/sparse/linalg/_dsolve/linsolve.pyrrsr"rc d|vr|dt_tjrd|vrtj|dyyy)aq 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"ctjtjfdtjtjfdtjtjfdtjtjfdi}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 complex128int64getattrr3nameindicesKeyError ValueErrorcopyrindptr)A _familiesf_typei_typefamilyemsgA_news r#_get_umf_familyrHcs, RXX !4 RXX !4 IR &FR-- .F%FF+,AY_F IIaLE::ahhbhh7ELJJqyy9EM 5= %77=hk&QRTo1$%sE&& F /FF c  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 dt%t&d st( t&_|xrt&j*}|r|r|r|j-} n|} t| |j j/} t(r t1d|jj2dvr t#dt5|\} }t7j8| } | j;t6j<|| d}|S|r|r|j-}d}|s|jdk(rd}nd }|j>j!tj@d}|jBj!tj@d}tE|}tGjH| |jJ|jL|||||\}}|d k7r1t dtNd|jQtjR|r|j/}|StU|}|jdk(s(t|st dtdt |}g}g}g}tW|jdD]}|dd|fj-j/}||}tjX|}|jd }|j[||j[tj\||t^ |j[tj|||j tj`|}tcte|j}tj`|| }tj`|| } |j||| ff|j|j}|r|jg|}|S)aSolve 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 r0rz!matrix - rhs dimension mismatch (z - r'r2Scikits.umfpack not installed.dD\convert matrix data to double, please, using .astype(), or set linsolve.useUmfpack.u = FalseT autoTransposeFrK)r>)ColPerm)optionszMatrix is exactly singularzCspsolve is more efficient when sparse b is in the CSC matrix format)maxval)shaper3)4r __class__rrformatr rrrndimrXsum_duplicates _asfptyper4 promote_typesr3astyper=hasattrr%noScikitr'toarrayravel RuntimeErrorcharrHr(UmfpackContextlinsolve UMFPACK_Ar;intcr?dictrgssvnnzdatarfillnanrrange flatnonzeroappendfullint concatenatermaxfrom_scipy_sparse)!r@b permc_spec use_umfpackis_pydata_sparsepydata_sparse_cls b_is_sparse b_is_vector result_dtypeMNb_vec umf_familyumfxflagr;r?rVinfo Afactsolve data_segsrow_segscol_segsjbjxjwsegment_length sparse_data idx_dtype sparse_row sparse_cols! r#rrsd*!,'7 T&q)A&q)A QKAHH6 aL = $ 41+K  AJFFaKEQVVq[%DQWWQZ1_K A##AGGQWW5Lww, HH\ "ww, HH\ " 77DAq QGAtqy13DQRSrvvGGID H?$AJHH%);A)>3,<aLIHH1771:& Cq!tW__&,,.^NN2&!"" EF  BqE!AB C..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.]) clsc0|jt|SNrwr ras r#csc_construct_funcz splu..csc_construct_func((A7 7r"rK&splu converted its input to CSC formatrMrNcan only factor square matricesSuperLU)DiagPivotThreshrU PanelSizeRelaxrUNATURALT SymmetricModeFrilurVr typeto_scipy_sparsetocscr rrZrrr\r]rXr=rr4rirjupdatergstrfrlrm) r@rydiag_pivot_threshrelax panel_sizerVA_clsrrrr;r?_optionss r#rrHsH!Q', 8    % % '& QKAHH- aL 5 $ 4 A 77DAq Q:;;.q"''9EOGV$5z(7H  y($(! >>!QUUAFFGV-?#X 77r"c rt|r0t|} | dd} |jj}nt} t |r|j dk(st |}tdtd|j|j}|j\} } | | k7r tdt|tjd\} }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 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.]) rc0|jt|Srrrs r#rz!spilu..csc_construct_funcrr"rKz'spilu converted its input to CSC formatrMrNrr) ILU_DropRule ILU_DropTolILU_FillFactorrrUrrrUrTrrr)r@drop_tol fill_factor drop_ruleryrrrrVrrrrr;r?rs r#rrs(v!Q', 8    % % '& QKAHH- aL 6 $ 4 A 77DAq Q:;;.q"''9EOGV#.$5z(7H  y($(! >>!QUUAFFGV-?"H 66r"cPtrjjttdst t_tj rt r tdtrjdk(sttdtdjjjdvr t!dt#\}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_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'rPrKrrMrNrQrRctjdd5jtj|d}ddd|S#1swYSxYw)Nignore)divideinvalidTrS)r4errstatesolver(rh)rxresultr@rs r#rzfactorized..solveLsNHh? P7#4#4a$O PM  PMs $AA)r rrr`r%rar'rdrrZr rrr]r3rer=rHr(rfnumericrr)r@rrrs` @r#rrs<!    % % ' :s ##| || ?@ @ E 1! A 9(Q 8 KKM 77<| j@| jB|| j<| j>| j@| jB| \}}|r t%d|s2 jDdgd gtG|jd z z} || z}|S#1swYxYw)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 rrLTrKz?CSC or CSR matrix format is required. Converting to CSC matrix.rMrNz+A must be a square matrix but its shape is .rrNrz&A is singular: zero entry on diagonal.)rrMz)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 r2)r3rZzA is singular.)$r rrrrZrrrr r>rXr=rrsetdiagdiagonalr4anyrr r\ asanyarrayr[r^r3float32r_r rgstrsrlrmr;r?reshapelen)r@rxlower overwrite_A overwrite_b unit_diagonaltransrrdiaginvdiagrLUrrs r#rrXs p!    % % ' E{qxx5( CC  QKAHH- N $ 4 aL  FFH 77DAqAv9!''! DF F    #: ; IIaL  zz| 66$!) 8: :D& C<K((A{7++..A aAvvV7y BD DAGGAJ Jwwi.qwwiq :  ##B$4$4QWWbjj$I177SLww, HH\ "ww, HH\ "  FFH  q!fL 1 a|E :  ! nnUqvvqyy!((qvvqyy!(( GAt *++ !'//"Bs177|a/?(@B K Hq  s "NN ct|r|jdvstdtdt |}|jdk(r:|j j dk|j jdk\fS|jdk(r5|j\}}||kj||k\jfS|jdk(r@td |jDtd |jDfS|jd k(rNtd t|jD}td t|jD}||fS|j|j}}t|dz }d\}}|dzddfD]E}|||||dz}|xr||k\j}|xr||kj}|rB|rEyt!j"t!j$|t!j&|}|}|xr||k\j}|xr||kj}|jdk(r||fS||fS)aReturns 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) )rKrLcoodiadoklilzCis_sptriangular needs sparse and not BSR format. Converting to CSR.rMrNrrrrc3,K|] \}}||kywrr!.0rcs r# z"is_sptriangular..s/da16/c3,K|] \}}||k\ywrr!rs r#rz"is_sptriangular..s4Q1Q!V4Qrrc3:K|]\}}|D] }||k ywrr!rrowcolscols r#rz"is_sptriangular..$R93TRcC3JRJRc3:K|]\}}|D] }||k\ ywrr!rs r#rz"is_sptriangular..rrr)TTr)FFrL)rrZrrr offsetsrvmincoordsallkeys enumeraterowsr?r;rr4repeatarangediff) r@rrrupperr?r;rrs r#rrs*R QKAHH(RR R $ 4 aL xx5yy}}!#QYY]]_%999 U XX d !!#ddl%7%7%999 U /affh//4Q4Q1QQQ U R !&&0ARRR !&&0ARRe|hh GF F aALE5Q2 vc{6#'?3-3$;++--3$;++-U   99RYYq\2776? 3D D  *tt|((*E  *tt|((*Exx5e| %<r"c"t|r|jdvstdtdt |}|jdk(ret d|j jj t d|j j jfS|jdvrx|j|j}}t|dz }tjtj|tj||z }|jd k(r| }n|jd k(r |j d|j dz }nP|jd k(rA|j#Dcgc] \}}||z  c}}dgz}t| t |fSt tjj dt tj |jdfScc}}w) abReturn 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) )rKrLrrrzCspbandwidth needs sparse format not LIL and BSR. Converting to CSR.rMrNrrrJrrLrr)rrZrrr rvrritemr?r;rr4rrrrr)r@r?r;rgaprrs r#rr2sH QKAHH(KK R $ 4 aL xx51qyy}}++--.Aqyy}}7K7K7M0NNNxx>!((AII K!Oii ! bggfo6@ 88u $C U hhqkAHHQK' U #$668,41aA,s2Cy#c("" s   ""A &BFF3K,<,<,>(B BB-sH )NT)NNNNN)NNNNNNNN)TFFF)+warningsrrrnumpyr4r scipy.sparserrr r r r scipy.sparse._sputilsr rrr scipy.linalgrr> threadingrrascikits.umfpackr( ImportErrorlocalr%__all__ UserWarningrrrHrrrrrrrr!r"r#r s77HHNN$  %Y__   X  AMF D@ F04.2f7RJNGK_6DBJIN%*G TM`7CAHsBBB