Ug~UddlZddlmZddlZddlZddlZddlZddlmZddl Z ddl Z ddl m Z m Z mZmZddlZddlmZmZmZeeed<eeed<eeed<ejejd kr dd lmZm Z m!Z!m"Z"n dd lmZm Z m!Z!e#Z"eed <eed <ejejdkrb ej$5ej%dde&ej'Z(ej)Z*dddn #1swxYwYn'#e+$rej,Z(ej-Z*YnwxYwej,Z(ej-Z*e e.ej/fZ0e e1ej2ej/fZ3e e4ed<ejejdkrdZ5n\ejejdkrdZ5n6 ej6dg7ddZ5n #e#$rdZ5YnwxYwerNe e e0ej8j9ej8j:fZ;ede ej8j9ej8j:fZ< ddl=m9Z9n#e>$rGddZ9YnwxYwdDdZ?dEdZ@e1ddfdZAd ZBd!e.d"e1fd#ZCd$ZD dFd&ZEdGd'ZFed(gd)ZGd*ZHGd+d,ZIGd-d.ZJ dHd0ZKedId2ZLd3ZMdJd4ZNd5ZOdKd6ZPdLdd8d9ZQdGd:ZRd;ZSdd8d<ZTd=ZUd>ZVGd?d@eWZXdEdAZYdBZZdMdCZ[dS)NN)contextmanager) namedtuple)OptionalUnion TYPE_CHECKINGTypeVar)array_namespaceis_numpysize AxisErrorComplexWarningVisibleDeprecationWarningz1.25.0)r r rDTypePromotionError)r r rnp_longnp_ulongz 2.0.0.dev0ignorez/.*In the future `np\.long` will be defined as.*copy_if_neededz2.0.0z1.28.0Fcopy GeneratorType)bound) GeneratorceZdZdS)rN)__name__ __module__ __qualname__O/var/www/surfInsights/venv3-11/lib/python3.11/site-packages/scipy/_lib/_util.pyrrTs rrc tg|R}||cxurn||td|jg|R}|dgj}||d|d|ddc}||fd|D}|S||}||j|j} |j|| } n^ || fd |D} ||| } | j| } | | <|| <| S) aReturn elements chosen from two possibilities depending on a condition Equivalent to ``f(*arrays) if cond else fillvalue`` performed elementwise. Parameters ---------- cond : array The condition (expressed as a boolean array). arrays : tuple of array Arguments to `f` (and `f2`). Must be broadcastable with `cond`. f : callable Where `cond` is True, output will be ``f(arr1[cond], arr2[cond], ...)`` fillvalue : object If provided, value with which to fill output array where `cond` is not True. f2 : callable If provided, output will be ``f2(arr1[cond], arr2[cond], ...)`` where `cond` is not True. Returns ------- out : array An array with elements from the output of `f` where `cond` is True and `fillvalue` (or elements from the output of `f2`) elsewhere. The returned array has data type determined by Type Promotion Rules with the output of `f` and `fillvalue` (or the output of `f2`). Notes ----- ``xp.where(cond, x, fillvalue)`` requires explicitly forming `x` even where `cond` is False. This function evaluates ``f(arr1[cond], arr2[cond], ...)`` onle where `cond` ``is True. Examples -------- >>> import numpy as np >>> a, b = np.array([1, 2, 3, 4]), np.array([5, 6, 7, 8]) >>> def f(a, b): ... return a*b >>> _lazywhere(a > 2, (a, b), f, np.nan) array([ nan, nan, 21., 32.]) Nz1Exactly one of `fillvalue` or `f2` must be given.TrFrrc3(K|] }|V dSNr.0arrconds r z_lazywhere..s'773t9777777r fill_valuedtypec3(K|] }|V dSr#r)r%r&nconds r r(z_lazywhere..s'==sE ======rr+) r ValueErrorbroadcast_arraysasarrayr+astype result_typefullshapeempty) r'arraysf fillvaluef2xpargs bool_dtypetemp1r+outtemp2r-s ` @r _lazywhererAXsX  ' ' ' 'B iR^ 8MLMMM 2 t -f - - -DTF##)J99T!Wju9==tABBxLD& JJqq77777778 9 9E zJJy)) u{IO<<ggdjYegDD 22====f===>??ue,,hhtzh//E CI Jrc tj|}tjd|D}tjtj|d||}t ||D]n\} tj durtj |d\ }t fd|D}tj| ||o|S)aZ Mimic `np.select(condlist, choicelist)`. Notice, it assumes that all `arrays` are of the same shape or can be broadcasted together. All functions in `choicelist` must accept array arguments in the order given in `arrays` and must return an array of the same shape as broadcasted `arrays`. Examples -------- >>> import numpy as np >>> x = np.arange(6) >>> np.select([x <3, x > 3], [x**2, x**3], default=0) array([ 0, 1, 4, 0, 64, 125]) >>> _lazyselect([x < 3, x > 3], [lambda x: x**2, lambda x: x**3], (x,)) array([ 0., 1., 4., 0., 64., 125.]) >>> a = -np.ones_like(x) >>> _lazyselect([x < 3, x > 3], ... [lambda x, a: x**2, lambda x, a: a * x**3], ... (x, a), default=np.nan) array([ 0., 1., 4., nan, -64., -125.]) c&g|]}|jjSr)r+char)r%as r z_lazyselect..s999QAGL999rrr)Fc3BK|]}tj|VdSr#)npextractr$s r r(z_lazyselect..s/==sRZc**======r) rHr0 mintypecoder4r5zipalltupleplace) condlist choicelistr7defaulttcoder?func_tempr's @r _lazyselectrVs8 & )F N99&999 : :E '"(6!9%%' G G GC*h//)) d 6$%-   %dF1I66a====f===== dDD$K(((( JrCctj|}||j}t|ds|f}t jt j||jz}tj ||zdztj }|j dd|z}|dkr||z }||||zdzdd}tj ||||}| d|S)zAllocate a new ndarray with aligned memory. Primary use case for this currently is working around a f2py issue in NumPy 1.9.1, where dtype.alignment is such that np.zeros() does not necessarily create arrays aligned up to it. N__len__rdatar)order)rHr+ alignmenthasattr functoolsreduceoperatormulitemsizer6uint8__array_interface__ndarrayfill)r5r+r\alignr bufoffsetrZs r _aligned_zerosrks HUOOE } 5) $ $  HL% 0 05> AD (4%?? ?&2Bb"" G A @ 7bhsmm # #>?? ?-}QWbj11 -,,,A Hrc tj|}n!#t$rt|ddwxYw|||krt|d|d|S)a Validate a scalar integer. This function can be used to validate an argument to a function that expects the value to be an integer. It uses `operator.index` to validate the value (so, for example, k=2.0 results in a TypeError). Parameters ---------- k : int The value to be validated. name : str The name of the parameter. minimum : int, optional An optional lower bound. z must be an integer.Nz" must be an integer not less than )raindex TypeErrorr/)knameminimums r _validate_intrKs$A N1   AAA455566D@Aq7{{D++!(++,,15 6 Hs5 FullArgSpec)r<varargsvarkwdefaults kwonlyargskwonlydefaults annotationsc tj|}d|jD}d|jD}|r|dnd}d|jD}|r|dnd}t d|jDpd}d|jD}d|jD}d |jD}t ||||||pd|S) asinspect.getfullargspec replacement using inspect.signature. If func is a bound method, do not list the 'self' parameter. Parameters ---------- func : callable A callable to inspect Returns ------- fullargspec : FullArgSpec(args, varargs, varkw, defaults, kwonlyargs, kwonlydefaults, annotations) NOTE: if the first argument of `func` is self, it is *not*, I repeat *not*, included in fullargspec.args. This is done for consistency between inspect.getargspec() under Python 2.x, and inspect.signature() under Python 3.x. cng|]2}|jtjjtjjfv+|j3Sr)kindinspect ParameterPOSITIONAL_OR_KEYWORDPOSITIONAL_ONLYrr%ps r rFz*getfullargspec_no_self..sO    6g'='79 9 9  9 9 9rcPg|]#}|jtjjk|j$Sr)rrrVAR_POSITIONALrrs r rFz*getfullargspec_no_self..s7 6W&5 5 5  5 5 5rrNcPg|]#}|jtjjk|j$Sr)rrr VAR_KEYWORDrrs r rFz*getfullargspec_no_self..s7    6W&2 2 2  2 2 2rc3tK|]3}|jtjjkr|j|ju*|jV4dSr#)rrrrrQr6rs r r(z)getfullargspec_no_self..sR Fg'= = = IQW $ $ $ $ $ $rcPg|]#}|jtjjk|j$Sr)rrr KEYWORD_ONLYrrs r rFz*getfullargspec_no_self..s7 6W&3 3 3  3 3 3rcxi|]7}|jtjjkr|j|ju*|j|j8Sr)rrrrrQr6rrs r z*getfullargspec_no_self..sI,,,Vw0===)17**&!)***rcDi|]}|j|ju|j|jSr) annotationr6rrs r rz*getfullargspec_no_self..s6333Al!'1161<111r)r signature parametersvaluesrMr) rSsigr<rrrr kwdefaultsrs r getfullargspec_no_selfrys*  D ! !C  --//   D --//G$-gajjG  --//   E 'E!HH4E>0022   --//J,,S^-B-B-D-D,,,J331F1F1H1H333K tWeXz!)T; 8 88rceZdZdZdZdZdS)_FunctionWrapperz? Object to wrap user's function, allowing picklability c*||_|gn||_dSr#r8r<)selfr8r<s r __init__z_FunctionWrapper.__init__s,BBD rc(|j|g|jRSr#r)rxs r __call__z_FunctionWrapper.__call__stva$$)$$$$rN)rrr__doc__rrrrr rrs<111%%%%%rrc>eZdZdZd dZdZdZdZdZdZ d Z d S) MapWrapperav Parallelisation wrapper for working with map-like callables, such as `multiprocessing.Pool.map`. Parameters ---------- pool : int or map-like callable If `pool` is an integer, then it specifies the number of threads to use for parallelization. If ``int(pool) == 1``, then no parallel processing is used and the map builtin is used. If ``pool == -1``, then the pool will utilize all available CPUs. If `pool` is a map-like callable that follows the same calling sequence as the built-in map function, then this callable is used for parallelization. rcd|_t|_d|_t |r||_|j|_dSddlm}t|dkr)||_|jj|_d|_dSt|dkrdSt|dkr8|t||_|jj|_d|_dStd) NFr)Poolr[Tr) processeszUNumber of workers specified must be -1, an int >= 1, or an object with a 'map' method) poolmap_mapfunc _own_poolcallablemultiprocessingrint RuntimeError)rrrs r rzMapWrapper.__init__s   D>> -DI IDMMM , , , , , ,4yyB DFF $  !%TaTQ D3t99555 $  !%"$,---rc|Sr#rrs r __enter__zMapWrapper.__enter__s rcJ|jr|jdSdSr#)rr terminaters r rzMapWrapper.terminates0 > " I   ! ! ! ! ! " "rcJ|jr|jdSdSr#)rrjoinrs r rzMapWrapper.joins. >  INN       rcJ|jr|jdSdSr#)rrclosers r rzMapWrapper.closes. >  IOO       rc||jr4|j|jdSdSr#)rrrr)rexc_type exc_value tracebacks r __exit__zMapWrapper.__exit__sB > " IOO    I   ! ! ! ! ! " "rct |||S#t$r}td|d}~wwxYw)Nz;The map-like callable must be of the form f(func, iterable))rr)rrSiterablees r rzMapWrapper.__call__sT >==x00 0 > > >677<= > >s 727Nr) rrrrrrrrrrrrrr rrs----8"""""" >>>>>rrint64c<t|tr||||||S|tjjj}|r;|||dz||S||||dz||S|||||S)al Return random integers from low (inclusive) to high (exclusive), or if endpoint=True, low (inclusive) to high (inclusive). Replaces `RandomState.randint` (with endpoint=False) and `RandomState.random_integers` (with endpoint=True). Return random integers from the "discrete uniform" distribution of the specified dtype. If high is None (the default), then results are from 0 to low. Parameters ---------- gen : {None, np.random.RandomState, np.random.Generator} Random number generator. If None, then the np.random.RandomState singleton is used. low : int or array-like of ints Lowest (signed) integers to be drawn from the distribution (unless high=None, in which case this parameter is 0 and this value is used for high). high : int or array-like of ints If provided, one above the largest (signed) integer to be drawn from the distribution (see above for behavior if high=None). If array-like, must contain integer values. size : array-like of ints, optional Output shape. If the given shape is, e.g., (m, n, k), then m * n * k samples are drawn. Default is None, in which case a single value is returned. dtype : {str, dtype}, optional Desired dtype of the result. All dtypes are determined by their name, i.e., 'int64', 'int', etc, so byteorder is not available and a specific precision may have different C types depending on the platform. The default value is 'int64'. endpoint : bool, optional If True, sample from the interval [low, high] instead of the default [low, high) Defaults to False. Returns ------- out: int or ndarray of ints size-shaped array of random integers from the appropriate distribution, or a single such random int if size not provided. )highr r+endpointNr)r r+)rr r+)rrintegersrHr|r}r~randint)genlowrr r+rs r rng_integersrsX#y!!C||CdU%-// / ;)"(C  O|{{37U{CCC{{3TAXD{NNN{{3TE{BBBr !E^1cuBnc#Ktjj|ffd tj_ dVtj_dS#tj_wxYw)z0Context with a fixed np.random.default_rng seed.c|Sr#rrorig_funs r z$_fixed_default_rng..JshhtnnrN)rHr| default_rngrs @r _fixed_default_rngrFs`y$H(,<<<<._wrapped.._s8    F75t < <   rr)r<kwargsreslinesrSrs r _wrappedz#_rng_html_rewrite.._wrapped]sFdD#F##        r)rcompileI)rSrrs` @r _rng_html_rewriter Qs?jFMMG Orcftj||}|r|tj||}|S)z argmin with a `keepdims` parameter. See https://github.com/numpy/numpy/issues/8710 If axis is not None, a.shape[axis] must be greater than 0. axis)rHargmin expand_dims)rEkeepdimsr rs r _argminrhs> )AD ! ! !C-D$nSt,,, Jrcxttj||d}tj|||S)a Return the first non-nan value along the given axis. If a slice is all nan, nan is returned for that slice. The shape of the return value corresponds to ``keepdims=True``. Examples -------- >>> import numpy as np >>> nan = np.nan >>> a = np.array([[ 3., 3., nan, 3.], [ 1., nan, 2., 4.], [nan, nan, 9., -1.], [nan, 5., 4., 3.], [ 2., 2., 2., 2.], [nan, nan, nan, nan]]) >>> _first_nonnan(a, axis=0) array([[3., 3., 2., 3.]]) >>> _first_nonnan(a, axis=1) array([[ 3.], [ 1.], [ 9.], [ 5.], [ 2.], [nan]]) Tr rr )rrHisnantake_along_axis)rEr rs r _first_nonnanrvs88  $666A a . . ..rcj|$|jdkrdS|}d}nM|j}||dkr:|d|d|zz||dzdz}tj|dt St ||}||ktj|z||S) a Determine if the values along an axis are all the same. nan values are ignored. `a` must be a numpy array. `axis` is assumed to be normalized; that is, 0 <= axis < a.ndim. For an axis of length 0, the result is True. That is, we adopt the convention that ``allsame([])`` is True. (There are no values in the input that are different.) `True` is returned for slices that are all nan--not because all the values are the same, but because this is equivalent to ``allsame([])``. Examples -------- >>> from numpy import nan, array >>> a = array([[ 3., 3., nan, 3.], ... [ 1., nan, 2., 4.], ... [nan, nan, 9., -1.], ... [nan, 5., 4., 3.], ... [ 2., 2., 2., 2.], ... [nan, nan, nan, nan]]) >>> _nan_allsame(a, axis=1, keepdims=True) array([[ True], [False], [False], [False], [ True], [ True]]) NrTrrr)r r) r ravelr5rHr4boolrrrL)rEr rshpa0s r _nan_allsamersD | 6Q;;4 GGIIg t9>>ete*tH},s4!899~=C734t<<< < qt $ $ $B 1W # ( (dX ( F FFr propagate)r;c|t|}t| }|hd}||vr tdt|d||jdp||jd}t |dkrd}n|r)|||}nt|r}tj |jtr^d}| D]F}tj t|tjrtj|rd}nGnd}|r|d krtd |r|r|d krd }t|||fS) N>omitraiserznan_policy must be one of .z real floatingzcomplex floatingrFTrzThe input contains nan valuesrz9`nan_policy='omit' is incompatible with non-NumPy arrays.)r r r/setisdtyper+xp_sizermaxrHrobjectrtypenumber) rE nan_policypoliciesr; not_numpyr contains_nanelmessages r _contains_nanr.s z Q  RLL I111!!Fc(mmFFFGGGzz!'?33:**QW&899 qzzQ  xxq ** " "-88  ''))  B}T"XXry11 bhrll #  : g--8999"\"j&&8&8M!!!  ##rcfd}|S)a Generate decorator for backward-compatible keyword renaming. Apply the decorator generated by `_rename_parameter` to functions with a recently renamed parameter to maintain backward-compatibility. After decoration, the function behaves as follows: If only the new parameter is passed into the function, behave as usual. If only the old parameter is passed into the function (as a keyword), raise a DeprecationWarning if `dep_version` is provided, and behave as usual otherwise. If both old and new parameters are passed into the function, raise a DeprecationWarning if `dep_version` is provided, and raise the appropriate TypeError (function got multiple values for argument). Parameters ---------- old_name : str Old name of parameter new_name : str New name of parameter dep_version : str, optional Version of SciPy in which old parameter was deprecated in the format 'X.Y.Z'. If supplied, the deprecation message will indicate that support for the old parameter will be removed in version 'X.Y+2.Z' Notes ----- Untested with functions that accept *args. Probably won't work as written. cNtjfd}|S)Nc |vrr}d}tt|ddz|d<d|}dddd|d }t j|t d|vrjd d }t|| |<|i|S) Nr rrmzUse of keyword argument `z!` is deprecated and replaced by `z`. Support for `z` will be removed in SciPy ) stacklevelz2() got multiple values for argument now known as ``) splitstrrrwarningswarnDeprecationWarningrrpop)r<r end_versionr- dep_versionfunnew_nameold_names r wrapperz5_rename_parameter..decorator..wrapper s$6!!M"-"3"3C"8"8K%([^)<)F : :/7 : :,7 : : :GM'+=!LLLLv%%"%, E E9A E E EG#G,,,#)::h#7#7x 3''' 'r)r_wraps)r<r?r;r=r>s` r decoratorz$_rename_parameter..decorator sH    ( ( ( ( ( ( (   ("rr)r>r=r;rAs``` r _rename_parameterrBs1@( rcf|jj}fd||D}|S)Nczg|]7}tjt|8Sr)rHr|rr&)r%child_ssbgs r rFz_rng_spawn..'sI888)%%hd2hhx&8&899888r)_bit_generator _seed_seqspawn)rng n_childrenss child_rngsrFs @r _rng_spawnrN#sL B B8888"$((:"6"6888J rc t|nfd|D} tdj}jg||R}n#t$r j}YnwxYwj|dS)Nc:g|]}|Sr)r1)r%itemr;s r rFz_get_nan../s% . . .BJJt   . . .rfloat16r.r)r getattrfloat32r3rrr1nan)r;rZ min_floatr+s` r _get_nanrW,s#%:$  2B . . . . . . .DB 2:66 00i000   ::bfE: * *2 ..s%AAAcd|| ks||krd|d|}t||dkr||z}|S)Nzaxis z) is out of bounds for array of dimension r)r )r ndimrs r normalize_axis_indexrZ9sM te||tt||KdKKTKKnn axxd{ KrcV|dS ||dS#t$r d|_YdSwxYw)aYCall wrapped callback; return True if algorithm should stop. Parameters ---------- callback : callable or None A user-provided callback wrapped with `_wrap_callback` res : OptimizeResult Information about the current iterate Returns ------- halt : bool True if minimization should stop NFT) StopIterationstop_iteration)callbackrs r _call_callback_maybe_haltr_DsP u u "&tts ((c@eZdZdZdZejZejZ dZ dZ dS) _RichResultz5 Container for multiple outputs with pretty-printing cX ||S#t$r}t||d}~wwxYwr#)KeyErrorAttributeError)rrrs r __getattr__z_RichResult.__getattr__`s@ .:  . . . &&A - .s )$)cgdt|dhdfdfdfd}|rt||S|jjdzS) N)r-successstatusr<funlrxlcol_indnitloweruppereqlinineqlin convergedflagfunction_calls iterationsroot _order_keys>conslackrv crossover_nitc |dS#t$rtjcYSwxYwNr)rrmr/rHrx)rQ order_keyss r keyz!_RichResult.__repr__..keyssN !''Q 888   v  s,0A A c34K|D]}|dvr |VdSr{r)itemsrQ omit_keyss r omit_redundantz,_RichResult.__repr__..omit_redundantys=  7i''   rc\t|S)N)r})sortedr)dr}rs r item_sorterz)_RichResult.__repr__..item_sorters(..33=== =r)sorterz())rSkeys_dict_formatter __class__r)rrr}rrr|s @@@@r __repr__z_RichResult.__repr__is T=*== EDD              > > > > > > 99;; 2"4 <<< <>*T1 1rcDt|Sr#)listrrs r __dir__z_RichResult.__dir__sDIIKK   rN) rrrrredict __setitem__ __setattr__ __delitem__ __delattr__rrrrr rara^sY??... "K"K222<!!!!!rracf|d}d|z}d|z|S)zQ Ensures that lines after the first are indented by the specified amount   )r4r)srqr4indents r _indenterrs4 GGDMME UF 6M   & &&rctj|rdStj|rdStj|rdStj|dddS)zP Returns a string representation of a float with exactly ten characters z infz -infz nanrmF) precisionpad_leftunique)rHisposinfisneginfrformat_float_scientific)rs r _float_formatter_10rs] {1~~| Q| !| %a1q O O OOrc t|trqtttt ||zdfd|D}nItj dz dddti5t|}dddn #1swxYwY|S) z Pretty printer for dictionaries `n` keeps track of the starting indentation; lines are indented by this much after a line break. `mplus` is additional left padding applied to keys rc g|]G\}}|dztt|zdzddzzHS)z: rmr)rjustrr)r%rvmrqrs r rFz#_dict_formatter..si...1awwqzzD( AaCE1f!E!EqsKKL...rLrm float_kind) linewidth edgeitems threshold formatterN) rrr$rlenrrrrH printoptionsrr5)rrqmplusrrrs ` ` @r rrs&!T Caffhh(( ) )E 1 II......#)6!99... / /_r!tqB(46I'JLLL  AA                Hs,CC C )NN)r)TFFFFr#)NNrF)r)FN)F)rN)rrN)\r contextlibrr_rar6r collectionsrrrvtypingrrrrnumpyrHscipy._lib._array_apir r r r#r& Exception__annotations__Warninglib NumpyVersion __version__numpy.exceptionsr r rrrcatch_warningsfilterwarnings FutureWarninglongrulongrrdint_uintrr IntNumberrufloating DecimalNumberrrro __array__r|rrSeedTyper numpy.random ImportErrorrArVrkrpryrrrrrrrrrr rrrr.rBrNrWrZr_rrarrrrrr rs %%%%%%"""""" LLLLLLLLLL  ?W =(((6r~&&(22 $ 6r~&&,66  $X $ & &  #H #B    gGxH                gGwHHHgGwH #rz/ " eR["*45 6r~&&'11NNV((833NN! T***  Qi)< i3456HGO59L9;9N:O4PQQQM 3333333              DDDDN%%%%P!&S4;s;u;;;;"""<(,BG"'5 5 5 5 p    RjIIIJJ 484848n % % % % % % % %G>G>G>G>G>G>G>G>T8?=C=C=C=C@)))).    ///@-G-G-G-G`#$$#$#$#$#$#$L4444n / / / / /4*!*!*!*!*!$*!*!*!Z'''' P P P      sZD!D ? D DDDDD-,D-:'G""G,+G,III