ó
    EñiÀ  ã                   ó†   • S r SSKrSSKrSSKJr  SSKJr  SSKJ	r	J
r
   " S S\5      r   SS	 jrSS
 jrSS jrS rS rg)z,
Spectral Algorithm for Nonlinear Equations
é    N)ÚOptimizeResult)Ú_check_unknown_optionsé   )Ú_nonmonotone_line_search_cruzÚ_nonmonotone_line_search_chengc                   ó   • \ rS rSrSrg)Ú_NoConvergenceé   © N)Ú__name__Ú
__module__Ú__qualname__Ú__firstlineno__Ú__static_attributes__r   ó    ÚU/home/mande/repo/quber/.venv/lib/python3.13/site-packages/scipy/optimize/_spectral.pyr	   r	      s   † Úr   r	   c           
      óÒ  ^*^+^,• [        U5        US;  a  [        SU< S35      eSm,U
c  U*4S jn
Uc  U+U,4S jnU,4S jnS/n[        XUUXR5      u  nnnm+nnSnT+m*UnU" U5      n[        R                  " T+/U	5      nS	nT*nS
nSn U" U5      nU(       a  [        SU SUS SUS 35        Ub	  U" UU5        UUU-  U-   :  a  SnSnOä[        U5      SU-  :”  a  SU-  [        R                  " U5      -  nO[        U5      U:  a  UnU* U-  nU
" UUU5      n  US:X  a  [        UUUUU S9u  n!n"n#n$OUS:X  a  [        UUUT+UUU S9u  n!n"n#n$nnW"U-
  n%W$U-
  n&[        R                  " U%U%5      [        R                  " U%U&5      -  nU"nU$nW#m+US:X  a  UR                  U#5        US-  nGM&  [        UUUS9n'[        UU5      n([        U'UUU(US   USS9n)U)$ ! [         a     M8  f = f)aó  
Solve nonlinear equation with the DF-SANE method

Options
-------
ftol : float, optional
    Relative norm tolerance.
fatol : float, optional
    Absolute norm tolerance.
    Algorithm terminates when ``||func(x)|| < fatol + ftol ||func(x_0)||``.
fnorm : callable, optional
    Norm to use in the convergence check. If None, 2-norm is used.
maxfev : int, optional
    Maximum number of function evaluations.
disp : bool, optional
    Whether to print convergence process to stdout.
eta_strategy : callable, optional
    Choice of the ``eta_k`` parameter, which gives slack for growth
    of ``||F||**2``.  Called as ``eta_k = eta_strategy(k, x, F)`` with
    `k` the iteration number, `x` the current iterate and `F` the current
    residual. Should satisfy ``eta_k > 0`` and ``sum(eta, k=0..inf) < inf``.
    Default: ``||F||**2 / (1 + k)**2``.
sigma_eps : float, optional
    The spectral coefficient is constrained to ``sigma_eps < sigma < 1/sigma_eps``.
    Default: 1e-10
sigma_0 : float, optional
    Initial spectral coefficient.
    Default: 1.0
M : int, optional
    Number of iterates to include in the nonmonotonic line search.
    Default: 10
line_search : {'cruz', 'cheng'}
    Type of line search to employ. 'cruz' is the original one defined in
    [Martinez & Raydan. Math. Comp. 75, 1429 (2006)], 'cheng' is
    a modified search defined in [Cheng & Li. IMA J. Numer. Anal. 29, 814 (2009)].
    Default: 'cruz'

References
----------
.. [1] "Spectral residual method without gradient information for solving
       large-scale nonlinear systems of equations." W. La Cruz,
       J.M. Martinez, M. Raydan. Math. Comp. **75**, 1429 (2006).
.. [2] W. La Cruz, Opt. Meth. Software, 29, 24 (2014).
.. [3] W. Cheng, D.-H. Li. IMA J. Numer. Anal. **29**, 814 (2009).

)ÚchengÚcruzzInvalid value z for 'line_search'é   c                 ó   >• TSU -   S-  -  $ )Nr   r   r   )ÚkÚxÚFÚf_0s      €r   Úeta_strategyÚ#_root_df_sane.<locals>.eta_strategyJ   s   ø€ à˜!˜a™% !™Ñ#Ð#r   c                 ó   >• TST-  -  $ )Nç      ð?r   )r   Úf_kÚnexps    €€r   ÚfnormÚ_root_df_sane.<locals>.fnormO   s   ø€ à˜˜T™‘?Ð"r   c                 óH   >• [         R                  R                  U 5      T-  $ ©N)ÚnpÚlinalgÚnorm)r   r!   s    €r   ÚfmeritÚ_root_df_sane.<locals>.fmeritS   s   ø€ Ü�y‰y�~‰~˜aÓ  $Ñ&Ð&r   r   r   Fz&too many function evaluations requiredTziter z
: ||F|| = Úgz
, sigma = zsuccessful convergencer   r   )Úetar   )Úshapezdf-sane)r   ÚsuccessÚmessageÚfunÚnfevÚnitÚmethod)r   Ú
ValueErrorÚ
_wrap_funcÚcollectionsÚdequeÚprintÚabsr&   Úsignr   r   r	   ÚvdotÚappendÚ_wrap_resultr   )-ÚfuncÚx0ÚargsÚftolÚfatolÚmaxfevr"   ÚcallbackÚdispÚMr   Ú	sigma_epsÚsigma_0Úline_searchÚunknown_optionsr)   r1   ÚfÚx_kÚx_shapeÚF_kÚ
is_complexr   Úsigma_kÚF_0_normÚprev_fsÚQÚCÚ	convergedr/   ÚF_k_normÚdr,   ÚalphaÚxpÚfpÚFpÚs_kÚy_kr   r   Úresultr   r    r!   s-                                             @@@r   Ú_root_df_saner_      s�  ú€ ôb ˜?Ô+àÐ+Ó+Ü˜>¨+©Ð8JÐKÓLÐLà€DàÑõ	$ð �}ö	#õ'ð ˆ3€DÜ,6°tÀØ7;¸Vó-KÑ)€A€sˆG�S˜#˜zð 	
€AØ
€CØ€Gá�S‹z€Hô ×Ò   qÓ)€Gð 	€AØ€Aà€IØ6€Gà
Ù˜“:ˆæÜ�E˜!˜˜J x° l°*¸WÀQ¸KÐHÔIàÑÙ�S˜#Ôà�d˜X‘o¨Ñ-Ó-à.ˆGØˆIØô ˆw‹<˜!˜I™+Ó%Ø˜	‘k¤B§G¢G¨GÓ$4Ñ4‰GÜ�‹\˜IÓ%ØˆGð ˆH�s‰Nˆñ ˜1˜c 3Ó'ˆð	Ø˜fÓ$Ü$AÀ!ÀSÈ!ÈWØFIñ%KÑ!��r˜2™rà Ó'Ü*HÈÈCÐQRÐTWØIJÈAÐSVñ+XÑ'��r˜2˜r 1 að �3‰hˆØ�3‰hˆÜ—'’'˜#˜sÓ#¤b§g¢g¨c°3Ó&7Ñ7ˆð ˆØˆØˆð ˜&Ó Ø�N‰N˜2Ôà	ˆQ‰ˆòe ôh 	�S˜*¨GÑ4€AÜ�S˜*Ó%€Aä˜a¨Ø$+Ø !¨¨Q©°Q¸yñJ€Fð €Møô5 ó 	Úð	ús   ÄG Ä3G Ç
G&Ç%G&c                 ó¸  ^ ^^^^^	• [         R                  " U5      nUR                  m	[         R                  " T " U/TQ76 5      R                  5       n[         R                  " U5      =(       d    [         R                  " U5      nUR                  5       nSTS'   U(       a"  UUU UUU	4S jn[        U5      n[        U5      nOUUU UUU	4S jnX�T	T" U5      Xg4$ )a   
Wrap a function and an initial value so that (i) complex values
are wrapped to reals, and (ii) value for a merit function
fmerit(x, f) is computed at the same time, (iii) iteration count
is maintained and an exception is raised if it is exceeded.

Parameters
----------
func : callable
    Function to wrap
x0 : ndarray
    Initial value
fmerit : callable
    Merit function fmerit(f) for computing merit value from residual.
nfev_list : list
    List to store number of evaluations in. Should be [0] in the beginning.
maxfev : int
    Maximum number of evaluations before _NoConvergence is raised.
args : tuple
    Extra arguments to func

Returns
-------
wrap_func : callable
    Wrapped function, to be called as
    ``F, fp = wrap_func(x0)``
x0_wrap : ndarray of float
    Wrapped initial value; raveled to 1-D and complex
    values mapped to reals.
x0_shape : tuple
    Shape of the initial value array
f : float
    Merit function at F
F : ndarray of float
    Residual at x0_wrap
is_complex : bool
    Whether complex values were mapped to reals

r   r   c                 óú   >• T	S   T:¼  a
  [        5       eT	S==   S-  ss'   [        U 5      R                  T
5      n[        R                  " T" U/TQ76 5      R                  5       n[        U5      nT" U5      nXC4$ ©Nr   r   )r	   Ú_real2complexÚreshaper&   ÚasarrayÚravelÚ_complex2real)r   ÚzÚvr   rK   r@   r)   r>   rC   Ú	nfev_listÚx0_shapes        €€€€€€r   Ú	wrap_funcÚ_wrap_func.<locals>.wrap_funcÙ   st   ø€ Ø˜‰|˜vÓ%Ü$Ó&Ð&Ø�a‹L˜AÑ‹LÜ˜aÓ ×(Ñ(¨Ó2ˆAÜ—
’
™4 ˜> Dš>Ó*×0Ñ0Ó2ˆAÜ˜aÓ ˆAÙ�q“	ˆAØ�4ˆKr   c                 óÒ   >• TS   T:¼  a
  [        5       eTS==   S-  ss'   U R                  T5      n [        R                  " T" U /TQ76 5      R	                  5       nT" U5      nX!4$ rb   )r	   rd   r&   re   rf   )	r   r   rK   r@   r)   r>   rC   rj   rk   s	      €€€€€€r   rl   rm   æ   sc   ø€ Ø˜‰|˜vÓ%Ü$Ó&Ð&Ø�a‹L˜AÑ‹LØ—	‘	˜(Ó#ˆAÜ—
’
™4 ˜> Dš>Ó*×0Ñ0Ó2ˆAÙ�q“	ˆAØ�4ˆKr   )r&   re   r-   rf   Úiscomplexobjrg   )
r>   r?   r)   rj   rC   r@   r   rO   rl   rk   s
   ` ````   @r   r5   r5   ¨   s­   ý€ ôP 
�Š�B‹€BØ�x‰x€HÜ
�
Š
‘4˜�?˜T’?Ó#×)Ñ)Ó+€AÜ—’ Ó$×:¬¯ª¸Ó(:€JØ	�‰‹€Bà€Iˆa�Læ÷	ò 	ô ˜2ÓˆÜ˜!Ó‰÷	ò 	ð ˜(¡F¨1£I¨qÐ<Ð<r   c                 óX   • U(       a  [        U 5      nOU nUb  UR                  U5      nU$ )z9
Convert from real to complex and reshape result arrays.
)rc   rd   )r^   rO   r-   rh   s       r   r=   r=   ò   s/   € ö Ü˜&Ó!‰àˆØÑØ�I‰I�eÓˆØ€Hr   c                 ón   • [         R                  " U [        S9R                  [         R                  5      $ ©N)Údtype)r&   ÚascontiguousarrayÚfloatÚviewÚ
complex128)r   s    r   rc   rc   ÿ   s$   € Ü×Ò ¬Ñ/×4Ñ4´R·]±]ÓCÐCr   c                 ón   • [         R                  " U [        S9R                  [         R                  5      $ rr   )r&   rt   Úcomplexrv   Úfloat64)rh   s    r   rg   rg     s$   € Ü×Ò ¬Ñ1×6Ñ6´r·z±zÓBÐBr   )r   g:Œ0âŽyE>gYóøÂn¥iè  NNFé
   Ng»½×Ùß|Û=r   r   )r   r%   )Ú__doc__r6   Únumpyr&   Úscipy.optimizer   Úscipy.optimize._optimizer   Ú_linesearchr   r   Ú	Exceptionr	   r_   r5   r=   rc   rg   r   r   r   Ú<module>r‚      sS   ðñó ã Ý )Ý ;ß Vô	�Yô 	ð FJØLPØ<BôVôrG=ôT
òDóCr   