\ K]c@`sdZddlmZmZmZddlZddlZddlZddlm Z ddl j j Z ddl mZddlZddlmZmZmZmZmZmZmZddlmZmZmZmZmZddlmZ dd lm!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 l0m1Z1m2Z2m3Z3d dl4m5Z5m6Z6m7Z7dZ8dZ9dZ:dZ;dZ<dZ=dZ>dZ?dZ@eAdZBdZCe#dejDdZEdZFe#dejGe)e-jHdZIdZJd ZKd!ZLe#ejMejDejNe#ejMejDejOd"ZPe#ejMejDejQd#ZRe#ejSejDejTejTd$ZUe#eVejDd%ZWe#d&ejXd'ZYe#d(ejXejTd)ZZd*e[fd+YZ\d,e\fd-YZ]d.e\fd/YZ^d0e\fd1YZ_d2e\fd3YZ`d4e\fd5YZad6e[fd7YZbd8Zce#ejMejDejXd9Zdd:Zed;Zfd<Zgd=Zhd>Zid?Zjd@ZkdAZldBZmdCZne#dDejXdEZodFZpe#dDejXejQdGZqe#dDejXejrejTdHZse2ejteAdIZue$ejXdJdKZvdLZwdMZxe#dNejXejQdOZye#dNejXejrejTdPZze2ej{dQZ|e#dRejXdSZ}e#ej~ejXdTZe#dUejXdVZdWZe2ejdXZe2ejdYZe2ejdZZe1d[Zej3ejXd\d]Ze#d^ejXejd_Ze$ejXd`daZe$ejXdbe$ejdbdcZe$ejXdde$ejdddeZe$ejXdfe$ejdfdgZe$ejXdhdiZe$ejXdje$ejdjdkZe$ejdldmZe$ejdndoZe$ejdpdqZe$ejdrdsZe$ejdtduZe$ejXdvdwZe$ejdxdyZe'ejeje'ejejdzZd{Ze$ejXd|d}Ze$ejdne$ejdpd~Ze$ejdrdZe$ejXddZe$ejXddZe3ejXde3ejXddZdZdZe$ejdee$ejdee%ejXdZe#dejXejdZe%ejdZe&ejdZe#dejejdZe#dejejejTdZe(ejXdZe(ejdZe#ejejXejXdZdZdZeAeAeAdZeAdZdZdZdZe$ejXddZe#deje)e-jHdZe#ejMejejNdZe#ejSejejNejTdZe#eVejdZe#ejejXdZe#deje)e-jHdZe#eejrejNe#ejejrejNdZe#eejQe#ejejQdZe#deje)e-jHdZe#ejejTdZe#deje)e-jHdZdZdZdZdZdZe#ejejTe#ejejTejTdZe#ejejTe#ejejTejdZe#ejejTe#ejejTejTdZe#ejejTe#ejejTejdZe d dfkrHe#ejejTejTdZe#ejejTejTejdZe#ejejTejTdZe#ejejTejTejdZne#ejejTdZe#ejejTejdZe#ejejTdZe#ejejTejdZe#ejejNdZe#ejejNejdZdZej2edZej2ejeAdedZe#ejejXdZe#ejejXejNdZe#ejejXejNe#dejXejNdZe#dejXejXe#ejejXejXdZe#dejXeje#ejejXeje#dejXejQe#ejejXejQdZe#ejejdZe#ejejejdZe#ejejejejdZe#ejejejejejdZe#ejejejdZe#ejejejejNdZdZe#dejXdZe#ejejXdZdZe#ejejXdZe#ejejXdZ e#dejXejdZ e#ej ejDe#ej ejDejdZ e#eejTejTe#eejTejTeje#eejTejTe#eejTejTejdZ dZdZdZdZdZe#ejejTe#ejejTejdZdZdZdZdZe#ejejXejNdZdZdZe#ejejrejXdZe#ejejrejXdZe#ej ejrejXdZ!dZ"dZ#dZ$e#ej%ejQdZ&e#ej%ejQejNdZ'e#ej(ejQdZ)dZ*e d dfkre#ej+ejQdZ,e#ej+ejQejNdZ-ne#ej.ejQdZ/e#ej0ejQdZ1e#ej2ejQdZ3ej3ejXddZ4ej3ejXddZ5iZ6dZ7e8dZ9e#dejXdZ:e#ej;ejXdZ<e#dejXeje#ej=ejXejdZ>e'ejXejXdZ?dZ@ejAe@dZBe#e@ejXejQejQdZCej2ejDjEjFeAeAdZFdS(s[ Implementation of operations on Array objects and objects supporting the buffer protocol. i(tprint_functiontabsolute_importtdivisionN(tir(tConstant(ttypestcgutilsttypingtutilst extendingtpndindexterrors(tas_dtypetcarraytfarrayt is_contiguoust is_fortran(tversion(ttype_can_asarray( t lower_builtint lower_getattrtlower_getattr_generictlower_setattr_generict lower_casttlower_constantt iternext_impltimpl_ret_borrowedtimpl_ret_new_reftimpl_ret_untrackedtRefType(t signature(tregister_jitabletoverloadtoverload_methodi(t quicksortt mergesorttslicingcC`sPtj|j|tj|j|g}|jj|}|jd|dS(sz Set the "range" metadata on a load instruction. Note the interval is in the form [lower_bound, upper_bound). trangeN(Rtintttypetmodulet add_metadatat set_metadata(tbuildertloadt lower_boundt upper_boundtrange_operandstmd((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytset_range_metadata#scC`s/d|jjd>d}t||d|dS(sF Mark the result of a load instruction as positive (or zero). iiN(R'twidthR1(R+R,R.((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt mark_positive.sc`sMjtjjdffdYS(s 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). t ArrayStructc`s5eZfdZefdZRS(c`st}y|jjd|}Wn$tk rNt|j|SX|jj}|j|}|dkrt j |j |dt }n|}||j |f}||fS(Nt __array__tzfill( Rt_contextt get_functiontNotImplementedErrortsupert _make_refstdata_model_managert _get_be_typetNoneRt alloca_oncet_buildertTrue(tselftreftsigt array_implt datamodeltbe_typet outer_ref(R4t array_typetreal_array_type(s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR;Ds  c`s|j}dkr%j|dS|jd}g}xUtD]G}tj||d|}|j|}|j|t||qGWtj ||S(s\ Override .shape to inform LLVM that its elements are all positive. itshape( R@t __getattr__t_get_ptr_by_nameR%Rt gep_inboundsR,tappendR3t pack_array(RBR+tptrtdimstitdimptrR,(tbasetndim(s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRKWs   (t__name__t __module__R;tpropertyRK((R4RIRURVRJ(s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR4Bs(tas_arrayRtcreate_struct_proxyRV(RI((R4RIRURVRJs5lib/python2.7/site-packages/numba/targets/arrayobj.pyt make_array6s   (,cC`s|j|j}|j|S(sB Return the item size for the given array or buffer type. (t get_data_typetdtypetget_abi_sizeof(tcontextRItllty((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt get_itemsizeqscC`s1|jrdnd}|j||j|d|S(s3 Load the item at the given array pointer. italignN(talignedR>t unpack_valueR^(R`R+tarraytyRQRc((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt load_itemyscC`s4|jrdnd}|j||j||d|S(s4 Store the item at the given array pointer. iRcN(RdR>t pack_valueR^(R`R+RftvalRQRc((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt store_itemscC`s[|jr<|j|||tj}tj|||}n|j|||tj}|S(sM Fix the integer index' type and value for the given dimension size. (tsignedtcastRtintpR$t fix_indextuintp(R`R+tidxtytidxtsizetind((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytfix_integer_indexs  cC`st|tjry|jdkryt|jtjs<tt||||}t||||j }|j|fS||fSdS(sS Normalize the index type and value. 0-d arrays are converted to scalars. iN( t isinstanceRtArrayRVR^tIntegertAssertionErrorR\Rgtdata(R`R+RpRqtidxarytidxval((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytnormalize_indexs ! cC`s\t|rRtgt||D]!\}}t||||^q\}}n||fS(s^ Same as normalize_index(), but operating on sequences of index types and values. (tlentzipR|(R`R+t index_typestindicesRpRq((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytnormalize_indicess @c C`s|j}|j}|j} t| j} |d krZtj|j| j d}n|jt j } t |t tfrtj||| }nt |t tfrtj||| }nt |tjr| |}ntd|d|d|d|d|} |d krBtj|j| j d| dRtnulltget_value_typetget_typeRRmRuttupletlistRRPRt INT_TYPEStdictt get_constantt unpack_tupleR'tcounttmultkeyst ValueErrortformattitemstsetattr(tarrayRyRKRRRRR`R+RFtrequired_fieldstintp_ttattrsRtunpacked_shapetaxlent got_fieldstktv((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytpopulate_arraysD             cC`s|j}|j}|jtjd}tj||j|j}x)|D]!}|j ||ddg}qIW||_ |jtjt |||_ dS(s Update some auxiliary information in *array* after some of its fields were changed. `itemsize` and `nitems` are updated. iRRN( R7R@RRRmRRRKRVRRRbR(tarytyRR`R+RRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytupdate_array_infos     tgetiterc C`s|j\}|\}|j||j}|jtjd}tj||}||_||_ |j r|j j |||n|j } t|||j| } | S(Ni(targst make_helpert return_typeRRRmRtalloca_once_valuetindexRt enable_nrttnrttincreft _getvalueR( R`R+RDRRfRtiterobjtzerotindexptrtrestout((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt getiter_arrays      cC`s4tj||||gd|}t||||S(s8 Look up and return an element from a 1D array. t wraparound(Rtget_item_pointerRg(R`R+RfRRqRRQ((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt_getitem_array1ds titernextc C`s8|j\}|\}|j}|jdkrCtd|jn|j||d|}t|||d|j} tj|| j dd\} |j |j } |j t j| | } |j| |j| Ut|||| | dt} |j| tj|| }|j||j WdQXdS(Nisiterating over %dD arraytvalueRR(RRIRVR9RR\RRRRKR,RticmptlctICMP_SLTt set_validtif_thenRtFalsetyield_tincrement_indextstore(R`R+RDRtresulttitertytiterRfRtaryRRtis_validRtnindex((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytiternext_arrays"      cC`s|jtjd}tj||j|j}tj||j|j}g} g} g} d} xt||D]\} }|tj kr|jt |d}xMt |D]?}| j || j || | j || | d7} qWqsnt |tjr|j||d| }tj||||tj|||| | j |jtj||}tj|||| }| j || j |nQt |tjrt|||| || }| j |ntd|f| d7} qsW| |jkstx?| |jkr_| j || | j || | d7} q!Wtj|||| dt}|| | fS(s Perform basic indexing on the given array. A (data pointer, shapes, strides) tuple is returned describing the corresponding view. iiRsunexpected index type: %sR(RRRmRRRKRVRR~tellipsisR}R%RORut SliceTypeRR$tguard_invalid_slicet fix_slicetstarttget_slice_lengtht fix_strideRwRtR9RxRR(R`R+RRRRRtshapesRtoutput_indicest output_shapestoutput_stridestaxtindexvalRpt n_missingRStslicetshtstRstdataptr((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytbasic_indexing:sP    c C`sPt|||}t|d|d|d|d|jd|jd|j|S(sF Build a view over the given array with the given parameters. RyRKRRRR(R\RRRR( R`R+RRRRyRRtretary((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt make_viewus    c C`st||||||\}}} t|tjrat|||||||| } | jS| sntt||||SdS(sp Return the result of indexing *ary* with the given *indices*, returning either a scalar or a view. N(RRuRtBufferRRRxRg( R`R+RRRRRRt view_shapest view_stridesR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt_getitem_array_generics$  c C`s|j\}}|\}}|jdks0tt||||}t|||j|||f|f}t|||j|S(s4 Basic indexing with an integer or a slice. i(RRVRxR\RRR( R`R+RDRRRpRRqR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytgetitem_arraynd_intps c C`s|j\}}|\}}t||||}|j}tj||dt|} t|||| \}} td|Drt|||||||| St |||j |||| } t |||j | S(s2 Basic or advanced indexing with a tuple. Rcs`s!|]}t|tjVqdS(N(RuRRv(t.0tty((s5lib/python2.7/site-packages/numba/targets/arrayobj.pys s( RR\RRRR}Rtanyt fancy_getitemRRR( R`R+RDRRttuptyRttupRRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytgetitem_array_tuples   cC`sD|j\}}}|\}}} t|tjr]|j} tj||dt|} n|f} |f} t||||}t||| | \} } y(t ||||| | \} } }Wnt k rt }n Xt | }|rt ||||| | S|j|| ||j} t|||| | dS(sH array[a] = scalar_or_array array[a,..,b] = scalar_or_array RN(RRuRt BaseTupleRRR}R\RRR9RAtbooltfancy_setsliceRlR^Rj(R`R+RDRRRptvaltyRRqRiRRRRRtuse_fancy_indexing((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt setitem_arrays( !   (    c C`sd|j\}|\}t|}||||}|j}|j|d}t|||j|S(Ni(RR\RKt extract_valueRR( R`R+RDRRRtarysttytshapearyR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt array_lens    s array.itemcC`s|j\}|\}t||||}|j}|j|jd||jddt$d}|jj|t |fWdQXt ||||j S(Ns!=itlikelys>item(): can only convert an array of size 1 to a Python scalar( RR\RRt icmp_signedR'Rt call_convtreturn_user_excRRgRy(R`R+RDRRRRtmsg((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt array_items   $ s array.itemsetc C`s|j\}}|\}}||jks0tt||||}|j}|j|jd||jddt$d} |j j |t | fWdQXt |||||j |jS(Ns!=iRs/itemset(): can only write to an array of size 1(RR^RxR\RRRR'RRRRRjRytget_dummy_value( R`R+RDRRRRRiRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt array_itemsets  $ tIndexercB`sDeZdZdZdZdZdZdZdZRS(sq Generic indexer interface, for generating indices over a fancy indexed array on a single dimension. cC`s tdS(se Prepare the indexer by initializing any required variables, basic blocks... N(R9(RB((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytprepare scC`s tdS(s= Return this dimension's size as an integer. N(R9(RB((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytget_size'scC`s tdS(s; Return this dimension's shape as a tuple. N(R9(RB((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt get_shape-scC`s tdS(s} Return a half-open [lower, upper) range of indices this dimension is guaranteed not to step out of. N(R9(RB((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytget_index_bounds3scC`s tdS(sW 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. N(R9(RB((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt loop_head:s cC`s tdS(s) Finish indexation loop. N(R9(RB((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt loop_tailEs( RWRXt__doc__RRRRRR(((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRs     t EntireIndexercB`sMeZdZdZdZdZdZdZdZdZ RS(s: Compute indices along an entire array dimension. cC`sI||_||_||_||_||_|jjtj|_dS(N( R`R+RRtdimRRRmtll_intp(RBR`R+RRR ((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt__init__Qs      cC`sa|j}|j|jj|j|_tj||j|_ |j |_ |j |_ dS(N( R+RRRKR RrRR?R Rtappend_basic_blocktbb_starttbb_end(RBR+((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRYs  cC`s|jS(N(Rr(RB((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR`scC`s |jfS(N(Rr(RB((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRcscC`s|jd|jfS(Ni(R Rr(RB((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRfscC`s|j}|jjtj|jd|j|j|j|j|j|j |j}|j |j d||j dt |j|jWdQX||fS(Nis>=R(R+RRR&R RtbranchR tposition_at_endR,RRRrRR(RBR+t cur_index((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRjs % cC`s^|j}tj||j|j}|j||j|j|j|j|j dS(N( R+RRR,RRRR RR(RBR+t next_index((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRvs  ( RWRXRR RRRRRR(((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRLs      tIntegerIndexercB`sMeZdZdZdZdZdZdZdZdZ RS(s0 Compute indices from a single integer. cC`s7||_||_||_|jjtj|_dS(N(R`R+RqRRRmR (RBR`R+Rq((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR s   cC`sdS(N((RB((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRscC`stj|jdS(Ni(RR&R (RB((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRscC`sdS(N(((RB((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRscC`s%|j|jj|j|jfS(N(RqR+taddR(RB((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRscC`s |jdfS(N(RqR>(RB((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRscC`sdS(N((RB((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRs( RWRXRR RRRRRR(((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR~s      tIntegerArrayIndexercB`sMeZdZdZdZdZdZdZdZdZ RS(s; Compute indices from an array of integer indices. cC`s^||_||_||_||_||_|jdksBt|jjtj |_ dS(Ni( R`R+RpRzRrRVRxRRRmR (RBR`R+RpRzRr((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR s     cC`sb|j}tj||jjd|_tj||j|_|j |_ |j |_ dS(Ni( R+RRRzRKtidx_sizeR?R t idx_indexR R R(RBR+((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRs  cC`s|jS(N(R(RB((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRscC`s |jfS(N(R(RB((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRscC`s|jd|jfS(Ni(R Rr(RB((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRsc C`s|j}|jjtj|jd|j|j|j|j|j|j |j}|j |j d||j dt |j|jWdQXt|j||j|j|dt }t|j||jj||j}||fS(Nis>=RR(R+RRR&R RRR RR,RRRRRRR`RpRzRtR^Rr(RBR+RR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRs %    cC`s^|j}tj||j|j}|j||j|j|j|j|j dS(N( R+RRR,RRRR RR(RBR+R((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRs   ( RWRXRR RRRRRR(((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRs     tBooleanArrayIndexercB`sMeZdZdZdZdZdZdZdZdZ RS(s> Compute indices from an array of boolean predicates. cC`sm||_||_||_||_|jdks9t|jjtj|_ t j |j d|_ dS(Nii( R`R+RpRzRVRxRRRmR RR&R(RBR`R+RpRz((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR s    cC`s|j}tj||jjd|_tj||j|_tj||j|_ |j |_ |j |_ |j |_ dS(Ni(R+RRRzRKRrR?R RRR R tbb_tailR(RBR+((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRs c C`s|j}tj||j}tj||jq}|j|}t|j||j |j |j dt }|j ||j||j}|j||WdQX|j|S(NR(R+RRRt for_rangeRrR,RR`RpRzRRRtzextR'R(RBR+Rtlooptctpred((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRs   !cC`s |jfS(N(R(RB((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRscC`s|jd|jfS(Ni(R Rr(RB((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRsc C`sB|j}|jj|j|j|jj|j|j|j|j|j|j|j|j}|j|j}|j |j d||j dt |j|j WdQXt|j||j|j|dt }|j |j||j|jWdQXtj||}|j||j||fS(Ns>=RR(R+RRRRRR RR,RRRrRRRR`RpRztnot_RRR(RBR+Rt cur_countRt next_count((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRs$    cC`s~|j}|j|j|j|jtj||j|j}|j||j|j|j |j|j dS(N( R+RRRRRR,RRR R(RBR+R((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRs  ( RWRXRR RRRRRR(((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRs    t SliceIndexercB`sMeZdZdZdZdZdZdZdZdZ RS(s( Compute indices along a slice. cC`ss||_||_||_||_||_||_||_|jjtj |_ t j |j d|_ dS(Ni(R`R+RRR RpRRRRmR RR&R(RBR`R+RRR RpR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR +s       cC`s|j}|j|jj|j|_tj|j||j |j tj ||j |jt j ||j j|_t j||j|_t j||j|_|j|_|j|_dS(N(R+RRRKR tdim_sizeR$RR`RpRRRt is_neg_inttsteptis_step_negativeR?R RRR R R(RBR+((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR6s  cC`stj|j|jS(N(R$RR+R(RB((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRDscC`s |jfS(N(R(RB((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRGscC`s(tj|j|j\}}||fS(N(R$tget_slice_boundsR+R(RBtlowertupper((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRJscC`s|j}|jj|jj|j|jj|j|j|j|j|j |j|j |j}|j |j}|j |j |j d||jj|j d||jj}|j|dt|j|jWdQX||fS(Ns<=s>=R(R+RRRRRRRR RR,tselectR&RtstopRRR(RBR+RR t is_finished((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRNs     cC`s|j}|j|j|j|jjddg}|j||jtj||j|j }|j||j |j |j |j |j dS(NRR(R+RR,RRR%RRRRRR RR(RBR+RR!((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR`s ! ( RWRXRR RRRRRR(((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR"&s     t FancyIndexercB`sDeZdZdZdZdZdZdZdZRS(s4 Perform fancy indexing on the given array. c C`s"||_||_||_tj||j|j|_tj||j|j|_|jj t j |_ g}d}xt ||D]\} } | t jkr |jt|d} xCt| D]5} t|||||} |j| |d7}qWqnt| t jr^|j|| | }t|||||| |} |j| nt| t jrt||| | |j|}t|||} |j| nt| t jr[t| ||| }t| jt jrt||| ||j|} n9t| jt jr?t||| |} n dsKt |j| nt d| f|d7}qW||jkst ||jfxB||jkrt|||||} |j| |d7}qWt||jkst t||jf||_!dS(Niisunexpected index type: %s("R`R+RRRRKRVRRRRRmR R~RR}R%RRORuRRR"RwRtRRvR\R^RtBooleanRRxtindexers(RBR`R+RRRRR/RRRpRRStindexerRRsRz((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR ps\        $ 0cC`sPx|jD]}|jq Wtg|jD]}|j^q+d|_dS(N((R/RtsumRtindexers_shape(RBRS((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRscC`s|jS(s? Get the resulting data shape as Python tuple. (R2(RB((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRscC`st||jjkst|j}tj}|jd}|jd}|}|}xt|j |j |D]\} } } |j ||j d| |}| j \} } |j| | }|j| |j| |}|jd| |}|j||j|||}|j||j|||}qsW|j||}|j|||}|j|||}||fS(s 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. iis==t<(R}RRVRxR+Rt false_bitR R~R/R2tor_t icmp_unsignedRRtsubRRR*(RBRRR+tis_emptyRtoneR(R)R0RKtstridet lower_indext upper_indext lower_offsett upper_offsett is_downwards((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytget_offset_boundss.     cC`s)td|jD\}}||fS(Ncs`s|]}|jVqdS(N(R(RRS((s5lib/python2.7/site-packages/numba/targets/arrayobj.pys s(R~R/(RBRtcounts((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt begin_loopsscC`s(x!t|jD]}|jqWdS(N(treversedR/R(RBRS((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt end_loopss( RWRXRR RRR@RBRD(((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR-ks :   " c C`sytj||j}tj||j} |j} t||||||} | j|j} | j} t ||| | }|j}tj ||j t j d}| j\}}tj|| || |j|dt}t||||}|j|}|j||g}t||| ||tj||}|j||| jt||| |jS(NiR(RRRKRRyR-RRRt_empty_nd_implRRRRmRBtget_item_pointer2tlayoutRRgR,tgepRjRRRDRR(R`R+RDRRRRRRRRyR0tout_tyt out_shapesRtout_datatout_idxt_RQRitcurtnext_idx((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRs.        c C`s|j\}}|\}}t||||}|jdkrt||||\}}t|||j|||f|f}t|||j|St|||||||f|fSdS(s3 Advanced or basic indexing with an array. iN(RR\RVR|RRRR( R`R+RDRRRpRRqR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytfancy_getitem_array s cC`sU|j}|jd}|jd}|jdkrT|} |j||j} n|} |} xt|jD]} |j|| |j|| |} |jd| |} |j | |j | | | } |j | | |j | | } qpW|j | |} |jd|j|}|j ||| } |j ||| } | | fS(s Compute a half-open range [lower, upper) of byte offsets from the array's data pointer, that bound the in-memory extent of the array. This mimicks offset_bounds_from_strides() from numpy/core/src/private/mem_overlap.c iitCFs>=s==( RR'RGRRR%RVR7RR*R(R`R+tarrtytarrRRRRR9R(R)RStmax_axis_offsett is_upwardsR8((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytoffset_bounds_from_stridess*    cC`sC|j||j}|j||}|j||}||fS(s Given [lower, upper) byte offsets and a base data pointer, compute the memory pointer bounds as pointer-sized integers. (tptrtointR'R(R`R+R(R)Rytdata_ptr_as_intRtend((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytcompute_memory_extentsHsc C`s7t||||||\}}t|||||S(sr Compute a half-open range [start, end) of pointer-sized integers which fully contain the array data. (RVRZ( R`R+RRRSRRRyR(R)((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytget_array_memory_extentsSscC`s4|j|jd|||jd||}|S(s[ Whether two memory extents [a_start, a_end) and [b_start, b_end) may overlap. R3(tand_R6(R`R+ta_startta_endtb_starttb_endt may_overlap((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytextents_may_overlap]sc`s~jdtjdj dtj|j|j}j j |} | j j | } j | j tj} tj| _} tj j| } tj| | } j j| | WdQXWdQX f d} fd}||fS(NtCRc`st| jksttj}j dt\}}|<jtjj |dt|WdQX|6jtj j |dt|WdQXWdQXt  j |S(NRR( R}RVRxRR?tif_elseRRRFR,RGRg(tsource_indicestsrc_ptrtif_copyt otherwise( R+R`t copy_datat copy_layoutt copy_shapest copy_stridestptrtytsrc_datat src_shapest src_stridestsrctytuse_copy(s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt src_getitems$    c`sTjdt9j}j|}jj|WdQXdS(NR(RRR,tbitcastRtfree(Ry(R+R`RiRrt voidptrty(s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt src_cleanups(R'RRR>RRRRRRtallocateRtRRRRmt loop_nestRFRGR,(R`R+RrRqtsrcRoRpRnt allocsizeRyRRRftdest_ptrRsRw(( R+R`RiRjRkRlRmRnRoRpRqRrRvs5lib/python2.7/site-packages/numba/targets/arrayobj.pytmaybe_copy_sourcejs.     %0c C`sW|jtjd}|jtjd}t|t|kr}t|t|}|g||}|g||}nt|t|krMt|t|}g|| D]}|jd||^q} tj|j| tj } |j |j | dt $d} |j j|t| fWdQX||}||}n||fS(se Preprocess dimension for broadcasting. Returns (shapes, strides) such that the ndim match *target_shape*. When expanding to higher ndim, the returning shapes and strides are prepended with ones and zeros, respectively. When truncating to lower ndim, the shapes are checked (in runtime). All extra dimension must have size of 1. iis==Rs,cannot broadcast source array for assignmentN(RRRoR}R6t functoolstreduceR\Rttrue_bitRRRRRR( R`R+RRt target_shapeRR9tnd_diffRt dim_is_onetacceptedR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt_bc_adjust_dimensions$ )   cC`sGg}g}|jtjd}|jtjd}gt||D]!\} } |jd| | ^qF} g|D]} |jd| |^qt} gt| | D]\} }|j| |^q}gt|||D]$\}} } |j|| | ^q}gt||D]!\}} |j||| ^q}||fS(s 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. iis!=s==(RRRoR~RR\R*(R`R+RRRt bc_shapest bc_stridesRR9ttartoldtmismatcht src_is_onetxtytpredstp((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt_bc_adjust_shape_stridess4(4:4c C`stj||j}tj||j}t|||||\}}t|||||\}}|jdt|dd}t|||}t dtj ||dtj ||} tj ||| ||fS(sX Broadcast the given array to the target_shape. Returns (array_type, array) RVRGtARKR( RRRKRRRtcopyR}R\RRPt copy_struct( R`R+tarrtypeRSRRRt new_arrtypetnew_arrtrepl((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt_broadcast_to_shapes c% `s|j\}}|\}}t||}tj|j} tj|j} |j} t||||} | jt t j rfj | j } tt| \tjj}tjj}j}tj}t| t|ksHtx>t|| D]-\}}j|jd||}qXWj|dt$d}jjt|fWdQXt|||\}}| j| |j\}}t||| \}}t||||}t||||\}}nt t j rPj | j } t| dkstj!tt"t j#}|f}jd| d|}j|dt$d}jjt|fWdQXfd}d}nfd }d }| j$\} }!t%d |!D}"||"}#j&|#|j }#tj'| | | |j(| d t}$t)||#|$| j*|j+S( s 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. s!=Rs0cannot assign slice from input of different sizeNiic`s@|\}jtjttj}||fS(N(R8toperatortgetitemRRRm(ReRqt getitem_impl(R+R`Rzt src_dtypeRq(s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRs?s  cS`sdS(N((((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRwGsc`sS(N((Re(Rz(s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRsOscS`sdS(N((((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRwRscs`s!|]}|dk r|VqdS(N(R>(RR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pys YsR(,RR\RRRKRRyR-RRuRRR^RRR4R}RxR~R5RRRRRRR[R@RRZRbR}tSequenceR8RRmRBRRlRFRGRjRDR(%R`R+RDRRRRRMRt dest_shapest dest_stridest dest_dataR0t index_shapeRoRpRnt shape_errortuRRt src_starttsrc_endt dest_lowert dest_uppert dest_starttdest_endRrRsRwtlen_impltseq_lent dest_indicesRAReRiR|((R+R`RzRRqs5lib/python2.7/site-packages/numba/targets/arrayobj.pyRsz                    cC`s|jd}|jd}|d}|d}gt||D]'\}} |j|| |tj^q>}tj|||dj} tjdtjdt |} t j |j || } || f} | | fS(NiiR^R( RR~RlRRmRRPR'tUniTupleR}RRR(R`R+RDRRtdimtysRRRRRiRKtshapetytnew_sigtnew_args((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytvararg_to_tupleqs    :! sarray.transposecC`st|||jd|dS(Ni(tarray_TR(R`R+RDR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytarray_transposescC`st|tt|kr-tdnt|}x;|D]3}||ksdt||kr@tdq@q@W|||(|||(dS(Nsrepeated axis in transposes2axis is out of bounds for array of given dimension(R}RRtabs(taxisRKRR R((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytpermute_arrayss   cC`s|jd}t||||d}|jd|d}}|j|j}} |jtj} tjj | |} ||j |j g} g| D]} t j || ^q}x-t| |D]\}}|j||qWtjd| dddd}|jtj|j| }g| D]} t|||^q(}xlt||D][\}}t|d|j|| jd|jtj|gd |gd |d dqYW|j|ttjtj|||g|D]}|j^qt|j||}t|d|jd|j|dd |j|d d |j d |j!d |j"|j}t#|||j|S(NiiR^RVRGRcRyRKRRRiR($RR\RR^RRRmRtTypeRRKRRR?R~RRvRR_RRtt as_pointerR>tcompile_internalRRRtvoidRRRyR,RRRR(R`R+RDRRRtaxistyRtnum_axisR^R t ll_ary_sizetarysRMtll_arysRztdstt np_ary_tyt np_itemsizetnp_arystnp_arytll_arytatretR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytarray_transpose_tuplesF % (             cC`s.t||||\}}t||||S(N(RR(R`R+RDRRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytarray_transpose_varargscC`sOt|tjr$tjdn|dkr?dd}n dd}|S(Ns#np.transpose does not accept tuplescS`s |jS(N(t transpose(Rtaxes((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytnp_transpose_implscS`s |j|S(N(R(RR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRs(RuRRR tUnsupportedErrorR>(RRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytnumpy_transposes   tTc C`s|jdkr|}nt||||}t|||}tj||j|j}tj||j|j}t|d|jdtj||ddddtj||dddd|j d|j d|j |j }t ||||S( NiRyRKiRRRR(RVR\RRRKRRRyRPRRRRR( R`R+ttypRRRRRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRs       c C`s?|jtj}|j}|jtj} tjj| |||||||| g} |jj | dd} ||j } t j ||j ddd} t j ||j ddd}||}t j ||dd}t j ||dd}| d}|j| | | |||||j|g}|S(s 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. tnametnumba_attempt_nocopy_reshapeRKiR(RRRmRtintcRRtfunctionR(tget_or_insert_functionRVRRNRMtcallR(R`R+RRtnewndtnewshapet newstridesR t ll_intp_startll_intctfntytfntndRKRt is_f_orderR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt_attempt_nocopy_reshapes(      !!   c C`sd}d}xCt|D]5\}}|dkrD|d7}|}q||9}qW|dkr|||krtdqnu|dkr|dkrd}|dk}n||}||dk}|stdn|||RRRRRRRoRRR6R'RRRR9RyR,RRRR(R`R+RDRRtrettyRRKR tll_shapeRRt shape_ary_tyt shape_arytshape_itemsizeRrRRRtfailRRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt array_reshape8sT    !               cC`s.t||||\}}t||||S(N(RR(R`R+RDRRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytarray_reshape_varargyscC`s d}|S(NcS`s |j|S(N(treshape(RRK((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytnp_reshape_impls((RRKR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt np_reshapes s array.ravelcC`skd}d}|jdjdkr1|}n|}|j||||}t|||j|}|S(NcS`s|j|jS(sNo copy version(RRr(R((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt imp_nocopyscS`s |jS(s Copy version(tflatten(R((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytimp_copysiRc(RRGRRR(R`R+RDRRRtimpR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt array_ravels   cC`sd}|j||||S(NcS`s |jS(N(travel(R((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt np_ravel_impls(R(R`R+RDRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytnp_ravels s array.flattencC`s=d}|j||||}t|||j|}|S(NcS`s|jj|jS(N(RRRr(R((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRs(RRR(R`R+RDRRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt array_flattens c `s|j|jkst|j|jks0tt|j}tdtdtdtjfd}|jtjt||}|jtjt||}|jtj|j} t j ||j ddd} t j ||j ddd} tj dtjd d d d} |j | } t j||jtj|jg}|j|jtj}|jtj|}t j||g}| ||}t|d | d|d|d |dd| ||}t|d | d|d|d |dd|j}|j}| |||||jtj|g}ttjtj| | tjtjtj}|j||||}t||t|||j|}|S(s 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. RRctFc `s(|krM|d|kr+}qM|d|krM}qMn||kru|ksq|dkrutS|kr|d}nd}||kr||dkrtS||}||c|9<|||RRtbooleanRRRR(R`R+toldtytnewtyRt new_layoutRRRRt shape_datat strides_datatshape_strides_array_typetaryclstshape_constantt sizeof_intptstrides_constantRt strides_aryRKRRRDR((RRRRs5lib/python2.7/site-packages/numba/targets/arrayobj.pyt _change_dtypesl     0    !         cC`s+t|stjdnd}|S(Ns+The argument to np.shape must be array-likecS`stj|jS(N(tnptasarrayRK(R((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytimpl3s(RR t TypingError(RR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytnp_shape.s  cC`s d}|S(NcS`sotj|j}t|d }gt|dD]"\}}|||kr6|^q6}tj||S(Ni(RtsortRRRR(RtbtheadRSRttail((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytnp_unique_impl<s9((RR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt np_unique:s cC`sd}t|tjtjtjtjtjfrt|tjrLtSt|tjtjfrt|j tjr|Snt j dndS(Nc S`stj|dtj}|jddkr<t||dStj|dkr`tdntj|}|j}|jd}|j|jkrtdntjtj |d|j }d}x;t |D]-}|||||||+|||7}qW|S(NR^iis#negative dimensions are not alloweds(operands could not be broadcast together( RRtint64RKtnp_repeat_impl_repeats_scalerRRRtemptyR1R^R%( Rtrepeatst repeats_arraytasataraveltnt to_returntposRS((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt!np_repeat_impl_repeats_array_likeIs"   !sIThe repeats argument must be an integer or an array-like of integer dtype( RuRRvtListRtNumberR.RwR"R^R R(RR$R+((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt np_repeatDs  cC`s|dkrtdntj|}|j}|jd}|dkretjdd|jS|dkr~tj|Stj||d|j}x1t|D]#}||||||d|+qW|SdS(Nis#negative dimensions are not allowedR^i( RRRRRKR#R^RR%(RR$R&R'R(R)RS((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR"qs      !trepeatcC`s d}|S(NcS`stj||S(N(RR/(RR/((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytarray_repeat_impls((RR$R0((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt array_repeats s array.viewcC`sU|jd}|j}t||||d}t|||}t|jj}xct|D]U} t|| } | dkr|jj } |j | | |_qft || | qfWt |||||} |j d| tjj| j d} |j| $d}|jj|t|fWdQX|j}t|||j|S(NiRys==s"new type not compatible with array(RRR\RRRtsortedtgetattrRyR'RtRRR6RRR&RRRRRR(R`R+RDRRRRRtfieldsRRiRmRRRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt array_views$    ' R^cC`s|j}t||||S(N(RR(R`R+RRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt array_dtypes RKcC`s:t|}||||}|j}t||||S(N(R\RKR(R`R+RRRfRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt array_shapes  RcC`s:t|}||||}|j}t||||S(N(R\RR(R`R+RRRfRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt array_stridess  RVcC`s+|jtj|j}t||||S(N(RRRmRVR(R`R+RRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt array_ndimsRrcC`s:t|}||||}|j}t||||S(N(R\RR(R`R+RRRfRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt array_sizes  RcC`s:t|}||||}|j}t||||S(N(R\RR(R`R+RRRfRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytarray_itemsizes  tnbytescC`sIt|}||||}|j|j|j}t||||S(s" nbytes = size * itemsize (R\RRRR(R`R+RRRfRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt array_nbytess t contiguouscC`s+|jtj|j}t||||S(N(RRR t is_contigR(R`R+RRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytarray_contiguousst c_contiguouscC`s+|jtj|j}t||||S(N(RRR t is_c_contigR(R`R+RRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytarray_c_contiguousst f_contiguouscC`s+|jtj|j}t||||S(N(RRR t is_f_contigR(R`R+RRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytarray_f_contiguousstreadonlycC`s,|jtj|j }t||||S(N(RRR tmutableR(R`R+RRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytarray_readonlystctypesc C`svt|}||||}tj|}|j||}|j|_|j|_|j}t||||S(N(R\Rt ArrayCTypesRRyRRR( R`R+RRRfRtacttctinfoR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt array_ctypess    RycC`sR|j||d|}|j}|j||jtj}t||||S(NR(RRyRWRRRmR(R`R+RRRMR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytarray_ctypes_data s cC`sO|j||d|}|j}|j||j|}t||||S(NR(RRyRtRR(R`R+tfromtyttotyRiRMR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytarray_ctypes_to_pointers c C`st|||d|}tjtj|j}|j|j|j}ttj ||tj}|j |j |j tj|g}|j ||||} | S(s)Helper to invoke the contiguous checker function on an array Args ---- checker : ``numba.numpy_supports.is_contiguous``, or ``numba.numpy_supports.is_fortran``. context : target context builder : llvm ir builder aryty : numba type ary : llvm value R(R\RRRmRVR_RR^Rtbool_RKRRR( tcheckerR`R+RRttup_intpRt check_sigt check_argsR?((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt_call_contiguous_checks   RcC`sC|j|tj|}||_|j}t||||S(N(RRt ArrayFlagsRRR(R`R+RRtflagsobjR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt array_flags8s  cC`s|jjdkrK|j||d|}tt|||j|j}n'|jjdk}|jtj|}t ||||S(NRcR( RIRGRRXRRRRR R(R`R+RRRZRRi((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytarray_flags_c_contiguous@s cC`s|jjdkrK|j||d|}tt|||j|j}nK|jj}|jjdkru|dkn |dk}|jtj |}t ||||S(NRRiRQ( RIRGRRXRRRVRRR R(R`R+RRRZRRGRi((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytarray_flags_f_contiguousNs  *trealcC`sl|jtjkr+t||||ddS|jtjkrPt||||StdjtjdS(NtattrR^sunsupported .real for {}( R^Rtcomplex_domaintarray_complex_attrt number_domainRR9RR'(R`R+RR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytarray_real_part_s timagcC`s|jtjkr+t||||ddS|jtjkrnt|jdt|}t||||gSt dj t jdS(NR_RdRGsunsupported .imag for {}( R^RR`RaRbRRRAtnumpy_zeros_like_ndR9RR'(R`R+RRRD((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytarray_imag_partjs tconjt conjugatecC`s d}|S(NcS`s tj|S(N(RRg(RS((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRys((RSR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt array_conjvs cC`sU|d ks|jtjkr6tdj|nt|}||||}|jj}|j|j|}|j j |} |j |j } |j |j| } |dkr|j| tjddg} n|jd|dd} t| ||} td | d | }tj| ||t||| | jS( s 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 imaginery 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^Rdscannot get attribute `{}`i iR^RGRRyR(R^Rd(R^RR`R9RR\tunderlying_floatR_R]RR'RRRtRyRHRtIntTypeRRRRRR(R`R+RRR_RfRtfltyt sizeof_fltyRt llfltptrtyRtresulttyRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRa~s    'cC`s |jS(N(R(R`R+tdtypetytdtypeval((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt dtype_typesR'tkindcC`s\t|}||||}|j}t|tjsRtd||fn|j|}|j|} |jd|dd} t| } | ||} |j tj | } t j ||j | d| j j}|j|j|}t| d|d|jd|jd |j tj |d |jd |j| j}t||| |S( sq Generic getattr() implementation for record arrays: fetch the given record member, i.e. a subarray. sattribute %r of %s not definedR^RGRRRyRKRRRR(R\R^RuRtRecordR9ttypeoftoffsetRRRmRt pointer_addRyR'R_R]RRKRRRRR(R`R+RRR_RfRtrectypeR^Rvtrestytrarytytraryt constoffsett newdataptrtdatasizeR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytarray_record_getattrs.         tstatic_getitemcC`sC|d}t|ts"tnt|||jd|d|S(Nii(RutstrR9RR(R`R+RDRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytarray_record_getitems  cC`s|j|||j|}|j|}t|tjrRt|}|||}|j} g|jD]} |j tj | ^qn} g|j D]} |j tj | ^q} t j ||||j| } t|d| dt j|| dt j|| d|j tj |jdddd|j}t||||St j ||||j|}|jrdnd}|j||||}t||||SdS( si Generic getattr() implementation for records: fetch the given record member, i.e. a scalar. RyRKRRRRiN(tsentry_record_alignmentRvRuRuRt NestedArrayR\R^RKRRmRRtget_record_memberR]RRPRrR>RRRdRe(R`R+RRR_RvtelemtyRRR^RRRtnewdataRtdptrRc((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytrecord_getattrs8  (( c C`s|j\}}|\}}|j|||j|} |j|} tj||| |j| } |j|||| }|jrdnd} |j || || d| dS(sg Generic setattr() implementation for records: set the given record member, i.e. a scalar. iRcN( RRRvRuRRR]RlRdR>Rh( R`R+RDRR_RRttargetRiRvRRRc((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytrecord_setattr s cC`sB|j|jd|d}||||jd|d|dS(s3 Record.__getitem__ redirects to getattr() ii(t get_getattrR(R`R+RDRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytrecord_getitem0 ststatic_setitemc C`sm|j\}}}|\}}} t|j||} |j|| } | dk sZt| ||| fS(s3 Record.__setitem__ redirects to setattr() N(RRRt get_setattrR>Rx( R`R+RDRtrectyRMRtrecRqRit getattr_sigR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytrecord_setitem9 s cC`s|j|||S(sB Create a constant array (mechanism is target-dependent). (tmake_constant_array(R`R+Rtpyval((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytconstant_arrayJ scC`sFtjtjd|j}|t|j}tj||S(sG Create a record constant as a stack-allocated array of bytes. i(Rt ArrayTypeRkR<t bytearrayttostringRR(R`R+RRtltyRi((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytconstant_recordR scC`sA|j\}}||kr"tjSd}|j||||S(NcS`s:|j|jko9|j|jko9|jj|jjkS(N(RKRRJRy(RR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt array_is_imple s(RRR4R(R`R+RDRtatytbtyR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytarray_is_ s   cC`s t|dS(sq Return the Structure representation of the given *flatiterty* (an instance of types.NumpyFlatType). tflat(t_make_flattening_iter_cls(t flatiterty((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytmake_array_flat_clsp scC`s t|dS(sv Return the Structure representation of the given *nditerty* (an instance of types.NumpyNdEnumerateType). t ndenumerate(R(tnditerty((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytmake_array_ndenumerate_clsx scC`sj|jtjd}|jd} |dk rF|jtj|nxtt |D]} tj ||| } tj ||j | } || } |j d| | }tj||;|j| | |dk r|| n|j| WdQX|j|| |dk rY|| qYqYW|dk rL|jtj|n|j| |j| dS(Nit end_incrementR3(RRRmR R>RRt false_byteRCR%RNRR,Rt if_likelyRt true_byteR(R`R+RVRKRtend_flagt loop_continuet loop_breakRtbbendR tidxptrRqRt in_bounds((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt_increment_indices s*       cC`s;tj||j|j}t|||j|||dS(N(RRRKRVR(R`R+RRRSRRRK((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt_increment_indices_array sc `sjjtjjr0nd dtfdY}d|fdYd|ffdYd|fd Yd |fd Yd |fd Ydtjf f dY}|S(sq Return the Structure representation of the given *nditerty* (an instance of types.NumpyNdIterType). it BaseSubItercB`sMeZdZdZdZejdZdZdZ dZ RS(sF Base class for sub-iterators of a nditer() instance. cS`s5||_||_||_||_|||_dS(N(tnditert member_namet start_dimtend_dimRV(RBRRRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR  s     cS`st|j|j|dS(N(RRR(RBRQ((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytset_member_ptr scS`st|j|jS(N(R3RR(RB((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt member_ptr scS`sdS(N((RBR`R+((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt init_specific scS`sdS(N((RBR`R+t logical_dim((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR scS`sdS(N((RBR`R+R((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR s( RWRXRR RRtcached_propertyRRRR(((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR s    t FlatSubItercB`s2eZdZdZdZdZdZRS(s Sub-iterator walking a contiguous array in physical order, with support for broadcasting (the index is reset on the outer dimension). cS`s2|jtjd}|jtj||dS(Ni(RRRmRRR(RBR`R+R((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR scS`s(|j|j}|j|j|gS(N(R,RRHRy(RBR`R+RRRRSR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytcompute_pointer scS`sQ||jdkrM|j|j}tj||}|j||jndS(Ni(RVR,RRRR(RBR`R+RR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR scS`s|dkr7|jtjd}|j||jnM||jdkr|j|j}tj||}|j||jndS(Nii( RRRmRRRVR,RR(RBR`R+RRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR s (RWRXRRRRR(((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR s    tTrivialFlatSubIterc`s&eZdZfdZdZRS(sx Sub-iterator walking a contiguous array in physical order, *without* support for broadcasting. c`sj stdS(N(tneed_shaped_indexingRx(RBR`R+(R(s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR scS`s7t|dks$tt||j|j|S(Ni(R}RxRHRy(RBR`R+RRRRS((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR s$(RWRXRRR((R(s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR stIndexedSubItercB`seZdZdZRS(sA Sub-iterator walking an array in logical order. cS`s7t||jksttj||||dtS(NR(R}RVRxRRR(RBR`R+RRRRS((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR s(RWRXRR(((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR stZeroDimSubItercB`seZdZdZRS(s5 Sub-iterator "walking" a 0-d array. cS`s|jS(N(Ry(RBR`R+RRRRS((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR s(RWRXRR(((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR st ScalarSubItercB`seZdZdZRS(s8 Sub-iterator "walking" a scalar value. cS`s|S(N((RBR`R+RRRRS((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR s(RWRXRR(((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR stNdIterc`seZdZejfdZ fdZfdZdZdZ  fdZ dZ dZ RS( s .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 `sg}ijrnd6d6d6d6}x_tjD]N\}}|\}}}}d|} ||} |j| || ||qGW|S(NRtindexedt0dtscalarsindex%d(RRR/RO( RBtlt factoriesRSR7RsRRRMRtfactory(RRRRRR(s5lib/python2.7/site-packages/numba/targets/arrayobj.pytsubiters s    c `s?|jtjd}|j|tj|||_x_t|D]Q\}}t|tjsCd|}t j |||} t ||| qCqCW|j ||||}tj tj} d} d} xt|D]K\}} t| tjr| jkr||j} ||j} PqqWdks?t|j|| d } |jtjd} d}xt||D]p\} }t| tjr| jdkr|j||ttjtj tj| j| |j| fqqWt j|| }dkr*|ddd}n|jd| |}|j|t jt j}jso| f}nt|kstt j||jd }x9t D]+}t j!|||}|j"||qW||_#t j$|||j|_t j |||_%x!|j&D]}|j'||q!WdS( sY Initialize the nditer() instance for the specific array inputs. isscalar%dicS`sXt|}xEt|D]7}|||t|||krtdqqWdS(Ns2nditer(): operands could not be broadcast together(R}R%R(RKt main_shapeR(RS((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt check_shapeN s "RNis==Rr(((RRRmt make_tupletTupletarraysRRuRvRRRt_arrays_or_scalarsRR>RVRKRRxR~RRtnoneRRR*RRRR}R?R'R%RNRRRPt exhaustedRR(RBR`R+tarrtysRRRSRRtslott main_shape_tyRt main_nitemsRRRRSRtshape_is_emptyRRR Rtsubiter(RGRVRtnshapes(s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR+ s\  !   !       c `s|jd}tj||j|j}tj|||jt|j|WdQXj }tj ||j }|j ||||}|j }|jt |j|||||} g| D]} | j^q} t| dkr |j| dn|j|j|j| tj ||j} t||t| | ||jtj|j||tj|j|||j||j|dS(sJ Compute next iteration of the nditer() instance. RYNii(R Rt as_bool_bitR,Rt if_unlikelyRRRRRRRRAt _make_viewsRR}RRt yield_typeRKRR~tpartialt_loop_continuet _loop_breakR( RBR`R+RRRRRRtviewsRRK(R(s5lib/python2.7/site-packages/numba/targets/arrayobj.pytiternext_specificy s.       cS`sWxP|jD]E}|j|ko-|jknr |j||||jq q WdS(N(RRRR(RBR`R+R R7((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR s"cS`sWxP|jD]E}|j|ko-|jknr |j||||jq q WdS(N(RRRR(RBR`R+R R7((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR s"c `shdg}j}|j}j} t| tjrIt| } n | g} gtD]$} |j t j ||| ^q_}xt ||D]\} } | \} } } }|| j | j!}dkr|ddd}nxU|D]M} || dkst|j|||| | || || | || s(R>R/RRRuRRRR%R,RRNR~RRRxt _make_viewtall(RBR`R+RRRRR/RtrettysRSR7RRMt array_indicest sub_indices(RGtnarraysRR(s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR s*     4  #c S`st|tjr!|jdks't|j|||||}|j|||} t||} |j|tj tj dd} |j|tj tj dd} t | || | | dd| S(sD Compute a 0d view for a given input array. iR((N( RuRRvRVRxRR\RbRRRmRR>( RBR`R+RRRRRSRRQtviewRRKR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR s'$$c S`sg}x}tt||D]f\}\}}t|tjrh|j|j|||d|q|jt|d|qW|S(NRsscalar%d(RR~RuRRvROR\R3( RBR`R+RRRRSRRRS((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR s ((( RWRXRRRRRRRRRRR(( RRRRRRGRRVRR(s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR s'N%   (RVRGR}RRtobjectRR[(RRR(( RRRRRRGRRVRRs5lib/python2.7/site-packages/numba/targets/arrayobj.pytmake_nditer_cls s     @c`s2|jdtj|ffdY}|S(sr Return the Structure representation of the given *nditerty* (an instance of types.NumpyNdIndexType). t NdIndexIterc`s,eZdZfdZfdZRS(s, .ndindex() implementation. c `s|jtjd}tj||jd|jtj}tj|tj}xtD]y}tj |||}|j ||||} |j t j | |} tj|| |j tj|WdQXqaW||_||_tj|||j|_dS(NiRr(RRRmRR?R'RRR%RNRRRtICMP_EQRRRRRPRK( RBR`R+RRRRR RR#t dim_is_empty(RV(s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR s     c `sN|jtjd}|jd}tj||j|j}tj|||j t |j |WdQXgt D]'}|jtj ||j|^q}x|D]} t|| qW|jtj|||j|j ttj||j} t||| |j|j|j ||j|dS(NiRY(RRRmR RRR,RRRRRR%RNRR3RRPR'RARRKRR( RBR`R+RRRRR RR,RK(RV(s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR s" 7   (RWRXRRR((RV(s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR s(RVRR[(RR((RVs5lib/python2.7/site-packages/numba/targets/arrayobj.pytmake_ndindex_cls s %4c`sdkst|j}|jdkrSdtj|ffdY}|Sdtj|ffdY}|SdS( NRRRctCContiguousFlatIterc`s>eZdZfdZfdZdZdZRS(sZ .flat() / .ndenumerate() implementation for C-contiguous arrays. c `s|jtjd}tj|||_|j|_dkrtj||j d|jtj|j }x<t |j D]+}tj |||}|j ||qW||_ndS(NiRRr(RRRmRRRRR:R?R'RVR%RNRR( RBR`R+RRRSRRR R(Rs(s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR, s   c `s[|j}|j}|j|j}|jtj||} |j| tj || |j |j |g} t |||| } dkr|j | n|j} gt|D]$} |jtj|| | ^q}tj||}|j tj||| gt||||| tj||}|j||jWdQXdS(NR(RVRR,RRRRRRRRHRyRgRRR%RNRPtmake_anonymous_structRRR(RBR`R+RRRSRRVRRRRQRRR tidxvalstidxtuple(Rs(s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRE s&     4cS`s+|j|j|g}t||||S(N(RHRyRg(RBR`R+RRRSRRQ((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR_ scS`s2|j|j|g}t|||||dS(N(RHRyRj(RBR`R+RRRSRRRQ((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytsetitemc s(RWRXRRRRR((Rs(s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR' s  tFlatIterc`sAeZdZdZfdZdZdZdZRS(s Generic .flat() / .ndenumerate() implementation for non-contiguous arrays. It keeps track of pointers along each dimension in order to minimize computations. cS`s||jtjd}|j}|j}tj||j|}tj||j d|jtj|j} tj||j d|jtj|j} tj |tj } xt |D]} tj || | } tj || | }|j|||j|| || }|jtj||}tj|||jtj| WdQXqW| |_| |_| |_dS(NiRr(RRRmRyRVRRRKR?R'RRR%RNRRRRRRRtpointersR(RBR`R+RRRSRRyRVRRRRR RtptrptrR#R((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRr s.       c `s |j}tj||j|}tj||j|}|j} |j} |jtj d} |j d} tj ||j |j } tj|| |jt|j| WdQX|jttj|| |d}|j |}t||||}dkr&|j|nhgt|D]$}|j tj|| |^q3}tj||}|jtj|||gxHtt|D]4}tj|| |}tj||j |}||}||}|jtj||}tj|||j||tj|| |}|j |}tj |||}|j||x@t|d|D]+}tj|| |}|j||qW|j| WdQX|j| |qW|jtj!|j |j| |j"| dS(NiRYiR(#RVRRRKRRRRRRmR RR,RRRRRRARNRgRR%RPRRCRRRRRRRwRR(RBR`R+RRRSRRVRRRRRRt is_exhaustedtlast_ptrRQRR RRRRqRR:RRt inner_dim(Rs(s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR sX      4    c S`s|j}tj||jd|}tj||jd|}g} xMtt|D]9} | j|j||| |j ||| }qXW| j tj ||j |||j | } | S(NR(RVRRRKRRCR%ROturemtudivtreverseRFRyRG( RBR`R+RRRSRRVRRRR RQ((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt_ptr_for_index s  cS`s.|j|||||}t||||S(N(RRg(RBR`R+RRRSRRQ((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR scS`s5|j|||||}t|||||dS(N(RRj(RBR`R+RRRSRRRQ((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR s(RWRXRRRRRR((Rs(s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRj s  @  (RR(RxRIRGRR[(RRsRIRR((Rss5lib/python2.7/site-packages/numba/targets/arrayobj.pyR! s %@%RcC`sttj|}|||}||_|j|}|||d|jd}|j|||||j}t||tj||S(NRCR( RRt NumpyFlatTypeRR\RMRRR(R`R+RRRSt flatiterclstflatitertarrclsR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytmake_array_flatiter s  c C`s|j\}|\}t|}|||d|}|j}|j|} | ||d|j} |j|||| |dS(NR(RRRIR\RR( R`R+RDRRRRRRRRRS((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytiternext_numpy_flatiter s    c C`s|jd}|\}}t|}|||d|}|j}|j|} | ||d|j} |j|||| |} t|||j| S(NiR(RRRIR\RRRR( R`R+RDRRRRRRRRRSR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytiternext_numpy_getitem s    c C`s|jd}|\}}}t|}|||d|}|j} |j| } | ||d|j} |j||| | |||jS(NiR(RRRIR\RRR( R`R+RDRRRRRRRRRRS((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytiternext_numpy_getitem_any s   c C`sc|jd}t|}|||d|d}|j|j}|||d|j}|jS(NiR(RRR\RIRR( R`R+RDRRRRRRS((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytiternext_numpy_getitem_flat. s   c C`s|j\}|\}ttj|}|||}||_|j|}|||d|jd}|j|||||j} t |||j | S(NRCR( RRRtNumpyNdEnumerateTypeRR\RMRRRR( R`R+RDRRRRSt nditerclsRRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytmake_array_ndenumerate9 s    c C`s|j\}|\}t|}|||d|}|j}|j|} | ||d|j} |j|||| |dS(NR(RRRIR\RR( R`R+RDRRRRR RRRRS((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytiternext_numpy_nditerK s    c C`sgt|j|D]'\}}|j|||tj^q}ttjt|}|||}|j||||j } t |||j | S(sndindex(*shape)( R~RRlRRmRtNumpyNdIndexTypeR}RRRR( R`R+RDRtargtytargRKR RR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytmake_array_ndindex[ s= c C`s|jj}|dkrx|jdj}|d}tj|||}g|D]!}|j|||tj^qN}ng}t tj t |} | ||} | j |||| j } t|||j| S(sndindex(shape)i(RRVRR^RRRlRRmRR R}RRR( R`R+RDRRVRpRRKRqR RR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytmake_array_ndindex_tuplej s   . cC`sM|j\}|\}t|}|||d|}|j|||dS(NR(RRR(R`R+RDRRRRR ((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytiternext_numpy_ndindex s    c C`s|j}|j}t|jdtjrDtj||d}n |dg}t|||}|j |||||j }t ||||S(s nditer(...) i( RRRuRRRRRRRRR( R`R+RDRRRRRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytmake_array_nditer s    cC`sG|j\}|\}t|||d|}|j|||dS(NR(RRR(R`R+RDRRRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytiternext_numpy_nditer2 s  c C`sHt|}|||}|j|j}|jtjt||}|jtjd}x |D]} |j|| }qgW|jdkrd} n|j dkr|g} x5t |dD]#} | j |j| d| qWt t | } nq|j dkrY|g} x/|d D]#} | j |j| d| q#Wt | } nt dj|j |j||} |j|j} |jj|d| d| }|jj||}|jtj}tj||d |}tj|| d |}t|d |j||jd |d |d |d||S(s 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. iiRciRs3Don't know how to allocate array with layout '{0}'.RrRcRRyRKRRR((R\R]R^RRRmRbRRVRGRCRORR9Rtget_preferred_array_alignmentRtmeminfo_alloc_alignedt meminfo_dataRRRPRRtR(R`R+RRRRtdatatypeRtarrlenRRtdimension_sizeR{RcRRyRt shape_arrayt strides_array((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRE sJ    ! !  cC`s/tj||j|j|j|jddS(s< Zero-fill an array. The array must be contiguous. iN(RtmemsetRyRRR(R`R+R((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt_zero_fill_array sc C`st|tjr9d}|j|||tjg}n9t|tjsQt|j}tj ||d|}|j |tjd}x\t |D]N}|j d|||}tj |||jj|tdWdQXqW|S(s; Parse the shape argument to an array constructor. iRiR3snegative dimensions not allowedN(snegative dimensions not allowed(RuRRwRlRmRRxRRRtget_constant_genericR%RRRRR( R`R+RRiRVRRR tis_neg((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt _parse_shape s! cC`s9|jd}|d}|j}|t||||fS(sL Parse the arguments of a np.empty(), np.zeros() or np.ones() call. i(RRR!(R`R+RDRt arrshapetypetarrshapeR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt_parse_empty_args s   cC`sz|jd}t|tjrit|||d|d}tj||jd|j}|j |fS|j dfSdS(s_ Parse the arguments of a np.empty_like(), np.zeros_like() or np.ones_like() call. iRRN(( RRuRRvR\RRRKRVR(R`R+RDRtarytypeRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt_parse_empty_like_args s   cC`sLt||||\}}t||||}t|||j|jS(N(R$RERRR(R`R+RDRRRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytnumpy_empty_nd scC`sLt||||\}}t||||}t|||j|jS(N(R&RERRR(R`R+RDRRRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytnumpy_empty_like_nd" scC`s\t||||\}}t||||}t|||t|||j|jS(N(R$RERRRR(R`R+RDRRRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytnumpy_zeros_nd* scC`s\t||||\}}t||||}t|||t|||j|jS(N(R&RERRRR(R`R+RDRRRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRe3 sicC`sOtdkrd}n d}|j||||}t|||j|S(Nii cS`sLtj|}tj|j}x$tj|jD]}|||t|||}x(t|D]}d||||fRuRRBRR^tfloatt DTypeSpecR-R R3(R?R@RR^R((RGs5lib/python2.7/site-packages/numba/targets/arrayobj.pyt numpy_eye s cC`sd}|j||||S(NcS`stj|ddS(NRi(Rtdiag(Ri((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt diag_impl s(R(R`R+RDRRL((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt numpy_diag s cC`s|jd}|jdkr+dd}n*|jdkrIdd}n td|j||||}t|||j|S(NiicS`s|j}|dt|}tj||f|j}|dkrzxft||D]}||||||fsc S`s|||}tj|j}tj|j}tt||d}tj||}|} x(t|D]} | || <| |7} qoW|S(Ni( tmathtceilR^RdRNRDRR#R%( RR+R%R^tnitems_ctnitems_rtnitems_iRRSRiRS((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR[s c S`smtj|||}t|d}tj||}|}x(t|D]}|||<||7}qKW|S(Ni(R`RaRNRR#R%( RR+R%R^RcRRSRiRS((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR[s R5R(RRRRRmRR(R`R+RDRR[R((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytnumpy_arange_4s  cC`s7d}|j||||}t|||j|S(NcS`stj||dS(Ni2(Rtlinspace(RR+((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRfs(RRR(R`R+RDRRfR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytnumpy_linspace_2s c`sOt|jjfd}|j||||}t|||j|S(Nc`sdtj|}|d}||}||dRR(R`R+RDRRmRRQRKRRRRRRPRtoffRRRyR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt np_cfarraywsB    :       cC`s{t|tjr+|jtjt|St|tjrk|jtttj|}|||fSdswt dS(Ni( RuRRRRmR}RR8RRx(R`R+tseqtytseqR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt _get_seq_sizes c`sF|jjtjt|tjfd}|S(sK Return a getitem() implementation that doesn't incref its result. c`s5||}jr1jj||n|S(N(RRtdecref(R+RR(R`RR(s5lib/python2.7/site-packages/numba/targets/arrayobj.pytwraps (R^R8RRRRRm(R`RR((R`RRs5lib/python2.7/site-packages/numba/targets/arrayobj.pyt_get_borrowing_getitems   c `sjtj}tj|dfd}g}||}} xTt|D]F} | dkr||| \}} n|jt|| qYWt|S(sF Compute the likely shape of a nested sequence (possibly 0d). ic`stt|tjrEt|dkr(dS|dj|dfSn+t|}|j||ffSdS(Ni(NN(RuRRR}R>RRR^(RRR(R+R`R(s5lib/python2.7/site-packages/numba/targets/arrayobj.pytget_first_items ( RRRmRR&R%RORR( R`R+RVRRRRRtinnertytinnerRS((R+R`Rs5lib/python2.7/site-packages/numba/targets/arrayobj.pytcompute_sequence_shapes    c`s>fdfd|||dS(s? Check the nested sequence matches the given *shapes*. c`sjjtddS(Nsincompatible sequence shape(sincompatible sequence shape(RRR((R+R`(s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt_failsc `sot|dkrdSt||}|d}jd||}j|dt WdQXt|dkrdSt|tjrt|}t j |<}|j }|||j f} || |dWdQXntt|tj rYx_tt|D]6} || }j|| } || |dqWndskt|dS(Nis!=Ri(R}RRRRRuRRRRRR^RRR%RRx( RRRRrtexpectedRRRRRRS(RR+tcheck_seq_sizeR`(s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRs*    N((R`R+RRR((RR+RR`s5lib/python2.7/site-packages/numba/targets/arrayobj.pytcheck_sequence_shapesc`sMfdfd||ddS(sl Assign a nested sequence contents to an array. The shape must match the sequence's structure. c `s\tjj|dt}j||j}t||dS(NR(RRFRGRRlR^Rj(RRRiRQ(RRR+R`RyRR(s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt assign_itemsc `sjt|dkrHt|tjtjf s4t|||dS|d}t|tjrt|}tj|I}|j }|||j f}|||d||j fWdQXnt|tjrTx~t t|D]U} || }j || }j tj| } |||d|| fqWndsft|dS(Nii(R}RuRRRRxRRRR^RR%RRRm( RRRRRrRRRRRSR(tassignRR+R`(s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRs$"  * %N(((R`R+RyRRRRRR((RRRRR+R`RyRRs5lib/python2.7/site-packages/numba/targets/arrayobj.pytassign_sequence_to_arraysc C`s|j}|j}|jd}|d}t|||||}t||ksYtt|||||t||||} t||| j || j |||t |||j| j S(Ni( RRVRRR}RxRRERRyRRR( R`R+RDRRRRVRRRRS((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytnp_array:s     c C`s|jd}|j|}|jd||}|j||j|||}|j|jd|||jd||}|j|dt(d|} |jj|t | fWdQX|S(NiR3s>=Rs%s(): axis out of bounds( R'RR*RR5RRRRRR( R`R+t func_nameRVRRtll_ndimt is_neg_axistaxis_out_of_boundsR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt_normalize_axisMs! c C`st||dksttjtj|}tj||}tjd}xt|dD]w}tj|} |jd| |} ||} |j | |j | || } |j | tj ||d| qcW|j |tj ||d|tj ||j|S(s 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). is>=i(R}RxRRRRR?R%RR*RRRNRR,( R`R+t orig_shapeRVRtll_shtyRR9R tll_dimt after_axisRRq((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt_insert_axis_in_shape`s   &"c C`s"t||dksttjtj|}tj||}tjd}tjd}xt|dD]q} tj| } |jd| |} |j | |j | || } |j || tj ||d| qrW|j |tj ||d|tj ||j|S(sD Same as _insert_axis_in_shape(), but with a strides array. iis>=(R}RxRRRRR?R%RR*RRRNRR,( R`R+t orig_stridesRVRRRR9RR RRRq((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt_insert_axis_in_strides}s   "cC`s|j}|j}|jd}t|||d|d}t|||} tj||j} tj||j} t||| ||} t ||| ||} t | d|j d| d| d|j d|j d|j| jS( s/ np.expand_dims() with the given axis. iRRyRKRRRR(RRVRR\RRRKRRRRRyRRRR(R`R+RDRRRRVRRRSRRRt new_shapest new_strides((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt expand_dimss"        cC`sr|j||d|jdtj}t||d|jj|}t|||||}t|||j|S(Nisnp.expand_dims( RlRRRmRRRVRR(R`R+RDRRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytnp_expand_dimss & c C`s|j}|}t|jtjr6t|j}n |jg}t|t|ks`tgt|||D]'\}} } ||||| | ^qs} t|jtjr|j ||j| } n | d} t |||j| S(Ni( RRuRRRRR}RxR~RR( R`R+RDRt transformRtarrsRRSRRRtretsR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt _atleast_nds  = c`s.tkstfd}|S(s` Return a callback successively inserting 1-sized dimensions at the following axes. c `sxtD]{}|d}|j|kr tj|}|jd|jd}t||tj|||f|}|}q q W|S(NiRV(R%RVRRRRRR( R`R+RSRRRRSRVRtnewarrty(Rtmin_ndim(s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRs    (R}Rx(RRR((RRs5lib/python2.7/site-packages/numba/targets/arrayobj.pyt_atleast_nd_transforms cC`s(tddg}t|||||S(Nii(RR(R`R+RDRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt np_atleast_1dscC`s+tdddg}t|||||S(Nii(RR(R`R+RDRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt np_atleast_2dscC`s.tddddg}t|||||S(Niii(RR(R`R+RDRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt np_atleast_3dsc  C`s=t|t|ko:t|ko:t|knsEttjd} t||||} tj|| j} g} x|D]} | }xztt| | D]c\}\}}|j d|j ||}|j ||}|j ||j |||}qW| j|qW| j}xt||||| D]\}}} }}|j}tj|| tjd|j}|}tj||| ||j|}t||||}|j|||j|j}tj|||| |j|}t|||||WdQXtj|||}qGW| S(s2 Concatenate arrays along the given axis. is==torderN(R}RxRRRERRRR~RR'RR*RRORyRyRGRFRgRlR^RjRw(R`R+RRRt arr_shapest arr_stridesRt ret_shapesRRt ret_stridest copy_offsetstarr_shRvR RrR:tis_axistaddendtret_dataRRRStarr_sttarr_dataRyRRfRiR|((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt_do_concatenates@E (        cC`s|j}gt||D]'\}}t|||d|^q}t||d||}g|D]} tj|| j^qe} g|D]} tj|| j^q} g| dD]} tj|| ^q} xMt |D]?}|j d|j ||}| |}|j |}g| dD]} | |^q,}|j |\}}|1tj|j||g} |j| |WdQX|tj}x/|D]'} |j||j d| |}qW|j|j|dt"|jj|td|fWdQXWdQXWdQXqWg| D]} |j | ^q.} t|||||| | || }t||||jS(NRsnp.concatenateis==iRs<np.concatenate(): input sizes over dimension %d do not match(RVR~R\RRRRKRRR%RR'R,RdR~RRRRR\RRRRRRRRR(R`R+RRRRRVRRRSRRRRR Rt ret_shape_ptrtret_sht other_shapeston_axist on_other_dimtis_okR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt_np_concatenate=sB :((& !    $"   c C`ss|j}tjd}tjd}tjt|} gt||D]'\} } t| ||d| ^qL}t||d||}tj||dj} x|dD]} tj }xttj|| j| D]h\}}|j ||j d||}|j |j |dt|jj|td WdQXqWqWg|D]} tj|| j^qZ}tjtj|}tj||}tj||}xt|dD]}tj|}|j d||}| |}|j||j|||}|j|tj||d||j|tj||d|qW|j|tj||d||j| tj||d|tj||j|gt|}tj||j|}gtt|D]}tj||^q}xt|dD]}tj|}|j d||}|j||j|||}xHtt|D]4}|j|||tj|||d|qWq+Wx@tt|D],}|j|tj|||d|qWg|D]!}tj||j|^q}t||||||||| }t||||jS( NiiRsnp.stacks==Rs5np.stack(): all input arrays must have the same shapes>=(s5np.stack(): all input arrays must have the same shape(RVRRR}R~R\RRRKRR\RRRRRRRRRRR?R%R*RRRNR,RRR(R`R+RRRRRVRR9t ll_narraysRRRRSRRtorig_shRRt input_shapesRR RRRqRSt input_stridesRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt _np_stacknsj : ! (   "&""(.  %*+   cC`sN|jtjd}t||t|jdtj||d|j|S(Ni( RRRmRRRRRR(R`R+RDRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytnp_concatenates  cC`s_|j||d|jdtj}t||t|jdtj||d|j|S(Nii( RlRRRmRRRRR(R`R+RDRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytnp_concatenate_axiss & cC`s t|jd}tj||d}g}g}|jtjd}xt||D]\} } | jdkr|j | |j | qZ| jdkst | j dd} t j | | } t||| | f|} |j | |j | qZWt|||||j|S(NiiiRV(RRRRRRRmR~RVRORxRRRRRR(R`R+RDRt orig_arrtyst orig_arrsRRRRRRSR t expand_sigtnewarr((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytnp_column_stacks"  cC`s9t||t|jdtj||d|j|S(s/ np.stack() with the given axis value. i(RRRRRR(R`R+RDRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt_np_stack_commons  i cC`s+|jtjd}t|||||S(Ni(RRRmR(R`R+RDRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytnp_stackscC`s<|j||d|jdtj}t|||||S(Ni(RlRRRmR(R`R+RDRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt np_stack_axiss&c`s|jd}|dj}|dkrQ|jtjdt||||S|dkrcdndfd}|j||||SdS(Niic`stj|dS(NR(Rt concatenate(R(R(s5lib/python2.7/site-packages/numba/targets/arrayobj.pytnp_hstack_impls(RRVRRRmRR(R`R+RDRRRVR((Rs5lib/python2.7/site-packages/numba/targets/arrayobj.pyt np_hstacks   cC`s|jd}|dj}|dkr2d}n@|dkri|jtjd}t|||||Sd}|j||||S(NicS`stjtj|dS(Ni(RRthstack(R((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytnp_vstack_impl"sicS`stj|ddS(NRi(RR(R((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR+s(RRVRRRmRR(R`R+RDRRRVRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt np_vstacks      c C`sO|jd}|j}|dj}|dkrNd}|j||||S|dkr|jtjd}|jd|jd} tj | |j} t ||| ||} |jtjd}tj || } t ||| | f|S|dkr,|jtjd}t |||||Sd}|j||||SdS(NicS`stj|jdddS(Nii(RRR(R((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyR8siRVicS`stj|ddS(NRi(RR(R((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRNs( RRRVRRRRmRRRRR( R`R+RDRRRRVRRt stack_rettyt stack_sigt stack_retR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt np_dstack1s&        tfillcC`s d}|S(NcS`s ||(dS(N(R>(RSRi((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt fill_implWs((RSRiR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytarr_fillTs tdotcC`s d}|S(NcS`stj||S(N(RR(RStother((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytdot_impl`s((RSRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt array_dot^s cC`stj|p||kS(N(R`tisnan(RR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt lt_floatslscC`s|||f}y t|SWntk r|dkrgtjd|rLtndd|}|j}n<|dkrtjd|rtndd|}|j }n|t|<|SXdS(s6 Get a sort implementation of the given kind. R"tltt is_argsortR#N( t_sortstKeyErrorR"tmake_jit_quicksortRR>t run_quicksortR#tmake_jit_mergesortt run_mergesort(Rstis_floatRtkeyRtfunc((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt get_sort_funcps            s array.sortc`sV|jd}tdddt|jtjfd}|j||||S(NiRsR"Rc`s|dS(N((RS(t sort_func(s5lib/python2.7/site-packages/numba/targets/arrayobj.pytarray_sort_impls(RRRuR^RtFloatR(R`R+RDRR%R((Rs5lib/python2.7/site-packages/numba/targets/arrayobj.pyt array_sorts   cC`sd}|j||||S(NcS`s|j}|j|S(N(RR(RR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt np_sort_impls  (R(R`R+RDRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytnp_sorts s array.argsortc `s|j\}}td|jdt|jtjdtfd}|jd|jd }|d }|j ||||S(NRsRRc`s |S(N((RS(R(s5lib/python2.7/site-packages/numba/targets/arrayobj.pytarray_argsort_implsRi( RRt literal_valueRuR^RRRAtreplaceR( R`R+RDRR%RsRtinnersigt innerargs((Rs5lib/python2.7/site-packages/numba/targets/arrayobj.pyt array_argsorts   cC`s+|j|jks'|jdks't|S(NR(RHRGRx(R`R+RPRQRi((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytarray_to_arrays'cC`s tdS(sR An intrinsic returning a derived array with the given shape and strides. N(R9(RRKR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytreshape_uncheckedsc`sdfd}|S(NcS`s&t|tjo%td|DS(Ncs`s!|]}t|tjVqdS(N(RuRRw(RR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pys s(RuRRR(RK((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRsc`slt|tjsdS| s0| r4dSt|t|krPdS|jdt|ddS(NRVRGR(RuRRvR}R(RRKR(R(s5lib/python2.7/site-packages/numba/targets/arrayobj.pyttypers((R`R ((Rs5lib/python2.7/site-packages/numba/targets/arrayobj.pyttype_reshape_uncheckeds  c C`s|jd}|j}t||||d}t|||}tj||d}tj||d} t|d|jd|d| d|jd|j|j } t |||| S( NiiiRyRKRRR( RRR\RRRRyRRRR( R`R+RDRRRRRRKRR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pytimpl_shape_uncheckeds       c`s|dtjfkr'tdntd|dtjfkrZtdntdddfd}|S(NcS`s|jS(N(RK(RRK((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRscS`s|S(N((RRK((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyRss*as_strided() strides argument is mandatorycS`s|S(N((RR((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyt get_stridessc`s(t|||||}|S(N(R (RRKR(RR(s5lib/python2.7/site-packages/numba/targets/arrayobj.pytas_strided_impls$(R>RRRR9(RRKRR((RRs5lib/python2.7/site-packages/numba/targets/arrayobj.pyt as_strideds(GRt __future__RRRR~R`RtllvmliteRtllvmlite.llvmpy.coretllvmpytcoreRRtnumpyRtnumbaRRRRR R R tnumba.numpy_supportR R RRRRR-Rtnumba.targets.imputilsRRRRRRRRRRRt numba.typingRtnumba.extendingRR R!tR"R#R$R1R3R\RbRgRjRtR|RR>RRRRRt ArrayIteratortBORROWEDRRRRRRwRRRRRtAnyRR}RRvRRRRRRRRR"R-RRPRVRZR[RbR}RRRRRRRRtVarArgRRRRRRRRRRRRRRRRKRtuniqueR R/R.R"R1RIR5R6t MemoryViewR7R8R9R:R;R=R@RCRFRIRNRKROtCPointertvoidptrRRRXR[RYR\R]RcRfRiRaRrtDTypeRt StringLiteralRRtRRRRRRtis_RRRRRRRRRRRRRRRR R R R+RRR RRRtNumpyNdIterTypeRRERR!R$R&R#R'R0R(R;R)t zeros_likeReR,R.R/R1R2R3R4R6R7R8R9R:R<R=R>RARCteyeRHRJRKRMRQttakeRTRXR,RZR[R-R\R]R^ReRfRgRkRnRoRRpR}tasfortranarrayR~tascontiguousarrayRRt frombufferRRRRRRRRRRRRRRRRt atleast_1dRt atleast_2dRt atleast_3dRRRRRRRt column_stackRRtstackRRRRtvstackRtdstackRRRRRRRRRRtargsortR R R t type_callableR Rtlibt stride_tricksR(((s5lib/python2.7/site-packages/numba/targets/arrayobj.pyts    4(L  ;   8   ;  '$*( !22:OEv *$ ) = %   x  !7*  # !A* ~  -!   !     : &! )! ' $    > > $ *!  7   ''''$* $ - $  $  $  $*$ '- $  $  % =!'&05   ) )'    $  ''' = 1 S $  '#      ' '