+ Yj~<^RIt^RIt^RIHtHt^RIHtHtH t ^RI H uH t R tR tR tR tR t^t^tRRltRRltRtRtRtR#)N) _RichResult_call_callback_maybe_halt)array_namespacexp_sizexp_result_typec a\V4pVf \V!MTpVe8.VOVP4O5p\VP 44pRVRV/Rlp\ VRRRV/p VP !.VOVO5!p V RVWRr!VU u.uFqPWR7NK pp VU u.uFqPV!V .VO5!4NK p p V^,Pp V ^,PoV'dbR V RV/V3R llp\P!SV 4p VU u.uFqPW4NK pp VUu.uFqPW4NK ppR pVeR VP4 2pV Uu.uFpVPV 8HNK pp\V4'g \V4hVP!V Uu.uFpVP NK upV .,!pV'g$VP#VR 4'g \R4hVU u.uFqPV VRR7NK pp V Uu.uFpVPVVRR7NK p pVU u.uFqP%V R4NK pp V Uu.uFpVP%VR4NK p pVUu.uF%qP%VPVRR7R4NK' ppWWV VV3#uup iuup iuup iuupiuupiuupiuup iuupiuup iuupiuupi)aInitialize abscissa, function, and args arrays for elementwise function Parameters ---------- func : callable An elementwise function with signature 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``. xs : tuple of arrays Finite real abscissa arrays. Must be broadcastable. args : tuple, optional Additional positional arguments to be passed to `func`. kwargs : tuple, optional Additional keyword arguments to be passed to `func`. preserve_shape : bool, default:False When ``preserve_shape=False`` (default), `func` may be passed arguments of any shape; `_scalar_optimization_loop` is permitted to reshape and compress arguments at will. When ``preserve_shape=False``, arguments passed to `func` must have shape `shape` or ``shape + (n,)``, where ``n`` is any integer. xp : namespace Namespace of array arguments in `xs`. Returns ------- xs, fs, args : tuple of arrays Broadcasted, writeable, 1D abscissa and function value arrays (or NumPy floats, if appropriate). The dtypes of the `xs` and `fs` are `xfat`; the dtype of the `args` are unchanged. shape : tuple of ints Original shape of broadcasted arrays. xfat : NumPy dtype Result dtype of abscissae, function values, and args determined using `np.result_type`, except integer types are promoted to `np.float64`. Raises ------ ValueError If the result dtype is not that of a real scalar Notes ----- Useful for initializing the input of SciPy functions that accept an elementwise callable, abscissae, and arguments; e.g. `scipy.optimize._chandrupatla`. Nkwnamesfuncc\V4\V4, p\\WVR44pV!V.VRVO5/VBVB#)N)lendictzip)xr r argskwargsnargskwarrayss&$$*, i/home/luca/screen-checking/.venv/lib/python3.14/site-packages/scipy/_lib/_elementwise_iterative_method.pyr _initialize..funcWsIIG ,ECef67H?D%L?H?? ?force_floatingTxpdtypeshapecl<R\S4\V4, ,pV!W,.VO5/VB#)r)r)r )rrr rrifshapes&$$*, rr rks1c&kCJ./A.t.v. .rzpThe shape of the array returned by `func` must be the same as the broadcasted shape of `x` and all other `args`.zWhen `preserve_shape=False`, z real floatingz3Abscissae and function output must be real numbers.)rcopy)r)r rvaluestuplekeysrbroadcast_arraysasarrayrnpbroadcast_shapes broadcast_tolowerall ValueError result_typerisdtypereshape)r xsrr complex_okpreserve_shapernxr xatxasrfsrargmessagef shapes_equalxfatrs&&&&&&& @r _initializer<sh RB!#" B (( ( & @7 @ @ " 9T 9b 9C   )r )D )C3BxS,. /Bq**Q* "BB /.0 1b**T!^d^ $bB 1 qEKKE U[[F / /T /##FE213 4Aooa' 47;>b1bQWWb1SE9 ;D bjj??NOO8: ;1**Qd* .B ;8: ;1"**Qd* .B ;)+ +1**Q B +(* +1"**Q B +EI JTcJJrzz#Dz15 9TD J RudB ..I 0 15< 22 < ; , + JsBK%!K K<K4K:K K#-K(K-0K2+K7c V f \R4hRp\P!V4pV PV4pV UUu/uFwppVV P VVR7bK pppV P VV P R7VR&V P VV P\4V PR7VR&V P VV PR7VR&V P VV PR7VR&\V4pWPn \VVV VWV 4pVe&\VVV VVWV 4p\VV4'dRpVPV8Ed\!V4'EdV'EgV'EdV!V4pVP'dVP^,P"VP"8wdt.pVPF[pVP"VP", pVP$R V,,pVP'V P)VV44K] WPn VP$pV'dV P)VVR ,4pV!V.VPO5!pV PVVR7pV'd%V P)VV4pV P)VV4pT;P*VP"^8Xd^MVP$R ,, unV!VVV4V;P^, un\VVV VWV 4pVe'\VVV VVWV 4p\VV4'dRpM\!V4^8XdM V !V4EK%\,P.!VP04R ,P3V'd\4M\64Vn\VVV VVWV 4#uuppi) a Main loop of a vectorized scalar optimization algorithm Parameters ---------- work : _RichResult All variables that need to be retained between iterations. Must contain attributes `nit`, `nfev`, and `success`. All arrays are subject to being "compressed" if `preserve_shape is False`; nest arrays that should not be compressed inside another object (e.g. `dict` or `_RichResult`). callback : callable User-specified callback function shape : tuple of ints The shape of all output arrays maxiter : Maximum number of iterations of the algorithm func : callable The user-specified callable that is being optimized or solved args : tuple Additional positional arguments to be passed to `func`. dtype : NumPy dtype The common dtype of all abscissae and function values pre_func_eval : callable A function that accepts `work` and returns `x`, the active elements of `x` at which `func` will be evaluated. May modify attributes of `work` with any algorithmic steps that need to happen at the beginning of an iteration, before `func` is evaluated, post_func_eval : callable A function that accepts `x`, `func(x)`, and `work`. May modify attributes of `work` with any algorithmic steps that need to happen in the middle of an iteration, after `func` is evaluated but before the termination check. check_termination : callable A function that accepts `work` and returns `stop`, a boolean array indicating which of the active elements have met a termination condition. post_termination_check : callable A function that accepts `work`. May modify `work` with any algorithmic steps that need to happen after the termination check and before the end of the iteration. customize_result : callable A function that accepts `res` and `shape` and returns `shape`. May modify `res` (in-place) according to preferences (e.g. rearrange elements between attributes) and modify `shape` if needed. res_work_pairs : list of (str, str) Identifies correspondence between attributes of `res` and attributes of `work`; i.e., attributes of active elements of `work` will be copied to the appropriate indices of `res` when appropriate. The order determines the order in which _RichResult attributes will be pretty-printed. preserve_shape : bool, default: False Whether to compress the attributes of `work` (to avoid unnecessary computation on elements that have already converged). Returns ------- res : _RichResult The final result object Notes ----- Besides providing structure, this framework provides several important services for a vectorized optimization algorithm. - It handles common tasks involving iteration count, function evaluation count, a user-specified callback, and associated termination conditions. - It compresses the attributes of `work` to eliminate unnecessary computation on elements that have already converged. zMust provide xp.FrsuccessstatusnitnfevT:NNN)r!r )NotImplementedErrormathprodarangezerosboolfullr& _EINPROGRESSint32rr_check_termination_prepare_resultrr@rndimrappendr/rAxpxatr?set _ECALLBACK _ECONVERR)workcallbackrmaxiterr rr pre_func_evalpost_func_evalcheck_terminationpost_termination_checkcustomize_resultres_work_pairsrr2 cb_terminate n_elementsactiverjres_dictrestemprr7 n_new_dims new_shapex_shaper9s&&&&&&&&&&&&&&& r_looprhs)R z!"455L5!J YYz "FAOPA288Je844HP((:RWW(=HYRZZ -ERXXVHXhhzh:HUOxx "((x;HV h CI c>6 12GFtS.&%/E $Xt 4 4L ((W ** $  9991**aff4DyyVVchh. IIZ7  BJJsI67!I''  1uu}.A  TYY  JJqJ &  1g&A 1g&A !&&A+Q1772;6 q!T" A #D#~v$5rK  "4nfe#3RID(488#  6?a  t$&&%a(,,nr)any_update_activeitemsgetattrr) rUrcr]r`rZr2rstopproceedkeyvalr7s &&&&&&& rrLrLs T "D vvd|| t.$PRS NTrN)r? zeros_likerPrQrRrmrn) rUrcr]r`maskr2rkey1key2 update_dict active_maskrqrrs &&&&&&& rrlrl9su 7EEn 4d#nKE![[A-K   ---K&&-f599$?K%,K'--/*1#vq*AA*Ec&366#(+K8<ciC66#(+K8< _order_keys)rrlrmr/rNr) rUrcr]r`rr\r2rrqrrrdrras &&&&&&&& rrMrMUs ((*C4ndNO S (EIIKzz#%#yyA~484 $n'Endan'EEC    (Fs6 Br!)NFNN)F)rDnumpyr'_utilrr _array_apirrrscipy._external.array_api_extra _externalarray_api_extrarP _ESIGNERRrT _EVALUEERRrS _EINPUTERR _ECONVERGEDrJr<rhrLrlrMr|rrrs] 9@@--        k/\MA`<98r