ó ʽ÷Xc @`s’ddlmZmZmZddlmZddlZddlmZm Z m Z m Z ddl m Z mZmZmZmZmZddlmZddlmZeZyddljZWnek rÚeZnXe Zd d d d d ddgZdefd„ƒYZ d„Z!d„Z"ded„Z$ddddde%ƒd„Z&ddddddddd„Z'd„Z(eeed„Z)dS(i(tdivisiontprint_functiontabsolute_import(twarnN(tasarraytemptytraveltnonzero(tisspmatrix_csctisspmatrix_csrt isspmatrixtSparseEfficiencyWarningt csc_matrixt csr_matrix(t LinAlgErrori(t_superlut use_solvertspsolvetsplutspilut factorizedtMatrixRankWarningtspsolve_triangularcB`seZRS((t__name__t __module__(((sB/tmp/pip-build-7oUkmx/scipy/scipy/sparse/linalg/dsolve/linsolve.pyRscK`s$d|kr |dtƒd|r>|jƒ}t}n|sët|ƒrYd} nd} td |ƒ} tj||j |j!|j"|j#|| d | ƒ\} }|dkrÓtdt$ƒ| j%t j&ƒn|r@| jƒ} q@nUt'|ƒ}t|ƒstdtƒt|ƒ}ng}g}g}x²t(|jdƒD]}|dd…|fj)jƒ}||ƒ}t j*|ƒ}|jd}|j+|ƒ|j+t j,|dt-ƒ|ƒ|j+t j||d|j ƒƒqEWt j.|ƒ}t j.|ƒ}t j.|ƒ}|j/|||ffd|jd|j ƒ} | S(s1Solve 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. s.spsolve requires A be CSC or CSR matrix formatiis$matrix must be square (has shape %s)is)matrix - rhs dimension mismatch (%s - %s)R"sScikits.umfpack not installed.tdDsZconvert matrix data to double, please, using .astype(), or set linsolve.useUmfpack = Falset autoTransposetColPermtoptionssMatrix is exactly singularsCspsolve is more efficient when sparse b is in the CSC matrix formatNtshape(0RR R RR R RtndimR-t sort_indicestasfptypetnpt promote_typesR"tastypet ValueErrorRttoarrayRtnoScikitt RuntimeErrorR#tumfpacktUmfpackContextR(tlinsolvet UMFPACK_AtTruetFalsetdictRtgssvtnnztdataR$tindptrRtfilltnanRtrangeR%t flatnonzerotappendtonestintt concatenatet __class__(R%tbt permc_spect use_umfpackt b_is_sparset b_is_vectort result_dtypetMtNtb_vectumftxtflagR,tinfot Afactsolvet data_segstrow_segstcol_segstjtbjtxjtwtsegment_lengtht sparse_datat sparse_rowt sparse_col((sB/tmp/pip-build-7oUkmx/scipy/scipy/sparse/linalg/dsolve/linsolve.pyR>sŽ%   1           !        'c C`sÖt|ƒs(t|ƒ}tdtƒn|jƒ|jƒ}|j\}}||krhtdƒ‚ntd|d|d|d|ƒ} |d k r¥| j |ƒnt j ||j |j|j|jdtd| ƒS( sú 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]_ drop_tol : float, optional (deprecated) No effect. 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/ ssplu requires CSC matrix formatscan only factor square matricestDiagPivotThreshR+t PanelSizetRelaxtiluR,N(RR RR R/R0R-R4R>tNonetupdateRtgstrfR@RAR$RBR=( R%RMtdiag_pivot_threshtdrop_toltrelaxt panel_sizeR,RRRSt_options((sB/tmp/pip-build-7oUkmx/scipy/scipy/sparse/linalg/dsolve/linsolve.pyRÄs7      $c C`sèt|ƒs(t|ƒ}tdtƒn|jƒ|jƒ}|j\} } | | krhtdƒ‚ntd|d|d|d|d|d|d |ƒ} |d k r·| j |ƒnt j | |j |j|j|jd td | ƒS( s 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. ssplu requires CSC matrix formatscan only factor square matricest ILU_DropRulet ILU_DropToltILU_FillFactorReR+RfRgRhR,N(RR RR R/R0R-R4R>RiRjRRkR@RAR$RBR<( R%Rmt fill_factort drop_ruleRMRlRnRoR,RRRSRp((sB/tmp/pip-build-7oUkmx/scipy/scipy/sparse/linalg/dsolve/linsolve.pyRs +       $c`sÃtr²trtdƒ‚ntˆƒsCtˆƒ‰tdtƒnˆjƒˆjƒ‰ˆj j dkrzt dƒ‚nt j tˆƒƒ‰ˆjˆƒ‡‡fd†}|StˆƒjSdS(s 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.]) sScikits.umfpack not installed.ssplu requires CSC matrix formatR)sZconvert matrix data to double, please, using .astype(), or set linsolve.useUmfpack = Falsec`sˆjtjˆ|dtƒS(NR*(tsolveR8R;R<(RL(R%RU(sB/tmp/pip-build-7oUkmx/scipy/scipy/sparse/linalg/dsolve/linsolve.pyRv}sN(RR6R7RR RR R/R0R"R#R4R8R9R(tnumericRRv(R%Rv((R%RUsB/tmp/pip-build-7oUkmx/scipy/scipy/sparse/linalg/dsolve/linsolve.pyRNs     cC`s~t|ƒs(tdtƒt|ƒ}n|s=|jƒ}n|jd|jdkrrtdj|jƒƒ‚n|jƒ|j ƒt j |ƒ}|j d kr¿tdj|jƒƒ‚n|jd|jdkrútdj|j|jƒƒ‚n|r |}n |jƒ}|r0t t|ƒƒ}nt t|ƒdddƒ}x+|D]#}|j|}|j|d} |r| d} t|| dƒ} n|} t|d| ƒ} | |ksÕ|j| |krítd j|ƒƒ‚n|j| |kr"td j||j| ƒƒ‚n|j| } |j| } ||ct j|| j| ƒ8<||c|j| RRRR(((sB/tmp/pip-build-7oUkmx/scipy/scipy/sparse/linalg/dsolve/linsolve.pyts0 ".     †I ? 7