(phLzSSKrSSKJs Jr SSKJr SSKJ r J r J r Sr Sr SrSSSSSSS .S jjrS rSSSSSSSS .S jrg)N) _RichResult)array_namespacexp_ravelxp_default_dtypec j[U5(d [S5e[R"U5(dU4n[ U5nUR U5SnUR URS5(a!UR URS5(a [S5eUR URS5(dUR U[U5S9nSn UcURnS n Uc UR*OUnUc UROUnUcS OUnURXR U5UR U5UR U5UR U55upp4nUR URS5(a!UR URS5(a [S 5eUR URS5(a!UR URS5(a [S 5eUR URS5(a!UR URS5(a [S 5eUR URS5(a!UR URS5(a [S5eURUS:5(d [S5eU (aBXRXA- S- UR S55-nURX!RSS9nUR U5nSn UR URS5(a9UR[!5:wd!UR URS5(a [U 5e[#US5n X{:XaUS:a [U 5eXX#XEXgU4 $)N`func` must be callable.numericcomplex floating`xl0` must be numeric and real. real floatingdtypeFT@`xr0` must be numeric and real. `xmin` must be numeric and real. `xmax` must be numeric and real."`factor` must be numeric and real.0All elements of `factor` must be greater than 1.g?copy)`maxiter` must be a non-negative integer.r)callable ValueErrornpiterablerasarrayisdtyperrnaninfbroadcast_arraysallminimumastypeshapetupleint) funcxl0xr0xminxmaxfactorargsmaxiterxpxr0_not_suppliedmessage maxiter_ints J/var/www/html/venv/lib/python3.13/site-packages/scipy/optimize/_bracket.py_bracket_root_ivr9 s D>>344 ;;t  w  B **S/" C JJsyy) , , ::cii!3 4 4:;; ::cii 1 1jj$4R$8j9  {fflBFF7D\266tD>RvF#%#6#6 ZZ_bjj. 40@"**VBT$V Cd& JJsyy) , , ::cii!3 4 4:;; JJtzz9 - - ::djj"4 5 5;<< JJtzz9 - - ::djj"4 5 5;<< JJv||Y / / ::fll$6 7 7=>> 66&1*  KLLJJ Q 3@@iiYYUi3jj!G9G JJw}}i 0 0GMMUW4Lzz'--);<<!!gbk"K  !Wq[!! ctb @@r i)r/r0r1r2r3c^%Sn[XX#XEXg5n U u pp#pEpgm%X4n [R"X U5n U up ppm%U up[T%R T%R X<5U SS9T%S9n[T%R T%R XL5U SS9T%S9nX1:*X:-X$:*-)nT%R U 5nT%R U 5nT%R X45nURSS-nT%R UUSUSU45nT%R UUSUSU45nUnT%R X445n[T%R X\5T%S9nT%R X]SS9nT%R XU45nT%RSU-5nUVs/sHnT%R UU45PM nnU S-n T%RU5nU)nT%RU5nUUUU- UU'UUUU- UU'T%RU[RT%RS9n[RUU'S unn[S"0S U_S U_S U_S U_SU_SU_SU_SU_SU_SU_SU_SU_SU_ST%R _ST%R _ST%R _ST%R _SU_6n/SQnU%4Sjn Sn!U%4Sjn"S n#U%4S!jn$[R""UXXpXmU U!U"U#U$UT%5$s snf)#alBracket the root of a monotonic scalar function of one variable This function works elementwise when `xl0`, `xr0`, `xmin`, `xmax`, `factor`, and the elements of `args` are broadcastable arrays. Parameters ---------- func : callable The function for which the root is to be bracketed. 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``. xl0, xr0: float array_like Starting guess of bracket, which need not contain a root. If `xr0` is not provided, ``xr0 = xl0 + 1``. Must be broadcastable with one another. xmin, xmax : float array_like, optional Minimum and maximum allowable endpoints of the bracket, inclusive. Must be broadcastable with `xl0` and `xr0`. factor : float array_like, default: 2 The factor used to grow the bracket. See notes for details. args : tuple, optional Additional positional arguments to be passed to `func`. Must be arrays broadcastable with `xl0`, `xr0`, `xmin`, and `xmax`. If the callable to be bracketed requires arguments that are not broadcastable with these arrays, wrap that callable with `func` such that `func` accepts only `x` and broadcastable arrays. maxiter : int, optional The maximum number of iterations of the algorithm to perform. 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. xl, xr : float The lower and upper ends of the bracket, if the algorithm terminated successfully. fl, fr : float The function value at the lower and upper ends of the bracket. nfev : int The number of function evaluations required to find the bracket. This is distinct from the number of times `func` is *called* because the function may evaluated at multiple points in a single call. nit : int The number of iterations of the algorithm that were performed. status : int An integer representing the exit status of the algorithm. - ``0`` : The algorithm produced a valid bracket. - ``-1`` : The bracket expanded to the allowable limits without finding a bracket. - ``-2`` : The maximum number of iterations was reached. - ``-3`` : A non-finite value was encountered. - ``-4`` : Iteration was terminated by `callback`. - ``-5``: The initial bracket does not satisfy `xmin <= xl0 < xr0 < xmax`. - ``1`` : The algorithm is proceeding normally (in `callback` only). - ``2`` : A bracket was found in the opposite search direction (in `callback` only). success : bool ``True`` when the algorithm terminated successfully (status ``0``). Notes ----- This function generalizes an algorithm found in pieces throughout `scipy.stats`. The strategy is to iteratively grow the bracket ``(l, r)`` until ``func(l) < 0 < func(r)``. The bracket grows to the left as follows. - If `xmin` is not provided, the distance between `xl0` and `l` is iteratively increased by `factor`. - If `xmin` is provided, the distance between `xmin` and `l` is iteratively decreased by `factor`. Note that this also *increases* the bracket size. Growth of the bracket to the right is analogous. Growth of the bracket in one direction stops when the endpoint is no longer finite, the function value at the endpoint is no longer finite, or the endpoint reaches its limiting value (`xmin` or `xmax`). Iteration terminates when the bracket stops growing in both directions, the bracket surrounds the root, or a root is found (accidentally). If two brackets are found - that is, a bracket is found on both sides in the same iteration, the smaller of the two is returned. If roots of the function are found, both `l` and `r` are set to the leftmost root. NFrr4rr)rr)rrxx0flimitr1activedx_lastf_lastnitnfevstatusr2xlxrflfrn) rGrGrHrHrIrIrErErFrFrJrJrKrK)r=r=)r?r?)rCrC)rDrDc>TRUR5nTRUR5nURU==UR U-ss'UR UURU-X'U)nURU==UR U-ss'URUURU- X'U$N) zeros_liker=isinfr@rBr1r>)workr=inir4s r8 pre_func_eval$_bracket_root..pre_func_evals MM$&& ! HHTZZ  q T[[^# wwqzDFF1I%R r dkk"o%  2+r:c`URUlURUlXlXlgrU)r=rCr?rDr=r?rXs r8post_func_eval%_bracket_root..post_func_evals$ff ff r:c>UR[R:HnTRUR5nTRUR 5nX2*:HUS:H-US:H-U)-n[R URU'SX'URUUR-SUR--nTRURU5nX`RRS:nXgXWpVXeURU:HnTRU5nSXF'XA)-n[URU'SX'URUR:HU)-n[URU'SX'TR!UR5TR!UR5-)U)-n[R"URU'SX'U$)NrTr)rGeim _EINPUTERRsignr?rD _ECONVERGEDrArL searchsortedr)rV _ESTOPONESIDEr=r@_ELIMITSisfinite _EVALUEERR) rXstopsfsf_lastrY also_stopjmaskr4s r8check_termination(_bracket_root..check_terminations s~~-WWTVV_''$++&nA ."' :te C A"[[^dff,466:  OODKK 3 ;;$$Q''w 9 4;;q>) * MM$  I& AVVtzz !dU *! Akk$&&!BKK$77 8D5 @ A r:cgrUr rXs r8post_termination_check-_bracket_root..post_termination_checkO r:c>USRSS-nUSSUnUSSUnUSUSnUSUSnUSSUnUSSUnUSUSn USUSn TRUSS9n TRUSS9n TRUSS9n TRU SS9nUS SUnUS USnXC- nXe- nUU:*US:H-US:HUS:g--nUU:*US:H-US:HUS:g--nUUU U'UUUU'UUU U'U UU U'XS 'XS 'XS 'XS 'TRUSSUUSUS5US'USSUUSUS-US'TRUS:HUU5US 'US S:HUS'US US US US USS$)Nr=rrrCr?rDTrrGrHrIrJrKrErFsuccessr)r)r!maximumwhere)resr)rLxalxarxblxbrfalfarfblfbrrHrJrIrKsasbdadbi1i2r4s r8customize_result'_bracket_root..customize_resultRsL HNN1  "#hrl(mBQ(mAB#hqrl#hrl(mBQ(mAB#hqrlZZ$Z ' ZZ$Z ' ZZ$Z ' ZZ$Z ']2A  ]12  Y YRxB!G$"'bAg)> ?RxB!G$"'bAg)> ?R2R2R2R2D D D D ZZE 2AE 12?E &k"1oF AB7F q"b1H h-1,I H H M MSbzr:r )r9rb _initializerr( broadcast_toconcatr)arangerWrV full_like _EINPROGRESSint32rcrr#_loop)&r,r-r.r/r0r1r2r3callbacktempxsfsr)rinvalid_bracketr=r?rLrCrDr>r@rAargrYrZrBrGrErFrXres_work_pairsr[r_rqrurr4s& @r8 _bracket_rootrKsaJH Ds$ ND<@9Ds$r B ??4T *D+/(DbbHC BIIbood:EINSU VD BIIbood:EINSU VD3s{CDO " A " Aii BCO  aA YY!"q!u~ &F YY!"q!u~ &F B IItl #E boof4 F!nnF?IC  H Hr HQ He HF H$ H() H28 HAG H H%) H28 H?C H&& H&(VV H13 H<>66 HFG HDBN $=~ JX 99T8G4"N4E+-=~ O 3s=Kc [U5(d [S5e[R"U5(dU4n[ U5n U R U5SnU R URS5(a!U R URS5(a [S5eU R URS5(dU R U[U 5S9nUc U R*OUnUc U ROUnSn UcU RnS n Sn UcU RnS n UcS OUnU RU R U5XR U5U R U5U R U5U R U55up!p4pVU R URS5(a!U R URS5(a [S 5eU R URS5(a!U R URS5(a [S 5eU R URS5(a!U R URS5(a [S 5eU R URS5(a!U R URS5(a [S5eU R URS5(a!U R URS5(a [S5eU RUS:5(d [S5eU (aBXRX- S- U R S55- nU RX!RSS9nU (aBXRXQ- S- U R S55-nU RX1RSS9nU R U5nSn U R URS5(a9UR[!5:wd!U R URS5(a [U 5e[#US5n X:XaUS:a [U 5eXX#XEXgX4 $)Nr r r r z`xm0` must be numeric and real.rrFTrrrrrrrrg?rrr)rrrr rr!r"rrr$r#r%r&r'r(r)r*r+)r,xm0r-r.r/r0r1r2r3r4xl0_not_suppliedr5r6r7s r8_bracket_minimum_ivrs D>>344 ;;t  w  B **S/" C JJsyy) , , ::cii!3 4 4:;; ::cii 1 1jj$4R$8j9lBFF7D\266tD  {ff {ffNSF(*(;(; 3jjorzz$/? 4"**V,)%Cc JJsyy) , , ::cii!3 4 4:;; JJsyy) , , ::cii!3 4 4:;; JJtzz9 - - ::djj"4 5 5;<< JJtzz9 - - ::djj"4 5 5;<< JJv||Y / / ::fll$6 7 7=>> 66&1*  KLL JJ B 3@@iiYYUi3JJ B 3@@iiYYUi3jj!G9G JJw}}i 0 0GMMUW4Lzz'--);<<!!gbk"K  !Wq[!! cF' EEr:)r-r.r/r0r1r2r3c^"Sn [XX#XEXgU5 n U u pp#pEpgnm"X!U4n [R"X U5n U up ppm"U up!nU unnnT"RT"R XM5USS9n[ UT"S9nT"RT"R X]5USS9n[ UT"S9nXB:*X!:-X:-X5:*-)nT"RT"R Xm5USS9n[ U5nUU:nUUUUsUU'UU'UUUUsUU'UU'T"R UXE5nT"RU5nU)nT"RU5nUUUU- UU'UUUU- UU'SUU- UU'T"RU[RT"RS9n[RUU'Sunn[X!X3UUUUUUUUUUUS 9n/S QnU"4S jnS nU"4S jnSn Sn![R"UXXX~UUUU U!UT"5$)aBracket the minimum of a unimodal scalar function of one variable This function works elementwise when `xm0`, `xl0`, `xr0`, `xmin`, `xmax`, and the elements of `args` are broadcastable arrays. Parameters ---------- func : callable The function for which the minimum is to be bracketed. 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`. xm0: float array_like Starting guess for middle point of bracket. xl0, xr0: float array_like, optional Starting guesses for left and right endpoints of the bracket. Must be broadcastable with one another and with `xm0`. xmin, xmax : float array_like, optional Minimum and maximum allowable endpoints of the bracket, inclusive. Must be broadcastable with `xl0`, `xm0`, and `xr0`. factor : float array_like, optional Controls expansion of bracket endpoint in downhill direction. Works differently in the cases where a limit is set in the downhill direction with `xmax` or `xmin`. See Notes. args : tuple, optional Additional positional arguments to be passed to `func`. Must be arrays broadcastable with `xl0`, `xm0`, `xr0`, `xmin`, and `xmax`. If the callable to be bracketed requires arguments that are not broadcastable with these arrays, wrap that callable with `func` such that `func` accepts only ``x`` and broadcastable arrays. maxiter : int, optional The maximum number of iterations of the algorithm to perform. The number of function evaluations is three greater than the number of iterations. 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. xl, xm, xr : float The left, middle, and right points of the bracket, if the algorithm terminated successfully. fl, fm, fr : float The function value at the left, middle, and right points of the bracket. nfev : int The number of function evaluations required to find the bracket. nit : int The number of iterations of the algorithm that were performed. status : int An integer representing the exit status of the algorithm. - ``0`` : The algorithm produced a valid bracket. - ``-1`` : The bracket expanded to the allowable limits. Assuming unimodality, this implies the endpoint at the limit is a minimizer. - ``-2`` : The maximum number of iterations was reached. - ``-3`` : A non-finite value was encountered. - ``-4`` : ``None`` shall pass. - ``-5`` : The initial bracket does not satisfy `xmin <= xl0 < xm0 < xr0 <= xmax`. success : bool ``True`` when the algorithm terminated successfully (status ``0``). Notes ----- Similar to `scipy.optimize.bracket`, this function seeks to find real points ``xl < xm < xr`` such that ``f(xl) >= f(xm)`` and ``f(xr) >= f(xm)``, where at least one of the inequalities is strict. Unlike `scipy.optimize.bracket`, this function can operate in a vectorized manner on array input, so long as the input arrays are broadcastable with each other. Also unlike `scipy.optimize.bracket`, users may specify minimum and maximum endpoints for the desired bracket. Given an initial trio of points ``xl = xl0``, ``xm = xm0``, ``xr = xr0``, the algorithm checks if these points already give a valid bracket. If not, a new endpoint, ``w`` is chosen in the "downhill" direction, ``xm`` becomes the new opposite endpoint, and either `xl` or `xr` becomes the new middle point, depending on which direction is downhill. The algorithm repeats from here. The new endpoint `w` is chosen differently depending on whether or not a boundary `xmin` or `xmax` has been set in the downhill direction. Without loss of generality, suppose the downhill direction is to the right, so that ``f(xl) > f(xm) > f(xr)``. If there is no boundary to the right, then `w` is chosen to be ``xr + factor * (xr - xm)`` where `factor` is controlled by the user (defaults to 2.0) so that step sizes increase in geometric proportion. If there is a boundary, `xmax` in this case, then `w` is chosen to be ``xmax - (xmax - xr)/factor``, with steps slowing to a stop at `xmax`. This cautious approach ensures that a minimum near but distinct from the boundary isn't missed while also detecting whether or not the `xmax` is a minimizer when `xmax` is reached after a finite number of steps. NFrr<Trr)r)rHxmrIr.rJfmrKstepr@limitedr1rErFrGr2) rMrN)rrrOrPrQrR)rrrScN>U=RUR-slTRUR5nURUR )URUR )-XR )'UR UR URUR - XR 'TRXR URUR :HUR UR XR 5XR 'U$rU)rr1 empty_likerIr.rr@r{)rXr=r4s r8r['_bracket_minimum..pre_func_evals T[[ MM$'' "88T\\M2TYY }5MM<<-**T\\2TYYt||5LL,, (( llOtwwt||4 4 JJt|| $ llO ,, r:cURURUsUlUlUlURURUsUlUlUlgrU)rrIrHrrKrJr^s r8r_(_bracket_minimum..post_func_evals>$(GGTWWa!$'$(GGTWWa!$'r:c|>UR[R:HnURUR:UR UR:-URUR:UR UR:--U)-n[R URU'SX'URUR:HU)-n[URU'SX'TRUR5TRUR 5-)U)-n[RURU'SX'U$)NT) rGrbrcrJrrKrerIr@rhrirj)rXrkrYr4s r8rq+_bracket_minimum..check_terminations s~~-WW DGGdgg$5 6ww TWW%78 9 E  AWW "te +! Akk$''"R[[%99 :dU B A r:cgrUr rts r8ru0_bracket_minimum..post_termination_checkrwr:cUSUS:nUSUUSUsUSU'USU'USUUSUsUSU'USU'U$)NrHrIrKrJr )r|r)comps r8r*_bracket_minimum..customize_resultsq4y3t9$+.t9T?CIdO(D $T4+.t9T?CIdO(D $T4 r:)rrbrr(rrr{rWrrrrrcrr)#r,rr-r.r/r0r1r2r3rrrrr)rfl0fm0fr0rrr@ unlimitedrrrGrErFrXrr[r_rqrurr4s# @r8_bracket_minimumrscLH t#Dg VDAE>DsV7B CB ??4T *D+/(DbbMCcMCc 99R__T15u9 ED DR D 99R__T15u9 ED DR D3syAS[QROYYrv5u4Y HF f F 9Dt9c$iCIs4yt9c$iCIs4y HHT4 &EIjG == D9~I6DO7^c'l2DM&/)F7O \\#s//rxx\ @F!nnF?IC ##333 wvSV d %~r  ;;r:rU)numpyr(scipy._lib._elementwise_iterative_method_lib_elementwise_iterative_methodrbscipy._lib._utilrscipy._lib._array_apirrrrhrgr9rrrr r:r8rs`66(MM  ?ADVt$t4Vr OFd(,Dt r4S;r: