o EbbS@sddlmZddlZddlZddlZddlZddlZddlmZddl Z ddl Z ddl m Z m Z mZmZddlZe eejfZe eejejfZeree e eejjejjfZede ejjejjfdZzddlmZWney}Gdd d ZYnwd7d d Zd8d d Z eddfddZ!ddZ"ddZ#dedefddZ$GdddZ%ddZ&   d9dd Z'd:d!d"Z(ed#gd$Z)d%d&Z*Gd'd(d(Z+Gd)d*d*Z, + d;d,d-Z-edd5d6Z1dS)?)contextmanagerN) namedtuple)OptionalUnion TYPE_CHECKINGTypeVar GeneratorType)Zbound) Generatorc@s eZdZdS)r N)__name__ __module__ __qualname__r r 2/usr/lib/python3/dist-packages/scipy/_lib/_util.pyr !sr c st|dur|durtdtj}n|durtdtjg|R}|d|dd}tfdd|D}tdd |D}tjt|d||d }t ||||durutfd d|D}t ||||S) a np.where(cond, x, fillvalue) always evaluates x even where cond is False. This one only evaluates f(arr1[cond], arr2[cond], ...). Examples -------- >>> 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.]) Notice, it assumes that all `arrays` are of the same shape, or can be broadcasted together. Nz%One of (fillvalue, f2) must be given.z)Only one of (fillvalue, f2) can be given.rc3|] }t|VqdSNnpextract.0Zarrcondr r Bz_lazywhere..cSg|]}|jjqSr dtypecharrar r r Cz_lazywhere..Z fill_valuerc3s|] }t|VqdSrrrrr rrGs) rasarray ValueErrornanbroadcast_arraystuple mintypecodefullshapeplace) rarraysf fillvaluef2argstemptcodeoutr rr _lazywhere%s" r5c stj|}tdd|D}tjt|d||d}t||D]*\}tdur-q!t|d\}tfdd|D}t|||q!|S)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 -------- >>> 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.]) cSrr rrr r rr!ir"z_lazyselect..rr#Fc3rrrrrr rrorz_lazyselect..) rr'r)r*r+zipallr(r,) ZcondlistZ choicelistr-defaultr3r4func_r2r rr _lazyselectMs r;CcCst|}|dur |j}t|ds|f}ttj||j}t ||dtj }|j dd|}|dkr:||}||||ddd}tj ||||d}| 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)rrZ alignmenthasattr functoolsreduceoperatormulitemsizeemptyZuint8Z__array_interface__Zndarrayfill)r+rr@Zalignsizebufoffsetr>r r r_aligned_zerosts   rLcCs(|jdur|j|jjdkr|S|S)zReturn an array equivalent to the input array. If the input array is a view of a much larger array, copy its contents to a newly allocated array. Otherwise, return the input unchanged. N)baserIcopy)Zarrayr r r _prune_arraysrPcCsd}|D]}||9}q|S)z Product of a sequence of numbers. Faster than np.prod for short lists like array shapes, and does not overflow if using Python integers. rr )iterableproductxr r rprods rTnreturncCs|dkr tt|StjS)zlCompute the factorial and return as a float Returns infinity when result is too large for a double )floatmathZ factorialrinf)rUr r rfloat_factorialsr[c@s(eZdZdZddZddZddZdS) DeprecatedImporta3 Deprecated import with redirection and warning. Examples -------- Suppose you previously had in some module:: from foo import spam If this has to be deprecated, do:: spam = DeprecatedImport("foo.spam", "baz") to redirect users to use "baz" module instead. cCs(||_||_t|jtj|j|_dSr) _old_name _new_name __import__sysmodules_mod)selfZold_module_nameZnew_module_namer r r__init__s zDeprecatedImport.__init__cCs t|jSr)dirrbrcr r r__dir__s zDeprecatedImport.__dir__cCs$td|j|jftt|j|S)Nz'Module %s is deprecated, use %s instead)warningswarnr]r^DeprecationWarninggetattrrb)rcnamer r r __getattr__s   zDeprecatedImport.__getattr__N)r r r __doc__rdrgrmr r r rr\s  r\cCs`|dus |tjurtjjjSt|tjtjfrtj|St|tjjtjj fr*|St d|)amTurn `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. Nz=%r cannot be used to seed a numpy.random.RandomState instance) rrandommtrand_rand isinstancenumbersZIntegralinteger RandomStater r%Zseedr r rcheck_random_states  rwTFc Cs|sddl}|j|rd}t||stj|rtd|r#tjntj}||}|s8|j t dur8td|rIt |j tj sI||tj d}|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. rNzxSparse 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 supported)r) Z scipy.sparseZsparseZissparser%rZmaZ isMaskedArrayZasarray_chkfiniter$rZ issubdtypeZinexactZfloat_) r Z check_finiteZ sparse_okZ objects_okZmask_okZ as_inexactZscipymsgZtoarrayr r r_asarray_validateds"#  rzcCsVzt|}Wntyt|ddw|dur)||kr)t|d|d|S)a Validate a scalar integer. This functon 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 )rDindex TypeErrorr%)krlZminimumr r r _validate_int)s r~ FullArgSpec)r1varargsvarkwdefaults kwonlyargsZkwonlydefaults annotationsc Cst|}dd|jD}dd|jD}|r|dnd}dd|jD}|r1|dnd}tdd|jDp@d}d d|jD}d d |jD}d d |jD}t||||||phd|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. cSs(g|]}|jtjjtjjfvr|jqSr )kindinspect ParameterPOSITIONAL_OR_KEYWORDZPOSITIONAL_ONLYrlrpr r rr!ms z*getfullargspec_no_self..cS g|] }|jtjjkr|jqSr )rrrZVAR_POSITIONALrlrr r rr!r  rNcSrr )rrrZ VAR_KEYWORDrlrr r rr!wrcss0|]}|jtjjkr|j|jur|jVqdSr)rrrrr8rGrr r rr|s   z)getfullargspec_no_self..cSrr )rrr KEYWORD_ONLYrlrr r rr!rcSs0i|]}|jtjjkr|j|jur|j|jqSr )rrrrr8rGrlrr r r s   z*getfullargspec_no_self..cSs"i|] }|j|jur|j|jqSr ) annotationrGrlrr r rrs )rZ signatureZ parametersvaluesr(r) r9Zsigr1rrrrZ kwdefaultsrr r rgetfullargspec_no_selfWs2  rc@s eZdZdZddZddZdS)_FunctionWrapperz? Object to wrap user's function, allowing picklability cCs"||_|dur g|_dS||_dSrr.r1)rcr.r1r r rrdsz_FunctionWrapper.__init__cCs|j|g|jRSrr)rcrSr r r__call__sz_FunctionWrapper.__call__N)r r r rnrdrr r r rrs rc@sJeZdZdZdddZddZddZd d Zd d Zd dZ ddZ dS) 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. rcCsd|_t|_d|_t|r||_|j|_dSddlm}t|dkr0||_|jj|_d|_dSt|dkr8dSt|dkrP|t|d|_|jj|_d|_dStd) NFr)Poolr?Tr)Z processeszUNumber of workers specified must be -1, an int >= 1, or an object with a 'map' method) poolmap_mapfunc _own_poolcallableZmultiprocessingrint RuntimeError)rcrrr r rrds$         zMapWrapper.__init__cCs|Srr rfr r r __enter__szMapWrapper.__enter__cC|jr |jdSdSr)rr terminaterfr r rrzMapWrapper.terminatecCrr)rrjoinrfr r rrrzMapWrapper.joincCrr)rrcloserfr r rrrzMapWrapper.closecCs"|jr|j|jdSdSr)rrrr)rcexc_type exc_value tracebackr r r__exit__s zMapWrapper.__exit__c Cs2z|||WSty}ztd|d}~ww)Nz;The map-like callable must be of the form f(func, iterable))rr|)rcr9rQer r rrszMapWrapper.__call__Nr) r r r rnrdrrrrrrr r r rrs  rint64cCst|tr|j|||||dS|durtjjj}|r7|dur(|j|d||dS|dur7|j||d||dS|j||||dS)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 np.int_. 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. )highrIrendpointNr)rIr)rrIr)rrr ZintegersrrorprqZrandint)genZlowrrIrrr r r rng_integerss ,  r !E^1cuBnc#s>tjj|ffdd tj_z dVWtj_dStj_w)z0Context with a fixed np.random.default_rng seed.cs|Srr rvZorig_funr r(sz$_fixed_default_rng..N)rroZ default_rngrvr rr_fixed_default_rng$s rcCs,tj||d}|r|durtj||d}|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. axisN)rZargminZ expand_dims)r keepdimsrresr r r_argmin/s rcCs$tt||dd}tj|||dS)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 -------- >>> 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]]) Trrr)rrisnanZtake_along_axis)r rr}r r r _first_nonnan=srcCs|dur|jdkr dS|}d}n#|j}||dkr5|d|d|||dd}tj|dtdSt||d}||kt|Bj||dS) 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 -------- >>> 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#rr) rIZravelr+rr*boolrrr7)r rrZshpZa0r r r _nan_allsame\s"  $ r)NN)r)TFFFFr)NNrF)r)FN)F)2 contextlibrrBrDr`rhrs collectionsrrrYtypingrrrrZnumpyrrrtZ IntNumberrXZfloatingZ DecimalNumberror ruZSeedTyperZ numpy.random ImportErrorr5r;rLrPrTr[r\rwrzr~rrrrrrrrrr r r rsh        ('  $  8)7 J @