_MhE ddlZddlZddlmZddlmZddlmZgdZ dd Z ddddddd d Z ddddddd d Z ddddddd d Z ddddddd dZddddddddddZdddddddddZdS)N)LinearOperator) make_system)get_lapack_funcs)bicgbicgstabcgcgsgmresqmrh㈵>c|dks||dkrd|d|d}t|tt|t|t|z}||fS)z= A helper function to handle tolerance normalization legacyNrz'scipy.sparse.linalg.z' called with invalid `atol`=z5; if set, `atol` must be a real, non-negative number.) ValueErrormaxfloat)nameb_normatolrtolmsgs e/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/scipy/sparse/linalg/_isolve/iterative.py_get_atol_rtolr s x4<4!88EtEE$EEEoo uT{{E$KK%--7 8 8D :)rrmaxiterMcallbackc,t||||\}}}}} tj|} t d| ||\}} | dkr | |dfSt |} tj|r tjn tj} || dz}|j |j }}|j |j }}tj |j j jdz}d\}}}|r|||z n|}|}t#|D]D}tj||kr| |dfcS||}||}| ||}tj||kr| dfcS|dkr,||z }||z}||z }||z}||z }n(|}|}||}||}| ||}|dkr| |dfcS||z } || |zz }|| |zz}|| |zz}|}|r ||F| ||fS) a Use BIConjugate Gradient iteration to solve ``Ax = b``. Parameters ---------- A : {sparse array, 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`` 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). x0 : ndarray Starting guess for the solution. rtol, atol : float, optional Parameters for the convergence test. For convergence, ``norm(b - A @ x) <= max(rtol*norm(b), atol)`` should be satisfied. The default is ``atol=0.`` and ``rtol=1e-5``. maxiter : integer Maximum number of iterations. Iteration will stop after maxiter steps even if the specified tolerance has not been achieved. M : {sparse array, ndarray, LinearOperator} Preconditioner for `A`. It should approximate the inverse of `A` (see Notes). 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. Returns ------- x : ndarray The converged solution. info : integer Provides convergence information: 0 : successful exit >0 : convergence to tolerance not achieved, number of iterations <0 : parameter breakdown Notes ----- The preconditioner `M` should be a matrix such that ``M @ A`` has a smaller condition number than `A`, see [1]_ . References ---------- .. [1] "Preconditioner", Wikipedia, https://en.wikipedia.org/wiki/Preconditioner .. [2] "Biconjugate gradient method", Wikipedia, https://en.wikipedia.org/wiki/Biconjugate_gradient_method Examples -------- >>> import numpy as np >>> from scipy.sparse import csc_array >>> from scipy.sparse.linalg import bicg >>> A = csc_array([[3, 2, 0], [1, -1, 0], [0, 5, 1.]]) >>> b = np.array([2., 4., -1.]) >>> x, exitCode = bicg(A, b, atol=1e-5) >>> print(exitCode) # 0 indicates successful convergence 0 >>> np.allclose(A.dot(x), b) True rrN )NNN)rnplinalgnormrlen iscomplexobjvdotdotmatvecrmatvecfinfodtypecharepsanycopyrangeabsconj)!Abx0rrrrrx postprocessbnrm2_ndotprodr+r,psolverpsolverhotolrho_prevpptilderrtilde iterationzztilderho_curbetaqqtildervalphas! rrrsB*!QA66Aq!Q INN1  EVUD$77GD! zz{1~~q   AA++7bggGB$h GFh GF Xagl # # ' *F+Ha.FF1II affhhA VVXXF7^^('(' 9>>!  t # #;q>>1$ $ $ $ F1II'&!$$ 6'??V # ## # # # q==X%D IA FA diikk !F f FFA[[]]F F1II WVQ   77;q>>3& & & &"  U1W  U1W %**,,v%%   HQKKK{1~~w&&rc t||||\}}}}} tj|} t d| ||\}} | dkr | |dfSt |} tj|r tjn tj} || dz}|j }|j }tj |j j j dz}|}d\}}}}}|r|||z n|}|}t!|D]}tj||kr| |dfcS| ||}tj||kr| |dfcS|dkrEtj||kr| |dfcS||z ||z z}|||zz}||z}||z }n(tj|}|}||}||}| ||}|dkr| |dfcS||z }|||zz}|dd|dd<tj||kr|||zz }| |dfcS||}||} | | || | | z }|||zz }|||zz }||| zz}|}|r ||| ||fS) a. Use BIConjugate Gradient STABilized iteration to solve ``Ax = b``. Parameters ---------- A : {sparse array, 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`` 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). x0 : ndarray Starting guess for the solution. rtol, atol : float, optional Parameters for the convergence test. For convergence, ``norm(b - A @ x) <= max(rtol*norm(b), atol)`` should be satisfied. The default is ``atol=0.`` and ``rtol=1e-5``. maxiter : integer Maximum number of iterations. Iteration will stop after maxiter steps even if the specified tolerance has not been achieved. M : {sparse array, ndarray, LinearOperator} Preconditioner for `A`. It should approximate the inverse of `A` (see Notes). 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. Returns ------- x : ndarray The converged solution. info : integer Provides convergence information: 0 : successful exit >0 : convergence to tolerance not achieved, number of iterations <0 : parameter breakdown Notes ----- The preconditioner `M` should be a matrix such that ``M @ A`` has a smaller condition number than `A`, see [1]_ . References ---------- .. [1] "Preconditioner", Wikipedia, https://en.wikipedia.org/wiki/Preconditioner .. [2] "Biconjugate gradient stabilized method", Wikipedia, https://en.wikipedia.org/wiki/Biconjugate_gradient_stabilized_method Examples -------- >>> import numpy as np >>> from scipy.sparse import csc_array >>> 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_array(R) >>> b = np.array([-1, -0.5, -1, 2]) >>> x, exit_code = bicgstab(A, b, atol=1e-5) >>> print(exit_code) # 0 indicates successful convergence 0 >>> np.allclose(A.dot(x), b) True rrNr r!NNNNNr"r#rr$r%r&rr'r(r)r*r+r-r.r/r0r1r2r3r4 empty_like)!r6r7r8rrrrrr9r:r;r<r=r>r+r?rAomegatolrBomegarOrCvrErFrGrhorKsphatrNshatts! rrrsfL*!QA66Aq!Q INN1  EZd;;GD! zz{1~~q   AA++7bggGB$ XF XFXagl # # ' *FH$@ HeUAq.FF1II affhhA VVXXF7^^.'.' 9>>!  t # #;q>>1$ $ $ $gfa   6#;;  ;q>>3& & & & q==ve}}x''"{1~~s****(Nuu}5D qLA IA FAA a  AAvayy F4LL WVQ   77;q>>3& & & &b U1W t!!! 9>>!  t # # tOA;q>>1$ $ $ $vayy F4LL1 1 - U4Z U4Z U1W    HQKKK{1~~w&&rct||||\}}}}} tj|} t d| ||\}} | dkr | |dfSt |} || dz}tj|r tjn tj} |j }|j }| r|||z n| }d\}}t|D]}tj||kr| |dfcS||}| ||}|dkr||z }||z}||z }n#tj |}|dd|dd<||}|| ||z }|||zz }|||zz}|}|r ||| ||fS)aL Use Conjugate Gradient iteration to solve ``Ax = b``. Parameters ---------- A : {sparse array, ndarray, LinearOperator} The 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``. b : ndarray Right hand side of the linear system. Has shape (N,) or (N,1). x0 : ndarray Starting guess for the solution. rtol, atol : float, optional Parameters for the convergence test. For convergence, ``norm(b - A @ x) <= max(rtol*norm(b), atol)`` should be satisfied. The default is ``atol=0.`` and ``rtol=1e-5``. maxiter : integer Maximum number of iterations. Iteration will stop after maxiter steps even if the specified tolerance has not been achieved. M : {sparse array, ndarray, LinearOperator} Preconditioner for `A`. `M` must represent a hermitian, positive definite matrix. It should approximate the inverse of `A` (see Notes). 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. Returns ------- x : ndarray The converged solution. info : integer Provides convergence information: 0 : successful exit >0 : convergence to tolerance not achieved, number of iterations Notes ----- The preconditioner `M` should be a matrix such that ``M @ A`` has a smaller condition number than `A`, see [2]_. References ---------- .. [1] "Conjugate Gradient Method, Wikipedia, https://en.wikipedia.org/wiki/Conjugate_gradient_method .. [2] "Preconditioner", Wikipedia, https://en.wikipedia.org/wiki/Preconditioner Examples -------- >>> import numpy as np >>> from scipy.sparse import csc_array >>> 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_array(P) >>> b = np.array([-1, -0.5, -1, 2]) >>> x, exit_code = cg(A, b, atol=1e-5) >>> print(exit_code) # 0 indicates successful convergence 0 >>> np.allclose(A.dot(x), b) True r rNr )NN)rr$r%r&rr'r(r)r*r+r1r2r3rS)r6r7r8rrrrrr9r:r;r<r=r>r+r?rErBrCrGrHrJrKrLrOs rr r 1sL*!QA66Aq!Q INN1  ET5$55GD! zz{1~~q   AAB$++7bggG XF XF.FF1II affhhAKHa7^^'' 9>>!  t # #;q>>1$ $ $ $ F1II'!Q-- q==X%D IA FAA a  AQQQ4AaaaD F1II''!Q--' U1W  U1W    HQKKK{1~~w&&rct||||\}}}}} tj|} t d| ||\}} | dkr | |dfSt |} tj|r tjn tj} || dz}|j }|j }tj |j j j dz}|r|||z n|}|}tj|}|dkrd}d\}}}}t!|D]Z}tj|}||kr| |dfcS| ||}tj||kr| dfcS|dkr1||z }|dd|dd<|||zz }||z}||z }||z}||z }n<|}|}tj|}||}||}| ||}|dkr| |d fcS||z }|dd|dd<|||zz}|||z} ||| zz }|||z }|}|r ||\| ||fS) a Use Conjugate Gradient Squared iteration to solve ``Ax = b``. Parameters ---------- A : {sparse array, ndarray, LinearOperator} The 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``. b : ndarray Right hand side of the linear system. Has shape (N,) or (N,1). x0 : ndarray Starting guess for the solution. rtol, atol : float, optional Parameters for the convergence test. For convergence, ``norm(b - A @ x) <= max(rtol*norm(b), atol)`` should be satisfied. The default is ``atol=0.`` and ``rtol=1e-5``. maxiter : integer Maximum number of iterations. Iteration will stop after maxiter steps even if the specified tolerance has not been achieved. M : {sparse array, ndarray, LinearOperator} Preconditioner for ``A``. It should approximate the inverse of `A` (see Notes). 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. Returns ------- x : ndarray The converged solution. info : integer Provides convergence information: 0 : successful exit >0 : convergence to tolerance not achieved, number of iterations <0 : parameter breakdown Notes ----- The preconditioner `M` should be a matrix such that ``M @ A`` has a smaller condition number than `A`, see [1]_. References ---------- .. [1] "Preconditioner", Wikipedia, https://en.wikipedia.org/wiki/Preconditioner .. [2] "Conjugate gradient squared", Wikipedia, https://en.wikipedia.org/wiki/Conjugate_gradient_squared_method Examples -------- >>> import numpy as np >>> from scipy.sparse import csc_array >>> 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_array(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 r rNr r!r)NNNNr"r#rR)!r6r7r8rrrrrr9r:r;r<r=r>r+r?rArErFbnormrBrCurLrGrnormrJrKrYvhatrNrOuhats! rr r sJ*!QA66Aq!Q INN1  EUE466GD! zz{1~~q   AA++7bggGB$ XF XF Xagl # # ' *F.FF1II affhhA VVXXF INN1  E zz/HaA7^^7'7'  q!! 4<<;q>>1$ $ $ $'&!$$ 6'??V # ## # # # q==X%DQQQ4AaaaD aKA IA FA IA FAAAA a  Avayyvd|| WVT " " 77;q>>3& & & &" t!!! U4Zva!e}} U4Z q M   HQKKK{1~~w&&r)rrrestartrrr callback_typec 6 | | d} tj| td| d} | dvrtd| |d} t ||||\}}} }} |j} |j}t |}tj |}td|||\}}|d kr | |d fStj | j j j}tj| r tjn tj}||d z}|d }t%||}tj ||}d }|t%|||z z}d }t'd| j }tj|dz|g| j }tj||dzg| j }tj|dg| j }d }t-|D]}|d krh| r|| | z n|}tj ||kr| | d fcS|||d ddf<tj |d ddf}|d ddfxxd|z zcc<tj|dz| j } || d <d}!t-|D]}"| ||"ddf}#||#}$tj |$}%t-|"dzD]1}&|||&ddf|$}|||"|&f<|$|||&ddfzz}$2tj |$}'|'||"|"dzf<|$dd||"dzddf<|'||%zkr d ||"|"dzf<d}!n||"dzddfxxd|'z zcc<t-|"D][}&||&d f||&df})}(||"|&|&dzgf\}*}+|(|*z|)|+zz|) |*z|(|+zzg||"|&|&dzgf<\|||"|"f||"|"dzf\}(})},|(|)g||"ddf<|,d f||"|"|"dzgf<tj|) | |"z}|(| |"z|g| |"|"dzg<tj|}|dz }| dvr|||z | dkr||krn ||ks|!rn||"|"fd krd | |"<tj|"dzg| j }-| d|"dz|-dd<t-|"d dD]M}&|-|&d kr?|-|&xx||&|&fzcc<|-|&}|-d|&xx|||&d|&fzzcc<N|-d d kr|-d xx|dzcc<| |-|d|"dzddfzz } || | z }tj |}.| dkr||kr| | |.|krd n|fcS| dkr || |.|krnI|!rnE||krt9|d|z}nt%d d|z}|t%|||.z z}|.|krd n|}/| | |/fS)ae Use Generalized Minimal RESidual iteration to solve ``Ax = b``. Parameters ---------- A : {sparse array, 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). x0 : ndarray Starting guess for the solution (a vector of zeros by default). atol, rtol : float Parameters for the convergence test. For convergence, ``norm(b - A @ x) <= max(rtol*norm(b), atol)`` should be satisfied. The default is ``atol=0.`` and ``rtol=1e-5``. restart : int, optional Number of iterations between restarts. Larger values increase iteration cost, but may be necessary for convergence. If omitted, ``min(20, n)`` is used. maxiter : int, optional Maximum number of iterations (restart cycles). Iteration will stop after maxiter steps even if the specified tolerance has not been achieved. See `callback_type`. M : {sparse array, 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. However, the final convergence is tested with respect to the ``b - A @ x`` residual. 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. This keyword has no effect if `callback` is not set. Returns ------- x : ndarray The converged solution. info : int Provides convergence information: 0 : successful exit >0 : convergence to tolerance not achieved, number of iterations 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_array >>> from scipy.sparse.linalg import gmres >>> A = csc_array([[3, 2, 0], [1, -1, 0], [0, 5, 1]], dtype=float) >>> b = np.array([2, 4, -1], dtype=float) >>> x, exitCode = gmres(A, b, atol=1e-5) >>> print(exitCode) # 0 indicates successful convergence 0 >>> np.allclose(A.dot(x), b) True Na2scipy.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., ``gmres(..., callback_type='pr_norm')``, or to retain the old behavior ``gmres(..., callback_type='legacy')``)category stacklevelr)r9pr_normrzUnknown callback_type: r rr g?r lartg)r.rr!FT)rri)rrr9g?g?)warningswarnDeprecationWarningrrr+r'r$r%r&rr-r.r/r0r(r)r*minremptyzerosr3r1r2r5 conjugater4r)0r6r7r8rrrcrrrrdrr9r:r+r?r=r;r<r0r>Mb_nrm2ptol_max_factorptolpresidrkrVhgivens inner_iterrGrEtmpS breakdowncolavwh0kh1crXn0n1magyr`infos0 rr r Fsr 5E  c$61EEEE 666D=DDEEE )!QA66Aq!Q XF XF AA INN1  EWeT488GD! zz{1~~q  (17< $C++7bggGB$'1ooGinnVVAYY''GO S$,77 7D F WAG 4 4 4E '!)Qqw///A '719%QW555A Xwl!' 2 2 2FJ7^^f;f; >>!"6FF1II affhhAy~~a  4''"{1~~q((((&))!QQQ$innQq!!!tW%% !QQQ$AG HWQYag . . .! >>- - C#qqq& ""Br A""B3q5\\ ! !ga111gq))#q& S1aaa4[ ""B Ac37lOaaaDAcAgqqqjMSV||"##sQw, #'111* !b&) 3ZZ H Had|VAqD\13AaC=)B&'dQrTkAFFHH9R)>;q>> 117B B B B C   HQKKK D== E  > E t^^!#to'=>>OO!#s_'<==OOTE\:::$11WD ;q>>4 r)rrrM1M2rcj 5|5t|d||\}} } }} tj|} t d| ||\}} | dkr | |dfS||t 5drC5fd}5fd}5fd}5fd}t |j|| }t |j|| }n1d }t |j|| }t |j|| }t|}||d z}tj | r tj n tj }tj | j jj}|}|}|}|}|}| r||| z n|}|}||}tj|}|}||} tj| }!d \}"}#}$tj|}%tj|}&d \}'}(})}*}+t+|D]},tj||kr| | dfcStj||kr| | dfcStj|!|kr| | dfcS|dd|%dd<|%d|z z}%|d|z z}|dd|&dd<|&d|!z z}&| d|!z z} || |}-tj|-|kr| | dfcS||}.|| }/|,dkrM|.|!|-z|'z |*zz}.|.dd|*dd<|/||-|'z z|(zz}/|/dd|(dd<n(|.}*|/}(||*}0||(|0}'tj|'|kr| | dfcS|'|-z }1tj|1|kr| | dfcS|0dd|dd<||1|%zz}||}|}2tj|}|&dd|dd<||1 z}|||(z }||} tj| }!|"}3|$}4||3tj|1zz }$dtjd|$dzzz }"tj|"|kr| | dfcS|#|2|1z |"|3z dzzz}#|,dkr'|)|4|"zdzz})|)|#|*zz })|+|4|"zdzz}+|+|#|0zz }+n2|*})|)|#z})|0}+|+|#z}+| |)z } ||+z}|r || | | |fS)a-Use Quasi-Minimal Residual iteration to solve ``Ax = b``. Parameters ---------- A : {sparse array, 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). x0 : ndarray Starting guess for the solution. atol, rtol : float, optional Parameters for the convergence test. For convergence, ``norm(b - A @ x) <= max(rtol*norm(b), atol)`` should be satisfied. The default is ``atol=0.`` and ``rtol=1e-5``. maxiter : integer Maximum number of iterations. Iteration will stop after maxiter steps even if the specified tolerance has not been achieved. M1 : {sparse array, ndarray, LinearOperator} Left preconditioner for A. M2 : {sparse array, 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. Returns ------- x : ndarray The converged solution. info : integer Provides convergence information: 0 : successful exit >0 : convergence to tolerance not achieved, number of iterations <0 : parameter breakdown See Also -------- LinearOperator Examples -------- >>> import numpy as np >>> from scipy.sparse import csc_array >>> from scipy.sparse.linalg import qmr >>> A = csc_array([[3., 2., 0.], [1., -1., 0.], [0., 5., 1.]]) >>> b = np.array([2., 4., -1.]) >>> x, exitCode = qmr(A, b, atol=1e-5) >>> print(exitCode) # 0 indicates successful convergence 0 >>> np.allclose(A.dot(x), b) True Nr rr?c0|dSNleftr?r7A_s r left_psolvezqmr..left_psolvesyyF+++rc0|dSNrightrrs r right_psolvezqmr..right_psolvesyyG,,,rc0|dSrr@rs r left_rpsolvezqmr..left_rpsolveszz!V,,,rc0|dSrrrs r right_rpsolvezqmr..right_rpsolveszz!W---r)r+r,c|SN)r7s ridzqmr..idsrr )rrlrrQr"iriir#r!i)rr$r%r&rhasattrrshaper'r(r)r*r-r.r/r0r1r+r2r,rSr3r4r5sqrt)6r6r7r8rrrrrrrr9r:r;r<rrrrrr=r>rAbetatolgammatoldeltatol epsilontolxitolrEvtilderrWwtilderHxigammaetathetarVrepsilonrLdrCrXrGdeltaytilderIrDrKrB gamma_prev theta_prevrs6 @rr r Lsv B)!T2q99Aq!Q INN1  EUE466GD! zz{1~~q   zbj 2x  @ , , , , , - - - - - - - - - - . . . . .'2(4666B '3(5777BB   B???BB???B AAB$++7bggG Xagl # # 'FGHHJ E55770AHHQKKA VVXXF &A )..  C VVXXF 6A   B E3 fA fA7GQ1a7^^P'P' 9>>!  t # #;q>>1$ $ $ $ 6#;;  ;q>>3& & & & 6"::  ;q>>3& & & &aaay!!! a#g a#gaaay!!! a"f  a"f 1  6%==8 # #;q>>3& & & &1A q== rEzG+q0 0F!!!9AaaaD sego33555: :F!!!9AaaaDD A A!'!V$$ 6'??Z ' ';q>>3& & & & 6$<<' ! !;q>>3& & & &111Iqqq $q& IIf  innQaaaDqqq DIIKK-!))A,, JJv   Y^^A    zBF4LL01BGAqL))) 6%==8 # #;q>>3& & & & D!UZ%7!$;;; q== *u$* *A QJA *u$* *A VOAAA HA A HA Q Q   HQKKK{1~~w&&r)r rr)rmnumpyr$scipy.sparse.linalg._interfacerutilsr scipy.linalgr__all__rrrr r r r rrrrs999999)))))) ; ; ;    B'2ttdB'B'B'B'B'JQ'Dr44Q'Q'Q'Q'Q'hu'dTTDu'u'u'u'u'pZ't"ddTZ'Z'Z'Z'Z'zC BddtC C C C C LI't"dtI'I'I'I'I'I'I'r