Cd0<dZddlmZddlZddlmZmZmZddlm Z ddl m Z ddl Z ddlmZddlmZd Ze jZe jZe jZe jZee jZee jZee jZee jZe jZe jZe jZe jZe jZe j Z e j!Z!e j"Z"e j#Z#ej$e%5e j&Z&dddn #1swxYwYe j'Z'ej$e%5e j(Z(dddn #1swxYwYe j)Z)ej$e%5e j*Z*dddn #1swxYwYdd Z+dd Z,d Z-dZ.dZ/dZ0dZ1ddZ2ddZ3ddZ4ddZ5dZ6dZ7dZ8dS)z- A set of NumPy functions to apply per chunk ) annotationsN) ContainerIterableSequencewraps)Integral)concat)flattenc>tdfd }|S)zU A wrapper for functions that don't provide keepdims to ensure that they do. Nc: |g|Rd|i|}|s|S|}|t|j}t|ttt fs|g}t }t|jD]}||vr|dz } |tdfz } ||}|S)NaxisN)rangendim isinstancerrrtupleslice) xrkeepdimsargskwargsraxesr_slice each_axis a_callables 0lib/python3.11/site-packages/dask/array/chunk.pykeepdims_wrapped_callablez3keepdims_wrapper..keepdims_wrapped_callables Jq 54 5 5 5d 5f 5 5 H <==D$Hh ?@@ 6D''qv * *ID  7"E$KK>) gJ)NNr)rrs` rkeepdims_wrapperr!s>  :2 %$r Fc tjD] }|vrd|< |r5tfdtjD}|tt fdtjD}||fdttdjdzdi|S)aCoarsen array by applying reduction to fixed size neighborhoods Parameters ---------- reduction: function Function like np.sum, np.mean, etc... x: np.ndarray Array to be coarsened axes: dict Mapping of axis to coarsening factor Examples -------- >>> x = np.array([1, 2, 3, 4, 5, 6]) >>> coarsen(np.sum, x, {0: 2}) array([ 3, 7, 11]) >>> coarsen(np.max, x, {0: 3}) array([3, 6]) Provide dictionary of scale per dimension >>> x = np.arange(24).reshape((4, 6)) >>> x array([[ 0, 1, 2, 3, 4, 5], [ 6, 7, 8, 9, 10, 11], [12, 13, 14, 15, 16, 17], [18, 19, 20, 21, 22, 23]]) >>> coarsen(np.min, x, {0: 2, 1: 3}) array([[ 0, 3], [12, 15]]) You must avoid excess elements explicitly >>> x = np.array([1, 2, 3, 4, 5, 6, 7, 8]) >>> coarsen(np.min, x, {0: 3}, trim_excess=True) array([1, 4]) c3K|]<\}}||zrtd||z ntddV=dS)rNr).0idrs r zcoarsen..sk  1)*DG JE!q47{^ $ $ $tT9J9J      r cLg|] }j||z|f!S)shape)r&r'rrs r zcoarsen..s1UUU!agajDG3T!W=UUUr r)rrr enumerater,r reshape) reductionrr trim_excessrr'indnewshapes `` rcoarsenr5TsP16]] D==DG    !!'**      cFVUUUUUuQV}}UUUVVWWH 9QYYx(( X XuU1afqj!5L5L/M/M XQW X XXr cttr g|jzttr fdt |jD|t dDS)aCTrim boundaries off of array >>> x = np.arange(24).reshape((4, 6)) >>> trim(x, axes={0: 0, 1: 1}) array([[ 1, 2, 3, 4], [ 7, 8, 9, 10], [13, 14, 15, 16], [19, 20, 21, 22]]) >>> trim(x, axes={0: 1, 1: 1}) array([[ 7, 8, 9, 10], [13, 14, 15, 16]]) c<g|]}|dS)r)get)r&r'rs rr-ztrim..s%6661A666r c3@K|]}t||r| ndVdSrr%)r&axs rr)ztrim..s7AAb5B0bSSD11AAAAAAr )rr rdictrr)rrs `rtrimr<sy$!!v$76666af 666 UAADAAA A A BBr cH|dusJdt||jkr|Stj|| }|dkrt | dnt | |t fdt |jDS)aChunk and combine function of topk Extract the k largest elements from a on the given axis. If k is negative, extract the -k smallest elements instead. Note that, unlike in the parent function, the returned elements are not sorted internally. TrrNc3FK|]}|krntdVdSrr%r&r'rk_slices rr)ztopk..s5PPQa4ii77U4[[PPPPPPr )absr,np partitionrrrr)akrrrAs ` @rtopkrGs t     7D 1vv Q&&&A!"QeQBoooE1"IIG UPPPPP%--PPP P P QQr c|dusJt|||}dtj|}|dkr|S|tfdt |jDS)zmFinal aggregation function of topk Invoke topk one final time and then sort the results internally. Trr>c3dK|]*}|krtdddntdV+dSNr%r&r'rs rr)z!topk_aggregate..S  DEQ$YYE$b ! ! !E$KK      r )rGrCsortrrr)rErFrrs ` rtopk_aggregaterOs t     Q4""A 7D A1uu      INqv      r c ||fS)z^Preparatory step for argtopk Put data together with its original indices in a tuple. r+)rEidxs rargtopk_preprocessrRs c6Mr c|dusJdt|tr[tt|}tjd|D}tjd|D}n|\}}t ||jkr|Stj|| }|dkrt| dnt| |tfdt|j D}tj ||tj ||fS)a)Chunk and combine function of argtopk Extract the indices of the k largest elements from a on the given axis. If k is negative, extract the indices of the -k smallest elements instead. Note that, unlike in the parent function, the returned elements are not sorted internally. Trcg|]\}}|Sr+r+)r&ai_s rr-zargtopk..s77752qB777r cHg|]\}}tj||j Sr+)rC broadcast_tor,)r&rUidxis rr-zargtopk..s* H H HTR_T28 , , H H Hr r>Nc3FK|]}|krntdVdSrr%r@s rr)zargtopk..s5SSdggd SSSSSSr ) rlistr rC concatenaterBr, argpartitionrrrrtake_along_axis) a_plus_idxrFrrrErQidx2rAs ` @rargtopkrasK t     7D*d##'*--.. N77J777 > >n H HZ H H H$  3 1vv ?1qbt , , ,D!"QeQBoooE1"IIG SSSSSU16]]SSSSS TD at , ,b.@dD.Q.Q QQr cR|dusJt|dkr|n|d}t|||\}}dtj|}tj||}|dkr|S|t fdt |jDS)zFinal aggregation function of argtopk Invoke argtopk one final time, sort the results internally, drop the data and return the index only. Tr#rr>c3dK|]*}|krtdddntdV+dSrJr%rLs rr)z$argtopk_aggregate..rMr )lenrarCargsortr^rrr)r_rFrrrErQr`s ` rargtopk_aggregaterfs t    ":22 1 J ZD( 3 3FAs 7D :ad # # #D S$ - -C1uu      INsx      r clddlm}||||||}t||kr |ddn|S)Nr) arange_safelikerK)dask.array.utilsrhrd)startstopsteplengthdtyperjrhress rarangerrsP,,,,,, +eT4T : : :C3xx&((3ss88c1r Tcddlm}t||r|}t||r|}t j|||||S)Nr)Array)endpointrp)dask.array.corertrcomputerClinspace)rlrmnumrurprts rrxrx sm%%%%%%%  $||~~ ;udC(% H H HHr c |j|fi|Sr)astype)r astype_dtypers rr{r{s 18L + +F + ++r Ccf|dkrQ tj||}n$#t$rtj|}YnwxYw||S tj||}n$#t$rtj|}YnwxYw|j|jS)Nr}ri)rCascontiguousarray TypeErrorviewasfortranarrayT)rrporders rrrs || ($QQ///AA ( ( ($Q''AAA (vve}} %!!!,,,AA % % %!!$$AAA %sxx  s AAA00BBclddlm}m}|||tjt jdk|z|z dk|jkz}||tfdt|j DS)aChunk function of `slice_with_int_dask_array_on_axis`. Slice one chunk of x by one chunk of idx. Parameters ---------- x: ndarray, any dtype, any shape i-th chunk of x idx: ndarray, ndim=1, dtype=any integer j-th chunk of idx (cartesian product with the chunks of x) offset: ndarray, shape=(1, ), dtype=int64 Index of the first element along axis of the current chunk of x x_size: int Total size of the x da.Array along axis axis: int normalized axis to take elements from (0 <= axis < x.ndim) Returns ------- x sliced along axis, using only the elements of idx that fall inside the current chunk. r) asarray_safemeta_from_arrayric3FK|]}|krntdVdSrr%)r&r'rrQs rr)z,slice_with_int_dask_array..Ss5LL!t))33tLLLLLLr ) rkrrr{rCint64wherer,rrr)rrQoffsetx_sizerrr idx_filters ` ` rslice_with_int_dask_arrayr(s,?>>>>>>> ,s!3!3 4 4 4C **RX  C (37C&L# . .C ,C(sQWT]23J j/C ULLLLLeAFmmLLL L L MMr c |tj}tj|dk|t |z|}d}d}tj| |D]`}||k|||zkz}tj|} tj||dz |zdz ||z }|jdkr ||dz }a|t fdt|j DS)aSFinal aggregation function of `slice_with_int_dask_array_on_axis`. Aggregate all chunks of x by one chunk of idx, reordering the output of `slice_with_int_dask_array`. Note that there is no combine function, as a recursive aggregation (e.g. with split_every) would not give any benefit. Parameters ---------- idx: ndarray, ndim=1, dtype=any integer j-th chunk of idx chunk_outputs: ndarray concatenation along axis of the outputs of `slice_with_int_dask_array` for all chunks of x and the j-th chunk of idx x_chunks: tuple dask chunks of the x da.Array along axis, e.g. ``(3, 3, 2)`` axis: int normalized axis to take elements from (0 <= axis < x.ndim) Returns ------- Selection from all chunks of x for the j-th chunk of idx, in the correct order rr#rKc3FK|]}|krntdVdSrr%)r&r'r idx_finals rr)z6slice_with_int_dask_array_aggregate..sF  89dIId       r ) r{rCrrsum zeros_likecumsumsizerrr) rQ chunk_outputsx_chunksrx_chunk_offsetchunk_output_offsetx_chunkridx_cumrs ` @r#slice_with_int_dask_array_aggregaterVs+4 **RX  C (37C#h--/ 5 5CN  c""I//^+nw6N0NO )J''RXj'A+8K*KQOOO '! rs33""""""9999999999%%%F f wff  ") $ $  R\ * *  ") $ $  R\ * * ff  * ] L   wZ((jG fZ(( YF fZ(( YF6Y6Y6Y6YrCCCC,RRR$$RRR:,2222 I I I I,,,, ! ! ! !+N+N+N\555p#####s6!C55C9<C9D++D/2D/ E!!E%(E%