(phE SSKrSSKrSSKJr SSKJr SSKJr /SQr SS jr SSSSSSS .S jjr SSSSSSS .S jjr SSSSSSS .S jjr SSSSSSS .SjjrSSSSSSSSS.SjjrSSSSSSSS.Sjjrg)N)LinearOperator) make_system)get_lapack_funcs)bicgbicgstabcgcgsgmresqmrh㈵>cUS:Xd UbUS:aSUSUS3n[U5e[[U5[U5[U5-5nX#4$)z5 A helper function to handle tolerance normalization legacyrz'scipy.sparse.linalg.z' called with invalid `atol`=z5; if set, `atol` must be a real, non-negative number.) ValueErrormaxfloat)nameb_normatolrtolmsgs X/var/www/html/venv/lib/python3.13/site-packages/scipy/sparse/linalg/_isolve/iterative.py_get_atol_rtolr sb x4<4!8&tf,I$PEEo uT{E$K%-7 8D :)rrmaxiterMcallbackc [XX!5uppn [RRU5n [ SXU5upKU S:Xa U "U5S4$[ U5n [R "U5(a[RO[Rn UcU S-nURURpURURnn[R"URR5RS-nSunnnUR5(a X"U5- OUR!5nUR!5n[#U5GH$n[RRU5U:a U "U5S4s $U"U5nU"U5nU "UU5n[R$"U5U:aU S4s $US:a(UU- nUU-nUU- nUUR'5-nUU- nO UR!5nUR!5nU"U5nU"U5nU "UU5nUS:Xa U "U5S4s $UU- n UU U-- nUU U--nUU R'5U--nUnU(dGMU"U5 GM' U "U5U4$)aUse 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 rr )NNN)rnplinalgnormrlen iscomplexobjvdotdotmatvecrmatvecfinfodtypecharepsanycopyrangeabsconj)!Abx0rrrrrx postprocessbnrm2_ndotprodr+r,psolverpsolverhotolrho_prevpptilderrtilde iterationzztilderho_curbetaqqtildervalphas! rrrsKB*!6A! IINN1 EVU$7GD z1~q   AA++bggGB$hh Ghh GF XXaggll # ' ' *F+HaF1I affhA VVXF7^ 99>>! t #q>1$ $ 1I&!$ 66'?V ## # q=X%D IA FA diik !F f FA[[]F 1I VQ  7q>3& &"  U1W  U1W %**,v%% 8 QKI$P1~w&&rc[XX!5uppn [RRU5n [ SXU5upKU S:Xa U "U5S4$[ U5n [R "U5(a[RO[Rn UcU S-nURnURn[R"URR5RS-nUnSunnnnnUR5(a X"U5- OUR5nUR5n[!U5GHn[RRU5U:a U "U5S4s $U "UU5n[R""U5U:a U "U5S4s $US:aD[R""U5U:a U "U5S4s $UU- UU- -nUUU--nUU-nUU- nO&[R$"U5nUR5nU"U5nU"U5nU "UU5nUS:Xa U "U5S4s $UU- nUUU--nUSSWSS&[RRU5U:aUUU-- nU "U5S4s $U"U5nU"U5n U "U U5U "U U 5- nUUU-- nUUU-- nUUU --nUnU(dGMU"U5 GM U "U5U4$) a6 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! rrrsL*!6A! IINN1 EZd;GD z1~q   AA++bggGB$ XXF XXFXXaggll # ' ' *FH$@ HeUAqF1I affhA VVXF7^ 99>>! t #q>1$ $fa  66#; q>3& & q=vve}x'"1~s**(Nuu}5D qLA IA FA a AAay 4L VQ  7q>3& &b U1W t! 99>>! t # tOAq>1$ $ay 4L1 1 - U4Z U4Z U1W  8 QKU$\1~w&&rc`[XX!5uppn [RRU5n [ SXU5upKU S:Xa U "U5S4$[ U5n UcU S-n[R "U5(a[RO[Rn URnURnUR5(a X"U5- OUR5nSunn[U5Hn[RRU5U:a U "U5S4s $U"U5nU "UU5nUS:aUU- nUU-nUU- nO[R"U5nUSSUSS&U"U5nUU "UU5- nUUU-- nUUU--nUnU(dMU"U5 M U "U5U4$)aP 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*!6A! IINN1 ET55GD z1~q   AAB$++bggG XXF XXFF1I affhAKHa7^ 99>>! t #q>1$ $ 1I!Q- q=X%D IA FA a AQ4AaD 1I'!Q-' U1W  U1W  8 QK+$21~w&&rcP[XX!5uppn [RRU5n [ SXU5upKU S:Xa U "U5S4$[ U5n [R "U5(a[RO[Rn UcU S-nURnURn[R"URR5RS-nUR5(a X"U5- OUR5nUR5n[RRU5nUS:XaSnSunnnn[!U5GH5n[RRU5nUU:a U "U5S4s $U "UU5n[R""U5U:aU S4s $US:a*UU- nUSSUSS&UUU-- nUU-nUU- nUU-nUU- nO6UR5nUR5n[R$"U5nU"U5nU"U5nU "UU5nUS:Xa U "U5S 4s $UU- nUSSUSS&UUU--nU"UU-5n UUU -- nX"U5- nUnU(dGM-U"U5 GM8 U "U5U4$) aUse 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*!6A! IINN1 EUE6GD z1~q   AA++bggGB$ XXF XXF XXaggll # ' ' *FF1I affhA VVXF IINN1 E z/HaA7^  q! 4<q>1$ $&!$ 66'?V ## # q=X%DQ4AaD aKA IA FA IA FAAA a Aayd| VT " 7q>3& &" t! U4Za!e} U4Z q M 8 QKg$n1~w&&r)rrrestartrrr callback_typec  UbU cSn [R"U [SS9 U cSn U S;a[SU <35eUcSn [ XX!5uppn UR n UR n[ U5n[RRU5n[SUXC5unnUS :Xa U "U5S 4$[R"U RR5Rn[R"U 5(a[R O[R"nUcUS -nUcS n[%X_5n[RRU"U55nS nU[%UUU- 5-nS n['SU RS9n[R("US-U/U RS9n[R*"XUS-/U RS9n[R*"US/U RS9nS n[-U5GH(nUS :Xa^U R/5(a X"U 5- OUR15n[RRU5U:a U "U 5S 4s $U"W5US SS24'[RRUS SS245nUS SS24==SU- -ss'[R*"US-U RS9n UU S 'Sn![-U5GHn"U "UU"SS245n#U"U#5n$[RRU$5n%[-U"S-5H)n&U"UU&SS24U$5nUUU"U&4'U$UUU&SS24--n$M+ [RRU$5n'U'UU"U"S-4'U$SSUU"S-SS24'U'UU%-::a S UU"U"S-4'Sn!OUU"S-SS24==SU'- -ss'[-U"5HOn&UU&S 4UU&S4n)n(UU"U&U&S-/4un*n+U(U*-U)U+--U)R35*U*-U(U+--/UU"U&U&S-/4'MQ U"UU"U"4UU"U"S-45un(n)n,U(U)/UU"SS24'U,S 4UU"U"U"S-/4'[R4"U)5*U U"-nU(U U"-U/U U"U"S-/'[R6"U5nUS- nU S;a U"UU- 5 U S:XaUU:Xa OUU::d U!(dGM O UW"U"4S :XaS U U"'[R*"U"S-/U RS9n-U SU"S-U-SS&[-U"S S5H=n&U-U&S :wdMU-U&==UU&U&4-ss'U-U&nU-SU&===UUU&SU&24--sss&M? U-S S :waU-S ==US-ss'U U-USU"S-2SS24-- n X"U 5- n[RRU5n.U S:XaUU:XaU "U 5U.U::aS 4s $U4s $U S:XaU"U 5 U.U::a OEU!(a O0 : 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$61E 662=2CDEE )!6A! XXF XXF AA IINN1 EWeT8GD! z1~q  ((177<< $ $C++bggGB$'oGiinnVAY'GO S$,7 7D F WAGG 4E '!)Qqww/A '19%QWW5A XXwl!'' 2FJ7^ >!"F1I affhAyy~~a 4'"1~q(()!Q$iinnQq!tW% !Q$AG HHWQYagg .! >C#q& "Br A"B3q5\a1gq)#q& S1a4[ " "B Ac37lOaDAcAgqjMSV|"##sQw, #'1* !b&) 3Zad|VAqD\13AaC=)B&'dQrTkAFFH9Rq> 1B B7B B C  QK D=    t^!#to'=>O!#s_'<=OOTE\::M$P$1WD q>4 r)rrrM1M2rc ^5Um5[USX!5up pn [RRU5n [ SXU5upMU S:Xa U "U5S4$UcUc[ T5S5(aCU54SjnU54SjnU54SjnU54Sjn[ URUUS 9n[ URUUS 9nO-S n[ URUUS 9n[ URUUS 9n[U5nUcUS -n[R"U 5(a[RO[Rn[R"U RR5RnUnUnUnUnUnU R!5(aXR#U 5- OUR%5nUR%5nUR#U5n[RRU5nUR%5nUR'U5n [RRU 5n!S un"n#n$[R("U5n%[R("U5n&S un'n(n)n*n+[+U5GHXn,[RRU5U:a U "U 5S4s $[R,"U5U:a U "U 5S4s $[R,"U!5U:a U "U 5S4s $USSU%SS&U%SU- -n%USU- -nUSSU&SS&U&SU!- -n&U SU!- -n U"U U5n-[R,"U-5U:a U "U 5S4s $UR#U5n.UR'U 5n/U,S:a;U.U!U--U'- U*--n.U.SSU*SS&U/UU-U'- R/5-U(--n/U/SSU(SS&O U.R%5n*U/R%5n(UR#U*5n0U"U(U05n'[R,"U'5U:a U "U 5S4s $U'U-- n1[R,"U15U:a U "U 5S4s $U0SSUSS&UU1U%--nUR#U5nUn2[RRU5nU&SSUSS&UU1R/5*-nUUR'U(5- nUR'U5n [RRU 5n!U"n3U$n4UU3[R,"U15-- n$S[R0"SU$S--5- n"[R,"U"5U:a U "U 5S4s $U#U2U1- *U"U3- S---n#U,S:a'U)U4U"-S--n)U)U#U*-- n)U+U4U"-S--n+U+U#U0-- n+O*U*R%5n)U)U#-n)U0R%5n+U+U#-n+U U)- n UU+-nU(dGMPU"U 5 GM[ U "U 5U4$)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?c(>TRUS5$Nleftr?r7A_s r left_psolveqmr..left_psolvesyyF++rc(>TRUS5$Nrightrrs r right_psolveqmr..right_psolvesyyG,,rc(>TRUS5$rr@rs r left_rpsolveqmr..left_rpsolveszz!V,,rc(>TRUS5$rrrs r right_rpsolveqmr..right_rpsolveszz!W--r)r+r,cU$N)r7s ridqmr..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 Lssv B)!T29A! IINN1 EUE6GD z1~q   zbj 2x  , - - .'2(46B '3(57B B?BB?B AAB$++bggG XXaggll # ' 'FGHHJ E5577HHQKA VVXF &A )).. C VVXF 6A  B E3 fA fA7GQ1a7^ 99>>! t #q>1$ $ 66#; q>3& & 66": q>3& &ay! a#g a#gay! a"f  a"f 1  66%=8 #q>3& &1A q= rEzG+q0 0F!9AaD sego3355: :F!9AaD A A!!V$ 66'?Z 'q>3& & 66$<' !q>3& &1Iq $q& IIf iinnQaDq DIIK-!))A, JJv  YY^^A   zBFF4L01BGGAqL)) 66%=8 #q>3& & D!UZ%7!$;;; q= *u$* *A QJA *u$* *A VOAA HA A HA Q Q 8 QKY$`1~w&&r)r rr)rmnumpyr$scipy.sparse.linalg._interfacerutilsr scipy.linalgr__all__rrrr r r r rrrrs9) ; B'2ttdB'JQ'Dr44Q'hu'dTTDu'pZ't"ddTZ'zC BddtC LI't"dtI'r