(ph=%SSKrSSKJr SSKrSSKrSSKrSSKrSSKJr SSK r SSK r SSK J r J r SSKrSSKJrJrJr SSKJrJr \\\S'\\\S'\\\S '\R6R9\R:5S :a SS KJrJ r J!r!J"r" O SS KJrJ r J!r! \#r"\\S '\\S'\R6R9\R:5S:aH\RH"5 \RJ"SS\&5 \RNr(\RRr*SSS5 O\RXr(\RZr*\.\R^-r0\1\Rd-\R^-r3\4S-\S'\R6R9\R:5S:aSr5OO\R6R9\R:5S:aSr5O#\Rl"S/5RoSS9 Sr5\RpRr\RpRt-r;\ \S'\0\;-S-r<\ \S'\ "S\;S9r=SSK>J9r9 SHSjr@SIS jrA\1S!S4S"jrBS#rCS$\.S%\14S&jrDS'rESSS(S).S*jrFS+rGSJS,jrHSKS-jrI\"S./S/Q5rJS0rK"S1S25rL"S3S45rMSLS5jrN\SMS6j5rOS7rPSNS8jrQS9rRSOS:jrSSPSSS;.S<jjrTSKS=jrUS>rVSS?.S@jrWSArXSBrY"SCSD\Z5r[SISEjr\SFr]SQSGjr^g!,(df  GN=f!\+a \RXr(\RZr*GNf=f!\#a Sr5GNCf=f!\?a "SS5r9GN f=f)RN)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) Generatorc\rSrSrSrg)rPN)__name__ __module__ __qualname____firstlineno____static_attributes__rC/var/www/html/venv/lib/python3.13/site-packages/scipy/_lib/_util.pyrrPs r$rc ^^ [T/UQ76nXCs=LabO UbUb [S5eUR"T/UQ76nURS/5RnUR USUSS9USSsmnURU"U4SjU565nUc[ U5[[[[1;a,[R"S S 9 X-Rn SSS5 OURURU5n URTRW URX9S 9S 9n OPT)m URU"U 4S jU565n URX5n UR!TRU S 9n XT 'XT'U $!,(df  N=f)a?Return 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,># UH oTv M g7fNr.0arrconds r% _lazywhere..s7t9r)invaliddtype)r2 fill_valuec3,># UH oTv M g7fr(r)r*r+nconds r%r-r.s=fsE fr/)r ValueErrorbroadcast_arraysasarrayr2astypetypeboolintfloatcomplexnperrstate result_typefullshapeempty) r,arraysf fillvaluef2xpargs bool_dtypetemp1r2outtemp2r5s ` @r% _lazywhererOTs{X  ' 'B R^ 8MLMM  t -f -DTF#))J99T!Wju9=tABxLD& JJq778 9E z  ?tS%9 9X.*11/.>>%++y95ggdjj!#I!CE 2=f=>?u,hhtzzh/E I J/.s E>> F c^ [R"U6n[R"UVs/sHoDRRPM sn5n[R "[R "US5X5S9n[X5Hrunm [R"T SL5(aM%[R"T US5um n[U 4SjU55n [R"UT U"U 65 Mt U$s snf)a  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.]) rr3r2Fc3R># UHn[R"TU5v M g7fr()r?extractr)s r%r-_lazyselect..s=fsRZZc**fs$') r?r7 mintypecoder2charrBrCzipalltupleplace) condlist choicelistrEdefaultatcoderMfunc_tempr,s @r% _lazyselectrcs8 & )F NN&9&QGGLL&9 :E ''"((6!9%' GC*/ d 66$%- %%dF1I6a=f== dD$K( 0 J:sC>Cc[R"U5nUc URn[US5(dU4n[R "[ RU5UR-n[R"XC-S-[R5nURSSU-nUS:waX6- nXVXd-S-SSn[R"XXRS9nURS5 U$)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?r2 alignmenthasattr functoolsreduceoperatormulitemsizerDuint8__array_interface__ndarrayfill)rCr2rialignsizebufoffsetrgs r%_aligned_zerosrys HHUOE } 5) $ $   HLL% 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 J^^^^^^SmSTSTSTSTS3 mUUUUUU4SjnU$)aExample 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.c">^[R"T5U U U UUU4Sj5nT(a[U5nUSVs/sHo3RPM nnSU;aSn[R ST5nUSUR S5RnSU;aXwR S5S-SO/nU/U-n [SXY5n XSUR S5'[U5RSS5Sn[U5Ul U$s snf) Nc >TU;nT U;nTSL=(a [U5TS-:nT SLn[U5[U5-[U5-S:a#T RST ST STS3n[U5e[R R RRRSLnU(aIURT5UT 'U(a,STST STS T S 3 T -n[R"U[S S 9 GOU(aUTn[R R[R R[R R 4n UcU(a[#X5(aOU(a)S T STST S3T -n[R"U[$S S 9 O^U(a&[R R'UT 5UT 'O1U(a*U(a#ST S3T -n[R"U[$S S 9 T "U0UD6$)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. r{ 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.)lenr<r TypeErrorr?randommtrand_rand_bit_generator _seed_seqpopwarningswarnDeprecationWarningr SeedSequence BitGenerator isinstance FutureWarning default_rng)rJkwargs as_old_kwarg as_new_kwarg as_pos_arg emit_warningmessageglobal_seed_setarg ok_classesNEW_NAMEcmn_msgrfunold_namers r%wrapper6_transition_to_rng..decorator..wrapperns9$v-L#v-L%T1Sc$i77?jA((0z2$$/=4  G MM'+=!L<( II''II**II** KJs.decoratorms  I (I ( I (V g&C7:<7HI7Hezz7HOI'I!)),Al+O,A,A%,HINNBD-w}}R'81'<'=>UW  'L0%.ue%E"BTL!/"7"7">?#hnnT1-a0"%c(JsD r)rrrrrrrs```` @@r%_transition_to_rngrsXTH K -9(Dj! :G G ZZx r$cUbU[RLa$[RRR$[ U[ R [R-5(a[RRU5$[ U[RR[RR-5(aU$[SUS35e)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. 'z<' cannot be used to seed a numpy.random.RandomState instance) r?rrrrnumbersIntegralinteger RandomStaterr6)seeds r%check_random_staters& |tryy(yy%%%$((2::566yy$$T**$ -- 0C0CCDD q!! ""r$cJU(d1SSKnURRU5(a Sn[U5eU(d/[R R U5(a [S5eU(a[RO[RnU"U5nU(d.UR[R"S5La [S5eU(aI[R"UR[R5(dU"U[RS9nU$)a 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 supportedr1) scipy.sparsesparseissparser6r?ma isMaskedArrayasarray_chkfiniter8r2 issubdtypeinexactfloat64) r^ check_finite sparse_ok objects_okmask_ok as_inexactscipymsgtoarrays r%_asarray_validatedrsF  <<  # #)CS/ !  55  q ! !>? ?&2b"" G A  77bhhsm #>? ?}}QWWbjj11,A Hr$c[R"U5nUbX:a[USU35SeU$![a [US35Sef=f)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 )rnrrr6)krminimums r% _validate_intr#sr$A NN1 q{D6"!!( +,15 6 H A4& 456D@As 3A  FullArgSpec)rJvarargsvarkwdefaults kwonlyargskwonlydefaults annotationsc [R"U5nURR5Vs/sHSnUR[R R [R R4;dMGURPMU nnURR5Vs/sH9nUR[R R:XdM-URPM; nnU(aUSOSnURR5Vs/sH9nUR[R R:XdM-URPM; nnU(aUSOSn[SURR555=(d SnURR5Vs/sH9nUR[R R:XdM-URPM; nnURR5Vs0sH_nUR[R R:XdM-URURLdMHURUR_Ma nnURR5Vs0sH5nURURLdMURUR_M7 n n[!X4XVUU=(d SU 5$s snfs snfs snfs snfs snfs snf)a;inspect.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. rNc3# UHVnUR[RR:XdM-URUR LdMHURv MX g7fr()kindinspectr POSITIONAL_OR_KEYWORDr]rD)r*ps r%r-)getfullargspec_no_self..vsJ2a FFg''== =  IIQWW $  2s,A A  A )r signature parametersvaluesrr rPOSITIONAL_ONLYrVAR_POSITIONAL VAR_KEYWORDrY KEYWORD_ONLYr]rD annotationr) r`sigrrJrrrr kwdefaultsrs r%getfullargspec_no_selfrQs*   D !C--/ /1 66g''==''779 9 /   --//1 66W&&55 5 / $gajG--/ /1 66W&&22 2 /  E!H4E>>002   --//1 66W&&33 3 /.1^^-B-B-D,-DVVw00===$))177*$!&&!))#-DJ,251F1F1H31HAll!''1(1661<<'1HK3 tez!)T; 88;    ,3sNAK.=K.+,K3K3,K8K86,K=&K=,LLLL9Lc$\rSrSrSrSrSrSrg)_FunctionWrapperiz7 Object to wrap user's function, allowing picklability c4XlUc/UlgUUlgr(rFrJ)selfrFrJs r%__init___FunctionWrapper.__init__s,B D r$c<UR"U/URQ76$r(r)r xs r%__call___FunctionWrapper.__call__svva$$))$$r$)rJrFN)rr r!r"rr rr#rr$r%rrs1%r$rcF\rSrSrSrS SjrSrSrSrSr Sr S r S r g ) MapWrapperiaB 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. cSUl[UlSUl[ U5(aXlURUlgSSKJn [U5S:Xa/U"5UlURRUlSUlg[U5S:Xag[U5S:a7U"[U5S9UlURRUlSUlg[S5e) NFr)PoolrhTr) processeszUNumber of workers specified must be -1, an int >= 1, or an object with a 'map' method) poolmap_mapfunc _own_poolcallablemultiprocessingrr< RuntimeError)r rrs r%r MapWrapper.__init__s   D>>I IIDM ,4yB F $  !%TaTQ 3t95 $  !%"$,--r$cU$r(rr s r% __enter__MapWrapper.__enter__s r$c\UR(aURR5 ggr()rr terminaters r%r"MapWrapper.terminates >> II   ! r$c\UR(aURR5 ggr()rrjoinrs r%r%MapWrapper.joins >> IINN  r$c\UR(aURR5 ggr()rrclosers r%r(MapWrapper.closes >> IIOO  r$cUR(a5URR5 URR5 ggr()rrr(r")r exc_type exc_value tracebacks r%__exit__MapWrapper.__exit__s, >> IIOO  II   ! r$cbURX5$![an[S5UeSnAff=f)Nz;The map-like callable must be of the form f(func, iterable))rr)r r`iterablees r%rMapWrapper.__call__s; >==0 0 >67<= > >s . ).)rrrNr) rr r!r"rr rr"r%r(r.rr#rr$r%rrs*-8"" >r$rc"[U[5(aURXX4US9$Uc$[RR R nU(a,UcURUS-X4S9$UbURXS-X4S9$URXX4S9$)a 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. )highrvr2endpointr)rvr2)r6rvr2)rrintegersr?rrrrandint)genlowr6rvr2r7s r% rng_integersr<sX#y!!||C%-/ / ;))""((C |{{37{CC{{3AXD{NN{{3{BBr$c#^# [RRmU4U4Sjj[RlSv T[Rlg!T[Rlf=f7f)z0Context with a fixed np.random.default_rng seed.c>T"U5$r(rrorig_funs r%$_fixed_default_rng.."s htnr$N)r?rrr?s @r%_fixed_default_rngrCsFyy$$H(,T"U0UD6nUVs/sHn[R"TSU5PM nnU$s snf)Nznp.random.default_rng())resub)rJrreslinelinesr`patterns r%_wrapped#_rng_html_rewrite.._wrapped5sND#F#  FF75t <    s"4)rFcompileI)r`rLrKs` @r%_rng_html_rewriterP)s&jjFMG Or$cj[R"XS9nU(aUb[R"X2S9nU$)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)r^keepdimsrSrHs r%_argminrW@s- ))A !CD$nnS, Jr$cj[[R"U5USS9n[R"XUS9$)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]]) TrSrVrR)rWr?isnantake_along_axis)r^rSrs r% _first_nonnanr\Ns-8  $6A  a ..r$c4Uc$URS:XagUR5nSnOAURnX1S:Xa-USUSU--X1S-S-n[R"US[ S9$[ XS9nX@:H[R"U5-RXS9$) 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]]) NrTr4rrQrRrY) rvravelrCr?rBr;r\rZrX)r^rSrVshpa0s r% _nan_allsameransD | 66Q; GGIgg 9>et*tH},s!89~=C7734t< < q $B W # ( (d ( FFr$) xp_omit_okayrIcUc [U5n[U5(+nUc1SknX;a[S[U5S35e[ U5S:XaSnGOnUR UR S5(a"URURU55nGO+UR UR S5(a`URURURU555URURURU555-nO[U5(a[R"UR [5(anSnUR5HWn[R"[U5[R 5(dM8[R"U5(dMUSn O OSnU(aUS :Xa [S 5eU(d!U(aU(aUS :Xa S n[U5eXa4$) N>omitraise propagateznan_policy must be one of .rFz real floatingzcomplex floatingTrezThe input contains nan valuesrdz9`nan_policy='omit' is incompatible with non-NumPy arrays.)rrr6setr isdtyper2rZmaxrealimagr?robjectr^r:number) r^ nan_policypoliciesrbrI not_numpy contains_nanelrs r% _contains_nanrts z Q RL I1!5c(m_AFGGqzQ AGG_ - -xxq * AGG/ 0 0xxrwwqz 23bhhrvvbggaj?Q6RR ""--88 '')B}}T"Xryy11bhhrll#    g-899 I,:v;MM!!  ##r$c^^^UUU4SjnU$)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. cN>^[R"T5UUUU4Sj5nU$)Nc l>TU;aT(ahTRS5n[[US5S-5US'SRU5nSTSTSTSUS3 n[R "U[ SS9 TU;aTRS TS 3n[U5eURT5UT'T"U0UD6$) Nrgrr{rrrrrr`) rrr<r%rrrrrr)rJrrr dep_versionrnew_namers r%r5_rename_parameter..decorator..wrappers6!"-"3"3C"8K%([^)>FZH//7j9++6-q :GMM'+=!Lv%"%,,099A ! EG#G,,#)::h#7x '' 'r$)rlr)rrryrzrs` r%r$_rename_parameter..decorators%   (  ("r$r)rrzryrs``` r%_rename_parameterr}s@( r$cURnURnURU5Vs/sH1n[RR [ U5"U55PM3 nnU$s snfr()rrspawnr?rrr:)r n_childrenbgsschild_ss child_rngss r% _rng_spawnrsb  B B"$((:"68"6h))%%d2hx&89"68 8s8A()rIc0Uc[U6OUnUVs/sHo RU5PM nn[USUR5nUR"/UQUP76nURURUS9S$s snf![ a UR nN:f=f)Nfloat16r1r)rr8getattrfloat32rArrnan)rIrgitem min_floatr2s r%_get_nanr s#%:$ 2B)- .JJt D .B 2::6 00i0 ::bffE: *2 .. /  sA7+A<<BBcVX*:dX:aSUSU3n[U5eUS:aX-nU$)Nzaxis z) is out of bounds for array of dimension r)r )rSndimrs r%normalize_axis_indexrs= e|t|dVDTFKn ax{ Kr$cLUcgU"U5 g![a SUlgf=f)a-Call 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 FT) StopIterationstop_iteration)callbackrHs r%_call_callback_maybe_haltr%s6   "&s ##cZ\rSrSrSrSr\Rr\Rr Sr Sr Sr g) _RichResulti?z4Container for multiple outputs with pretty-printing cHX$![an[U5UeSnAff=fr()KeyErrorAttributeError)r rr2s r% __getattr___RichResult.__getattr__As, .:  . &A - .s ! !c^^^^/SQm[UST5m1SkmU4SjmU4SjmUU4SjnUR5(a [XS9$URRS-$) N)rsuccessstatusrfunlr xlcol_indnitloweruppereqlinineqlin convergedflagfunction_calls iterationsroot _order_keys>conslackr crossover_nitc>TRUSR55$![a [Rs$f=fNr)rrr6r?r)r order_keyss r%key!_RichResult.__repr__..keyTs; !''Q 88 vv  s!%AAc3>># UHnUST;aMUv M g7frr)itemsr omit_keyss r%omit_redundant,_RichResult.__repr__..omit_redundantZs$7i' sc@>[T"UR55TS9$)N)r)sortedr)drrs r% item_sorter)_RichResult.__repr__..item_sorter`s.3= =r$)sorterz())rkeys_dict_formatter __class__r)r rrrrrs @@@@r%__repr___RichResult.__repr__Js^ T=*= E      > 99;;"4< <>>**T1 1r$c4[UR55$r()listrrs r%__dir___RichResult.__dir__hsDIIK  r$rN)rr r!r"rrdict __setitem__ __setattr__ __delitem__ __delattr__rrr#rr$r%rr?s,?. ""K""K2<!r$rcVURS5nSU-nSU-RU5$)zI Ensures that lines after the first are indented by the specified amount r )rr%)srrindents r% _indenterrls/ GGDME UF 6M   &&r$c[R"U5(ag[R"U5(ag[R"U5(ag[R"USSSS9$)zH Returns a string representation of a float with exactly ten characters z infz -infz nanr{F) precisionpad_leftunique)r?isposinfisneginfrZformat_float_scientific)r s r%_float_formatter_10rusK {{1~~ Q ! % %a1q OOr$c[U[5(a[[[[ UR 5555U-nSRU"U5VVs/sH:upVURU5S-[[XdU-S-SU5US-5-PM< snn5nU$[R"SU- SSS[0S9 [U5nS S S 5 U$s snnf!,(df  W$=f) 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 rz: r{rL float_kind) linewidth edgeitems threshold formatterN)rrrjrrrrr%rjustrrr? printoptionsrr)rrmplusrmrvrs r%rrs!T Caffh( )E 1 II#)!9.#,41wwqzD( aCE1f!EqsKL#,. / H__r!tqB(46I'JLAAL H.LL HsAC C&& C5)NN)r)TFFFFr()NNint64F)l !E^1cuBn)FN)F)rfN)rrN)_rF contextlibrrlrnrr collectionsrrrtypingrrnumpyr?scipy._lib._array_apirrr scipy._lib._docscraper r r: Exception__annotations__Warninglib NumpyVersion __version__numpy.exceptionsr r rrrcatch_warningsfilterwarningsrlongrulongrrint_uintr<r IntNumberr=floating DecimalNumberr;rr} __array__rrrrrr numpy.random ImportErrorrOrcryr~rrrrrrrrrrr<rCrPrWr\rartr}rrrrrrrrrrr$r%rsa %" %DD8  ?W =(66r~~&(2 $ 66r~~&,6   $ $ &  # #B  ggGxxH' &ggGwwH "**   #bjj0 t 66r~~&'1NVV(83N ! T* ))%% (=(==i=$&-)-t4  3 L^%P!&S4;s;u;  :264#'ur"<(,BG"'5 p RIJ 48n % %G>G>T8?=C@)). /@-G`,$$,$^4n /4*!$*!Z' P {"' & ggGwwH*     sTK6'-K$K6"L*L*$ K3.K63K66LLL'&L'*L>=L>