+
    ùª¨jÏ?  ã                   ób   € R t R.t^ RIHtHtHtHt ^ RIHt ^ RI	H
t
 ^ RIHt ^ RIHt R	R ltR# )
a¢  
Copyright (C) 2010 David Fong and Michael Saunders

LSMR uses an iterative method.

07 Jun 2010: Documentation updated
03 Jun 2010: First release version in Python

David Chin-lung Fong            clfong@stanford.edu
Institute for Computational and Mathematical Engineering
Stanford University

Michael Saunders                saunders@stanford.edu
Systems Optimization Laboratory
Dept of MS&E, Stanford University.

Úlsmr)ÚzerosÚinfÚ
atleast_1dÚresult_type)Únorm)Úsqrt)Úaslinearoperator)Ú
_sym_orthoNc	                ó  € \        V 4      p V P                  ^8”  d   \        V P                   R24      h\        V4      pVP                  ^8”  d   VP	                  4       pR"p	Rp
Rp^p^ pV P
                  w  rï\        Wï.4      pVf   TpVf   \        W\        4      pM\        WV\        4      pV'       da   \        R4       \        R4       \        RV RV R24       \        R	VR
 R24       \        RVR RVR R24       \        RVR RVR R24       Tp\        V4      pVf   \        VV4      pVP                  4       pM<\        VP                  4       4      pVV P                  V4      ,
          p\        V4      pV^ 8”  d.   ^V,          V,          pV P                  V4      p\        V4      pM\        VV4      p^ pV^ 8”  d   ^V,          V,          p^ pVV,          pTp^p^p^p^ pVP                  4       p\        VV4      p Tp!^ p"^p#^ p$^ p%^ p&^ p'VV,          p(^ p)Rp*\        V(4      p+^p,^ p-Rp.Rp/Rp0Rp1^ p2^ p3V^ 8”  d
   ^V,          p3Tp4VV,          p5V5^ 8X  d%   V'       d   \        V	^ ,          4       VV2VV4V5V+V,V-3# V^ 8X  d   ^ VR#&   VV2VV4V5V+V,V-3# V'       dc   \        R4       \        W«4       ^p6VV,          p7VR RV^ ,          R 2p.RV4R RV5R 2p/RV6R RV7R 2p0\        RP!                  V.V/V0.4      4       VV8  EdX   V^,           pVV) ,          pVV P                  V4      ,          p\        V4      pV^ 8”  dU   V^V,          ,          pVV) ,          pVV P                  V4      ,          p\        V4      pV^ 8”  d   V^V,          ,          p\#        VV4      w  p8p9p:Tp;\#        V:V4      w  p<p=pV=V,          p>V<V,          pTp?T&p@VV,          pAVV,          pB\#        VV,          V>4      w  pppVV,          p&V) V,          pV VAV,          V;V?,          ,          ) ,          p V V,          p VV&VV,          ,          V ,          ,          pVV>V,          ) ,          pVV,          pV8V!,          pCV9) V!,          pDV<VC,          pEV=) VC,          p!T%pF\#        V#VA4      w  pGpHpIVHV,          p%VGV,          p#VH) V",          VGVE,          ,           p"V@VFV$,          ,
          VI,          p$V&V%V$,          ,
          V#,          pJV'VDVD,          ,           p'\        V'V"VJ,
          ^,          ,           V!V!,          ,           4      p4V(VV,          ,           p(\        V(4      p+V(VV,          ,           p(\%        V)V?4      p)V^8”  d   \        V*V?4      p*\%        V)XB4      \        V*VB4      ,          p,\'        V4      p5\        V4      p-V4V,          p6V+V4,          ^ 8w  d   V5V+V4,          ,          p7M\(        p7^V,,          pKV6^V+V-,          V,          ,           ,          pLWCV+,          V-,          V,          ,           pMVV8¼  d   ^p2^XK,           ^8:  d   ^p2^V7,           ^8:  d   ^p2^XL,           ^8:  d   ^p2XKV38:  d   ^p2V7V8:  d   ^p2V6XM8:  d   ^p2V'       dÏ   V^(8:  gU   V^
8:  gN   VV^
,
          8¼  g@   V^
,          ^ 8X  g2   XKRV3,          8:  g$   V7RV,          8:  g   V6RXM,          8:  g   V2^ 8w  dt   WÜ8¼  d   ^ p\        R4       \        W«4       V^,           pVR RV^ ,          R 2p.RV4R RV5R 2p/RV6R RV7R 2p0RV+R RV,R 2p1\        RP!                  V.V/V0V1.4      4       V2^ 8”  g   EK^   V'       d‰   \        R4       \        R4       \        V	V2,          4       \        RV2R RV4R 24       \        RV+R RV5R 24       \        RVR R V,R 24       \        R!V-R 24       \        V.V/4       \        V0V14       VV2VV4V5V+V,V-3# )$aG  Iterative solver for least-squares problems.

lsmr solves the system of linear equations ``Ax = b``. If the system
is inconsistent, it solves the least-squares problem ``min ||b - Ax||_2``.
``A`` is a rectangular matrix of dimension m-by-n, where all cases are
allowed: m = n, m > n, or m < n. ``b`` is a vector of length m.
The matrix A may be dense or sparse (usually sparse).

Parameters
----------
A : {sparse array, ndarray, LinearOperator}
    Matrix A in the linear system.
    Alternatively, ``A`` can be a linear operator which can
    produce ``Ax`` and ``A^H x`` using, e.g.,
    ``scipy.sparse.linalg.LinearOperator``.
b : array_like, shape (m,)
    Vector ``b`` in the linear system.
damp : float
    Damping factor for regularized least-squares. `lsmr` solves
    the regularized least-squares problem::

     min ||(b) - (  A   )x||
         ||(0)   (damp*I) ||_2

    where damp is a scalar.  If damp is None or 0, the system
    is solved without regularization. Default is 0.
atol, btol : float, optional
    Stopping tolerances. `lsmr` continues iterations until a
    certain backward error estimate is smaller than some quantity
    depending on atol and btol.  Let ``r = b - Ax`` be the
    residual vector for the current approximate solution ``x``.
    If ``Ax = b`` seems to be consistent, `lsmr` terminates
    when ``norm(r) <= atol * norm(A) * norm(x) + btol * norm(b)``.
    Otherwise, `lsmr` terminates when ``norm(A^H r) <=
    atol * norm(A) * norm(r)``.  If both tolerances are 1.0e-6 (default),
    the final ``norm(r)`` should be accurate to about 6
    digits. (The final ``x`` will usually have fewer correct digits,
    depending on ``cond(A)`` and the size of LAMBDA.)  If `atol`
    or `btol` is None, a default value of 1.0e-6 will be used.
    Ideally, they should be estimates of the relative error in the
    entries of ``A`` and ``b`` respectively.  For example, if the entries
    of ``A`` have 7 correct digits, set ``atol = 1e-7``. This prevents
    the algorithm from doing unnecessary work beyond the
    uncertainty of the input data.
conlim : float, optional
    `lsmr` terminates if an estimate of ``cond(A)`` exceeds
    `conlim`.  For compatible systems ``Ax = b``, conlim could be
    as large as 1.0e+12 (say).  For least-squares problems,
    `conlim` should be less than 1.0e+8. If `conlim` is None, the
    default value is 1e+8.  Maximum precision can be obtained by
    setting ``atol = btol = conlim = 0``, but the number of
    iterations may then be excessive. Default is 1e8.
maxiter : int, optional
    `lsmr` terminates if the number of iterations reaches
    `maxiter`.  The default is ``maxiter = min(m, n)``.  For
    ill-conditioned systems, a larger value of `maxiter` may be
    needed. Default is False.
show : bool, optional
    Print iterations logs if ``show=True``. Default is False.
x0 : array_like, shape (n,), optional
    Initial guess of ``x``, if None zeros are used. Default is None.

    .. versionadded:: 1.0.0

Returns
-------
x : ndarray of float
    Least-square solution returned.
istop : int
    istop gives the reason for stopping::

      istop   = 0 means x=0 is a solution.  If x0 was given, then x=x0 is a
                  solution.
              = 1 means x is an approximate solution to A@x = B,
                  according to atol and btol.
              = 2 means x approximately solves the least-squares problem
                  according to atol.
              = 3 means COND(A) seems to be greater than CONLIM.
              = 4 is the same as 1 with atol = btol = eps (machine
                  precision)
              = 5 is the same as 2 with atol = eps.
              = 6 is the same as 3 with CONLIM = 1/eps.
              = 7 means ITN reached maxiter before the other stopping
                  conditions were satisfied.

itn : int
    Number of iterations used.
normr : float
    ``norm(b-Ax)``
normar : float
    ``norm(A^H (b - Ax))``
norma : float
    ``norm(A)``
conda : float
    Condition number of A.
normx : float
    ``norm(x)``

Notes
-----

.. versionadded:: 0.11.0

References
----------
.. [1] D. C.-L. Fong and M. A. Saunders,
       "LSMR: An iterative algorithm for sparse least-squares problems",
       SIAM J. Sci. Comput., vol. 33, pp. 2950-2971, 2011.
       :arxiv:`1006.0758`
.. [2] LSMR Software, https://web.stanford.edu/group/SOL/software/lsmr/

Examples
--------
>>> import numpy as np
>>> from scipy.sparse import csc_array
>>> from scipy.sparse.linalg import lsmr
>>> A = csc_array([[1., 0.], [1., 1.], [0., 1.]], dtype=float)

The first example has the trivial solution ``[0, 0]``

>>> b = np.array([0., 0., 0.], dtype=float)
>>> x, istop, itn, normr = lsmr(A, b)[:4]
>>> istop
0
>>> x
array([0., 0.])

The stopping code ``istop=0`` returned indicates that a vector of zeros was
found as a solution. The returned solution `x` indeed contains
``[0., 0.]``. The next example has a non-trivial solution:

>>> b = np.array([1., 0., -1.], dtype=float)
>>> x, istop, itn, normr = lsmr(A, b)[:4]
>>> istop
1
>>> x
array([ 1., -1.])
>>> itn
1
>>> normr
4.440892098500627e-16

As indicated by ``istop=1``, `lsmr` found a solution obeying the tolerance
limits. The given solution ``[1., -1.]`` obviously solves the equation. The
remaining return values include information about the number of iterations
(`itn=1`) and the remaining difference of left and right side of the solved
equation.
The final example demonstrates the behavior in the case where there is no
solution for the equation:

>>> b = np.array([1., 0.01, -1.], dtype=float)
>>> x, istop, itn, normr = lsmr(A, b)[:4]
>>> istop
2
>>> x
array([ 1.00333333, -0.99666667])
>>> A.dot(x)-b
array([ 0.00333333, -0.00333333,  0.00333333])
>>> normr
0.005773502691896255

`istop` indicates that the system is inconsistent and thus `x` is rather an
approximate solution to the corresponding least-squares problem. `normr`
contains the minimal distance that was found.
z.-dimensional `A` is unsupported, expected 2-D.z(   itn      x(1)       norm r    norm Arz% compatible   LS      norm A   cond AÚ z2LSMR            Least-squares solution of  Ax = b
zThe matrix A has z
 rows and z columnszdamp = z20.14eÚ
zatol = z8.2ez                 conlim = zbtol = z             maxiter = Ú8gg}Ã”%­I²TÚ Ú6gz12.5ez10.3ez  z8.1egš™™™™™ñ?zLSMR finishedzistop =z    normr =z    normA =z    normAr =zitn   =z    condA =z    normx =)z9The exact solution is x = 0, or x = x0, if x0 was given  z:Ax - b is small enough, given atol, btol                  z:The least-squares solution is good enough, given atol     z:The estimate of cond(Abar) has exceeded conlim            z:Ax - b is small enough for this machine                   z:The least-squares solution is good enough for this machinez:Cond(Abar) seems to be too large for this machine         z:The iteration limit has been reached                      © )r	   ÚndimÚ
ValueErrorr   ÚsqueezeÚshapeÚminr   ÚfloatÚprintr   r   ÚcopyÚmatvecÚrmatvecr   Újoinr
   ÚmaxÚabsr   )NÚAÚbÚdampÚatolÚbtolÚconlimÚmaxiterÚshowÚx0ÚmsgÚhdg1Úhdg2ÚpfreqÚpcountÚmÚnÚminDimÚdtypeÚuÚnormbÚxÚbetaÚvÚalphaÚitnÚzetabarÚalphabarÚrhoÚrhobarÚcbarÚsbarÚhÚhbarÚbetaddÚbetadÚrhodoldÚtautildeoldÚ
thetatildeÚzetaÚdÚnormA2ÚmaxrbarÚminrbarÚnormAÚcondAÚnormxÚstr1Ústr2Ústr3Ústr4ÚistopÚctolÚnormrÚnormarÚtest1Útest2ÚchatÚshatÚalphahatÚrhooldÚcÚsÚthetanewÚ	rhobaroldÚzetaoldÚthetabarÚrhotempÚ	betaacuteÚ	betacheckÚbetahatÚthetatildeoldÚ	ctildeoldÚ	stildeoldÚrhotildeoldÚtaudÚtest3Út1ÚrtolsN   &&&&&&&&&                                                                     Ú\C:\Ai_Coding\apps\studio\ComfyUI\.venv\Lib\site-packages\scipy\sparse\linalg\_isolve\lsmr.pyr   r      si  € ôP 	˜Ó€AØ‡v�v�„zÜ˜AŸF™F˜8Ð#QÐRÓSÐSÜ�1‹€AØ‡v�v�„zØ�I‰I‹KˆðI€Cð 6€DØ2€DØ€EØ€Fà�7‰7�D€Aô �!�‹[€Fà‚Øˆà	‚zÜ˜A¤%Ó(‰ä˜A "¤eÓ,ˆçÜˆcŒ
ÜÐCÔDÜÐ! !  J¨q¨c°Ð:Ô;Ü�˜˜V�} BÐ'Ô(Ü�˜˜T�{Ð"<¸VÀD¸MÈÐLÔMÜ�˜˜T�{Ð"9¸'À"¸ÀRÐHÔIà	€AÜ�‹G€EØ	‚zÜ�!�U‹OˆØ�z‰z‹|‰ä�r—w‘w“yÓ!ˆØ�—‘˜“�OˆÜ�A‹wˆàˆa„xØ��X˜�NˆØ�I‰I�a‹LˆÜ�Q“‰ä�!�U‹OˆØˆàˆq„yØ��Y˜!�Oˆð €CØ�d�l€GØ€HØ
€CØ€FØ€DØ€Dà	�‰‹€AÜ��E‹?€Dð €FØ€EØ€GØ€KØ€JØ€DØ	€Að �U�]€FØ€GØ€GÜ�‹L€EØ€EØ€Eð €DØ€DØ€DØ€Dð €EØ€DØ�„zØ�6�zˆØ€Eð �T�\€FØ�„{ßÜ�#�a•&ŒMØ�%˜˜e V¨U°E¸5Ð@Ð@à�„zØˆˆ"‰Ø�%˜˜e V¨U°E¸5Ð@Ð@çÜˆcŒ
ÜˆdÔØˆØ˜•ˆØ�b�˜˜1˜Q�4 ˜,Ð'ˆØ�5˜�-˜q ¨ Ð/ˆØ�E˜$�<˜q  t Ð-ˆÜˆb�g‰g�t˜T 4Ð(Ó)Ô*ð ��-Ø�A�gˆð 	
ˆeˆV�ˆØ	ˆQ�X‰X�a‹[ÕˆÜ�A‹wˆà�!Œ8Ø�!�d•(�OˆAØ�$��JˆAØ�—‘˜1“ÕˆAÜ˜“GˆEØ�qŒyØ�a˜%•iÕ �ô  *¨(°DÓ9Ñˆˆd�Hð ˆÜ˜x¨Ó.‰	ˆˆ1ˆcØ�U•7ˆØ�U•7ˆð ˆ	ØˆØ˜#•:ˆØ˜•*ˆÜ'¨¨s­
°HÓ=Ñˆˆd�FØ�g�~ˆØ�&˜7Õ"ˆð 	�8˜c•> V¨iÕ%7Õ8Ð9Õ9ˆØ��	ˆØ	ˆd�c˜F•lÕ# tÕ+Õ+ˆØ	�˜3•ÐÕˆØ	ˆQ�ˆð
 ˜6•Mˆ	Ø�E˜F•Nˆ	ð �i•-ˆØ��i•ˆð
 #ˆÜ,6°wÀÓ,IÑ)ˆ	�9˜kØ Õ'ˆ
Ø˜fÕ$ˆØ�˜eÕ# i°'Õ&9Õ9ˆð
  °Õ!<Õ<ÀÕKˆØ�z KÕ/Õ/°7Õ:ˆØ�	˜IÕ%Õ%ˆÜ�Q˜% $�,¨Õ*Õ*¨V°f­_Õ<Ó=ˆð ˜$ �+Õ%ˆÜ�V“ˆØ˜% %�-Õ'ˆô �g˜yÓ)ˆØ�Œ7Ü˜' 9Ó-ˆGÜ�G˜WÓ%¬¨G°WÓ(=Õ=ˆô
 �W“ˆÜ�Q“ˆð
 ˜•ˆØ�E�M˜aÔØ˜e e�mÕ,‰EäˆEØ�E•	ˆØ�a˜% %�-¨%Õ/Õ/Õ0ˆØ˜U•l UÕ*¨UÕ2Õ2ˆð �'Œ>ØˆEØˆu�9˜Œ>ØˆEØˆu�9˜Œ>ØˆEØˆr�6�QŒ;ØˆEð �DŒ=ØˆEØ�DŒ=ØˆEØ�DŒ=ØˆE÷ Ø�R”˜S BœY¨C°7¸Rµ<Ô,?Ø�b•˜A” 5¨C°$­JÔ#6Ø˜˜t�Ô#¨°#¸µ*Ô)<Ø˜”
à”?Ø�FÜ˜#”JÜ˜$Ô%Ø !��Ø˜b˜  1 Q¥4¨ ,Ð/�Ø˜5 ˜- q¨°¨Ð7�Ø˜E $˜< q¨¨t¨Ð5�Ø˜5 ˜, a¨¨d |Ð4�Ü�b—g‘g˜t T¨4°Ð6Ó7Ô8à�1�9Ø÷ ÜˆcŒ
ÜˆoÔÜˆc�%�jÔÜ�˜˜b�z ¨U°4¨LÐ9Ô:Ü�˜E $˜< |°F¸4°=ÐAÔBÜ�˜˜B�x˜{¨5°¨,Ð7Ô8Ü�˜E $˜<Ð(Ô)Üˆd�DÔÜˆd�DÔàˆe�S˜% ¨°°uÐ<Ð<ó    )g        ç�íµ ÷Æ°>ro   g    „×—ANFN)Ú__doc__Ú__all__Únumpyr   r   r   r   Únumpy.linalgr   Úmathr   Úscipy.sparse.linalg._interfacer	   Ú scipy.sparse.linalg._isolve.lsqrr
   r   r   rn   rm   Ú<module>rw      s+   ðñð$ ˆ(€ç 5Ó 5Ý Ý Ý ;å 7öQ=rn   