:j7 1dZddlZddlZddlZddlZddlmZddlmZddl Z ddl m Z m Z ddlmZmZmZmZmZddlmZmZmZmZmZmZmZmZmZmZddlmZm 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.m/Z/dd l0m1Z1dd l2m3Z3m4Z4m5Z5m6Z6m7Z7dd l8m9Z9m:Z:ddl;mZ>m?Z?ddl@mAZAmBZBddl2mCZCddlDmEZFmGZHmIZImJZJmKZKdZLdZMdZNdZOdZPdZQdZRdZSdZT dYdZUdZVdZWe4eWdZXd ZYe4eYd!ZZe#d"ejd#Z\d$Z]e#d%eje)e-jd&Z` dYd'Zad(Zbd)Zce#ejejeje#ejejeje#ejejejd*Zhe#ejejejd+Zje#ejejejejd,Zme#enejd-Zoe#d.ejd/Zqe!d0kr$e#d1ejejd2ZrGd3d4esZtGd5d6etZuGd7d8etZvGd9d:etZwGd;detZyGd?d@esZzdAZ{e#ejejejdBZ|dCZ}dDZ~dEZdFZdGZdHZdIZdJZe6dKZe6dLZe3dMZdNZe4e jdOZe3dPZe4e jdQZe4e jdRZdSZe4edTUdVZe4edWUdXZdYZdZZe#d[ejd\Zd]Ze#d[ejejd^Ze#d[ejej0ejd_Ze4e j4dYd`Ze$ejdadbZe4e j:dZdcZe4e j>dZddZe4e jBd[deZdfZdgZe#dhejejdiZe#dhejej0ejdjZe!dkkre4e jNdlZne4e jNdmZe4e jRdnZe4e jVdYdoZe#dpejdqZe#e j\ejdrZe#dsejdtZe3duZe3dvZe4e jfdYdwZe5ejdxd\dyZdzZe4e jnd{Ze4e jrd|Ze4e jvd}Ze4e jzd~Ze3dZejjejddZe6dZdZe4edTUdZe#dejejdZe$ejddZe$ejde$ejddZe$ejde$ejddZe$ejde$ejddZe$ejddZe$ejde$ejddZe$ejde$ejddZe$ejddZe$ejddZe$ejddZe$ejddZe$ejddZe$ejddZe'ejeje'ejejdZdZe$ejddZe$ejde$ejddZe$ejddZe$ejddZe$ejddZdZe5ejde5ejddZdZe$ejdee$ejdee#dejejdZe%ejdZe#dejejbdZe%ejdZe&ejdZe#dejejbdZe#dejejdZe#dejejbejdZe#dejejejdZe(ejdZe(ejdZe(ejdZe#ejejejdZe7ejdd„ZdÄZdĄZ d\dńZ dYdƄZdDŽZdȄZdɄZe$ejdʫd˄Ze#d%eje)e-jd̄Ze#ejejejd̈́Ze#ejejejejd΄Ze#enejdτZe#e jejdЄZe#d%ej e)e-jdфZe#e ej0eje#e jej0ejd҄Ze#e eje#e jejdӄZ e#d%eje)e-jdԄZ e#e jejdՄZ e#d%eje)e-jdքZe#ej ejejdׄZd؄ZeCejddWUdڄZdۄZe6d܄Zd݄ZdބZd߄ZdZe6dZe4e j6efdZe6dZe4e j>dYdZ e6dZ!e5ejddZ"e4e jFefdZ$e4e jJdYdZ&e4e jNdYdZ(e4e jRdYdZ*e4e jVdYdZ,e4e jZdYdZ.e4e j^dYdZ0dZ1ejhe1dZ2ejhe jfddefdZ4e4e jjd]dZ6e4e jndZ8e4e jrd]dZ:dZ;e4e jxe5ejddYdZ=dZ>e4e j~d\dZ@e4e jdZdZBdZCe6dZDe#dejdZEe4e jdZGdZHe6dZIe4e jdZKe4e jdZMe#dejeje#dejejbdZNe6dZOe5ejddZPe6d ZQe4e jed dfd ZSe4edYd ZTe4edYd ZUdZVdZWdZXdZYdZZdZ[dZ\dZ]e6dZ^e4e jdYdZ`dZadZbdZcdZde6dZee4e jdZfdZgdZhe4e jd Zje4e jd!Zle4e jd"Znd#Zod$Zpd%Zqd&Zre6d'Zse4e jd]d(Zud)Zve6d*Zwe4e jd+Zyd,Zze6d-Z{e4e jd]d.Z}d/Z~e6d0Ze4e jd1Ze6d2Ze4e jd3Ze!d0k\re4e j ee6d4Ze4e jd5Zejjejd6d7Zejjejd8d9Ze4e jd:Ze4e jd;Ze6d<Ze4e j d=Ze4e j$d]d>Ze4e j(d]d?Ze4e j,d@Ze4e j0dAZe4e j4dBZiZdCZd^dDZdEZe#dFejdGZe4e jBdHZe#dIejejbe#e jFejejbdJZe'ejejdKZe'ejejLe'ejejNe'ejeje'ejejPe'ejejRe'ejejTe'ejejVdLZe'ejejLdMZdNZej^edOZe#eejejejdPZejhe jdjfjhd_dQZejhe jdjfjjdYdRZe4edSZe4e jpdTZe4e jtdUZe3dVZe4e jzdWZe4e j~d`dXZy(az[ Implementation of operations on Array objects and objects supporting the buffer protocol. N)ir)Constant)pndindexliteral_unroll)typestypingerrorscgutils extending) 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)_make_constant_bytes bytes_type) tuple_setitembuild_full_slice_tuple)overload_classmethod) parse_dtype parse_shape_parse_nested_sequence_sequence_of_arrays_choose_concatenation_layoutct|j|t|j|g}|jj|}|j d|y)zz Set the "range" metadata on a load instruction. Note the interval is in the form [lower_bound, upper_bound). rangeN)rtypemodule add_metadata set_metadata)builderload lower_bound upper_boundrange_operandsmds f/home/mcse/projects/srt_converter/srt-converter-venv/lib/python3.12/site-packages/numba/np/arrayobj.pyset_range_metadatarE.sK tyy+6tyy+68N  $ $^ 4Bgr"c^d|jjdz zdz }t||d|y)zF Mark the result of a load instruction as positive (or zero). rN)r:widthrE)r>r?rAs rD mark_positiverJ9s.1,-2Kwa5rFcjtjjGfddS)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). c<eZdZfdZefdZxZS)make_array..ArrayStructcdt } |jjd|}|jj }|j|}|#tj|j|d}n|}||j|f}||fS#t$rt||cYSwxYw)N __array__T)zfill) r$_context get_functionNotImplementedErrorsuper _make_refsdata_model_manager _get_be_typer alloca_once_builder) selfrefsig array_impl datamodelbe_type outer_ref ArrayStruct __class__ array_typereal_array_types rDrUz*make_array..ArrayStruct._make_refsOsOZ8C @!]]77 SI  88DI'' 2G{#// w6:<  T]]YL9Cc> !' @[$:3?? @sBB/.B/cH|j}dk(rj|dS|jd}g}tD]H}t j ||d|}|j |}|j|t||Jt j||S)z\ Override .shape to inform LLVM that its elements are all positive. rshape) rY __getattr___get_ptr_by_namer9r gep_inboundsr?appendrJ pack_array) rZr>ptrdimsidimptrr?basendims rDrfz%make_array..ArrayStruct.shapecs mmGqy''g66 ''0CD4[ - --gsAqA||F+ D!gt,  - %%gt4 4rF)__name__ __module__ __qualname__rUpropertyrf __classcell__)rbrarcrprqrds@rDrarMMs "(  5  5rFra)as_arrayr create_struct_proxyrq)rcrarprqrds`@@@@rD make_arrayryAsE!))O  & & 7D   D+5+5d+5Z rFcZ|j|j}|j|S)zB Return the item size for the given array or buffer type. ) get_data_typedtypeget_abi_sizeof)contextrclltys rD get_itemsizer}s+  !1!1 2D  ! !$ ''rFc`|jrdnd}|j||j||S)z3 Load the item at the given array pointer. NrHalign)aligned unpack_valuer|)r~r>arraytyrlrs rD load_itemrs6OODE   &+  --rFcb|jrdnd}|j||j|||S)z4 Store the item at the given array pointer. NrHr)r pack_valuer|)r~r>rvalrlrs rD store_itemrs1OODE   gw}}c3e  LLrFc|jr;|j|||tj}t j |||}|S|j|||tj }|S)zM Fix the integer index' type and value for the given dimension size. )signedcastrintpr- fix_indexuintp)r~r>idxtyidxsizeinds rDfix_integer_indexrs] ||ll7C ;d3 Jll7C < JrFct|tjrn|jdk(r_t|jtj sJt ||||}t||||j}|j|fS||fS)zS Normalize the index type and value. 0-d arrays are converted to scalars. r) isinstancerArrayrqr|Integerryrdata)r~r>rridxaryidxvals rDnormalize_indexrsv%%%**/%++u}}555"E"7GS97GUFKK@{{F""czrFc t|r4tt||Dcgc]\}}t||||c}}\}}||fScc}}w)z^ Same as normalize_index(), but operating on sequences of index types and values. )lenzipr)r~r> index_typesindicesrrs rDnormalize_indicesrs[  7|"7:;7P%')3&5Wgu58&:%' ( W   %'sA c"|j}|j}|j} tjtj dd} |j | } t| j} t| j} | | z| k7r6| | z }d|jdt|dkDrdndd|d}t||*t|j| jd d }|jtj}t!|t"t$frt'j(|||}t!|t"t$frt'j(|||}t!|t*r||}t-||||| }|.t|j| jd d |d <n||d <|j/tjd}t'j0|||j2j4}|D]}|j7||d g}||d<t|j9}|| k7rtdj;| |z |j=D]\}}t?||||S)z Helper function for populating array structures. This avoids forgetting to set fields. *shape* and *strides* can be Python tuples or LLVM arrays. rHCzThe datamodel for type z is missing fields .Nmeminfo)rfstridesritemsizerparentnswflagsnitemsz missing {0}) rQrY _datamodelrrfloat64rVset_fields_fe_typer ValueErrorrget_value_typeget_typerrtuplelistr rkintdict get_constant unpack_tupler:countmulkeysformatitemssetattr)arrayrrfrrrrr~r>r^standard_arraystandard_array_type_datamodelrequired_fieldsdatamodel_fieldsmissingmsgintp_tattrsrunpacked_shapeaxlen got_fieldskvs rDpopulate_arrayrs{nnGnnG  I[[37N$+$>$>~$N!7??@O9,,- **>!$44((89!'lQ.sB7q Do711   y )+,02 # #EJJ /F%%'""7E6:'E4=)$$Wgv>(C (# u "  #E~"7#9#9   x ($*+/1h!h  ! !%**a 0F))'5%**:J:JKN;VU5':;E(OUZZ\"J_$--o .JKLL 1q! LrFcn|j}|j}|jtjd}t j ||j|j}|D]}|j||dg}||_ |jtjt|||_ y)z Update some auxiliary information in *array* after some of its fields were changed. `itemsize` and `nitems` are updated. rHrrN) rQrYrrrr rrfrqrrrr)arytyrr~r>rrrs rDupdate_array_infors nnGnnG ! !%**a 0F))'5;; KN;VU5':;EL))%***6w*FHENrFct)z/Constrain axis values to valid positive values.rS func_namearg_namerqaxiss rDnormalize_axisr  rFct|tstjdt|tstjd|jd|jdfd}|S)N func_name must be a str literal.arg_name must be a str literal. : Argument * out of bounds for dimensions of the arraycF|dkr||z }|dks||k\r t|SNrr)rrrqrrs rDimplz&normalize_axis_overloads..impl%s/ !8 DLD !8tt|S/ ! rF)rr%r TypingError literal_value)rrrqrrrs @rDnormalize_axis_overloadsrsr i /  !CDD h .  !BCC  " " #;x/E/E.FG4 4  KrFct)zFNormalizes an axis argument into a tuple of non-negative integer axes.rrs rDnormalize_axis_tupler0rrFct|tstjdt|tstjd|jd|jd|jd|jdt|t j rfd}|St|dzfd }|S) Nrrrrz: repeated axis in z argumentcH|dkr||z }|dks||k\r t|fSrr)rrrqrinvalid_axis_msgs rDrz,normalize_axis_tuple_overloads..implHs3ax ax44< !1227NrFrc }t|D]1\}}|dkr||z }|dks||k\r tt|||}3tt |k7r t |Sr) enumeraterr0rr) rrrqr norm_axisrnaxaxis_lenrnorm_axis_initrepeated_axis_msgs rDrz,normalize_axis_tuple_overloads..implTs{&I"4 <26$JB6R4Z$%566))Q;  <3y>"h. !233 rF)rr%r rrrrr) rrrqrrrrrrs @@@@rDnormalize_axis_tuple_overloadsr5s i /  !CDD h .  !BCC  " " #;x/E/E.FG4 4  " " ##6  ! ! ") - $ & 4 K#t9  KrFgetiterc|j\}|\}|j||j}|jtj d}t j||}||_||_ |jr|jj||||j} t|||j| } | Sr)args make_helper return_typerrrr alloca_once_valueindexr enable_nrtnrtincref _getvaluer!) r~r>r\rrriterobjzeroindexptrresouts rD getiter_arrayr esIWGU!!'3??;G    A .D(($7HGMGM 7GU3    C 7GS__c BC JrFc tj||j|j}tj||j|j}|j |d|}tj ||j|} |dd} |dd} t|tjr"t|||||| | | } | jS| rJt|||| S)z1 Evaluate `ary[idx]`, where idx is a single int. rrrHN)r rrfrqrr pointer_addrrrBuffer make_viewrr) r~r>rraryrshapesroffsetdataptr view_shapes view_stridesretarys rD_getitem_array_single_intr}s ! !'399EJJ GF""7CKKuzzJG [[S )F!!'388Vr\rresultitertyiterrrrrris_validrnindexs rDiternext_arrayr*sxxHV FTG!!'6!>G *W gwgmm DC""7CIIQ?GF LL 'E""3v6H X  "-) Wf//#u   e((%8 fgmm, ---s AD,,D5c |jtjd}|jtjd}tj||j |j } tj||j|j } g} g} g} t|Dcgc]}t|s|c}}d}t||D]\}}|tjurm|j t|z dz|z}t|D]@}| j|| j| || j| ||dz }Bt|tjr|j!|||}t#j$||||t#j&||| || j|j(t#j*||}t#j,||| |}| j|| j|nt|tj.rBt1||||| |}|rtj2|||| ||| j|nAt|r(| j|| j||dz}nt5d||dz }||j ksJ||j kr=| j| || j| ||dz }||j kr=tj6||||| dd}|| | fScc}w)z Perform basic indexing on the given array. A (data pointer, shapes, strides) tuple is returned describing the corresponding view. rrHrunexpected index type: F wraparound boundscheck)rrrr rrfrqrrrrellipsisr9rjr SliceTyperr-guard_invalid_slice fix_slicestartget_slice_length fix_striderrdo_boundscheckrSget_item_pointer)r~r>rrrrr/ronerroutput_indices output_shapesoutput_stridesr num_newaxesrindexvalr n_missingrnsliceshstrrs rDbasic_indexingrCs    A .D   uzz1 -C  ! !'399ejj AF""7CKKDGNMNkFs[5EsFGK Bw 4 % ENN " S\1A5 CI9% %%d+$$VBZ0%%gbk2a    eU__ -''h'GE  ' '% G   gufRj 9  ! !%++ .))'59B##GUGBK@B   $  ! !" % u}} -#GWeX$*2J0C&&wfRj"M  ! !# &     %  ! !$ ' !GB%U&LM M aA F    uzz/VBZ(gbk* a uzz/&&w'527ULG ]N 33aGs &M7Mc t|||}t|||||j|j|j|S)zF Build a view over the given array with the given parameters. rrfrrrr)ryrrrr) r~r>rrrrrrrs rDrrsF %Z $Wg 6F6"LL;;** & MrFc t|||||||j\}}} t|tjr"t |||||||| } | j S|rJt||||S)zp Return the result of indexing *ary* with the given *indices*, returning either a scalar or a view. r/)rCenable_boundscheckrrrrrr) r~r>rrrrrrrrrs rD_getitem_array_genericrIs w['#*#=#= ?'G[,+u||,7GUC"K?!!'5'::rFc |j\}}|\}}t|tjs|jdk\sJt ||||}t |||j|||f|f}t|||j|S)z9 Basic indexing with an integer, slice, or None. rH) rrrNoneTyperqryrIrr r~r>r\rrrrrr s rDgetitem_arraynd_intprMs88LE5HC eU^^ ,zzQ *U GWc 2C '3??!&eXv ?C Wgs DDrFc z|j\}}|\}}t||||}|j}tj||t |} t |||| \}} td|Drt|||||||| St|||j|||| } t|||j| S)z2 Basic or advanced indexing with a tuple. r c3PK|]}t|tj ywNrrr).0tys rD z&getitem_array_tuple..:s =2:b%++ & =$&) rryrr rrrany fancy_getitemrIrr ) r~r>r\rrtuptyrtuprrr s rDgetitem_array_tuplerZ+s 88LE5HC *U GWc 2C++K""7Cs5zBG,Wg-8'CK = ==WgsD"Cg? ? !'3??!&[' CC Wgs DDrFc  |j\}}}|\}}} t|tjr.|j} t j ||t |} n|f} |f} t||||}t||| | \} } t||||| | |j\} } }t| }|rt||||| | S|j|| ||j} t!||||  y#t$rd}YMwxYw)zH array[a] = scalar_or_array array[a,..,b] = scalar_or_array r rGTN)rrr BaseTupler rrryrrCrHboolrSfancy_setslicerr|r)r~r>r\rrrvaltyrrrrrrrruse_fancy_indexings rD setitem_arrayraDs& ((E5%MCc%)kk &&w3u:Fh & *U GWc 2C-Wg-8'CK* 7GUCg'.'A'A C ! "&\gwT)74 4 ,,wUEKK 8CwW5 "!"s C55 DDc|j\}|\}t|}||||}|j}|j|d}t |||j |Sr)rryrf extract_valuer"r) r~r>r\rrrarysttyshapearyr s rD array_lenrfms\xxHU FSG '7C (CyyH   ! ,C gw EErFz array.itemc l|j\}|\}t||||}|j}|j|j d||j dd5d}|j j|t|fdddt||||jS#1swY!xYw)N!=rHFlikelyz>item(): can only convert an array of size 1 to a Python scalar) rryrr rr: call_convreturn_user_excrrr)r~r>r\rrrrrs rD array_itemrmxs XXFE DC *U GWc 2C ZZF ,,T66;;q>J %  'GN))':vFG Wguchh 77 GGs %%B**B3rz array.itemsetc |j\}}|\}}||jk(sJt||||}|j}|j |j d||j dd5d} |jj|t| fdddt|||||j|jS#1swY2xYw)NrhrHFriz/itemset(): can only write to an array of size 1) rr|ryrr rr:rkrlrrrget_dummy_value) r~r>r\rrr_rrrrs rD array_itemsetrrsxx uS ###j#6 __W00vv{{1~N$)+ KCC    - -gzC6 J K 7GUC:&&((  K Ks 8%CCc4eZdZdZdZdZdZdZdZdZ y) Indexerzq Generic indexer interface, for generating indices over a fancy indexed array on a single dimension. ct)ze Prepare the indexer by initializing any required variables, basic blocks... rrZs rDpreparezIndexer.prepare "!rFct)z= Return this dimension's size as an integer. rrvs rDget_sizezIndexer.get_size "!rFct)z; Return this dimension's shape as a tuple. rrvs rD get_shapezIndexer.get_shaper{rFct)z} Return a half-open [lower, upper) range of indices this dimension is guaranteed not to step out of. rrvs rDget_index_boundszIndexer.get_index_boundsrxrFct)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. rrvs rD loop_headzIndexer.loop_heads "!rFct)z) Finish indexation loop. rrvs rD loop_tailzIndexer.loop_tailr{rFN) rrrsrt__doc__rwrzr}rrrrFrDrtrts% "" " " ""rFrtc:eZdZdZdZdZdZdZdZdZ dZ y ) EntireIndexerz: Compute indices along an entire array dimension. c||_||_||_||_||_|jj t j|_yrP) r~r>rrdimrrrll_intp)rZr~r>rrrs rD__init__zEntireIndexer.__init__s?   ||225::> rFc$|j}|j|jj|j|_t j||j|_ |j|_ |j|_ yrP) r>rcrrfrrr rXrrappend_basic_blockbb_startbb_endrZr>s rDrwzEntireIndexer.preparesc,,))$((..$((C (($,,? 224 002 rFc|jSrPrrvs rDrzzEntireIndexer.get_sizes yyrFc|jfSrPrrvs rDr}zEntireIndexer.get_shapes |rFc<|jd|jfSrrrrvs rDrzEntireIndexer.get_index_bounds Q++rFc|j}|jjt|jd|j|j |j |j|j |j|j}|j|jd||jd5|j |jddd||fS#1swY||fSxYwNr>=Fri) r>r$rrrbranchrposition_at_endr?r rrr)rZr> cur_indexs rDrzEntireIndexer.loop_heads,, 8DLL!4djjAt}}% .LL, __W00y$))L$)+ ( NN4;; ' ()## ()##s C..C:c|j}tj||j|j}|j ||j|j |j|j|jyrP) r>r r#r?rr$rrrrrZr> next_indexs rDrzEntireIndexer.loop_tails^,,,,Wgll4::6NO  j$**-t}}% ,rFN rrrsrtrrrwrzr}rrrrrFrDrrs*?3, $-rFrc:eZdZdZdZdZdZdZdZdZ dZ y ) IntegerIndexerz0 Compute indices from a single integer. c||_||_||_|jjtj |_yrP)r~r>rrrrr)rZr~r>rs rDrzIntegerIndexer.__init__s1  ||225::> rFcyrPrrvs rDrwzIntegerIndexer.prepare  rFc.t|jdSNrH)rrrvs rDrzzIntegerIndexer.get_sizes a((rFcyNrrrvs rDr}zIntegerIndexer.get_shapesrFc|j|jj|j|jfSrP)rr>addrzrvs rDrzIntegerIndexer.get_index_boundss,$,,**488T]]_EFFrFc|jdfSrP)rrvs rDrzIntegerIndexer.loop_headsxx~rFcyrPrrvs rDrzIntegerIndexer.loop_tailrrFNrrrFrDrrs+?  )G rFrc:eZdZdZdZdZdZdZdZdZ dZ y ) IntegerArrayIndexerz; Compute indices from an array of integer indices. c||_||_||_||_||_|j dk(sJ|jj tj|_ yr) r~r>rrrrqrrrr)rZr~r>rrrs rDrzIntegerArrayIndexer.__init__%sO     zzQ||225::> rFc|j}tj||jjd|_tj ||j|_|j|_ |j|_ yr) r>r rrrfidx_sizerXr idx_indexrrrrs rDrwzIntegerArrayIndexer.prepare.sf,,,,Wdkk6G6GHK  ,,WdllC224 002 rFc|jSrPrrvs rDrzzIntegerArrayIndexer.get_size5s }}rFc|jfSrPrrvs rDr}zIntegerArrayIndexer.get_shape8s rFc<|jd|jfSrrrvs rDrz$IntegerArrayIndexer.get_index_bounds;rrFc|j}|jjt|jd|j|j |j |j|j |j|j}|j|jd||jd5|j |jdddt|j||jj |j|j"|}t%|j||jj ||j&}||fS#1swYxYwr)r>r$rrrrrrr?r rrrrr~rr|rrr)rZr>rrs rDrzIntegerArrayIndexer.loop_head?s,, 8DLL!4dnnEt}}% .LL0 __   i ?  ( NN4;; '  ( * LL'4::#3#3TZZ  "$,,"&**"2"2E499Fi ( (s E''E0c|j}tj||j|j}|j ||j|j |j|j|jyrP) r>r r#r?rr$rrrrrs rDrzIntegerArrayIndexer.loop_tailTsb,,,,W-4\\$..-IK  j$..1t}}% ,rFNrrrFrDrr s*?3 , *-rFrc:eZdZdZdZdZdZdZdZdZ dZ y ) BooleanArrayIndexerz> Compute indices from an array of boolean predicates. c||_||_||_||_|jdk(sJ|jj t j|_t|jd|_ yNrHr) r~r>rrrqrrrrrr)rZr~r>rrs rDrzBooleanArrayIndexer.__init__bsZ    zzQ||225::> T\\1- rFc|j}tj||jjd|_tj ||j|_tj ||j|_ |j|_ |j|_ |j|_ yr)r>r rrrfrrXrrrrrbb_tailrrs rDrwzBooleanArrayIndexer.prepareks,,(($++2C2CDQG  ,,WdllC(($,,? 224 113 002 rFc |j}tj||j}tj||j 5}|j |}t|j||jj|j|j|j}|j||j||j}|j!||ddd|j |S#1swYxYwrP)r>r rr for_rangerr?rr~rr|rrrzextr:r$)rZr>rloopcpreds rDrzzBooleanArrayIndexer.get_sizets,,))'499=   w 2 $d U#A, gtzz'7'7 DKKD Aw||D!&&9:A MM!U # $||E"" $ $s BDD c$|jfSrPrzrvs rDr}zBooleanArrayIndexer.get_shape !!rFc<|jd|jfSrrrvs rDrz$BooleanArrayIndexer.get_index_boundss Q++rFc|j}|jj|j|j|jj|j|j|j |j |j|j |j|j}|j|j}|j|jd||jd5|j |jdddt|j||jj |j|j"|}|j|j%|5|j |j&dddt)j*||}|j||j||fS#1swYxYw#1swYKxYw)NrFri)r>r$rrrrrrr?r rrrrr~rr|rnot_rr r#)rZr>r cur_countr next_counts rDrzBooleanArrayIndexer.loop_headst,, 499dnn5 499djj1t}}% .LL0 LL, __W00y$))L$)+ ( NN4;; ' () LL'4::#3#3TZZ  __W\\$/ 0 ) NN4<< ( ),,Wi@  j$**-)## ( ( ) )sG' G3'G03G<c|j}|j|j|j|jt j ||j |j}|j||j|j|j|j|jyrP) r>rrrr r#r?rr$rrrs rDrzBooleanArrayIndexer.loop_tails,,t||$ -,,W-4\\$..-IK  j$..1t}}% ,rFNrrrFrDrr]s*.3 #", $0-rFrc:eZdZdZdZdZdZdZdZdZ dZ y ) SliceIndexerz( Compute indices along a slice. c||_||_||_||_||_||_||_|jjtj|_ t|jd|_ yr) r~r>rrrrr@rrrrrr)rZr~r>rrrrr@s rDrzSliceIndexer.__init__s_     ||225::> T\\1- rFc|j}|j|jj|j|_t j|j||j|jt j||j|j tj||jj|_tj ||j"|_tj ||j"|_|j)|_|j)|_yrP)r>rcrrfrdim_sizer-r2r~rr@r3r is_neg_intstepis_step_negativerXrrrrrrrs rDrwzSliceIndexer.prepares,,--dhhnndhhG ##DLL'4::$(JJ 0'4::t}}= ' 2 27DJJOO L(($,,? (($,,? 224 002 rFcVtj|j|jSrP)r-r5r>r@rvs rDrzzSliceIndexer.get_sizes'' djjAArFc$|jfSrPrrvs rDr}zSliceIndexer.get_shaperrFcdtj|j|j\}}||fSrP)r-get_slice_boundsr>r@)rZloweruppers rDrzSliceIndexer.get_index_boundss*// djjI ue|rFc (|j}|jj|jj|j|jj|j |j |j|j|j|j|j|j}|j|j }|j|j|jd||jj|jd||jj}|j|d5|j|j ddd||fS#1swY||fSxYw)Nz<=rFri)r>r$r@r4rrrrrrr?selectrrstopr r)rZr>rr is_finisheds rDrzSliceIndexer.loop_heads*,, 4::++TZZ8 499djj1t}}% .LL, LL, nnT%:%:%,%8%8y9=&J%,%8%8y9=&JK __[_ 7 ( NN4;; ' ()## ()##s FFc|j}|j|j|j|jj dg}|j ||jtj||j|j}|j ||j|j|j|j|jy)Nrr)r>rr?rr@rr$r r#rrrrr)rZr>rrs rDrzSliceIndexer.loop_tails,,[[djj!94::??(-w!0  j$**-,,Wgll4::6NO  j$**-t}}% ,rFNrrrFrDrrs+ . 3B"$$-rFrc4eZdZdZdZdZdZdZdZdZ y) FancyIndexerz4 Perform fancy indexing on the given array. c :||_||_||_tj||j |j |_tj||j|j |_|jjtj|_ g|_ g}t|Dcgc]}t|s|c}} d} d} t!||D]\} } | tj"urY|j t|z dz| z}t%|D],}t'||||| }|j)|| dz } | dz } .rt+| tj,r7|j/|| | }t1||||| | |}|j)|nDt+| tj2r;t5||| | |j| }t7|||}|j)|nt+| tj8rt;| ||| }t+| j<tj2rt?||| ||j| }n5t+| j<tj@rtC||| |}nJ|j)|n:t| r!|jj)| | dz} ntEd| | dz } | dz } | |j ksJ| |j f| |j kr5t'||||| }|j)|| dz } | |j kr5t||j k(sJt||j f||_#ycc}w)NrrHr,)$r~r>rr rrfrqrrrrrrnewaxesrrrr0r9rrjrr1rrrrrrryr|rBooleanrAssertionErrorindexers)rZr~r>rrrrrrr=rnew_axr>rr?rnindexerr@rrs rDrzFancyIndexer.__init__s%   **7CIIuzzJ ++GS[[%**M ||225::>  +J3S9I3JK "7K8( OHe&!JJW59KG y) A+GWeS"MGOOG,!GBaKF  %1++GUHE&wR',e5(E5==1'%(, B9('3?(E5;;/*E*7GXFekk5==91'72726++b/CG  U]];1'727AG1(U# ##F+a$E%KLL !GB aKFQ( VUZZ1"ejj!115::o#GWeS"EG OOG $ !GB5::o 8} *GS]EJJ,GG*  mKs 6NNc\|jD]}|j|jjtj d}|jDcgc]}|j }}|jD]}|j||ft|d|_ ycc}w)NrHr) rrwr~rrrr}rinsertsumindexers_shape)rZrnr9 res_shapes rDrwzFancyIndexer.prepare:s A IIK ll'' A6-1MM:qQ[[]: : (A   Q ' ( ")R0;sB)c|jS)z? Get the resulting data shape as Python tuple. )rrvs rDr}zFancyIndexer.get_shapeMs"""rFc  t||jjk(sJ|j}tj }|j d}|j d}|}|}t|j|j|D]\} } } |j||jd| |}| j\} } |j| | }|j| |j| |}|jd| |}|j!||j#|||}|j!||j#|||}|j!||}|j#|||}|j#|||}||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. rrH==r)rrrqr>r false_bitrrrror_ icmp_unsignedrrsubrrr)rZrrr>is_emptyrr9rrrrfstride lower_index upper_index lower_offset upper_offset is_downwardss rDget_offset_boundszFancyIndexer.get_offset_boundsSs 7|tzz...,,$$||All1o&)$--9L9L*1'3 > "GUF{{8#*#8#8ud#KMH(/'?'?'A $K";;v{;L";;vw{{;/LML"..sFDALKK '|/;/;!=>EKK '|/;/;!=>E >& E8,xu5xu5e|rFcBtd|jD\}}||fS)Nc3<K|]}|jywrP)r)rRrns rDrTz+FancyIndexer.begin_loops..zsE! Es)rr)rZrcountss rD begin_loopszFancyIndexer.begin_loopsys$Et}}EFrFcXt|jD]}|jyrP)reversedrr)rZrns rD end_loopszFancyIndexer.end_loops}s#$--( A KKM rFN) rrrsrtrrrwr}rrrrrFrDrrs(@!D1&# $LrFrc btj||j}tj||j} |j} t ||||||} | j |j} | j} t||| | }|j}tj||jtjd}| j\}}tj||| || |j |d|j" }t%||||}|j'|}|j)||g}t+||| ||tj,||}|j/||| j1t3||| |j5S)NrFr-)r rrfrrrrwrr}_empty_nd_implrrrrrget_item_pointer2layoutrHrr?geprr#r$rr!r)r~r>r\rrrrrrrrrout_ty out_shapesr out_dataout_idx_rlrcurnext_idxs rDrWrWs ! !'399 5F""7CKK8G 88D7GUC&1G OO__F""$J '6: >CxxH''(/(<(arrtyarrrrrrr9rrrnmax_axis_offset is_upwardsrs rDoffset_bounds_from_stridesrsX||H == D ))A,C ||t Hcjj10 %<+uzz" OA&kk'!**1++fQi*EGO ,,T?DIJNN:#*;;uo#FOENN:#('++e_*MOE O E8,&&tSZZ>xu5xu5 %<rFc|j||j}|j||}|j||}||fS)z Given [lower, upper) byte offsets and a base data pointer, compute the memory pointer bounds as pointer-sized integers. )ptrtointr:r)r~r>rrrdata_ptr_as_intr4ends rDcompute_memory_extentsrsD &&tUZZ8O KK /E ++ou -C #:rFcFt||||||\}}t|||||S)zr Compute a half-open range [start, end) of pointer-sized integers which fully contain the array data. )rr) r~r>rrrrrrrs rDget_array_memory_extentsr!s2 .gws.4g?LE5 !'7E5$ GGrFcn|j|jd|||jd||}|S)z[ Whether two memory extents [a_start, a_end) and [b_start, b_end) may overlap. r)and_r)r~r>a_starta_endb_startb_end may_overlaps rDextents_may_overlapr)s> ,,c7E2c7E2K rFc 2jdtjdjd5j |j |j }jj|} | jj| } j| jtj} tj| 5} tjj | } tj| | } jj#| | ddddddf d}fd}||fS#1swY.xYw#1swY2xYw)NrFric tj }jd5\}}|5jtjj  |d|ddd|5jtj j |d|ddddddtj |S#1swYpxYw#1swY:xYw#1swY>xYw)NFrir.)r rXif_elser$rr?r r)source_indicessrc_ptrif_copy otherwiser>r~ copy_data copy_layout copy_shapes copy_stridesptrtysrc_data src_shapes src_stridessrctyuse_copys rD src_getitemz&maybe_copy_source..src_getitem-s%%gu5 __Xe_ 4 8L)  --gw.5ll9.E.9<.9>9> @     --gw.8+.3llN9>@    '5',,w2GHH      s:C5=C. C588C)0C5C& "C5)C2 .C55C>cjd5j}j|}jj |dddy#1swYyxYw)NFri)r r?bitcastrfree)rr>r~r2r; voidptrtys rD src_cleanupz&maybe_copy_source..src_cleanupAsZ __Xe_ 4 ,<< *D??43D KK  Wd + , , ,s AAA')r:r rr rrrrallocater>r$rrr loop_nestrr r?)r~r>r;r:srcr8r9r7 allocsizerrrr/dest_ptrr<rAr2r3r4r5r6r@s```` ``` @@@@@@rDmaybe_copy_sourcerGsn MMEK))'8rr target_shaperr9nd_diffrA dim_is_oneacceptedrs rD_bc_adjust_dimensionrPKsy    Q /D   u{{A .C <3v;&l#c&k16)&7"W," 7? \ S[ (f+L 11 &x 02++D"c:2 2##GLL*$+$4$46__W\\(3E_ B K@C    - -gzC6 J K!'(# 7?2  K Ks:E"'%E''E0c g}g}|jtjd}|jtjd}t||D cgc]\} } |j d| | } } } |D cgc]} |j d| |} } t| | D cgc]\} }|j | |}} }t|||D cgc]\}} } |j || | }} }} t||D cgc]\}} |j ||| }}} ||fScc} } wcc} wcc}} wcc} } }wcc} }w)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. rrHrhr)rrrrrr#r)r~r>rrrL bc_shapes bc_stridesrr9taroldmismatch src_is_onexypredsps rD_bc_adjust_shape_stridesr\psXIJ    Q /D   u{{A .C!$L& 9;C##D#s3;H;AGH#'%%dC5HJH,/*,E FDAqW\\!Q  FE F$'|V$DFF QS3,FIF!$E7 35a..D#.5J5 j  ;H FF5sD(8D.#D3D9Ec tj||j}tj||j}t |||||\}}t |||||\}}|j t|d}t|||}t||jtj||tj|||j|j|j||fS)zX Broadcast the given array to the target_shape. Returns (array_type, array) Arqr rE)r rrfrrPr\copyrryrrrkrrr) r~r>arrtyperrLrr new_arrtypenew_arrs rD_broadcast_to_shaperds  ! !'399 5F""7CKK8G*7GVW+79OFG.w/6 FOFG,,C $5c,BK%j%gw7G7 ++GV<"--gw?LL;;** &  rFc^|j|jdd}|||}d}||fS)Nr^T)rqr readonlyc n|\}}|jd}t||||}tj||}t |||||\}}t |dt |j|jjdd|j} t|||j| S)Nrr) rryr rrdrrrrrrr r) r~r>r\rrDshape_r:rdestr s rDcodegenz$_numpy_broadcast_to..codegens V j#6%%gv6%gwsFL4 h&&t'?'?'IJ! nn '3??CHHrF)r`r) typingctxrrfretr\rjs rD_numpy_broadcast_torms8 **%++cD* AC eU CI <rFcD|jd}||}d}||fS)NTrfc|\}|jd}t||||}tj|jj |_|j }t|||j|Sr) rryr get_null_valuerr:rr r)r~r>r\rrDr:rir s rDrjz#get_readonly_array..codegensh  z% '37,,T[[-=-=> nn '3??CHHrF)r`)rkrrlr\rjs rDget_readonly_arrayrrs/ ((D( !C c(CI <rFc|j}t|}t|}||kDr td|D]}|dks tdd}||z }||kr1||}||} || k(s|dk(r |dz }|dz }n td||kr0yy)NzDinput operand has more dimensions than allowed by the axis remappingrz4all elements of broadcast shape must be non-negativerHz=operands could not be broadcast together with remapped shapes)rfrr) r dest_shape src_shapesrc_ndim dest_ndimr src_index dest_indexsrc_dimdest_dims rD_can_broadcastr|s I9~HJI)12 2- !8,- -- IX%J h I&j) h 'Q, NI !OJ45 5 h rFc\tj|}t||t||SrP)npasarrayr|rmrrfs rD_default_broadcast_to_implrs' JJu E5% ue ,,rFc dt|stjdt|tj rd}|St|tj rAt|jtj sd}tj|tSt|tjra|jdkDrRt|Dcgc]}t|tjc}sd|d}tj|tSt|tjrc|jdk(rTt|tjxr|jdk(}t|s|rd}|Sd}tj|d |z}tj|cc}w) Nz-The first argument "array" must be array-likec0tj||fSrP)r~ broadcast_tors rDrz numpy_broadcast_to..impls??55(3 3rFz7The second argument "shape" must be a tuple of integersr"z," object cannot be interpreted as an integercBtj|}t|SrP)r~rrrrs rDrz numpy_broadcast_to..impl s 5))%00rFz/Cannot broadcast a non-scalar to a scalar arrayz:The argument "shape" must be a tuple or an integer. Got %s)rr rrrrUniTupler|rTuplerallIntegerLiteralrrqr)rrfrrtypis_scalar_arrays rDnumpy_broadcast_torsa E "  "12 2%' 4 E5>> *%++u}}5KC$$S) ))) E5;; 'EKK!OUKcJsE$8$89KLeWHIC$$S) ))) E5;; 'EKK1,<$UEKK8LUZZ1_ % O 1 KDC$$S) )   %%+Ls !F-ctt|D]O}|t|z |z}||}|dkr td|dk(r/||dk(r|||<=|||k7sFtdy)Nr#negative dimensions are not allowedrHz=shape mismatch: objects cannot be broadcast to a single shape)r9rr)rmrfrnrtmps rDnumpy_broadcast_shapes_listrs 3u:  3 E NQ Ah 7BC C !8  Q419AaD qTS[23 3 3rFc| t|D]\}}t|tj}t|tjxr$t|j tj}t|tj xrt|jdk(}|r|r|rd|d|}tj|d|D]Y}t|tjr td*t|tjsEtt|[dk(rdSdz  fd}|S)Nrz Argument z* must be either an int or tuple[int]. Got rHcyrrrs rDz+ol_numpy_broadcast_shapes..BrFrHcdgz}}t|D]M}t|trt|dkDrt ||/t|t s@t ||fOt |D]\}}t|||}|Sr)rrrrrrrr0)rrrYargrelemrtup_inits rDrz'ol_numpy_broadcast_shapes..implFsaAC%d+ >c5)c#hl/1c:S)/1sf=  > 'q\ 4 T#Cd3 4JrF) rrrrrr|rrr rmaxr\) rrris_int is_int_tupleis_empty_tuplerrrrs @@rDol_numpy_broadcast_shapesr,sdO*SC/!#u~~61 syy%-- 0 #C5M#cii.A:M,.se$ C$$S) )* A! c5== )Aq A U__ -As3x A !  Av!8  rFct|D])\}}t|rtjd|dd}d}|D]]}t |t j t jfr |j}n|}||}A||k7sGtjd|dt|D]\}}t |t jrt|j7t |t jt jt jfr td}tjd|dzfd}|S) Nz Argument "z" must be array-likezTMismatch of argument types. Numba cannot broadcast arrays with different types. Got rrHzUnhandled type rc`dgz}t|D],}t|tj|j.}t D]}t ||||}g}t|D]:}|jtjtj||<|Sr) rrr~rrfr9r0rjr)rrfrrYrnoutsrrs rDrz$numpy_broadcast_arrays..implxs a#D) KE 'q"**U2C2I2I J Kq 2AQa1C 2#D) AE KK 5(93? @ A rF)rrr rrrrr\r|ArrayCompatiblerrqNumberr)rrr unified_dtypedtrrrs @@rDnumpy_broadcast_arraysrUsQdO6S$$$z#75&56 66 M B 4 cEKK9 :BB  M b $$&,,06&34 4 4 AdO>S c500 1Asxx A ellEMM5??K LAq A$$se%<= = >axH( KrFct)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.rr8 index_shapes rDraise_with_shape_contextr  rFgeneric)targetct|tjr_t|tjrD|j|jk(r*t|jtjrd}|Syyyy)Nctd)Nz0cannot assign slice from input of different sizerrs rDrz1ol_raise_with_shape_context_generic..implsOP PrFrrrr|rr8rrs rD#ol_raise_with_shape_context_genericrsg :u~~.;/K--- z'' 7 Q 8 . 0 /rFCPUct|tjr_t|tjrD|j|jk(r*t|jtjrd}|Syyyy)Nc Lt|dk(r d|dd}n,ddj|Dcgc] }t|c}d}t|dk(r d|dd}n,ddj|Dcgc] }t|c}d}d|d|}t|cc}wcc}w) NrH(rz,), )zcannot assign slice of shape z from input of shape )rjoinstrr)r8r shape_strrX index_strrs rDrz-ol_raise_with_shape_context_cpu..impls:!# 1 b1  :*Fa3q6*F GHJ ;1$ A/r2  ;*Ga3q6*G HIK 29+>%;(CS/ !+G+Hs B -B! rrs rDol_raise_with_shape_context_cpursf:u~~.;/K--- z'' 7 "  8 . 0 /rFc ^()*|j\}}*|\}}(t||}tj|j} tj|j } |j } t||||} | jd} t*tjr*j)| j}t*((t*(|\*(tj(j}tj(j }(j }tj}t!|t!|k(sJt#||D](\}}j%|j'd||}*j)|d5| ||dddt+*(|||\}}| j-| |j.\}}t1||| \}}t3||||}t5|*(|||\}}nt*tj6r*j)| j}t!|dk(sJj9t t;tj<*}|(f}j'd|d|}j)|d5| |f|dfddd()*fd}d }n *)(fd }d }j?tj@d} | jC\}!}"tE|"}"| jFD]}#|"jI|#| |"D$cgc]}$|$|$ }%}$||%}&jK|&)|j}&tjL| | | |jN|!djP }'tS||&|'| jU|jWS#1swYMxYw#1swY/xYwcc}$w) 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. c |jjt}tjtj t |tjtj t |f}|j|j|i}|j||}|||j||jd||j||jd|fyNrrH) typing_contextresolve_value_typerrrint64r get_call_typerR make_tupler)r~r>r8rfntyargtys raise_sigfuncs rDraise_shape_mismatch_errorz2fancy_setslice..raise_shape_mismatch_errors%%88 $&..c*o>..c+.>?A&&w'='=vrJ ##D)4 Ww))'9>>!3D*46))'9>>!3D*578 9rFrhFriNrHrc|\}jtjttj }||fSrP)rRoperatorgetitemr$rr)r.r getitem_implr>r~rD src_dtyper:s rDr<z#fancy_setslice..src_getitemsF!DC"//  )UEJJ7L #s4 4rFcyrPrrrFrDrAz#fancy_setslice..src_cleanup rFcSrPr)r.rDs rDr<z#fancy_setslice..src_getitem$sJrFcyrPrrrFrDrAz#fancy_setslice..src_cleanup'rrFr-),rryr rrfrrrrwrrrr|r}rdrrrrrr r!rrrr)rGSequencerRr$rrrrrrrrrr rHrrrq)+r~r>r\rrrrrr dest_shapes dest_strides dest_datarrrr8r9r7 shape_errorur src_startsrc_end dest_lower dest_upper dest_startdest_endr;r<rAlen_implseq_lenr dest_indicesrrnrr.rrFrDrr:s+`` @@@rDr^r^s0 hhOE1eKCC *U GWc 2C&&w :K''=LI7GUC&1G OO 9%&KK '') j#6('5#)46 s))'399= **7CKK@ 88'' ;3z?222 K0 GDAq!++k&-&9&9$1&EGK G__[_ 7 4 &w'2 4 4 6gw69:6A8M 7")!:!:<;><<"I J5gw6@*6? A H'wG'18=$5Wgx5:C5@($L [ E5>> *KK '') ;1$$$''Yuzz5-IJ7SF+))$ AH __[_ 7 : &w'(3A'8 : : 5 5         Q /D"..0L&&\F __ a"(9A1=a9N9 n %C ,,wY r\rrdimtysrrmrSrrfshapetynew_signew_argss rDvararg_to_tuplerUs HHQKE XXab\F q'C 8Dvt, .C LL#r5:: 6 .D .   wd1gll ;Enn5::SY?Gsw?GEzH H  .s,C"zarray.transposec>t|||jd|dSr)array_Trr~r>r\rs rDarray_transposerhs 7GSXXa[$q' ::rFct|tt|k7r tdt|}|D] }||k\st||kDstd|||dd|||ddy)Nzrepeated axis in transposez2axis is out of bounds for array of given dimension)rrrabs)rrfrrrXs rDpermute_arraysrmsy 4yCD N"566 e*C 0 8s1v|/0 00 T{E!HGAJrFc v|jd}t||||d}|jd|d}}|j|j} }|j t j } tj| |} ||j|jg} | D cgc]} tj|| }} t| |D]\}}|j||t j| dd}|j!t j |j#| }| D cgc]} t|||}} t||D]T\}}t%||j'|| j)|j!t j |g|g|dV|j+|t,t/j0t j2||||Dcgc]}|j5c}t|j6||}t%||j8|j;|d|j;|d|j<|j>|j@|j5}tC|||j6|Scc} wcc} wcc}w)NrrHrr|rqr rrfrrrrorE)"rryrr|rrrr ArrayTyperfrr rXrr$rrr}rr> as_pointercompile_internalrrr$voidrrrr?rrrr )r~r>r\rrraxistyrnum_axisr|r ll_ary_sizearysrll_arysrDdst np_ary_ty np_itemsizenp_arysnp_aryll_aryarlr s rDarray_transpose_tupler|sg HHQKE *U GWd1g 6C88A;QDFllFLLeH$$UZZ0G,,w1K #))S[[ )DBFGQw""7K8GGGg& S c3  %as$J,4J1,J6c@t||||\}}t||||SrP)rrr~r>r\rrrs rDarray_transpose_varargr s('#tDGX '7H EErFc|t|tjrtjd|dd}|Sdd}|S)Nz#np.transpose does not accept tuplesc"|jSrP transposeraxess rDnp_transpose_implz*numpy_transpose..np_transpose_impls;;= rFc$|j|SrPrrs rDrz*numpy_transpose..np_transpose_impls;;t$ $rFrP)rrr\r r)rrrs rDnumpy_transposersA!U__%  !FGG | !  % rFTc 4|jdkr|}nt||||}t|||}tj||j|j}tj||j |j}t ||jtj||dddtj||ddd|j|j|j|j}t||||S)NrHrE)rqryr rrfrrrrkrrrrr ) r~r>rrr rrlrrs rDrrs xx1}jogw6jogw/%%gsyy#((C&&w SXXFsHH$//"F&11'74R4=I # "{{!jj  *mmo WgsC 88rFc4t|tjstjdt|tjstjdt|t tj fstjddd}|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 integerc\tj|||}tjd|S)Ng$@)r~linspacepower)r4rnumrYs rDrznumpy_logspace..impls% KKtS )xxa  rF2)rrrr rrr)r4rrrs rDnumpy_logspacerss eU\\ *  !NOO dELL )  !NOO cC/ 0  !NOO! KrFct|tjsd}tj|t|tjsd}tj|t|t tj fsd}tj|td||fDr:ttjt|t|ddfd }|Sdd}|S)Nz%The argument "start" must be a numberz$The argument "stop" must be a number%The argument "num" must be an integerc3PK|]}t|tj ywrPrrComplexrRrs rDrTz"numpy_geomspace.. Cc:c5== ) CrUcF|dk(s|dk(r td |} |}tdkrz|jdk(|jdk(z}tj|dk(tj|dk(z}d}|r|j }|j }d}|r)| }| }| }ntj|}||z}||z}tj |}tj |}tj|||}|dkDr||d<|dkDr||d<||zS)Nr&Geometric sequence cannot include zerornrrHy?)rrrealr~signimaglog10logspace) r4rrboth_imaginary both_negativeout_signlogstartlogstopr% result_dtypes rDrznumpy_geomspace..impls'zTQY !IJJ 'E%Dv%"'**/dii1n!E!#2!5"''$-2:M N !!JJE99D!H "FE 5D (yH775>! xxHhhtnG[[7C8FQw!q 7!%F2Jf$ $rFc\|dk(s|dk(r tdtj|dk(tj|dk(z}d}|r | }| }| }tj|}tj|}tj|||}|dkDr||d<|dkDr||d<||zS)Nrr(rrH)rr~r*r,r-)r4rrr/r0r1r2r%s rDrznumpy_geomspace..impl!szTQY !IJJWWU^r1bggdmr6IJMHu$9xxHhhtnG[[7C8FQw!q 7!%F2Jf$ $rFr) rrrr rrrrVr r~ result_typer )r4rrrrr3s @rDnumpy_geomspacer6s eU\\ *5  %% dELL )4  %% cC/ 05  %% CeT] CC!"..%19$#GH  %p K+ %* KrFct|ttjfst j dt|tj st j d|jdkrt jddd}|S)Nz*The second argument "k" must be an integerz'The first argument "m" must be an arrayroInput must be >= 2-d.cB|dz}|dk(r|ddS|dk(r*tjtj|ddS|dk(r(tjtj|S|dk(r*tjtj|ddSt)NrrHro)r~swapaxesfliplrflipudr)rrs rDrznumpy_rot90..implDs E 6Q4K !V;;ryy|Q2 2 !V99RYYq\* * !V99R[[Aq12 2 rFr) rrrrr rrrqNumbaValueError)rrrs rD numpy_rot90r@9sr a#u}}- .  !MNN a %  !JKKvvz$$%<== ! KrFc |jtj}|j}|jtj} t j | |||||||| g} tj|j| d} ||j} tj||jddd} tj||jddd}||}tj||dd}tj||dd}| d}|j| | | |||||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. numba_attempt_nocopy_reshaperfrr)rrrrintcr FunctionTyper get_or_insert_functionr;rqrirhcallr)r~r>rrnewndnewshape newstridesr ll_intp_starll_intcrfnndrfr is_f_orderr s rD_attempt_nocopy_reshaperOTsE$$UZZ0G%%'L$$UZZ0G ??7|| % D  ' '(F HB  B  #*>*>w*GA NE""7C,@,@,K#$a)G ENE##GXq!jA|tB|fdddt|||}t!|| jD|jG| |jG|| jH| jJ| jL|j5}tO|||j|S#1swYxYw) NrrHrrrrzincompatible shape for arrayrE)(rrrrrrrrryr rXr$rr|rr}rr>rrrrWrr$rrrrOrr:r rkrlrSrr?rrrr )r~r>r\rrrettyrrfrll_shaperrH shape_ary_ty shape_aryshape_itemsizerrGrIrVfailrrlr s rD array_reshaper_s HHQKE OOEhhqkG GE$$UZZ0G||GW]]3H *U GWd1g 6C""7H5H MM%";;W]]3GL( <(':I))%***1*@*@*IKN9'2D2D2FG!..uzz7==IJ*+* ! ::D W&=#--ejj.3kk<I"I$7$7$9:< MME$$Wh7J '5#u!): 7B  r2771: 6D  P,))'3FOP *U GW -C3 h/"<< 3LL;;** & --/C Wgs DDPPs 4%K33K<c@t||||\}}t||||SrP)rr_r s rDarray_reshape_varargras('#tDGX '7H ==rF)rorHc d}|S)Nc$|j|SrPreshape)rrHs rDnp_reshape_implz#np_reshape..np_reshape_impls99X& &rFr)rrHrfs rD np_reshapergs  'rFc d}|S)Nc$|j|SrPrd)rrfs rDrfz#np_reshape..np_reshape_impls99U# #rFr)rrfrfs rDrgrgs  $rFc.t|sd}tj|t|tj r$t|j tjs1t|tjsd}tj|d}|S)N#The argument "a" must be array-likezBThe argument "new_shape" must be an integer or a tuple of integersc0tj|}tj|}t|tr4d}tj|D]}||z}|dksd}t |n|dkr d}t ||}|j dk(r.tj|j|jS| |j z }|}t|dz D]}tj||f}|d|}tj||S)NrHrz0All elements of `new_shape` must be non-negative) r~rravelrrrrzerosastyper|r9 concatenatere) r new_shapenew_size dim_lengthrmsg2repeatsr rns rDrznumpy_resize..impls JJqM HHQK i 'H jj3 * J&>LC$S/)  * 1}I && H 66Q;88I&--agg6 6I'(w{# +A..#q*C +)8nzz#y))rF)rr rrrrr|r)rrqrrs rD numpy_resizervst A 3  %%  5>> 2   7 y%-- 0%  %%*8 KrFct|stjdt|stjdt|rdd}|St |t j stjddd}|S)Nz+The first argument "arr" must be array-likez/The second argument "values" must be array-likectjtj|}tjtj|}tj||fSrP)r~rmrrprvaluesrs rDrznp_append..impl% sB((2::c?+CXXbjj01F>>3-0 0rFz,The third argument "axis" must be an integerc4tj||f|SNrr~rprys rDrznp_append..impl/ s>>3-d; ;rFrP)rr rrrrr)rrzrrs rD np_appendr s C   !NOO F #  "./ /4 1 K $ .$$&/0 0 < KrFz array.ravelcd}d}|jdjdk(r|}n|}|j||||}t|||j|}|S)Nc8|j|jS)zNo copy version)rerrs rD imp_nocopyzarray_ravel..imp_nocopy7 s{{388$$rFc"|jS)z Copy version)flattenrs rDimp_copyzarray_ravel..imp_copy; s{{}rFrr)rr rr!r)r~r>r\rrrimpr s rD array_ravelr4 s_%  xx{S   " "7Cd ;C 7GS__c BC JrFc0d}|j||||S)Nc"|jSrP)rmrs rD np_ravel_implznp_ravel..np_ravel_implM swwyrF)r)r~r>r\rrs rDnp_ravelrK s   # #G]C FFrFz array.flattencdd}|j||||}t|||j|}|S)NcT|jj|jSrP)r`rerrs rDrzarray_flatten..impV sxxz!!#((++rF)rr!r)r~r>r\rrr s rD array_flattenrS s8,  " "7Cd ;C 7GS__c BC JrFc|tj|n|}tj|||\}}}tj|jD]*}||} ||} ||} t t | | | ||<,|SrP)r~ empty_likebroadcast_arraysndindexrfminr) ra_mina_maxr rla_ba_min_ba_max_brval_a val_a_min val_a_maxs rD _np_clip_implr^ s"k"-- sC//5%@C'CII&;E EN EN UI. :E ; JrFctj|jD]-}||}||}|rt||||<t ||||</|SrP)r~rrfrr)rbuse_minr rrval_bs rD_np_clip_impl_nonerl sZAGG$+%% UE*CJUE*CJ + JrFc&t|stjdt|tj s t|stjdt|tj s t|stjdt|tj s"t|sd}tj||duxst|tj }|duxst|tj }|r|rdd}|St|tj}t|tj} |r| rdd} | S|r| s|rdd} | Sdd} | S|s| r|rdd } | Sdd }|S|rdd }|S|rdd }|Sdd }|S)Nrkz6The 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 providedctd)Nz&array_clip: must set either max or minrrrrr s rD np_clip_nnznp_clip..np_clip_nn sEF FrFc|tj|n|}tj|jD] }||}t t |||||<"|SrP)r~rrrfrrrrrr rlrrs rD np_clip_ssznp_clip..np_clip_ss s['*k"--"sCAGG, ;% UE!2E:E  ;JrFc|tj|n|}tj|jD]}||}t ||||<|SrP)r~rrrfrrs rD np_clip_snznp_clip..np_clip_sn T+.+bmmA&3ZZ03EeHE!$UE!2CJ3 rFcJtj||}t||||SrPr~ full_liker)rrrr  a_min_fulls rD np_clip_saznp_clip..np_clip_sa s%  \\!U3 $Q E3??rFc|tj|n|}tj|jD]}||}t ||||<|SrP)r~rrrfrrs rD np_clip_nsznp_clip..np_clip_ns rrFcJtj||}t||||SrPr)rrrr  a_max_fulls rD np_clip_asznp_clip..np_clip_as s%  \\!U3 $Qz3??rFc|tj|n|}tj||\}}t||d|S)NTr~rrr)rrrr rlrrs rD np_clip_naznp_clip..np_clip_na s=*-+bmmA&3!221e< W)#wcBBrFc|tj|n|}tj||\}}t||d|S)NFr)rrrr rlrrs rD np_clip_anznp_clip..np_clip_an s=*-+bmmA&3!221e< W)#wsCCrFct||||SrP)rrs rD np_clip_aaznp_clip..np_clip_aa s%Quc::rFrP) rr rrrrKrrr)rrrr r a_min_is_none a_max_is_nonera_min_is_scalara_max_is_scalarrrrrrrrrs rDnp_cliprx s A   !FGG uenn - '  #46 6 uenn - '  "45 5 sEKK (K,<E  %%TMFZu~~%FMTMFZu~~%FM G  5O  5O?      @      @   C    D   ;  rFclipcdd}|S)Nc2tj||||SrP)r~rrs rDrzarray_clip..impl swwq%,,rFNNNr)rrrr rs rD array_clipr s - KrFc v|j|jk(sJ|j|jk(sJt|j}tdtdtdtjfd}|j tj t||}|j tj t||}|j tj |j} tj||jddd} tj||jddd} tjtj dd } |j| } tj||j tj |jg}|j|jtj }|j tj |}tj||g}| ||}t!|| |||d | ||}t!|| |||d |j#}|j#}| |||||j tj|g}t%tj&tj | | tj tj tj}|j)||||}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. r^rFc"| k(r!|d|k(r  }n|d|k(r }||k7r | k(s|dk(ry| k(r|dz }nd}||kr!||zdk7ry||z}||xx|zcc<|||<y||kDr|||z}||zdk7ry||z||<|||<y y)NrrFrHTr) rMrmr old_itemsize new_itemsizer rnnewdim bytelength any_layoutc_layoutf_layoutint8s rDrz_change_dtype..imp s Z r{l*h|+h < 'Vz-AR1W X QAA , &|+1!\1F Gv G%GAJ"L (a</J\)a/ L0DG%GAJ rFrfrrrHrNr)rqr ordrrrrrr rirhrryrkr}r{rrr$booleanrrr r)r~r>oldtynewtyr new_layoutrrrrM shape_data strides_datashape_strides_array_typearyclsshape_constant sizeof_intpstrides_constantr\ strides_aryrfrrr\r rrrrs @@@@rD _change_dtyper s :: ## # <<5<< '' 'U\\"JSJ3xH3xH ::D.`'' (4We(DFL'' (4We(DFL   ejj%** 5B%%gs/C/CG/L&',J''(+(<(Cjj*J)KLN(()>)>uzz)JKK&&uzz;?K))'K=Aw(I9"'+' !'*K;$'+' !    !E##%G w l  Z 8 :D EMMJJ,,JJJJJJ  C  " "7Cd ;CeS! GWcoos CC JrFcLt|stjdd}|S)Nz+The argument to np.shape must be array-likec@tj|jSrP)r~rrfrs rDrznp_shape..impl| szz!}"""rFrr rrrs rDnp_shaperw s& A   !NOO# KrFcLt|stjdd}|S)Nz*The argument to np.size must be array-likec@tj|jSrP)r~rrrs rDrznp_size..impl szz!}!!!rFrrs rDnp_sizer s& A   !MNN" KrFc d}|S)Ncd}tj|j}t|dd}t |ddDcgc]"\}}|||k7r|||r||s|$}}}tj ||zScc}}w)Nc||k( SrPr)rXs rDisnanz0np_unique..np_unique_impl..isnan sQ< rFrH)r~sortrmrrr)arrrheadrnrXtails rDnp_unique_implz!np_unique..np_unique_impl s  GGBHHJ AbqE{#AabE* !Qtqy%!+%(   xxt $$  s'Br)rrs rD np_uniquer s % rFcd}t|tjtjtjtj tj frt|tjrtSt|tjtjfr&t|jtjr|Stjdy)Nc@tj|tj}|jddk(rt ||dStj |dkr t dtj|}|j}|jd}|j|jk7r t dtjtj||j}d}t|D]}|||||||z|||z }|S)Nr|rrHrz(operands could not be broadcast together) r~rrrfnp_repeat_impl_repeats_scalerrVrrmemptyrr|r9) rru repeats_arrayasaaraveln to_returnposrns rD!np_repeat_impl_repeats_array_likez4np_repeat..np_repeat_impl_repeats_array_like s 7"((;   q !Q &0M!4DE E 66-!# $BC Cjjm LLO <<=.. .:< <HHRVVM2#))D q $A6?? **Q-C YY[F QA!|xx++ AwwvHHQ[ : q CA9?Ia'kQUg$5 6 CrFrepeatc d}|S)Nc.tj||SrP)r~r)rrus rDarray_repeat_implz'array_repeat..array_repeat_impl syyG$$rFr)rrurs rD array_repeatr s% rFc:tj|}d}||fS)z"Computes the itemsize of the dtypec|j|jdj}|j|j}||j |Sr)r{rr|rr})cgctxr>r\llargsrllintps rDrjz%_intrin_get_itemsize..codegen sJ""388A;#4#45$$S__5e**4011rF)rr)tyctxr|r\rjs rD_intrin_get_itemsizer s# **U C2 <rFcyrPr)rr|s rD_compatible_viewr rFc d}|S)zDDetermines if the array and dtype are compatible for forming a view.ct|}||jk7r|jdk(r d}t| |jdz }|j|dk7}|j dk7}|j ||jk7}|r|r|r d}t|||jkr%|dk(s|j|zdk7r d} t| y|j||jz} | |zdk7r d} t| yy)NrzOChanging the dtype of a 0d array is only supported if the itemsize is unchangedrHzJTo 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.)rrrqrrfrr) rr| dtype_sizemsg1rp1p2p3rtmsg3rmsg4s rDrz ol_compatible_view..impl s)%0  #vv{7 &&66A:D!#B1B4AJJ.Brb2 &&AJJ&?ajj:&=&BID$T**'C 3J&!+1D%T** ,9 $rFrrr|rs rDol_compatible_viewr s "+F KrFz array.viewc|jd}|j}t||||d}t|||}t|jj }t |D]N} t|| } | dk(r.|jj} |j| | |_Bt|| | Ptdk\r\|j} | jt} | j!| g|ji}|j#| |}|||t%|||||}|j'd|t)|jd}|j+|5d}|j,j/|t0|fddd|j3}t5|||j|S#1swY1xYw)Nrr)rHrz"new type not compatible with array)rrryrrrsortedgetattrrr:r>rrrrrrrRrrrr rkrlrrr )r~r>r\rrrYrrlfieldsrrr6r r_compatible_view_sigrrVr^rr s rD array_viewr# s HHQKE OOE *U GWd1g 6C *U GW -C '' (F F^!c1o ;HHMMEsE2CH CC ! &&''(89#11%388rJ##D*>? Wd ws ;B  r8BGGQ+? @D  G2))':vFG --/C Wgs DD GGs +%GG r|c>|j}t||||SrP)rqr"r~r>rrr s rD array_dtyper&K s!  ! ! #C gwS 99rFrfc`t|}||||}|j}t||||SrP)ryrfr"r~r>rrrrr s rD array_shaper)Q s5oG GWe ,E ++C gwS 99rFrc`t|}||||}|j}t||||SrP)ryrr"r(s rD array_stridesr+Z s5oG GWe ,E --C gwS 99rFrqcr|jtj|j}t ||||SrP)rrrrqr"r%s rD array_ndimr-c s/   uzz388 4C gwS 99rFrc`t|}||||}|j}t||||SrP)ryrr"r(s rD array_sizer/j s3oG GWe ,E ,,C gwS 99rFrc`t|}||||}|j}t||||SrP)ryrr"r(s rDarray_itemsizer1r s5oG GWe ,E ..C gwS 99rFnbytesct|}||||}|j|j|j}t ||||S)z" nbytes = size * itemsize )ryrrrr"r(s rD array_nbytesr4{ sD oG GWe ,E ++ellENN 3C gwS 99rF contiguouscr|jtj|j}t ||||SrP)rrr is_contigr"r%s rDarray_contiguousr8 s-   u}}cmm C gwS 99rF f_contiguouscr|jtj|j}t ||||SrP)rrr is_f_contigr"r%s rDarray_f_contiguousrA r=rFrfct|jtj|j }t ||||SrP)rrrmutabler"r%s rDarray_readonlyrD s/   u}}#++o >C gwS 99rFctypesct|}||||}tj|}|j||}|j|_|j |_|j }t||||SrP)ryr ArrayCTypesrrrrr ) r~r>rrrractctinfor s rD array_ctypesrJ spoG GWe ,E   C C  # .F**FK]]FN    C WgsC 88rFrc|j|||}|j}|j||jtj }t ||||SNr)rrrrrrr")r~r>rrrIr s rDarray_ctypes_datarM sT  #U ;F ++C   3 6 6uzz B CC gwS 99rFc|j|||}|j}|j||j|}t ||||SrL)rrr>rr")r~r>fromtytotyrrIr s rDarray_ctypes_to_pointerrQ sP & rrtup_intpr check_sig check_argsr7s rD_call_contiguous_checkrX s *U GWC 8C~~ejj%**5H%%g&<&J(('9)35I rFrc|j|tj|}||_|j }|j j |||t||||SrP)rr ArrayFlagsrrrrr!)r~r>rrflagsobjr s rD array_flagsr\ s[""7E,<,rrr[r rs rDarray_flags_c_contiguousr^ s ~~#&&w5&A$]GW%(^^X__Fnn##s*""5==#6 gwS 99rFcx|jjdk7r<|j|||}tt|||j|j }nX|jj}|jj dkDr|dk(n|dv}|jtj|}t||||S)NrrrHr) rcr rrXrrrqrrrr")r~r>rrr[r r rs rDarray_flags_f_contiguousr` s ~~#&&w5&A$Z'%(^^X__F&&"~~22Q6fmFdN""5==#6 gwS 99rFr)c|jtjvrt||||dS|jtjvrt ||||St djtj)Nr)attrzunsupported .real for {}) r|rcomplex_domainarray_complex_attr number_domainr rSrr:)r~r>rrs rDarray_real_partrg se yyE(((!'7CVLL e)) ) '3>>!"<"C"CDJJ"OPPrFr+c2|jtjvrt||||dS|jtjvrt |j d|}t||||g\}}t||||}tj||j|j|j|jdt|||j |j#St%dj't(j)Nr+rbTrorzunsupported .imag for {})r|rrdrerfr$r`_parse_empty_like_argsrr memsetrrrrr!rrrSrr:)r~r>rrr\rarrs rDarray_imag_partrk s yyE(((!'7CVLL e)) )$/50'3PWgw?w'++cll69jj+BCD F#// # 1 1""<"C"CDJJ"OPPrFc|dvs|jtjvrtdj |t |}||||}|jj }|j|j|}|jj|} |j|j} |j|j| } |dk(r,|j| t!j"ddg} |j%|d} t | ||} t'| | }t)j*| ||t-||| | j/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 ^ ^ ^ )r)r+zcannot get attribute `{}`r+ rHr^r|r )rr)r|rrdrSrryunderlying_floatr}r{rr:rrr>rr rIntTyper`rr copy_structr r)r~r>rrrcrrflty sizeof_fltyr llfltptrtyrresulttyr%repls rDrere sE8 ##syy8L8L'L!"="D"DT"JKKoG GWe ,E 99 % %D(()>)>t)DEK~~"";/H''-88:Jooejj*5G v~++g 2q(9':;xxd3x/H !Z !'7 3F Wx 0D t, Wgx9I9I9K LLrFconj conjugatec d}|S)Nc,tj|SrP)r~rwrs rDrzarray_conj..implX swws|rFrrrs rD array_conjr}U s  KrFc"|jSrP)rq)r~r>dtypetydtypevals rD dtype_typer` s  " " $$rFr:kindstatic_getitemc|j}t|tjr%|j |d}t ||||Sd}t j|)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"r LoweringError)r~r>r\rrYr rs rDstatic_getitem_number_clazzrm s^ OOE%%,g$$U+D1!'7E3??L""3''rFc t|}||||}|j}t|tjst d|d|d|j |}|j|} t|tjr6|j|j|j|jzd} n|j|d} t| } | ||} |jtj| } tj||j| | jj }t|tjrtj"||j$|j}||j$Dcgc]"}|jtj|$c}z }tj"||j&|j}||j&Dcgc]"}|jtj|$c}z }|j)|j+|j}n8|j$}|j&}|j)|j+|}t-| ||||jtj||j.|j0| j3}t5||| |Scc}wcc}w) zq Generic getattr() implementation for record arrays: fetch the given record member, i.e. a subarray. z attribute z of z not definedr^rrn)rrE)ryr|rrRecordrStypeofr NestedArrayr`rqrrr rrr:rrfrr}r{rrrrr )r~r>rrrcrrrectyper|rrestyrarytyrary constoffset newdataptrrfrnrdatasizer s rDarray_record_getattrr sR oG GWe ,EiiG gu|| ,!%)3#01 1 NN4 E ^^D !F%**+++CHHuzz$9#GuS1  F '7 #D&&uzz6:K$$[tyy~~J%**+$$Wekk388D u{{K!'&&uzz15KK&&w sxxHOAG((Q7OO))'*?*? *LM --))'*?*?*FG4""#00XF ==,, ( .. C Wguc ::'LPs 'K)8'K.cv|d}t|tstt|||jd|d|Sr)rrrSrr)r~r>r\rrs rDarray_record_getitemr s: GE eS !!! #((1+tAw NNrFc |j|||j|}|j|}t|tj r5t |}|||}|j} |jD cgc]"} |jtj| $} } |jD cgc]"} |jtj| $} } tj||||j| } t|| tj || tj || |jtj|j"dd|j%}t'||||Stj||||j|}|j(rdnd}|j+||||}t'||||Scc} wcc} w)zT Generic getattr() implementation for records: get the given record member. NrErH)sentry_record_alignmentrrrrrryr|rfrrrr get_record_memberr{rrkrrr rr)r~r>rrrcrelemtyrrr|rrHrInewdatar dptrrs rDrecord_getattrr s  ##C. ZZ F ZZ F&%++,6"GW% LL"AG((Q7""nn&ag**5::q9& &++GUF,3,A,A%,HJ $$Wh7&&w ;))%**fkkB mmo '3<<((%)0)>)>v)FH ""7FD%@ '3<<-"&s >'G5'G#c |j\}}|\}}|j|||j|} |j|} t | t j rtj||||d} | j} tj||| | jj} tj|| | |jt j| j ytj||| |j#| }|j%|||| }|j&rdnd}|j)|| |||y)zT Generic setattr() implementation for records: set the given record member. rHrNr)rrrrrrrr rxrrr:pointeememcpyrrrr{rrr)r~r>r\rrcrr_rrrr val_structrDrirrs rDrecord_setattrr s1 JCKFC ##C. ZZ F ZZ F&%++,7W007>B1gG oo((&&),)9)9;wc++EJJ F H((&&)0)>)>v)FHll7C7 7FCUCrFc|j|jd|d}||||jd|d|dS)3 Record.__getitem__ redirects to getattr() rrH) get_getattrr)r~r>r\rrs rDrecord_static_getitem_strr sE   sxx{DG 4D #((1+tAwQ @@rFc2|jdj}t|jdj}|j |j ||}|j |jd|}||||jd|d||S)rrHr)rrrr!insert_const_stringr;r)r~r>r\rrr!ll_fieldrs rDrecord_static_getitem_intr s ((1+ # #C #((1+$$ %F**7>>6#;GH   sxx{H 5D #((1+tAws DDrFstatic_setitemc|j\}}}|\}}} t|j||} |j|| } | J| ||| fS)3 Record.__setitem__ redirects to setattr() )rr$r get_setattr) r~r>r\rrectyrr_recrr getattr_sigrs rDrecord_static_setitem_strr! s_ hhOE1eMCcCOOUE:K   sK 0D    #s $$rFc|j\}}}|\}}} t|j||} t|jdj} |j | || } | J| ||| fS)rr)rr$rrr!r) r~r>r\rrrr_rrrrr!rs rDrecord_static_setitem_intr. s{ hhOE1eMCcCOOUE:K #((1+$$ %F   vc{K 8D    #s $$rFc(|j|||S)zB Create a constant array (mechanism is target-dependent). )make_constant_array)r~r>rSpyvals rDconstant_arrayr@ s  & &wE ::rFctjtjd|j}|t |j }t j||S)zG Create a record constant as a stack-allocated array of bytes. )rrrpr2 bytearraytobytesr r)r~r>rSrltyrs rDconstant_recordrH sH ,,rzz!}ell 3C i ( )C  $ $Wc 22rFctjt|tj}|j |||S)zM Create a constant array from bytes (mechanism is target-dependent). r)r~rruint8r)r~r>rSrbufs rDconstant_bytesrR s2 ((9U#288 4C  & &wC 88rFcx|j\}}||k7rtjSd}|j||||S)Nc|j|jk(xrH|j|jk(xr-|jj|jjk(SrP)rfrrErrrs rD array_is_implzarray_is..array_is_impld sI177"/ QYY&/ . 0rF)rr rr)r~r>r\ratybtyrs rDarray_isr^ s@xxHC cz   0  # #G]C FFrF__hash__cdS)NcyrPrr{s rDrzol_array_hash..q rrFrr{s rD ol_array_hashro s rFct|dS)zq Return the Structure representation of the given *flatiterty* (an instance of types.NumpyFlatType). flat_make_flattening_iter_cls) flatitertys rDmake_array_flat_clsrw s %Z 88rFct|dS)zv Return the Structure representation of the given *nditerty* (an instance of types.NumpyNdEnumerateType). ndenumeraternditertys rDmake_array_ndenumerate_clsr s %X} ==rFc|jtjd}|jd} | |j t j |tt|D]} t j||| } t j||j| } || } |jd| | }t j||5|j | | ||| |j| ddd|j || ||| | |j t j||j| |j!| y#1swYmxYw)Nr end_incrementr)rrrrr$r false_byterr9rir#r?r if_likelyr true_byter)r~r>rqrfrend_flag loop_continue loop_breakrbbendridxptrrr in_boundss rD_increment_indicesr sF    A .D  & & 7E g(((3d $%%gw<%%gw||F/CDc ''S%8   w 2 " MM#v &(c" NN5 !  "  dF#  ! sO" g''2 NN5 E" " "s .E//E8 ctj||j|j}t |||j|||yrP)r rrfrqr)r~r>rrrrrfs rD_increment_indices_arrayr s4  #))UZZ @EwUGXNrFc v j jtj jr nd Gddt }Gdd|Gfdd|Gdd |Gd d |Gd d |G f ddt j}|S)zq Return the Structure representation of the given *nditerty* (an instance of types.NumpyNdIterType). rHcReZdZdZdZdZejdZdZ dZ dZ y) $make_nditer_cls..BaseSubIterzF Base class for sub-iterators of a nditer() instance. cP||_||_||_||_||z |_yrP)nditer member_name start_dimend_dimrq)rZrrrrs rDrz-make_nditer_cls..BaseSubIter.__init__ s+ DK*D &DN"DL)+DIrFcFt|j|j|yrP)rrr)rZrls rDset_member_ptrz3make_nditer_cls..BaseSubIter.set_member_ptr s DKK!1!13 7rFcBt|j|jSrP)r rrrvs rD member_ptrz/make_nditer_cls..BaseSubIter.member_ptr s4;;(8(89 9rFcyrPr)rZr~r>s rD init_specificz2make_nditer_cls..BaseSubIter.init_specific rrFcyrPrrZr~r> logical_dims rDrz2make_nditer_cls..BaseSubIter.loop_continue rrFcyrPrrs rDrz/make_nditer_cls..BaseSubIter.loop_break rrFN) rrrsrtrrrrIcached_propertyrrrrrrFrD BaseSubIterr s:  , 8  " " : # :   rFrc(eZdZdZdZdZdZdZy)$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). c|jtjd}|jt j ||yr)rrrrr r)rZr~r>rs rDrz2make_nditer_cls..FlatSubIter.init_specific s3'' A6D    9 9'4 H IrFcr|j|j}|j|j|gSrP)r?rr r)rZr~r>rrrrs rDcompute_pointerz4make_nditer_cls..FlatSubIter.compute_pointer s+LL1E;;sxx%1 1rFc||jdz k(rN|j|j}tj||}|j ||jyyr)rqr?rr r#r$)rZr~r>rrs rDrz2make_nditer_cls..FlatSubIter.loop_continue sMdii!m+ T__5//? eT__5 ,rFcH|dk(r=|jtjd}|j||jy||j dz k(rN|j |j}tj||}|j||jyyr) rrrr$rrqr?r r#)rZr~r>rrrs rDrz/make_nditer_cls..FlatSubIter.loop_break s}a++EJJ: dDOO4 A - T__5//? eT__5 .rFN)rrrsrtrrrrrrrFrD FlatSubIterr s  J 2 6 6rFrc"eZdZdZfdZdZy)+make_nditer_cls..TrivialFlatSubIterzx Sub-iterator walking a contiguous array in physical order, *without* support for broadcasting. c"jrJyrP)need_shaped_indexing)rZr~r>rs rDrz9make_nditer_cls..TrivialFlatSubIter.init_specific s44 444rFcvt|dksJt||j|j|Sr)rr rrZr~r>rrrs rDrz;make_nditer_cls..TrivialFlatSubIter.compute_pointer s2w<1$ 2c'l 2$;;sxx1 1rFN)rrrsrtrrrrsrDTrivialFlatSubIterr s  5 2rFrceZdZdZdZy)'make_nditer_cls..IndexedSubIterzA Sub-iterator walking an array in logical order. clt||jk(sJtj|||||dSNFr,)rrqr r8rs rDrz7make_nditer_cls..IndexedSubIter.compute_pointers:w<499, ,,++GWeS,3G GrFNrrrsrtrrrrFrDIndexedSubIterr s   GrFr ceZdZdZdZy)'make_nditer_cls..ZeroDimSubIterz5 Sub-iterator "walking" a 0-d array. c|jSrP)rrs rDrz7make_nditer_cls..ZeroDimSubIter.compute_pointers 88OrFNr rrFrDZeroDimSubIterr s   rFrceZdZdZdZy)&make_nditer_cls..ScalarSubIterz8 Sub-iterator "walking" a scalar value. c|SrPrrs rDrz6make_nditer_cls..ScalarSubIter.compute_pointersJrFNr rrFrD ScalarSubIterrs   rFrc eZdZdZej fdZ fdZfdZdZ dZ  fdZ dZ d Z y ) make_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 g}jr n  d}tjD]0\}}|\}}}}d|z} ||} |j| || ||2|S)N)rindexed0dscalarzindex%d)rrrrj)rZl factoriesrnrrrrrrfactoryrr rrrrs rDsubitersz(make_nditer_cls..NdIter.subiters#sA080M0M0$2-#0 I $H$5$56 I3.1+i!'!m #D/{IwGH  I HrFc|jtjd}|j|tj|||_t |D]K\}}t|tjr!d|z}tj|||} t||| M|j||||}tjtj} d} d} t |D]O\}} t| tjs!| jk(s1||j} ||j } n;dk(sJ|j|| d} |jtjd} d}t#||D]\} }t| tjs!| jdkDs1t%tj&tjtj| j| }|j)||||j| ftj*|| }dk(r|ddd}|j-d | |}|j/|tj0tj2}j4s| f}t7|k(sJtj8||j: }t=D]+}tj>|||}|jA||-||_!tjD|||j:|_tj|||_#|jHD]}|jK||y) zY Initialize the nditer() instance for the specific array inputs. rscalar%dNrrHct|}t|D]'}|||t||z |zk7stdy)Nz2nditer(): operands could not be broadcast together)rr9r)rf main_shaperrns rD check_shapezBmake_nditer_cls..NdIter.init_specific..check_shapeVsOJq?AQx:c*o.AA.E#FF(*>???rFrrrr)&rrrrrarraysrrrr rr_arrays_or_scalarsrrqrfrrr$nonerrrrrrrrrXr:r9rir$rrk exhaustedrr)rZr~r>arrtysr%rrnrSrslot main_shape_tyr# main_nitemsrr$rr\rshape_is_emptyr(rrrsubiterr rqrnshapess rDrz-make_nditer_cls..NdIter.init_specific3s '' A6D",,Wekk&6I-35DK#6* 52!"ekk2",q.K"44WfQiHDD+t4  5,,WgvvNF"NN5::tF}"%00{DIN~w7H7H'.'9'9;I00&v;') ))))'4997KGW~ , --gwD dF+ ,#DL ++GVTYYGDJ$66w JDN == 8%%gw7 8rFc2|jd}tj||j|j}tj ||5|j d|j|ddd j}tj||j}|j||||}|j}|j d|j|||||} | D cgc]} | j} } t| dk(r|j| dn,|j|j!| j"| tj||j$} t'||t| | ||jt)j*|j,||t)j*|j.|||j||j1|y#1swYxYwcc} w)zJ Compute next iteration of the nditer() instance. rFNTrHr)rr as_bool_bitr?r( if_unlikelyrrr%rr&r _make_viewsrrr"rr!rfrrIpartial_loop_continue _loop_breakr) rZr~r>r%rr(r)r%rviewsrrfrs rDiternext_specificz1make_nditer_cls..NdIter.iternext_specifics..u5E ++G,3LL,HJI$$Wi8 &  'u% &__F))'4;;?F,,WgvvNFllG   T "$$WgwOE,12qQ[[]2E25zQ eAh' g00(:M:M1689(($**=E wUU&(001D1D1818 : )001A1A1818 :  ! NN5 !  # #E *? & &3s#H9HHc|jD]E}|j|cxkr|jks#n&|j||||jz GyrP)rrrrrZr~r>rrs rDr5z.make_nditer_cls..NdIter._loop_continuesG}} M==C5#++5%%gwcmm8KL MrFc|jD]E}|j|cxkr|jks#n&|j||||jz GyrP)rrrrr:s rDr6z+make_nditer_cls..NdIter._loop_breaksE}} J==C5#++5NN7GS3==5HI JrFc <dgz}j}|j}j} t| tj r t | } n| g} tD cgc](} |jtj||| *}} t||D]c\} } | \} } } }|| j| j}dk(r|ddd}|D],} || J|j|||| | || || | || <.etd|DsJ|Scc} w)z: Compute the views to be yielded. Nrrc3 K|]}|ywrPrrRrs rDrTz>make_nditer_cls..NdIter._make_views..s(Qq(s )rrr!rrr\rr9r?r rirrr _make_viewr)rZr~r>rr)r%r7rrrettysrnrr.r array_indices sub_indicesr narraysrr/s rDr3z+make_nditer_cls..NdIter._make_viewssNFW$E((H}}H((F&%//2f  %g0||G$8$8'1$MN0G0!$Hh 7 N W),&1a%g&7&7H S="-dd"3K&NA 8+++#w/5ay/5ay&)W NE!HN N(%(( ((L0s"-Dct|tjr|jdk(sJ|j |||||}|j |||} t ||} |j|tjtjdd} |j|tjtjdd} t| || | | d| S)zD Compute a 0d view for a given input array. rrN)r) rrrrqrryrrrrr) rZr~r>rrYrrr.rlviewrrfrs rDr?z*make_nditer_cls..NdIter._make_views eU[[1ejjAo EE))'7GUCPC,7%%e,Wg>D#GU3H&&wuzz10M')+E((%..Q2O)+-G 4eWh MKrFcg}tt||D]j\}\}}t|tjr*|j |j ||||M|j t|d|zl|S)Nrr!)rrrrrrjryr ) rZr~r>r)r%rrnrrs rDr&z2make_nditer_cls..NdIter._arrays_or_scalarssA#,S-@#A <=@BCHHWT:>:;  <HrFN)rrrsrtrrIrrrr8r5r6r3r?r&) rr rrrr rCrqrr/s rDNdIterrsO   " "   # M 8^( +T M  J  8 ( rFrG)rqr rr%robjectr rx) rrrGrr rrrr rCrqr/s ` @@@@@@@@@rDmake_nditer_clsrI s ==D __F(//"G33dGf86k6@ 2[ 2GG VV,,X6Vp MrFc`|jGfddtj|}|S)zr Return the Structure representation of the given *nditerty* (an instance of types.NumpyNdIndexType). c&eZdZdZfdZfdZy)%make_ndindex_cls..NdIndexIterz, .ndindex() implementation. c|jtjd}tj||j |jtj }tj |tj}t D]}tj|||}|j||||} |jd| |} tj|| 5|jtj|ddd||_||_tj |||j |_y#1swYxYwNrrr)rrrr rXr:rrr9rir$rr2rrr(rkrf) rZr~r>rrrr(rrr dim_is_emptyrqs rDrz3make_ndindex_cls..NdIndexIter.init_specifics''' A6D))'499/6/C/CEJJDH0JKG 11'7;M;MNIT{ @ --gwD dF+"#;&44T8TJ ((,?@MM'"3"3Y?@@ @#DL&DN ++GVTYYGDJ @@s +!E  E c n|jtjd}|jd}t j ||j |j}t j||5|jd|j|dddt Dcgc]2}|j t j||j|4}}|D]} t|| |jt j |||j"|jdt j$||j& } t)|| | |j|j|j||j+|y#1swY xYwcc}w)NrrFT)rrrrr r1r?r(r2rrr9rirrJr"rkr:rrfrr) rZr~r>r%rrr(rrr?rfrqs rDr8z7make_ndindex_cls..NdIndexIter.iternext_specificsq'' A6D..u5E++G,3LL,HJI$$Wi8 &  'u% &#(+/||G$8$89=9<%>?/G/  -gt, - MM',,WgtyyI J   T "(($**dCE wu#||T^^ = NN5 !  # #E *' & &/s8#F%07F2%F/N)rrrsrtrrr8rqsrD NdIndexIterrLs  H, +rFrR)rqr rx)rrRrqs @rDmake_ndindex_clsrSs. ==D5+g11(;5+n rFcdvsJ|j}|jdk(r"Gfddtj|}|SGfddtj|}|S)N)rrrc2eZdZdZfdZfdZdZdZy)6_make_flattening_iter_cls..CContiguousFlatIterzZ .flat() / .ndenumerate() implementation for C-contiguous arrays. c|jtjd}tj|||_|j |_ dk(rtj||j|jtj|j}t|jD]+}tj|||}|j||-||_yy)Nrrr)rrrr rrrrrXr:rqr9rir$r) rZr~r>rrrrrrrs rDrzD_make_flattening_iter_cls..CContiguousFlatIter.init_specificBs++EJJ:$66wE "ll =(%11$11%**ejjIKG %UZZ04!(!5!5gw!L dF34$+DL)rFc b|j}|j}|j|j}|j d||} |j | t j|| 5|j|j|g} t|||| } dk(r|j| n|j} t|D cgc](} |jt j|| | *}} t j|||j!t"j$}|jt j&||| gt)||||| t j*||}|j-||jdddycc} w#1swYyxYw)NrrrS)rqrr?rrrr rr rrr"rr9rirkr{rrmake_anonymous_structrr#r$)rZr~r>rrr%rqrrr(rlrrridxvalsidxtuplers rDr8zH_make_flattening_iter_cls..CContiguousFlatIter.iternext_specific[szz TZZ0"..sE6B  *&&w95!++chh8C%gwsCEv~ e,#',,/4Dk#;(+$+<<0D0DWELEH1J$K#;#;$+#5#5gw9@9N9N:?**:F$G #99';CU:KMN1'514g?$33GUCEMM%4-55#;55s /AF% -F 8BF% F%%F.cX|j|j|g}t||||SrP)r rrrZr~r>rrrrls rDrz>_make_flattening_iter_cls..CContiguousFlatIter.getitem{s)kk#((UG4 '5#>>rFc\|j|j|g}t|||||yrP)r rrrZr~r>rrrrrls rDsetitemz>_make_flattening_iter_cls..CContiguousFlatIter.setitems(kk#((UG47GUE3?rFN)rrrsrtrrr8rrarsrDCContiguousFlatIterrV=s  +2 5@ ? @rFrcc4eZdZdZdZfdZdZdZdZy)+_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|jtjd}|j}|j}t j ||j|}t j||j|jtj|j} t j||j|jtj|j} t j|t j} t|D]} t j|| | } t j|| | }|j|||j|| || }|jd||}t j ||5|jt j"| ddd| |_| |_| |_y#1swYxYwrN)rrrrrqr rrfrXr:rrr9rir$rr2rrpointersr()rZr~r>rrrrrqrrrgr(rrptrptrrrOs rDrz9_make_flattening_iter_cls..FlatIter.init_specifics++EJJ:xxzz --gsyy$G!--TYYW-A-A%**BG**.NO#..TYYW-A-A%**BG**.NO$55g6=6H6HJ !; DC$11'7CHF$11'8SIFMM$/MM$/ &c{H#*#8#8x#NL ,,WlCD g&7&7CDD D ' ( !* DDs !G!!G* c H|j}tj||j|}tj||j|}|j } |j } |jtjd} |jd} tj||j|j} tj|| 5|jd|j!| ddd|jdtj"|| |dz }|j|}t%||||}dk(r|j'|nyt)|Dcgc](}|jtj"|| |*}}tj*||}|j'tj,|||gt/t)|D]>}tj"|| |}tj0||j|}||}||}|j3d||}tj4||5|j7||tj"|| |}|j|}tj8|||}|j7||t)|dz|D]+}tj"|| |}|j7||-|j!| ddd|j7| |A|j7tj:|j|j!| |j=| y#1swYxYwcc}w#1swY}xYw)NrrFTrHrr)rqr rrfrrrgrrrrr1r?r(r2rrrirr"r9rkrZrr#rrr$rrr)rZr~r>rrr%rqrrrrgrr is_exhaustedlast_ptrrlrrr[r\rrrrrrh inner_dimrs rDr8z=_make_flattening_iter_cls..FlatIter.iternext_specifics7zz --gsyy$G!..w TJ,,==++EJJ:2259 '22W\\$..9 ; ((,?*$$U+NN5)*  &#//4!8Lll8,!'7E3?6>MM%( +0+7$' '||G,@,@AHAD-F G7G7 '11'7CHMM55g7?6GIJ $E$K00C$11'7CHF!11'29,,v2FHC#3KE$S\F ' 3 3Ce DI **7I> . c62!(!5!5gx!M%ll62%11'3G c62).sQw)=7I%,%9%9':B:C&EF$MM#v6 7  u- .MM$//04 g//@u%''.k**7& . .s#N7-N*B2NNN! c |j}tj||j|}tj||j|}g} t t |D];} | j|j||| |j||| }=| jtj|||j|||j| } | S)Nr )rqr rrfrrr9rjuremudivreverserrr ) rZr~r>rrrrqrrrrrls rD_ptr_for_indexz:_make_flattening_iter_cls..FlatIter._ptr_for_indexszz --gsyyM!..w 4P#E$K0=CNN7<<vc{#CD#LLs .FlatIter.getitems+))'7E3N '5#>>rFcL|j|||||}t|||||yrP)rqrr`s rDraz3_make_flattening_iter_cls..FlatIter.setitem s*))'7E3N7GUE3?rFN) rrrsrtrrr8rqrrarbsrDFlatIterres%  +BC /J " ? @rFrt)rcr r rx)rrrcrcrts ` rDrr7sr * ** *&&JCD @'"="=j"ID @L#"E @w22:>E @NrFrc>ttj|}|||}||_|j |}||||j d}|j |||||j}t||tj||SNr)r[) rr NumpyFlatTyperryrhrrr )r~r>rr flatiterclsflatiterarrclsr s rDmake_array_flatiterr{s%e&9&9%&@AK7G,HHN    &F 'x'@'@'I JC 7GUC8    C Wgu/B/B5/I3 OOrFc|j\}|\}t|}||||}|j}|j|} | |||j} |j |||| |yrL)rrrcryrr8) r~r>r\rr%rryrxrrzrs rDiternext_numpy_flatiterr} sq88LZJX%j1K7G8r\rrryrrxrrzrr s rDiternext_numpy_getitemr0s!JOHe%j1K7G8r\rrryrrrxrrzrs rDiternext_numpy_getitem_anyr@s!J!HeU%j1K7G8r\rrrxryrzrs rDiternext_numpy_getitem_flatrQs]!J%j1K7G47;H    5 5 6F ' 8C ::rFcP|j\}|\}ttj|}|||}||_|j |}||||j d}|j|||||j} t|||j| Srv) rrrNumpyNdEnumerateTyperryrhrrr r) r~r>r\rrr nditerclsrrzr s rDmake_array_ndenumerater\s XXFE DC*5+E+Ee+LMI w (FFL    &F 'v'>'>w'G HC '5#6    C Wgs DDrFc|j\}|\}t|}||||}|j}|j|} | |||j} |j |||| |yrL)rrrcryrr8) r~r>r\rr%rrrrrzrs rDiternext_numpy_nditerrnsqJXHV*84I wv 6F   E    &F ' 6C Wguc6BrFc tt|j|Dcgc]'\}}|j|||tj)}}}t tj t|}|||}|j||||j} t|||j| Scc}}w)zndindex(*shape)) rrrrrrSNumpyNdIndexTyperrrr r) r~r>r\rargtyrrfrrr s rDmake_array_ndindexr~s #388T2 4\\'3uzz : 4E 4!!7!7E !CDI w (F '51    C Wgs DD 4s,B4c |jj}|dkDre|jdj}|d}t j |||}|Dcgc]$}|j |||tj&}}ng}ttjt|} | ||} | j|||| j} t|||j| Scc}w)zndindex(shape)r)rrqrr|r rrrrrSrrrrr ) r~r>r\rrqrrYrfrrrr s rDmake_array_ndindex_tuplers ??  D ax !!1g$$Wc48!#gsE5::>## !7!7E !CDI w (F '51    C Wgs DD#s)C.cz|j\}|\}t|}||||}|j|||yrL)rrSr8)r~r>r\rr%rrrs rDiternext_numpy_ndindexrs@JXHV *I wv 6F Wgv6rFcH|j}|j}t|jdtj rt j||d}n|dg}t|||}|j|||||j}t||||S)z nditer(...) r) rr%rrrr\r rrIrrr ) r~r>r\rrr)r%rr s rDmake_array_nditerrs H __F#((1+u/%%gtAw7q' &_X &w 8F '66:    C Wgx ==rFcv|j\}|\}t||||}|j|||yrL)rrIr8)r~r>r\rr%rrs rDiternext_numpy_nditer2rs=JXHV &_X &wv FF Wgv6rFc|j\}}tjtjdt ||k(}t |||j |Sr)rrrrprr"r)r~r>r\rarg1arg2r s rD dtype_eq_implrsEJD$ ++bjjmS%6 7C gw EErFct|}|||}|j|j}|jtj t ||}|jtj d}ttjdd} |D]H} |j|| } |j| d}|j| |j| d} J|jdk(rd} n|jdk(rO|g} t|ddD]&} | j!|j#| d| (t%t| } np|jdk(r=|g} |ddD]&} | j!|j#| d| (t%| } n$t'dj)|j|j||}|j|d}|j| |j|d} |j+| d 5|j,j/|t0d ddd|j}|j3|}|jtj4|}|j7||f}t j8tj:}t j<t?|}tA||tj tj4}|jC|tD||}|jFjI||}|jKtj }tMjN||| }tMjN|| | }tQ||jS||jU|||| |S#1swYyxYw)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. rHrrrNrrz3Don't know how to allocate array with layout '{0}'.Fri)z[array is too big; `arr.size * arr.dtype.itemsize` is larger than the maximum possible size.rYr)+ryr{r|rrrrrrrpsmul_with_overflowrcrrqr rrjrrrSrr rkrlrget_preferred_array_alignmentuint32rqMemInfoPointervoidptrTypeRefr:r$r_call_allocatorr meminfo_datarr rkrr>r)r~r>rarrrdatatyperarrlenoverflowr arrlen_multrdimension_sizeallocsize_multrEr| align_valrrmip arytypeclassargtypesrrr shape_array strides_arrays rDrrsO  F ' "C$$W]]3H##EJJ Wg0NOH ! !%**a 0F 1 q)H  00; &&{A6;; g++K;  ||q 3 *&vabz2 EN NN7;;wr{NC D E)* 3 *$Sbk EN NN7;;wr{NC D E.! A H H ! ! //AN%%na8I{{8W%:%:>1%MNH % 0  )) Z -   MME55e.impl,sIu--rFr)rrErrs rD_ol_array_allocater's . KrFc&|j||S)z9Trampoline to call the intrinsic used for allocation )r)rarrs rDrr1s   T5 ))rFcpd}tjtj}t|||}||fS)z3Intrinsic to call into the allocator for Array cJ|\}}|jj|||}|SrP)rmeminfo_alloc_aligned)r~r>r$rrErrs rDrjzintrin_alloc..codegen;s)!E++33GYNrF)rrrr$)rkrErrjrr\s rDrr7s5   u}} -C CE *C <rFc d}t|tjr&d}|j|||tjg}n@t|tj sJ|j }tj|||}g}|D]&}|j||||j|(|j|tjd} t|D]X} |jd|| | } tj|| 5|jj!|t"ddddZ|S#1swYfxYw)z; Parse the shape argument to an array constructor. c|jtj}|j}t j |}t |d|dz zdz }|j|kr|j||}|S|j|k\ru|jd||} |j| d5|jj|tdddd|j|kDr|j||}|S|}S#1swY0xYw)z0Cast src to intp only if value can be maintainedrH>Fri)z#Cannot safely convert value to intpN)rrrrIrrprsextrr rkrlrtrunc) r~r>src_trDr intp_widthintp_irmaxvalr  is_largers rD safecast_intpz#_parse_shape..safecast_intpIs'' 3\\ **Z('Q*q.%8A$=? ;; #,,sG,C [[J &++Cf=I59 !!11Z<  {{Z'mmC1    s ."C??DrHr rr)znegative dimensions not allowedN)rrrrrr\rr rrjr:get_constant_genericr9rr2rkrlr) r~r>rSrrrq passed_shapesrrrris_negs rD _parse_shaperEs+*"emm$ gsB CD "eoo...xx,,WcF F B mGWaffa@AB  ' 'Q ?DT{$$S&+t<  & 1     - -%I    M   s "D::E cb|jd}|d}|j}|t||||fS)zL Parse the arguments of a np.empty(), np.zeros() or np.ones() call. r)rrr)r~r>r\r arrshapetypearrshaperas rD_parse_empty_argsrus988A;LAwHooG L'<J JJrFc|jd}t|tjrQt ||||d}t j ||j|j}|j|fS|jdfS)z_ Parse the arguments of a np.empty_like(), np.zeros_like() or np.ones_like() call. rrr r) rrrrryr rrfrqr)r~r>r\rarytyperrs rDririsr hhqkG'5;;'!j!'7$q'B%%gsyy M&&""rFcnt|tjrd|d}tj|y)NzIf np.z0 dtype is a string it must be a string constant.)rr UnicodeTyper r)fnamer|rs rD_check_const_str_dtypers7%**+ugMN  %%,rFc<|j}||||}d}||fS)Nc`t||||\}}t||||}|jSrP)rrrr r>r\r rarrs rDrjznumpy_empty_nd..codegens2+E7CHUGWf=}}rF instance_type)r ty_shapety_dtype ty_retty_refty_rettyr\rjs rDnumpy_empty_ndrs,))H 8X| 4C <rFcvtd||tus7t|tjr|j tus t |rtj}n t|}t|}|'|%tj||dtffd }|Sd|d|d}tj|)Nrrrct||SrP)r)rfr|rYs rDrzol_np_empty..impls!%6 6rFz.Cannot parse input types to function np.empty(rr) rfloatrrFunction typing_keyrdoublety_parse_dtypety_parse_shaperr r)rfr|nb_dtyperqrrrYs @rD ol_np_emptyrs7E*  E5>> *u/?/?5/H  <<!%( % D 0 (cB# 7 >ugRwaP  %%rFc<|j}||||}d}||fS)Nc`t||||\}}t||||}|jSrP)rirrrs rDrjz$numpy_empty_like_nd..codegens20fMUGWf=}}rFr)r  ty_prototyperrrr\rjs rDnumpy_empty_like_ndrs,))H << 8C <rFctd|t|s t|}n)t|tj r |j }n|}|dt|tj r2|jdk7r |jnd}|j||dn6t j |ddnd|d|d }tj|d fd }|S) Nrr^rF)r|r rfrz3Cannot parse input types to function np.empty_like(rrct||SrP)r)rr|rYs rDrzol_np_empty_like..impls"3u55rFrP) rrrrrrr|r r`r r)rr|rr rrrYs @rDol_np_empty_likers</ u !%( C %99 c5;; '#&::#4SZZ#FHH8FUHKEKK!S1E #uBugQ0  %%6 KrFc:tj|}d}||fS)Nct|jd|||d}tj||j|j |j |jdyr)ryrr rjrrrr)r r>r\r rs rDrjz(_zero_fill_array_method..codegensO%j!%eWfQi@w'++cllCJJ*O rF)rr')r rZr\rjs rD_zero_fill_array_methodrs! **T C <rF _zero_fillc d}|S)z?Adds a `._zero_fill` method to zero fill an array using memset.ct|yrP)rrvs rDrz ol_array_zero_fill..impls %rFr)rZrs rDol_array_zero_fillrs & KrFc0td|tfd}|S)NrncTtj||}|j|SNr)r~rr)rfr|rs rDrzol_np_zeros..impls!hhuE*  rF)rrrfr|rs rD ol_np_zerosrs7E* KrFc&td|dd}|S)N zeros_likecTtj||}|j|Sr)r~rr)rr|rs rDrzol_np_zeros_like..impls!mmAU+  rFrPrrs rDol_np_zeros_likers</ KrFc&td|dd}|S)N ones_likectj||}|j}tt |D]}d||< |SNrrHr~rrr9r)rr|rarr_flatrs rDrzol_np_ones_like..impl sAmmAU+88X' CHSM  rFrPrrs rDol_np_ones_likers;. KrFc^td|t|s t|n|dfd }|S)Nfullctj|}|j}tt |D]}|||< |SrPr~rrr9r)rf fill_valuer|rrrrs rDrzimpl_np_full..fullsBhhuh'88X' 'C&HSM ' rFrP)rrr)rfr r|rrs @rD impl_np_fullr s065) u !%( KrFc&td|dd}|S)Nrctj||}|j}tt |D]}|||< |SrPr)rr r|rrrs rDrz$impl_np_full_like..full_like'sAmmAu%88X' 'C&HSM ' rFrPr)rr r|rs rDimpl_np_full_liker#s;. rFc&td|dd}|S)Nonesctj||}|j}tt |D]}d||< |Srr )rfr|rrrs rDrzol_np_ones..impl7sAhhuE*88X' CHSM  rFrPrrs rD ol_np_onesr1s65) KrFcztd|t|s t|ntjdfd }|S)Nidentitycftj||f}t|D] }d|||f< |Sr)r~rnr9)rr|rrnrs rDrz"impl_np_identity..identityHs<hh1vx(q AC1I  rFrP)rrrrr)rr|rrs @rDimpl_np_identityr@s4:u- u !%(<< OrFcyrPrNMs rD_eye_none_handlerrPrrFcJt|tjrd}|Sd}|S)Nc|SrPrrs rDrz$_eye_none_handler_impl..implWHrFc|SrPrrs rDrz$_eye_none_handler_impl..implZrrF)rrrK)rrrs rD_eye_none_handler_implr Ts&!U^^$  K  KrFc:|t|tjrtjt nVt|tj tjfrtt|d|ntj|ddt ffd }|S)Nr|rct||}tj||f}|dk\r+t|||z }t |D] }d||||zf<|St||z|}t |D] }d|||z |f<|Sr)rr~rnrr9) rrrr|_Mrdrnrs rDrznumpy_eye..impljs q! $hh2w# 6ArAvA1X " !Aq1uH  "  AE2A1X " !AE1H  " rF) rrrKr~r|r DTypeSpecrr r )rrrr|rrs @rD numpy_eyer&_sn } 5%..9 XXe_ EEOOU\\: ; geWe4 5 XXe_!5  KrFct|stjdt|tj r)|j dvrtjddd}|Sy)N#The argument "v" must be array-like)rHrozInput must be 1- or 2-d.ch|jdk(r|j}|dt|z}tj||f|j }|dk\r"t ||z D]}||||||zf<|St ||zD]}|||||z |f<|S|j\}}|dkr||z}|dkDr||z }tt||d}tj||j }|dk\rt |D]}||||zf||<|St |D]}|||z |f||<|Sr) rqrfrr~rnr|r9rrr)rrrrrlrnrowscolss rD diag_implzimpl_np_diag..diag_implsdvv{GGaD3q6Mhh1vqww/6"1q5\-()!Aq1uH -  #1q5\-()!AE1H - WW dq5!8Dq5!8DD$+hhq!''*6"1X-!"1a!e8A-  #1X-!"1q5!8A- rFr)rr rrrrrqNumbaTypeError)rrr,s rD impl_np_diagr.ysZ A   !FGG!U[[! 66 ''(BC C 6?"rFct|tjsd}tj|t|j tj sd}tj|t|dzfd}|S)Nz5The argument "dimensions" must be a tuple of integersrctjf|ztj}d}|D]K}tj|tjj t ||}|||<|dz }M|S)NrrrH)r~rrarangerer0) dimensionsr rnrrrrfs rDrznumpy_indices..implsxhhtj(9  C))Crxx088eQ,CCF FA   rF)rrrr rr|rr)r2rrrrfs @@rD numpy_indicesr3so j%.. 1E  %% j&& 6E  %% JA 1HE  KrFct|sd}tj|t|tt j fsd}tj|dd}|S)Nr(z#The argument "k" must be an integercdtj|}|j}t|}t |}||z}tj ||f|j }tjd| }tjd|}t|D]}|||||z||zf<|Sr) r~rrmrrrnr|maximumr9) rrrabs_krr rnjts rDrznumpy_diagflat..impls JJqM GGI FA Ihh1vqww' JJq1"  JJq! q %A !!CAq1u  % rFr)rr rrrrr)rrrrs rDnumpy_diagflatr:sU A 3  %% a#u}}- .3  %%  KrFcn|dvsJ|dk(r4d}td|D]"}d|z}|d|ddj|d z }$n3d }td|D]"}d|z}|d|d dj|d z }$tj|}t |t t d |}t |S)N)rrarzv def _getitem(a, idx, axis): if axis == 0: return a[idx, ...] rH):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)r9rtextwrapdedentexecglobalsr&)rqrrLrnlsts rD"generate_getitem_setitem_with_axisrBs ) )) ) y  q$ A1*C S!"iin-.  B   q$ A1*C S!yy~&'  B   BWY Qtf: B B rFtakec tj|rt|tjr t|tj rd d}|St|tjr1t|tjr|j dk(d fd }|St|tjr1t|tjtjfrd d}|Syyt|tjrBt|tj r(d|jdz z t fdd fd }|St|tjrgt|tjtjtjfr-|j}t|d t|d d fd }|Syy) Nc||jdz kDs||j kr td|j|S)NrHIndex out of bounds)r IndexErrorrm)rrrs rD take_implznumpy_take..take_impls<affqj)Ww->$%:;;wwy))rFrctj|j|j} r|j }n|}tj |}d}|j }|D]<}||jdz kDs||j kr td||||<|dz}>|j|jS)NrrrHrF) r~rrr|r`rrmrGrerf) rrrrlwalkeritrnrrXF_orders rDrHznumpy_take..take_impl shhw||177;$\\^F$FYYv&wwyAAFFQJ'1w;()>??!!WCFAA  {{7==11rFcXtj|}tj||SrP)r~rrC)rrrconverts rDrHznumpy_take..take_impls!((7+wwq'**rFrrHcJt}d}|t|jkr|j|dk(sJ|jtt|jD])}|j|}||k7st |||}|dz }+|j |Sr)rrrfr9r0re)rrrYr8rrr9s rD_squeezeznumpy_take.._squeeze'sAhc!''l*qwwt}/AJ177JA QWW.C Ad{+CA6Q  yy~%rFctj||f|}|jdk(r|dS|dkr||jz }||S)Nr}rHr)r~rCrq)rrrrrPs rDrHznumpy_take..take_impl3sNGGAz566Q;Q4K!8AFFND4((rFrracz|}|dkr||jz }|dks||jk\rd|d|j}t|t|j|t |}t j ||j}tt |D]} ||||} |||||S)Nrzaxis z) is out of bounds for array of dimension r) rqrr0rfrr~rr|r9) rrrrrrfr rnrY_getitem_setitems rDrHznumpy_take..take_implJs!8AFFND!8tqvv~"2$'++,66(4C$S/)%aggtS\BhhuAGG4s7|,.A GAJ5AS!T1-. rFrP) r rrrrrr rr\rqr&rB) rrrrHrqrLrSrTrPr9s @@@@@rD numpy_takerUsb4 a %*Wemm*L *  a %*Wekk*Jnn+G 2  a %7UZZ$AB +  C & a %*Wemm*L #A  & & )  a %7U[[%**eoo$NO66D9$ JH9$ JH   /P &rFc|Dcgc]}t|tjr|!}}td|Drtj}|Std|Drtj }|St tddtjtjzz}|Dcgc]}tj|}}t||gz}|Scc}wcc}w)Nc3PK|]}t|tj ywrPr#rRrs rDrTz _arange_dtype..`s 8A:a ' 8rUc3PK|]}t|tj ywrP)rrFloatrXs rDrTz _arange_dtype..bs 8AZ5;; ' 8rUzint%sr) rrrKrV complex128rr r~r|rr unliteralr)rrboundsr|NPY_TYrXunliteral_boundss rD _arange_dtyper`]s CAZ5>>%Ba CF C 8 88  & L% 8 8 8 " L 1rxx}/E/E+E FG9??1EOOA.??$y01 L-D&@sCC.C"c  t|tjr |j}t|tjr |j}t|tjr |j}|tj}|tj}|tj}t|tj r~t|tj tj frTt|tj tj fr*t|tj tjfsyt|tj rt||| n |j t|||fDcgc]}t|tjc} t|ddt|ddt|ddd fd }|Scc}w)Nrcn|}n|}n|}||nd}|d|} }n||} }|dk(r td| |z |z } ttj| j} dur?ttj| j } t t| | d} n t | d} tj| }|}t| D] }|||zz||<|S)NrHrzMaximum allowed size exceededT) rrmathceilr)r+rrr~rr9)r4rrr| lit_startlit_stoplit_step_step_start_stopnitems_cnitems_rnitems_irrrrn start_value step_value stop_value true_dtype use_complexs rDrznp_arange..impls#.#:K !+!7:T!+!7:T$0a  yEF%xEF A:<= =FNe+tyy/0 $ 499X]]34HXx0!4F1%Fhhvz*v 'AAI&CF ' rFr) rrOptionalr:r'rrKr%r`r|rVr$r ) r4rrr|rXrrnrorprqrrs @@@@@rD np_arangertwsb$'yy$'yy%(  |zz |zz }  uell + tennell; < tennell; <55>>5??"CD%("5$5 [[ !&d 35"!U]]356K%$7K5J5J< KK5s!G"ctd||fDsyt|ttjfsd}t j |td||fDrtjntjdfd }|S)Nc3PK|]}t|tj ywrP)rrrr%s rDrTz!numpy_linspace..sFz#u||,FrUr!c3PK|]}t|tj ywrPr#r%s rDrTz!numpy_linspace..r&rUctj|}|dz}|dz}|dk(r|S|dz }|dkDr8||z }tj||}td|D] }|||zz||<n||d<|dkDr||d<|S)Ng?rrHr)r~rdivider9) r4rrrdivdeltarrnr|s rDrz numpy_linspace..linspaceshhsE"  cz !8JAg 75LE99UC(D1c] ,!d(+A ,CF 7CG rFr) rrrrrr rrVr[r)r4rrrrr|s @rDnumpy_linspacer|ss F F F cC/ 05  %% CeT] CC   , OrFc |jd}t||||d}tj||j}|j }t ||||}|j} |j} |jdvsJ|j|jk(r0tj|| | |j|jdntj||j} tj||j} |jtj} tj ||| 5}tj"||| || |j|}tj"||| || |j|}|j%|j'||dddt)|||j |j+S#1swY/xYw)z Array copy. rrrrHrN)rryr rrfrrrr  raw_memcpyrrrrrrrCrr$r?r!r)r~r>r\rrrrrettyperlr7rr9rrrr/rFs rD _array_copyrshhqkG *W gwd1g >C  ! !'399 5FooG '7F ;CxxHI >>T !! !~~'7Ix<.numpy_copys (+ +rFc,tj|SrP)r~rrs rDrz#impl_numpy_copy..numpy_copy s::a= rF)rr rrrr)rrs rDimpl_numpy_copyrsL A   "12 2!U[[! ,  ! rFc D|j}|jd}|j|k(sJd|jdk(r|jdk(sJt ||||d}t |||}|j |t jt jdd} |j|t jt jd|jf} t||j| | |j|j|jt||||j!S|j|jk(s|jdk(r|jdvrt||||dS|jdk(r|dvsJ|dk(rt"nt$} t'| ||||d} |j)| 5\} }| 5t||||d}|j*}d d d |5t-||||}|j*}d d d d d d |j/j0}|j3||j3|St-||||S#1swYxYw#1swYlxYw#1swYpxYw) zd Common logic for layout conversion function; e.g. ascontiguousarray and asfortranarray rz return-type has incorrect layoutrHrrrr^rN)rrr rqryrrrrrrrrrrr rrrrXr-blockrphir: add_incoming)r~r>r\r output_layoutrYrrrlrfr check_funcr7thenorelseout_thenthen_blk out_orelse orelse_blkret_phis rD_as_layout_arrayr&sq OOE HHQKE <<= (L*LL ( zzQzzQjQ@j1,, U^^EJJ2D $$W%*^^EJJ%B&)ll_6 sCHHeWcll{{CJJ 0 '5#--/JJ ,,%,, & aELLD$8 '5$q'BB <<3  !D( ((*73*>JJ.z/6/6/4/3Aw 8I + /~f-0'515a :H&}}H- /!,WgsD!IJ!(J/ /kk(--0G  8 4  Z 8Nwd; ;!-- // / /s<JI>: JJ J>J J J JJcttjstj|j j t|jdd}||}|fdfS)NrHF)r rqrfc8t||||jS)N)r)rr)rrrrrs rDrz,_as_layout_array_intrinsic..ss#3 1a-"="=$?rF) rrr%r RequireLiteralValuer`rrrq)rkrrrlr\s ` rD_as_layout_array_intrinsicrgsr mU%8%8 9((77 &&** ^  C a C ? ??rFct|stjdt|tj tj frd}|St|tjrd}S)NrkcRtjtj|SrP)r~ascontiguousarrayrrs rDrz%array_ascontiguousarray..impl}s'' 4 4rFct|dSNrrrs rDrz%array_ascontiguousarray..impl-a5 5rFrr rrrrrrrs rDarray_ascontiguousarrayrwsY A   !FGG!ellEMM34 5 K Au{{ # 6 KrFct|stjdt|tj tj frd}|St|tjrd}|Sy)NrkcRtjtj|SrP)r~asfortranarrayrrs rDrz"array_asfortranarray..impls$$RXXa[1 1rFct|dS)Nrrrs rDrz"array_asfortranarray..implrrFrrs rDarray_asfortranarrayrsZ A   !FGG!ellEMM34 2 Au{{ # 6  $rFz array.astypec r|jd}t||||d}tj||j}|j }t ||||}|j} |j} tj||j} tj||j} |jtj} tj||| 5}tj||| || |j|}tj||| || |j|}t||||}|j!|||j"|j"}t%|||||dddt'|||j |j)S#1swY/xYwr)rryr rrfrrrrrrrrCrr rrr|rr!r)r~r>r\rrrrrrlr7rr9rrrr/rFitems rD array_astypers{hhqkG *W gwd1g >C  ! !'399 5FooG '7F ;CxxHI&&w w++GWh,2K,3NNGE,,Wgy-3\-4^^WF'7G<||GT7=='--H7GWdH= > GWcoos}} OO > >s /BF--F6c^t|tjsJt|}d}||fS)Nc |j\}t|}||||d}|j}|j||j}t |||} |j rV|jdk(rGtj|| j|j|j|| j7Stj||j} tj||j} |j} |jtj } tj"|| dd}tj$|| | 5}tj&|||j| | | |}|j)|| jj*}|j-|}|j/| j|g}tj0|||||j3|j5|||ddd| j7S#1swY| j7SxYw)NrrbyteptrT)namerP)rryrrrr.r;r r r~rrrfrrrrrXrCrr>r:r?r rr$rr)r~r>r\rrSrrrr2bstrrfrr rbyteidxrrlsrcptrrdestptrs rDrjz)_array_tobytes_intrinsic..codegensxx2GWd1g.<<Xszz2#GWf= NNryyC/   w 388SZZ' ).~~)((#)).impls +C0 0rFrQr|s rDimpl_array_tobytesrs#u{{# 1 $rFc@|j}||||||}d}||fS)Nc |jd}|d}|d}|j}t||||d}t|} | ||} | j} t ||} t |j j| } |j|j|j }|j|| }|j||}|jd|tj |jd}d}|j|d5|jj|t |fddd|jd|tj |jd}|j#|| }t%j&||}|j|d5d }|jj|t |fddd|j)|5\}}|5|j*}|j-|| }ddd|5|j*}dddddd|j/|j}|j1|j1||j|| }|j3d ||}|j|d5d }|jj|t |fdddt%j4||g}t%j4|| g}|j7|j8|g}|j;||j=| j?d }tA| |||| |jB|jD | jG} tI|||j| S#1swYmxYw#1swYxYw#1swYxYw#1swYxYw#1swYxYw#1swYxYw)Nrror;rrz=offset must be non-negative and no greater than buffer lengthFriz.buffer size must be a multiple of element sizerz%buffer is smaller than requested sizerrE)%rrryrrrrr:rrrrrr rkrlrsremr is_not_nullr- basic_blocksdivrrrrkr rr>rrrrrrr )!r~r>r\rbufty arg_count arg_offsetrr out_ary_tyout_ary out_datamodelr ll_itemsizer2ll_offset_sizenbytes_is_negativerll_count_is_negativeremis_incompatible then_block else_blockbb_if num_wholebb_else ll_itemcountll_required_size is_too_largerfrrr s! rDrjznp_frombuffer..codegens G !W jQ@& Wg.** /s||00(; SZZ6 Z=V^4$00   KK  *  N __/_ > K    - -gzC6 J K '22   KK  * ll6;/!--gs; ___U_ ; KBC    - -gzC6 J K __1 2 .6Nz: >++#LL=  > .!-- .  .{{9>>2 !!)U3!!)W5#;;|[A,,S2BFK __\%_ 8 K9C    - -gzC6 J K ""7\N;$$W{m<{{388j\2 '(()?)?)GH  w "& +"{{!jj  *! '3??CHHm K K K K  > > . .  . . K Ks`#N'0%N4.O4O O O*O1%O('N14N>O OO OO%(O2r) rkbufferr|rrrYrSr\rjs rD np_frombufferrs3   B VUE65 1CNI` <rFrctd|t|tjr|jdk7rd|}t j ||tus7t|tjr|jtus t|rtj}n t|}|%tj|dd|j nd|d|d}t j |td d ffd }|S) N frombufferrz+Argument "buffer" must be buffer-like. Got rH)r|rqr rfz3Cannot parse input types to function np.frombuffer(rrrrc"t||||SrP)r)rr|rrrYs rDrz impl_np_frombuffer..implUsVUE65AArF)rrrrr r rrrrrrrrrC)rr|rrrrrrYs @rDimpl_np_frombufferr>s</ fell +v}}/C;F8D  %%  u~~ .53C3Cu3L  <<!%( (3)/%79 &xr%3  %% 1B KrFct|rtdddfd }|St|tjrtd|dfd }|Sy)Nrc||SrPrrlrfr|intrinsic_cfarrays rDrzimpl_carray..impl`$S%0 0rFc||SrPrrs rDrzimpl_carray..implfrrFrPrget_cfarray_intrinsicrrr%rlrfr|rrs @rD impl_carrayr[L51#t< 1 E5?? +1#u= 1 ,rFct|rtdddfd }|St|tjrtd|dfd }|Sy)Nrc||SrPrrs rDrzimpl_farray..implprrFc||SrPrrs rDrzimpl_farray..implvrrFrPrrs @rD impl_farrayrkrrFc(tfd}|S)Ncb|tjurd}nBt|tjr |j}nd|d}t j | |d}t j ||}nft tjr1 j}|>||k7r9d|d|d}t j |d d}t j |t|}|d|d}t j |tj|| }t|||}|tfS)Nz pointer argument expected, got ''z*explicit dtype required for void* argumentzmismatching dtype 'z' for pointer type 'zinvalid dtype spec 'zinvalid shape ') rrrCPointerr|r r-r%rrr$ np_cfarray) rkrlrf ptr_dtyperr|rqrYr\dtype_r s rDrz0get_cfarray_intrinsic..intrinsic_cfarray|s1 %-- I U^^ , I4SE;C'', , > B++C00E  0LLE$));+E72Fse1M++C00(2C'', ,e$ <#E7!,C'', , E40sE*JrFr))r rrs`` rDrr{s> rFc |jdd\}}|dd\}}|j}|jdvsJt|||} t ||} t j | } t|tjrt j||} n|f}|f} t|| D cgc]'\} }|j||| tj)} } }| }g}|jdk(r+| D]%}|j||j||}'nCt!| D]%}|j||j||}'|j#|j%||j'|j(j+}t-| || || d| j/}t1|||j|Scc}} w)zR numba.numpy_support.carray(...) and numba.numpy_support.farray(...). Nrorrr)rrr ryrr rrrr\rrrrrjrrrpr>r{r|rrrr!)r~r>r\rr6rrlrfrrrrrrOroffrrrr s rDrrs XXbq\NE7bqJC OOE <<4  j1GGU+H..*K'5??+%%gu5*#&w#79&%ll7E65::>9F9 CG ||s &A NN3 ++c1%C &&! &A NN3 ++c1%C &  ??3"00=HHJ LD7"'     C GWcoos CC99s0,Gc0t|tjr)|jtjt |St|tj r8|jt ttj|}|||fSJrP) rrr\rrrrrRr$)r~r>seqtyseqrs rD _get_seq_sizersj%)##EJJE ;; E5>> *''Yuzz5-JK#((qrFc|jjtjt |t j fd}|S)zK Return a getitem() implementation that doesn't incref its result. cl||}jrjj|||SrP)rrdecref)r>rrlr~rrYs rDwrapz$_get_borrowing_getitem..wraps37D)    KK  ws 3 rF)r|rRrrr$rr)r~rrrrYs` @@rD_get_borrowing_getitemrsC KKE''(8(8(1% (KML KrFc   jtj}t|d  fd}g}||} }t |D]0} | dkDr ||| \}} |j t || 2t|S)zF Compute the likely shape of a nested sequence (possibly 0d). rct|tjr&t|dk(ry|dj |dfSt |}|j ||ffS)NrNN)rrr\rrcrr|)rrrr>r~rs rDget_first_itemz.compute_sequence_shape..get_first_itemsa eU__ -5zQ!Qx!6!6sA!>>>1'5AL;; WsDk BB BrF)rrrrr9rjrr) r~r>rqrrrrrinnertyinnerrnrs `` @rDcompute_sequence_shapers # #EJJ /F FA DCFCUG 4[G q5+GU;NGU mGWguEFG =rFc<fdfd|||y)z? Check the nested sequence matches the given *shapes*. cHjjtdy)N)zincompatible sequence shape)rkrlr)r>r~srD_failz#check_sequence_shape.._fails))':*J LrFct|dk(ryt ||}|d} jd||} j|d5 dddt|dk(ryt |t j rZt|}tj |5}|j}| ||jf}  || |dddddyt |t jr>tt|D]&} || } j|| }  || |dd(yJ|#1swYxYw#1swYyxYw)NrrhFrirH)rrrr rrrrr rr|rr\r9rc)rrrrexpectedrVrrrrrnrr>check_seq_sizer~s rDrz,check_sequence_shape..check_seq_sizesP v;!  Wguc:!9&&tT8< __Xe_ 4  G  v;!   eU^^ ,1'5AL""7D1 ;T++$WsDJJ.?@wvabz: ; ; u /3u:& ;(--c15wvabz: ; eO1)   ; ;s D<%/E<EENr)r~r>rrrrrs`` @@rDcheck_sequence_shaper s L:5#v&rFcN fd  fd||dy)zl Assign a nested sequence contents to an array. The shape must match the sequence's structure. c tj j|d}j||j}t ||yr )r rr rr|r) rr_rrlrr>r~rrrs rD assign_itemz-assign_sequence_to_array..assign_item<sQ''$(- g%Qll7C <7GUC5rFct|dk(r7t|tjtjfrJ |||y|d}t|tjrit |}t j |5}|j}| ||jf} |||dd||jfzdddyt|tjrctt|D]K} || } j|| }jtj| }  |||dd|| fzMyJ|#1swYyxYwr)rrrrr\rr rr|rr9rcrr)rrrrrrrrrrnrassignr r>r~s rDr z(assign_sequence_to_array..assignBsM v;! !%%..%//)JK KK  , ay eU^^ ,1'5AL""7D1 LT++$WsDJJ.?@wvabz7djj]3JK L L u /3u:& G(--c15,,UZZ;wvabz7eX3EF  G eO1 L Ls >EErNr) r~r>rrrrrrr r s `````` @@rDassign_sequence_to_arrayr5s"66 2 5#vr"rFct||\}}t|r|}nt|}|ytj||dSr)r5rrrr)rkrHr|rq seq_dtypes rDnp_array_typerr^sD,Y?OD)5u% =  ;;udC ((rFcTtd|t|||}|||}d}||fS)Nrc j|j}|j}|jd}|d}t|||||}t ||k(sJt |||||t ||||} t||| j|| j|||t|||j| jSr) rrqrrrrrrrrr!r) r~r>r\rrrqrrrrs rDrjznp_array..codegenoszz 1g'$sK6{d"""Wguc6BWguf= '388V!$eUC A #// # 1 1rF)rr)rkobjr|rlr\rjs rDnp_arrayris67E* C /C c5/C1" <rFctd|t|stjdt |s"t |d}tj|dd}|S)Nrz(The argument "object" must be array-likez:The argument "dtype" must be a data-type if it is providedct||SrP)r)rHr|s rDrzimpl_np_array..impls&&rFrP)rrr rrr)rHr|rrs rD impl_np_arrayrs^7E* F #  "12 2 u ."7"?J  %%' KrFc|jd}|j|}|jd||}|j||j|||}|j |jd|||jd||}|j |d5d|z} |j j|t| fddd|S#1swY|SxYw)NrrrFriz%s(): axis out of bounds) r:rrrrr rkrlrG) r~r>rrqrrll_ndim is_neg_axisaxis_out_of_boundsrs rD_normalize_axisrs 99Q>+w{{4'A4 HD!Ct,D$02 +E :G(94))':vFG K G Ks (CCc vt||dz k(sJtjtj|}tj ||}tjd}t |dz D]z}tj|} |jd| |} ||} |j| |j| || } |j| tj||d| ||j|tj||d|tj||j|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). rHrrrrrr rrXr9rrrr$rirr?) r~r> orig_shaperqrll_shtyrr9rll_dim after_axisrArs rD_insert_axis_in_shaper$s z?dQh && &ll7>>40G  ' 2F .. CTAXI$((vt< _nnZ$[[5#%  b'..w3GHI MM#w++GVQEF   f)= >>rFc t||dz k(sJtjtj|}tj ||}tjd}tjd}t |dz D]x} tj| } |jd| |} |j| |j| || } |j|| tj||d| z|j|tj||d|tj||j|S)zD Same as _insert_axis_in_shape(), but with a strides array. rHrrr) r~r> orig_stridesrqrr!rr9rrr"r#rs rD_insert_axis_in_stridesr's" | q (( (ll7>>40G!!'73G .. C >>! DTAXF$((vt< nnZ$[[5#%  l3'**7GQD F F MM$,,Wgq$GH   g)> ??rFc |j}|j}|jd}t||||d}t|||} t j ||j } t j ||j} t||| ||} t||| ||} t| |j| | |j|j|j| jS)z/ np.expand_dims() with the given axis. rrrE)rrqrryr rrfrr$r'rrrrrr)r~r>r\rrrYrqrrrlrr new_shapes new_stridess rD expand_dimsr+s OOE ::D HHQKE *U GWDG r\rrrls rDrjznp_expand_dims..codegenso||GT!Wchhqk5::Fw1A"33T;'7Ct< '3??CHHrF)rqr r`)rkrrr rlr\rjs rDnp_expand_dimsr.sN1QXX#F &&affqj& 0C a,CI <rFct|tjsd|}tj|t|tj sd|}tj|d}|S)Nz)First argument "a" must be an array. Got z(Argument "axis" must be an integer. Got ct||SrP)r.)rrs rDrz!impl_np_expand_dims..implsa&&rF)rrrr rr)rrrrs rDimpl_np_expand_dimsr1 sb a %9!=  %% dEMM *8?  %%' KrFc0tfdfdS)Nc 0||Dcgc](}|jt|j*c}fd}tt dkDrt j ndt jj||fScc}w)NrQc Ft }tj||d}t| Dcgc]\}}}||||||} }}}t | dkDr|j ||j | } n| d} t|||j | Scc}}}wr)_atleast_nd_transformr rrrrrr )r~r>r\r transformarrsrrrYretsrlr)rminimumr@s rDrjz*_atleast_nd..impl..codegen!s-gt.implsCGHC#((CHHg 6(7H MF aV,VAY++66t<>?FG GIs-Bc|SrPr)rrs rDrz_atleast_nd..1s trFr)r9rrs``@rD _atleast_ndr>sGG( %$rFc6tk(sJfd}|S)z` Return a callback successively inserting 1-sized dimensions at the following axes. c  t D]t}|dz}|j|kstj |}|j |jdz}t ||t j|||f|}|}v|S)NrHrQ)r9rqr rr`r+rr$) r~r>rrrYrnrqrnewarrtyrmin_ndims rDr6z(_atleast_nd_transform..transform;sx !Aq5DzzD ~~d1g. ::5::>::!'7"("2"28U"CcV"&(! ! rF)r)rBrr6s`` rDr5r54s$ s4y    rFcBtd|Dr tddgSy)Nc3PK|]}t|tj ywrPrQr%s rDrTz np_atleast_1d..M 8C:c5;; ' 8rUrHrrr>rs rD np_atleast_1drGKs$ 84 881qc""9rFcDtd|DrtdddgSy)Nc3PK|]}t|tj ywrPrQr%s rDrTz np_atleast_2d..SrErUrorrFrs rD np_atleast_2drJQs& 84 881q!f%%9rFcDtd|DrtdgdSy)Nc3PK|]}t|tj ywrPrQr%s rDrTz np_atleast_3d..YrErUr;)rrrorFrs rD np_atleast_3drMWs" 84 881i((9rFc ft|t|cxk(rt|cxk(rt|k(sJJtjd} t||||} tj|| j } g} |D]} | }t t| | D]_\}\}}|jd|j||}|j||}|j||j|||}a| j|| j}t||||| D]\}}} }}|j}tj|| tj|j }|5}tj"|||| ||j |}t%||||}|j'|||j(|j(}tj"||||| |j |}t+|||||dddtj,|||}| S#1swY$xYw)z2 Concatenate arrays along the given axis. rr)orderN)rr rrrrrrrr:rrrrjrrCr rrrr|rr)r~r>rr)r7 arr_shapes arr_stridesrY ret_shapesrrl ret_strides copy_offsetsarr_shrrrris_axisaddendret_datarrarr_starr_datarCrr/rrFs rD_do_concatenater[]s, v;#d) Js: J#k:J JJ JJ J >>! D '5* =C&&w  ?&&w&A+B. J ? ?s 4BH''H0 c x|j}t||Dcgc]\}}t||||}}}t||d||}|D cgc]"} t j || j $} } |D cgc]"} t j || j$} } | dD cgc]} t j|| } } t|D]C}|jd|j||}| |}|j|}| ddD cgc]} | | }} |j|5\}}|5tj|j ||gz} |j#| |ddd|5tj$}|D]%} |j'||jd| |}'|j)|j+|d5|j,j/|t0d|zfdddddddddF| D cgc]} |j| } } t3|||||| | || }t5||||j7Scc}}wcc} wcc} wcc} wcc} w#1swYxYw#1swYxYw#1swYxYw#1swYxYwcc} w) Nrnp.concatenaterrrHFrizr)r7rYrrqrrrrPrQrArRrrV ret_shape_ptrret_sh other_shapeson_axis on_other_dimis_okrls rD_np_concatenaterds ::Dfd+ -Q JsOGWA 6 -D - 7G-=tT JDGKKs'&&w :KJKIMN#7''=NKN 'qM+++GR8+J+T{>%%dDIIcNDA"3 m,*4QR.9B39 9 __W % >)@'< 1%%KK F8+- b-0  1  >((&PB#LL)0)<)%%5557:;=>> > > > >0.88r',,r"8J8 '7D $ K -C GWeS]]_ EEY - LN +: 1 1>> > > > >$9sxI+'I1='I6-I; J9J*?7J6 J*AJ&J J J*"J7J J*J JJ' #J**J4 c  |j}tjd}tjd}tjt|} t ||D cgc]\} } t | ||| }} } t ||d||}tj||dj} |ddD]} tj}t tj|| j| D]t\}}|j||jd||}|j|j|d5|jj|t ddddv|D cgc]"} tj|| j"$}} t%j&tj|}tj(||}tj(||}t+|dz D]}tj|}|jd ||}| |}|j-||j/|||}|j1|tj2||d||j1|tj2||d||j1|tj2||d||j1| tj2||d|tj||j5|}|gt|z}tj||j5|}t+t|Dcgc]}tj(||}}t+|dz D]}tj|}|jd ||}|j-||j/|||}t+t|D]3}|j1|||tj2|||d|5t+t|D]-}|j1|tj2|||d|/|Dcgc]'}tj||j5|)}}t7||||||||| }t9||||j;Scc} } w#1swYxYwcc} wcc}wcc}w) NrrHrnp.stackrFri)z5np.stack(): all input arrays must have the same shaper)rqr rrrryrrrfrKr#rr rrkrlrrrrrXr9rrr$rir?r[r!r)r~r>r)r7rYrrqrr9 ll_narraysrrr rrcrAorig_shr&r! input_shapesrRrr"r#rrn input_stridesrBrls rD _np_stackrks ::D >>! D .. CD *Jfd+ -Q JsOGWA 6 -D - 7GZt DD%%gtAw}}=JABxP  w33GSYYG)+ PKBLL(;(;D"g(NOEe!4UC P!!11ZNP P P PPKOO3G((#++>OLO ll7>>40G&&w8L$$Wg6JTAXM$((vt< _nnZ$[[5#%  b'..w aMN b'..w AsKLM MM#w++G\1dKL MM*g2273=34379: ''l1KLL >CI-L%%gw||J/GHJ$CI.0((':0M0TAX 5$((vt< nnZ$[[5#%s4y! 5A MM,q/#.!..w a8H!/24 5 5 53t9 8 dG00-:JA157 88 -.))'7<<3CD.M. '7D $ m -C GWeS]]_ EE_ - P P PB0*.s$$S "S6'S !S%0,S*S c|t|tjsyt|d|\}}|dk(rd}t j |t |}tj|||S)Nr]rz.zero-dimensional arrays cannot be concatenated)rrrr6r r-r7r)rkr%rr|rqrr s rDnp_concatenate_typerrm%sl  4 ? &i&6@KE4 qy>##C(( )& 1F ;;udF ++rFctt|||}t|tjsJ|||}d}||fS)Nc |j||d|jdtj}t ||t |jdt j||d|j|Sr) rrrrrdrr rrr~r>r\rrs rDrjznp_concatenate..codegen=se||GT!Wchhqk5::Fw#CHHQK0&33GT!WE"# % %rF)rmrrr)rkr%rrlr\rjs rDnp_concatenaterq7sA y&$ 7C c5;; '' ' fd C% <rFcDt|tjrdd}|Sy)Nct||SrP)rqr%rs rDrz!impl_np_concatenate..implKs!&$/ /rFrrrr\r%rrs rDimpl_np_concatenaterwHs&%//* 0 +rFc||D]7}|jdks|jdkDs"d}tj|y)NrHroz7np.column_stack() is only defined on 1-d and 2-d arrays)rqr r-)r~rr%rrs rD_column_stack_dimsryPsA - 66A:!KC'', ,- rFct|d|t\}}t|}tj|||}||}d}||fS)Nznp.column_stack) dim_choosercBt|jd}tj||d}g}g}|j t j d}t||D]\} } | jdk(r#|j| |j| 8| jdk(sJ| jd} tj| | } t||| | f|} |j| |j| t|||||j|S)NrrHrorQ)rrr rrrrrrqrjr`rr$r+rdr)r~r>r\r orig_arrtys orig_arrsr)r7rrrr expand_signewarrs rDrjz np_column_stack..codegenbs388A;' (($q': ##EJJ2k95 $JE3zzQ e$ C zzQ&  *#--eU; $WgzC64P e$ F# $w"6 6rF)r6ryr7rr)rkrYr|rqr rlr\rjs rDnp_column_stackrYsS%i&72DFKE4*# .F ++eT6 *C c(C64 <rFcBt|tjrd}|Sy)Nct|SrP)rrYs rDrzimpl_column_stack..impls "3' 'rFrurYrs rDimpl_column_stackrs#u' ( (rFc t||t|jdtj||d|j |S)z/ np.stack() with the given axis value. r)rkrrr rrrps rD_np_stack_commonrsC Wg#((1+&))'47;__  rFct|d|\}}td|Drdnd}tj||dz|}|||}d}||fS)Nrfc3:K|]}|jdk(yw)rN)r rXs rDrTz"np_stack_common..s8AC8srrrHc|j||d|jdtj}t |||||Sr)rrrrrrps rDrjz np_stack_common..codegens9||GT!Wchhqk5::F#tTBBrF)r6rrr) rkr%rr|rqr rlr\rjs rDnp_stack_commonrsa&i&0&:KE4888ScF ++eTAXv .C fd CC <rFcDt|tjrdd}|Sy)Nct||SrP)rrts rDrzimpl_np_stack..impls"640 0rFrrurvs rD impl_np_stackrs&%//* 1 +rFct|||\}}t||}t|}tj|||}|SrP)r6rr7rr)rkrr%ndim_minr|rqr rls rD NdStack_typerrsA%iFCKE4 tX D )& 1F ++eT6 *C JrFc<t|d|d}||}d}||fS)Nz np.hstackrHc|jd}|dj}|dk(r/|jtjdt ||||S|dk(rdndfd}|j ||||S)NrrHc2tj|Sr|r~rts rDnp_hstack_implz3_np_hstack..codegen..np_hstack_impls~~f488rFrrqrrrrr)r~r>r\rrXrqrrs @rDrjz_np_hstack..codegensz Qx}} 19'' A6D#GWc4F F  1qD 9++G^S$O OrFrrkrYrlr\rjs rD _np_hstackrs-  ;Q 7C c(CP& <rFcBt|tjrd}|Sy)Nct|SrP)rrs rDrzimpl_np_hstack..impl c? "rFrurs rDimpl_np_hstackr#u' # (rFc<t|d|d}||}d}||fS)Nz np.vstackroc|jd}|dj}|dk(rd}n7|dk(r/|jtjd}t |||||Sd}|j ||||S)NrcTtjtj|dSr)r~r+hstackr%s rDnp_vstack_implz3_np_vstack..codegen..np_vstack_impls~~bii&7;;rFrHc0tj|dS)Nrr}r~rs rDrz3_np_vstack..codegen..np_vstack_impl~~f155rFr)r~r>r\rrXrqrrs rDrjz_np_vstack..codegensx Qx}} 19 <QY'' A6D#GWc4F F 6''dKKrFrrs rD _np_vstackrs-  ;Q 7C c(CL& <rFcBt|tjrd}|Sy)Nct|SrP)rrs rDrzimpl_np_vstack..implrrFrurs rDimpl_np_vstackrrrFc<t|d|d}||}d}||fS)Nz np.dstackr;c|jd}|j}|dj}|dk(rd}|j||||S|dk(r|j t j d}|j|jdz } tj| g|j} t||| ||} |j t j d}tj|| } t||| | f|S|dk(r/|j t j d}t|||||Sd}|j||||S)NrcNtj|jdddS)NrHr)r~rrers rDrz3_np_dstack..codegen..np_vstack_impls yy(00Ar::rFrHrQroc0tj|dS)Nror}r~rs rDrz3_np_dstack..codegen..np_vstack_implrrF) rrrqrrrrr`rr$rr+) r~r>r\rrXrYrqrr stack_retty stack_sig stack_retrs rDrjz_np_dstack..codegens: Qx}} 19 ;++G^S$O O QY'' A6D**%**q.*9K((@sxx@I('9d)-/I'' A6D))%=Jwi\4P P QY'' A6D#GWc4F F 6++G^S$O OrFrrs rD _np_dstackrs.  ;Q 7C c(C PD <rFcBt|tjrd}|Sy)Nct|SrP)rrs rDrzimpl_np_dstack..impl*rrFrurs rDimpl_np_dstackr'rrFfillc d}|S)Nc||ddyrPr)rrs rD fill_implzarr_fill..fill_impl2sArFr)rrrs rDarr_fillr/s rFdotc d}|S)Nc.tj||SrP)r~r)rothers rDdot_implzarray_dot..dot_impl;svvc5!!rFr)rrrs rD array_dotr9s" OrFcRt|stjd|zd}|S)NzCannot np.fliplr on %s typecztj|}|jdkr td|ddddddfS)Nror8r.r~rrqrrr^s rDrznp_flip_lr..implGs= JJqM 66A:45 5TrT3rFrrrs rD np_flip_lrrAs/ A   !>!BCC  KrFcRt|stjd|zd}|S)NzCannot np.flipud on %s typecttj|}|jdkr td|ddddfS)NrHzInput must be >= 1-d.r.rrs rDrznp_flip_ud..implXs: JJqM 66A:45 52s|rFrrs rD np_flip_udrRs/ A   !>!BCC KrFct|tjstj|t |j tjtj|}fd}||fS)zY Creates a tuple of slices for np.flip indexing like `(slice(None, None, -1),) * sz` rcd}tj g}tj g|}|j tj}|j }| |g} |j |||| } | S)Nc Z|}t|D]}t||tddd}|S)Nr)r9r0r@)length empty_tupler rns rDrz6_build_flip_slice_tuple..codegen..implns8C6] C#CE$b,AB CJrF)rrrr$rget_constant_undefr) r~r>r$rrinner_argtypes inner_sig ll_idx_typer inner_argsr r tuple_types rDrjz(_build_flip_slice_tuple..codegenms{   **j1$$ZA.A ,,UZZ8 00< !$'5 &&wiL rF) rrrr rrrr slice3_type)r szr\rjrrs @@rD_build_flip_slice_tuplercsf b%.. /((,, r De&7&7tDJ R.C" <rFcpt|tjstjd|zd}|S)NzCannot np.flip on %s typec6t|j}||SrP)rrq)rsls rDrznp_flip..impls $QVV ,u rF)rrrr rrs rDnp_fliprs5 a %  !.impls$>> 3# rFct|j||\}}tjtj|dzg|z|g||z dz zz}tj |||S)NrHr})divmodrfr~cumsumrr)rrrrrrs rDrznp_array_split..implspCIIdO-@AFAsiiQ# *S01456!G>>#wT: :rFc "t|j}tdd|j|}g}d}|D]/}t||t ||}|j |||}1|j |t||t d|SNznp.splitrr)r1rqrr0r@rjrrr slice_tupr prevrrs rDrznp_array_split..impls.sxx8I!*fchhEDCD* #ItU45EF 3s8$  JJs=D%T:JKL MJrFc3PK|]}t|tj ywrPrrr)rRr9s rDrTz!np_array_split..sP 1emm,PrUc 4t|j}tdd|j|}g}d}t|D]/}t ||t ||}|j |||}1|j |t ||t d|Sr)r1rqrrr0r@rjrs rDrznp_array_split..impls.sxx8I!*fchhEDCD%&9: #ItU45EF 3s8$  JJs=D%T:JKL MJrFr) rrrListTyperr IterableType iterator_typer!rrrrrrs rDnp_array_splitrs# CD  %u}}5 ;  &(:(:;   - - 8 8 MM   & 4 P6I6O6OP P   Q 5rFct|tjtjtjfrdd}|St|tj rdd}|St |||S)NcXtjtj|||Sr|)r~splitrrs rDrznp_split..impls88BJJsO-@tL LrFct|j||\}}|dk7r tdtj|||S)Nrz0array split does not result in an equal divisionr})rrfrr~r)rrrrrs rDrznp_split..implsMCIIdO-@AFAsax F>>(t rFr}r)rrrrrrrrs rDnp_splitrs[# CD M %u}}5  c#6TBBrFc,t|tjsd}tj|t|tj tjtj tjfsd}tj|d}|S)N#The argument "ary" must be an array:The argument "indices_or_sections" must be int or 1d-arraycf|jdkr tdtj||dS)Nroz3vsplit only works on arrays of 2 or more dimensionsrr}rqrr~rrrs rDrznumpy_vsplit..impls5 88a<?A Axx0q99rFrrrr rrrrrrrrs rD numpy_vsplitrs c5;; '3  %% )EMM5;;,1JJ,H IK  %%: KrFc,t|tjsd}tj|t|tj tjtj tjfsd}tj|d}|S)Nrrc|jdk(r td|jdkDrtj||dStj||dS)Nrz3hsplit only works on arrays of 1 or more dimensionsrHr}rrs rDrznumpy_hsplit..implsT 88q=?A A 88a<88C!41= =xx0q99rFrrs rD numpy_hsplitrss c5;; '3  %% )EMM5;;,1JJ,H IK  %%: KrFc,t|tjsd}tj|t|tj tjtj tjfsd}tj|d}|S)Nrrcf|jdkr tdtj||dS)Nr;z3dsplit only works on arrays of 3 or more dimensionsror}rrs rDrznumpy_dsplit..impls3 88a<*+ +xx0q99rFrrs rD numpy_dsplitrrrFc ||kS)z7 Trivial comparison function between two keys. rrs rD default_ltr-s  q5LrFc ||j|f} t|S#t$r`|dk(r%tj||d}|j }n(|dk(r#t j||}|j}t|<|cYSwxYw)z6 Get a sort implementation of the given kind. r+T)lt is_argsort is_np_arrayr,)r r ) rr_sortsKeyErrorr+make_jit_quicksort run_quicksortr,make_jit_mergesort run_mergesort)rlt_implr keyrrs rD get_sort_funcr4s   * ,Cc{   ; //% "D%%D [ //%'D%%Ds   sA&BBct|tjrtSt|tjrt St SrP)rrrZrr$rrrs rDlt_implementationrLs0%% E5== )rFz array.sortc|jd}tdt|jfd}|j ||||S)Nrr+)rrc|yrPrr sort_funcs rDarray_sort_implz#array_sort..array_sort_impl\s #rF)rrrr|r)r~r>r\rrrrs @rD array_sortrUsGhhqkG;&7 &FHI  # #G_c4 HHrFcLt|stjdd}|S)NzArgument "a" must be array-likecF|j}|j|SrP)r`r)rr s rD np_sort_implz"impl_np_sort..np_sort_implisffh   rFr)rr s rD impl_np_sortr!cs/ A   "12 2 rFz array.argsortc |j\}}t|jt|jd fd}|j |jdd}|dd}|j ||||S)NT)rrr c|SrPrrs rDarray_argsort_implz)array_argsort..array_argsort_implys ~rFrHr)rrrrr|replacer) r~r>r\rrrr$innersig innerargsrs @rD array_argsortr(ps|HHMGT4#5#5&7 &F)-/I{{! {-HRaI  # #G-?$,i 99rFcZ|j|jk7s|jdk(sJ|S)Nr^)rCr )r~r>rOrPrs rDarray_to_arrayr*s* >>T\\ )T[[C-?? ? JrFczd}t||}|j||||g}t|||j|S)Nc$|jdSr)rCrs rDrzarray0d_to_scalar..implsvvayrF)r$rr"rr~r>rOrPrrr\r s rDarray0d_to_scalarr.sB D& !C  " "7D#u =C gw EErFczd}t||}|j||||g}t|||j|S)Nct|dSr)rrs rDrz array_to_unichrseq..impls1R5zrF)r$rr rr-s rDarray_to_unichrseqr1sB D& !C  " "7D#u =C Wgs DDrFct)zR An intrinsic returning a derived array with the given shape and strides. r)rrfrs rDreshape_uncheckedr3rrFcdfd}|S)Nc^t|tjxrtd|DS)Nc3PK|]}t|tj ywrPrr>s rDrTz>type_reshape_unchecked..check_shape..s@QJq%--0@rU)rrr\rrfs rDr$z+type_reshape_unchecked..check_shapes*5%//2A@%@@ BrFct|tjsy|r|syt|t|k7ry|j t|dS)Nr^r_)rrrrr`)rrfrr$s rDtyperz%type_reshape_unchecked..typersP!U[[) 5!W)=  u:W % vv3u:cv22rFr)r~r9r$s @rDtype_reshape_uncheckedr:sB3 LrFc|jd}|j}t||||d}t|||}tj||d}tj||d} t ||j || |j|j|j} t|||| S)NrrHror) rrryr rrrrrrr ) r~r>r\rrrYrr rfrr s rDimpl_shape_uncheckedr<s HHQKE OOE *U GWd1g 6C *U GW -C  $q' 2E""7DG4G3"LL;;  --/C Wguc ::rFc|dtjfvr tdn td|dtjfvrtjdtddfd }|S)Nc|jSrPr7rXrfs rDr}zas_strided..get_shapes 77NrFc|SrPrr?s rDr}zas_strided..get_shapesLrFz,as_strided() strides argument cannot be Nonec|SrPr)rXrs rD get_strideszas_strided..get_stridessNrFc>t|||||}|SrP)r3)rXrfrr}rBs rDas_strided_implz#as_strided..as_strided_impls$ a1e!4k!W6M NrFr)rr'r&r r)rXrfrrDr}rBs @@rD as_stridedrEs uzz""        4$$   !OPP     rFct|tjrOtt |j dztt |j dzt dnt|tjrt|jtjratt |j t|ztt |j t|zt dntjdt|r t dnt|tjr t dn`t|tjr1t|jtjr t dntjdd fd }|S) NrHc|fSrPr window_shapes rDget_window_shapez-sliding_window_view..get_window_shapes  ? "rFc|SrPrrHs rDrJz-sliding_window_view..get_window_shape s rFz4window_shape must be an integer or tuple of integersc*tt|SrP)rr9rIrrqs rDget_axisz%sliding_window_view..get_axissd $ $rFc tdd||gSNsliding_window_viewrrrMs rDrNz%sliding_window_view..get_axiss4fdDI rFc D|Dcgc]}tdd||c}Scc}wrPrR)rIrrqrs rDrNz%sliding_window_view..get_axis!s0"###8&$J# ##sz2axis must be None, an integer or tuple of integerscP |} |||j}t|t|k7r td } }t|jD]6}t |||j |}t |||j |}8|j}t||D]l\}}|dkr td|||kr td|||z dz}t |||}t |||}t |||j |}|dz }nt|||} | S)Nz2Must provide matching length window_shape and axisrz-`window_shape` cannot contain negative valuesz4window_shape cannot be larger than input array shaperH) rqrrr9r0rfrrr3)rXrIr out_shape out_stridesrnrrtrimmedrErNrJ shape_buffer stride_buffers rDsliding_window_view_implz5sliding_window_view..sliding_window_view_impl+sP' 5  dAFF3 | D )D  ! # qvv FA%iAGGAJ?I' Q ! EK F FF4. GBQw C}s" J mc)A-G%iW=I%iC8I' Q " FK FA $!I{; rFrP) rrrrr9rqr&rr|rr rr)rXrIrrZrNrJrXrYs @@@@rDrQrQsx , .U166A:./ eAFFQJ/0  #  # \5>> 2 |))5== 9U166C ,=#=>? eAFFS->$>?@      B  4  %  % D%-- (     T5>> * tzz5== 1  #  #   @  %%N $#rFcBt|tjrd}|Sy)Nc|jdk(rtdkrytd|jdk(rt|j dStd)Nr)roroFziThe truth value of an empty array is ambiguous. Use `array.size > 0` to check that an array is not empty.rHz[The truth value of an array with more than one element is ambiguous. Use a.any() or a.all())rrrr]rCr{s rDrzol_bool..implXs_xx1} 6) $'JLLQCHHQK(( #-//rFrQr|s rDol_boolr]Us!#u{{# / $rFct|ttjfst j dt|ttjfst j dt|tj st j d|jttfd}|S)Nz.The second argument "axis1" must be an integerz-The third argument "axis2" must be an integer'The first argument "a" must be an arrayctdd|}tdd|}t||}t|||}tj||S)Nz np.swapaxesaxis1axis2)rr0r~r)rrarb axes_tuple axes_listrqs rDrznumpy_swapaxes..implxsP}gtUC}gtUC"9eU; ":ue< ||Az**rF) rrrrr rrrqrr9)rrarbrrdrqs @@rDnumpy_swapaxesreis ec5==1 2  "+, , ec5==1 2  "+, , a %  !JKK 66DeDk"I+ KrFc^t|tjstjdt|tj sSt|tj r$t|jtj stjdt|tj sSt|tj r$t|jtj stjd|jd|jzfd}|S)Nr_zGThe second argument "source" must be an integer or sequence of integerszKThe third argument "destination" must be an integer or sequence of integersrctdd |}tdd |}t|t|k7r tdt|jDcgc] }||vs| }}t t ||D]\}}|j|| }t|D]\}} t||| }|j|Scc}w)Nz np.moveaxissource destinationzL`source` and `destination` arguments must have the same number of parameters) rrrr9rqrrrrr0r) rrhrir order_listrirDrOrnorq order_inits rDrznumpy_moveaxis..impls%mXtVL* =$   v;#k* *0  "'qvvBA!6/aB BK 89 )ID#   dC ( )j) /DAq!%A.E /{{5!!Cs  C !C ) rrrr rrrr|rq)rrhrirrqrls @@rDnumpy_moveaxisrms a %  !JKK65==) vu~~ .6<<7   &  ; . {ENN 3;,,emm<   &  66DJ", KrFc(tdd|j|}t|j}d||<t t ||jD]7\}\}} |dk(r| } n| dk(r|} n|| k7r t d|} t||| }9t|||j|} tj|| }tj||}|} t|dkDr3tt| D]}t| ||j|} |} t|dkDr9tt| D]"}t| ||j|dz|z} $|j|}tj| |fz| z|j}tdddf}tj| D]X}tj| D]>}|||z|z}|||z|z}|||z|z}t|D] }|||||<@Z|S)Nznp.take_along_axisrrHz*`arr` and `indices` dimensions don't matchr)rrqrrfrrrr0r~rrr9rr|r@r)rrrNi_origNk_origindices_broadcast_shape arr_shapernd1d2new_valarr_broadcast_shapeNiNkJr np_s_iikka_1d indices_1dout_1dr8s rD_take_along_axis_implrs4 .$ GDSYYIIdO Y !>?  8B 7G 1WGRx @G"/ #Q#   (syy //#2 3Coog'>?G B 7|as2w 4Ar1ciil3B 4 B 7|as2w ?Ar1ciiq1 &=>B ?  dA ((29r>399 -C 4t $ &Ejjn0**R. 0BrEzB'D eb1Jeb)F1X 0 A/q  0  00 JrFct|tjstjdt|tjstjdt|j tj stjdt|rd}n |j}||jk7rtjdtt|jt|rfd}|St|dt|tjstjd|j}|d kr|j|z}|d ks||jk\rtjd tt|tt|dz|jfd }|S) Nz)The first argument "arr" must be an arrayz.The second argument "indices" must be an arrayz'The indices array must contain integersrHz;`indices` and `arr` must have the same number of dimensionsc@t|j|dddS)Nrr)rr)rrrrqs rDtake_along_axis_implz1arr_take_along_axis..take_along_axis_impl s%(B)@B BrFrzaxis must be a literal valuerzaxis is out of boundsc$t|||SrP)r)rrrrwrxrqs rDrz1arr_take_along_axis..take_along_axis_impls(gtR)@B BrF)rrrr rr|rrrqrr9rrr?r)rrrarr_ndimrrwrxrqs @@@rDarr_take_along_axisrsu c5;; '  !LMM gu{{ +  <> > gmmU]] 3  !JKK4887<<  I  $E',,$784 B( ! v&$ 4 45(()GH H!! !888d?D !8tsxx'(()@A A 5;  5388, - B rFct|tjrut|tjrd d}|St|tjrd d}|St|tj rd d}|St jdt|rt|jtjrd d}|St|jtjrd d}|St|jtj rd d}|St jdt jd) Nc|SrPrrXr`nanposinfneginfs rDrznan_to_num_impl..impl&rFc@||n'tjt|j}||n'tjt|j}tj |r|Stj |r|Stj|r|S|SrP)r~finfor:rrrisneginfisposinf)rXr`rrrmin_infmax_infs rDrznan_to_num_impl..impl*s)$q'*..)$q'*.. 88A;J[[^"N[[^"NrFctj|j|||}tj|j|||}t ||S)N)rrr)r~ nan_to_numr)r+complex)rXr`rrrrrs rDrznan_to_num_impl..impl>s>MM!&&c&PMM!&&c&Pq!}$rFz4Only Integer, Float, and Complex values are acceptedc|SrPrrs rDrznan_to_num_impl..implJrrFc||n(tj|jj}||n(tj|jj}tj |}|rtj |n|}|j} t|jD]\} tj| | r|| | <!tj| | r|| | <?tj| | sX|| | <^|SrP) r~rr|rrrr`rr9rrrr) rXr`rrrrrx_output output_flatrns rDrznan_to_num_impl..implMs)!''*..)!''*.. ZZ](,"$kk v{{+1Axx A/), A[^4)0 A[^4)0 A 1 rFctj|}|rtj|n|}tj|jd|||tj|j d||||S)NF)r`rrr)r~rr`rr)r+)rXr`rrrrrs rDrznan_to_num_impl..implfsgZZ](," KK!!  KK!!  rFz4The first argument must be a scalar or an array-likeTgNN) rrrrrZr$r rrr|)rXr`rrrrs rDnan_to_num_implr!s!U\\" a ' t Ko5;; ' l KG5== ) %D K{$$F  !  aggu}} - l Ki - f K7 / 4 K $$F   "./ /rFrPrrrr)Frr(rrIrcrr=llvmliter llvmlite.irrnumpyr~numbarr numba.corerrr r r numba.np.numpy_supportr r rrrrrrrrrrrnumba.core.imputilsrrrrrrrr r!r"r#numba.core.typingr$numba.core.typesr%numba.core.extendingr&r'r(r)r* numba.miscr+r, numba.cpythonr-numba.cpython.charseqr.r/numba.cpython.unsafe.tupler0r1r2numba.core.typing.npydeclr3rr4rr5r6r7rErJryrrrrrrrrrrrrrr r ArrayIteratorBORROWEDr*rCrrIrrr1rKrMr\rZraAnyrarrfrrmrrrHrtrrrrrrrWrrrr!r)rGrPr\rdrmrrr|rrrrbroadcast_shapesrrrrrrr^rrrrVarArgr rrrr-r geomspacer6rot90r@rOrWr_rarergresizervrjrrrmrrrrrrrrrfrrruniquerrrrrrrrr%r#r& MemoryViewr)r+r-r/r1r4r8r<rArDrJrGrMrrrQrXr\rZr^r`rgrkrer}rDType NumberClassrrrrrrrrrrrrrBytesris_rrrrrrrIrSrr{rwr}rrrrrrrrrrrrrrNumpyNdIterTypereqrrrrrrrrirrrrrrrrrrrnrrrrrrr rrrrrrrr eyer&diagr.rr3diagflatr:rBrCrUr`r1rtrr|rrrr`rrrrrrrrrrrrrrrrrrrrrrrrrrrr$r'r+r.r1r>r5 atleast_1drG atleast_2drJ atleast_3drMr[rdrkrmrqrprwryr column_stackrrrstackrrrrrrvstackr row_stackrdstackrrrr=rr>rrfliprrrrrvsplitrhsplitrdsplitrr rrrrrr!argsortr(r*UnicodeCharSeqrZr$r NPTimedelta NPDatetimer.r1r3 type_callabler:r<lib stride_tricksrErQr]r]r<removeaxisrmrtake_along_axisrrrrrFrDrs   *@@;;;PO****(*AA+!BL5EE#69x(-M    BJH&  .,  , ,^y%,,'(.;*z5../w -!0-6 $A4H  ;*xu}}=xu?xu~~>E?@>E"xu?E@E0xuyy%))D%6E%6PsELL!F"F|U[[) 8* 86?EKK; )< )(/"f/"d/-G/-d W >:-':-zN-'N-bB-7B-JL6L^(GVxu{{;;<;&'TH :$z"J!. 4  ,  "55>-  "//'&'&T 3 3  "  %%P "  66r "95 6  "512*U%v& %++.;/;  %++u?3E@3El %++|u||EII/FGFHF  ",,  u{{C 9!9& "++   ",,IIX "((4!H;< U__==E>=E@ \U\\%))-DE>F> 6 bjj bjj  "))++\ "))2}ekk*+,rxx%G&G ,-   "''vvrf%& {| "(( "'' "))   ")))1)1X"5;;12    9-(.(V|U[[%//:$E;$ETu{{G$:%: u{{G$u):*%:u{{I&u+:,':u{{F#u(:)$: u{{F#:$:u{{J'u,:-(:u{{H%u*:+&:u.:/: u0:1: u0:1: u,:-:u{{H% 9& 9u  &):*: E  u~~. E  u}}-;./;4u{{G$8%8u.u0 :1/ :u0 :1 : u{{F#Q$Qu{{F# Q$ Q 4Mnf%k*+&% # ekk6":." ekk6":.!2!2EII>(?(.u{{#4;$4;ne.A.ABOCOu||$$=%$=Nu||$D%D:u/B/BCADAu/C/CDEEEu/B/BEIIN %O %u/C/CUYYO %P %" ;; 33 99x||U[[%++6 G7 G EKK,-9>IM6:#D'+O EP >BVru{{F# P$ Pz5../w  E!0 Ex!4!4emmD EE Ex!4!4emmyy % %sE''()r~~u{{+E,E"z5556w  C!7 Cxemm45rzz<5<< 67 E86 Ex)rzz5??+E,*E*z5112w 7!37ryy%))$>%>&z5001w 7!27x{{EKK5F6FL^ekk;u=>*     -`K #&    "(("&&*   "--0  l+, "((" "-- ",,   "''    ",,   "''   "++   %&'BFF1E2 "''##L "**6 "++4  F "''f%^&^B4 "))@@F "++$$N"PJ  |U[[)4*4 "''  >* & &R "))5;;/05;;./ "))    "))     : "''   "..;;| "((CC4 "))& "))* ")), 0|U[[) I* I "''   U-@-@Arzz5;;(;(;< 9=B 9& EKK%&  EKK--. EKK% EKK' EKK' EKK' EKK**+ EKK))*F+,(((&/F EKK--.E/E*+," %++uP;Q;*BFF((33458BFF((<<=[$>[$| $& "++0 "++33l88v "  ( ( V "--^^rF