o 4BiZ@szddlZddlmZmZmZddlmmZ ddl m Z deeddeddddZ d d Z dddddd ddd d ZdS)N)_xtol_rtol_iter) _RichResult)argsxatolxrtolfatolfrtolmaxitercallbackcCs@t|||||||| } | \}}}}}}}} t|||f|} | \}} } }}}| \}}| \}}tj|tjtd}d\}}|durAtn|}|durItn|}|durUt |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)rN?)x1f1x2f2x3f3tr r r r nitnfevstatus) rr)xxmin)funfminrrrrxlrflr)xrr)frrcSs|j|j|j|j}|SN)rrr)workrrr\/var/www/html/Trade-python/venv/lib/python3.10/site-packages/scipy/optimize/_chandrupatla.py pre_func_evalsz$_chandrupatla..pre_func_evalcSs|j|j|_|_t|t|jk}|}|j||j||j|<|j|<|j||j||j|<|j|<|||_|_dSr*) rcopyrrrnpsignrr)rfr+jnjrrr,post_func_evals ""z%_chandrupatla..post_func_evalcSsrt|jt|jk}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|jt|jk|@}tjtjtj|j|<|j|<|j|<d||<t|jt|j@t|j@t|j@|B}tjtjtj|j|<|j|<|j|<d||<|S)NrT)r/absrrchooserrrr! zeros_likebooldxr r tolr r eim _ECONVERGEDrr0nan _ESIGNERRisfinite _EVALUEERR)r+istoprrr,check_terminations.  (  (z(_chandrupatla..check_terminationc Ss|j|j|j|j}|j|j|j|j}|j|j|j|j}dtd||k|t|k@}|j||j||j|||f\}}}}t|d} |||||||||||||| |<d|j |j } t | | d| |_ dS)Nrr) rrrrrrr/sqrt full_liker:r9clipr) r+xi1phi1alphar2f1jf2jf3jalphajrtlrrr,post_termination_checks$* z-_chandrupatla..post_termination_checkcS|d|d|d|df\}}}}|d|dk}t|||f|d<t|||f|d<t|||f|d<t|||f|d<|SNr%r(r'r)r/r6resshaper%r(r'r)rArrr,customize_result$z'_chandrupatla..customize_result)_chandrupatla_ivr; _initializer/rE _EINPROGRESSintrrfinfotinyminimumr5r_loop)funcabrr r r r r rrTtempxsfsrUrrrrrrrrr+res_work_pairsr-r4rCrOrVrrr, _chandrupatlas8 r " rgc Cst|stdt|s|f}t|dur|nd|dur|nd|dur&|nd|dur-|ndg}t|jtjrMt|dksMtt |sM|j dkrQtdt |} || ks]|dkratd|durmt|smtd||||||||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/iterableasarray issubdtypernumberanyisnanrUr[) r`rr r r r r rtols maxiter_intrrr,rXs(  rXdc!Cst||||||| | } | \}}}}}}} } |||f} t|| |} | \}} }}}}| \}}}|\}}}|d}tj|tjtd}d\}}|durOt|j n|}|dur[t|j n|}|durgt|j n|}|durvt t|j n|}t |||ft |||f} }tj | dd}tj| |dd\}}}tj||dd\}}}|}td"id|d|d |d |d |d |d |d|d|d|d|d|d|d|d|d|}gd}dd}dd}dd}dd}d d!} t|| || |||||||| | S)#aFind 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. ]) gw?r)rNr)axisrrrrrrphir r r r rrrq0r) r)rr)r rr"r#r$)xmr)r(rr&)fmr)r)rc Ss|j|j}|j|j}||j|j}||j|j}|||}d||j|j|j|j}t||jdt|k}||}t|||j||j|k} |j|| t ||| |j|| || <|jd|j |} || |<||_| S)Nrr) rrrrrrr5rwxtolr/r0rv) r+x21x32ABCq1rAxir2rrrr,r-s     2z-_chandrupatla_minimize..pre_func_evalcSst||jt|j|jk}|||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+rArx1ix2ix3ifif1if2if3ir2nixnix1nix2nix3nifnif1nif2nif3nirrr,r4s$"**4**4"""&z._chandrupatla_minimize..post_func_evalcSstj|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 |jt|j|jk}|j|}|j ||j|<||j |<|j|}|j||j|<||j|<t|j|j|j|_t|j |jd|jk}t|j|j|j}||jd|j|jd|kO}||M}dt j||<|j |<|S)NrTr)r/r7rr8rrrr=rr;r>rr?rr@r5r r rzr r r<)r+rBrAfinitercftolrrr,rCs,*      " z1_chandrupatla_minimize..check_terminationcSsdSr*r)r+rrr,rOsz6_chandrupatla_minimize..post_termination_checkcSrPrQrRrSrrr,rVrWz0_chandrupatla_minimize..customize_resultr)rXr;rYtyper/rErZr[r\r]rDepsvstackargsorttake_along_axisr.rr_)!r`rrrrr r r r r rrTrdrcrerUrrrrrvrrrrArwr+rfr-r4rCrOrVrrr,_chandrupatla_minimizesd u    "2%. r)numpyr/ _zeros_pyrrr(scipy._lib._elementwise_iterative_method_lib_elementwise_iterative_methodr;scipy._lib._utilrrgrXrrrrr,s  Y