o 0 i @sdZddlZddlZddlZddlZddlmZddlmZddl Z ddl m Z m Z ddlmZmZmZmZmZmZddlmZmZmZmZmZmZmZmZmZmZddlm Z m!Z!m"Z"dd l#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.dd l/m0Z0dd l1m2Z2dd l3m4Z4m5Z5m6Z6m7Z7m8Z8dd l9m:Z:m;Z;ddlm?Z?m@Z@ddl3mAZAddlBmCZDmEZFmGZGmHZHmIZIddZJddZKddZLddZMddZNddZOddZPd d!ZQd"d#ZR dTd$d%ZSd&d'ZTd(d)ZUe5eUd*d+ZVe$d,ejWd-d.ZXd/d0ZYe$d1ejZe*e.j[d2d3Z\ dTd4d5Z]d6d7Z^d8d9Z_e$ej`ejWejae$ej`ejWejbd:d;Zce$ej`ejWejddd?Zhe$eiejWd@dAZje$dBejkdCdDZle"dEkrxe$dFejkejgdGdHZmGdIdJdJenZoGdKdLdLeoZpGdMdNdNeoZqGdOdPdPeoZrGdQdRdReoZsGdSdTdTeoZtGdUdVdVenZudWdXZve$ej`ejWejkdYdZZwd[d\Zxd]d^Zyd_d`ZzdadbZ{dcddZ|dedfZ}dgdhZ~didjZe7dkdlZe7dmdnZe4dodpZdqdrZe5e jdsdtZe4dudvZe5e jdwdxZe5e jdydzZd{d|Ze5ed}d~ddZe5edd~ddZddZddZe$dejkddZddZe$dejkejdddZe$dejkeejgddZe5e jdTddZe%ejkdddZe5e jdUddZe5e jdUddZe5e jdVddZddZddZe$dejkejdddZe$dejkeejgddZe"dkre5e jddZn e5e jddZe5e jddZe5e jdTddZe$dejkddZe$e jejkddZe$dejkddZe4ddZe4ddZe5e jdTddZe6ejkddWddZddZe5e jddÄZe5e jddńZe5e jddDŽZe5e jddɄZe4dd˄Ze6ejkd̡dd΄Ze7ddЄZdd҄Ze5ed}d~ddԄZe$dejkejddׄZe%ejkd؃ddڄZe%ejkdۃe%ejdۃdd݄Ze%ejkdރe%ejdރddZe%ejkde%ejdddZe%ejkdddZe%ejkde%ejdddZe%ejkde%ejdddZe%ejdddZe%ejdddZe%ejdddZe%ejdddZe%ejkdddZe%ejdddZe(ejejЃe(ejejуddZҐddZe%ejkdddZe%ejde%ejdddZe%ejddd Ze%ejkd d d Ze%ejkd ddZِddZe6ejkde6ejkdddZېddZe%ejݐde܃e%ejݐde܃e$dejejgddZe&ejkddZe$dejkej2dd Ze&ejd!d"Ze'ejd#d$Ze$dejej2d%d&Ze$dejejd'd(Ze$d)ejej2ejgd*d+Ze$d)ejejejgd,d-Ze)ejkd.d/Ze)ejd0d1Ze)ejd2d3Ze$ejejkejkd4d5Ze8ejkd6d7d8Zd9d:Zd;d<Z  dWd=d>Z dTd?d@ZdAdBZdCdDZdEdFZe%ejkdGdHdIZe$d1eje*e.j[dJdKZe$ej`ejejadLdMZe$ejfejejaejgdNdOZe$eiejdPdQZe$e jejkdRdSZe$d1eje*e.j[dTdUZe$e eejae$e jeejadVdWZe$e ejde$e jejddXdYZe$d1eje*e.j[dZd[Ze$e jejgd\d]Ze$d1ej e*e.j[d^d_Z e$ej ejej݃d`daZ dbdcZ eAejkdddedfZdgdhZe7didjZdkdlZdmdnZdodpZdqdrZe7dsdtZe5e jefdudvZe7dwdxZe5e jdTdydzZe7d{d|Ze6ejkd}d~dZe5e jefddZe5e j dTddZ!e5e j"dTddZ#e5e j$dTddZ%e5e j&dTddZ'e5e j(dTddZ)e5e j*dTddZ+ddZ,e5e,ddZ-e5e j.ddefddZ/e5e j0dXddZ1e5e j2ddZ3e5e j4dXddZ5ddZ6e5e j7e6ejkddTddZ8ddZ9e5e j:dWddZ;e5e j<dUddZ=ddZ>e7ddZ?e$dejkddZ@e5e jAddZBddZCe7ddZDe5e jEddZFe5e jGddZHe$dejkeje$dejkej2ddZIe7ddZJe5e jKefddZLe5edTddZMe5edTddZNdd„ZOdÐdĄZPdŐdƄZQdǐdȄZRdɐdʄZSdːd̄ZTd͐d΄ZUdϐdЄZVe7dѐd҄ZWe5e jXdTdӐdԄZYdՐdքZZdאd؄Z[dِdڄZ\dېd܄Z]e7dݐdބZ^e5e j]dߐdZ_ddZ`ddZae5e jbddZce5e jdddZee5e jfddZgddZhddZiddZjddZke7ddZle5e jmdXddZnddZoe7ddZpe5e jqddZrddZse7ddZte5e judXddZvddZwe7ddZxe5e jyddZze7d d Z{e5e j|d d Z}e"dEk re5e j~e}e7d dZe5e jddZe6ejkdddZe6ejkdddZe5e jddZe5e jddZe7ddZe5e jddZe5e jdXdd Ze5e jdXd!d"Ze5e jd#d$Ze5e jd%d&Ze5e jd'd(ZiZd)d*ZdYd,d-Zd.d/Ze$d0ejkd1d2Ze5e jd3d4Ze$d5ejkej2e$e jejkej2d6d7Ze(ejkejkd8d9Ze(ejkeje(ejkeje(ejkejae(ejkeje(ejkeje(ejkeje(ejkejd:d;Ze(ejkejd<d=Zd>d?Zeed@dAZe$eejkejdejddBdCZe5e jjjdZdDdEZe5e jjjdTdFdGZe5edHdIZe5e jdJdKZe4dLdMZe5e jdNdOZe5e jd[dRdSZdS(\z[ Implementation of operations on Array objects and objects supporting the buffer protocol. N)ir)Constant)pndindexliteral_unroll)typestypingerrorscgutils extendingconfig) as_dtype from_dtypecarrayfarray is_contiguous is_fortrancheck_is_integertype_is_scalar lt_complex lt_floats)type_can_asarray is_nonelike numpy_version) lower_builtin lower_getattrlower_getattr_genericlower_setattr_generic lower_castlower_constant iternext_implimpl_ret_borrowedimpl_ret_new_refimpl_ret_untrackedRefType) signature) StringLiteral)register_jitableoverloadoverload_method intrinsicoverload_attribute) quicksort mergesort)slicing) tuple_setitembuild_full_slice_tuple)overload_classmethod) parse_dtype parse_shape_parse_nested_sequence_sequence_of_arrays_choose_concatenation_layoutcCs4t|j|t|j|g}|j|}|d|dS)zz Set the "range" metadata on a load instruction. Note the interval is in the form [lower_bound, upper_bound). rangeN)rtypemoduleZ add_metadataZ set_metadata)builderload lower_bound upper_boundZrange_operandsmdr>]/home/app/PaddleOCR-VL-test/.venv_paddleocr/lib/python3.10/site-packages/numba/np/arrayobj.pyset_range_metadata-s   r@cCs&d|jjd>d}t||d|dS)zF Mark the result of a load instruction as positive (or zero). rN)r7widthr@)r9r:r<r>r>r? mark_positive8srCcs6jtjGfdddS)z Return the Structure representation of the given *array_type* (an instance of types.ArrayCompatible). Note this does not call __array_wrap__ in case a new array structure is being created (rather than populated). cs4eZdZfddZefddZZS)zmake_array..ArrayStructcst}z |jd|}Wntyt||YSw|jj}||}|dur9tj |j |dd}n|}||j |f}||fS)NZ __array__T)zfill) r$_context get_functionNotImplementedErrorsuper _make_refsdata_model_managerZ _get_be_typer alloca_once_builder)selfrefsigZ array_impl datamodelZbe_typeZ outer_ref) ArrayStruct __class__ array_typereal_array_typer>r?rINs     z*make_array..ArrayStruct._make_refscsp|j}dkr |dS|d}g}tD]}t||d|}||}||t||qt ||S)z\ Override .shape to inform LLVM that its elements are all positive. rshape) rL __getattr___get_ptr_by_namer6r gep_inboundsr:appendrC pack_array)rMr9ptrdimsiZdimptrr:)basendimr>r?rUbs       z%make_array..ArrayStruct.shape)__name__ __module__ __qualname__rIpropertyrU __classcell__r>rQrSr^r_rT)rRr?rQLsrQ)Zas_arrayr create_struct_proxyr_)rSr>rer? make_array@s  -rgcCs||j}||S)zB Return the item size for the given array or buffer type. ) get_data_typedtypeget_abi_sizeof)contextrSlltyr>r>r? get_itemsize|s  rmcCs"|jrdnd}|j||j||dS)z3 Load the item at the given array pointer. NrAalign)aligned unpack_valueri)rkr9arraytyr[ror>r>r? load_items rscCs$|jrdnd}|j||j|||dS)z4 Store the item at the given array pointer. NrArn)rp pack_valueri)rkr9rrvalr[ror>r>r? store_itemsrvcCs@|jr||||tj}t|||}|S||||tj}|S)zM Fix the integer index' type and value for the given dimension size. )signedcastrintpr-Z fix_indexuintp)rkr9idxtyidxsizeindr>r>r?fix_integer_indexs rcCsZt|tjr)|jdkr)t|jtjsJt||||}t||||j}|j|fS||fS)zS Normalize the index type and value. 0-d arrays are converted to scalars. r) isinstancerArrayr_riIntegerrgrsdata)rkr9r{r|idxaryZidxvalr>r>r?normalize_indexs  rcs2t|rtfddt||D\}}||fS)z^ Same as normalize_index(), but operating on sequences of index types and values. csg|] \}}t||qSr>)r).0r{r|r9rkr>r? s z%normalize_indices..)lenzip)rkr9 index_typesindicesr>rr?normalize_indicess  rcCs|j}|j}|j} ttjdd} |j| } t| j} t| j} | | @| krC| | }d|j dt |dkr7dndd|d}t ||d urRt | | d d }| tj}t|ttfrft|||}t|ttfrtt|||}t|tr}||}t|||||d }|d urt | | d d |d <n||d <|tjd}t|||jj}|D] }|j||d gd}q||d<t|}|| krt d| ||D] \}}t|||q|S)z Helper function for populating array structures. This avoids forgetting to set fields. *shape* and *strides* can be Python tuples or LLVM arrays. rACzThe datamodel for type z is missing fields .Nmeminfo)rUstridesritemsizerparentnswflagsnitemsz missing {0}) rErL _datamodelrrfloat64rJset_fieldsZ_fe_typer ValueErrorrget_value_typeget_typeryrtuplelistr rZintdict get_constant unpack_tupler7countmulkeysformatitemssetattr)arrayrrUrrrrrkr9rPZstandard_arrayZstandard_array_type_datamodelZrequired_fieldsZdatamodel_fieldsmissingmsgintp_tattrsrunpacked_shapeaxlenZ got_fieldskvr>r>r?populate_arraysh         rcCsh|j}|j}|tjd}t||j|j}|D] }|j ||dgd}q||_ |tjt |||_ dS)z Update some auxiliary information in *array* after some of its fields were changed. `itemsize` and `nitems` are updated. rArrN) rErLrrryr rrUr_rrrmr)arytyrrkr9rrrr>r>r?update_array_infos rcCst)z/Constrain axis values to valid positive values.rG func_namearg_namer_axisr>r>r?normalize_axisrcsLt|ts tdt|tstd|jd|jdfdd}|S)Nz func_name must be a str literal.zarg_name must be a str literal.z : Argument z* out of bounds for dimensions of the arraycs,|dkr||7}|dks||krt|SNrrrrr>r?impl$s z&normalize_axis_overloads..impl)rr%r TypingError literal_value)rrr_rrr>rr?normalize_axis_overloadss     rZgetiterc Cst|j\}|\}|||j}|tjd}t||}||_||_ |j r,|j |||| } t|||j| } | Sr)args make_helper return_typerrryr alloca_once_valueindexr enable_nrtnrtincref _getvaluer!) rkr9rOrrrriterobjzeroZindexptrresoutr>r>r? getiter_array/s rc Cstj||j|jd}tj||j|jd}||d|}t||j|} |dd} |dd} t|t j rEt |||||| | | } | S| rIJt |||| S)z1 Evaluate `ary[idx]`, where idx is a single int. rrrAN)r rrUr_rr pointer_addrrrBuffer make_viewrrs) rkr9rraryr|shapesroffsetdataptr view_shapes view_stridesretaryr>r>r?_getitem_array_single_intGs    rZiternextcCs|j\}|\}|j}|j|||d}t||||jd} tj|| jdd\} ||j } | d| | } | | | | %t |||j|| | } || t|| }|||j WddS1sewYdS)NvaluerAr<)rrSrrgrr rrUr:r icmp_signed set_validif_thenr yield_typeyield_increment_indexstore)rkr9rOrresultZitertyiterrrrrrris_validrZnindexr>r>r?iternext_array\s"     "rc Cs>|tjd}|tjd}t||j|j} t||j|j} g} g} g} tdd|D}d}t ||D]\}}|tj uri|jt|d|}t |D]}| || | || | ||d7}qNq6t |tjr|j|||d}t||||t||| || |jt||}t||| |}| || |n=t |tjrt||||| |}|rt|||| ||| |nt|r| || ||d8}ntd|f|d7}q6||jksJ||jkr| | || | ||d7}||jkstj||||| ddd}|| | fS) z Perform basic indexing on the given array. A (data pointer, shapes, strides) tuple is returned describing the corresponding view. rrAcSg|]}t|r|qSr>rrr|r>r>r?rz"basic_indexing..runexpected index type: %sF wraparound boundscheck)rrryr rrUr_rrrellipsisr6rYr SliceTyperr-guard_invalid_slice fix_slicestartget_slice_lengthZ fix_striderrZdo_boundscheckrrGget_item_pointer)rkr9rrrrrronerrZoutput_indicesZ output_shapesZoutput_strides num_newaxesaxindexvalr{ n_missingr]sliceshstr~rr>r>r?basic_indexingxsf                   rc Cs.t|||}t|||||j|j|jd|S)zF Build a view over the given array with the given parameters. rrUrrrr)rgrrrr) rkr9rrrrrrrr>r>r?rsrc Cs^t|||||||jd\}}} t|tjr$t|||||||| } | S|r(Jt||||S)zp Return the result of indexing *ary* with the given *indices*, returning either a scalar or a view. r)renable_boundscheckrrrrrrs) rkr9rrrrrrrrrr>r>r?_getitem_array_generics  r c CsZ|j\}}|\}}|jdksJt||||}t|||j|||f|f}t|||j|S)z4 Basic indexing with an integer or a slice. rA)rr_rgr rr rkr9rOrrr{rr|rr>r>r?getitem_arraynd_intps   r c Cs|j\}}|\}}t||||}|j}tj||t|d} t|||| \}} tdd|Dr;t|||||||| St |||j |||| } t |||j | S)z2 Basic or advanced indexing with a tuple. rcs|] }t|tjVqdSNrrr)rtyr>r>r? z&getitem_array_tuple..) rrgrr rrrany fancy_getitemr rr ) rkr9rOrrtuptyrtuprrrr>r>r?getitem_array_tuples   rc Cs|j\}}}|\}}} t|tjr|j} tj||t|d} n|f} |f} t||||}t||| | \} } zt ||||| | |j d\} } }Wn t yRd}Ynwt | }|rbt ||||| | S||| ||j} t|||| | dS)zH array[a] = scalar_or_array array[a,..,b] = scalar_or_array rr TN)rrr BaseTupler rrrgrrr rGboolfancy_setslicerxrirv)rkr9rOrrr{valtyrr|rurrrrrZuse_fancy_indexingr>r>r? setitem_array s4     rc CsD|j\}|\}t|}||||}|j}||d}t|||j|Sr)rrgrU extract_valuer"r) rkr9rOrrrZarysttyZshapearyrr>r>r? array_len4s  rz array.itemcCs|j\}|\}t||||}|j}|j|d||dddd}|j|t|fWdn1s7wYt ||||j S)N!=rAFZlikelyz>item(): can only convert an array of size 1 to a Python scalar) rrgrrrr7 call_convreturn_user_excrrsr)rkr9rOrrrrrr>r>r? array_item?sr$rz array.itemsetc Cs|j\}}|\}}||jksJt||||}|j}|j|d||dddd} |j|t | fWdn1s@wYt |||||j | S)Nr rAFr!z/itemset(): can only write to an array of size 1) rrirgrrrr7r"r#rrvrget_dummy_value) rkr9rOrrrrrurrr>r>r? array_itemsetOs r(c@@eZdZdZddZddZddZdd Zd d Zd d Z dS)Indexerzq Generic indexer interface, for generating indices over a fancy indexed array on a single dimension. cCt)ze Prepare the indexer by initializing any required variables, basic blocks... rrMr>r>r?preparejzIndexer.preparecCr+)z= Return this dimension's size as an integer. rr,r>r>r?get_sizeqzIndexer.get_sizecCr+)z; Return this dimension's shape as a tuple. rr,r>r>r? get_shapewr0zIndexer.get_shapecCr+)z} Return a half-open [lower, upper) range of indices this dimension is guaranteed not to step out of. rr,r>r>r?get_index_bounds}r.zIndexer.get_index_boundscCr+)aW Start indexation loop. Return a (index, count) tuple. *index* is an integer LLVM value representing the index over this dimension. *count* is either an integer LLVM value representing the current iteration count, or None if this dimension should be omitted from the indexation result. rr,r>r>r? loop_heads zIndexer.loop_headcCr+)z) Finish indexation loop. rr,r>r>r? loop_tailr0zIndexer.loop_tailN) r`rarb__doc__r-r/r1r2r3r4r>r>r>r?r*ds r*c@HeZdZdZddZddZddZdd Zd d Zd d Z ddZ dS) EntireIndexerz: Compute indices along an entire array dimension. cCs2||_||_||_||_||_|jtj|_dSr) rkr9rrdimrrryll_intp)rMrkr9rrr8r>r>r?__init__s zEntireIndexer.__init__cCsB|j}||jj|j|_t||j|_ | |_ | |_ dSr) r9rrrUr8r}r rKr9rappend_basic_blockbb_startbb_endrMr9r>r>r?r-s  zEntireIndexer.preparecC|jSrr}r,r>r>r?r/zEntireIndexer.get_sizecC|jfSrr@r,r>r>r?r1zEntireIndexer.get_shapecC|d|jfSrr9r}r,r>r>r?r2zEntireIndexer.get_index_boundscCs|j}|jt|jd|j||j||j||j}|j | d||j dd||j Wd||fS1sBwY||fSNr>=Fr!) r9rrr9rbranchr<position_at_endr:rrr}r=)rMr9 cur_indexr>r>r?r3s    zEntireIndexer.loop_headcCD|j}t|||j}|||j||j||j dSr) r9r rr:rrrIr<rJr=rMr9 next_indexr>r>r?r4s  zEntireIndexer.loop_tailN r`rarbr5r:r-r/r1r2r3r4r>r>r>r?r7s r7c@r6)IntegerIndexerz0 Compute indices from a single integer. cCs&||_||_||_|jtj|_dSr)rkr9r|rrryr9)rMrkr9r|r>r>r?r:szIntegerIndexer.__init__cCdSrr>r,r>r>r?r-zIntegerIndexer.preparecCs t|jdSNrA)rr9r,r>r>r?r/ zIntegerIndexer.get_sizecCdSNr>r>r,r>r>r?r1rRzIntegerIndexer.get_shapecCs|j|j|j|fSr)r|r9addr/r,r>r>r?r2szIntegerIndexer.get_index_boundscCs |jdfSr)r|r,r>r>r?r3 zIntegerIndexer.loop_headcCrQrr>r,r>r>r?r4rRzIntegerIndexer.loop_tailNrOr>r>r>r?rPs rPc@r6)IntegerArrayIndexerz; Compute indices from an array of integer indices. cCs@||_||_||_||_||_|jdksJ|jtj|_ dSrS) rkr9r{rr}r_rrryr9)rMrkr9r{rr}r>r>r?r:szIntegerArrayIndexer.__init__cCsD|j}t||jjd|_t||j|_| |_ | |_ dSr) r9r rrrUidx_sizerKr9 idx_indexr;r<r=r>r>r>r?r-s  zIntegerArrayIndexer.preparecCr?rrZr,r>r>r?r/rAzIntegerArrayIndexer.get_sizecCrBrr\r,r>r>r?r1rCzIntegerArrayIndexer.get_shapecCrDrrEr,r>r>r?r2rFz$IntegerArrayIndexer.get_index_boundscCs|j}|jt|jd|j||j||j||j}|j | d||j dd||j Wdn1s?wYt |j||jj|j|j|}t|j||jj||j}||fSrG)r9rrr9r[rIr<rJr:rrrZr=rrkr{rirrr})rMr9rKrr>r>r?r3s&    zIntegerArrayIndexer.loop_headcCrLr) r9r rr:r[rrIr<rJr=rMr>r>r?r4s  zIntegerArrayIndexer.loop_tailNrOr>r>r>r?rYs  rYc@r6)BooleanArrayIndexerz> Compute indices from an array of boolean predicates. cCsH||_||_||_||_|jdksJ|jtj|_t |jd|_ dSNrAr) rkr9r{rr_rrryr9rr)rMrkr9r{rr>r>r?r:)szBooleanArrayIndexer.__init__cCs^|j}t||jjd|_t||j|_t||j|_ | |_ | |_ | |_ dSr)r9r rrrUr}rKr9r[rr;r<bb_tailr=r>r>r>r?r-2s  zBooleanArrayIndexer.preparecCs|j}t||j}t||j-}||}t|j||j j |j |j |j }| ||||j}|||Wdn1sAwY||Sr)r9r rr for_ranger}r:rrkr{rirrrWZzextr7r)rMr9rloopcpredr>r>r?r/;s    zBooleanArrayIndexer.get_sizecC |fSrr/r,r>r>r?r1JrXzBooleanArrayIndexer.get_shapecCrDrrEr,r>r>r?r2Msz$BooleanArrayIndexer.get_index_boundscCs|j}|j|j|j|j|j|j||j||j||j}||j}|j | d||j dd||j Wdn1sKwYt |j||jj|j|j|}| ||||jWdn1swwYt||}|||j||fS)NrHFr!)r9rrr[rrIr<rJr:rrr}r=rrkr{rirnot_r_r r)rMr9rK cur_countrc next_countr>r>r?r3Rs,     zBooleanArrayIndexer.loop_headcCs\|j}||j||jt|||j}|||j||j ||j dSr) r9rIr_rJr rr:r[rr<r=rMr>r>r?r4js    zBooleanArrayIndexer.loop_tailNrOr>r>r>r?r]$s   r]c@r6) SliceIndexerz( Compute indices along a slice. cCsL||_||_||_||_||_||_||_|jtj |_ t |j d|_ dSr) rkr9rrr8r{rrrryr9rr)rMrkr9rrr8r{rr>r>r?r:zszSliceIndexer.__init__cCs|j}||jj|j|_t|j||j |j t ||j |jt ||j j|_t ||j|_t ||j|_||_||_dSr)r9rrrUr8dim_sizer-rrkr{rrr Z is_neg_intstepis_step_negativerKr9rrr;r<r=r>r>r>r?r-s zSliceIndexer.preparecCst|j|jSr)r-rr9rr,r>r>r?r/zSliceIndexer.get_sizecCrdrrer,r>r>r?r1rXzSliceIndexer.get_shapecCst|j|j\}}||fSr)r-Zget_slice_boundsr9r)rMlowerupperr>r>r?r2szSliceIndexer.get_index_boundsc Cs|j}|j|jj|j|j|j|j||j| |j| |j}| |j}| |j | d||jj| d||jj}|j|dd||jWd||fS1s_wY||fS)Nz<=rHFr!)r9rrrrrrrIr<rJr:selectrlrstoprr=)rMr9rKrg is_finishedr>r>r?r3s*     zSliceIndexer.loop_headcCsp|j}|j||j|jjdgd}|||jt|||j }|||j | |j | |j dS)Nrr)r9rWr:rrrkrr rrrIr<rJr=)rMr9rNrhr>r>r?r4s zSliceIndexer.loop_tailNrOr>r>r>r?rius  ric@r)) FancyIndexerz4 Perform fancy indexing on the given array. c Cs|||_||_||_t||j|j|_t||j|j|_|j t j |_ g|_ g}tdd|D}d} d} t||D]\} } | t jurm|jt|d|} t| D]}t||||| }||| d7} | d7} qTqrrr>r>r?rrz)FancyIndexer.__init__..rrAr)$rkr9rr rrUr_rrrrryr9newaxesrrrr6r7rYrrrrirrrPrrgrirYBooleanr]rAssertionErrorindexers)rMrkr9rrrrrwrrZnew_axrr{rr]indexerrr~rr>r>r?r:sv                   " zFancyIndexer.__init__cCs^|jD]}|q|jtjd}dd|jD}|jD] }|||fqt|d|_ dS)NrAcSg|]}|qSr>)r1rr]r>r>r?rz(FancyIndexer.prepare..r>) rwr-rkrrryrtinsertsumindexers_shape)rMr]rZ res_shaper>r>r?r-s   zFancyIndexer.preparecCr?)z? Get the resulting data shape as Python tuple. )r~r,r>r>r?r1szFancyIndexer.get_shapec Cst||jjks J|j}tj}|d}|d}|}|}t|j|j |D]C\} } } | || d| |}| \} } | | | }| | || |}|d| |}||||||}||||||}q&|||}||||}||||}||fS)z Get a half-open [lower, upper) range of byte offsets spanned by the indexer with the given strides and itemsize. The indexer is guaranteed to not go past those bounds. rrA==r)rrr_r9r false_bitr9rrwr~or_ icmp_unsignedr2rsubrrWrp)rMrrr9is_emptyrrrnrorxrUstrideZ lower_indexZ upper_indexZ lower_offsetZ upper_offsetZ is_downwardsr>r>r?get_offset_boundssB       zFancyIndexer.get_offset_boundscCs tdd|jD\}}||fS)Ncss|]}|VqdSr)r3rzr>r>r?rAsz+FancyIndexer.begin_loops..)rrw)rMrcountsr>r>r? begin_loops@szFancyIndexer.begin_loopscCst|jD]}|qdSr)reversedrwr4)rMr]r>r>r? end_loopsDs zFancyIndexer.end_loopsN) r`rarbr5r:r-r1rrrr>r>r>r?rssB& rsc Cst||j}t||j} |j} t||||||} | |j} | } t ||| | }|j}t || t j d}| \}}tj||| || |j|d|jd }t||||}||}|||g}t||| ||t||}|||| t||| |S)NrFr)r rrUrrrsr-rr1_empty_nd_implrrrryrget_item_pointer2layoutr rsr:geprvrrrr!r)rkr9rOrrrrrrrrrxZout_tyZ out_shapesrZout_dataZout_idx_r[rucurZnext_idxr>r>r?rIs6      rc Cs|j\}}|\}}t||||}|jdkr4t||||\}}t|||j|||f|f}t|||j|St|||||||f|fS)z3 Advanced or basic indexing with an array. r)rrgr_rr rr rr r>r>r?fancy_getitem_arrayts      rc Cs|j}|d}|d}|jdvr|} |||j} | | fS|} |} t|jD]-} ||| ||| |} |d| |} | | | | | | } | | | | | | } q(| | |} |d|j|}| ||| } | ||| } | | fS)z Compute a half-open range [lower, upper) of byte offsets from the array's data pointer, that bound the in-memory extent of the array. This mimics offset_bounds_from_strides() from numpy/core/src/private/mem_overlap.c rrACFrHr) rr7rrrr6r_rrrprW)rkr9arrtyarrrrrrrrnror]Zmax_axis_offsetZ is_upwardsrr>r>r?offset_bounds_from_stridess2       rcCs.|||j}|||}|||}||fS)z Given [lower, upper) byte offsets and a base data pointer, compute the memory pointer bounds as pointer-sized integers. )ptrtointr7rW)rkr9rnrorZdata_ptr_as_intrendr>r>r?compute_memory_extentss  rc Cs&t||||||\}}t|||||S)zr Compute a half-open range [start, end) of pointer-sized integers which fully contain the array data. )rr) rkr9rrrrrrnror>r>r?get_array_memory_extentss rcCs$||d|||d||}|S)z[ Whether two memory extents [a_start, a_end) and [b_start, b_end) may overlap. r)and_r)rkr9Za_startZa_endZb_startZb_endZ may_overlapr>r>r?extents_may_overlaps   rc s@jdtdj ddc|j|j}j|} | j | } |  t j } t| (} t j| } t| | } | | Wdn1smwYWdn1s|wY f dd} fdd}||fS)NrFr!cst}j ddT\}}|tj|dd|Wdn1s1wY|tj j|dd|Wdn1sUwYWdn1sdwYt |S)NFr!r)r rKif_elserrr:rrs)source_indicessrc_ptrZif_copyZ otherwise) r9rk copy_data copy_layout copy_shapes copy_stridesptrtysrc_data src_shapes src_stridessrctyuse_copyr>r? src_getitems4  z&maybe_copy_source..src_getitemcsXjdd}|}j|WddS1s%wYdS)NFr!)rr:bitcastrfreer)r9rkrr voidptrtyr>r? src_cleanups   "z&maybe_copy_source..src_cleanup)r7r rrrrrrallocaterrrrry loop_nestrrr:)rkr9rrsrcrrr allocsizerrrrdest_ptrrrr>) r9rkrrrrrrrrrrrr?maybe_copy_sources8      "rc s|tjd}|tjdt|t|kr0t|t|}g||}|g||}||fSt|t|krt|t|}fdd|d|D}tj|tj}j |ddd} |j t | fWdn1swwY||d}||d}||fS) ae Preprocess dimension for broadcasting. Returns (shapes, strides) such that the ndim match *target_shape*. When expanding to higher ndim, the returning shapes and strides are prepended with ones and zeros, respectively. When truncating to lower ndim, the shapes are checked (in runtime). All extra dimension must have size of 1. rrAcg|] }d|qSr)rrrr9rr>r?r(z(_bc_adjust_dimension..NFr!z,cannot broadcast source array for assignment)rrrzr functoolsreducerr true_bitrrfr"r#r) rkr9rr target_shaperZnd_diffZ dim_is_oneacceptedrr>rr?_bc_adjust_dimensions,      rc sg}g}|tjd|tjdfddt||D}fdd|D}fddt||D} fddt| ||D}fddt| |D}||fS) z Broadcast shapes and strides to target_shape given that their ndim already matches. For each location where the shape is 1 and does not match the dim for target, it is set to the value at the target and the stride is set to zero. rrAcsg|] \}}d||qS)r r)rtaroldr9r>r?rCz,_bc_adjust_shape_strides..crrr)rrrr>r?rEcsg|] \}}||qSr>)r)rxyrr>r?rFcs g|] \}}}|||qSr>rp)rprrrr>r?rGscsg|] \}}||qSr>r)rrr)r9rr>r?rIr)rrrzr) rkr9rrrZ bc_shapesZ bc_stridesmismatchZ src_is_onepredsr>)r9rrr?_bc_adjust_shape_strides7s     rc Cst||j}t||j}t|||||\}}t|||||\}}|jt|dd}t|||}t ||j t ||t |||j |j |jd||fS)zX Broadcast the given array to the target_shape. Returns (array_type, array) Ar_rr)r rrUrrrcopyrrgrrrZrrr) rkr9arrtyperrrrZ new_arrtypeZnew_arrr>r>r?_broadcast_to_shapeNs&   rcCs,|j|jddd}|||}dd}||fS)NrT)r_rreadonlyc Ssz|\}}|jd}t||||}t||}t|||||\}}t|dt||j dd| } t |||j | S)Nrr) rrgr rrrrrrrrr r) rkr9rOrrZshape_rrdestrr>r>r?codegenms  z$_numpy_broadcast_to..codegen)rr) typingctxrrUretrOrr>r>r?_numpy_broadcast_tohs rcCs$|jdd}||}dd}||fS)NTrcSsH|\}|jd}t||||}t|jj|_|}t|||j|Sr) rrgr Zget_null_valuerr7rr r)rkr9rOrrrrrr>r>r?rs  z#get_readonly_array..codegen)r)rrrrOrr>r>r?get_readonly_arrays  rc Cs|j}t|}t|}||krtd|D] }|dkrtdqd}||}||krM||}||} || ks:|dkrC|d7}|d7}ntd||ks*dSdS)NzDinput operand has more dimensions than allowed by the axis remappingrz4all elements of broadcast shape must be non-negativerAz=operands could not be broadcast together with remapped shapes)rUrr) rZ dest_shapeZ src_shapeZsrc_ndimZ dest_ndimr}Z src_indexZ dest_indexZsrc_dimZdest_dimr>r>r?_can_broadcasts& rcCst|}t||t||Sr)npasarrayrrrrUr>r>r?_default_broadcast_to_impls   rcCst|s tdt|tjrdd}|St|tjr+t|jtjs)d}t|tSt|tj rL|j dkrLt dd|DsJd|d }t|tSt|tj ru|j dkrut|tj oa|j dk}t|sh|rnd d}|Sd }t|d |}t|) Nz-The first argument "array" must be array-likecSst||fSr)r broadcast_torr>r>r?rz numpy_broadcast_to..implz7The second argument "shape" must be a tuple of integersrcSg|]}t|tjqSr>)rrIntegerLiteral)rtypr>r>r?rrz&numpy_broadcast_to.."z," object cannot be interpreted as an integercSst|}t|Sr)rrrrr>r>r?rs z/Cannot broadcast a non-scalar to a scalar arrayz:The argument "shape" must be a tuple or an integer. Got %s)rrrrrrUniTuplerirTuplerallrr_r)rrUrrZis_scalar_arrayr>r>r?numpy_broadcast_tos4         rcCsrtt|D]0}|t||}||}|dkrtd|dkr!q||dkr,|||<q|||kr6tdqdS)Nr#negative dimensions are not allowedrAz=shape mismatch: objects cannot be broadcast to a single shape)r6rr)rmrUr]rtmpr>r>r?numpy_broadcast_shapes_lists   rcst|D]7\}}t|tj}t|tjot|jtj}t|tjo't|jdk}|s;|s;|s;d|d|}t |qd|D]}t|tjrNt dq@t|tj r[t t|q@dkrdddSdfdd }|S) Nrz Argument z* must be either an int or tuple[int]. Got rAcWrUrVr>rr>r>r? z+ol_numpy_broadcast_shapes..rAcszdg}}t|D] }t|trt|dkrt||q t|tr+t||fq t|D] \}}t|||}q0|Sr^)rrrrrr enumerater.)rrrargr|elemrZtup_initr>r?r s   z'ol_numpy_broadcast_shapes..impl) rrrrrrirrrrmaxr)rr|rZis_intZ is_int_tupleZis_empty_tuplerrr>rr?ol_numpy_broadcast_shapess0         rcst|D]\}}t|std|dqd}d}|D]$}t|tjtjfr+|j}n|}|dur4|}q||kr@td|qdt|D])\}}t|tj rXt |j qGt|tj tj tjfrit dqGtd|dfdd }|S) Nz Argument "z" must be array-likezTMismatch of argument types. Numba cannot broadcast arrays with different types. Got rrAzUnhandled type rcs|dg}t|D] }t|t|jq }tD] }t||||}qg}t|D]}|tt||q-|SrS) rrrrrUr6r.rYr)rrUrrr]Zoutsrr>r?r?s    z$numpy_broadcast_arrays..impl)rrrrrrrrriZArrayCompatiblerr_Numberru)rr|rZ unified_dtypedtrr>rr?numpy_broadcast_arrayss6  rcCr+)zTargets should implement this if they wish to specialize the error handling/messages. The overload implementation takes two tuples as arguments and should raise a ValueError.rr index_shaper>r>r?raise_with_shape_contextVr0rZgeneric)targetcCNt|tjrt|tjr!|j|jkr#t|jtjr%dd}|SdSdSdSdS)NcStd)Nz0cannot assign slice from input of different sizerrr>r>r?rfrCz1ol_raise_with_shape_context_generic..implrrrrirrrrr>r>r?#ol_raise_with_shape_context_generic]s    rZCPUcCr)NcSst|dkrd|dd}ndddd|Dd}t|dkr,d|dd}nddd d|Dd}d |d |}t|) NrA(rz,), cSg|]}t|qSr>strrrr>r>r?rvr{zAol_raise_with_shape_context_cpu..impl..)cSr r>r r r>r>r?rzr{zcannot assign slice of shape z from input of shape )rjoinr)rrZ shape_strZ index_strrr>r>r?rrs  z-ol_raise_with_shape_context_cpu..implrrr>r>r?ol_raise_with_shape_context_cpuks     rc' s:|j\}}|\}}t||}t|j} t|j} |j} t||||} | dd} t t j rۈj | }tt|\tj}tj}j}tj}t|t|ksrJt||D]\}}|d||}qwj|dd| ||Wdn1swYt|||\}}| | |j\}}t||| \}}t||||}t||||\}}nmt t jr<j | }t|dksJttt j}|f}d|d|}j|dd| |f|dfWdn 1s(wYfd d }d d }n fd d }dd }t j d} | !\}!}"t"|"}"| j#D] }#|"$|#| q\dd|"D}$||$}%%|%|j }%tj&| | | |j'|!dj(d }&t)||%|&| *|+S)z Implement slice assignment for arrays. This implementation works for basic as well as fancy indexing, since there's no functional difference between the two for indexed assignment. cSs~|jt}ttjt|ttjt|f}||j|i}|||}||| ||j d|| ||j d|fdSNrrA) typing_contextresolve_value_typerrrint64r get_call_typerF make_tupler)rkr9rrfntyZargtysZ raise_sigfuncr>r>r?raise_shape_mismatch_errors  z2fancy_setslice..raise_shape_mismatch_errorr Fr!NrArcs,|\}tjttj}||fSr)rFoperatorgetitemr$rry)rr| getitem_implr9rkrZ src_dtyperr>r?rs  z#fancy_setslice..src_getitemcSrQrr>r>r>r>r?rrRz#fancy_setslice..src_cleanupcsSrr>)r)rr>r?rrRcSrQrr>r>r>r>r?rrRcSsg|]}|dur|qSrr>)rrbr>r>r?rrz"fancy_setslice..r),rrgr rrUrrrsr-rrrrir1rrrrrrrrrrrrrSequencerFr$ryrrzrrrtr|rxrrr rvrr')'rkr9rOrrrrrrZ dest_shapes dest_strides dest_datarxrrrrrZ shape_errorurZ src_startZsrc_endZ dest_lowerZ dest_upperZ dest_startZdest_endrrrlen_implZseq_lenrZ dest_indicesrr]rrurr>rr?rs               rc s|jd}|jdd}|d}|dd}fddt||D}t||dj}tjtjt|d} t |j || } ||f} | | fS)NrrAc"g|] \}}||tjqSr>rxrry)rrrurr>r?r#z#vararg_to_tuple..rir) rrr rZr7rrryrrr$r) rkr9rOrrZdimtysrr\rUshapetynew_signew_argsr>rr?vararg_to_tuples   r)zarray.transposecCst|||jd|dSr)array_Trrkr9rOrr>r>r?array_transpose/sr,cCsnt|tt|krtdt|}|D]}||ks t||kr$tdq|||dd<|||dd<dS)Nzrepeated axis in transposez2axis is out of bounds for array of given dimension)rrrabs)rrUrr8rr>r>r?permute_arrays4sr.c s|jd}t||d}|jd|d}}|j|j}} tj} t| |||j |j g} fdd| D} t | | D] \} } | |qBtj | dddtj| }fdd| D}t || D]\}}t||| tj|g|g|ddqotttjd d|Dt|j}t||j| d| d |j|j|jd |}t|j|S) NrrAcg|]}tqSr>r rKrr)r9 ll_ary_sizer>r?rPrz)array_transpose_tuple..rrir_rcsg|] }tqSr>rgr1)r9rk np_ary_tyr>r?r[rrrUrrrcSryr>rrar>r>r?rkr{r&r) rrgrrirrryr ArrayTyperUrrrrrrjrr as_pointercompile_internalr.rr$voidrrr:rrrrr )rkr9rOrrrZaxistyrZnum_axisrir9ZarysZll_arysrdstZ np_itemsizeZnp_arysZnp_aryZll_aryrrr>)r9rkr2r5r?array_transpose_tupleCsP       r?cC t||||\}}t||||Sr)r)r?rkr9rOrr'r(r>r>r?array_transpose_varargzrBcCs:t|tjr td|durddd}|Sddd}|S)Nz#np.transpose does not accept tuplescS|Sr transposer9axesr>r>r?np_transpose_implrCz*numpy_transpose..np_transpose_implcS ||SrrErGr>r>r?rIrXr)rrrrr)r9rHrIr>r>r?numpy_transposes    rKTc Cs|jdkr|}nFt||||}t|||}t||j|j}t||j|j}t||jt||dddt||ddd|j |j |j d| }t ||||S)NrAr)r_rgr rrUrrrrZrrrrr ) rkr9rrrrrrrr>r>r?r*s r*2cCsTt|tjs tdt|tjstdt|ttjfs#tdddd}|S)Nz+The first argument "start" must be a numberz+The second argument "stop" must be a numberz+The third argument "num" must be an integerrNcSst|||}td|S)Ng$@)rlinspacepower)rrqnumrr>r>r?rs znumpy_logspace..implrN)rrrrrrr)rrqrQrr>r>r?numpy_logspaces      rScst|tjs d}t|t|tjsd}t|t|ttjfs)d}t|tdd||fDrJtt t |t |dd fdd }|Sd d d}|S) Nz%The argument "start" must be a numberz$The argument "stop" must be a number%The argument "num" must be an integercsrrrrComplexrrr>r>r?rrz"numpy_geomspace..rNc s|dks|dkr td|}|}tdkrH|jdk|jdk@}t|dkt|dk@}d}|r<|j}|j}d}|rG| }| }| }n t|}||}||}t|}t|}t|||}|dkrv||d<|dkrv||d<||S)Nr&Geometric sequence cannot include zeror%rMrAy?)rrrealrsignimaglog10logspace) rrqrQZboth_imaginary both_negativeout_signlogstartlogstoprZ result_dtyper>r?rs8   znumpy_geomspace..implcSs|dks|dkr tdt|dkt|dk@}d}|r'| }| }| }t|}t|}t|||}|dkrH||d<|dkrH||d<||S)NrrXrMrA)rrrZr\r])rrqrQr^r_r`rarr>r>r?rs   rR) rrrrrrrrr rZ result_typer )rrqrQrrr>rbr?numpy_geomspaces"      8 rcrAcCsRt|ttjfs tdt|tjstd|jdkr"tdddd}|S) Nz*The second argument "k" must be an integerz'The first argument "m" must be an arrayr&Input must be >= 2-d.rAcSsp|d}|dkr|ddS|dkrtt|ddS|dkr(tt|S|dkr6tt|ddSt)NrrAr&)rswapaxesfliplrflipudrv)rrr>r>r?r s znumpy_rot90..implr) rrrrrrrr_NumbaValueError)rrrr>r>r? numpy_rot90s       rkc Cs|tj}|}|tj} t| |||||||| g} t|j | d} ||j } t || ddd} t || ddd}||}t ||dd}t ||dd}| d}| | | | |||||j|g}|S)a Call into Numba_attempt_nocopy_reshape() for the given array type and instance, and the specified new shape. Return value is non-zero if successful, and the array pointed to by *newstrides* will be filled up with the computed results. Znumba_attempt_nocopy_reshaperUrr)rrryr;Zintcr FunctionTyper Zget_or_insert_functionr8r_rXrWcallr)rkr9rrnewndnewshape newstridesr9Z ll_intp_starZll_intcrfnndrUrZ is_f_orderrr>r>r?_attempt_nocopy_reshapes2     rsc Csd}d}t|D]\}}|dkr|d7}|}q||9}q|dkr*||kr(tddS|dkrO|dkr9d}|dk}n ||}||dk}|sItd|||<dStd)NrrAz)total size of new array must be unchangedzmultiple negative shape values)rr) origsizerUZ num_neg_valueZ known_sizerrZneg_axinferredokr>r>r?normalize_reshape_value?s*    rwz array.reshapec Cs|jd}|j}|jd}|d}|tj}t||j} t||||d} t || } | || tj |j ddd} t| ||} |tj||}t| || ||tj|jg|g|dd| j}||tttjtj| || g|j}t || }t|||| || |}|d||d}||d}|j |t!|fWdn1swYt|||}t|| j"|#| |#|| j$| j%| j&d|}t'|||j|S) NrrArr3r6rzincompatible shape for arrayr)(rrrrryrr:rrgr rKrrrirrjrrr;rr<rwrr$r=rzrrsrr7rr"r#rGrr:rrrr )rkr9rOrrrettyr&rUr9Zll_shaperroZ shape_ary_ty shape_aryZshape_itemsizer}rnrprvfailrrrr>r>r? array_reshape]sb         r{cCr@r)r)r{rAr>r>r?array_reshape_varargrCr|)r&rAcC dd}|S)NcSrJrreshape)r9ror>r>r?np_reshape_implrX#np_reshape..np_reshape_implr>)r9rorr>r>r? np_reshapercCr})NcSrJrr~)r9rUr>r>r?rrXrr>)r9rUrr>r>r?rrcCsVt|s d}t|t|tjrt|jtjs%t|tjs%d}t|dd}|S)N#The argument "a" must be array-likezBThe argument "new_shape" must be an integer or a tuple of integersc Sst|}t|}t|tr(d}t|D]}||9}|dkr&d}t|qn |dkr2d}t||}|jdkrBt||j S| |j }|}t |dD] }t ||f}qQ|d|}t ||S)NrArz0All elements of `new_shape` must be non-negative) rrravelrrrr}zerosZastyperir6 concatenater) r9 new_shapenew_sizeZ dim_lengthrmsg2repeatsrr]r>r>r?rs.      znumpy_resize..impl)rrrrrrrir)r9rrrr>r>r? numpy_resizes     rcCs^t|s tdt|stdt|rddd}|St|tjs(tdddd}|S)Nz+The first argument "arr" must be array-likez/The second argument "values" must be array-likecSs.tt|}tt|}t||fSr)rrrrrvaluesrr>r>r?rsznp_append..implz,The third argument "axis" must be an integercSstj||f|dSNrrrrr>r>r?rr)rrrrrrr)rrrrr>r>r? np_appends     rz array.ravelcCsNdd}dd}|jdjdkr|}n|}|||||}t|||j|}|S)NcSs ||jS)zNo copy version)rr}rr>r>r? imp_nocopy zarray_ravel..imp_nocopycSrD)z Copy version)flattenrr>r>r?imp_copy zarray_ravel..imp_copyrr)rrr<r!r)rkr9rOrrrimprr>r>r? array_ravelsrcCsdd}|||||S)NcSrDr)rr9r>r>r? np_ravel_impl rCznp_ravel..np_ravel_impl)r<)rkr9rOrrr>r>r?np_ravel srz array.flattencCs,dd}|||||}t|||j|}|S)NcSs||jSr)rrr}rr>r>r?r rmzarray_flatten..imp)r<r!r)rkr9rOrrrr>r>r? array_flatten src Csl|dur t|n|}t|||\}}}t|jD]}||} ||} ||} tt| | | ||<q|Sr)r empty_likebroadcast_arraysndindexrUminr) r9a_mina_maxrra_ba_min_ba_max_brval_aZ val_a_minZ val_a_maxr>r>r? _np_clip_impl% srcCsHt|jD]}||}||}|rt||||<qt||||<q|Sr)rrrUrr)r9bZuse_minrrrZval_br>r>r?_np_clip_impl_none3 srcCs^t|s tdt|tjst|stdt|tjs't|s'tdt|tjs8t|s8d}t||dupAt|tj}|dupKt|tj}|rW|rWddd}|St|tj}t|tj} |rn| rnddd} | S|r| s|r{dd d } | Sdd d } | S|s| r|rdd d} | Sddd}|S|rddd}|S|rddd}|Sddd}|S)Nrz6The argument "a_min" must be a number or an array-likez6The argument "a_max" must be a number or an array-likez5The argument "out" must be an array if it is providedcSr)Nz&array_clip: must set either max or minrr9rrrr>r>r? np_clip_nnX rCznp_clip..np_clip_nncSsH|dur t|n|}t|jD]}||}tt|||||<q|Sr)rrrrUrrr9rrrrrrr>r>r? np_clip_ssa s znp_clip..np_clip_sscSsB|dur t|n|}t|jD] }||}t||||<q|Sr)rrrrUrrr>r>r? np_clip_sno znp_clip..np_clip_sncSst||}t||||Srr full_liker)r9rrrZ a_min_fullr>r>r? np_clip_sa|  znp_clip..np_clip_sacSsB|dur t|n|}t|jD] }||}t||||<q|Sr)rrrrUrrr>r>r? np_clip_ns rznp_clip..np_clip_nscSst||}t||||Srr)r9rrrZ a_max_fullr>r>r? np_clip_as rznp_clip..np_clip_ascSs4|dur t|n|}t||\}}t||d|S)NTrrrr)r9rrrrrrr>r>r? np_clip_na znp_clip..np_clip_nacSs4|dur t|n|}t||\}}t||d|S)NFr)r9rrrrrrr>r>r? np_clip_an rznp_clip..np_clip_ancSt||||Sr)rrr>r>r? np_clip_aa sznp_clip..np_clip_aar) rrrrrNoneTyperrr)r9rrrrZ a_min_is_noneZ a_max_is_nonerZa_min_is_scalarZa_max_is_scalarrrrrrrrrr>r>r?np_clip? sV                  rclipcCsddd}|S)NcSst||||Sr)rrrr>r>r?r rmzarray_clip..implNNNr>)r9rrrrr>r>r? array_clip s rc s|j|jksJ|j|jksJt|j}tdtdtdtjfdd}|tjt||}|tjt||}|tj|j} t || ddd} t || ddd} tj tjd dd } | | } t ||tj|jg}||tj}|tj|}t ||g}| ||}t|| |||d d | ||}t|| |||d d |}|}| |||||tj|g}ttjtj| | tjtjtj}|||||}t||t|||j|}|S) a Attempt to fix up *ary* for switching from *oldty* to *newty*. See Numpy's array_descr_set() (np/core/src/multiarray/getset.c). Attempt to fix the array's shape and strides for a new dtype. False is returned on failure, True on success. rrFc s|kr|d|kr}n |d|kr}||kr'|ks%|dkr'dS|kr0|d}nd}||krP||dkr>dS||}|||9<|||<dS||krn|||}||dkrbdS||||<|||<dS dS)NrMrFrATr>) rrr\r old_itemsize new_itemsizerr]newdimZ bytelengthZ any_layoutZc_layoutZf_layoutint8r>r?r s4        z_change_dtype..imprUrrrAr3Nr6)r_rordrrrryrmr rXrWrrgrZrjrhrrr$booleanr<rr r)rkr9ZoldtynewtyrZ new_layoutrrrrrZ shape_dataZ strides_dataZshape_strides_array_typearyclsZshape_constantZ sizeof_intpZstrides_constantryZ strides_aryrUrrrOrr>rr? _change_dtype s  0       rcCt|s tddd}|S)Nz+The argument to np.shape must be array-likecS t|jSr)rrrUrr>r>r?rC rTznp_shape..implrrrr9rr>r>r?np_shape>  rcCr)Nz*The argument to np.size must be array-likecSrr)rrr}rr>r>r?rM rTznp_size..implrrr>r>r?np_sizeH rrcC dd}|S)NcsJt|tdd}fddtddD}t||S)NrAcs g|] \}}||kr|qSr>r>)rr]rrr>r?rY  z5np_unique..np_unique_impl..)rsortrrrr)arheadtailr>rr?np_unique_implV sz!np_unique..np_unique_implr>)rrr>r>r? np_uniqueT srcCshdd}t|tjtjtjtjtjfr2t|tjrtSt|tjtjfr-t|j tjr-|St ddS)Nc Sstj|tjd}|jddkrt||dSt|dkr!tdt|}|}|jd}|j|jkr9tdtjt ||j d}d}t |D]}|||||||<|||7}qJ|S)NrirrArz(operands could not be broadcast together) rrrrUnp_repeat_impl_repeats_scalerrrremptyr}rir6) r9rZ repeats_arrayasaaraveln to_returnposr]r>r>r?!np_repeat_impl_repeats_array_likec s$    z4np_repeat..np_repeat_impl_repeats_array_likezIThe repeats argument must be an integer or an array-like of integer dtype) rrrListrrrurrrirr)r9rrr>r>r? np_repeat^ s  rcCs|dkrtdt|}|}|jd}|dkr"tjd|jdS|dkr+t|Stj|||jd}t|D]}||||||d|<q9|S)NrrrrA) rrrrrUrrirr6)r9rrrrrr]r>r>r?r s    rrepeatcCr})NcS t||Sr)rr)r9rr>r>r?array_repeat_impl rTz'array_repeat..array_repeat_implr>)r9rrr>r>r? array_repeat rcCt|}dd}||fS)z"Computes the itemsize of the dtypecSs,||jdj}||j}|||Sr)rhrrirrj)cgctxr9rOllargsrlZllintpr>r>r?r s z%_intrin_get_itemsize..codegen)rry)tyctxrirOrr>r>r?_intrin_get_itemsize s rcCrQrr>)r9rir>r>r?_compatible_view rRrcCr})zDDetermines if the array and dtype are compatible for forming a view.c Sst|}||jkrf|jdkrd}t| |jd}|j|dk}|jdk}|j||jk}|r:|r:|r:d}t|||jkrR|dksJ|j|dkrPd} t| dS|j||j} | |dkrhd} t| dSdS)NrzOChanging the dtype of a 0d array is only supported if the itemsize is unchangedrAzJTo change to a dtype of a different size, the last axis must be contiguouszZWhen changing to a smaller dtype, its size must be a divisor of the size of original dtypezuWhen changing to a larger dtype, its size must be a divisor of the total size in bytes of the last axis of the array.)rrr_rrUr}r) r9riZ dtype_sizeZmsg1rp1p2Zp3rZmsg3rZmsg4r>r>r?r s0       z ol_compatible_view..implr>r9rirr>r>r?ol_compatible_view s#rz array.viewcCs<|jd}|j}t||||d}t|||}t|jj}t|D]} t|| } | dkr:|jj } | | | |_q#t || | q#|j } | t} | | g|jRi}|| |}|||t|||||}|d|t|j d}||d}|j|t|fWdn1swY|}t|||j|S)Nrrrz"new type not compatible with array)rrrgrrrsortedgetattrrr7rrrrrrrFrrrrr"r#rrr )rkr9rOrrrxrrfieldsrrurrrZ_compatible_view_sigrrvrzrrr>r>r? array_view s0        rricCs|}t||||Sr)r'r"rkr9rrrr>r>r? array_dtype srrUcC(t|}||||}|j}t||||Sr)rgrUr"rkr9rrrrrrr>r>r? array_shape  rrcCrr)rgrr"rr>r>r? array_strides rrr_cC|tj|j}t||||Sr)rrryr_r"rr>r>r? array_ndim srr}cCrr)rgrr"rr>r>r? array_size% s rrcCrr)rgrr"rr>r>r?array_itemsize- rrnbytescCs2t|}||||}||j|j}t||||S)z" nbytes = size * itemsize )rgrrrr"rr>r>r? array_nbytes6 s r  contiguouscCrr)rrr is_contigr"rr>r>r?array_contiguousB r  c_contiguouscCrr)rrrZ is_c_contigr"rr>r>r?array_c_contiguousH r r f_contiguouscCrr)rrrZ is_f_contigr"rr>r>r?array_f_contiguousN r rrcCs |tj|j }t||||Sr)rrrmutabler"rr>r>r?array_readonlyT rCrctypesc CsPt|}||||}t|}|||}|j|_|j|_|}t||||Sr)rgr ArrayCTypesrrrrr ) rkr9rrrrrZactctinforr>r>r? array_ctypes\ s   rrcCs8|j|||d}|j}|||tj}t||||SNr)rrrrrryr")rkr9rrrrr>r>r?array_ctypes_datai srcCs6|j|||d}|j}||||}t||||Sr)rrrrr")rkr9fromtytotyrurrr>r>r?array_ctypes_to_pointerr src Csrt||||d}ttj|j}|||j}ttj ||tj}|j |j | tj|g}| ||||} | S)a)Helper to invoke the contiguous checker function on an array Args ---- checker : ``numba.numpy_supports.is_contiguous``, or ``numba.numpy_supports.is_fortran``. context : target context builder : llvm ir builder aryty : numba type ary : llvm value r)rgrrryr_rjrrir$Zbool_rUrrr<) checkerrkr9rrZtup_intprZ check_sigZ check_argsr r>r>r?_call_contiguous_check{ s   rrcCs>||t|}||_|}|j|||t||||Sr)rr ArrayFlagsrrrrr!)rkr9rrflagsobjrr>r>r? array_flags s r!cCsZ|jjdkr|j|||d}tt|||j|j}n |jjdk}|tj|}t ||||S)Nrr) rSrrrrrrrrr")rkr9rrr rrur>r>r?array_flags_c_contiguous s  r"cCsr|jjdkr|j|||d}tt|||j|j}n|jj}|jjdkr'|dkn|dv}|tj |}t ||||S)NrrrAr) rSrrrrrr_rrrr")rkr9rrr rrrur>r>r?array_flags_f_contiguous s r#rYcCsH|jtjvrt||||ddS|jtjvrt||||Stdtj)NrYattrzunsupported .real for {}) rircomplex_domainarray_complex_attr number_domainr rGrr7)rkr9rrr>r>r?array_real_part s  r)r[cCs|jtjvrt||||ddS|jtjvrHt|jdd|}t||||g\}}t||||}t ||j | |j |jdt|||j|Stdtj)Nr[r$Trrzunsupported .imag for {})rirr&r'r(r$r_parse_empty_like_argsrr memsetrrrrr!rrrGrr7)rkr9rrrOrrrr>r>r?array_imag_part s   r,cCs|dvs |jtjvrtd|t|}||||}|jj}|||}|j |} | | } | |j| } |dkrK|| tddg} |j|dd} t| ||} t| | d}t| ||t||| | S) a Given a complex array, it's memory layout is: R C R C R C ^ ^ ^ (`R` indicates a float for the real part; `C` indicates a float for the imaginary part; the `^` indicates the start of each element) To get the real part, we can simply change the dtype and itemsize to that of the underlying float type. The new layout is: R x R x R x ^ ^ ^ (`x` indicates unused) A load operation will use the dtype to determine the number of bytes to load. To get the imaginary part, we shift the pointer by 1 float offset and change the dtype and itemsize. The new layout is: x C x C x C ^ ^ ^ )rYr[zcannot get attribute `{}`r[ rArrir)rr)rirr&rGrrgZunderlying_floatrjrhrr7rr;rrrrIntTyperrr Z copy_structr r)rkr9rrr%rrrZfltyZ sizeof_fltyrZ llfltptrtyrZresulttyrreplr>r>r?r' s    r'conj conjugatecCr)NcSs t|Sr)rr1rr>r>r?r rXzarray_conj..implr>rrr>r>r? array_conj r5cCrDr)r')rkr9ZdtypetyZdtypevalr>r>r? dtype_type rr7r7kindZstatic_getitemcCs<|j}t|tjr||d}t||||Sd}t|)zThis handles the "static_getitem" when a Numba type is subscripted e.g: var = typed.List.empty_list(float64[::1, :]) It only allows this on simple numerical types. Compound types, like records, are not supported. NzlUnreachable; the definition of __getitem__ on the numba.types.abstract.Type metaclass should prevent access.)rrrrrr"rZ LoweringError)rkr9rOrrxrrr>r>r?static_getitem_number_clazz( s   r9c st|}|||}|j}t|tjstd||f||}||} t|tjr9|j |j|j |j dd} n|j |dd} t| } | |} tj | } t j||j| | jjd}t|tjrt ||j|j }|fdd|jD7}t ||j|j }|fdd|jD7}|j}n|j}|j}|}t| ||| tj ||j|jd | }t|| |S) zq Generic getattr() implementation for record arrays: fetch the given record member, i.e. a subarray. zattribute %r of %s not definedrr3r.)rcg|] }tj|qSr>rrryrzrkr>r?rb rz(array_record_getattr..cr:r>r;rzr<r>r?re rr)rgrirrRecordrGtypeofr NestedArrayrr_rryr rrr7rrUrrjrhrrrrr )rkr9rrr%rrrZrectyperirZrestyZrarytyZraryZ constoffsetZ newdataptrrUrZdatasizerr>r<r?array_record_getattr@ sN        r@cCs0|d}t|ts tt|||jd|d|Sr^)rr rGr@r)rkr9rOrrr>r>r?array_record_getitemx s rAc s ||||}||}t|tjret|}||}|j} fdd|jD} fdd|j D} t ||| | } t || t || t || tj|jddd|} t||| St ||| |}|jrudnd}||||} t||| S)zT Generic getattr() implementation for records: get the given record member. cr:r>r;rrr<r>r?r rz"record_getattr..cr:r>r;rBr<r>r?r rNrrA)sentry_record_alignmentrr>rrr?rgrirUrr get_record_memberrhrrZrryr}rr rprq)rkr9rrr%relemtyrrrirorpnewdatardptrror>r<r?record_getattr sB            rHc Cs|j\}}|\}}|||||} ||} t| tjrHt||||dd} | j } t ||| | j j } t || | |tj| jdSt ||| || }||||| }|jr`dnd}|j|| |||ddS)zT Generic setattr() implementation for records: set the given record member. rArNrn)rrCrr>rrr?r rfrrDr7ZpointeeZmemcpyrryrrhrxrprt)rkr9rOrr%rrrrurrEZ val_structrrrGror>r>r?record_setattr s,         rIcCs4||jd|d}||||jd|d|dS)3 Record.__getitem__ redirects to getattr() rrA) get_getattrr)rkr9rOrrr>r>r?record_static_getitem_str srLcCs^|jdj}t|jdj}||j||}||jd|}||||jd|d||S)rJrAr)rrrrZinsert_const_stringr8rK)rkr9rOrr|rZll_fieldrr>r>r?record_static_getitem_int s rMZstatic_setitemc CsJ|j\}}}|\}}} t|j||} ||| } | dusJ| ||| fS)3 Record.__setitem__ redirects to setattr() N)rr$r get_setattr) rkr9rOrrectyrrrecr|ru getattr_sigrr>r>r?record_static_setitem_str s    rSc Cs^|j\}}}|\}}} t|j||} t|jdj} || || } | dus(J| ||| fS)rNrN)rr$rrrrO) rkr9rOrrPrrrQr|rurRrrr>r>r?record_static_setitem_int s   rTcCs||||S)zB Create a constant array (mechanism is target-dependent). )make_constant_array)rkr9rpyvalr>r>r?constant_array srWcCs0ttd|j}|t|}t||S)zG Create a record constant as a stack-allocated array of bytes. )rr:r/r bytearraytostringr r)rkr9rrVZltyrur>r>r?constant_record s r[cCs"tjt|tjd}||||S)zM Create a constant array from bytes (mechanism is target-dependent). r)rrrYZuint8rU)rkr9rrVbufr>r>r?constant_bytes sr]cCs0|j\}}||kr tjSdd}|||||S)NcSs(|j|jko|j|jko|jj|jjkSr)rUrrrr9rr>r>r? array_is_impl s  zarray_is..array_is_impl)rr rr<)rkr9rOratyZbtyr_r>r>r?array_is s ra__hash__cCsddS)NcSrQrr>r3r>r>r?r, rzol_array_hash..r>r3r>r>r? ol_array_hash* rrccC t|dS)zq Return the Structure representation of the given *flatiterty* (an instance of types.NumpyFlatType). flat_make_flattening_iter_cls) flatitertyr>r>r?make_array_flat_cls2  ricCrd)zv Return the Structure representation of the given *nditerty* (an instance of types.NumpyNdEnumerateType). ndenumeraterfnditertyr>r>r?make_array_ndenumerate_cls: rjrnc Cs|tjd}|d} |dur|tj|tt|D]T} t ||| } t || | } || } | d| | }t |||| | |durO|| || Wdn1s^wY||| |durq|| q|dur}|tj||| || dS)NrZ end_incrementr)rrryr;rr false_byterr6rXrr:r if_likelyrI true_byterJ)rkr9r_rUrend_flag loop_continue loop_breakrbbendr8idxptrr|r in_boundsr>r>r?_increment_indicesB s.     rxcCs*t||j|j}t|||j|||dSr)r rrUr_rx)rkr9rrrrrrUr>r>r?_increment_indices_arrayc sryc sjjtjjrnd Gdddt}Gddd|Gfddd|Gdd d |Gd d d |Gd d d |G f dddt}|S)zq Return the Structure representation of the given *nditerty* (an instance of types.NumpyNdIterType). rAc@sFeZdZdZddZddZejddZdd Z d d Z d d Z dS)z$make_nditer_cls..BaseSubIterzF Base class for sub-iterators of a nditer() instance. cSs&||_||_||_||_|||_dSr)nditer member_name start_dimend_dimr_)rMrzr{r|r}r>r>r?r:x s z-make_nditer_cls..BaseSubIter.__init__cSst|j|j|dSr)rrzr{)rMr[r>r>r?set_member_ptr z3make_nditer_cls..BaseSubIter.set_member_ptrcSst|j|jSr)rrzr{r,r>r>r? member_ptr z/make_nditer_cls..BaseSubIter.member_ptrcSrQrr>rMrkr9r>r>r? init_specific rRz2make_nditer_cls..BaseSubIter.init_specificcSrQrr>rMrkr9 logical_dimr>r>r?rs rRz2make_nditer_cls..BaseSubIter.loop_continuecSrQrr>rr>r>r?rt rRz/make_nditer_cls..BaseSubIter.loop_breakN) r`rarbr5r:r~rcached_propertyrrrsrtr>r>r>r? BaseSubIters s  rc@s0eZdZdZddZddZddZdd Zd S) z$make_nditer_cls..FlatSubIterz Sub-iterator walking a contiguous array in physical order, with support for broadcasting (the index is reset on the outer dimension). cSs$|tjd}|t||dSr)rrryr~r r)rMrkr9rr>r>r?r sz2make_nditer_cls..FlatSubIter.init_specificcSs||j}||j|gSr)r:rrr)rMrkr9rrrrr>r>r?compute_pointer s z4make_nditer_cls..FlatSubIter.compute_pointercSs<||jdkr||j}t||}|||jdSdSrS)r_r:rr rr)rMrkr9rrr>r>r?rs s   z2make_nditer_cls..FlatSubIter.loop_continuecSsd|dkr|tjd}|||jdS||jdkr0||j}t||}|||jdSdSr) rrryrrr_r:r r)rMrkr9rrrr>r>r?rt s  z/make_nditer_cls..FlatSubIter.loop_breakN)r`rarbr5rrrsrtr>r>r>r? FlatSubIter s  rcs$eZdZdZfddZddZdS)z+make_nditer_cls..TrivialFlatSubIterzx Sub-iterator walking a contiguous array in physical order, *without* support for broadcasting. csjrJdSr)need_shaped_indexingrrlr>r?r rz9make_nditer_cls..TrivialFlatSubIter.init_specificcSs&t|dks Jt|||j|SrS)rrrrMrkr9rrrr>r>r?r sz;make_nditer_cls..TrivialFlatSubIter.compute_pointerN)r`rarbr5rrr>rlr>r?TrivialFlatSubIter s  rc@eZdZdZddZdS)z'make_nditer_cls..IndexedSubIterzA Sub-iterator walking an array in logical order. cSs(t||jks Jtj|||||ddSNFr)rr_r rrr>r>r?r s z7make_nditer_cls..IndexedSubIter.compute_pointerNr`rarbr5rr>r>r>r?IndexedSubIter  rc@r)z'make_nditer_cls..ZeroDimSubIterz5 Sub-iterator "walking" a 0-d array. cSs|jSrrrr>r>r?r rAz7make_nditer_cls..ZeroDimSubIter.compute_pointerNrr>r>r>r?ZeroDimSubIter rrc@r)z&make_nditer_cls..ScalarSubIterz8 Sub-iterator "walking" a scalar value. cSs|Srr>rr>r>r?r rRz6make_nditer_cls..ScalarSubIter.compute_pointerNrr>r>r>r? ScalarSubIter rrcs|eZdZdZejfddZ fddZfddZdd Z d d Z  fd d Z ddZ ddZ dS)zmake_nditer_cls..NdIterz .nditer() implementation. Note: 'F' layout means the shape is iterated in reverse logical order, so indices and shapes arrays have to be reversed as well. c sdg}jrnd}tjD]\}}|\}}}}d|} ||} || || ||q|S)N)reZindexedZ0dZscalarzindex%d)rrrwrY) rMlZ factoriesr]rr8r|r}rr{factory)rrrrrrmr>r?subiters s  z(make_nditer_cls..NdIter.subiterscs2|tjd}||t|||_t|D]\}}t|tjs2d|}t |||} t ||| q| ||||}t tj} d} d} t|D]\}} t| tjre| jkre||j} ||j} nqJdkslJ||| d} |tjd} dd}t||D]'\} }t| tjr| jdkrttjt tj| j| }|||||j| fqt || }dkr|ddd }|d | |}||t jt j}js| f}t|ksJt j||jd }tD]}t |||}| ||q||_!t "|||j|_t |||_#|j$D] }|%||q dS) zY Initialize the nditer() instance for the specific array inputs. rscalar%dNr>rAcSs>t|}t|D]}|||t|||krtdqdS)Nz2nditer(): operands could not be broadcast together)rr6r)rU main_shaperr]r>r>r? check_shapes  zBmake_nditer_cls..NdIter.init_specific..check_shaperrMrr@)&rrryrrarraysrrrr rr_arrays_or_scalarsrr_rUrrr$noner<rrrprqrorrrKr7r6rXrrrZ exhaustedrr)rMrkr9arrtysrrr]rr{slotZ main_shape_tyrZ main_nitemsrrrrOrZshape_is_emptyrrr8rvsubiter)rr_rmnshapesr>r?r sl          z-make_nditer_cls..NdIter.init_specificc s>|d}t|||j}t|||d||Wdn1s*wYj}t ||j}| ||||}|j }|d| |||||} dd| D} t | dkrg|| dn |||j| t ||j} t||t | | ||jt|j||t|j||||||dS) zJ Compute next iteration of the nditer() instance. rFNTcSryr>r7rrr>r>r?rRr{zEmake_nditer_cls..NdIter.iternext_specific..rAr)r;r as_bool_bitr:r if_unlikelyrrIrrrr _make_viewsrrrrrUrxrpartial_loop_continue _loop_breakrJ) rMrkr9rrurrrrviewsrUrlr>r?iternext_specific=sD       z1make_nditer_cls..NdIter.iternext_specificcS@|jD]}|j|kr|jkrnq|||||jqdSr)rr|r}rsrMrkr9r8rr>r>r?rg z.make_nditer_cls..NdIter._loop_continuecSrr)rr|r}rtrr>r>r?rlrz+make_nditer_cls..NdIter._loop_breakc sdg}j}|j}j} t| tjrt| } n| g} fddtDt||D]=\} } | \} } } } | j | j }dkrJ|ddd}| D]}||dusVJ| ||| |||||| ||<qLq-t dd|DsvJ|S)z: Compute the views to be yielded. Nc  g|] }t|qSr>r:r rXrzr9rr>r?r}sz?make_nditer_cls..NdIter._make_views..rrMcss|]}|VqdSrr>rr>r>r?rsz>make_nditer_cls..NdIter._make_views..) rwrrrrrrr6rr|r} _make_viewr)rMrkr9rrrrrwrrettysrrrZ array_indicesZ sub_indicesr])rnarraysrmrrr?rqs0       z+make_nditer_cls..NdIter._make_viewsc Sst|tjr |jdks J||||||}||||} t||} ||ttj dd} ||ttj dd} t | || | | dd| S)zD Compute a 0d view for a given input array. rr>N)r) rrrr_rrgrmrrryr) rMrkr9rrxrrrr[viewrrUrr>r>r?rs z*make_nditer_cls..NdIter._make_viewc Ss`g}tt||D]$\}\}}t|tjr#||||||dq |t|d|q |S)Nrr)rrrrrrYrgr) rMrkr9rrrr]rrr>r>r?rs  z2make_nditer_cls..NdIter._arrays_or_scalarsN)r`rarbr5rrrrrrrrrrr> rrrrrrrr_rmrr>r?NdIter s O* r)r_rrrrobjectr rf)rmrrr>rr?make_nditer_clsi s    ,Yrcs$|jGfdddt|}|S)zr Return the Structure representation of the given *nditerty* (an instance of types.NumpyNdIndexType). cs(eZdZdZfddZfddZdS)z%make_ndindex_cls..NdIndexIterz, .ndindex() implementation. c s|tjd}tj||j|tjd}t|tj}tD]7}t |||}| ||||} | d| |} t || | tj |Wdn1sRwYq ||_||_t|||j|_dSNrr@r)rrryr rKr7rror6rXrrrrqrrrZrU) rMrkr9rrrrr8rvrj dim_is_emptyr_r>r?rs&   z3make_ndindex_cls..NdIndexIter.init_specificc s|tjd}d}tj}t|| d |Wdn1s1wYfddt D}|D]}t |qD| t||j| dtj} t|| jj ||dS)NrrFc s"g|] }tj|qSr>)r:r rXrrr8r9rMr>r?rs   zKmake_ndindex_cls..NdIndexIter.iternext_specific..T)rrryr;r rr:rrrrIr6rCrrZr7rrUrxrrJ) rMrkr9rrrurrr:rUrrr?rs,         z7make_ndindex_cls..NdIndexIter.iternext_specificN)r`rarbr5rrr>rr>r? NdIndexIters r)r_r rf)rmrr>rr?make_ndindex_clss7rcsXdvsJ|j}|jdkrGfdddt|}|SGfdddt|}|S)N)rerkrcs8eZdZdZfddZfddZddZdd Zd S) z6_make_flattening_iter_cls..CContiguousFlatIterzZ .flat() / .ndenumerate() implementation for C-contiguous arrays. c s|tjd}t|||_|j|_dkr?tj||j |tj|j d}t |j D]}t |||}| ||q*||_dSdS)Nrrkr@)rrryr rrrrrKr7r_r6rXrr) rMrkr9rrrrr8rvr8r>r?rs zD_make_flattening_iter_cls..CContiguousFlatIter.init_specificcs|j}|j}|j}d||} || t| W|j |g} t ||| } dkr8| | n(|j fddt |D} t| } | t| | gt|||t|}||jWddS1sxwYdS)Nrrec rr>rrrr>r?r&   z\_make_flattening_iter_cls..CContiguousFlatIter.iternext_specific..)r_rr:rrrr rprrrsrrr6rZmake_anonymous_structryrr)rMrkr9rrrr_rrrr[ridxvalsidxtuplerrr?rs4      "zH_make_flattening_iter_cls..CContiguousFlatIter.iternext_specificcSs||j|g}t||||Sr)rrrsrMrkr9rrrr[r>r>r?r4sz>_make_flattening_iter_cls..CContiguousFlatIter.getitemcSs$||j|g}t|||||dSr)rrrvrMrkr9rrrrr[r>r>r?setitem8sz>_make_flattening_iter_cls..CContiguousFlatIter.setitemN)r`rarbr5rrrrr>rr>r?CContiguousFlatIters    rcs<eZdZdZddZfddZddZdd Zd d Zd S) z+_make_flattening_iter_cls..FlatIterz Generic .flat() / .ndenumerate() implementation for non-contiguous arrays. It keeps track of pointers along each dimension in order to minimize computations. c Ss|tjd}|j}|j}t||j|}tj||j |tj|jd} tj||j |tj|jd} t |tj } t |D]D} t || | } t || | }|||||| || }|d||}t|||tj| Wdn1s}wYq>| |_| |_| |_dSr)rrryrr_r rrUrKr7rror6rXrrrrqrpointersr)rMrkr9rrrrr_rrrrr8rvptrptrrjrr>r>r?rGs>    z9_make_flattening_iter_cls..FlatIter.init_specificc sH|j}t|j|}t|j|}|j|j} |tj d} d} t |j } t| |d| Wdn1sJwY|dt| |d} | }t|||}dkrs||nfddt|D}t|}|t||gtt|D]y}t|}t |}||}||}d ||}t|C||t| |} |}t||}||t|d|D]}t| |}||q| Wdn 1swY| |qtj|j | | dS) NrrFTrArec rr>rrrr>r?rrzQ_make_flattening_iter_cls..FlatIter.iternext_specific..r)r_r rrUrrrrrryr;rr:rrrrIrXrsrr6rZrrrrrprrrqrJ)rMrkr9rrrr_rrrrru is_exhaustedZlast_ptrr[rrrr8rvr|rrrwrZ inner_dimrrr?rhsn              z=_make_flattening_iter_cls..FlatIter.iternext_specificc Ss|j}tj||j|d}tj||j|d}g} tt|D]} | |||| | ||| }q| t |||j |||j | } | S)Nr)r_r rrUrrr6rYZuremZudivreverserrr) rMrkr9rrrr_rrrr8r[r>r>r?_ptr_for_indexs z:_make_flattening_iter_cls..FlatIter._ptr_for_indexcSs ||||||}t||||Sr)rrsrr>r>r?rsz3_make_flattening_iter_cls..FlatIter.getitemcSs&||||||}t|||||dSr)rrvrr>r>r?rsz3_make_flattening_iter_cls..FlatIter.setitemN) r`rarbr5rrrrrr>rr>r?FlatIter?s !E r)rSrr rf)rhr8rSrrr>rr?rgs  DrgrecCshtt|}|||}||_||}||||dd}||||||}t||t||SNr)rN) rir NumpyFlatTyperrgrWrrr )rkr9rr flatiterclsflatiterarrclsrr>r>r?make_array_flatiters  rc CZ|j\}|\}t|}||||d}|j}||} | |||jd} ||||| |dSr)rrirSrgrr) rkr9rOrrrhrrrrrr>r>r?iternext_numpy_flatiter rc Csj|jd}|\}}t|}||||d}|j}||} | |||jd} ||||| |} t|||j| SNrr)rrirSrgrrr r) rkr9rOrrhrrrrrrrr>r>r?iternext_numpy_getitems  rc Csf|jd}|\}}}t|}||||d}|j} || } | |||jd} |||| | |||Sr)rrirSrgrrr') rkr9rOrrhrrrrrrrr>r>r?iternext_numpy_getitem_anys   rc CsF|jd}t|}||||dd}||j}||||jd}|jSr)rrirgrSrr) rkr9rOrrhrrrrr>r>r?iternext_numpy_getitem_flat s  rc Csr|j\}|\}tt|}|||}||_||}||||dd}||||||} t |||j | Sr) rrnrNumpyNdEnumerateTyperrgrWrrr r) rkr9rOrrr nditerclsrzrrr>r>r?make_array_ndenumerates  rc Crr)rrnrSrgrr) rkr9rOrrrmrzrrrrr>r>r?iternext_numpy_nditer'rrcs^fddt|j|D}ttt|}|}|||}t|j |S)zndindex(*shape)cr"r>r#)rZargtyrrr>r?r;r$z&make_array_ndindex..) rrrrNumpyNdIndexTyperrrr r)rkr9rOrrUrrzrr>rr?make_array_ndindex7s   rc s|jj}|dkr%|jdj|d}t||}fdd|D}ng}ttt |}|}| || } t |j| S)zndindex(shape)rcsg|] }|tjqSr>r#rr9rkr{r>r?rPz,make_array_ndindex_tuple..) rr_rrir rrrrrrrr ) rkr9rOrr_rrUrrzrr>rr?make_array_ndindex_tupleFs  rcCs6|j\}|\}t|}||||d}||||dSr)rrr)rkr9rOrrrmrzrr>r>r?iternext_numpy_ndindex]s rc Csn|j}|j}t|jdtjrt||d}n|dg}t|||}| ||||| }t ||||S)z nditer(...) r) rrrrrrr rrrrr ) rkr9rOrrmrrrzrr>r>r?make_array_nditeris rcCs2|j\}|\}t||||d}||||dSr)rrr)rkr9rOrrrmrzr>r>r?iternext_numpy_nditer2}srcCs4|j\}}ttdt||k}t|||j|SrS)rrrr/rr"r)rkr9rOrZarg1Zarg2rr>r>r? dtype_eq_impls rcCsbt|}|||}||j}|tjt||}|tjd}tt dd} |D]} | || } | | d}| | | | d} q*|j dkrKd} nN|jdkrp|g} t|ddD] } | || d| q[tt| } n)|jdkr|g} |ddD] } | || d| q~t| } ntd|j| ||}| |d}| | | |d} |j| d d |j|td Wdn1swY|j}||}|tj|}|||f}ttj}tt|}t ||tjtj}|!|t"||}|j#$||}|%tj}t&j'|||d }t&j'|| |d }t(||)||*||||d |S)a Utility function used for allocating a new array during LLVM code generation (lowering). Given a target context, builder, array type, and a tuple or list of lowered dimension sizes, returns a LLVM value pointing at a Numba runtime allocated array. rArr>rNrMrz3Don't know how to allocate array with layout '{0}'.Fr!)z[array is too big; `arr.size * arr.dtype.itemsize` is larger than the maximum possible size.)rr6)+rgrhrirrryrmrrr/Zsmul_with_overflowrrr_rrrYrrrGrrr"r#rZget_preferred_array_alignmentZuint32r'MemInfoPointervoidptrZTypeRefr7r$r<_call_allocatorrZ meminfo_datarr rZrrr;)rkr9rrrrdatatyperZarrlenoverflowrZ arrlen_multrZdimension_sizeZallocsize_multrriZ align_valrormipZ arytypeclassargtypesrrrZ shape_arrayZ strides_arrayr>r>r?rst              r _allocatecCs dd}|S)zTImplements a Numba-only default target (cpu) classmethod on the array type. cSs t||Sr) intrin_alloc)clsrror>r>r?rrXz _ol_array_allocate..implr>)rrrorr>r>r?_ol_array_allocatesrcCs |||S)z9Trampoline to call the intrinsic used for allocation )r)rr}ror>r>r?rs rcCs(dd}ttj}t|||}||fS)z3Intrinsic to call into the allocator for Array cSs|\}}|j|||}|Sr)rZmeminfo_alloc_aligned)rkr9r$rrrorr>r>r?rszintrin_alloc..codegen)rrrr$)rrrorrrOr>r>r?rs  rc Csdd}t|tjrd}||||tjg}nt|tjsJ|j}tj|||d}g}|D] }| ||||j |q.| |tjd} t |D])} | d|| | } t|| |j|tdWdn1slwYqH|S) z; Parse the shape argument to an array constructor. c Ss|tj}|j}t|}t|d|d>d}|j|kr&|||}|S|j|kr`|d||} |j | dd|j |t dWdn1sLwY|j|kr^| ||}|S|}|S)z0Cast src to intp only if value can be maintainedrA>Fr!)z#Cannot safely convert value to intpN)rrryrBrr/rZsextrrr"r#rtrunc) rkr9Zsrc_trrZ intp_widthZintp_irmaxvalrZ is_largerr>r>r? safecast_intps(       z#_parse_shape..safecast_intprArrr)znegative dimensions not allowedN)rrrrxryrrr rrYr7get_constant_genericr6rrr"r#r) rkr9rrurr_Z passed_shapesrrrr8Zis_negr>r>r? _parse_shapes(  rcCs*|jd}|d}|j}|t||||fS)zL Parse the arguments of a np.empty(), np.zeros() or np.ones() call. r)rrr)rkr9rOrZ arrshapetypeZarrshaperr>r>r?_parse_empty_args.s rcCsT|jd}t|tjr%t||||dd}tj||j|jd}|j |fS|j dfS)z_ Parse the arguments of a np.empty_like(), np.zeros_like() or np.ones_like() call. rrrr>) rrrrrgr rrUr_r)rkr9rOrarytyperrr>r>r?r*8s    r*cCs&t|tjrd|d}t|dS)NzIf np.z0 dtype is a string it must be a string constant.)rrZ UnicodeTyperr)fnamerirr>r>r?_check_const_str_dtypeFs   rcC"|j}||||}dd}||fS)NcS(t||||\}}t||||}|Sr)rrrrr9rOrrrrr>r>r?rQznumpy_empty_nd..codegenZ instance_type)rZty_shapety_dtype ty_retty_refty_rettyrOrr>r>r?numpy_empty_ndL rcstd||tust|tjr|jtust|rtj}nt|}t |}|dur>|dur>tj ||ddtffdd }|Sd|d|d}t |) Nrrr3c t||Sr)r)rUrirxr>r?rfrTzol_np_empty..implz.Cannot parse input types to function np.empty(rr ) rfloatrrFunction typing_keyrdoublety_parse_dtypety_parse_shaperrr)rUrinb_dtyper_rrr>r r? ol_np_emptyXs    rcCr)NcSrr)r*rrrr>r>r?rsrz$numpy_empty_like_nd..codegenr)rZ ty_prototyperrrrOrr>r>r?numpy_empty_like_ndnrrcstd|t|st|}n t|tjr|j}n|}|dur?t|tjr7|jdkr,|jnd}|j||ddnt|ddnd|d|d }t |d fd d }|S) NrrrF)rirrrz3Cannot parse input types to function np.empty_like(rr crr)r)rrir r>r?rrTzol_np_empty_like..implr) rrrrrrrirrrr)rrirrrrr>r r?ol_np_empty_likezs&     rcCr)NcSs<t|jd|||d}t||j||j|jddSr)rgrr r+rrrr)rr9rOrrr>r>r?rsz(_zero_fill_array_method..codegen)rr)rrMrOrr>r>r?_zero_fill_array_methods r _zero_fillcCr)z?Adds a `._zero_fill` method to zero fill an array using memset.cSs t|dSr)rr,r>r>r?rrTz ol_array_zero_fill..implr>)rMrr>r>r?ol_array_zero_fillr6rcCstd|tfdd}|S)NrcStj||d}||SNr)rrr)rUrirr>r>r?rzol_np_zeros..impl)rr rUrirr>r>r? ol_np_zeross  rcCtd|ddd}|S)N zeros_likecSrr)rrr)r9rirr>r>r?rrzol_np_zeros_like..implrrrr>r>r?ol_np_zeros_likes  rcCr)N ones_likecS2tj||d}|j}tt|D]}d||<q|SNrrArrrer6r)r9rirarr_flatr|r>r>r?r  zol_np_ones_like..implrrrr>r>r?ol_np_ones_likes  r&cs2td|t|st|n|dfdd }|S)Nfullcs0t|}|j}tt|D]}|||<q|Srrrrer6r)rU fill_valuerirr$r|rr>r?r'  zimpl_np_full..fullr)rrr)rUr)rir'r>r*r? impl_np_fulls  r,cCstd|ddd}|S)NrcSs0t||}|j}tt|D]}|||<q|Srr#)r9r)rirr$r|r>r>r?rr+z$impl_np_full_like..full_likerr)r9r)rirr>r>r?impl_np_full_likes  r-cCr)NonescSr!r"r()rUrirr$r|r>r>r?rr%zol_np_ones..implrrrr>r>r? ol_np_oness  r/cs4td|t|st|ntjdfdd }|S)Nidentitycs.t||f}t|D]}d|||f<q |SrS)rrr6)rrirr]r*r>r?r0s z"impl_np_identity..identityr)rrrrr )rrir0r>r*r?impl_np_identitys  r1cCrQrr>NMr>r>r?_eye_none_handler rRr5cCs$t|tjr dd}|Sdd}|S)NcS|Srr>r2r>r>r?rrRz$_eye_none_handler_impl..implcS|Srr>r2r>r>r?rrRrrr)r3r4rr>r>r?_eye_none_handler_impl s r9csf|dus t|tjrttnt|tjtjfr"tt |d|nt|ddtffdd }|S)Nrircst||}t||f}|dkr)t|||}t|D] }d||||f<q|St|||}t|D] }d||||f<q4|Sr)r5rrrr6)r3r4rriZ_Mrdr]rr>r?r#s   znumpy_eye..impl) rrrrrir  DTypeSpecrr r)r3r4rrirr>r;r? numpy_eyes   r=cCsDt|s tdt|tjr |jdvrtdddd}|SdS)N#The argument "v" must be array-like)rAr&zInput must be 1- or 2-d.rcSs*|jdkrG|j}|dt|}t||f|j}|dkr2t||D] }||||||f<q#|St||D] }||||||f<q8|S|j\}}|dkrT||}|dkr\||}tt||d}t ||j}|dkrt|D] }||||f||<qs|St|D] }||||f||<q|Sr^) r_rUr-rrrir6rrr)rrrrrr]rowscolsr>r>r? diag_impl;s2    zimpl_np_diag..diag_implr)rrrrrrr_NumbaTypeError)rrrAr>r>r? impl_np_diag2s     rCcsXt|tjs d}t|t|jtjsd}t|t|dfdd}|S)Nz5The argument "dimensions" must be a tuple of integersrcsVtjf|tjd}d}|D]}tj|tjdt||}|||<|d7}q|S)NrrrA)rrrarangerr.) dimensionsrr]r8r|r3rUr>r?rfs  znumpy_indices..impl)rrrrrrirr)rErrr>rFr? numpy_indicesYs    rGcCsBt|s d}t|t|ttjfsd}t|ddd}|S)Nr>z#The argument "k" must be an integerrc Sst|}|}t|}t|}||}t||f|j}td| }td|}t|D]}|||||||f<q/|Sr) rrrrr-rrimaximumr6) rrrZabs_krrr]jtr>r>r?rs   znumpy_diagflat..implr)rrrrrrr)rrrrr>r>r?numpy_diagflatus   rKcCs|dvsJ|dkr'd}td|D]}d|}|d|dd|d 7}qnd }td|D]}d|}|d|d d|d 7}q.t|}t|ttd |}t|S)N)rrrzv def _getitem(a, idx, axis): if axis == 0: return a[idx, ...] rA):z elif axis == z: return a[rz, idx, ...] z| def _setitem(a, idx, axis, vals): if axis == 0: a[idx, ...] = vals z: a[z, idx, ...] = vals r)r6rtextwrapdedentexecglobalsr&)r_r8rqr]lstr>r>r?"generate_getitem_setitem_with_axiss.    rRtakecs8t|rLt|tjrt|tjrddd}|St|tjr2t|tjr2|jdkdfdd }|St|tjrHt|tjtjfrJddd}|SdSdSt|tjrpt|tjrpd|j dt fdd dfd d }|St|tjrt|tjtjtjfr|j }t |d t |d dfd d }|SdSdS)NcSs.||jdks ||j krtd||S)NrAIndex out of bounds)r} IndexErrorr)r9rrr>r>r? take_impls znumpy_take..take_implrc stj|j|jd}r|}n|}t|}d}|}|D]}||jdks.||j kr2td||||<|d}q||j S)NrrrArT) rrr}rirrzrrUrrU) r9rrrZwalkeritr]rer)F_orderr>r?rVs     cSst|}t||Sr)rrrS)r9rrconvertr>r>r?rVs  rrAcsvt}d}|t|jkr|j|dksJ|jtt|jD]}|j|}||kr5t|||}|d7}q ||Sr)rrrUr6r.r)rrrrIr|r)rJr>r?_squeezes&   znumpy_take.._squeezecs@tj||f|d}|jdkr|dS|dkr||j7}||S)NrrAr)rrSr_)r9rrr)rZr>r?rVs    rrcs|dkr ||j7}|dks||jkrd|d|j}t|t|j|t|}tj||jd}tt|D]}||||}||||q6|S)Nrzaxis z) is out of bounds for array of dimension r) r_rr.rUrrrrir6)r9rrrrUrr]r)_getitem_setitemr>r?rVs r) r rrrrrrrrr_r&rR)r9rrrVr_r>)rXr[r\rZrJr? numpy_takes:         r]cGsdd|D}tdd|Drtj}|Stdd|Dr#tj}|Sttddttj}dd|D}t ||g}|S) NcSsg|] }t|tjs|qSr>r8r8r>r>r?rrz!_arange_dtype..csrrrUr8r>r>r?rrz _arange_dtype..csrr)rrFloatr8r>r>r?rrzint%srXcSsg|]}t|qSr>)rZ unliteralr r>r>r?r#) rr complex128rrrrirrr)rZboundsriZNPY_TYZunliteral_boundsr>r>r? _arange_dtypesracst|tjr |j}t|tjr|j}t|tjr|j}|dur"tj}|dur)tj}|dur0tj}t|tjrQt|tjtjfrQt|tjtjfrQt|tjtjfsSdSt|tjr`t|||n|j t dd|||fDt |ddt |ddt |dddfdd }|S)NcSrr>rUr r>r>r?rEznp_arange..rcsdurn|}durn|}durn|}|dur|nd}|dur*d|}} n||}} |dkr7td| ||} tt| j} durZtt| j} tt| | d} nt| d} t | }|}t | D] }|||||<qk|S)NrArzMaximum allowed size exceededT) rrmathceilrYr[rrrrr6)rrqrkriZ lit_startZlit_stopZlit_stepZ_step_start_stopZnitems_cZnitems_rZnitems_irrrur]Z start_valueZ step_valueZ stop_valueZ true_dtypeZ use_complexr>r?rLs(      znp_arange..implr) rrOptionalr7rrrr<rarirr)rrqrkrirr>rgr? np_arange)s>        rics|tdd||fDs dSt|ttjfsd}t|tdd||fDr2tj r.tj ntj ntj dfdd }|S) Ncsrr)rrrrWr>r>r?rorz!numpy_linspace..rTcsrrrUrWr>r>r?rvrrNcst|}|d}|d}|dkr|S|d}|dkr7||}t||}td|D] }|||||<q+n||d<|dkrC||d<|S)Ng?rrArM)rrdivider6)rrqrQrdivdeltarkr]rr>r?rOs  z numpy_linspace..linspacerR) rrrrrrrrr ZUSE_LEGACY_TYPE_SYSTEMr`Z np_complex128r)rrqrQrrOr>rr?numpy_linspacems rmc Cs0|jd}t||||dd}t||j}|j}t||||}|j} |j} |jdvs.J|j|jkrBtj || | |j |j ddnLt||j } t||j } | tj} t||| )}t||| || |j|}t||| || |j|}||||Wdn1swYt|||j|S)z Array copy. rrrrArnN)rrgr rrUrrrrZ raw_memcpyrrrrrryrrrr:r!r)rkr9rOrrrrrettyperrrrrrrrrr>r>r? _array_copys6      rocCs@t|tjsJ|jdkrdnd}|j|dd}||}|tfS)NrrF)rr)rrrrrro)rr9rrrOr>r>r?_array_copy_intrinsics rpz array.copycCrr)ror+r>r>r? array_copyrrqcCst|tjr dd}|S)NcSt|Sr)rprr>r>r? numpy_copyrCz#impl_numpy_copy..numpy_copyr)r9rsr>r>r?impl_numpy_copys rtc Cs|j}|jd}|j|ksJd|jdkr`|jdksJt||||dd}t|||}||ttjdd} | |ttjd|j f} t ||j | | |j |j |jt||||S|j|jksp|jdkry|jdvryt||||dS|jdkr|dvsJ|dkrtnt} t| ||||d} || D\} }| t||||d}|j}Wd n1swY|t||||}|j}Wd n1swYWd n1swY||j}|||||||St||||S) zd Common logic for layout conversion function; e.g. ascontiguousarray and asfortranarray rz return-type has incorrect layoutrArrrrrN)rrrr_rgrrrryrrrrrrr rrrrrblockrophir7Z add_incoming)rkr9rOr output_layoutrxrrrrUrZ check_funcr ZthenorelseZout_thenZthen_blkZ out_orelseZ orelse_blkZret_phir>r>r?_as_layout_arrays`        rycsHttjs t|jjt|jdd}||}|fddfS)NrA)rr_cst||||jdS)Nrw)ryr)rbrrr9rzr>r?rs z,_as_layout_array_intrinsic..) rrr%rRequireLiteralValuerrrr_)rr9rwrrOr>rzr?_as_layout_array_intrinsics   r|cCsHt|s tdt|tjtjfrdd}|St|tjr"dd}|S)NrcStt|Sr)rascontiguousarrayrrr>r>r?r&rmz%array_ascontiguousarray..implcSrdNrr|rr>r>r?r)rXrrrrrrrurrr>r>r?array_ascontiguousarray s  rcCsLt|s tdt|tjtjfrdd}|St|tjr$dd}|SdS)NrcSr}r)rasfortranarrayrrr>r>r?r4rmz"array_asfortranarray..implcSrd)Nrrrr>r>r?r8rXrrr>r>r?array_asfortranarray.s  rz array.astypec Cs|jd}t||||dd}t||j}|j}t||||}|j} |j} t||j} t||j} | t j } t ||| 9}t ||| || |j|}t ||| || |j|}t||||}||||j|j}t|||||Wdn1s~wYt|||j|Sr)rrgr rrUrrrrrrryrrrrsrxrirvr!r)rkr9rOrrrrrnrrrrrrrrritemr>r>r? array_astype=s0     rcCr)Nc Ss2|jd}|j}t||||dd}t|}|||}|j} t||} t|jj| } ||j |j} | | | } t || }|j |ddd}|j|t|fWdn1s\wYt ||| | g}t || g}||j|| d}t||||| |j|jd|}t|||j|S)NrrFr!z.buffer size must be a multiple of element sizerr)rrrgrrmrrr7rrZsremr Z is_not_nullrr"r#rrZZsdivrrrrrrrrr )rkr9rOrZbuftyrr\Z out_ary_tyout_aryZ out_datamodelr ll_itemsizerremZis_incompatiblerrUrrrr>r>r?ras<     znp_frombuffer..codegenr)rbufferrirxrrOrr>r>r? np_frombuffer\s $rcstd|t|tjr|jdkrd|}t||tus-t|tjr)|j tus-t |r1tj }nt |}|durEtj |dd|j dnd|d|d}t|tffd d }|S) N frombufferrz+Argument "buffer" must be buffer-like. Got rA)rir_rrz3Cannot parse input types to function np.frombuffer(rr crr)r)rrir r>r?rrTz impl_np_frombuffer..impl)rrrrrrrr r r rr rrr)rrirrrr>r r?impl_np_frombuffers0       rcPt|rtdddfdd }|St|tjr&td|dfdd }|SdS)Nrc ||Srr>r[rUriintrinsic_cfarrayr>r?rrXzimpl_carray..implcrrr>rrr>r?rrXrrget_cfarray_intrinsicrrr<r[rUrirr>rr? impl_carray   rcr)Nrcrrr>rrr>r?rrXzimpl_farray..implcrrr>rrr>r?rrXrrrr>rr? impl_farrayrrcstfdd}|S)Nc s|tjurd}nt|tjr|j}n d|d}t|dur/|dur,d}t||}n+ttjrOj}|durN||krNd|d|d}t|n dd}t|t|}|durmd|d}t|t ||}t |||}|t fS)Nz pointer argument expected, got ''z*explicit dtype required for void* argumentzmismatching dtype 'z' for pointer type 'zinvalid dtype spec 'zinvalid shape ') rrrCPointerrirrBr<rrr$ np_cfarray) rr[rUZ ptr_dtyperrir_rxrOdtype_rr>r?rs4            z0get_cfarray_intrinsic..intrinsic_cfarrayr))rrrr>rr?rsrcs<|jdd\}}|dd\}}|j}|jdvsJt|} t|} t| } t|tj r9t |} n|f}|f} fddt || D} | } g}|jdkrf| D] }| |  | |} qWnt| D] }| |  | |} qj|||j}t| || || dd| }t|j|S)zR numba.numpy_support.carray(...) and numba.numpy_support.farray(...). Nr&rcr"r>r#)rrrrr>r?rr$znp_cfarray..rr6)rrrrgrmr rrrrrrrYrrrrrhrir;rrr!)rkr9rOrrr&r[rUrrrrroffrrrrr>rr?rsJ         rcCsNt|tjr|tjt|St|tjr%|tttj|}|||fSJr) rrrrryrrrFr$)rkr9seqtyseqr!r>r>r? _get_seq_sizes   rcs2|jtjt|tjfdd}|S)zK Return a getitem() implementation that doesn't incref its result. cs$||}jrj|||Sr)rrZdecref)r9rrrkrrxr>r?wrap.s z$_get_borrowing_getitem..wrap)rirFrrr$rry)rkrrr>rr?_get_borrowing_getitem&s  rc sttj}t|dfdd}g}||}} t|D]} | dkr+||| \}} |t|| qt|S)zF Compute the likely shape of a nested sequence (possibly 0d). rcsNt|tjrt|dkrdS|d|dfSt|}|j||ffS)NrNN)rrrrrrri)rrrr9rkrr>r?get_first_item>s   z.compute_sequence_shape..get_first_item)rrryrr6rYrr) rkr9r_rrrrrinnertyinnerr]r>rr?compute_sequence_shape7s    rcs0fddfdd|||dS)z? Check the nested sequence matches the given *shapes*. csjtddS)N)zincompatible sequence shape)r"r#rr>rr>r?_failZs z#check_sequence_shape.._failc s<t|dkrdSt||}|d}d||}j|dd Wdn1s/wYt|dkrr?r^s0    "  z,check_sequence_shape..check_seq_sizeNr>)rkr9rrrr>rr?check_sequence_shapeUsrcs:fddfdd||ddS)zl Assign a nested sequence contents to an array. The shape must match the sequence's structure. c sBtjj|dd}||j}t||dSr)r rrrxrirv)rrrur[)rr9rkrrrr>r? assign_items z-assign_sequence_to_array..assign_itemc st|dkrt|tjtjfrJ|||dS|d}t|tjr[t|}t|#}|j}|||j f}|||dd||j fWddS1sTwYdSt|tjrt t|D]!} || } || } tj | } |||dd|| fqgdSJ|r)rrrrrrr r`rirr6rrry) rrrrr}rrarrr]r)assignrr9rkr>r?rs(     "  z(assign_sequence_to_array..assignr>Nr>)rkr9rrrrrrr>)rrrr9rkrrrr?assign_sequence_to_array~srcCs>t||\}}t|r|}n t|}|durdSt||dSr)r3rrrr)rrrir_Z seq_dtyper>r>r?np_array_typersrcCs0td|t|||}|||}dd}||fS)Nrc Ss|j}|j}|jd}|d}t|||||}t||ksJt|||||t||||} t||| j|| j |||t |||j| Sr) rr_rrrrrrrrr!r) rkr9rOrrr_rrrrr>r>r?rs    znp_array..codegen)rr)robjrirrOrr>r>r?np_arrays   rcCsLtd|t|stdt|st|durd}t|ddd}|S)Nrz(The argument "object" must be array-likez:The argument "dtype" must be a data-type if it is providedcS t||Sr)r)rrir>r>r?rrXzimpl_np_array..implr)rrrrrr)rrirrr>r>r? impl_np_arrays    rc Cs|d}||}|d||}||||||}||d|||d||}|j|ddd|} |j|t| fWd|S1sLwY|S)NrrrHFr!z%s(): axis out of bounds) r7rrprWrrr"r#rU) rkr9rr_rrZll_ndimZ is_neg_axisZaxis_out_of_boundsrr>r>r?_normalize_axiss     rc Cst||dks Jttj|}t||}td}t|dD])}t|} |d| |} ||} || | | || } | | t ||d| q"| |t ||d|t || |S)z Compute shape with the new axis inserted e.g. given original shape (2, 3, 4) and axis=2, the returned new shape is (2, 3, 1, 4). rArHrrrr:r rrKr6rrprWrrXrr:) rkr9 orig_shaper_rll_shtyrrr8ll_dim after_axisrr|r>r>r?_insert_axis_in_shapes    rc Cst||dks Jttj|}t||}td}td}t|dD]'} t| } |d| |} || | | || } | || t ||d| q'| |t ||d|t || |S)zD Same as _insert_axis_in_shape(), but with a strides array. rArrHr) rkr9 orig_stridesr_rrrrrr8rrr|r>r>r?_insert_axis_in_strides s"      rc Cs|j}|j}|jd}t||||dd}t|||} t||j} t||j} t||| ||} t ||| ||} t | |j | | |j |j |jd| S)z/ np.expand_dims() with the given axis. rrr)rr_rrgr rrUrrrrrrrrr)rkr9rOrrrxr_rrrrrZ new_shapesZ new_stridesr>r>r? expand_dims(s$ rcCsB|jdkr|jnd}|j|jd|d}|||}dd}||fS)NrArrcSsP|||d|jdtj}t||d|jj|}t|||||}t|||j|S)NrAznp.expand_dims) rxrrryrrr_rr )rkr9rOrrrr>r>r?rJs znp_expand_dims..codegen)r_rr)rr9rrrrOrr>r>r?np_expand_dimsDs  rcCsLt|tjsd|}t|t|tjs d|}t|dd}|S)Nz)First argument "a" must be an array. Got z(Argument "axis" must be an integer. Got cSrr)r)r9rr>r>r?r_rXz!impl_np_expand_dims..impl)rrrrrr)r9rrrr>r>r?impl_np_expand_dimsUs      rcstfddfddS)NcsX|fdd|Dfdd}ttdkr tndtj||fS)Ncs g|] }|jt|jdqS)r)rrr_rW)minimumr>r?rhrz-_atleast_nd..impl..csntt|d}fddt|D}t|dkr+|j|}n|d}t|j|S)Nrcs"g|] \}}}|||qSr>r>)rrrrxr9rk transformr>r?rnsz>_atleast_nd..impl..codegen..rA)_atleast_nd_transformr rrrrrr )rkr9rOrarrsZretsr)rrHrrrr?rjs   z*_atleast_nd..impl..codegenrAr)r$rrrZ StarArgTupleZ from_types)Z typingcontextrr)rHr)rrr?res z_atleast_nd..implcs|Srr>r)rr>r?rzsz_atleast_nd..r)rrHr>)rHrrr? _atleast_ndds rcs"tksJfdd}|S)z` Return a callback successively inserting 1-sized dimensions at the following axes. c sbtD]*}|d}|j|kr.t|}|j|jdd}t||t|||f|}|}q|S)NrAr)r6r_r rrrrr$) rkr9rrrxr]r_rZnewarrtyrHmin_ndimr>r?rs  z(_atleast_nd_transform..transform)r)rrHrr>rr?r}s rcGs"tdd|DrtddgSdS)NcsrrrrWr>r>r?rrz np_atleast_1d..rArrrrr>r>r? np_atleast_1ds rcGs$tdd|DrtdddgSdS)NcsrrrrWr>r>r?rrz np_atleast_2d..r&rrrr>r>r? np_atleast_2drcGs$tdd|DrtdgdSdS)NcsrrrrWr>r>r?rrz np_atleast_3d..rf)rrr&rrr>r>r? np_atleast_3drrc  Cst|t|krt|krt|ksJJtd} t||||} t|| j} g} |D]2} | }tt| | D]!\}\}}|d| ||}| ||}| || |||}q=| |q2| j}t||||| D]_\}}} }}|j}tj|| tj|jd}|9}t|||| ||j|}t||||}||||j|j}t||||| |j|}t|||||Wdn1swYt|||}qp| S)z2 Concatenate arrays along the given axis. rr)orderN)rr rrrrrrrr7rrprWrYrrrrrsrxrirvr)rkr9rrr arr_shapes arr_stridesrx ret_shapesrrZ ret_stridesZ copy_offsetsZarr_shrr8r}ris_axisaddendZret_datarrZarr_stZarr_datarrrrurr>r>r?_do_concatenatesL6        rc s|j}fddt||D}td||}fdd|D}fdd|D}fdd|dD} t|D]d||} | } | } fd d|d dD} | v\}}|t j | | g} || Wdn1swY|@t j }| D] }|d|| }qj|d d jtd fWdn1swYWdn1swYWdn1swYq9fdd| D} t||||||| }t||S)Nc"g|] \}}t||dqSrr4rr`r9rr>r?rr$z#_np_concatenate..np.concatenatecg|] }t|jqSr>)r rrUrrrr>r?rrcrr>r rrrrr>r?rrcsg|]}t|qSr>)r rrrr>r?rrbrrcsg|]}|qSr>r>r)r8r>r?rr{rAFr!z)r:rrr>r?r r_)r_rrr6rr7r:rrrrWrr rrrrfr"r#rrr!r)rkr9rrrxrr_rrrrZ ret_shape_ptrZret_shZ other_shapesZon_axisZ on_other_dimris_okrr>)r9rkr8r?_np_concatenates`     rc s|j}td}td}tt|} fddt||D}td||}t|dj} |ddD]A} tj} tt| j| D]1\} } | d| |} j | ddj td Wdn1sswYqGq8fd d|D}ttj|t}t}t|dD]5}t|} d ||}| |} ||||}| t|d|| t|d|q|t|d|| t|d|t|}|gt|}t|}fd dtt|D}t|dD]6}t|} d ||}||||}tt|D]}|||t||d|q6qtt|D]}|t||d|qTfd d|D}t||||||| }t||S)NrrAcrrr4rrr>r?rr$z_np_stack..np.stackrFr!)z5np.stack(): all input arrays must have the same shapecrr>rrrr>r?r.rrHcr/r>r0rz)r9rr>r?rOrbcsg|] }t|qSr>)r rr:)rrrr>r?rdr)r_r rrrrrrUrrrrrfr"r#rrr:rKr6rprWrrXr:rr!r)rkr9rrrxrr_rrZ ll_narraysrrrrZorig_shrZ input_shapesrr8rrr|Z input_stridesr]rr>)r9rkrr? _np_stacks              rcCsT|dur t|tjs dSt|d|\}}|dkrd}t|t|}t|||S)Nrrz.zero-dimensional arrays cannot be concatenated)rrrr4rrBr5r)rrrrir_rrr>r>r?np_concatenate_typerns rcCs6t|||}t|tjsJ|||}dd}||fS)Nc SsF|||d|jdtj}t||t|jdt||d|j|Sr^) rxrrryrrr rrrkr9rOrrr>r>r?rs znp_concatenate..codegen)rrrr)rrrrrOrr>r>r?np_concatenates  rcCt|tjr ddd}|SdS)NrcSrr)rrrr>r>r?rrXz!impl_np_concatenate..implrrrrrrrr>r>r?impl_np_concatenate  rcCs0|D]}|jdks|jdkrd}t|qdS)NrAr&z7np.column_stack() is only defined on 1-d and 2-d arrays)r_rrB)rkrrr9rr>r>r?_column_stack_dimss  rcCsBt|d|td\}}t|}t|||}||}dd}||fS)Nznp.column_stack)Z dim_choosercSst|jd}t||d}g}g}|tjd}t||D]:\} } | jdkr3| | | | q| jdks:J| j dd} t | | } t ||| | f|} | | | | qt|||||j|S)NrrAr&r)rrr rrrryrr_rYrrr$rrr)rkr9rOrZ orig_arrtysZ orig_arrsrrrrrr expand_sigZnewarrr>r>r?rs$        z np_column_stack..codegen)r4rr5rr)rrrir_rrrOrr>r>r?np_column_stacks rcCt|tjr dd}|SdS)NcSrrr)rrr>r>r?rrCzimpl_column_stack..implrrrr>r>r?impl_column_stack rc Cs*t||t|jdt||d|j|S)z/ np.stack() with the given axis value. r)rrrr rrrr>r>r?_np_stack_commons  rc CsVt|d|\}}tdd|Drdnd}t||d|}|||}dd}||fS) Nrcss|]}|jdkVqdS)rN)rr8r>r>r?rsz"np_stack_common..rrrAcSs,|||d|jdtj}t|||||SrS)rxrrryrrr>r>r?rsz np_stack_common..codegen)r4rrr) rrrrir_rrrOrr>r>r?np_stack_commons rcCr)NrcSrr)rrr>r>r?rrXzimpl_np_stack..implrrrr>r>r? impl_np_stackrrcCs4t|||\}}t||}t|}t|||}|Sr)r4rr5rr)rrrZndim_minrir_rrr>r>r? NdStack_typers  rcC&t|d|d}||}dd}||fS)Nz np.hstackrAcsf|jd}|dj}|dkr|tjdt||||S|dkr#dndfdd}|||||S)NrrAcstj|dSrrrrr>r?np_hstack_implrz3_np_hstack..codegen..np_hstack_implrr_rrryrr<)rkr9rOrrr_rr>rr?rs   z_np_hstack..codegenrrrrrOrr>r>r? _np_hstackrcCr)NcSrrr)rrr>r>r?rrCzimpl_np_hstack..implrrr>r>r?impl_np_hstackrrcCr)Nz np.vstackr&cSsd|jd}|dj}|dkrdd}n|dkr&|tjd}t|||||Sdd}|||||S)NrcSstt|dSrS)rrhstackrr>r>r?np_vstack_impl)rz3_np_vstack..codegen..np_vstack_implrAcStj|ddS)Nrrrrr>r>r?r2rr)rkr9rOrrr_rrr>r>r?r$s   z_np_vstack..codegenrrr>r>r? _np_vstackrrcCr)NcSrrr)rrr>r>r?r=rCzimpl_np_vstack..implrrr>r>r?impl_np_vstack:rrcCr)Nz np.dstackrfc Ss|jd}|j}|dj}|dkrdd}|||||S|dkrY|tjd}|j|jdd} tj | g|jR} t ||| ||} |tjd}t || } t ||| | f|S|dkrl|tjd}t |||||Sdd}|||||S)NrcSst|dddS)NrArM)rrrrr>r>r?rQrz3_np_dstack..codegen..np_vstack_implrArr&cSr)Nr&rrrr>r>r?rhr) rrr_r<rrryrrr$rr) rkr9rOrrrxr_rrZ stack_rettyZ stack_sigZ stack_retrr>r>r?rKs*    z_np_dstack..codegenrrr>r>r? _np_dstackFs"rcCr)NcSrrr)rrr>r>r?rsrCzimpl_np_dstack..implrrr>r>r?impl_np_dstackprrfillcCr})NcSs||dd<dSrr>)rrur>r>r? fill_impl{s zarr_fill..fill_implr>)rrur r>r>r?arr_fillxsr dotcCr})NcSrr)rr )rotherr>r>r?dot_implrTzarray_dot..dot_implr>)rr rr>r>r? array_dotrrcC"t|s td|dd}|S)NzCannot np.fliplr on %s typecSs4t|}|jdkrtd|ddddddfS)Nr&rdrM.rrr_rrrr>r>r?rs  znp_flip_lr..implrrrr>r>r? np_flip_lrrcCr)NzCannot np.flipud on %s typecSs.t|}|jdkrtd|ddddfS)NrAzInput must be >= 1-d.rM.rrr>r>r?rs  znp_flip_ud..implrrr>r>r? np_flip_udrrcsNt|tjs t|t|jtjtjd|}fdd}||fS)zY Creates a tuple of slices for np.flip indexing like `(slice(None, None, -1),) * sz` r%c sZdd}tjg}tjg|R}|tj}|}||g} ||||| } | S)NcSs*|}t|D] }t||tddd}q|S)NrM)r6r.r)length empty_tuplerr]r>r>r?rs z6_build_flip_slice_tuple..codegen..impl)rryrr$rZget_constant_undefr<) rkr9r$rrZinner_argtypesZ inner_sigZ ll_idx_typerZ inner_argsrr}Z tuple_typer>r?rs    z(_build_flip_slice_tuple..codegen) rrrrr{rrrZ slice3_type)rszrOrr>rr?_build_flip_slice_tuples   rcCs&t|tjs td|dd}|S)NzCannot np.flip on %s typecSst|j}||Sr)rr_)rslr>r>r?rs znp_flip..impl)rrrrrrr>r>r?np_flips rcCst|tjtjtjfrd dd}|St|tjrd dd}|St|tjr4t|jjtjr4d dd}|St|tj rKt dd|jDrMd dd}|SdSdS) NrcStjt|||dSr)r array_splitrrindices_or_sectionsrr>r>r?rs znp_array_split..implcSsPt|j||\}}tt|dg||g||d}tj|||dS)NrAr)divmodrUrZcumsumrr)rr!rrrrr>r>r?rs c Sspt|j}tdd|j|}g}d}|D]}t||t||}||||}q||t||t|d|SNznp.splitrr)r/r_rr.rrYrr!rZ slice_tuprprevrr|r>r>r?rs csrrrrr)rrJr>r>r?rrz!np_array_split..c Sstt|j}tdd|j|}g}d}t|D]}t||t||}||||}q||t||t|d|Sr#)r/r_rrr.rrYr$r>r>r?rs  r) rrrListTyperrZ IterableTypeZ iterator_typerrrrr!rrr>r>r?np_array_splits,        r)cCsLt|tjtjtjfrddd}|St|tjrddd}|St|||dS)NrcSrr)rsplitrr r>r>r?rsznp_split..implcSs4t|j||\}}|dkrtdtj|||dS)Nrz0array split does not result in an equal divisionr)r"rUrrr)rr!rrrr>r>r?r"srr)rrrr'rrr)r(r>r>r?np_splits    r+cCNt|tjs d}t|t|tjtjtjtjfs!d}t|dd}|S)N#The argument "ary" must be an array:The argument "indices_or_sections" must be int or 1d-arraycS"|jdkr tdtj||ddS)Nr&z3vsplit only works on arrays of 2 or more dimensionsrrr_rrr*rr!r>r>r?r= znumpy_vsplit..implrrrrrrrrrr!rrr>r>r? numpy_vsplit2    r5cCr,)Nr-r.cSs<|jdkr td|jdkrtj||ddStj||ddS)Nrz3hsplit only works on arrays of 1 or more dimensionsrArr0r1r>r>r?rQs  znumpy_hsplit..implr3r4r>r>r? numpy_hsplitFs    r7cCr,)Nr-r.cSr/)Nrfz3dsplit only works on arrays of 3 or more dimensionsr&rr0r1r>r>r?rgr2znumpy_dsplit..implr3r4r>r>r? numpy_dsplit\r6r8cCs||kS)z7 Trivial comparison function between two keys. r>r^r>r>r? default_ltvsr9FcCsr||j|f}zt|WSty8|dkr"tj||dd}|j}n|dkr0tj||d}|j}|t|<|YSw)z6 Get a sort implementation of the given kind. r+T)lt is_argsortZ is_np_arrayr,)r:r;) r`_sortsKeyErrorr+Zmake_jit_quicksortZ run_quicksortr,Zmake_jit_mergesortZ run_mergesort)r8lt_implr;keyrrr>r>r? get_sort_func}s(   r@cCs$t|tjrtSt|tjrtStSr)rrr^rrVrr9rr>r>r?lt_implementations  rAz array.sortcs8|jd}tdt|jdfdd}|||||S)Nrr+)r8r>cs |dSrr>r3Z sort_funcr>r?array_sort_implrz#array_sort..array_sort_impl)rr@rArir<)rkr9rOrrrCr>rBr? array_sorts  rDcCr)NzArgument "a" must be array-likecSs|}||Sr)rr)r9rr>r>r? np_sort_implsz"impl_np_sort..np_sort_implr)r9rEr>r>r? impl_np_sorts rFz array.argsortc s^|j\}}t|jt|jddfdd}|j|jddd}|dd}|||||S)NT)r8r>r;cs|Srr>r3rBr>r?array_argsort_implrCz)array_argsort..array_argsort_implrAr)rr@rrArireplacer<) rkr9rOrrr8rGZinnersigZ innerargsr>rBr? array_argsorts   rIcCs|j|jks |jdks J|S)Nr)rr)rkr9rrrur>r>r?array_to_arraysrJcC4dd}t||}|||||g}t|||j|S)NcSs |dSr)rSrr>r>r?rs zarray0d_to_scalar..impl)r$r<r"rrkr9rrrurrOrr>r>r?array0d_to_scalars rMcCrK)NcSs t|dSrVr rr>r>r?rrTz array_to_unichrseq..impl)r$r<r rrLr>r>r?array_to_unichrseqs rNcCr+)zR An intrinsic returning a derived array with the given shape and strides. rr9rUrr>r>r?reshape_uncheckedr0rPcsddfdd}|S)NcSst|tjotdd|DS)Ncsrrr&rr>r>r?rrz>type_reshape_unchecked..check_shape..)rrrrrUr>r>r?rs z+type_reshape_unchecked..check_shapecsJt|tjsdS|r|sdSt|t|krdS|jt|ddS)Nrr)rrrrrrOrr>r?typers z%type_reshape_unchecked..typerr>)rkrSr>rRr?type_reshape_uncheckeds  rTc Cs|jd}|j}t||||d}t|||}t||d}t||d} t||j|| |j|jd| } t |||| S)NrrAr&r6) rrrgr rrrrrrr ) rkr9rOrrrxrrrUrrr>r>r?impl_shape_unchecked s rUcs`|dtjfvrtddntdd|dtjfvr tdtddd fdd }|S) NcSr?rrQrrUr>r>r?r1%rzas_strided..get_shapecSr7rr>rVr>r>r?r1)z,as_strided() strides argument cannot be NonecSr7rr>)rrr>r>r? get_strides4rWzas_strided..get_stridescst|||||}|Sr)rP)rrUrr1rXr>r?as_strided_impl8sz#as_strided..as_strided_implr)rrr&rr)rrUrrZr>rYr? as_strided"s    r[cst|tjrtt|jdtt|jdtddn/t|tjrIt|jtjrItt|jt |tt|jt |tddnt dt |rYtddn&t|tjrftddnt|tjrzt|jtjrztd dnt d d fd d }|S)NrAcSs|fSrr> window_shaper>r>r?get_window_shapeIrz-sliding_window_view..get_window_shapecSr6rr>r\r>r>r?r^RrWz4window_shape must be an integer or tuple of integerscSs tt|Sr)rr6r]rr_r>r>r?get_axis]rz%sliding_window_view..get_axiscSstdd||gS)Nsliding_window_viewrrr_r>r>r?r`bs csfdd|DS)Ncsg|] }tdd|qS)rarrbr8rr>r?rlrz9sliding_window_view..get_axis..r>r_r>rr?r`js z2axis must be None, an integer or tuple of integersc s|}|||j}t|t|krtd}}t|jD]}t|||j|}t|||j|}q |j}t||D]7\}}|dkrItd|||krStd|||d}t|||}t|||}t|||j|}|d7}q=t|||} | S)Nz2Must provide matching length window_shape and axisrz-`window_shape` cannot contain negative valuesz4window_shape cannot be larger than input array shaperA) r_rrr6r.rUrrrP) rr]rZ out_shapeZ out_stridesr]rr8Ztrimmedrr`r^Z shape_bufferZ stride_bufferr>r?sliding_window_view_implts8     z5sliding_window_view..sliding_window_view_implr) rrrrr6r_r&rrirrrr)rr]rrdr>rcr?ra?s>           'racCr)NcSs>|jdkrtdkr dStd|jdkrt|dStd)Nr)r&r&FziThe truth value of an empty array is ambiguous. Use `array.size > 0` to check that an array is not empty.rAz[The truth value of an array with more than one element is ambiguous. Use a.any() or a.all())r}rrrrSr3r>r>r?rs  zol_bool..implrr4r>r>r?ol_bools recsnt|ttjfs tdt|ttjfstdt|tjs%td|jtt fdd}|S)Nz.The second argument "axis1" must be an integerz-The third argument "axis2" must be an integerz'The first argument "a" must be an arraycs`tdd|}tdd|}|dkr|7}|dkr|7}t||}t|||}t||S)Nz np.swapaxesaxis1axis2r)rr.rrF)r9rfrgZ axes_tupleZ axes_listr_r>r?rs   znumpy_swapaxes..impl) rrrrrrrr_rr6)r9rfrgrr>rhr?numpy_swapaxess     ricCstdd|j|}t|j}d||<tt||jD]$\}\}} |dkr&| } n| dkr-|} n || kr5td|} t||| }qt|||j|} t || }t ||}|} t |dkrmt t | D] }t| ||j|} qa|} t |dkrt t | D]}t| ||j|d|} q{|j|}t | |f| |j }tdddf}t| D]1}t| D])}||||}||||}||||}t |D] }|||||<qqq|S)Nznp.take_along_axisrrAz*`arr` and `indices` dimensions don't matchr)rr_rrUrrrr.rrrr6rrirr)rrrZNi_origZNk_origindices_broadcast_shapeZ arr_shaper]Zd1Zd2new_valZarr_broadcast_shapeNiNkJrZnp_s_iikkZa_1dZ indices_1dZout_1drIr>r>r?_take_along_axis_implsT        rqcst|tjs tdt|tjstdt|jtjs"tdt|r)d}n|j}||jkr6tdt t |jt|rIfdd}|St |dt|tj sYt d |j}|d kre|j|}|d ksn||jkrst d t t |t t |d|jfd d}|S) Nz)The first argument "arr" must be an arrayz.The second argument "indices" must be an arrayz'The indices array must contain integersrAz;`indices` and `arr` must have the same number of dimensionscst||dddS)Nrr>)rqrrrr)rjr>r?take_along_axis_impl#sz1arr_take_along_axis..take_along_axis_implrzaxis must be a literal valuerzaxis is out of boundscst|||Sr)rqrrrlrmrjr>r?rs4s )rrrrrrirrr_rr6rrrjr)rrrZarr_ndimrsr>rtr?arr_take_along_axiss>           ruTcCst|tjr2t|tjrd dd}|St|tjr d dd}|St|tjr-d dd}|Stdt|ret|j tjrDd dd}|St|j tjrRd d d}|St|j tjr`d d d}|Stdtd ) NTrvcSr6rr>rrnanr>r>r?r?rRznan_to_num_impl..implcSsFt|r|St|rtt|jSt|r!tt|jS|Sr)risnanisneginffinfor7risposinfrrwr>r>r?rCs   cSs*tj|j|d}tj|j|d}t||S)N)rx)r nan_to_numrYr[complex)rrrxrrbr>r>r?rLs z4Only Integer, Float, and Complex values are acceptedcSr6rr>rwr>r>r?rXrRc Sst|jj}t|jj}t|}|rt|n|}|j}t|j D]%}t ||r2|||<q$t ||r>|||<q$t ||rI|||<q$|Sr) rr{rirrrrrer6r}ryrzr|) rrrxZmin_infZmax_infx_outputZ output_flatr]r>r>r?r[s   cSsDt|}|r t|n|}tj|jd|dtj|jd|d|S)NF)rrx)rrrr}rYr[)rrrxrrr>r>r?rls z4The first argument must be a scalar or an array-likeTrv) rrrrr^rVrrrri)rrrxrr>r>r?nan_to_num_impl:s6   ; 7 . "   rrrRrrr)Frr(r5rrcrrMZllvmliterZ llvmlite.irrnumpyrZnumbarrZ numba.corerrrr r r Znumba.np.numpy_supportr r rrrrrrrrrrrZnumba.core.imputilsrrrrrrrr r!r"r#Znumba.core.typingr$Znumba.core.typesr%Znumba.core.extendingr&r'r(r)r*Z numba.miscr+r,Z numba.cpythonr-Znumba.cpython.unsafe.tupler.r/r0Znumba.core.typing.npydeclr1rr2rr3r4r5r@rCrgrmrsrvrrrrrrrrrrZ ArrayIteratorZBORROWEDrrrr rrrr rrrAnyrrrrr$r(rr*r7rPrYr]rirsrrrrrrrrrrrrrrrrrZbroadcast_shapesrrrrrrrr)r,r.r?ZVarArgrBrFrKr*r]rSZ geomspacercZrot90rkrsrwr{r|rrresizerrYrrrrrrrrrrrrUrr}runiquerrrrrrrrr<rrZ MemoryViewrrrrrr r rrrrrrrrrrr!rr"r#r)r,r'r5r7ZDTypeZ NumberClassr9r@rAr=rHrIrLrrMrSrTrWr[Bytesr]is_rarcrirnrxryrrrgrrrrrrrkrrrrrrrrrzrZNumpyNdIterTypereqrrrrrrrr*rrrr rrrrrrrrrrr r&r'r,rr-r.r/r0r1r5r9eyer=ZdiagrCrrGZdiagflatrKrRrSr]rarDrirOrmrorprqrrtryr|r~rrrrrrrrrrrrrrrrrrrrrrrrrrrrZ atleast_1drZ atleast_2drZ atleast_3drrrrrrrrrrZ column_stackrrrstackrrrrrrZvstackrZ row_stackrZdstackrr rrhrrirrfliprrr)r*r+Zvsplitr5Zhsplitr7Zdsplitr8r<r9r@rArDrrFZargsortrIrJZUnicodeCharSeqr^rVruZ NPTimedeltaZ NPDatetimerMrNrPZ type_callablerTrUlibZ stride_tricksr[rarrergrirqZtake_along_axisrur}rr>r>r>r?s   04     <    E      D    (    22=QE+ *   =%    *  ( 9      6   L$ @     .          y~    ,      +  $                                       7  7'       "  J A X         O  0               &  # Z  C*%  A   +$4 ))      =2Y   %       )      >          ^  ; +