^Mh=UddlZddlmZddlZddlZddlZddlZddlmZddl Z ddl Z ddl m Z m Z ddlZddlmZmZmZddlmZmZeeed<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.ej/zZ0e1ej2zej/zZ3e4dzed<ejejdkrdZ5n\ejejdkrdZ5n6 ej6dg7ddZ5n #e#$rdZ5YnwxYwej8j9ej8j:zZ;e ed<e0e;zdzZm9Z9n#e?$rGddZ9YnwxYwdKdZ@dLd ZAe1d!dfd"ZBd#ZCd$e.d%e1fd&ZDd'ZEddd(d)d*ZFd+ZG dMd,ZHdNd-ZIed.gd/ZJd0ZKGd1d2ZLGd3d4ZM dOd6ZNedPd8ZOd9ZPdQd:ZQd;ZRdRd<ZSdSddd>d?ZTdNd@ZUdAZVddBdCZWdDZXdEZYGdFdGeZZ[dLdHZ\dIZ]dTdJZ^dS)UN)contextmanager) namedtuple) TypeAliasTypeVar)array_namespaceis_numpyxp_size) FunctionDoc Parameter 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_RNGSeedType GeneratorType)bound) GeneratorceZdZdS)rN)__name__ __module__ __qualname__P/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/scipy/_lib/_util.pyrrPs r!rcp tg|R}||cxurn||td|jg|R}|dgj}||d|d|ddc}||fd|D}|t |tttthvr8tj d 5||zj} dddn #1swxYwYn| |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!r)invaliddtype)r- fill_valuec3(K|] }|V dSr%r )r'r(nconds r"r*z_lazywhere..s'==sE ======r!)r ValueErrorbroadcast_arraysasarrayr-astypetypeboolintfloatcomplexnperrstate result_typefullshapeempty) r)arraysf fillvaluef2xpargs bool_dtypetemp1r-outtemp2r0s ` @r" _lazywhererJTs.X  ' ' ' 'B iR^ 8MLMMM 2 t -f - - -DTF##)J99T!Wju9==tABBxLD& JJqq77777778 9 9E z  ??tS%9 9 9X... 2 2*1 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2>>%+y995ggdj!#IU!C!CEE 22====f===>??ue,,hhtzh//E CI Js" C99C=C=c 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..s999QAGL999r!rr.r-Fc3BK|]}tj|VdSr%)r:extractr&s r"r*z_lazyselect..s/==sRZc**======r!) r:r2 mintypecoder=r>zipalltupleplace) condlist choicelistr@defaulttcoderHfunc_tempr)s @r" _lazyselectr_s8 & )F N99&999 : :E '"(6!9%%' G G GC*h//)) d 6$%-   %dF1I66a====f===== dDD$K(((( Jr!Cctj|}||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)r:r- alignmenthasattr functoolsreduceoperatormulitemsizer?uint8__array_interface__ndarrayfill)r>r-realignsizebufoffsetrcs r"_aligned_zerosrus HUOOE } 5) $ $  HL% 0 05> AD (4%`_ transition from use of `numpy.random.RandomState` to `numpy.random.Generator`, this keyword was changed from `{old_name}` to `rng`. For an interim period, both keywords will continue to work, although only one may be specified at a time. After the interim period, function calls using the `{old_name}` keyword will emit warnings. The behavior of both `{old_name}` and `rng` are outlined above, but only the `rng` keyword should be used in new code. T) position_num end_version replace_docc Hdddddd fd}|S)ayExample decorator to transition from old PRNG usage to new `rng` behavior Suppose the decorator is applied to a function that used to accept parameter `old_name='random_state'` either by keyword or as a positional argument at `position_num=1`. At the time of application, the name of the argument in the function signature is manually changed to the new name, `rng`. If positional use was allowed before, this is not changed.* - If the function is called with both `random_state` and `rng`, the decorator raises an error. - If `random_state` is provided as a keyword argument, the decorator passes `random_state` to the function's `rng` argument as a keyword. If `end_version` is specified, the decorator will emit a `DeprecationWarning` about the deprecation of keyword `random_state`. - If `random_state` is provided as a positional argument, the decorator passes `random_state` to the function's `rng` argument by position. If `end_version` is specified, the decorator will emit a `FutureWarning` about the changing interpretation of the argument. - If `rng` is provided as a keyword argument, the decorator validates `rng` using `numpy.random.default_rng` before passing it to the function. - If `end_version` is specified and neither `random_state` nor `rng` is provided by the user, the decorator checks whether `np.random.seed` has been used to set the global seed. If so, it emits a `FutureWarning`, noting that usage of `numpy.random.seed` will eventually have no effect. Either way, the decorator calls the function without explicitly passing the `rng` argument. If `end_version` is specified, a user must pass `rng` as a keyword to avoid warnings. After the deprecation period, the decorator can be removed, and the function can simply validate the `rng` argument by calling `np.random.default_rng(rng)`. * A `FutureWarning` is emitted when the PRNG argument is used by position. It indicates that the "Hinsen principle" (same code yielding different results in two versions of the software) will be violated, unless positional use is deprecated. Specifically: - If `None` is passed by position and `np.random.seed` has been used, the function will change from being seeded to being unseeded. - If an integer is passed by position, the random stream will change. - If `np.random` or an instance of `RandomState` is passed by position, an error will be raised. We suggest that projects consider deprecating positional use of `random_state`/`rng` (i.e., change their function signatures to ``def my_func(..., *, rng=None)``); that might not make sense for all projects, so this SPEC does not make that recommendation, neither does this decorator enforce it. Parameters ---------- old_name : str The old name of the PRNG argument (e.g. `seed` or `random_state`). position_num : int, optional The (0-indexed) position of the old PRNG argument (if accepted by position). Maintainers are welcome to eliminate this argument and use, for example, `inspect`, if preferred. end_version : str, optional The full version number of the library when the behavior described in `DeprecationWarning`s and `FutureWarning`s will take effect. If left unspecified, no warnings will be emitted by the decorator. replace_doc : bool, default: True Whether the decorator should replace the documentation for parameter `rng` with `_rng_desc` (defined above), which documents both new `rng` keyword behavior and typical legacy `random_state`/`seed` behavior. If True, manually replace the first paragraph of the function's old `random_state`/`seed` documentation with the desired *final* `rng` documentation; this way, no changes to documentation are needed when the decorator is removed. Documentation of `rng` after the first blank line is preserved. Use False if the function's old `random_state`/`seed` behavior does not match that described by `_rng_desc`. rngz@To silence this warning and ensure consistent behavior in SciPy z", control the RNG using argument `z `. Arguments passed to keyword `z` will be validated by `np.random.default_rng`, so the behavior corresponding with a given value may change compared to use of `a+`. For example, 1) `None` will result in unpredictable random numbers, 2) an integer will result in a different stream of random numbers, (with the same distribution), and 3) `np.random` or `RandomState` instances will result in an error. See the documentation of `default_rng` for more information.cXtj fd}rt|}d|dD}d|vrd}td }|d|dj}d|vr ||ddzdng}|g|z}td||} | |d|d<t| d dd}t||_ |S) Nc |v} |v}duot|dzk} du}t|t|zt|zdkr" jd d dd}t|tjjjjj du}|rI| | <|r.dd dd d z}tj |td n|r}|}tjjtjjtjjf} ||rt#|| rn|r+d dd d z}tj |t$d nT|r)tj| | <n)|r'|r%d d z}tj |t$d  |i|S)Nr2() got multiple values for argument now known as `z`. Specify one of `z` or `z`.Use of keyword argument `!` is deprecated and replaced by ``. Support for `` will be removed in SciPy z. rw stacklevelzPositional use of `z` (formerly known as `z`) is still allowed, but the behavior is changing: the argument will be normalized using `np.random.default_rng` beginning in SciPy zH, and the resulting `Generator` will be used to generate random numbers.zJThe NumPy global RNG was seeded by calling `np.random.seed`. Beginning in z2, this function will no longer use the global RNG.)lenr7r TypeErrorr:randommtrand_rand_bit_generator _seed_seqpopwarningswarnDeprecationWarningr SeedSequence BitGenerator isinstance FutureWarning default_rng)rEkwargs as_old_kwarg as_new_kwarg as_pos_arg emit_warningmessageglobal_seed_setarg ok_classesNEW_NAMEcmn_msgrfunold_namers r"wrapperz6_transition_to_rng..decorator..wrapperns$v-L#v-L%T1Sc$ii.decorator..sIIIeuzIIIr! Parametersrz/{None, int, `numpy.random.Generator`}, optionalz {old_name}r ) rhwrapsr _rng_descreplaceindexdescr strsplit__doc__)rrdocparameter_names_type_descold_doc old_doc_keepnew_doc_rng_parameter_docrrrrrrs` r" decoratorz%_transition_to_rng..decoratormsd   I (I (I (I (I (I (I (I (I (  I (V  +g&&CIIs<7HIIIO''I!)),AAl+O,A,A%,H,HINBD--ww}}R'8'81'<'='=>>UW  'L0%.ueW%E%E"BTL!/"7"7">">?#hhnnT1--a0"%c((r!r )rrrrrrrs```` @@r"_transition_to_rngrsTH G  G G:B G G G G  G G G ZZZZZZZZZZx r!cf||tjurtjjjSt |t jtjzrtj|St |tjjtjj zr|Std|d)a`Turn `seed` into a `np.random.RandomState` instance. Parameters ---------- seed : {None, int, `numpy.random.Generator`, `numpy.random.RandomState`}, optional If `seed` is None (or `np.random`), the `numpy.random.RandomState` singleton is used. If `seed` is an int, a new ``RandomState`` instance is used, seeded with `seed`. If `seed` is already a ``Generator`` or ``RandomState`` instance then that instance is used. Returns ------- seed : {`numpy.random.Generator`, `numpy.random.RandomState`} Random number generator. N'z<' cannot be used to seed a numpy.random.RandomState instance) r:rrrrnumbersIntegralinteger RandomStaterr1)seeds r"check_random_staters& |try((y%%$(2:566+y$$T***$ - 0CCDD !!!! " ""r!c|s/ddl}|j|rd}t||s.tj|rtd|r tjn tj}||}|s*|j t j durtd|r;t j |j tj s||tj }|S)aA Helper function for SciPy argument validation. Many SciPy linear algebra functions do support arbitrary array-like input arguments. Examples of commonly unsupported inputs include matrices containing inf/nan, sparse matrix representations, and matrices with complicated elements. Parameters ---------- a : array_like The array-like input. check_finite : bool, optional Whether to check that the input matrices contain only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs. Default: True sparse_ok : bool, optional True if scipy sparse matrices are allowed. objects_ok : bool, optional True if arrays with dype('O') are allowed. mask_ok : bool, optional True if masked arrays are allowed. as_inexact : bool, optional True to convert the input array to a np.inexact dtype. Returns ------- ret : ndarray The converted validated array. rNzSparse arrays/matrices are not supported by this function. Perhaps one of the `scipy.sparse.linalg` functions would work instead.zmasked arrays are not supportedOzobject arrays are not supportedr,) scipy.sparsesparseissparser1r:ma isMaskedArrayasarray_chkfiniter3r- issubdtypeinexactfloat64) rN check_finite sparse_ok objects_okmask_ok as_inexactscipymsgtoarrays r"_asarray_validatedrsF " <  # # ")CS// ! @ 5  q ! ! @>?? ?&2Bb"" G A @ 7bhsmm # #>?? ?-}QWbj11 -,,,A Hr!c 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 )rjrrr1)krminimums r" _validate_intr#s$A N1   AAA455566D@Aq7{{D++!(++,,15 6 Hs5 FullArgSpec)rEvarargsvarkwdefaults 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 )kindinspectr POSITIONAL_OR_KEYWORDPOSITIONAL_ONLYrr'ps r"rOz*getfullargspec_no_self..gsO    6g'='79 9 9  9 9 9r!cPg|]#}|jtjjk|j$Sr )rrr VAR_POSITIONALrrs r"rOz*getfullargspec_no_self..ls7 6W&5 5 5  5 5 5r!rNcPg|]#}|jtjjk|j$Sr )rrr VAR_KEYWORDrrs r"rOz*getfullargspec_no_self..qs7    6W&2 2 2  2 2 2r!c3tK|]3}|jtjjkr|j|ju*|jV4dSr%)rrr rrZr?rs r"r*z)getfullargspec_no_self..vsR Fg'= = = IQW $ $ $ $ $ $r!cPg|]#}|jtjjk|j$Sr )rrr KEYWORD_ONLYrrs r"rOz*getfullargspec_no_self..{s7 6W&3 3 3  3 3 3r!cxi|]7}|jtjjkr|j|ju*|j|j8Sr )rrr rrZr?rrs r" z*getfullargspec_no_self..sI,,,Vw0===)17**&!)***r!cDi|]}|j|ju|j|jSr ) annotationr?rrs r"rz*getfullargspec_no_self..s6333Al!'1161<111r!)r signature parametersvaluesrVr) r\sigrErrrr kwdefaultsrs r"getfullargspec_no_selfrQs*  D ! !C  --//   D --//G$-gajjG  --//   E 'E!HH4E>0022   --//J,,S^-B-B-D-D,,,J331F1F1H1H333K tWeXz!)T; 8 88r!ceZdZdZdZdZdS)_FunctionWrapperz? Object to wrap user's function, allowing picklability c*||_|gn||_dSr%rArE)selfrArEs r"__init__z_FunctionWrapper.__init__s,BBD r!c(|j|g|jRSr%r )r xs r"__call__z_FunctionWrapper.__call__stva$$)$$$$r!N)rrrrr rr r!r"rrs<111%%%%%r!rc>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)PoolrdTr) processeszUNumber of workers specified must be -1, an int >= 1, or an object with a 'map' method) poolmap_mapfunc _own_poolcallablemultiprocessingrr7 RuntimeError)r rrs r"r zMapWrapper.__init__s   D>> -DI IDMMM , , , , , ,4yyB DFF $  !%TaTQ D3t99555 $  !%"$,---r!c|Sr%r r s r" __enter__zMapWrapper.__enter__s r!cJ|jr|jdSdSr%)rr terminaters r"r zMapWrapper.terminates0 > " I   ! ! ! ! ! " "r!cJ|jr|jdSdSr%)rrjoinrs r"r"zMapWrapper.joins. >  INN       r!cJ|jr|jdSdSr%)rrclosers r"r$zMapWrapper.closes. >  IOO       r!c||jr4|j|jdSdSr%)rrr$r )r exc_type exc_value tracebacks r"__exit__zMapWrapper.__exit__sB > " IOO    I   ! ! ! ! ! " "r!ct |||S#t$r}td|d}~wwxYw)Nz;The map-like callable must be of the form f(func, iterable))rr)r r\iterablees r"rzMapWrapper.__call__sT >==x00 0 > > >677<= > >s 727Nr) rrrrr rr r"r$r)rr r!r"rrs----8"""""" >>>>>r!rint64c<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. )highrrr-endpointNr)rrr-)r0rrr-)rrintegersr:rrrrandint)genlowr0rrr-r1s r" rng_integersr6sX#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%r rorig_funs r"z$_fixed_default_rng.."shhtnnr!N)r:rrr:s @r"_fixed_default_rngr=s`y$H(,<<<<._wrapped..7s8    F75t < <   r!r )rErreslinesr\rDs r"_wrappedz#_rng_html_rewrite.._wrapped5sFdD#F##        r!)rAcompileI)r\rGrDs` @r"_rng_html_rewriterJ)s?jFMMG Or!cftj||}|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)r:argmin expand_dims)rNkeepdimsrMrEs r"_argminrQ@s> )AD ! ! !C-D$nSt,,, Jr!cxttj||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]]) TrMrPrL)rQr:isnantake_along_axis)rNrMrs r" _first_nonnanrVNs88  $666A a . . ..r!cj|$|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]]) NrTr-rrPrLrS) rrravelr>r:r=r6rVrTrU)rNrMrPshpa0s r" _nan_allsamer[nsD | 6Q;;4 GGIIg t9>>ete*tH},s4!899~=C734t<<< < qt $ $ $B 1W # ( (dX ( F FFr! propagate) xp_omit_okayrDc|t|}t| }|hd}||vr tdt|dt |dkrd}nf||jdr*|||}n!||jdrx||| |||| |z}nt|r}tj |jtr^d}|D]F}tj t|tjrtj|rd}nGnd}|r|d krtd |s|r|r|d krd }t|||fS) N>omitraiser\znan_policy must be one of .rFz real floatingzcomplex floatingTr`zThe input contains nan valuesr_z9`nan_policy='omit' is incompatible with non-NumPy arrays.)rrr1setr isdtyper-rTmaxrealimagr:robjectrXr5number) rN nan_policypoliciesr]rD not_numpy contains_nanelrs r" _contains_nanrns z Q  RLL I111!!Fc(mmFFFGGGqzzQ AG_ - -xxq ** AG/ 0 0 xxrwwqzz 2 233bhhrvvbggajj?Q?Q6R6RR " "-88  ''))  B}T"XXry11 bhrll #  : g--8999 "I",":v;M;MM!!!  ##r!cfd}|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) Nrarrwrrrrrr`) rrr7r"rrrrrr)rErrr dep_versionrnew_namers r"rz5_rename_parameter..decorator..wrappers$6!!M"-"3"3C"8"8K%([^)<)F : :/7 : :,7 : : :GM'+=!LLLLv%%"%, E E9A E E EG#G,,,#)::h#7#7x 3''' 'r!)rhr)rrrsrtrs` r"rz$_rename_parameter..decoratorsH    ( ( ( ( ( ( (   ("r!r )rrtrsrs``` r"_rename_parameterrus1@( r!cf|jj}fd||D}|S)Nczg|]7}tjt|8Sr )r:rrr5)r'child_ssbgs r"rOz_rng_spawn..sI888)%%hd2hhx&8&899888r!)rrspawn)r n_childrenss child_rngsrys @r" _rng_spawnr~sL B B8888"$((:"6"6888J r!)rDc t|nfd|D} tdj}jg||R}n#t$r j}YnwxYwj|dS)Nc:g|]}|Sr )r3)r'itemrDs r"rOz_get_nan..s% . . .BJJt   . . .r!float16r,r )rgetattrfloat32r<rrr3nan)rDrc min_floatr-s` r"_get_nanr 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 )rMndimrs r"normalize_axis_indexrsM te||tt||KdKKTKKnn axxd{ Kr!cV|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)callbackrEs r"_call_callback_maybe_haltr%sP u u "&tts ((c@eZdZdZdZejZejZ dZ dZ dS) _RichResultz5 Container for multiple outputs with pretty-printing cX ||S#t$r}t||d}~wwxYwr%)KeyErrorAttributeError)r rr,s r" __getattr__z_RichResult.__getattr__As@ .:  . . . &&A - .s )$)cgdt|dhdfdfdfd}|rt||S|jjdzS) N)rsuccessstatusrfunlrxlcol_indnitloweruppereqlinineqlin convergedflagfunction_calls iterationsroot _order_keys>conslackr crossover_nitc |dS#t$rtjcYSwxYwNr)rrr1r:r)r order_keyss r"keyz!_RichResult.__repr__..keyTsN !''Q 888   v  s,0A A c34K|D]}|dvr |VdSrr )itemsr omit_keyss r"omit_redundantz,_RichResult.__repr__..omit_redundantZs=  7i''   r!c\t|S)N)r)sortedr)drrs r" item_sorterz)_RichResult.__repr__..item_sorter`s(..33=== =r!)sorterz())rkeys_dict_formatter __class__r)r rrrrrs @@@@r"__repr__z_RichResult.__repr__Js T=*== EDD              > > > > > > 99;; 2"4 <<< <>*T1 1r!cDt|Sr%)listrrs r"__dir__z_RichResult.__dir__hsDIIKK   r!N) rrrrrdict __setitem__ __setattr__ __delitem__ __delattr__rrr r!r"rr?sY??... "K"K222<!!!!!r!rcf|d}d|z}d|z|S)zQ Ensures that lines after the first are indented by the specified amount r )rr")sr{rindents r" _indenterrls4 GGDMME UF 6M   & &&r!ctj|rdStj|rdStj|rdStj|dddS)zP Returns a string representation of a float with exactly ten characters z infz -infz nanrwF) precisionpad_leftunique)r:isposinfisneginfrTformat_float_scientific)rs r"_float_formatter_10rus] {1~~| Q| !| %a1q O O OOr!c 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: rwr)rjustrr)r'rvmr{rs r"rOz#_dict_formatter..si...1awwqzzD( AaCE1f!E!EqsKKL...r!Lrw float_kind) linewidth edgeitems threshold formatterN) rrrdrrrrr"r: printoptionsrr)rr{mplusrrrs ` ` @r"rrs&!T Caffhh(( ) )E 1 II......#)6!99... / /_r!tqB(46I'JLLL  AA                Hs,CC C )NN)r)TFFFFr%)NNr.F)r7)FN)F)r\N)rrN)_rA contextlibrrhrjrr collectionsrrrtypingrrnumpyr:scipy._lib._array_apirrr scipy._lib._docscraper r r5 Exception__annotations__Warninglib NumpyVersion __version__numpy.exceptionsr r rrrcatch_warningsfilterwarningsrlongrulongrrint_uintr7r IntNumberr8floating DecimalNumberr6rry __array__rrrrrr numpy.random ImportErrorrJr_rurzrrrrrrrrrrr6r=rJrQrVr[rnrur~rrrrrrrrr r!r"rs  %%%%%%"""""" %%%%%%%%DDDDDDDDDD88888888  ?W =(((6r~&&(22 $ 6r~&&,66  $X $ & &  #H #B    gGxH                gGwHHHgGwH "*   #bj0 t 6r~&&'11NNV((833NN! T*** )% (==i===$&-)---t444  3333333              LLLL^%%%%P!&S4;s;u;;;;  :264#'uuuuur"""<(,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`,$$,$,$,$,$,$^4444n / / / / /4*!*!*!*!*!$*!*!*!Z'''' P P P      sZD"!D DDDDDD10D13'GG%$G%!H((H=<H=