ge~w,dZgdZddlZddlmZddlZddlmZddl m Z ddl m Z dd l mZdd lmZd d d ddZdZdZdZdZd+dZeddded,dZeddded,d Zed!d"d#ed,d$Zed%d&d'ed,d(Ze d-d)Ze d.d*ZdS)/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. c\tj|}||kr|dfS|dfS)z; Successful termination condition for the solvers. r rnplinalgnorm)residualatolresids Elib/python3.11/site-packages/scipy/sparse/linalg/_isolve/iterative.py _stoptestr Cs2 INN8 $ $E }}axaxcF|2tjd|tdd}t |}|dkr,|}||krdS|dkr|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. Na 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.combinexsIYY &tX)F)F F +VF^^ =>>  r!)rBr@rA atol_defaultrCs``` r set_docstringrFws/ 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 )rAh㈵>c t|||\}}}t} || dz}|j|jc} |j|j} } tjj} tt| dz}fd}t||tj |d}|dkr |dfS|}d}d}td | zj }d}d}d }|} |}|||||||| \ }}}}}}}}|||kr |t|dz |dz | z}t|dz |dz | z}|dkr| |n|dkr3||xx|zcc<||xx|||zz cc<n|d kr3||xx|zcc<||xx|| ||zz cc<n|d kr| ||||<ns|dkr| ||||<nX|dkr-||xx|zcc<||xx|zz cc<n%|d kr|rd}d}t|||\}}d }}|dkr||kr||ks|}||fS)N bicgrevcomcZtjz SNrbmatvecxsrr2zbicg..get_residual#y~~ffQii!m,,,r!rr)rr dtypeTr$F)r lenrOrmatvec _type_convrUchargetattrr r4rrrrslicer )ArNx0r0maxiterMcallbackr postprocessnrZpsolverpsolveltrrevcomr2rndx1ndx2workijobinfoftflagiter_olditersclr1sclr2slice1slice2rOrPs ` @@rrrsT.&aB22Aa!K AAB$h OFGh GF QW\ "C Z|!3 4 4F------- S$ q 1 1< H HD v~~{1~~q  E D D !A#AG , , ,D D D F E 6!QeUD$d C C >5%tT5%  EGOO HQKKKtAvtAvax((tAvtAvax(( BJJ# aii LLLE !LLL LLLE&&f"6"66 6LLLLaii LLLE !LLL LLLE''$v,"7"77 7LLLLaii!6$v,//DLLaii"74<00DLLaii LLLE !LLL LLLE&&))O +LLLLaii #DL$77KE4=@ axxEW$$etmm ;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 Tt|||\}}}t} || dz}|j|j} tjj} t t| dz} fd} t||tj | d}|dkr |dfS|}d}d}td | zj }d}d}d }|} |}| ||||||| \ }}}}}}}}|||kr |t|dz |dz | z}t|dz |dz | z}|dkr| |n|dkr3||xx|zcc<||xx|||zz cc<ns|d kr| ||||<nX|d kr-||xx|zcc<||xx|zz cc<n%|dkr|rd}d}t|||\}}d }(|dkr||kr||ks|}||fS)NrIbicgstabrevcomcZtjz SrLrrMsrr2zbicgstab..get_residualrQr!rr)rr rRrTTrVrWr$Fr rYrOr[rUr\r]r r4rrrrr^r r_rNr`r0rarbrcrrdrerfrhrir2rrjrkrlrmrnrorprqrrrsrtrurOrPs ` @@rrrs4*!QA66Aq!Q  AAB$ XF XF QW\ "C Z'7!7 8 8F------- S$ q 1 1< L LD v~~{1~~q  E D D !A#AG , , ,D D D F E 6!QeUD$d C C >5%tT5%  EGOO HQKKKtAvtAvax((tAvtAvax(( BJJ# aii LLLE !LLL LLLE&&f"6"66 6LLLLaii!6$v,//DLLaii LLLE !LLL LLLE&&))O +LLLLaii #DL$77KE436 axxEW$$etmm ;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||tj | d}|dkr |dfS|}d}d}td | zj }d}d}d }|} |}| ||||||| \ }}}}}}}}|||kr |t|dz |dz | z}t|dz |dz | z}|dkr| |n|dkr3||xx|zcc<||xx|||zz cc<n|d kr| ||||<n|d kr-||xx|zcc<||xx|zz cc<n[|d krU|rd}d}t|||\}}|dkr0|dkr*z ||<t|||\}}d }^|dkr||kr||ks|}||fS)NrIcgrevcomcZtjz SrLrrMsrr2zcg..get_residualTrQr!rr)rr rRr$rTTrVrWFrzr{s ` @@rrr.s6*!QA66Aq!Q  AAB$ XF XF QW\ "C Zz!1 2 2F------- S$ q 1 1< F FD v~~{1~~q  E D D !A#AG , , ,D D D F E 6!QeUD$d C C >5%tT5%  EGOO HQKKKtAvtAvax((tAvtAvax(( BJJ# aii LLLE !LLL LLLE&&f"6"66 6LLLLaii!6$v,//DLLaii LLLE !LLL LLLE&&))O +LLLLaii #DL$77KE4qyyUQYY !66!99}V 'V d;; t=@ axxEW$$etmm ;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 t|||\}}}t} || dz}|j|j} tjj} t t| dz} fd} t||tj | d}|dkr |dfS|}d}d}td | zj }d}d}d }|} |}| ||||||| \ }}}}}}}}|||kr |t|dz |dz | z}t|dz |dz | z}|dkr| |n|dkr3||xx|zcc<||xx|||zz cc<n|d kr| ||||<n|d kr-||xx|zcc<||xx|zz cc<n[|dkrU|rd}d}t|||\}}|dkr0|dkr*z ||<t|||\}}d }^|dkr#tz |\}}|rd}|dkr||kr||ks|}||fS)NrI cgsrevcomcZtjz SrLrrMsrr2zcgs..get_residualrQr!rr)rr rRryrTTrVrWr$Firz)r_rNr`r0rarbrcrrdrerfrhrir2rrjrkrlrmrnrorprqrrrsrtruokrOrPs ` @@rrrsN4*!QA66Aq!Q  AAB$ XF XF QW\ "C Z{!2 3 3F------- S$ q 1 1< G GD v~~{1~~q  E D D !A#AG , , ,D D D F E 6!QeUD$d C C >5%tT5%  EGOO HQKKKtAvtAvax((tAvtAvax(( BJJ# aii LLLE !LLL LLLE&&f"6"66 6LLLLaii!6$v,//DLLaii LLLE !LLL LLLE&&))O +LLLLaii #DL$77KE4qyyUQYY !66!99}V 'V d;; t=@ s{{a&&))mT22 r  D axxEW$$etmm ;q>>4 r!c )*||}n/|tdd} tj| td|| tjdtd| d } | d vrtd | |d } t |||\}}*} t } || d z}|d}t || }|j)|j}t*j j }tt|dz}tj}tj|})*fd}t!|| ||d} | dkr | *dfS|dkr | dfSd}|t || |z z}tj}tj}d}d}t%d|z| z*j }t%|dzd|zdzz*j }d}d}d}|}|} d}!d}"d}# |}$|*|||||||||| \ *}}}}}}%}&}| dkr||$kr |*t'|dz |dz | z}'t'|dz |dz | z}(|dkr(| dvr|"r|||z n| dkr |*n9|dkr-||(xx|&zcc<||(xx|%)*zz cc<n|dkr!|||(||'<|!s| dkrd}"d}!n|dkrN||(xx|&zcc<||(xx|%)||'zz cc<|"r| dvr|||z d}"|#dz}#nv|dkrp|rd}d}t)||'| \}}|s||krt dd|z}nt+dd |z}|dkr|t || |z z}n||z}|} d}| d kr |#|kr|}n|dkr|| 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 NzOCannot 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.rV)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')``rWr%r()rPpr_normr(zUnknown callback_type: nonerI gmresrevcomcZtjz SrLrrMsrr2zgmres..get_residualrQr!rr)rg?r rRrSrTTFrP)rr(r$g?gؗҜ>4 r!c !"!td|\} "} ||t!drC!fd} !fd} !fd} !fd}tj| | }tj| |}n1d}tj||}tj||}t }||d z}t "jj}tt|d z}"fd }t||tj |d }|d kr | "dfS|}d}d}td|z"j}d}d}d}|} |}|"||||||| \ "}}}}}}}}|||kr |"t|dz |dz |z}t|dz |dz |z} |dkr| |"n|dkr>|| xx|zcc<|| xx|||zz cc<n9|dkr=|| xx|zcc<|| xx|||zz cc<n|dkr||| ||<n|dkr||| ||<n|dkr||| ||<n|dkr||| ||<nb|dkr7|| xx|zcc<|| xx|"zz cc<n%|dkr|rd}d}t%|||\}}d}|dkr||kr||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 Nrfc0|dSNleftrfrNA_s r left_psolvezqmr..left_psolve(syy6***r!c0|dSNrightrrs r right_psolvezqmr..right_psolve+syy7+++r!c0|dSrrgrs r left_rpsolvezqmr..left_rpsolve.szz!F+++r!c0|dSrrrs r right_rpsolvezqmr..right_rpsolve1szz!G,,,r!)rOrZc|SrLrD)rNs ridzqmr..id6sr!rI qmrrevcomcntjz SrL)rrrrO)r_rNrPsrr2zqmr..get_residualBs%y~~ahhqkkAo...r!rr)rr rR TrVrWr$rXrSryF)r hasattrr shaperYr[rUr\r]r r4rrrrr^rOrZr )#r_rNr`r0raM1M2rcrrbrdrrrrrrerhrir2rrjrkrlrmrnrorprqrrrsrtrurrPs#`` @@rrrsyH B)!T2q99Aq!Q  zbj 2h   @ + + + + + , , , , , , , , , , - - - - - \RRRB mTTTBB   B???BB???B AAB$ QW\ "C Z{!2 3 3F/////// S$ q 1 1< G GD v~~{1~~q  E D D "Q$qw ' 'D D D F E" 6!QeUD$d C C >5%tT5%  EGOO HQKKKtAvtAvax((tAvtAvax(( BJJ# aii LLLE !LLL LLLE!((4<"8"88 8LLLLaii LLLE !LLL LLLE!))DL"9"99 9LLLLaii99T&\22DLLaii99T&\22DLLaii::d6l33DLLaii::d6l33DLLaii LLLE !LLL LLLE!((1++- -LLLLaii #DL$77KE4E"H axxEW$$etmm ;q>>4 r!)r5r6)NrGNNNN) NrGNNNNNNN)NrGNNNNN)r>__all__r*textwrapr numpyrr5r scipy.sparse.linalg._interfacer utilsr scipy._lib._utilrscipy._lib._threadsafetyrr[r;r=r r4rFrrrrrrrDr!rrs22 6 6 6999999++++++2222223CS 1 1 0 % R&4&4&4RH9 *? ? ? +,? D9 0: : : 12: zF9  2? ? ? 34? DN9 0E E E 12E PPT04p p p p fJN Y Y Y Y Y Y r!