Ugd,ddlmZmZmZddlZddlmZddlmZm Z m Z m Z m Z ddl mZmZddlmZddlZddlmZd Z ddlmZn #e$rd ZYnwxYwe Zgd ZGd d eZdZdZdZddZ dddde!fdZ" ddZ#dZ$ ddZ%dS))warncatch_warnings simplefilterN)asarray)issparseSparseEfficiencyWarning csc_matrixeyediags)is_pydata_spmatrixconvert_pydata_sparse_to_scipy) LinAlgError)_superluFT) use_solverspsolvespluspilu factorizedMatrixRankWarningspsolve_triangularceZdZdS)rN)__name__ __module__ __qualname__c/var/www/surfInsights/venv3-11/lib/python3.11/site-packages/scipy/sparse/linalg/_dsolve/linsolve.pyrrsDrrc d|vr|dtd<tr!d|vrtj|ddSdSdS)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)r!N)globalsr umfpack configure)kwargss rrrsizv"("6 ,M+v55f5J.KLLLLLLMM55rctjtjfdtjtjfdtjtjfdtjtjfdi}t t|jj}t t|jjj} |||f}n+#t$r}d|d|d}t||d}~wwxYw|d d z}tj |}tj |j tj |_ tj |jtj |_||fS) 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_familyrC_s9 RX !4 RX !4 IR & &FR- . .F%FF+, %%%T7=TTJPTTToo1$%AY_F IaLLE:ahbh777ELJqy999EM 5=s' B22 C<CCctjtjj}|jd|krt dt|j|kr,tj|j|krt d|j tjd}|j tjd}||fS)Nz#indptr values too large for SuperLUz$indices values too large for SuperLUFr9) r/iinfointcmaxr:r8shapeanyr6astype)r; max_valuer6r:s r_safe_downcast_indicesrNs!!%Ix|i>??? AG}y  6!)i' ( ( ECDD DirwU33G X__RW5_ 1 1F F?rc h t|}|r|jnd}t|}t|}t|r |jdvs&t |}t dtdt|}|st|}|j dkp|j dko|j ddk}| | }tj|j|j}|j|kr||}|j|kr||}|j \} } | | krt#d| | fd| |j d kr&t#d |j d |j d d|ot$}|r|r|r|} n|} t| |j } t*rt-d |jjdvrt#dt1|\} }t3j| } | t2j|| d}n|r|r|}d}|s|jdkrd}nd }|jtjd}|jtjd}tA|}tCj"| |j#|j$|||||\}}|d kr6t dtJd|&tj'|r|}ntQ|}|jdks5t|s&t dtdt |}g}g}g}tS|j dD]}|dd|gf}||}tj*|}|j d }|+||+tj,||tZ |+tj|||j tj.|}tj.|}tj.|}||||ff|j |j}|r|/|}|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 stacklevelrz!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 autoTransposeFrPrF)ColPerm)optionszMatrix is exactly singularzCspsolve is more efficient when sparse b is in the CSC matrix format)rJr.)0r __class__r rformatr rrrndimrJsum_duplicates _asfptyper/ promote_typesr.rLr8r toarrayravelnoScikit RuntimeErrorcharrCr#UmfpackContextlinsolve UMFPACK_Ar6rHr:dictrgssvnnzdatarfillnanrrange flatnonzeroappendfullint concatenatefrom_scipy_sparse) r;b permc_spec use_umfpackis_pydata_sparsepydata_sparse_cls b_is_sparse b_is_vector result_dtypeMNb_vec umf_familyumfxflagr6r:r[info Afactsolve data_segsrow_segscol_segsjbjxjwsegment_length sparse_data sparse_row sparse_cols rrrsAd*!,,'7A T&q))A&q))A QKK4AH66 qMM = $ 4 4 4 41++K  AJJFaKEQVq[%DQWQZ1_K A#AGQW55Lw, HH\ " "w, HH\ " " 7DAq QFaVFFFGGGAGAJVQWVVQRVVVWWW,*KI;{I;  IIKKEEEQW---3355  A?@@ @ 7>>GAtqyy13DQRSSSSrv GGII$AJH%%);A)>)>%3,<<<<qMMIHH171:&& C C qqq1#vY&&((..00Z^^N2&&!"""" E E EFFF  BqE!A!A!ABBBB.33K11J11J [:z*BC!"99A  ;%77:: Hrc t|r:t|dd}|}nt}t |r |jdks&t |}tdtd| | }|j \}}||krtdt|\} } t||||} || || d d krd | 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.]) clsc:|t|SNrvr ras rcsc_construct_funcz splu..csc_construct_func((Q88 8rrP&splu converted its input to CSC formatrRrScan only factor square matrices)DiagPivotThreshrZ PanelSizeRelaxNrZNATURALT SymmetricModeFrilur[r typeto_scipy_sparsetocscr rr]rrr_r`rJr8rNrjupdatergstrfrlrm) r;rxdiag_pivot_threshrelax panel_sizer[rrrr6r:_optionss rrrSsvH!('+Aww 9 9 9 9 9     % % ' '' QKK4AH-- qMM 5 $ 4 4 4 4 A 7DAq Q:;;;,Q//OGV$5z(777H    y(($(! >!QUAFGV-?#X 7 7 77rc t|r:t|dd} |}nt} t |r |jdks&t |}tdtd| | }|j \} } | | krtdt|\} } t|||||||}||||d d krd |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.]) rc:|t|Srrrs rrz!spilu..csc_construct_funcrrrPz'spilu converted its input to CSC formatrRrSr) ILU_DropRule ILU_DropTolILU_FillFactorrrZrrNrZrTrrr)r;drop_tol fill_factor drop_rulerxrrrr[rrrr6r:rs rrrsv!('+Aww 9 9 9 9 9     % % ' '' QKK4AH-- qMM 6 $ 4 4 4 4 A 7DAq Q:;;;,Q//OGV#.$5z(777H    y(($(! >!QUAFGV-?"H 6 6 66rc:tr&trtrt dt r jdks&ttdtd j j dvrtdt\}t!j|fd}|St'jS) 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.]) rUrPrrRrSrVrWctjdd5tj|d}dddn #1swxYwY|S)Nignore)divideinvalidTrX)r/errstatesolver#ri)rwresultr;rs rrzfactorized..solveRsHh??? P P7#4a$OO P P P P P P P P P P P P P P PMs$AA A )r rrr rdrerr]r rrr`r.rfr8rCr#rgnumericrr)r;rrrs` @rrrs7<!(     % % ' '  A?@@ @  8E 1 11 A 9(Q 8 8 8 8 KKMM 7>> 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 rrQTrPz?CSC or CSR matrix format is required. Converting to CSC matrix.rRrSz+A must be a square matrix but its shape is .rrNrz&A is singular: zero entry on diagonal.)rrRz)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 r-)r.r]zA is singular.rE)$r rrrr]rrrr r9rJr8rrsetdiagdiagonalr/rKrr r_ asanyarrayr^rar.float32rLr rgstrsrlrmr6r:reshapelen)r;rwlower overwrite_A overwrite_b unit_diagonaltransrrdiaginvdiagr~LUrrs rrr^sp!(     % % ' ' E{{qx5(( C  QKKAH-- N $ 4 4 4 4 qMM  FFHH 7DAqAvv D!' D D DFF F )      #: ; ; ; IIaLLL               zz|| 6$!)   :8:: :D& C<<E'NN"AAuW~~%(A aAvV B B B BDD DAGAJ :w : :/0w : : :   #B$4QWbj$I$I17SSLw, HH\ " "w, HH\ " "  FFHH   1v\ 2 2 2 e 4 4 4  ! nUqvqy!(qvqy!(  GAt ,*+++ !'/"Bs17||a/?(@BBB K Hs-+D$$D(+D()NT)NNNNNNNN)TFFF)&warningsrrrnumpyr/r scipy.sparserrr r r scipy.sparse._sputilsr r scipy.linalgrr9rrdscikits.umfpackr# ImportErrorr __all__ UserWarningrrrCrNrrjrrrrrrrrs=7777777777KKKKKKKKKKKKKKTTTTTTTT$$$$$$  %%%%%%%HHH\  6 6 6        @M@M@MD   D   @ @ @ @ Ftddffe7e7e7e7PJNGK^6^6^6^6B???DIN%*G G G G G G sAAA