xf~wdZgdZddlZddlmZddlZddlmZddl m Z ddl m Z dd l mZdd lmZd d d ddZdZdZdZdZd(dZeddded)dZeddded)dZeddd ed)d!Zed"d#d$ed)d%Ze d*d&Ze d+d'Zy),z,Iterative methods for solving linear systems)bicgbicgstabcgcgsgmresqmrN)dedent) _iterative)LinearOperator) make_system)_aligned_zeros) non_reentrantsdcz)frFDzC Parameters ---------- A : {sparse matrix, ndarray, LinearOperator}aXb : ndarray Right hand side of the linear system. Has shape (N,) or (N,1). Returns ------- x : ndarray The converged solution. info : integer Provides convergence information: 0 : successful exit >0 : convergence to tolerance not achieved, number of iterations <0 : illegal input or breakdown Other Parameters ---------------- x0 : ndarray Starting guess for the solution. tol, atol : float, optional Tolerances for convergence, ``norm(residual) <= max(tol*norm(b), atol)``. The default for ``atol`` is ``'legacy'``, which emulates a different legacy behavior. .. warning:: The default value for `atol` will be changed in a future release. For future compatibility, specify `atol` explicitly. maxiter : integer Maximum number of iterations. Iteration will stop after maxiter steps even if the specified tolerance has not been achieved. M : {sparse matrix, ndarray, LinearOperator} Preconditioner for A. The preconditioner should approximate the inverse of A. Effective preconditioning dramatically improves the rate of convergence, which implies that fewer iterations are needed to reach a given error tolerance. callback : function User-supplied function to call after each iteration. It is called as callback(xk), where xk is the current solution vector. cZtjj|}||kr|dfS|dfS)z; Successful termination condition for the solvers. r rnplinalgnorm)residualatolresids G/usr/lib/python3/dist-packages/scipy/sparse/linalg/_isolve/iterative.py _stoptestr Cs/ IINN8 $E }axaxc|.tjdj|tdd}t |}|dk(r"|}||kry|dk(r|S|t |zSt t ||t |zS)a Parse arguments for absolute tolerance in termination condition. Parameters ---------- tol, atol : object The arguments passed into the solver routine by user. bnrm2 : float 2-norm of the rhs vector. get_residual : callable Callable ``get_residual()`` that returns the initial value of the residual. routine_name : str Name of the routine. a scipy.sparse.linalg.{name} called without specifying `atol`. The default value will be changed in a future release. For compatibility, specify a value for `atol` explicitly, e.g., ``{name}(..., atol=0)``, or to retain the old behavior ``{name}(..., atol='legacy')``)namecategory stacklevellegacyexitr)warningswarnformatDeprecationWarningfloatmax)tolrbnrm2 get_residual routine_namers r _get_atolr4Ns" | 78>v.combinexs?YY &tX)F F +VF^ =>  r!)r@r>r? atol_defaultrAs``` r set_docstringrDws Nr!z7Use BIConjugate Gradient iteration to solve ``Ax = b``.zThe real or complex N-by-N matrix of the linear system. Alternatively, ``A`` can be a linear operator which can produce ``Ax`` and ``A^T x`` using, e.g., ``scipy.sparse.linalg.LinearOperator``.a1 Examples -------- >>> import numpy as np >>> from scipy.sparse import csc_matrix >>> from scipy.sparse.linalg import bicg >>> A = csc_matrix([[3, 2, 0], [1, -1, 0], [0, 5, 1]], dtype=float) >>> b = np.array([2, 4, -1], dtype=float) >>> x, exitCode = bicg(A, b) >>> print(exitCode) # 0 indicates successful convergence 0 >>> np.allclose(A.dot(x), b) True )r?c t|||\}}}t} || dz}|j|jc} |j|j} } tj j } tt| dz}fd}t||tjj|d}|dk(r |dfS|}d}d}td | zj }d}d}d }|} |}|||||||| \ }}}}}}}}| ||kDr|t|dz |dz | z}t|dz |dz | z}|dk(r ||n|dk(r'||xx|zcc<||xx|||zz cc<n|d k(r'||xx|zcc<||xx|| ||zz cc<nn|d k(r| ||||<nZ|dk(r| ||||<nF|dk(r$||xx|zcc<||xx|zz cc<n|d k(r|rd}d}t|||\}}d }/|dkDr ||k(r||ks|}||fS)N bicgrevcomcTtjjz SNrbmatvecxsrr2zbicg..get_residualyy~~fQi!m,,r!rr)rr dtypeTr$F)r lenrLrmatvec _type_convrRchargetattrr r4rrrrslicer )ArKx0r0maxiterMcallbackr postprocessnrWpsolverpsolveltrrevcomr2rndx1ndx2workijobinfoftflagiter_olditersclr1sclr2slice1slice2rLrMs ` @@rrrs.&aB2Aa!K AAB$hh OFGhh GF QWW\\ "C Z|!3 4F- S$ q 1< HD v~1~q  E D D !A#AGG ,D D D F E  !QeUD$d C >5%tT5%  EGO QKtAvtAvax(tAvtAvax( BJ# ai LE !L LE&f"66 6Lai LE !L LE'$v,"77 7Lai!$v,/DLai"4<0DLai LE !L LE&)O +Lai#DL$7KE4= @ axEW$etm q>4 r!zBUse BIConjugate Gradient STABilized iteration to solve ``Ax = b``.zThe real or complex N-by-N matrix of the linear system. Alternatively, ``A`` can be a linear operator which can produce ``Ax`` using, e.g., ``scipy.sparse.linalg.LinearOperator``.a Examples -------- >>> import numpy as np >>> from scipy.sparse import csc_matrix >>> from scipy.sparse.linalg import bicgstab >>> R = np.array([[4, 2, 0, 1], ... [3, 0, 0, 2], ... [0, 1, 1, 1], ... [0, 2, 1, 0]]) >>> A = csc_matrix(R) >>> b = np.array([-1, -0.5, -1, 2]) >>> x, exit_code = bicgstab(A, b) >>> print(exit_code) # 0 indicates successful convergence 0 >>> np.allclose(A.dot(x), b) True c t|||\}}}t} || dz}|j|j} tjj } t t| dz} fd} t||tjj| d}|dk(r |dfS|}d}d}td | zj }d}d}d }|} |}| ||||||| \ }}}}}}}}| ||kDr|t|dz |dz | z}t|dz |dz | z}|dk(r ||n|dk(r'||xx|zcc<||xx|||zz cc<nZ|d k(r| ||||<nF|d k(r$||xx|zcc<||xx|zz cc<n|dk(r|rd}d}t|||\}}d }|dkDr ||k(r||ks|}||fS)NrFbicgstabrevcomcTtjjz SrIrrJsrr2zbicgstab..get_residualrNr!rr)rr rOrQTrSrTr$Fr rVrLrXrRrYrZr r4rrrrr[r r\rKr]r0r^r_r`rrarbrcrerfr2rrgrhrirjrkrlrmrnrorprqrrrLrMs ` @@rrrs@4*!QA6Aq!Q  AAB$ XXF XXF QWW\\ "C Z'7!7 8F- S$ q 1< LD v~1~q  E D D !A#AGG ,D D D F E  !QeUD$d C >5%tT5%  EGO QKtAvtAvax(tAvtAvax( BJ# ai LE !L LE&f"66 6Lai!$v,/DLai LE !L LE&)O +Lai#DL$7KE43 6 axEW$etm q>4 r!z5Use Conjugate Gradient iteration to solve ``Ax = b``.zThe real or complex N-by-N matrix of the linear system. ``A`` must represent a hermitian, positive definite matrix. Alternatively, ``A`` can be a linear operator which can produce ``Ax`` using, e.g., ``scipy.sparse.linalg.LinearOperator``.a Examples -------- >>> import numpy as np >>> from scipy.sparse import csc_matrix >>> from scipy.sparse.linalg import cg >>> P = np.array([[4, 0, 1, 0], ... [0, 5, 0, 0], ... [1, 0, 3, 2], ... [0, 0, 2, 4]]) >>> A = csc_matrix(P) >>> b = np.array([-1, -0.5, -1, 2]) >>> x, exit_code = cg(A, b) >>> print(exit_code) # 0 indicates successful convergence 0 >>> np.allclose(A.dot(x), b) True c "t|||\}}}t} || dz}|j|j} tjj } t t| dz} fd} t||tjj| d}|dk(r |dfS|}d}d}td | zj }d}d}d }|} |}| ||||||| \ }}}}}}}}| ||kDr|t|dz |dz | z}t|dz |dz | z}|dk(r ||n|dk(r'||xx|zcc<||xx|||zz cc<n|d k(r| ||||<np|d k(r$||xx|zcc<||xx|zz cc<nG|d k(rB|rd}d}t|||\}}|dk(r%|dkDr z ||<t|||\}}d }|dkDr ||k(r||ks|}||fS)NrFcgrevcomcTtjjz SrIrrJsrr2zcg..get_residualTrNr!rr)rr rOr$rQTrSrTFrwrxs ` @@rrr.st6*!QA6Aq!Q  AAB$ XXF XXF QWW\\ "C Zz!1 2F- S$ q 1< FD v~1~q  E D D !A#AGG ,D D D F E  !QeUD$d C >5%tT5%  EGO QKtAvtAvax(tAvtAvax( BJ# ai LE !L LE&f"66 6Lai!$v,/DLai LE !L LE&)O +Lai#DL$7KE4qyUQY !6!9}V 'V d; t= @ axEW$etm q>4 r!z=Use Conjugate Gradient Squared iteration to solve ``Ax = b``.zThe real-valued N-by-N matrix of the linear system. Alternatively, ``A`` can be a linear operator which can produce ``Ax`` using, e.g., ``scipy.sparse.linalg.LinearOperator``.a Examples -------- >>> import numpy as np >>> from scipy.sparse import csc_matrix >>> from scipy.sparse.linalg import cgs >>> R = np.array([[4, 2, 0, 1], ... [3, 0, 0, 2], ... [0, 1, 1, 1], ... [0, 2, 1, 0]]) >>> A = csc_matrix(R) >>> b = np.array([-1, -0.5, -1, 2]) >>> x, exit_code = cgs(A, b) >>> print(exit_code) # 0 indicates successful convergence 0 >>> np.allclose(A.dot(x), b) True c dt|||\}}}t} || dz}|j|j} tjj } t t| dz} fd} t||tjj| d}|dk(r |dfS|}d}d}td | zj }d}d}d }|} |}| ||||||| \ }}}}}}}}| ||kDr|t|dz |dz | z}t|dz |dz | z}|dk(r ||n|dk(r'||xx|zcc<||xx|||zz cc<n|d k(r| ||||<np|d k(r$||xx|zcc<||xx|zz cc<nG|dk(rB|rd}d}t|||\}}|dk(r%|dkDr z ||<t|||\}}d }|dk(rtz |\}}|rd}|dkDr ||k(r||ks|}||fS)NrF cgsrevcomcTtjjz SrIrrJsrr2zcgs..get_residualrNr!rr)rr rOrvrQTrSrTr$Firw)r\rKr]r0r^r_r`rrarbrcrerfr2rrgrhrirjrkrlrmrnrorprqrrokrLrMs ` @@rrrs4*!QA6Aq!Q  AAB$ XXF XXF QWW\\ "C Z{!2 3F- S$ q 1< GD v~1~q  E D D !A#AGG ,D D D F E  !QeUD$d C >5%tT5%  EGO QKtAvtAvax(tAvtAvax( BJ# ai LE !L LE&f"66 6Lai!$v,/DLai LE !L LE&)O +Lai#DL$7KE4qyUQY !6!9}V 'V d; t= @ s{a&)mT2 r D axEW$etm q>4 r!c )*||}n+| tdd} tj| td|| tjdtd| d} | d vrtd | |d } t |||\}}*} t } || d z}|d }t || }|j)|j}t*jj}tt|dz}tjj}tjj|})*fd}t!|| ||d} | dk(r | *dfS|dk(r | dfSd}|t || |z z}tj"}tj"}d}d}t%d|z| z*j}t%|dzd|zdzz*j}d}d}d}|}|} d}!d}"d}# |}$|*|||||||||| \ *}}}}}}%}&}| dk(r ||$k7r|*t'|dz |dz | z}'t'|dz |dz | z}(|dk(r | dvr|"r|||z n | dk(r|*n|dk(r$||(xx|&zcc<||(xx|%)*zz cc<n|dk(r|||(||'<|!s| dk(rd}"d}!n|dk(r?||(xx|&zcc<||(xx|%)||'zz cc<|"rw| dvr |||z d}"|#dz}#n`|dk(r[|rd}d}t)||'| \}}|s||kDrt dd|z}nt+dd|z}|dk7r|t || |z z}n||z}|} d}| dk(r|#|kDr|}n|dk\r|| ks|}| *|fS) aU Use Generalized Minimal RESidual iteration to solve ``Ax = b``. Parameters ---------- A : {sparse matrix, ndarray, LinearOperator} The real or complex N-by-N matrix of the linear system. Alternatively, ``A`` can be a linear operator which can produce ``Ax`` using, e.g., ``scipy.sparse.linalg.LinearOperator``. b : ndarray Right hand side of the linear system. Has shape (N,) or (N,1). Returns ------- x : ndarray The converged solution. info : int Provides convergence information: * 0 : successful exit * >0 : convergence to tolerance not achieved, number of iterations * <0 : illegal input or breakdown Other parameters ---------------- x0 : ndarray Starting guess for the solution (a vector of zeros by default). tol, atol : float, optional Tolerances for convergence, ``norm(residual) <= max(tol*norm(b), atol)``. The default for ``atol`` is ``'legacy'``, which emulates a different legacy behavior. .. warning:: The default value for `atol` will be changed in a future release. For future compatibility, specify `atol` explicitly. restart : int, optional Number of iterations between restarts. Larger values increase iteration cost, but may be necessary for convergence. Default is 20. maxiter : int, optional Maximum number of iterations (restart cycles). Iteration will stop after maxiter steps even if the specified tolerance has not been achieved. M : {sparse matrix, ndarray, LinearOperator} Inverse of the preconditioner of A. M should approximate the inverse of A and be easy to solve for (see Notes). Effective preconditioning dramatically improves the rate of convergence, which implies that fewer iterations are needed to reach a given error tolerance. By default, no preconditioner is used. In this implementation, left preconditioning is used, and the preconditioned residual is minimized. callback : function User-supplied function to call after each iteration. It is called as `callback(args)`, where `args` are selected by `callback_type`. callback_type : {'x', 'pr_norm', 'legacy'}, optional Callback function argument requested: - ``x``: current iterate (ndarray), called on every restart - ``pr_norm``: relative (preconditioned) residual norm (float), called on every inner iteration - ``legacy`` (default): same as ``pr_norm``, but also changes the meaning of 'maxiter' to count inner iterations instead of restart cycles. restrt : int, optional, deprecated .. deprecated:: 0.11.0 `gmres` keyword argument `restrt` is deprecated infavour of `restart` and will be removed in SciPy 1.12.0. See Also -------- LinearOperator Notes ----- A preconditioner, P, is chosen such that P is close to A but easy to solve for. The preconditioner parameter required by this routine is ``M = P^-1``. The inverse should preferably not be calculated explicitly. Rather, use the following template to produce M:: # Construct a linear operator that computes P^-1 @ x. import scipy.sparse.linalg as spla M_x = lambda x: spla.spsolve(P, x) M = spla.LinearOperator((n, n), M_x) Examples -------- >>> import numpy as np >>> from scipy.sparse import csc_matrix >>> from scipy.sparse.linalg import gmres >>> A = csc_matrix([[3, 2, 0], [1, -1, 0], [0, 5, 1]], dtype=float) >>> b = np.array([2, 4, -1], dtype=float) >>> x, exitCode = gmres(A, b) >>> print(exitCode) # 0 indicates successful convergence 0 >>> np.allclose(A.dot(x), b) True zOCannot specify both restart and restrt keywords. Preferably use 'restart' only.zj'gmres' keyword argument 'restrt' is deprecated infavour of 'restart' and will be removed in SciPy 1.12.0.rS)r'a4scipy.sparse.linalg.gmres called without specifying `callback_type`. The default value will be changed in a future release. For compatibility, specify a value for `callback_type` explicitly, e.g., ``{name}(..., callback_type='pr_norm')``, or to retain the old behavior ``{name}(..., callback_type='legacy')``rTr%r()rMpr_normr(zUnknown callback_type: nonerF gmresrevcomcTtjjz SrIrrJsrr2zgmres..get_residualrNr!rr)rg?r rOrPrQTFrM)rr(r$g?gؗҜ4 r!c !"!td|\} "} ||t!drE!fd} !fd} !fd} !fd}tj| | }tj| |}n3d}tj||}tj||}t }||d z}t "j j}tt|d z}"fd }t||tjj|d }|d k(r | "dfS|}d}d}td|z"j }d}d}d}|} |}|"||||||| \ "}}}}}}}}| ||kDr|"t|dz |dz |z}t|dz |dz |z} |dk(r ||"n1|dk(r0|| xx|zcc<|| xx|j!||zz cc<n|dk(r0|| xx|zcc<|| xx|j#||zz cc<n|dk(r|j!|| ||<n|dk(r|j!|| ||<n|dk(r|j#|| ||<nl|dk(r|j#|| ||<nO|dk(r-|| xx|zcc<|| xx|j!"zz cc<n|dk(r|rd}d}t%|||\}}d}|dkDr ||k(r||ks|}| "|fS)a Use Quasi-Minimal Residual iteration to solve ``Ax = b``. Parameters ---------- A : {sparse matrix, ndarray, LinearOperator} The real-valued N-by-N matrix of the linear system. Alternatively, ``A`` can be a linear operator which can produce ``Ax`` and ``A^T x`` using, e.g., ``scipy.sparse.linalg.LinearOperator``. b : ndarray Right hand side of the linear system. Has shape (N,) or (N,1). Returns ------- x : ndarray The converged solution. info : integer Provides convergence information: 0 : successful exit >0 : convergence to tolerance not achieved, number of iterations <0 : illegal input or breakdown Other Parameters ---------------- x0 : ndarray Starting guess for the solution. tol, atol : float, optional Tolerances for convergence, ``norm(residual) <= max(tol*norm(b), atol)``. The default for ``atol`` is ``'legacy'``, which emulates a different legacy behavior. .. warning:: The default value for `atol` will be changed in a future release. For future compatibility, specify `atol` explicitly. maxiter : integer Maximum number of iterations. Iteration will stop after maxiter steps even if the specified tolerance has not been achieved. M1 : {sparse matrix, ndarray, LinearOperator} Left preconditioner for A. M2 : {sparse matrix, ndarray, LinearOperator} Right preconditioner for A. Used together with the left preconditioner M1. The matrix M1@A@M2 should have better conditioned than A alone. callback : function User-supplied function to call after each iteration. It is called as callback(xk), where xk is the current solution vector. See Also -------- LinearOperator Examples -------- >>> import numpy as np >>> from scipy.sparse import csc_matrix >>> from scipy.sparse.linalg import qmr >>> A = csc_matrix([[3, 2, 0], [1, -1, 0], [0, 5, 1]], dtype=float) >>> b = np.array([2, 4, -1], dtype=float) >>> x, exitCode = qmr(A, b) >>> print(exitCode) # 0 indicates successful convergence 0 >>> np.allclose(A.dot(x), b) True Nrcc(j|dSNleftrcrKA_s r left_psolvezqmr..left_psolve(syy6**r!c(j|dSNrightrrs r right_psolvezqmr..right_psolve+syy7++r!c(j|dSrrdrs r left_rpsolvezqmr..left_rpsolve.szz!F++r!c(j|dSrrrs r right_rpsolvezqmr..right_rpsolve1szz!G,,r!)rLrWc|SrIrB)rKs ridzqmr..id6sr!rF qmrrevcomcftjjjz SrI)rrrrL)r\rKrMsrr2zqmr..get_residualBs"yy~~ahhqkAo..r!rr)rr rO TrSrTr$rUrPrvF)r hasattrr shaperVrXrRrYrZr r4rrrrr[rLrWr )#r\rKr]r0r^M1M2r`rr_rarrrrrrbrerfr2rrgrhrirjrkrlrmrnrorprqrrrrMs#`` @@rrrsBH B)!T2q9Aq!Q  zbj 2h  + , , - \RB mTB B?BB?B AAB$ QWW\\ "C Z{!2 3F/ S$ q 1< GD v~1~q  E D D "Q$qww 'D D D F E  !QeUD$d C >5%tT5%  EGO QKtAvtAvax(tAvtAvax( BJ# ai LE !L LE!((4<"88 8Lai LE !L LE!))DL"99 9Lai99T&\2DLai99T&\2DLai::d6l3DLai::d6l3DLai LE !L LE!((1+- -Lai#DL$7KE4E H axEW$etm q>4 r!)0)Nh㈵>NNNN) NrNNNNNNN)NrNNNNN)r<__all__r*textwrapr numpyrrr scipy.sparse.linalg._interfacer utilsr scipy._lib._utilrscipy._lib._threadsafetyrrXr9r;r r4rDrrrrrrrBr!rrse2 69+23CS 1 0 % R&4RH9 *? +,? D9 0: 12: zF9  2? 34? DN9 0E 12E PPT04p p fJN Y Y r!