B T\G? @sddlmZmZmZddlmZddlZddlZye pe ej ddddej dddej dre ej dd d d d re e dddse d ej Z ejj ZWdQRXWn:e k rd$ddZ ejje ejjddZYnXeejdkrddZd%ddZd&ddZeejdkr:ddZddZddZddZeejed ksreejed!krxeZneZGd"d#d#eZdS)')absolute_importdivisionprint_function) LooseVersionNg?Zunsafe)casting)rdtypeg?Zi8)rzIDivide not working with dtype: https://github.com/numpy/numpy/issues/3484cCs$t|||}|dk r ||}|S)zImplementation of numpy.divide that works with dtype kwarg. Temporary compatibility fix for a bug in numpy's version. See https://github.com/numpy/numpy/issues/3484 for the relevant issue.N)npdivideZastype)Zx1Zx2outrxr6lib/python3.7/site-packages/dask/array/numpy_compat.pyr s r z1.12.0cCsht|tj }|rt|}t|jjtjs4|dfS|sFtj|dd}t|}tj |||d||fS)a If `a` is of inexact type, make a copy of `a`, replace NaNs with the `val` value, and return the copy together with a boolean mask marking the locations where NaNs were present. If `a` is not of inexact type, do nothing and return `a` together with a mask of None. Note that scalars will end up as array scalars, which is important for using the result as the value of the out argument in some operations. Parameters ---------- a : array-like Input array. val : float NaN values are set to val before doing the operation. Returns ------- y : ndarray If `a` is of inexact type, return a copy of `a` with the NaNs replaced by the fill value, otherwise return `a`. mask: {bool, None} If `a` is of inexact type, return a boolean mask marking locations of NaNs, otherwise return None. NT)Zsubok)where) isinstancer ZndarrayZarray issubclassrtypeZinexactZisnanZcopyto)avalZis_newmaskrrr _replace_nan+s  rcCs t|d\}}tj||||dS)a Return the cumulative sum of array elements over a given axis treating Not a Numbers (NaNs) as zero. The cumulative sum does not change when NaNs are encountered and leading NaNs are replaced by zeros. Zeros are returned for slices that are all-NaN or empty. .. versionadded:: 1.12.0 Parameters ---------- a : array_like Input array. axis : int, optional Axis along which the cumulative sum is computed. The default (None) is to compute the cumsum over the flattened array. dtype : dtype, optional Type of the returned array and of the accumulator in which the elements are summed. If `dtype` is not specified, it defaults to the dtype of `a`, unless `a` has an integer dtype with a precision less than that of the default platform integer. In that case, the default platform integer is used. out : ndarray, optional Alternative output array in which to place the result. It must have the same shape and buffer length as the expected output but the type will be cast if necessary. See `doc.ufuncs` (Section "Output arguments") for more details. Returns ------- nancumsum : ndarray. A new array holding the result is returned unless `out` is specified, in which it is returned. The result has the same size as `a`, and the same shape as `a` if `axis` is not None or `a` is a 1-d array. See Also -------- :func:`numpy.cumsum` : Cumulative sum across array propagating NaNs. isnan : Show which elements are NaN. Examples -------- >>> nancumsum(1) array([1]) >>> nancumsum([1]) array([1]) >>> nancumsum([1, np.nan]) array([ 1., 1.]) >>> a = np.array([[1, 2], [3, np.nan]]) >>> nancumsum(a) array([ 1., 3., 6., 6.]) >>> nancumsum(a, axis=0) array([[ 1., 2.], [ 4., 2.]]) >>> nancumsum(a, axis=1) array([[ 1., 3.], [ 3., 3.]]) r)axisrr )rr Zcumsum)rrrr rrrr nancumsumTs=rcCs t|d\}}tj||||dS)a  Return the cumulative product of array elements over a given axis treating Not a Numbers (NaNs) as one. The cumulative product does not change when NaNs are encountered and leading NaNs are replaced by ones. Ones are returned for slices that are all-NaN or empty. .. versionadded:: 1.12.0 Parameters ---------- a : array_like Input array. axis : int, optional Axis along which the cumulative product is computed. By default the input is flattened. dtype : dtype, optional Type of the returned array, as well as of the accumulator in which the elements are multiplied. If *dtype* is not specified, it defaults to the dtype of `a`, unless `a` has an integer dtype with a precision less than that of the default platform integer. In that case, the default platform integer is used instead. out : ndarray, optional Alternative output array in which to place the result. It must have the same shape and buffer length as the expected output but the type of the resulting values will be cast if necessary. Returns ------- nancumprod : ndarray A new array holding the result is returned unless `out` is specified, in which case it is returned. See Also -------- :func:`numpy.cumprod` : Cumulative product across array propagating NaNs. isnan : Show which elements are NaN. Examples -------- >>> nancumprod(1) array([1]) >>> nancumprod([1]) array([1]) >>> nancumprod([1, np.nan]) array([ 1., 1.]) >>> a = np.array([[1, 2], [3, np.nan]]) >>> nancumprod(a) array([ 1., 2., 6., 6.]) >>> nancumprod(a, axis=0) array([[ 1., 2.], [ 3., 2.]]) >>> nancumprod(a, axis=1) array([[ 1., 2.], [ 3., 3.]]) r)rrr )rr Zcumprod)rrrr rrrr nancumprods:rz1.15.0c Cst|jtjstdt||jkr.tdd|j}tt |dgtt |d|j}g}x`t ||D]R\}}|dkr| |qn|d|d||dd}| t | |qnWt|S)Nz"`indices` must be an integer arrayz;`indices` and `arr` must have the same number of dimensions)rr))r Z issubdtyperZinteger IndexErrorlenndim ValueErrorlistrangezipappendZarangeZreshapetuple) arr_shapeindicesrZ shape_onesZ dest_dimsZ fancy_indexZdimnZ ind_shaperrr_make_along_axis_idxs   r(cCsF|dkr|j}t|f}d}n|dkr0|j|}|j}|t|||S)a Take values from the input array by matching 1d index and data slices. This iterates over matching 1d slices oriented along the specified axis in the index and data arrays, and uses the former to look up values in the latter. These slices can be different lengths. Functions returning an index along an axis, like `argsort` and `argpartition`, produce suitable indices for this function. .. versionadded:: 1.15.0 Parameters ---------- arr: ndarray (Ni..., M, Nk...) Source array indices: ndarray (Ni..., J, Nk...) Indices to take along each 1d slice of `arr`. This must match the dimension of arr, but dimensions Ni and Nj only need to broadcast against `arr`. axis: int The axis to take 1d slices along. If axis is None, the input array is treated as if it had first been flattened to 1d, for consistency with `sort` and `argsort`. Returns ------- out: ndarray (Ni..., J, Nk...) The indexed result. Notes ----- This is equivalent to (but faster than) the following use of `ndindex` and `s_`, which sets each of ``ii`` and ``kk`` to a tuple of indices:: Ni, M, Nk = a.shape[:axis], a.shape[axis], a.shape[axis+1:] J = indices.shape[axis] # Need not equal M out = np.empty(Nk + (J,) + Nk) for ii in ndindex(Ni): for kk in ndindex(Nk): a_1d = a [ii + s_[:,] + kk] indices_1d = indices[ii + s_[:,] + kk] out_1d = out [ii + s_[:,] + kk] for j in range(J): out_1d[j] = a_1d[indices_1d[j]] Equivalently, eliminating the inner loop, the last two lines would be:: out_1d[:] = a_1d[indices_1d] See Also -------- take : Take along an axis, using the same indices for every 1d slice put_along_axis : Put values into the destination array by matching 1d index and data slices Examples -------- For this sample array >>> a = np.array([[10, 30, 20], [60, 40, 50]]) We can sort either by using sort directly, or argsort and this function >>> np.sort(a, axis=1) array([[10, 20, 30], [40, 50, 60]]) >>> ai = np.argsort(a, axis=1); ai array([[0, 2, 1], [1, 2, 0]]) >>> take_along_axis(a, ai, axis=1) array([[10, 20, 30], [40, 50, 60]]) The same works for max and min, if you expand the dimensions: >>> np.expand_dims(np.max(a, axis=1), axis=1) array([[30], [60]]) >>> ai = np.expand_dims(np.argmax(a, axis=1), axis=1) >>> ai array([[1], [0]]) >>> take_along_axis(a, ai, axis=1) array([[30], [60]]) If we want to get the max and min at the same time, we can stack the indices first: >>> ai_min = np.expand_dims(np.argmin(a, axis=1), axis=1) >>> ai_max = np.expand_dims(np.argmax(a, axis=1), axis=1) >>> ai = np.concatenate([ai_min, ai_max], axis=1) >>> ai array([[0, 1], [1, 0]]) >>> take_along_axis(a, ai, axis=1) array([[10, 30], [40, 60]]) Nr)Zflatrrshaper()Zarrr&rr%rrrtake_along_axissW  r*cs6|fdd|Dfdd|Djd}t|S)Ncsg|]}j|dqS)r)fields).0name)rrr [sz/_make_sliced_dtype_np_ge_16..csg|]}j|dqS)r)r+)r,r-)rrrr.\s)namesZformatsZoffsetsitemsize)r0r r)rindexnewr)rr_make_sliced_dtype_np_ge_16Qs  r3cstfdd|D}|S)Ncsg|]}||fqSrr)r,r-)rrrr.dsz/_make_sliced_dtype_np_lt_14..)r r)rr1Zdtr)rr_make_sliced_dtype_np_lt_14bsr4z1.16.0z1.14.0c@s>eZdZdZddZddddddfdd Zdd d Zd S) _Recurserz; Utility class for recursing over nested iterables cCs ||_dS)N) recurse_if)selfr6rrr__init__xsz_Recurser.__init__cKs|S)Nr)r kwargsrrr}sz_Recurser.cKs|S)Nr)r r9rrrr:~scKs|S)Nr)r9rrrr:sc s fdd|f|S)a{ Iterate over the nested list, applying: * ``f_map`` (T -> U) to items * ``f_reduce`` (Iterable[U] -> U) to mapped items For instance, ``map_reduce([[1, 2], 3, 4])`` is:: f_reduce([ f_reduce([ f_map(1), f_map(2) ]), f_map(3), f_map(4) ]]) State can be passed down through the calls with `f_kwargs`, to iterables of mapped items. When kwargs are passed, as in ``map_reduce([[1, 2], 3, 4], **kw)``, this becomes:: kw1 = f_kwargs(**kw) kw2 = f_kwargs(**kw1) f_reduce([ f_reduce([ f_map(1), **kw2) f_map(2, **kw2) ], **kw1), f_map(3, **kw1), f_map(4, **kw1) ]], **kw) cs@|s|f|Sf|fdd|Df|SdS)Nc3s|]}|fVqdS)Nr)r,xi)f next_kwargsrr sz2_Recurser.map_reduce..f..)r6)r r9)r<f_kwargsf_mapf_reducer7)r=rr<s    z_Recurser.map_reduce..fr)r7r r@rAr?r9r)r<r?r@rAr7r map_reduce{s& z_Recurser.map_reducerccsZ||}|||fV|sdSx6t|D]*\}}x ||||fD] }|VqDWq(WdS)aB Iterate over x, yielding (index, value, entering), where * ``index``: a tuple of indices up to this point * ``value``: equal to ``x[index[0]][...][index[-1]]``. On the first iteration, is ``x`` itself * ``entering``: bool. The result of ``recurse_if(value)`` N)r6 enumeratewalk)r7r r1Z do_recurseir;vrrrrDs  z_Recurser.walkN)r)__name__ __module__ __qualname____doc__r8rBrDrrrrr5os -r5)NN)NNN)NNN)Z __future__rrrZdistutils.versionrZnumpyr warningscatch_warningsZallcloser float TypeErrorZmaZ ma_divideZcoreZ_DomainedBinaryOperationZ_DomainSafeDivide __version__rrrr(r*r3r4Z_make_sliced_dtypeobjectr5rrrrs>    ) @ >d