a “ Àh¶Zã@szddlZddlmZmZmZddlmmZ ddl m Z deeddeddœdd„Z d d „Z dddddd ddœd d „ZdS)éNé)Ú_xtolÚ_rtolÚ_iter)Ú _RichResult©)ÚargsÚxatolÚxrtolÚfatolÚfrtolÚmaxiterÚcallbackcCs@t|||||||| ƒ} | \}}}}}}}} t |||f|¡} | \}} } }}}| \}}| \}}tj|tjtd}d\}}|dur‚tn|}|dur’tn|}|durªt  |¡j n|}|t  t  |¡t  |¡¡}t ||||ddd|||||||d}gd¢}dd„}d d „}d d „}d d„}dd„}t || |||||||||||¡ S)aFind the root of an elementwise function using Chandrupatla's algorithm. For each element of the output of `func`, `chandrupatla` seeks the scalar root that makes the element 0. This function allows for `a`, `b`, and the output of `func` to be of any broadcastable shapes. Parameters ---------- func : callable The function whose root is desired. The signature must be:: func(x: ndarray, *args) -> ndarray where each element of ``x`` is a finite real and ``args`` is a tuple, which may contain an arbitrary number of components of any type(s). ``func`` must be an elementwise function: each element ``func(x)[i]`` must equal ``func(x[i])`` for all indices ``i``. `_chandrupatla` seeks an array ``x`` such that ``func(x)`` is an array of zeros. a, b : array_like The lower and upper bounds of the root of the function. Must be broadcastable with one another. args : tuple, optional Additional positional arguments to be passed to `func`. xatol, xrtol, fatol, frtol : float, optional Absolute and relative tolerances on the root and function value. See Notes for details. maxiter : int, optional The maximum number of iterations of the algorithm to perform. callback : callable, optional An optional user-supplied function to be called before the first iteration and after each iteration. Called as ``callback(res)``, where ``res`` is a ``_RichResult`` similar to that returned by `_chandrupatla` (but containing the current iterate's values of all variables). If `callback` raises a ``StopIteration``, the algorithm will terminate immediately and `_chandrupatla` will return a result. Returns ------- res : _RichResult An instance of `scipy._lib._util._RichResult` with the following attributes. The descriptions are written as though the values will be scalars; however, if `func` returns an array, the outputs will be arrays of the same shape. x : float The root of the function, if the algorithm terminated successfully. nfev : int The number of times the function was called to find the root. nit : int The number of iterations of Chandrupatla's algorithm performed. status : int An integer representing the exit status of the algorithm. ``0`` : The algorithm converged to the specified tolerances. ``-1`` : The algorithm encountered an invalid bracket. ``-2`` : The maximum number of iterations was reached. ``-3`` : A non-finite value was encountered. ``-4`` : Iteration was terminated by `callback`. ``1`` : The algorithm is proceeding normally (in `callback` only). success : bool ``True`` when the algorithm terminated successfully (status ``0``). fun : float The value of `func` evaluated at `x`. xl, xr : float The lower and upper ends of the bracket. fl, fr : float The function value at the lower and upper ends of the bracket. Notes ----- Implemented based on Chandrupatla's original paper [1]_. If ``xl`` and ``xr`` are the left and right ends of the bracket, ``xmin = xl if abs(func(xl)) <= abs(func(xr)) else xr``, and ``fmin0 = min(func(a), func(b))``, then the algorithm is considered to have converged when ``abs(xr - xl) < xatol + abs(xmin) * xrtol`` or ``fun(xmin) <= fatol + abs(fmin0) * frtol``. This is equivalent to the termination condition described in [1]_ with ``xrtol = 4e-10``, ``xatol = 1e-5``, and ``fatol = frtol = 0``. The default values are ``xatol = 2e-12``, ``xrtol = 4 * np.finfo(float).eps``, ``frtol = 0``, and ``fatol`` is the smallest normal number of the ``dtype`` returned by ``func``. References ---------- .. [1] Chandrupatla, Tirupathi R. "A new hybrid quadratic/bisection algorithm for finding the zero of a nonlinear function without using derivatives". Advances in Engineering Software, 28(3), 145-149. https://doi.org/10.1016/s0965-9978(96)00051-8 See Also -------- brentq, brenth, ridder, bisect, newton Examples -------- >>> from scipy import optimize >>> def f(x, c): ... return x**3 - 2*x - c >>> c = 5 >>> res = optimize._chandrupatla._chandrupatla(f, 0, 3, args=(c,)) >>> res.x 2.0945514818937463 >>> c = [3, 4, 5] >>> res = optimize._chandrupatla._chandrupatla(f, 0, 3, args=(c,)) >>> res.x array([1.8932892 , 2. , 2.09455148]) ©Údtype)réNçà?)Úx1Úf1Úx2Úf2Úx3Úf3Útr r r r ÚnitÚnfevÚstatus) ©rr)ÚxÚxmin)ÚfunÚfmin©rr©rr©Úxlr©Úflr)Úxrr)ÚfrrcSs|j|j|j|j}|S©N)rrr)ÚworkrrrúX/var/www/html/assistant/venv/lib/python3.9/site-packages/scipy/optimize/_chandrupatla.pyÚ pre_func_evalŽsz$_chandrupatla..pre_func_evalcSsŒ|j ¡|j ¡|_|_t |¡t |j¡k}|}|j||j||j|<|j|<|j||j||j|<|j|<|||_|_dSr*) rÚcopyrrrÚnpÚsignrr)rÚfr+ÚjZnjrrr,Úpost_func_eval“s ""z%_chandrupatla..post_func_evalcSsrt |j¡t |j¡k}t ||j|jf¡|_t ||j|jf¡|_tj |jt d}t|j|jƒ|_ t|jƒ|j |j |_|j |jk}|t |j¡|j|jkO}tj|j|<d||<t |j¡t |j¡k|@}tjtjtj|j|<|j|<|j|<d||<t |j¡t |j¡@t |j¡@t |j¡@|B}tjtjtj|j|<|j|<|j|<d||<|S)NrT)r/ÚabsrrÚchooserrrr!Ú zeros_likeÚboolÚdxr r Útolr r ÚeimÚ _ECONVERGEDrr0ÚnanÚ _ESIGNERRÚisfiniteÚ _EVALUEERR)r+ÚiÚstoprrr,Úcheck_terminations.  ( ÿ ÿÿ(z(_chandrupatla..check_terminationc Ss|j|j|j|j}|j|j|j|j}|j|j|j|j}dt d|¡|k|t |¡k@}|j||j||j|||f\}}}}t |d¡} |||||||||||||| |<d|j |j } t  | | d| ¡|_ dS)Nrr) rrrrrrr/ÚsqrtÚ full_liker9r8Zclipr) r+Zxi1Zphi1Úalphar2Zf1jZf2jZf3jZalphajrÚtlrrr,Úpost_termination_check¿s$* ÿz-_chandrupatla..post_termination_checkcSsˆ|d|d|d|df\}}}}|d|dk}t |||f¡|d<t |||f¡|d<t |||f¡|d<t |||f¡|d<|S©Nr%r(r'r)©r/r5©ÚresÚshaper%r(r'r)r@rrr,Úcustomize_resultÐs$z'_chandrupatla..customize_result)Ú_chandrupatla_ivr:Ú _initializer/rDÚ _EINPROGRESSÚintrrÚfinfoÚtinyÚminimumr4rÚ_loop)ÚfuncÚaÚbrr r r r r rrKÚtempÚxsÚfsrLrrrrrrrrr+Úres_work_pairsr-r3rBrGrMrrr,Ú _chandrupatlas8r ÿþ " þr]c Csît|ƒstdƒ‚t |¡s |f}t |dur0|nd|dur>|nd|durL|nd|durZ|ndg¡}t |jtj¡ršt |dk¡sšt t  |¡¡sš|j dkr¢tdƒ‚t |ƒ} || ksº|dkrÂtdƒ‚|durÚt|ƒsÚtdƒ‚||||||||fS)Nz`func` must be callable.rr)éz(Tolerances must be non-negative scalars.z)`maxiter` must be a non-negative integer.z`callback` must be callable.) ÚcallableÚ ValueErrorr/ÚiterableZasarrayZ issubdtyperÚnumberÚanyÚisnanrLrQ) rVrr r r r r rZtolsZ maxiter_intrrr,rNÞs* ýÿÿrNédc!CsÎt||||||| | ƒ} | \}}}}}}} } |||f} t || |¡} | \}} }}}}| \}}}|\}}}| d¡}tj|tjtd}d\}}|duržt |¡j n|}|dur¶t |¡j n|}|durÎt |¡j n|}|durìt  t |¡j ¡n|}t  |||f¡t  |||f¡} }tj | dd}tj| |dd\}}}tj||dd\}}}| ¡}t||||||||||||||||d}gd¢}d d „}d d „}d d„}dd„}dd„} t || || |||||||| |¡ S)a¦Find the minimizer of an elementwise function. For each element of the output of `func`, `_chandrupatla_minimize` seeks the scalar minimizer that minimizes the element. This function allows for `x1`, `x2`, `x3`, and the elements of `args` to be arrays of any broadcastable shapes. Parameters ---------- func : callable The function whose minimizer is desired. The signature must be:: func(x: ndarray, *args) -> ndarray where each element of ``x`` is a finite real and ``args`` is a tuple, which may contain an arbitrary number of arrays that are broadcastable with `x`. ``func`` must be an elementwise function: each element ``func(x)[i]`` must equal ``func(x[i])`` for all indices ``i``. `_chandrupatla` seeks an array ``x`` such that ``func(x)`` is an array of minima. x1, x2, x3 : array_like The abscissae of a standard scalar minimization bracket. A bracket is valid if ``x1 < x2 < x3`` and ``func(x1) > func(x2) <= func(x3)``. Must be broadcastable with one another and `args`. args : tuple, optional Additional positional arguments to be passed to `func`. Must be arrays broadcastable with `x1`, `x2`, and `x3`. If the callable to be differentiated requires arguments that are not broadcastable with `x`, wrap that callable with `func` such that `func` accepts only `x` and broadcastable arrays. xatol, xrtol, fatol, frtol : float, optional Absolute and relative tolerances on the minimizer and function value. See Notes for details. maxiter : int, optional The maximum number of iterations of the algorithm to perform. callback : callable, optional An optional user-supplied function to be called before the first iteration and after each iteration. Called as ``callback(res)``, where ``res`` is a ``_RichResult`` similar to that returned by `_chandrupatla_minimize` (but containing the current iterate's values of all variables). If `callback` raises a ``StopIteration``, the algorithm will terminate immediately and `_chandrupatla_minimize` will return a result. Returns ------- res : _RichResult An instance of `scipy._lib._util._RichResult` with the following attributes. (The descriptions are written as though the values will be scalars; however, if `func` returns an array, the outputs will be arrays of the same shape.) success : bool ``True`` when the algorithm terminated successfully (status ``0``). status : int An integer representing the exit status of the algorithm. ``0`` : The algorithm converged to the specified tolerances. ``-1`` : The algorithm encountered an invalid bracket. ``-2`` : The maximum number of iterations was reached. ``-3`` : A non-finite value was encountered. ``-4`` : Iteration was terminated by `callback`. ``1`` : The algorithm is proceeding normally (in `callback` only). x : float The minimizer of the function, if the algorithm terminated successfully. fun : float The value of `func` evaluated at `x`. nfev : int The number of points at which `func` was evaluated. nit : int The number of iterations of the algorithm that were performed. xl, xm, xr : float The final three-point bracket. fl, fm, fr : float The function value at the bracket points. Notes ----- Implemented based on Chandrupatla's original paper [1]_. If ``x1 < x2 < x3`` are the points of the bracket and ``f1 > f2 <= f3`` are the values of ``func`` at those points, then the algorithm is considered to have converged when ``x3 - x1 <= abs(x2)*xrtol + xatol`` or ``(f1 - 2*f2 + f3)/2 <= abs(f2)*frtol + fatol``. Note that first of these differs from the termination conditions described in [1]_. The default values of `xrtol` is the square root of the precision of the appropriate dtype, and ``xatol=fatol = frtol`` is the smallest normal number of the appropriate dtype. References ---------- .. [1] Chandrupatla, Tirupathi R. (1998). "An efficient quadratic fit-sectioning algorithm for minimization without derivatives". Computer Methods in Applied Mechanics and Engineering, 152 (1-2), 211-217. https://doi.org/10.1016/S0045-7825(97)00190-4 See Also -------- golden, brent, bounded Examples -------- >>> from scipy.optimize._chandrupatla import _chandrupatla_minimize >>> def f(x, args=1): ... return (x - args)**2 >>> res = _chandrupatla_minimize(f, -5, 0, 5) >>> res.x 1.0 >>> c = [1, 1.5, 2] >>> res = _chandrupatla_minimize(f, -5, 0, 5, args=(c,)) >>> res.x array([1. , 1.5, 2. ]) g¨ô—›wãù?r)réNr)Zaxis)rrrrrrÚphir r r r rrrÚq0r) r)rr)r rr"r#r$)Zxmr)r(rr&)Úfmr)r)rc Ssþ|j|j}|j|j}||j|j}||j|j}|||}d||j|j|j|j}t||jƒdt|ƒk}||}t|||j|ƒ|j|k} |j|| t   ||| ¡|j|| || <|jd|j |} || |<||_| S)Nrr) rrrrrrr4rhÚxtolr/r0rg) r+Zx21Zx32ÚAÚBÚCÚq1r@Úxir2rrrr,r-‘s     2z-_chandrupatla_minimize..pre_func_evalcSst ||j¡t |j|j¡k}|||j||j||j|f\}}}}|||j||j||j|f\}} } } || k} || || || <| | <| } || | | || || f\|| <| | <|| <| | <|} || |j| |j| |j| f\}}}}|| |j| |j| |j| f\}}}}||k} || || || <|| <| } || || || || f\|| <|| <|| <|| <||||j|<|j|<|j|<| | | |j|<|j|<|j|<||||j| <|j| <|j| <||||j| <|j| <|j| <dSr*)r/r0rrrrrr)rr1r+r@roZx1iZx2iZx3iÚfiZf1iZf2iZf3ir2ÚniZxniZx1niZx2niZx3niZfniZf1niZf2niZf3nirrr,r3¶s$"**4**4"""z._chandrupatla_minimize..post_func_evalcSs²tj|jtd}|j|jk|j|jkB}tjtj|j|<|j|<dt j ||<|j |<t  |j|j|j |j|j|j¡}||B}tjtj|j|<|j|<dt j||<|j |<t|j |jƒt|j|jƒk}|j|}|j ||j|<||j |<|j|}|j||j|<||j|<t|jƒ|j|j|_t|j |jƒd|jk}t|jƒ|j|j}||jd|j|jd|kO}||M}dt j||<|j |<|S)NrTr)r/r6rr7rrrr<rr:r=rr>rr?r4r r rjr r r;)r+rAr@ZfiniterYZftolrrr,rBÐs,*      " z1_chandrupatla_minimize..check_terminationcSsdSr*r)r+rrr,rGþsz6_chandrupatla_minimize..post_termination_checkcSsˆ|d|d|d|df\}}}}|d|dk}t |||f¡|d<t |||f¡|d<t |||f¡|d<t |||f¡|d<|SrHrIrJrrr,rMs$z0_chandrupatla_minimize..customize_result)rNr:rOÚtyper/rDrPrQrRrSrCÚepsZvstackZargsortZtake_along_axisr.rrU)!rVrrrrr r r r r rrKrZrYr[rLrrrrrgrrrr@rhr+r\r-r3rBrGrMrrr,Ú_chandrupatla_minimizeúsFu ÿ    " þ%. þrt)Únumpyr/Z _zeros_pyrrrZ(scipy._lib._elementwise_iterative_methodZ_libZ_elementwise_iterative_methodr:Zscipy._lib._utilrr]rNrtrrrr,Ús ÿ Yþ