CdddlmZddlZddlZddlZddlZddlmZddlm Z m Z ddl m Z ddl ZddlmZmZmZmZddlmZmZmZddlmZdd lmZmZdd lmZdd lm Z m!Z!e"dddZ#d Z$d Z%dZ&dZ'dZ(dZ)dZ*dZ+dZ,dZ-d)dZ.dZ/edZ0dZ1dZ2dZ3dZ4dZ5dZ6dZ7d Z8d!Z9d"Z:d#Z;d$Zd'Z?d(Z@dS)*) annotationsN)product)IntegralNumber) itemgetter)concatmemoizemergepluck)configcoreutilsgetitem)is_dask_collectiontokenize)HighLevelGraph) cached_cumsum is_arraylikec>t|tr)t|}||krtd|z|S|dSt |r/|jjdks |jdkrtd||Stdt||)zSanitize a one-element index.$Bad index. Must be integer-like: %sNiz!Bad index. Must be integer-like: Invalid index type) isinstancerint IndexErrorrdtypekindsize TypeErrortype)indind2s 2lib/python3.11/site-packages/dask/array/slicing.py_sanitize_index_elementr&s#v >3xx 3;;CcIJJ JK t C > 9>S CHMMFFFGG G ,d3ii===c ddlm}|dSt|trGtt |jt |jt |jSt|trt |St|r|S|||}|j tkrTtj |}t|dkr|d}t|r|Stj|Stj|j tjr|Stj|j tjr|tj}tj||r|Stj||}|tj|d}t5d|zt7dt9||)aSanitize the elements for indexing along one axis >>> sanitize_index([2, 3, 5]) array([2, 3, 5]) >>> sanitize_index([True, False, True, False]) array([0, 2]) >>> sanitize_index(np.array([1, 2, 3])) array([1, 2, 3]) >>> sanitize_index(np.array([False, True, True])) array([1, 2]) >>> type(sanitize_index(np.int32(0))) >>> sanitize_index(1.0) 1 >>> sanitize_index(0.5) Traceback (most recent call last): ... IndexError: Bad index. Must be integer-like: 0.5 r)asanyarray_safeNlikerrr)dask.array.utilsr)rslicer&startstopsteprrrboolnpnonzerolenr asanyarray issubdtypeintegerfloatingastypeintpallcloseiscloseravel flatnonzerorr!r")r#r) index_arrayr3 int_index check_int first_errs r%sanitize_indexrC)s(100000 {t C    #CI . . #CH - - #CH - -   C &s+++ C  !/#C000KD  *[)) w<<1  ajG   *N=)) ) {("* 5 5 > {("+ 6 6 >&&rw// ;{I . . Q  ; ::I#))++BNI:,F,Fq,IJICiOPP P,d3ii===r'cttt|}td|Dr&td|D}fd|D}||fSt d|D}t ||z }|t dddf|zz }t|||\} } ttt| } | | fS)aW Main function for array slicing This function makes a new dask that slices blocks along every dimension and aggregates (via cartesian product) each dimension's slices so that the resulting block slices give the same results as the original slice on the original structure Index must be a tuple. It may contain the following types int, slice, list (at most one list), None Parameters ---------- in_name - string This is the dask variable name that will be used as input out_name - string This is the dask variable output name blockshape - iterable of integers index - iterable of integers, slices, lists, or None itemsize : int The number of bytes required for each element of the array. Returns ------- Dict where the keys are tuples of (out_name, dim_index[, dim_index[, ...]]) and the values are (function, (in_name, dim_index, dim_index, ...), (slice(...), [slice()[,...]]) Also new blockdims with shapes of each block ((10, 10, 10, 10), (20, 20)) Examples -------- >>> from pprint import pprint >>> dsk, blockdims = slice_array('y', 'x', [(20, 20, 20, 20, 20)], ... (slice(10, 35),), 8) >>> pprint(dsk) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE {('y', 0): (, ('x', 0), (slice(10, 20, 1),)), ('y', 1): (, ('x', 1), (slice(0, 15, 1),))} >>> blockdims ((10, 15),) See Also -------- This function works by successively unwrapping cases and passing down through a sequence of functions. slice_with_newaxis : handle None/newaxis case slice_wrap_lists : handle fancy indexing with lists slice_slices_and_integers : handle everything else c3jK|].}t|to|tdddkV/dSN)rr-).0indexs r% zslice_array..sS  JO 5%  EUeD$.E.E%E      r'cFg|]}tt|Sranger4rGbds r% zslice_array..s$@@@U3r77^^@@@r'c&i|] }f|zf|zSrKrK)rGsin_nameout_names r% zslice_array..s'AAA1{Q QAAAr'c3K|]}|duV dSrFrKrGrs r%rIzslice_array..s&661$666666r'N)tuplemapallrsumr4r-slice_with_newaxes) rTrS blockdimsrHitemsizesuffixesdsknot_none_countmissingdsk_outbd_outs `` r% slice_arrayrecszc%++,,I   SX   @@i@@@AAAAAAAAAI~6666666N)nn~-G eD$%% '' 11E)7IuhWWOGV 3uf%% & &F F?r'cNtd|D}dt|D}t|}t|D]8\}} td|d| D} | r||xx| zcc<9t ||||\} } |r~t |t |fd| D} t| fd| D}| d}||fS| | fS)z] Handle indexing with Nones Strips out Nones then hands off to slice_wrap_lists c3K|]}||V dSrFrKrGr#s r%rIz%slice_with_newaxes..s";;33?3????;;r'cg|] \}}|| SrFrKrGrr#s r%rPz&slice_with_newaxes..sBBB3ck!kkkr'c3@K|]}t|tVdSrFrrrhs r%rIz%slice_with_newaxes..s,??c 3))??????r'Nci|]F\}}|dkf|dddz|dd|ddfzGS)rrNrK)rGkvexpand expand_origrTs r%rUz&slice_with_newaxes..ss   1txK&&122** *QrrUkk!A$6M6M5O-Or'c4i|]\}}|dk||SrrK)rGrorprTs r%rUz&slice_with_newaxes..s-MMMTQAaDH.s>XXQz!eT8455HaXXXXXXr'Too many indices for arraycLg|]!\}}t|r |jdk|"Srt)rndimrjs r%rPz$slice_wrap_lists..s:aL,=,=BE(Q,,,,,r'r#Don't yet support nd fancy indexingrc3ZK|]&}t|rtdddn|V'dSrFrr-rWs r%rIz#slice_wrap_lists..sO>?<??9dD$r'c3^K|](}t|p|tdddkV)dSrFrrWs r%rIz#slice_wrap_lists..s> J Jq<?? :a5tT#:#:: J J J J J Jr')axiszslice-c3XK|]$\}}|k t|t dV%dSrNrl)rGrr#rs r%rIz#slice_wrap_lists..sB  !SDZX=V=VA  r')rZr4rrvNotImplementedErrorr rwr-poprXslice_slices_and_integerstakerr[r )rTrSr]rHr^ where_listindex_without_listrrtmpr`axis2rrs @r%rxrxsY XXRWXXX X XXXX y>>SZZ ' '5666!%((J :!"GHHH% 1 .3U "'1a..jnne  N(7IuMMMCH  J JE J J JJJ !} gy% 1 *>t    DD 8Wi"GHHH3 )%7  Z !}s    %e,,        #z5;PUVVV DS$  r'c $ddlm}td|D}t||D]B\}}t j|r)|t dddkrtd||Ctd|DsJt|t|ksJttt|||}d|D} tt|ggd| DR} tt|ggd t||DR} ttd | D} d t| | | D} d t|||D}| |fS) z` Dask array indexing with slices and integers See Also -------- _slice_1d r)unknown_chunk_messagec3DK|]}t|ddVdS)T initial_zeroNr)rGdims r%rIz,slice_slices_and_integers..+s4QQ-$777;QQQQQQr'Nz Arrays chunk sizes are unknown: c3NK|] }t|ttfV!dSrF)rr-rrhs r%rIz,slice_slices_and_integers..3s1CCcz#x011CCCCCCr'cPg|]#}t|$SrK)sortedrzrWs r%rPz-slice_slices_and_integers..8s(CCC6!'')),,CCCr'c.g|]}td|Srtr rGrRs r%rPz-slice_slices_and_integers..;s (R(R(Rq!(R(R(Rr'cg|]m\}}t|t|jr0|jdkr%tt |dddntt |nS)rNr)rrr0rMr4)rGdrs r%rPz-slice_slices_and_integers..AsuAq!!X..'(vO!&1**c!ff ddd##%A--r'c.g|]}td|Srurrs r%rPz-slice_slices_and_integers..Is IIIa IIIr'c,i|]\}}}|t||fSrKr)rGrTrSslicess r%rUz-slice_slices_and_integers..Ks7 %Hgv 7GV,r'cbg|],\}}}t|tt|||-SrK)rr new_blockdim)rGrrdbs r%rPz-slice_slices_and_integers..PsJ Aq"!X&&QAr')dask.array.corerrXzipr2isnanr- ValueErrorrZr4rwrY _slice_1dr)rTrSr]rHrshaperr# block_slicessorted_block_slicesin_names out_names all_slicesrc new_blockdimss r%rr s655555 QQyQQQ Q QEu%%S 8C== SE$d$;$;;;Q5Q:OQQ  CCUCCC C CCCC u::Y ' ' ' 'Iui??@@LCClCCCGWIS(R(R>Q(R(R(RSSSTTH J  e44     IgII5HIIIJKKJ),Y*)M)MG E5)44M M !!r'c t|}t|trJtj||}|dkr|||dz z }n|}t |t |iSt|t sJ|tkr&dtt|DS|j pd}|dkr|j pd}|j |j n|}n4|j |j n|dz }||kr|dz n|}|j |dz n|j }|dkr||z }|dkr||z }t} |dkrtj||} tj||} t| dzt|} | dkr||| dz z }||| dz z }t| | D]K}||} || kr1|dkr+t |t|| || |<|| z |z}n|| z }|| z}Ln|} tj||} tj||} t| dzt|dz } t!| dz d} t| | dD]u}||}|dkrd}n ||dz }|| cxkr|krJn.| |krAt | |z t!||z dz ||z || |<| |dz z |z}||zdz } v| D]4\}}|t d||dkrt ddd| |<5| st ddd| d<| S)a Returns a dict of {blocknum: slice} This function figures out where each slice should start in each block for a single dimension. If the slice won't return any elements in the block, that block will not be in the output. Parameters ---------- dim_shape - the number of elements in this dimension. This should be a positive, non-zero integer blocksize - the number of elements per block in this dimension This should be a positive, non-zero integer index - a description of the elements in this dimension that we want This might be an integer, a slice(), or an Ellipsis Returns ------- dictionary where the keys are the integer index of the blocks that should be sliced and the values are the slices Examples -------- Trivial slicing >>> _slice_1d(100, [60, 40], slice(None, None, None)) {0: slice(None, None, None), 1: slice(None, None, None)} 100 length array cut into length 20 pieces, slice 0:35 >>> _slice_1d(100, [20, 20, 20, 20, 20], slice(0, 35)) {0: slice(None, None, None), 1: slice(0, 15, 1)} Support irregular blocks and various slices >>> _slice_1d(100, [20, 10, 10, 10, 25, 25], slice(10, 35)) {0: slice(10, 20, 1), 1: slice(None, None, None), 2: slice(0, 5, 1)} Support step sizes >>> _slice_1d(100, [15, 14, 13], slice(10, 41, 3)) {0: slice(10, 15, 3), 1: slice(1, 14, 3), 2: slice(2, 12, 3)} >>> _slice_1d(100, [20, 20, 20, 20, 20], slice(0, 100, 40)) # step > blocksize {0: slice(0, 20, 40), 2: slice(0, 20, 40), 4: slice(0, 20, 40)} Also support indexing single elements >>> _slice_1d(100, [20, 20, 20, 20, 20], 25) {1: 5} And negative slicing >>> _slice_1d(100, [20, 20, 20, 20, 20], slice(100, 0, -3)) # doctest: +NORMALIZE_WHITESPACE {4: slice(-1, -21, -3), 3: slice(-2, -21, -3), 2: slice(-3, -21, -3), 1: slice(-1, -21, -3), 0: slice(-2, -20, -3)} >>> _slice_1d(100, [20, 20, 20, 20, 20], slice(100, 12, -3)) # doctest: +NORMALIZE_WHITESPACE {4: slice(-1, -21, -3), 3: slice(-2, -21, -3), 2: slice(-3, -21, -3), 1: slice(-1, -21, -3), 0: slice(-2, -8, -3)} >>> _slice_1d(100, [20, 20, 20, 20, 20], slice(100, -12, -3)) {4: slice(-1, -12, -3)} rrci|] }|t SrK)colon)rGros r%rUz_slice_1d..s666Q5666r'Nr)rrrbisect bisect_rightrr-rrMr4r0r.r/dict bisect_leftminmaxrz) dim_shapelengthsrHchunk_boundariesrr#r0r.r/ristartistoplengthrstart chunk_stop chunk_startoffsetrorps r%rrYsR%W--%"""   0% 8 8 q55*1q511CCCAC!! eU # #### ~~66%G "5"56666 :?D axx  q"Z3uzz${6 IM!&)!3!3 A #(:#5Q5: qyy  axx  A axx$%5u=="#3T::EAIs7||,, A::,VaZ88E*6A:66Dvu%%  AQZFv~~$((UCf$5$5t<<!4/ FNDD #$4e<<#$4d;;VaZ%5!6!6!:;;EAIr""vub)) 2 2A)!,JAvv .q1u5 v2222 22222$Z' j014dZ6GHH!!K!O4<$v-1 ++1 aQ'' ' 'tT**AaD Q1~~! Hr'ctstjtjt |dzt }d|d<tj||dd}tjt |dzt }d|d<tj||dd<fdt|dd|dd|DS)zy >>> partition_by_size([10, 20, 10], [1, 5, 9, 12, 29, 35]) [array([1, 5, 9]), array([ 2, 19]), array([5])] r)rrN)outc2g|]\}}}|||z SrKrK)rGjrolseqs r%rPz%partition_by_size..s+ S S Swq!QS1X\ S S Sr'r) rr2r5emptyr4rcumsum searchsortedr)sizesrleftright locationss ` r%partition_by_sizers   !mC   8CJJN# . . .DDG Ieabb * * *EUas333IIaLOC//IabbM S S S S#inimT*R*R S S SSr'c|t|dkrdStj|dd|ddkS)zdIs sequence sorted? >>> issorted([1, 2, 3]) True >>> issorted([3, 1, 2]) False rTNrr)r4r2rZ)rs r%issortedrs= 3xx1}}t 6#crc(c!""g% & &&r'cddlm}t|stj|}t |}|||}tj||d}|}tjtj |ddz}|dg|}|t|g|}tj |||g}g}tt|dz D]T} ||| || dz} ||| } | dkr| || dz z } | | | fU|S)aConstruct a plan to slice chunks with the given index Parameters ---------- chunks : Tuple[int] One dimensions worth of chunking information index : np.ndarray[int] The index passed to slice on that dimension Returns ------- out : List[Tuple[int, np.ndarray]] A list of chunk/sub-index pairs corresponding to each output chunk r asarray_safer*r)sider)r,rrr2r5rrtolistwherediffr4 concatenaterMappend) chunksrHr cum_chunkschunk_locationsrextrac_locrr sub_indexchunks r% slicing_planrsw.-----   % e$$v&&Jju555Joj%gFFFO&,,..O HRW_-- . .q 1A 5E L!5 ) ) )E L#o../e < < " "''%(U1q5\12 a) 199!Juqy$99I E9%&&&& Jr'cddlm}t|}t|tdzkrQt jt|tz }t jd|z|dt|stj |}tj tjd} fdttD} t jd | D} t j| s| dkrtjx} } nt j| | |zz } | d z} tjd d }|d u}|D]5\}}|s.t|| krd }t j||dd}6g}g}|D]\}}t|}|rl|| krftj|t j|| z }||||gt|zt|stj|}||||dD}t/|}t/tt||<t/t1|gg|R}t/|}||<dD}||<t/t1|}t/t1|gg|R}dt3||D}t/}t5t7t||<t9t3||} t5|| fS)aIndex array with an iterable of index Handles a single index by a single list Mimics ``np.take`` >>> from pprint import pprint >>> chunks, dsk = take('y', 'x', [(20, 20, 20, 20)], [5, 1, 47, 3], 8, axis=0) >>> chunks ((2, 1, 1),) >>> pprint(dsk) # doctest: +ELLIPSIS {('y', 0): (, ('x', 0), (array([5, 1]),)), ('y', 1): (, ('x', 2), (array([7]),)), ('y', 2): (, ('x', 0), (array([3]),))} When list is sorted we retain original block structure >>> chunks, dsk = take('y', 'x', [(20, 20, 20, 20)], [1, 3, 5, 47], 8, axis=0) >>> chunks ((3, 1),) >>> pprint(dsk) # doctest: +ELLIPSIS +NORMALIZE_WHITESPACE {('y', 0): (, ('x', 0), (array([1, 3, 5]),)), ('y', 1): (, ('x', 2), (array([7]),))} When any indexed blocks would otherwise grow larger than dask.config.array.chunk-size, we might split them, depending on the value of ``dask.config.slicing.split-large-chunks``. >>> import dask >>> with dask.config.set({"array.slicing.split-large-chunks": True}): ... chunks, dsk = take('y', 'x', [(1, 1, 1), (2000, 2000), (2000, 2000)], ... [0] + [1] * 6 + [2], axis=0, itemsize=8) >>> chunks ((1, 3, 3, 1), (2000, 2000), (2000, 2000)) rPerformanceWarning zESlicing with an out-of-order index is generating %d times more chunks stacklevelzarray.chunk-sizec,g|]}|k|SrKrK)rGrrrs r%rPztake..s"GGG!Q$YYF1IYYYr'c34K|]}t|VdSrF)r)rGr~s r%rIztake..s(99qCFF999999r'z array.slicing.split-large-chunksNaiSlicing is producing a large chunk. To accept the large chunk and silence this warning, set the option >>> with dask.config.set(**{'array.slicing.split_large_chunks': False}): ... array[indexer] To avoid creating the large chunks, set the option >>> with dask.config.set(**{'array.slicing.split_large_chunks': True}): ... array[indexer]TcFg|]}tt|SrKrLrNs r%rPztake..s$ , , ,rE#b''NN , , ,r'c>g|]}tgt|zSrK)rr4rNs r%rPztake..s% 1 1 1BugB 1 1 1r'c(g|]\}}t||fSrKr)rGinkeyslcs r%rPztake..s# J J J sws# J J Jr')rrrr4mathceilwarningswarnrr2asarrayr parse_bytesr getrMprodrinf array_splitextendarrayrrwrrrXrYr)!outnameinnamerrHr^rrplanfactornbytes other_chunks other_numelwarnsizemaxsizesplitwarned_ index_listmsg where_index index_lists where_idx index_length index_sublistdimsindimskeysoutdimsrinkeysvalueschunks2r`s! ` ` r%rrKsL322222 t e , ,D 4yyCt %%***3t99s6$<'8'8899  "( )        " 5!! vz*<== > >FGGGGGuS[['9'9GGGL)99L99999K z++"2"2!X%77)FkH&<=>>Q; J94 @ @E$ F   : #j//H44-  M#1a @ @ @ @FKK!% * * ::  *\G++NDIlW&<==M   } - - -    {S-?-?? @ @ @ @ ++ 2Xj11   z * * *   y ) ) ) ) , ,V , , ,D $ZZFc+..//00F4L  +F+++ , ,D4jjGGDM 1 1& 1 1 1FF4L '6" # #F '6(-W--- . .F J Jc&&6I6I J J JF6llG#c;//00GDM s4  ! !C >>3 r'ct|tr#ttt||St|tr!|dkrt j|s||zS|St|tjtfrEt j|s1tj |}tj |dk||z|S|S)aPFlip negative indices around to positive ones >>> posify_index(10, 3) 3 >>> posify_index(10, -3) 7 >>> posify_index(10, [3, -3]) array([3, 7]) >>> posify_index((10, 20), (3, -3)) (3, 17) >>> posify_index((10, 20), (3, [3, 4, -3])) # doctest: +NORMALIZE_WHITESPACE (3, array([ 3, 4, 17])) r) rrXrY posify_indexrrrr2ndarrayrwr5r)rr#s r%r%r%s#u4Suc22333#x   774:e,,7; J# D)**34:e3D3D3mC  xauc222 Jr'c|sd}|Sd}g}d}tt|dzD]9}||vr|d|d|z|dz }:d|z}d|}|jd it }i}t t|d d |||d S) Nc|SrFrK)rvals r%rqz_expander..expandsJr'zKdef expand(seq, val): return ({left}) + tuple({right}) rrzval, z seq[%d], zseq[%d:]z execrqrK)rMrrjoinformatlocalsr+compile)rrqdeclrrrrnss r% _expanderr2s       s5zzA~&&  AEzz G$$$$ K!O,,,QQwwt}}t{&&VXX&&  WT; / /R888(|r'c:tt|S)zCreate a function to insert value at many locations in sequence. >>> expander([0, 2])(['a', 'b', 'c'], 'z') ('z', 'a', 'z', 'b', 'c') )r2rX)rs r%ryrys U5\\ " ""r'c|tdddkrSt|trt|gSt|trJt t ||td}fd|D}t|tr|j r|j dkr |ddd}d|DS)a >>> new_blockdim(100, [20, 10, 20, 10, 40], slice(0, 90, 2)) [10, 5, 10, 5, 15] >>> new_blockdim(100, [20, 10, 20, 10, 40], [5, 1, 30, 22]) [4] >>> new_blockdim(100, [20, 10, 20, 10, 40], slice(90, 10, -2)) [16, 5, 10, 5, 4] Nr)keycrg|]3\}}|tdddkrtd|dn|4S)Nrrr-)rGrrrs r%rPz new_blockdim..sX As$'%dD*A*A#A#AaQsr'rcg|];}ttjd|jz|jz |jz .s> V V VC 3>CI5ABB C C V V Vr') r-rrwr4rrrrzrr0)rrrHpairsrs ` r%rrs dD$''''%E |%***** 9Y77==??ZPQ]] S S SEF%EJ5:>>" V Vv V V VVr'cdt|D}|s|S|d}|t|td|Dz dz z }|d|tdddf|zz||dzdzS)zReplace ... with slices, :, : ,: >>> replace_ellipsis(4, (3, Ellipsis, 2)) (3, slice(None, None, None), slice(None, None, None), 2) >>> replace_ellipsis(2, (Ellipsis, None)) (slice(None, None, None), slice(None, None, None), None) c*g|]\}}|tu|SrK)Ellipsisrjs r%rPz$replace_ellipsis..*s!FFF3cXoo!ooor'rc3K|]}|duV dSrFrKrWs r%rIz#replace_ellipsis../s&,F,F1Q$Y,F,F,F,F,F,Fr'rN)rvr4r[r-)rrH isellipsislocextra_dimensionss r%replace_ellipsisrA sGF)E"2"2FFFJ  mCJJ,F,F,F,F,F)F)FFJK dsd uT4..03CCCeCRSGIIFVVr'c8t|trtj|r|S||\}}}|dkr%|dkrd}||krd}|dkrd}| |||kr|}n|dkr||dz krd}|dkrd}t|||S|S)zNormalize slices to canonical form Parameters ---------- idx: slice or other index dim: dimension length Examples -------- >>> normalize_slice(slice(0, 10, 1), 10) slice(None, None, None) rNr)rr-rrindices)idxrr.r/r0s r%normalize_slicerE5s#u( :c?? JKK,,tT !88zzs{{qyyE$5$,, AXXaaxxUD$''' Jr'c$ddlm}m}t|ts|f}t |dkr\t |dkrI|d}t |r2t||s"|j|kr||g|ddR}tt ||}d}|D]0}t|dr|j dkr ||j z }(|+|dz }1|tdft ||z zz}t d|Dt |krtdg}d}|D]:}|!| |||dz }%| d;tt||D]\}\}} | t!||| t t#t$|}t t#t&||}t)||}|S)aTNormalize slicing indexes 1. Replaces ellipses with many full slices 2. Adds full slices to end of index 3. Checks bounding conditions 4. Replace multidimensional numpy arrays with dask arrays 5. Replaces numpy arrays with lists 6. Posify's integers and lists 7. Normalizes slices to canonical form Examples -------- >>> normalize_index(1, (10,)) (1,) >>> normalize_index(-1, (10,)) (9,) >>> normalize_index([-1], (10,)) (array([9]),) >>> normalize_index(slice(-3, 10, 1), (10,)) (slice(7, None, None),) >>> normalize_index((Ellipsis, None), (10,)) (slice(None, None, None), None) >>> normalize_index(np.array([[True, False], [False, True], [True, True]]), (3, 2)) (dask.array,) r)Array from_arrayrNrcg|]}||SrFrKrWs r%rPz#normalize_index..s , , ,!amAmmmr'r)rrGrHrrXr4rrrAhasattrrr-rrrvr check_indexrYrCrEr%) rDrrGrHr n_sliced_dims none_shaper#rrs r%normalize_indexrNYsE421111111 c5 ! !f 3xx!||E Q F ?? ,:a#7#7 ,AGu>> check_index(0, 3, 5) >>> check_index(0, 5, 5) Traceback (most recent call last): ... IndexError: Index 5 is out of bounds for axis 0 with size 5 >>> check_index(1, 6, 5) Traceback (most recent call last): ... IndexError: Index 6 is out of bounds for axis 1 with size 5 >>> check_index(1, -1, 5) >>> check_index(1, -6, 5) Traceback (most recent call last): ... IndexError: Index -6 is out of bounds for axis 1 with size 5 >>> check_index(0, [1, 2], 5) >>> check_index(0, [6, 3], 5) Traceback (most recent call last): ... IndexError: Index is out of bounds for axis 0 with size 5 >>> check_index(1, slice(0, 3), 5) >>> check_index(0, [True], 1) >>> check_index(0, [True, True], 3) Traceback (most recent call last): ... IndexError: Boolean array with size 2 is not long enough for axis 0 with size 3 >>> check_index(0, [True, True, True], 1) Traceback (most recent call last): ... IndexError: Boolean array with size 3 is not long enough for axis 0 with size 1 NzBoolean array with size z is not long enough for axis z with size z Index is out of bounds for axis zIndex z is out of bounds for axis ) rrwr2r5rrrrr1r ranyr-)rr# dimensions r%rKrKsP#t!mC   x   C   c   9  x9$$ =sx== $==1:==%$ Y # # % % # *:)?)?)A)A O4OOIOO    C      SI:-- QS Q QT Q Qi Q Q   .-r'cddlmt||jksJfd|D}t |dkrt dg}d}t |D]\}}||z t|r|jj dvr|jdkr\|tj }t||}|tfdt|jD}|dz }|jdkr4t||}|t!dt d |||t|fS) a*Slice x with at most one 1D dask arrays of ints. This is a helper function of :meth:`Array.__getitem__`. Parameters ---------- x: Array index: tuple with as many elements as x.ndim, among which there are one or more Array's with dtype=int Returns ------- tuple of (sliced x, new index) where the new index is the same as the input, but with slice(None) replaced to the original slicer where a 1D filter has been applied and one less element where a zero-dimensional filter has been applied. r)rGcg|]E}t|ttfp&t|tjfo |jdkFSrt)rrXrwr2r&r)rGrDrGs r%rPz-slice_with_int_dask_array..s^  3 && C sRZ/ 0 0 ASX\r'rriuc3FK|]}|krdntdVdS)rNr7)rGrout_axiss r%rIz,slice_with_int_dask_array.. s5WWAhAAE$KKWWWWWWr'NzZSlicing with dask.array of ints only permitted when the indexer has zero or one dimensions)rrGr4rr[rrvrrrr2newaxis!slice_with_int_dask_array_on_axisrXrMrr-) r~rH fancy_indexes out_indexdropped_axis_cntin_axisrDrGrVs @@r%slice_with_int_dask_arrayr]s&&%%%%% u::    M  =A!"GHHHI!%(("" -- c5 ! ! "cin&<&<x1}}"*o5ahGGeWWWWqvWWWWWX A%  Q5ahGG  t----)=   S ! ! ! ! eI r'crddlm}ddlm}m}m}ddlm}d|cxkr |jksnJtj |j | rtdtjtj||j ||jd}d|d<||d}||j|j|j |f|j|j }t)t+|j} |jf} |f} | d |dz| z| |dzd z} | d || z| |dzd z} ||j| || || || |j|||j|j }||j| || || d |j |||j|j }|S)zSlice a ND dask array with a 1D dask arrays of ints along the given axis. This is a helper function of :func:`slice_with_int_dask_array`. r)r)rG blockwiserHrzOSlicing an array with unknown chunks with a dask.array of ints is not supportedr*r)r)metaN)x_sizerrr`T)rx_chunksrrr`) dask.arrayrrrGr_rHr,rrr2rrrPrrollr_metadasknamerrXrMr]r#slice_with_int_dask_array_aggregate)r~rDrrrGr_rHrrx_axesidx_axes offset_axesp_axesy_axespys r%rXrXs7 !     <<<<<<<<<<------     qv       x##%% ! 4   WRY||AHTNIIIJJA N NFF1I Zq ) ) )FU V[18D>"3V\F 5== ! !FyH'K JdQhJ ( *VD1HJJ-? ?F ETE]X %taxzz(: :F   '  wt} g W   A   1  $ g W   A Hr'c ddlmm}m}fd|D}t |dkrn|dj|jkrWt j|j s_t j|dj s.| }td|D}n!|jdkrtj dd|t|g|Rd |ji}d t!||zfd t#t%j|D}t jf|jzf}t/j||g }|||j|fStfd |Drt3dfd|D} g} d} | D]} t5| rB| jt6kr2| tt9| | | jzf} | |jz } nt;ddf} | dz } | | t?tA| } |tBtt9|j|tt9|jg| Rd |ji}g}tE||j#D]k\} }t5| rA| jt6kr1|t jft |zV||lt||_$|t|fS)aSlice x with one or more dask arrays of bools This is a helper function of `Array.__getitem__`. Parameters ---------- x: Array index: tuple with as many elements as x.ndim, among which there are one or more Array's with dtype=bool Returns ------- tuple of (sliced x, new index) where the new index is the same as the input, but with slice(None) replaced to the original slicer when a filter has been applied. Note: The sliced x will have nan chunks on the sliced axes. r)rGr_elemwisecrg|]3}t|r|jtkrtdn|4SrFrrr1r-rGr#rGs r%rPz.slice_with_bool_dask_array..tsN "#u--L#)t2C2Cd r'rc3>K|]}|VdSrF)r=rWs r%rIz-slice_with_bool_dask_array..|s*33!''))333333r'zWhen slicing a Dask array of unknown chunks with a boolean mask Dask array, the output array may have a different ordering compared to the equivalent NumPy operation. This will raise an error in a future release of Dask.rrzgetitem-c i|] \}}|f| SrKrK)rGrrorgs r%rUz.slice_with_bool_dask_array..s#SSS1ay!SSSr' dependenciesc3nK|]/}t|o|jtko |jdkV0dSr)rrr1rrts r%rIz-slice_with_bool_dask_array..sU  KN 3F39#4FQ      r'zSlicing with dask.array of bools only permitted when the indexer has only one dimension or when it has the same dimension as the sliced arraycrg|]3}t|r|jtkr|ntd4SrFrsrts r%rPz.slice_with_bool_dask_array..sN #u%%L#)t*;*;tr'N)%rrGr_rqr4rr2rrrPr=rXrrrrrrvr flatten __dask_keys__nan npartitionsrfrom_collectionsrrr1rMr-rrwrgetitem_variadicrr_chunks)r~rHr_rqrZror`rgraphindexesargindsrr#newrrrGrgs @@r%slice_with_bool_dask_arrayr^s(;:::::::::I  5zzQ58=AF22x  $$&& rxa/G/G/K/K/M/M  A33U33333EE VaZZ M5      HWa 7% 7 7 7qw 7 7HQ...SSSS $,q?P?P2Q2Q(R(RSSS6)am+-/cLLLuUD&!'22I==     RW    "    G G A c5 ! ! ci4&7&7eAq38|44556C KAA;;%C FAs6'??##G ) eAFmm  eAFmm        g   CF%,,!! U c5 ! ! !ci4&7&7 MM26)c%jj0 1 1 1 1 MM% --CK i   r'c||SrFrK)r~rHs r%rrs U8Or'c ddlm}||}t|ddkr d|D}tjtj|dd}d|d<tj|}tj|}t||D]g\}}||} tj| } |tj | tj | z} | ||<| ||<h||fS)aGenerate blockwise-sorted index pairs for shuffling an array. Parameters ---------- index : ndarray An array of index positions. chunks : tuple Chunks from the original dask array Returns ------- index2 : ndarray Same values as `index`, but each block has been sorted index3 : ndarray The location of the values of `index` in `index2` Examples -------- >>> index = np.array([6, 0, 4, 2, 7, 1, 5, 3]) >>> chunks = ((4, 4),) >>> a, b = make_block_sorted_slices(index, chunks) Notice that the first set of 4 items are sorted, and the second set of 4 items are sorted. >>> a array([0, 2, 4, 6, 1, 3, 5, 7]) >>> b array([3, 0, 2, 1, 7, 4, 6, 5]) r)slices_from_chunksrcg|] }|d SrtrK)rGslice_s r%rPz,make_block_sorted_slices..s111&)111r') rrr4r2rdr empty_likersortargsortr) rHrrroffsetsr{index3rrabcs r%make_block_sorted_slicesrs >322222   ' 'F 6!9~~11&111gbiq **A..GGAJ ]5 ! !F ]5 ! !Ffg.. &M GAJJ RZrz!}} 5 566 6vv 6>r'c4ddlm}|jx}}|jdkr |df}t ||\}}t j5t jd|||||cdddS#1swxYwYdS)a!A relatively efficient way to shuffle `x` according to `index`. Parameters ---------- x : Array index : ndarray This should be an ndarray the same length as `x` containing each index position in ``range(0, len(x))``. Returns ------- Array rrrignoreN) rrrrrrcatch_warnings simplefilterrechunk)r~rHrchunks1r#r{rs r% shuffle_slicers322222 Ggvzz1:--eW==NFF  " "22h(:;;;y  ))&1222222222222222222s 6B  BBc t|ts|f}|D]S}|dus|durtd|t|st |r|jstd|Tg}g}g}t t||}d}tt||D]\}\}} t|t} | r.| | \} } } | dkr| dkrd} t| | | }| dkro| | \} } } | dz} t| | z dz | \}}|| z}| |z} | |zdz} t| | | }| || | \} } } t| | z | \}}|s|s| dn|dkr|dz }| || |nYt|ttjfrt|}n't|tjst |r|dz }|dkrtd ||jdkrt%d |jd | |j}|jt,kr2t/j|s|| krt%d |d | d|t |r:|jt,kr tj}ntj|dk|| z|}| || ||||<||||fS)aReformat the indices for assignment. The aim of this is to convert the indices to a standardised form so that it is easier to ascertain which chunks are touched by the indices. This function is intended to be called by `setitem_array`. A slice object that is decreasing (i.e. with a negative step), is recast as an increasing slice (i.e. with a postive step. For example ``slice(7,3,-1)`` would be cast as ``slice(4,8,1)``. This is to facilitate finding which blocks are touched by the index. The dimensions for which this has occured are returned by the function. Parameters ---------- indices : numpy-style indices Indices to array defining the elements to be assigned. shape : sequence of `int` The shape of the array. Returns ------- parsed_indices : `list` The reformated indices that are equivalent to the input indices. implied_shape : `list` The shape implied by the parsed indices. For instance, indices of ``(slice(0,2), 5, [4,1,-1])`` will have implied shape ``[2,3]``. reverse : `list` The positions of the dimensions whose indices in the parsed_indices output are reversed slices. implied_shape_positions: `list` The positions of the dimensions whose indices contribute to the implied_shape. For instance, indices of ``(slice(0,2), 5, [4,1,-1])`` will have implied_shape ``[2,3]`` and implied_shape_positions ``[0,2]``. Examples -------- >>> parse_assignment_indices((slice(1, -1),), (8,)) ([slice(1, 7, 1)], [6], [], [0]) >>> parse_assignment_indices(([1, 2, 6, 5],), (8,)) ([array([1, 2, 6, 5])], [4], [], [0]) >>> parse_assignment_indices((3, slice(-1, 2, -1)), (7, 8)) ([3, slice(3, 8, 1)], [5], [1], [1]) >>> parse_assignment_indices((slice(-1, 2, -1), 3, [1, 2]), (7, 8, 9)) ([slice(3, 7, 1), 3, array([1, 2])], [4, 2], [0], [0, 2]) >>> parse_assignment_indices((slice(0, 5), slice(3, None, 2)), (5, 4)) ([slice(0, 5, 1), slice(3, 4, 2)], [5, 1], [], [0, 1]) >>> parse_assignment_indices((slice(0, 5), slice(3, 3, 2)), (5, 4)) ([slice(0, 5, 1), slice(3, 3, 2)], [5, 0], [], [0]) TFzBdask does not yet implement assignment to a scalar boolean index: zNdask does not yet implement assignment to a scalar numpy or dask array index: rrNrzvdask is currently limited to at most one dimension's assignment index being a 1-d array of integers or booleans. Got: zIncorrect shape (z-) of integer indices for dimension with size z:boolean index did not match indexed array along dimension z; dimension is z( but corresponding boolean dimension is )rrXrrrrrwrNrvrr-rCdivmodrrr2r7r&rrr rr1rrr~r)rCrrH implied_shapeimplied_shape_positionsreverseparsed_indicesn_listsrr is_slicer.r/r0divmoddiv_step index_sizes r%parse_assignment_indicesr sJ| gu % %*   D==EUNN%,"',,     #5e#<#< ej %8.388  M G/'599::NG%c.%&@&@AA`"`"=E4eU++ \ . % d 3 3 E4axxDBJJ%t,,Eaxx %*MM$$7$7!tT !%$,"2D99S:!x'!+eT400q!!! % d 3 3 E4dUlD11HC 2s 2$$Q''''!881HC$$S)))'..q1111 RZ0 1 1* .JJEE rz * *& ..@.G.G& . qLG{{)&$&&zQ > >>7;>> J t## :..$$&& G!"GG37GG:DGG"%(( E;$&&!#JJHUQY eDDE   , , , # * *1 - - -!q ='3J JJr'cddlm}m}|jdkr|Sdt |z}|df||fi}t j|||g}|j}|sd}||||f|j S)zConcatenate the multidimensional chunks of an array. Can be used on chunks with unknown sizes. Parameters ---------- x : dask array Returns ------- dask array The concatenated dask array with one chunk. r)rG concatenate3rz concatenate3-rxru)rr) rrGrrrr}rrrr)r~rGrrgrrrs r%concatenate_array_chunksrs43333333} Xa[[ (D \1??#4#456A  +D!1# F F FE WF  5fYag > > >>r'c  6789tj678fd}tj8fd}tj8fd}tj8fd}ddlm7|j}|j} t | } t ||\}} } } d| vr7| r5t| dkr"td| d t| t | | z 99dkr| 9d }| }d}9fd | D} nD9 }| }| |d }d9| d |d |zkr"td | dt| g}g}tt||| D]P\}\}}}||8t8ru8j tkretj|s |8jkr+|d ||ntd|d8j|dkr#|t'd ||kr+|d ||tj|r,|d ||0td| d t| |j}d|D}dt||D}t+|}t-7|}i6|f}t||D]R\}}g}g}g}9} d}!d }"tt||D]\}#\8\}$}%t18t2}&t18t&r|%|$z }'8j|%kr |'|%8jz z}'8j|$z }(|(dkr |(8jz}(|(|'krd}!n58j})t'|(|'|)}*t;|'|(z |)\}+},|,r|+dz }+8|$}-t;|-d|-dz |)\}.},|,r|.dz }.n~|&r| dz } |$8cxkr|%ksnd}!n8|$z }*n^8j tk}/||#|$|%|/}*|/r||#|$|%}+||#|$}.n d }+d }.|#}"|$|%f}0t8s |*jsd}!nC||*|&s*||+||.||dd z}1|!s|6|1<|d d }2|D]P}|9z}||"kr||8||"| ||zg|0R|2|<,||}(t'|(|(||z|2|<Q| D]T}||}3|2||3\}(}'})|3dz}3|3|(z }(|3|'z }'|'dkrd }'t'|(|'d|2|<U| t |kr|2dt@|t|2}4tC|4}4tE7|4}5tGtI|4j%66tL||5|f6|1<T|'|'|'|'6S)aMaster function for array assignment. This function, that is intended to be called by `Array.__setitem__`, creates a new dask that assigns values to each block that is touched by the indices, leaving other blocks unchanged. Each block that overlaps the indices is assigned from the approriate part of the assignment value. The dasks of these value parts are included in the output dask dictionary, as are the dasks of any 1-d dask array indices. This ensures that the dask array assignment value and any dask array indices are not computed until the `Array.__setitem__` operation is computed. The part of the assignment value applies to block is created as a "getitem" slice of the full asignment value. Parameters ---------- out_name : `str` The dask variable output name. array : dask array The dask array that is being assigned to. indices : numpy-style indices Indices to array defining the elements to be assigned. value : dask array The assignment value, i.e. the values which will be assigned to elements of array. Returns ------- dsk : `dict` A dictionary where the keys are new unique tokens for each block of the form (out_name, dim_index[, dim_index[, ...]]) and the values are either (key,) or (setitem, key, v_key, block_indices) where key is an existing top-level dask key of array. The first case occurs when the block represented by key does not overlap the indices. The second case occurs when the block represented by key does overlap the indices. setitem is the chunk assignment function; v_key is the dask key of the the part of the assignment value that corresponds to the block; and block_indices are the assigment indices that apply to the block. The dictionary also includes any additional key/value pairs needed to define v_key, as well as any any additional key/value pairs needed to define dask keys contained in the block_indices list as references to dask array indices. c|r ||}nftr'tj|k|kz|}||z}n0tj|k|kzd}||z }t|r`t|}t |jt|}|S)aThe positions of index elements in the range values loc0 and loc1. The index is the input assignment index that is defined in the namespace of the caller. It is assumed that negative elements of an integer array have already been posified. The non-hashable dsk is the output dask dictionary that is defined in the namespace of the caller. Parameters ---------- dim : `int` The dimension position of the index that is used as a proxy for the non-hashable index to define the LRU cache key. loc0 : `int` The start index of the block along the dimension. loc1 : `int` The stop index of the block along the dimension. is_bool : `bool` Whether or not the index is of boolean data type. Returns ------- numpy array or `str` If index is a numpy array then a numpy array is returned. If index is a dask array then the dask of the block index is inserted into the output dask dictionary, and its unique top-layer key is returned. r) rr2rrupdaterrfnextr})rloc0loc1is_boolrr`r|rHs r%block_index_from_1d_indexz0setitem_array..block_index_from_1d_index+sD  d4i AA  & & $%-EDL95$GGA IAA $%-EDL9::1=Aa4A a  1(++A JJtAF|| $ $ $WWQ__..//00Ar'c<tj||S)aNumber of True index elements between positions loc0 and loc1. The index is the input assignment index that is defined in the namespace of the caller. Parameters ---------- dim : `int` The dimension position of the index that is used as a proxy for the non-hashable index to define the LRU cache key. loc0 : `int` The start index of the block along the dimension. loc1 : `int` The stop index of the block along the dimension. Returns ------- numpy array or dask array If index is a numpy array then a numpy array is returned. If index is dask array then a dask array is returned. r2r[)rrrrHs r%$block_index_shape_from_1d_bool_indexz;setitem_array..block_index_shape_from_1d_bool_indexls4veDI&'''r'c<tjd|S)aNumber of True index elements preceeding position loc0. The index is the input assignment index that is defined in the namespace of the caller. Parameters ---------- dim : `int` The dimension position of the index that is used as a proxy for the non-hashable index to define the LRU cache key. loc0 : `int` The start index of the block along the dimension. Returns ------- numpy array or dask array If index is a numpy array then a numpy array is returned. If index is dask array then a dask array is returned. Nr)rrrHs r%n_preceeding_from_1d_bool_indexz6setitem_array..n_preceeding_from_1d_bool_indexs0veETEl###r'ctrtjjr:tj|k|kzdd}t |}|ff|_nZtj|k|kzd}t |}n%tj|k|kzd}|S)aValue indices for index elements between loc0 and loc1. The index is the input assignment index that is defined in the namespace of the caller. It is assumed that negative elements have already been posified. Parameters ---------- dim : `int` The dimension position of the index that is used as a proxy for the non-hashable index to define the LRU cache key. vsize : `int` The full size of the dimension of the assignment value. loc0 : `int` The start index of the block along the dimension. loc1 : `int` The stop index of the block along the dimension. Returns ------- numpy array or dask array If index is a numpy array then a numpy array is returned. If index is dask array then a dask array is returned. TFr)rr2rr rrr)rvsizerrrrHs r%value_indices_from_1d_int_indexz6setitem_array..value_indices_from_1d_int_indexs< e $ $ >x ## 0Hdem =tUKK,Q//#XK Hdem =>>qA,Q//$%-EDL9::1=Ar'r)r|rz%shape mismatch: value array of shape z4 could not be broadcast to indexing result of shape Nc&g|] }|k|z SrKrK)rGrrs r%rPz!setitem_array.."s">>>!!v++1v:+++r'ruz*could not broadcast input array from shapez into shape z.shape mismatch: value array dimension size of z5 is greater then corresponding boolean index size of c0g|]}t|dS)Trr)rGbdss r%rPz!setitem_array..Ws%GGG}St444GGGr'cHg|]\}}dt||D S)c"g|] \}}|||zf SrKrK)rGrRrs r%rPz,setitem_array...Ys$888&!S!QW888r')r)rGstartsshapess r%rPz!setitem_array..XsD FF 98C$7$7888r'TFr)( functools lru_cache dask.corer|rr4rrrrXrvrrrr1rrr rr-rrrwr}rrr/r.r0rrCinsertr<rrr rrfsetitem cache_clear):rTr rCvaluerrrr array_shape value_shape value_ndimrrrarray_common_shapevalue_common_shape value_offsetbase_value_indicesnon_broadcast_dimensionsrrrrrcumdimsarray_locationsin_keysin_keyr block_indicesblock_indices_shapeblock_preceeding_sizes local_offsetoverlapsdim_1d_int_indexrrr integer_indexr/r.r0 block_indexblock_index_sizerempre n_preceedingr loc0_loc1out_key value_indicesr rpv_keyr`r|rHrs: @@@@r% setitem_arrayrsF @>>>>>>>@(((((6$$$$$233333j"!!!!!+K+K[!!J@X@@.>.B.B /K / /m,, / /   l  * ,F {{+6773( >>>>w>>>w *(7 } } % )< < <CCC,1-,@,@CC  !!  24KLL 9Aq!  e $ $ )<)<z!}} UZ"))$///(//2222 $Q$$z$$  66  % %eDkk 2 2 2 2 !VV  % %d + + + $ + +A . . . . Z]]   % %d + + + $ + +A . . . .* **''** \FGGGGGG!'622O/O775..001122G C{H /::n?n? &  !#  *3C4K4K*L*LJ <J < &C&%$&uc22M%''8 d{:$$D5:--D d*199UZ'ED==$HEz#E466 (.te|T(B(B% #*$)$mmD))$*3q6CF?D$A$A! c& A%L ! u++++t++++$HE#dl  +-77T4QQ  +'K'KT4(($$C#B3#M#MLL'+$#'L'*$ $d I)%009I %HE   - - -  <#**+;<<<&--l;;;VABBZ' "CL +111- ) P PAF A$$$   #B#B$k!l2B&C$FO$$$ a  /q1#(8KA8N0N#O#O a   6 6A%a(D -a 0 8 8 > > E4 AID5LE$;Daxx$UD"55M!   G $ $  H - - - % && ' $Q ' 'WWQ__..//00 DLL#&&  >G ))+++(44666#//111#//111 Jr'cl|js|Stt||jD][\}\}}t |t jr9|jtkr)|t j ||kd}|||<\t j |sCt j |r$| t j j }|} ||t|<n"#t $r}t!d|d}~wwxYw|S)aChunk function of `setitem_array`. Assign v to indices of x. Parameters ---------- x : numpy array The array to be assigned to. v : numpy array The values which will be assigned. indices : list of `slice`, `int`, or numpy array The indices describing the elements of x to be assigned from v. One index per axis. Note that an individual index can not be a `list`, use a 1-d numpy array instead. If a 1-d numpy array index contains the non-valid value of the size of the corresponding dimension of x, then those index elements will be removed prior to the assignment (see `block_index_from_1d_index` function). Returns ------- numpy array A new independent array with assigned elements, unless v is empty (i.e. has zero size) in which case then the input array is returned and the indices are ignored. Examples -------- >>> x = np.arange(8).reshape(2, 4) >>> setitem(x, np.array(-99), [np.array([False, True])]) array([[ 0, 1, 2, 3], [-99, -99, -99, -99]]) >>> x array([[0, 1, 2, 3], [4, 5, 6, 7]]) >>> setitem(x, np.array([-88, -99]), [slice(None), np.array([1, 3])]) array([[ 0, -88, 2, -99], [ 4, -88, 6, -99]]) >>> setitem(x, -x, [slice(None)]) array([[ 0, -1, -2, -3], [-4, -5, -6, -7]]) >>> x array([[0, 1, 2, 3], [4, 5, 6, 7]]) >>> setitem(x, np.array([-88, -99]), [slice(None), np.array([4, 4, 3, 4, 1, 4])]) array([[ 0, -99, 2, -88], [ 4, -99, 6, -88]]) >>> value = np.where(x < 0)[0] >>> value.size 0 >>> y = setitem(x, value, [Ellipsis]) >>> y is x True rzEshape mismatch: value array could not be broadcast to indexing resultN)r rvrrrr2r&rr1rmaisMAview MaskedArraycopyrXr)r~rprCrrH block_sizees r%rrs/t 6#,C,A,A"B"B E: eRZ ( ( U[D-@-@"(5:#566q9:EGAJ 5::a==&RUZZ]]& FF25$ % % A%..  V    Hs?D D1D,,D1rt)A __future__rrrrr itertoolsrnumbersrroperatorrnumpyr2tlzrr r r rfr r rdask.array.chunkr dask.baserrdask.highlevelgraphr dask.utilsrrr-rr&rCrer\rxrrrrrrr%r2ryrrArErNrKr]rXrrrrrrrrrKr'r%rs8""""""  $$$$$$$$------------$$$$$$$$$$$$$$$$22222222......22222222 dD$>>>$7>7>7>tPPPf&&&R>>>B6"6"6"rd d d NTTT$ ' ' ')))Xvvvvr8  6###WWW6*!!!HBBBJC C C L222jB B B JY!Y!Y!x333l2222}K}K}K@???