
    tKg                         d Z ddlZddlZddlmZ ddlmZ ddlm	Z	m
Z
  G d de      Z	 	 	 dd	Zdd
ZddZd Zd Zy)z,
Spectral Algorithm for Nonlinear Equations
    N)OptimizeResult)_check_unknown_options   )_nonmonotone_line_search_cruz_nonmonotone_line_search_chengc                       e Zd Zy)_NoConvergenceN)__name__
__module____qualname__     \/home/alanp/www/video.onchill/myenv/lib/python3.12/site-packages/scipy/optimize/_spectral.pyr	   r	      s    r   r	   c           	        *+, t        |       |dvrt        d|d      d,|
*fd}
|+,fd},fd}dg}t        | |||||      \  }}}+}}d}+*|} ||      }t        j                  +g|	      }d	}*}d
}d}	  ||      }|rt        d|||fz         |	 |||       |||z  |z   k  rd}d}nt        |      d|z  kD  rd|z  t        j                  |      z  }nt        |      |k  r|}| |z  } |
|||      } 	 |dk(  rt        |||||       \  }!}"}#}$n|dk(  rt        |||+|||       \  }!}"}#}$}}"|z
  }%$|z
  }&t        j                  |%|%      t        j                  |%|&      z  }|"}|$}#+|dk(  r|j                  |#       |dz  }t        |||      }'t        ||      }(t        |'|||(|d   |d      })|)S # t        $ r Y <w xY w)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                     d| z   dz  z  S )Nr   r   r   )kxFf_0s      r   eta_strategyz#_root_df_sane.<locals>.eta_strategyJ   s    !a%!##r   c                     dz  z  S )N      ?r   )r   f_knexps    r   fnormz_root_df_sane.<locals>.fnormO   s    T?"r   c                 H    t         j                  j                  |       z  S N)nplinalgnorm)r   r   s    r   fmeritz_root_df_sane.<locals>.fmeritS   s    yy~~a $&&r   r   r   Fz&too many function evaluations requiredTziter %d: ||F|| = %g, sigma = %gz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$   r*   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_sanerX      s   b ?+++>+8JKLLD	$ }	#' 3D,6tR7;VT-K)AsGS#z 	
A
CGSzH q)G 	AAI6G
:3q(G6LLMS#dXo--.GI w<!I+%	kBGGG$44G\I%G HsN 1c3'	f$$A!S!WFI%K!r2r'*HCQRTWIJASV+X'r2r1a 3h3h''#s#bggc3&77  & NN2	Qe h 	S*G4AS*%Aa$+ !QQyJF M5  		s   9G 	GGc                    	 t        j                  |      }|j                  	t        j                    |g       j                         }t        j                  |      xs t        j                  |      }|j                         }dd<   |r! 	fd}t        |      }t        |      }n
 	fd}||	 |      ||fS )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                     	d   k\  r
t               	dxx   dz  cc<   t        |       j                  
      }t        j                   |g       j                         }t        |      } |      }||fS Nr   r   )r	   _real2complexreshaper!   asarrayravel_complex2real)r   zvr   rD   r9   r$   r7   r<   	nfev_listx0_shapes        r   	wrap_funcz_wrap_func.<locals>.wrap_func   sv    |v%$&&aLALa ((2A

4>D>*002Aa Aq	Aa4Kr   c                     d   k\  r
t               dxx   dz  cc<   | j                        } t        j                   | g       j	                         } |      }||fS r[   )r	   r]   r!   r^   r_   )	r   r   rD   r9   r$   r7   r<   rc   rd   s	      r   re   z_wrap_func.<locals>.wrap_func   se    |v%$&&aLAL		(#A

4>D>*002Aq	Aa4Kr   )r!   r^   r&   r_   iscomplexobjr`   )
r7   r8   r$   rc   r<   r9   r   rH   re   rd   s
   ` ````   @r   r.   r.      s    P 
BBxxH


4?T?#))+A$:(:J	BIaL	 	 2!	 	 b(F1Iq*<<r   c                 L    |rt        |       }n| }||j                  |      }|S )zA
    Convert from real to complex and reshape result arrays.
    )r\   r]   )rW   rH   r&   ra   s       r   r6   r6      s/     &!IIeHr   c                 r    t        j                  | t              j                  t         j                        S N)dtype)r!   ascontiguousarrayfloatview
complex128)r   s    r   r\   r\      s$    /44R]]CCr   c                 r    t        j                  | t              j                  t         j                        S rj   )r!   rl   complexrn   float64)ra   s    r   r`   r`     s$    166rzzBBr   )r   g:0yE>gYni  NNF
   Ng|=r   r   )r   r    )__doc__r/   numpyr!   scipy.optimizer   scipy.optimize._optimizer   _linesearchr   r   	Exceptionr	   rX   r.   r6   r\   r`   r   r   r   <module>rz      sS      ) ; V	Y 	 FJLP<BVrG=T
DCr   