a Re~w @s0dZgdZddlZddlmZddlZddlmZddl m Z ddl m Z dd l mZdd lmZd d d ddZdZdZddZddZd4ddZedddded5dd Zed!d"d#ded6d$d%Zed&d'd(ded7d)d*Zed+d,d-ded8d.d/Zed9d0d1Zed:d2d3ZdS);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. cCs(tj|}||kr|dfS|dfSdS)z; Successful termination condition for the solvers. r rNnplinalgnorm)ZresidualatolresidrY/var/www/sunrise/env/lib/python3.9/site-packages/scipy/sparse/linalg/_isolve/iterative.py _stoptestCs rcCsz|dur$tjdj|dtddd}t|}|dkr`|}||krFdS|dkrR|S|t|Sntt||t|SdS) 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_residualZ routine_namerrrr _get_atolNs r/0csfdd}|S)Nc s*dtdddttf|_|S)N z z )join common_doc1replace common_doc2r__doc__)fnAinfofooterheaderrrcombinexs zset_docstring..combiner)r<r:r;Z atol_defaultr=rr9r set_docstringwsr>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;h㈵>c st|||\}}}t} |dur0| d}|j|j} |j|j} } tjj} tt| d}fdd}t ||t j |d}|dkr|dfS|}d}d }t d | jd }d}d}d }|}|}|||||||| \ }}}}}}}}|dur||kr|t|d|d| }t|d|d| }|d krj|durv|qvn|dkr|||9<|||||7<n|d kr|||9<|||| ||7<n|dkr| ||||<nz|dkr| ||||<n^|dkrF|||9<|||7<n*|d krp|r^d }d}t|||\}}d }q|dkr||kr||ks|}||fS)N Z bicgrevcomcstjSNrrbmatvecxrrr.szbicg..get_residualrr%rr dtypeTr F)r lenrDrmatvec _type_convrIchargetattrr r/rrrr slicer)ArCx0r,maxiterMcallbackr postprocessnrNpsolverpsolveltrrevcomr.rndx1ndx2workijobinfoftflagiter_olditersclr1sclr2slice1slice2rrBrrsj          rzBUse 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 s>t|||\}}}t} |dur0| d}|j|j} tjj} tt| d} fdd} t||t j | d}|dkr|dfS|}d}d }t d | jd }d}d}d }|}|}| ||||||| \ }}}}}}}}|dur ||kr |t |d|d| }t |d|d| }|d krX|dur|qn|dkr|||9<|||||7<nz|d kr| ||||<n^|dkr|||9<|||7<n*|dkr |rd }d}t|||\}}d }q|dkr2||kr2||ks2|}||fS)Nr@ZbicgstabrevcomcstjSrArrrBrrr.szbicgstab..get_residualrr%rr rFrHTrJrKr Fr rMrDrOrIrPrQr r/rrrr rRrrSrCrTr,rUrVrWrrXrYrZr\r]r.rr^r_r`rarbrcrdrerfrgrhrirrBrrs`        rz5Use 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 stt|||\}}}t} |dur0| d}|j|j} tjj} tt| d} fdd} t||t j | d}|dkr|dfS|}d}d }t d | jd }d}d}d }|}|}| ||||||| \ }}}}}}}}|dur ||kr |t |d|d| }t |d|d| }|d krX|durF|qFn|dkr|||9<|||||7<n|d kr| ||||<n|dkr|||9<|||7<n`|d kr@|rd }d}t|||\}}|dkr@|dkr@||<t|||\}}d }q|dkrh||krh||ksh|}||fS)Nr@ZcgrevcomcstjSrArrrBrrr.Tszcg..get_residualrr%rr rFr rHTrJrKFrkrlrrBrr.sf        rz=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 st|||\}}}t} |dur0| d}|j|j} tjj} tt| d} fdd} t||t j | d}|dkr|dfS|}d}d }t d | jd }d}d}d }|}|}| ||||||| \ }}}}}}}}|dur ||kr |t |d|d| }t |d|d| }|d krX|durF|qFn|dkr|||9<|||||7<n|d kr| ||||<n|dkr|||9<|||7<n`|dkr@|rd }d}t|||\}}|dkr@|dkr@||<t|||\}}d }q|dkrpt|\}}|rpd}|dkr||kr||ks|}||fS)Nr@Z cgsrevcomcstjSrArrrBrrr.szcgs..get_residualrr%rr rFrjrHTrJrKr Firk)rSrCrTr,rUrVrWrrXrYrZr\r]r.rr^r_r`rarbrcrdrerfrgrhriokrrBrrsn         rc ) s&|dur|}n&|dur tdnd} tj| tdd|durT| durTtjdtdd| dur`d } | d vrvtd | |durd } t|||\}}} t} |dur| d }|durd}t|| }|j|j}tj j }t t |d}t j}t j|}fdd}t|| ||d} | dkr@| dfS|dkrV| dfSd}|t|| |}t j}t j}d}d}td|| j d}t|dd|dj d}d}d}d}|}|} d}!d}"d}#|}$||||||||||| \ }}}}}}%}&}| dkr$||$kr$|t|d|d| }'t|d|d| }(|dkr| dvrx|"r|||n| dkr|qnH|dkr||(|&9<||(|%7<n|dkr|||(||'<|!s| dkrd}"d}!n|dkr\||(|&9<||(|%||'7<|"r| dvrN|||d}"|#d}#n~|dkr|rtd}d}t||'| \}}|s||krtdd|}ntd d!|}|dkr|t|| |}n||}|} d}| d kr|#|kr|}qq|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.rJ)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')``rKr!r$)rEpr_normr$zUnknown callback_type: noner@Z gmresrevcomcstjSrArrrBrrr.szgmres..get_residualrr%rg?r rFrGrHTFrE)rnr$r g?gؗҜ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 NrZcs |dSNleftrZrCA_rr left_psolve(szqmr..left_psolvecs |dSNrightrwrxryrr right_psolve+szqmr..right_psolvecs |dSrur[rxryrr left_rpsolve.szqmr..left_rpsolvecs |dSr|rrxryrr right_rpsolve1szqmr..right_rpsolve)rDrNcSs|SrArrxrrrid6szqmr..idr@Z qmrrevcomcstjSrA)rrrrDr)rSrCrErrr.Bszqmr..get_residualrr%rr rF TrJrKr rLrGrjF)r hasattrr shaperMrOrIrPrQr r/rrrr rRrDrNr)!rSrCrTr,rUZM1ZM2rWrrVrXr{r~rrrrYr\r]r.rr^r_r`rarbrcrdrerfrgrhrir)rSrzrCrErrsD           "        r)r0r1)Nr?NNNN)Nr?NNNN)Nr?NNNN)Nr?NNNN) Nr?NNNNNNN)Nr?NNNNN)r7__all__r&textwraprnumpyrr0r Zscipy.sparse.linalg._interfacer utilsr Zscipy._lib._utilr Zscipy._lib._threadsafetyrrOr4r6rr/r>rrrrrrrrrrsd      ) ) B=BH t