3 OdR@sddlmZddlZddlmZddlmZmZmZm Z m Z m Z ddl m Z ddlmZddlZddlmZd ZyddljZWnek rd ZYnXe Zd d d ddddgZGdddeZdd ZddZddd Zddddefdd ZdddZ ddZ!dddZ"dS))warnN)asarray)isspmatrix_cscisspmatrix_csr isspmatrixSparseEfficiencyWarning csc_matrix csr_matrix)is_pydata_spmatrix) LinAlgError)_superluFT use_solverspsolvespluspilu factorizedMatrixRankWarningspsolve_triangularc@s eZdZdS)rN)__name__ __module__ __qualname__rrW/var/www/html/virt/lib64/python3.6/site-packages/scipy/sparse/linalg/dsolve/linsolve.pyrscKs6d|kr|dtd<tr2d|kr2tj|dddS)ac Select default sparse direct solver to be used. Parameters ---------- useUmfpack : bool, optional Use UMFPACK 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. useUmfpackassumeSortedIndices)rN)globalsrumfpack configure)kwargsrrrrs c Cstjtjfdtjtjfdtjtjfdtjtjfdi}tj|jj}tj|jjj}y|||f}Wn(t k rd||f}t |YnX|dd}t j |}tj |j dtjd |_ tj |jdtjd |_||fS) z8Get umfpack family string given the sparse matrix dtype.ZdiZzidlZzlzmonly float64 or complex128 matrices with int32 or int64 indices are supported! (got: matrix: %s, indices: %s)rlF)copydtype)npfloat64Zint32Z complex128Zint64Z sctypeDictr#nameindicesKeyError ValueErrorr"arrayindptr)AZ _familiesZf_typeZi_typefamilymsgZA_newrrr_get_umf_family<s"      r/c CsDt|r|jj}t|p"t|s6t|}tdtt|pDt|}|sRt |}|j dkpr|j dkor|j ddk}|j |j }tj|j|j}|j|kr|j|}|j|kr|j|}|j \}}||krtd||ff||j dkrtd|j |j df|ot}|r|r|r.|j} n|} t | |jdj} trRtd|jjd krhtd t|\} }tj| } | jtj|| d d } n|r|r|j}d }|s*t|rd} nd} t|d}tj ||j!|j"|j#|j$|| |d\} }|dkrtdt%| j&tj'|r@| j} nt(|}t|pBt|sXtdtt|}g}g}g}xt)|j dD]z}tj |dd|fj*j}||}tj+|}|j d}|j,||j,tj-||t.d|j,tj |||jdqtWtj/|}tj/|}tj/|}|j0|||ff|j |jd} t|r@|j0| } | S)aSolve 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 use_umfpack : bool, optional if True (default) then use umfpack for the solution. This is only referenced if b is a vector and ``scikit-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. Examples -------- >>> 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).todense(), B.todense()) True z.spsolve requires A be CSC or CSR matrix formatr z$matrix must be square (has shape %s)rz)matrix - rhs dimension mismatch (%s - %s))r#zScikits.umfpack not installed.dDzZconvert matrix data to double, please, using .astype(), or set linsolve.useUmfpack = FalseT) autoTransposeF)ColPerm)optionszMatrix is exactly singularzCspsolve is more efficient when sparse b is in the CSC matrix formatN)shaper#)1r to_scipy_sparsetocscrrrrrrrndimr5sum_duplicatesasfptyper$Z promote_typesr#astyper)rZtoarrayZravelnoScikit RuntimeErrorcharr/rUmfpackContextZlinsolve UMFPACK_Adictr Zgssvnnzdatar'r+rfillnanrrangeZtodenseZ flatnonzeroappendfullintZ concatenate __class__)r,b permc_specZ use_umfpackZ b_is_sparseZ b_is_vectorZ result_dtypeMNZb_vec umf_familyumfxflagr4infoZ AfactsolveZ data_segsZrow_segsZcol_segsjZbjZxjwZsegment_lengthZ sparse_dataZ sparse_rowZ sparse_colrrrr[s0 "                            c Cst|r(t|ddd}|jj}nt}t|sFt|}tdt|j|j }|j \}}||krpt dt ||||d} |dk r| j || dd krd | d <tj||j|j|j|j|d | d S)a^ Compute the LU decomposition of a sparse, square matrix. Parameters ---------- A : sparse matrix Sparse matrix to factorize. Should be in CSR or CSC format. 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 http://crd.lbl.gov/~xiaoye/SuperLU/ Examples -------- >>> 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.]) )clscWs |t|S)N)r)rVarrr7szsplu..zsplu requires CSC matrix formatzcan only factor square matrices)DiagPivotThreshr3 PanelSizeRelaxNr3NATURALT SymmetricModeF)csc_construct_funcilur4)r typer6r7rrrrr9r:r5r)rAupdater gstrfrBrCr'r+) r,rLdiag_pivot_threshrelax panel_sizer4r^rMrN_optionsrrrrs*B     c Cst|r(t|ddd} |jj}nt} t|sFt|}tdt|j|j }|j \} } | | krpt dt |||||||d} |dk r| j || dd krd | d <tj| |j|j|j|j| d | d S) aB 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 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 -------- >>> 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.]) )rVcWs |t|S)N)r)rVrWrrrrXszspilu..zsplu requires CSC matrix formatzcan only factor square matrices)Z ILU_DropRuleZ ILU_DropTolZILU_FillFactorrYr3rZr[Nr3r\Tr])r^r_r4)r r`r6r7rrrrr9r:r5r)rArar rbrBrCr'r+) r,Zdrop_tolZ fill_factorZ drop_rulerLrcrdrer4r^rMrNrfrrrrVs.9     cstrjjtrtr$tdts>ttdt j j j dkrZt dt\}tj|jfdd}|StjSdS)a Return a function for solving a sparse linear system, with A pre-factorized. Parameters ---------- A : (N, N) array_like Input. 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 -------- >>> from scipy.sparse.linalg import factorized >>> A = np.array([[ 3. , 2. , -1. ], ... [ 2. , -2. , 4. ], ... [-1. , 0.5, -1. ]]) >>> solve = factorized(A) # Makes LU decomposition. >>> rhs1 = np.array([1, -2, 0]) >>> solve(rhs1) # Uses the LU factors. array([ 1., -2., -2.]) zScikits.umfpack not installed.zsplu requires CSC matrix formatr1zZconvert matrix data to double, please, using .astype(), or set linsolve.useUmfpack = Falsecsjtj|ddS)NT)r2)solverr@)rK)r,rPrrrgszfactorized..solveN)r r6r7rr<r=rrrrr:r#r>r)r/rr?numericrrg)r,rOrgr)r,rPrrs"      cCs,t|r|jj}t|s0tdtt|}n |s<|j}|jd|jdkr`t dj |j|j t j |}|jdkrt dj |j|jd|jdkrt dj |j|jt j|j|t j}|rt j|j|dd r|}nt d j |j|n|j|d d }|rtt|}ntt|ddd}x|D]} |j| } |j| d} |rl| d} t| | d} n| } t| d| } | r| | ks|j| | krtd j | |j| | krtdj | |j| |j| }|j| }|| t j||j|8<|s2|| |j| <q2W|S)a Solve the equation `A x = b` for `x`, assuming A is a triangular matrix. Parameters ---------- A : (M, M) sparse matrix A sparse square triangular matrix. Should be in CSR 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`. The indices of `A` are going to be sorted and zero entries are going to be removed. 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 and will not be referenced. .. 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 -------- >>> 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 z8CSR matrix format is required. Converting to CSR matrix.rr z.A must be a square matrix but its shape is {}.r0z,b must have 1 or 2 dims but its shape is {}.zThe size of the dimensions of A must be equal to the size of the first dimension of b but the shape of A is {} and the shape of b is {}.Z same_kind)Zcastingz5Cannot overwrite b (dtype {}) with result of type {}.T)r"z#A is singular: diagonal {} is zero.z*A is not triangular: A[{}, {}] is nonzero.)r r0ri)r r6Ztocsrrrrr r"r5r)formatr9r$Z asanyarrayr8Z result_typerCr%Zcan_castr#r;rFlenr+slicer'r dotT)r,rKlowerZ overwrite_AZ overwrite_bZ unit_diagonalZx_dtyperQZ row_indicesiZ indptr_startZ indptr_stopZA_diagonal_index_row_iZA_off_diagonal_indices_row_iZA_column_indices_in_row_iZA_values_in_row_irrrrsj8         )NT)NNNNNNNN)TFFF)#warningsrZnumpyr$rZ scipy.sparserrrrrr Zscipy.sparse.sputilsr Z scipy.linalgr r"r r<Zscikits.umfpackr ImportErrorr__all__ UserWarningrrr/rrArrrrrrrrs6         a Z: