"j <ddlZddlZddlmZmZddlmZmZm Z ddl m cm Z dZdZdZdZd ZdZdZdd Z dd Zd ZdZdZdS)N) _RichResult_call_callback_maybe_halt)array_namespacexp_sizexp_result_typeFcF t|} t|nt|dd jg|R}|d|||dc} fd|D}fd|D}|dj |dj |r< d fd t j  fd |D} fd Dd } |d | } fd |D} t| st| j d|D gz|s% dstdfd|D}fd|D}fd|D}fd|D}fdD|| fS)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`. 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`. NT)force_floatingxpc>g|]}|Sdtypeasarray).0xxatrs VC:\Projects\DSCons\.venv\Lib\site-packages\scipy\_lib\_elementwise_iterative_method.py z_initialize..Ys) / / /q"**Qc* " " / / /cHg|]}|gRSr)rrargsfuncrs rrz_initialize..Zs3 1 1 1"**TT!^d^^^ $ $ 1 1 1rr)shaper cldtt|z z}|||g|Ri|S)N)r)len)rr!r rkwargsifshapes rr z_initialize..func`sBc&kkCJJ./A4!.t...v.. .rc<g|]}|Sr broadcast_to)rrr!rs rrz_initialize..ds' 4 4 4Abooa'' 4 4 4rc<g|]}|Srr()rargr!rs rrz_initialize..es'<<<U++<<.ks 111AGu$111rcg|] }|j Srr)rr-s rrz_initialize..rs111QW111rz real floatingz3Abscissae and function output must be real numbers.c@g|]}|dST)rcopyr)rrxfatrs rrz_initialize..u+ ; ; ;1"**Qd* . . ; ; ;rc@g|]}|dSr0r)rr-r2rs rrz_initialize..vr3rc<g|]}|dSr reshape)rrrs rrz_initialize..z' + + +1"**Q   + + +rc<g|]}|dSr6r8)rr-rs rrz_initialize..{r:rcfg|]-}|dd.S)T)r1r7)r9r)rr+rs rrz_initialize..|s7 J J JcBJJrzz#Dz115 9 9 J J Jr) r#rrbroadcast_arraysr!npbroadcast_shapeslowerall ValueError result_typeisdtype)r xsr complex_okpreserve_shapernxxasfsmessage shapes_equalr&r!rr2s` ` ` @@@@r _initializerMsb RB!#"  B "Tb 9 9 9C "  )r )D ) ) )C3B3xRSSHB / / / / /B / / /B 1 1 1 1 1 1b 1 1 1B qEKE U[F=!&T / / / / / / /#FE22 4 4 4 4 4 4 4 4<<<<11b111SE9 ;D Pbjj??PNOOO ; ; ; ; ; ; ; ;B ; ; ; ; ; ; ; ;B , + + + + + +B + + + + + + +B J J J JT J J JD RudB ..rc   tdd}tj| } fd| D}  j|d<  t j |d<  j |d<  j |d <t|}||_ t||| || | }|(t||| ||| | }t||rd }|j|krt!|r|sr||}|j rs|j d j|jkrXg}|j D]G}|j|jz }|jd |zz}| ||H||_ |j}|r ||d z}||g|j R} |}|r, ||} ||}|xj|jdkrdn |jdz c_|||||xjdz c_t||| || | }|)t||| ||| | }t||rd }n>t!|d krn*| ||j|krt!|r|st-j|jdd|rt4nt6|_t||| ||| | S)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. NzMust provide xp.FcFi|]\}}|Sr)zeros)rr%jr n_elementsrs r z_loop..s/PPPA288Je844PPPrrsuccessstatusnitnfevTr)rr7rr )NotImplementedErrormathprodarangerPboolfullr _EINPROGRESSint32rr_check_termination_prepare_resultrrVrndimr!appendr9rWxpxatrUset _ECALLBACK _ECONVERR)workcallbackr!maxiterr rr pre_func_evalpost_func_evalcheck_terminationpost_termination_checkcustomize_resultres_work_pairsrrG cb_terminateactiveres_dictrestemprr+ n_new_dims new_shapex_shaper-rRs ` ` @r_looprzsR z!"4555L5!!J YYz " "FPPPPPPPPPH((:RW(==HYRZZ -E-ERXVVHXhhzh::HUOxx "(x;;HV h  CDI c>6 1>2GGFtS.&%/EE $Xt 4 4 L (W    *  M$   9 1*af44Dy 8 8Vch. IZ7  BJJsI667777DI'  / 1uu}..A D TY    JJqJ & &  ' 1g&&A 1g&&A !&A++QQ172;6 q!T""" A #D#~v$5~rKK  "4nfe#3^RIID(488 #  6??a   t$$$O (W    * R&%%aaa(,,<-VZZYWWDK 4nfe+^R A AArc R ||}||rt||||||||r||}| | }|sY|D],\}} |dvr t| dddkr| n| ||<- fd|jD|_|S)N>nrrbrc g|] }| Srr)rr+proceeds rrz&_check_termination..)s;;;#W;;;r)any_update_activeitemsgetattrr) rirurqrsrnrGrstopkeyvalr~s @rr`r`s  T " "D vvd||< tS.&$PRSSS  .3s#EEE d4dEEErrrTTrb)rU zeros_likerdrerfrr) rirurqrsmaskrGr update_dict active_maskrrs ` rrr.s FEEEnEEEK![A-K    B----K&--f599$??K%,K'--// B BS*1#vq*A*AA*E*Ec+&&36#c(++K8<#>c$iiC6#c(++K8<