U
    ,dZ                 	   @   s  d Z ddlZddlZddlZddlmZ ddlmZ ddlZ	ddl
mZmZ ddlmZmZmZmZmZmZ ddlmZmZmZmZmZmZ ddlmZmZmZ dd	lmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z) dd
l*m+Z+ ddl,m-Z-m.Z.m/Z/m0Z0 ddl1m2Z2m3Z3 ddl4m5Z5 ddl6m7Z7m8Z8 ddl9m:Z: ddl,m;Z; ddl<m=Z>m?Z@ dd ZAdd ZBdd ZCdd ZDdd ZEdd ZFdd ZGd d! ZHd"d# ZIdd$d%ZJd&d' ZKed(ejLd)d* ZMd+d, ZNed-ejOe%e)jPd.d/ ZQdd0d1ZRd2d3 ZSd4d5 ZTeejUejLejVeejUejLejWd6d7 ZXeejUejLejYd8d9 ZZeej[ejLej\ej\d:d; Z]ee^ejLd<d= Z_ed>ej`d?d@ ZaedAej`ej\dBdC ZbG dDdE dEecZdG dFdG dGedZeG dHdI dIedZfG dJdK dKedZgG dLdM dMedZhG dNdO dOedZiG dPdQ dQecZjdRdS ZkeejUejLej`dTdU ZldVdW ZmdXdY ZndZd[ Zod\d] Zpd^d_ Zqd`da Zrdbdc Zsddde Zte0dfdg Zue-dhdi Zve.e	jwdjdk Zxe-dldm Zydndo Zzedpkre.e	j{ez e.e	j|dqdr Z}dsdt Z~dudv Zedwej`dxdy Zdzd{ Zedwej`ejYd|d} Zedwej`eej\d~d Ze.e	jdddZe ej`ddd Ze.e	jdddZe.e	jdddZdd Zdd Zedej`ejYdd Zedej`eej\dd Ze.e	jdd Ze.e	jdddZedej`dd Zee	jej`dd Zedej`dd Ze-dd Ze-dd Ze.e	jdddZe/ej`ddddZdd Ze.e	jdd Ze.e	jdd Ze.e	jdd Ze-dd Ze/ej`ddd Ze0dd Zdd Ze.edddd Zedej`ejdd Ze ej`dddÄ Ze ej`dăe ejdăddƄ Ze ej`dǃe ejdǃddɄ Ze ej`dʃe ejdʃdd̄ Ze ej`d̓ddτ Ze ej`dЃe ejdЃdd҄ Ze ejdӃddՄ Ze ejdփdd؄ Ze ejdكddۄ Ze ejd܃ddބ Ze ejd߃dd Ze ej`ddd Ze ejddd Ze#ejeje#ejejdd Zdd Ze ej`ddd Ze ejdփe ejdكdd Ze ejd܃dd Ze ej`ddd Ze ej`ddd Zdd Ze/ej`de/ej`ddd Zdd  Ze ejǐdeƃ e ejǐdeƃ e!ej`dd Zedej`ejɃdd Ze!ej˃dd	 Ze"ej˃d
d ZedejejɃdd Zedejejσdd Zedejejej\dd Zedejejej\dd Ze$ej`dd Ze$ej˃dd Ze$ejՃdd Zeejej`ej`dd Zؐdd Zِdd  Zڐdd!d"Zېdd#d$Zܐd%d& Zݐd'd( Zސd)d* Ze ej`d+d,d- Zed-eje%e)jPd.d/ ZeejUejejVd0d1 Zeej[ejejVej\d2d3 Zee^ejd4d5 Zee	jej`d6d7 Zed-eje%e)jPd8d9 ZeeeejVee	jeejVd:d; ZeeejYee	jejYd<d= Zed-eje%e)jPd>d? Zee	jej\d@dA Zed-eje%e)jPdBdC ZdDdE Ze;ej`dFdGdH ZdIdJ Ze0dKdL ZdMdN ZdOdP ZdQdR ZdSdT Ze0dUdV Ze.e	jefdWdXZe0dYdZ Ze.e	j dd[d\Ze0d]d^ Ze/ej`d_d`da Ze.e	jefdbdcZe.e	jddddeZe.e	jd dfdgZ	e:e	j
ej\ej\dhdi Ze:e	j
ej\ej\eje:e	j
ej\ej\ejɃdjdk Ze:e	jej\ej\dldm Ze:e	jej\ej\eje:e	jej\ej\ejɃdndo Ze.e	jd!dpdqZe:e	jejVdrds Ze:e	jejVeje:e	jejVejɃdtdu Zdvdw Ze.edxdy Ze.e	jddefdzd{Ze:e	jej`d|d} Ze:e	jej`ejVd~d Zedej`ejVe:e	jej`ejVdd Zedej`ej`e:e	jej`ej`dd Zedej`eje:e	jej`ejedej`ejYe:e	jej`ejYdd Z dd Z!e.e	j"d"ddZ#e:e	j$ej%ej%dd Z&e:e	j$ej%ej%ejVdd Z'dd Z(edej`dd Z)e:e	j*ej`dd Z+dd Z,e:e	j-ej`dd Z.e:e	j/ej`dd Z0e.e	j/dd Z1e.e	j-dd Z2edej`ejedej`ejɃdd Z3e:e	j4ejLe:e	j4ejLeje:e	j4ejLejɃdd Z5e:eej\ej\e:eej\ej\eje:eej\ej\e:eej\ej\ejdd Z6dd Z7dd Z8dd Z9dd Z:dd Z;e:e	j<ej\e:e	j<ej\eje:e	j<ej\ejɃdd Z=dd Z>dd Z?dd Z@dd ZAe:e	jAej`ejVdd ZBdd ZCdd ZDe:e	jEeej`dd ZFe:e	jGeej`dÐdĄ ZHe:e	jIeej`dŐdƄ ZJdǐdȄ ZKdɐdʄ ZLdːd̄ ZMe:e	jNejYd͐d΄ ZOe:e	jNejYejVdϐdЄ ZPe:e	jQejYdѐd҄ ZRdӐdԄ ZSe:e	jTejYdՐdք ZUe:e	jTejYejVdאd؄ ZVe:e	jWejYdِdڄ ZXe:e	jYejYdېd܄ ZZe:e	j[ejYdݐdބ Z\e/ej`dߡdd Z]e/ej`ddd Z^e.e	j_dd Z`e.e	jadd Zbe0dd Zce.e	jddd Zee.e	jfd#ddZge.e	jhd$ddZii Zjdd Zkd%ddZledej`dd Zme:e	jnej`dd Zoedej`ejɃee	jpej`ejɃdd Zqe#ej`ej`dd Zre#ej`ejse#ej`ejte#ej`ejVe#ej`ejue#ej`ejve#ej`ejwe#ej`ejxd d Zye#ej`ejsdd Zzdd Z{e|e{dd Z}ee{ej`ejYejYdd	 Z~e.e	jjjd&d
dZe.edd Ze.e	jdd Ze-dd Ze.e	jdd ZdS ('  z[
Implementation of operations on Array objects and objects supporting
the buffer protocol.
    N)ir)Constant)pndindexliteral_unroll)typesutilstypingerrorscgutils	extending)as_dtypecarrayfarrayis_contiguous
is_fortrancheck_is_integer)type_can_asarrayis_nonelikenumpy_version)lower_builtinlower_getattrlower_getattr_genericlower_setattr_generic
lower_castlower_constantiternext_implimpl_ret_borrowedimpl_ret_new_refimpl_ret_untrackedRefType)	signature)register_jitableoverloadoverload_method	intrinsic)	quicksort	mergesort)slicing)tuple_setitembuild_full_slice_tuple)glue_lowering)overload_classmethod)parse_dtypeparse_shapec                 C   s4   t |j|t |j|g}| j|}|d| dS )zz
    Set the "range" metadata on a load instruction.
    Note the interval is in the form [lower_bound, upper_bound).
    rangeN)r   typemoduleZadd_metadataZset_metadata)builderloadZlower_boundupper_boundZrange_operandsZmd r4   5/tmp/pip-unpacked-wheel-eu7e0c37/numba/np/arrayobj.pyset_range_metadata'   s
    

r6   c                 C   s&   d|j jd > d }t| |d| dS )zF
    Mark the result of a load instruction as positive (or zero).
       r   N)r/   widthr6   )r1   r2   r3   r4   r4   r5   mark_positive2   s    r9   c                    s6   j tjG  fddd  S )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                       s4   e Zd Z fddZefddZ  ZS )zmake_array.<locals>.ArrayStructc                    s   t }z| jd|}W n$ tk
r@   t | | Y S X | jj }| |}|d krttj	| j
|dd}n|}|| j
|f}||fS )NZ	__array__T)zfill)r    _contextget_functionNotImplementedErrorsuper
_make_refsdata_model_managerZ_get_be_typer
   alloca_once_builder)selfrefsigZ
array_impl	datamodelZbe_typeZ	outer_ref)ArrayStruct	__class__
array_typereal_array_typer4   r5   r?   H   s    


z*make_array.<locals>.ArrayStruct._make_refsc                    sp   | j }dkr | dS | d}g }tD ]2}t||d|}||}|| t|| q0t	||S )z\
            Override .shape to inform LLVM that its elements are all positive.
            r   shape)
rB   __getattr___get_ptr_by_namer.   r
   gep_inboundsr2   appendr9   
pack_array)rC   r1   ptrdimsiZdimptrr2   )basendimr4   r5   rK   \   s    


z%make_array.<locals>.ArrayStruct.shape)__name__
__module____qualname__r?   propertyrK   __classcell__r4   rG   rI   rT   rU   rJ   )rH   r5   rG   F   s   rG   )Zas_arrayr
   create_struct_proxyrU   )rI   r4   r[   r5   
make_array:   s
    
-r]   c                 C   s   |  |j}| |S )zB
    Return the item size for the given array or buffer type.
    )get_data_typedtypeget_abi_sizeof)contextrI   lltyr4   r4   r5   get_itemsizev   s    rc   c                 C   s"   |j r
dnd}| j||j||dS )z3
    Load the item at the given array pointer.
    Nr7   align)alignedunpack_valuer_   )ra   r1   arraytyrQ   re   r4   r4   r5   	load_item~   s    ri   c                 C   s$   |j r
dnd}| j||j|||dS )z4
    Store the item at the given array pointer.
    Nr7   rd   )rf   
pack_valuer_   )ra   r1   rh   valrQ   re   r4   r4   r5   
store_item   s    rl   c                 C   s>   |j r(| |||tj}t|||}n| |||tj}|S )zM
    Fix the integer index' type and value for the given dimension size.
    )signedcastr   intpr'   Z	fix_indexuintp)ra   r1   idxtyidxsizeindr4   r4   r5   fix_integer_index   s
    ru   c                 C   s^   t |tjrR|jdkrRt |jtjs(tt|| ||}t| |||j	}|j|fS ||fS dS )zS
    Normalize the index type and value.  0-d arrays are converted to scalars.
    r   N)

isinstancer   ArrayrU   r_   IntegerAssertionErrorr]   ri   data)ra   r1   rq   rr   idxaryZidxvalr4   r4   r5   normalize_index   s    
r|   c                    s2   t |r*t fddt||D  \}}||fS )z^
    Same as normalize_index(), but operating on sequences of
    index types and values.
    c                    s   g | ]\}}t  ||qS r4   )r|   ).0rq   rr   r1   ra   r4   r5   
<listcomp>   s   z%normalize_indices.<locals>.<listcomp>)lenzip)ra   r1   index_typesindicesr4   r~   r5   normalize_indices   s
    r   c                 C   s  | j }| j}| j}	ttjdd}
|j|
 }t|j}t|	j}||@ |kr|| }d| j	 dt
|dkrndnd d| d}t||d	krt||	d
d	}|tj}t|ttfrt|||}t|ttfrt|||}t|tr||}t|||||d}|d	kr2t||	dd	|d< n||d< |tjd}t|||jj}|D ]}|j||dgd}q^||d< t| }||krtd|| | D ]\}}t| || q| S )z
    Helper function for populating array structures.
    This avoids forgetting to set fields.

    *shape* and *strides* can be Python tuples or LLVM arrays.
    r7   CzThe datamodel for type z is missing fields  .Nmeminfo)rK   stridesrz   itemsizer   parentnswflagsnitemszmissing {0}) r;   rB   
_datamodelr   rw   float64r@   set_fieldsZ_fe_typer   
ValueErrorr   get_value_typeget_typero   rv   tuplelistr
   rP   intdictget_constantunpack_tupler/   countmulkeysformatitemssetattr)arrayrz   rK   r   r   r   r   ra   r1   rF   Zstandard_arrayZstandard_array_type_datamodelZrequired_fieldsZdatamodel_fieldsmissingmsgintp_tattrsr   unpacked_shapeaxlenZ
got_fieldskvr4   r4   r5   populate_array   s`    


*



r   c                 C   sh   |j }|j}|tjd}t||j| j}|D ]}|j	||dgd}q0||_
|tjt|| |_dS )z
    Update some auxiliary information in *array* after some of its fields
    were changed.  `itemsize` and `nitems` are updated.
    r7   r   r   N)r;   rB   r   r   ro   r
   r   rK   rU   r   r   rc   r   )arytyr   ra   r1   r   r   r   r4   r4   r5   update_array_info   s    r   Zgetiterc                 C   st   |j \}|\}| ||j}| tjd}t||}||_||_	| j
rX| j||| | }	t| ||j|	}
|
S Nr   )argsmake_helperreturn_typer   r   ro   r
   alloca_once_valueindexr   
enable_nrtnrtincref	_getvaluer   )ra   r1   rE   r   rh   r   iterobjzeroZindexptrresoutr4   r4   r5   getiter_array  s    r   c              	   C   s   t j||j|jd}t j||j|jd}||d |}t ||j|}	|dd }
|dd }t|t	j
rt| |||||	|
|}| S |
rtt| |||	S dS )z1 Evaluate `ary[idx]`, where idx is a single int. r   r   r7   N)r
   r   rK   rU   r   r   pointer_addrz   rv   r   Buffer	make_viewr   ry   ri   )ra   r1   r   r   aryrr   shapesr   offsetdataptrview_shapesview_stridesretaryr4   r4   r5   _getitem_array_single_int%  s      r   Ziternextc              	   C   s   |j \}|\}|j}| j|||d}t|| ||jd}	tj||	jdd\}
||j	}|
d||
}|| ||> t| ||j||	|}|| t||}|||j	 W 5 Q R X d S )Nvaluer7   r   <)r   rI   r   r]   r   r
   r   rK   r2   r   icmp_signed	set_validif_thenr   
yield_typeyield_increment_indexstore)ra   r1   rE   r   resultZitertyiterrh   r   r   r   r   is_validr   Znindexr4   r4   r5   iternext_array:  s*    
     
r   c              	   C   s  |  tjd}t||j|j}t||j|j}	g }
g }g }d}t||D ]B\}}|tj	kr|jt
| d }t|D ]2}|
| |||  ||	|  |d7 }qzqLt|tjr0| j|||d}t| ||| t||||  |
|j t||}t|||	| }|| || nXt|tjrzt| ||||| }|rnt| |||| | |
| ntd|f |d7 }qL||jkst||jk r|||  ||	|  |d7 }qtj| ||||
ddd}|||fS )z
    Perform basic indexing on the given array.
    A (data pointer, shapes, strides) tuple is returned describing
    the corresponding view.
    r   r7   r   unexpected index type: %sF
wraparoundboundscheck)r   r   ro   r
   r   rK   rU   r   r   ellipsisr   r.   rO   rv   	SliceTyper   r'   guard_invalid_slice	fix_slicestartget_slice_lengthZ
fix_striderx   ru   Zdo_boundscheckr=   ry   get_item_pointer)ra   r1   r   r   r   r   r   r   r   r   Zoutput_indicesZoutput_shapesZoutput_stridesaxindexvalrq   	n_missingrS   sliceshstrt   r   r4   r4   r5   basic_indexingV  sZ    





 r   c           	   	   C   s.   t || |}t|||||j|j|jd |S )zF
    Build a view over the given array with the given parameters.
    rz   rK   r   r   r   r   )r]   r   r   r   r   )	ra   r1   r   r   r   rz   r   r   r   r4   r4   r5   r     s    r   c              	   C   sb   t | |||||| jd\}}}	t|tjrHt| |||||||	}
|
 S |rPtt| |||S dS )zp
    Return the result of indexing *ary* with the given *indices*,
    returning either a scalar or a view.
    r   N)	r   enable_boundscheckrv   r   r   r   r   ry   ri   )ra   r1   r   r   r   r   r   r   r   r   r   r4   r4   r5   _getitem_array_generic  s      r   c           	      C   sZ   |j \}}|\}}|jdks tt|| ||}t| ||j|||f|f}t| ||j|S )z4
    Basic indexing with an integer or a slice.
    r7   )r   rU   ry   r]   r   r   r   	ra   r1   rE   r   r   rq   r   rr   r   r4   r4   r5   getitem_arraynd_intp  s    

   r   c              	   C   s   |j \}}|\}}t|| ||}|j}tj||t|d}	t| |||	\}}	tdd |D rvt| |||||||	S t	| ||j
||||	}
t| ||j
|
S )z2
    Basic or advanced indexing with a tuple.
    r   c                 s   s   | ]}t |tjV  qd S Nrv   r   rw   )r}   tyr4   r4   r5   	<genexpr>  s     z&getitem_array_tuple.<locals>.<genexpr>)r   r]   r   r
   r   r   r   anyfancy_getitemr   r   r   )ra   r1   rE   r   r   tuptyr   tupr   r   r   r4   r4   r5   getitem_array_tuple  s.    
 
   
   r   c              	   C   s   |j \}}}|\}}}	t|tjr>|j}
tj||t|d}n|f}
|f}t|| ||}t| ||
|\}
}z"t	| ||||
|| j
d\}}}W n tk
r   d}Y n
X t|}|rt| ||||
|S | ||	||j}	t| |||	| dS )zH
    array[a] = scalar_or_array
    array[a,..,b] = scalar_or_array
    r   r   TN)r   rv   r   	BaseTupler
   r   r   r]   r   r   r   r=   boolfancy_setslicern   r_   rl   )ra   r1   rE   r   r   rq   valtyr   rr   rk   r   r   r   r   r   Zuse_fancy_indexingr4   r4   r5   setitem_array  s6    
 

 r   c           	      C   sD   |j \}|\}t|}|| ||}|j}||d}t| ||j|S r   )r   r]   rK   extract_valuer   r   )	ra   r1   rE   r   r   r   ZarysttyZshapearyr   r4   r4   r5   	array_len  s    r  z
array.itemc              	   C   st   |j \}|\}t|| ||}|j}|j|d||ddd d}| j|t|f W 5 Q R X t	| |||j
S )N!=r7   FZlikelyz>item(): can only convert an array of size 1 to a Python scalar)r   r]   r   r   r   r/   	call_convreturn_user_excr   ri   rz   )ra   r1   rE   r   r   r   r   r   r4   r4   r5   
array_item  s    r  zarray.itemsetc           
   	   C   s   |j \}}|\}}||jks tt|| ||}|j}|j|d||ddd d}	| j	|t
|	f W 5 Q R X t| ||||j |  S )Nr  r7   Fr  z/itemset(): can only write to an array of size 1)r   r_   ry   r]   r   r   r   r/   r  r  r   rl   rz   get_dummy_value)
ra   r1   rE   r   r   r   r   rk   r   r   r4   r4   r5   array_itemset&  s    
r  c                   @   s@   e Zd ZdZdd Zdd Zdd Zdd	 Zd
d Zdd Z	dS )Indexerzq
    Generic indexer interface, for generating indices over a fancy indexed
    array on a single dimension.
    c                 C   s   t dS )ze
        Prepare the indexer by initializing any required variables, basic
        blocks...
        Nr=   rC   r4   r4   r5   prepareA  s    zIndexer.preparec                 C   s   t dS )z=
        Return this dimension's size as an integer.
        Nr
  r  r4   r4   r5   get_sizeH  s    zIndexer.get_sizec                 C   s   t dS )z;
        Return this dimension's shape as a tuple.
        Nr
  r  r4   r4   r5   	get_shapeN  s    zIndexer.get_shapec                 C   s   t dS )z}
        Return a half-open [lower, upper) range of indices this dimension
        is guaranteed not to step out of.
        Nr
  r  r4   r4   r5   get_index_boundsT  s    zIndexer.get_index_boundsc                 C   s   t dS )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.
        Nr
  r  r4   r4   r5   	loop_head[  s    	zIndexer.loop_headc                 C   s   t dS )z)
        Finish indexation loop.
        Nr
  r  r4   r4   r5   	loop_tailf  s    zIndexer.loop_tailN)
rV   rW   rX   __doc__r  r  r  r  r  r  r4   r4   r4   r5   r	  ;  s   r	  c                   @   sH   e Zd ZdZdd Zdd Zdd Zdd	 Zd
d Zdd Z	dd Z
dS )EntireIndexerz:
    Compute indices along an entire array dimension.
    c                 C   s2   || _ || _|| _|| _|| _| j tj| _d S r   )	ra   r1   r   r   dimr   r   ro   ll_intp)rC   ra   r1   r   r   r  r4   r4   r5   __init__r  s    zEntireIndexer.__init__c                 C   sB   | j }|| jj| j| _t|| j| _	|
 | _|
 | _d S r   )r1   r   r   rK   r  rs   r
   rA   r  r   append_basic_blockbb_startbb_endrC   r1   r4   r4   r5   r  z  s
    
zEntireIndexer.preparec                 C   s   | j S r   rs   r  r4   r4   r5   r    s    zEntireIndexer.get_sizec                 C   s   | j fS r   r  r  r4   r4   r5   r    s    zEntireIndexer.get_shapec                 C   s   |  d| jfS r   r  rs   r  r4   r4   r5   r    s    zEntireIndexer.get_index_boundsc              	   C   s|   | j }| j t| jd| j || j || j || j}|j	|
d|| jdd || j W 5 Q R X ||fS Nr   >=Fr  )r1   r   r   r  r   branchr  position_at_endr2   r   r   rs   r  )rC   r1   	cur_indexr4   r4   r5   r    s    zEntireIndexer.loop_headc                 C   sD   | j }t||| j}||| j || j || j	 d S r   )
r1   r
   r   r2   r   r   r  r  r   r  rC   r1   
next_indexr4   r4   r5   r    s
    zEntireIndexer.loop_tailNrV   rW   rX   r  r  r  r  r  r  r  r  r4   r4   r4   r5   r  m  s   r  c                   @   sH   e Zd ZdZdd Zdd Zdd Zdd	 Zd
d Zdd Z	dd Z
dS )IntegerIndexerz0
    Compute indices from a single integer.
    c                 C   s&   || _ || _|| _| j tj| _d S r   )ra   r1   rr   r   r   ro   r  )rC   ra   r1   rr   r4   r4   r5   r    s    zIntegerIndexer.__init__c                 C   s   d S r   r4   r  r4   r4   r5   r    s    zIntegerIndexer.preparec                 C   s   t | jdS Nr7   )r   r  r  r4   r4   r5   r    s    zIntegerIndexer.get_sizec                 C   s   dS Nr4   r4   r  r4   r4   r5   r    s    zIntegerIndexer.get_shapec                 C   s   | j | j| j |  fS r   )rr   r1   addr  r  r4   r4   r5   r    s    zIntegerIndexer.get_index_boundsc                 C   s
   | j d fS r   )rr   r  r4   r4   r5   r    s    zIntegerIndexer.loop_headc                 C   s   d S r   r4   r  r4   r4   r5   r    s    zIntegerIndexer.loop_tailNr$  r4   r4   r4   r5   r%    s   r%  c                   @   sH   e Zd ZdZdd Zdd Zdd Zdd	 Zd
d Zdd Z	dd Z
dS )IntegerArrayIndexerz;
    Compute indices from an array of integer indices.
    c                 C   s@   || _ || _|| _|| _|| _|jdks,t| j tj	| _
d S r&  )ra   r1   rq   r{   rs   rU   ry   r   r   ro   r  )rC   ra   r1   rq   r{   rs   r4   r4   r5   r    s    zIntegerArrayIndexer.__init__c                 C   sD   | j }t|| jjd | _t|| j| _|	 | _
|	 | _d S r   )r1   r
   r   r{   rK   idx_sizerA   r  	idx_indexr  r  r  r  r4   r4   r5   r    s
    
zIntegerArrayIndexer.preparec                 C   s   | j S r   r*  r  r4   r4   r5   r    s    zIntegerArrayIndexer.get_sizec                 C   s   | j fS r   r,  r  r4   r4   r5   r    s    zIntegerArrayIndexer.get_shapec                 C   s   |  d| jfS r   r  r  r4   r4   r5   r    s    z$IntegerArrayIndexer.get_index_boundsc              	   C   s   | j }| j t| jd| j || j || j || j}|j	|
d|| jdd || j W 5 Q R X t| j|| jj| j| j|}t| j|| jj|| j}||fS r  )r1   r   r   r  r+  r  r  r   r2   r   r   r*  r  r   ra   rq   r_   r{   ru   rs   )rC   r1   r!  r   r4   r4   r5   r    s0          zIntegerArrayIndexer.loop_headc                 C   sD   | j }t||| j}||| j || j || j	 d S r   )
r1   r
   r   r2   r+  r   r  r  r   r  r"  r4   r4   r5   r    s    
zIntegerArrayIndexer.loop_tailNr$  r4   r4   r4   r5   r)    s   	r)  c                   @   sH   e Zd ZdZdd Zdd Zdd Zdd	 Zd
d Zdd Z	dd Z
dS )BooleanArrayIndexerz>
    Compute indices from an array of boolean predicates.
    c                 C   sH   || _ || _|| _|| _|jdks&t| j tj| _	t
| j	d| _d S Nr7   r   )ra   r1   rq   r{   rU   ry   r   r   ro   r  r   r   )rC   ra   r1   rq   r{   r4   r4   r5   r     s    zBooleanArrayIndexer.__init__c                 C   s^   | j }t|| jjd | _t|| j| _t|| j| _	|
 | _|
 | _|
 | _d S r   )r1   r
   r   r{   rK   rs   rA   r  r+  r   r  r  bb_tailr  r  r4   r4   r5   r  	  s    

zBooleanArrayIndexer.preparec              	   C   s   | j }t|| j}t|| jP}||}t| j|| j	j
| j	| j|j}|||||j}||| W 5 Q R X ||S r   )r1   r
   r   r   	for_rangers   r2   r   ra   rq   r_   r{   r   r(  Zzextr/   r   )rC   r1   r   loopcpredr4   r4   r5   r    s    
    zBooleanArrayIndexer.get_sizec                 C   s
   |   fS r   r  r  r4   r4   r5   r  !  s    zBooleanArrayIndexer.get_shapec                 C   s   |  d| jfS r   r  r  r4   r4   r5   r  $  s    z$BooleanArrayIndexer.get_index_boundsc              	   C   s   | j }| j | j| j | j | j| j || j || j || j}|| j}|j	|
d|| jdd || j W 5 Q R X t| j|| jj| j| j|}|	|| || j W 5 Q R X t||}||| j ||fS )Nr  Fr  )r1   r   r   r+  r   r  r  r   r2   r   r   rs   r  r   ra   rq   r_   r{   not_r/  r
   r   )rC   r1   r!  	cur_countr3  
next_countr4   r4   r5   r  )  s0        zBooleanArrayIndexer.loop_headc                 C   s\   | j }|| j || j t||| j}||| j || j	 || j
 d S r   )r1   r  r/  r   r
   r   r2   r+  r   r  r  r"  r4   r4   r5   r  A  s    
zBooleanArrayIndexer.loop_tailNr$  r4   r4   r4   r5   r-    s   		r-  c                   @   sH   e Zd ZdZdd Zdd Zdd Zdd	 Zd
d Zdd Z	dd Z
dS )SliceIndexerz(
    Compute indices along a slice.
    c                 C   sL   || _ || _|| _|| _|| _|| _|| _| j tj	| _
t| j
d| _d S r   )ra   r1   r   r   r  rq   r   r   r   ro   r  r   r   )rC   ra   r1   r   r   r  rq   r   r4   r4   r5   r  Q  s    zSliceIndexer.__init__c                 C   s   | j }|| jj| j| _t| j|| j	| j
 t|| j
| j t|| j
j| _t|| j| _t|| j| _| | _| | _d S r   )r1   r   r   rK   r  dim_sizer'   r   ra   rq   r   r   r
   Z
is_neg_intstepis_step_negativerA   r  r   r   r  r  r  r  r4   r4   r5   r  \  s    
zSliceIndexer.preparec                 C   s   t | j| jS r   )r'   r   r1   r   r  r4   r4   r5   r  j  s    zSliceIndexer.get_sizec                 C   s
   |   fS r   r4  r  r4   r4   r5   r  m  s    zSliceIndexer.get_shapec                 C   s   t | j| j\}}||fS r   )r'   Zget_slice_boundsr1   r   )rC   lowerupperr4   r4   r5   r  p  s    zSliceIndexer.get_index_boundsc              	   C   s   | j }| j | jj| j | j | j| j || j |	| j |
| j}|
| j}|| j|d|| jj|d|| jj}|j|dd || j W 5 Q R X ||fS )Nz<=r  Fr  )r1   r   r   r   r   r   r   r  r  r   r2   selectr;  r   stopr   r  )rC   r1   r!  r6  Zis_finishedr4   r4   r5   r  t  s$    zSliceIndexer.loop_headc                 C   sp   | j }|j|| j| jjdgd}||| j t||| j	}||| j	 |
| j || j d S )Nr   r   )r1   r(  r2   r   r   r:  r   r
   r   r   r  r  r   r  )rC   r1   r#  r7  r4   r4   r5   r    s    zSliceIndexer.loop_tailNr$  r4   r4   r4   r5   r8  L  s   r8  c                   @   s@   e Zd ZdZdd Zdd Zdd Zdd	 Zd
d Zdd Z	dS )FancyIndexerz4
    Perform fancy indexing on the given array.
    c              	   C   s6  || _ || _|| _t||j|j| _t||j|j| _| j 	t
j| _g }d}t||D ]^\}	}
|
t
jkr|jt| d }t|D ]&}t|||||}|| |d7 }qq\t|
t
jr|||
|	}t||||||
|}|| nt|
t
jr*t|||
|	| j| }t|||}|| nt|
t
jrt|
|||	}t|
jt
jrpt|||
|| j| }n*t|
jt
jrt|||
|}n
dst || nt d|
f |d7 }q\||jkst ||jf||jk r
t|||||}|| |d7 }qt||jks,t t||jf|| _!d S )Nr   r7   r   )"ra   r1   r   r
   r   rK   rU   r   r   r   r   ro   r  r   r   r   r.   r  rO   rv   r   r   r8  rx   ru   r%  rw   r]   r_   r)  Booleanr-  ry   indexers)rC   ra   r1   r   r   r   r   rB  r   r   rq   r   rS   indexerr   rt   r{   r4   r4   r5   r    sj    


 
  


"zFancyIndexer.__init__c                 C   s0   | j D ]}|  qtdd | j D d| _d S )Nc                 S   s   g | ]}|  qS r4   )r  r}   rS   r4   r4   r5   r     s     z(FancyIndexer.prepare.<locals>.<listcomp>r4   )rB  r  sumindexers_shaperC   rS   r4   r4   r5   r    s    

zFancyIndexer.preparec                 C   s   | j S )z?
        Get the resulting data shape as Python tuple.
        )rF  r  r4   r4   r5   r    s    zFancyIndexer.get_shapec              	   C   s  t || jjkst| j}tj}| d}| d}|}|}t| j	| j
|D ]\}	}
}|||d|
|}|	 \}}|||}|||||}|d||}||||||}||||||}qL|||}||||}||||}||fS )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.
        r   r7   ==r   )r   r   rU   ry   r1   r
   	false_bitr  r   rB  rF  or_icmp_unsignedr  r   subr   r(  r>  )rC   r   r   r1   is_emptyr   oner<  r=  rC  rK   strideZlower_indexZupper_indexZlower_offsetZupper_offsetZis_downwardsr4   r4   r5   get_offset_bounds  sB    


zFancyIndexer.get_offset_boundsc                 C   s    t dd | jD  \}}||fS )Nc                 s   s   | ]}|  V  qd S r   )r  rD  r4   r4   r5   r     s     z+FancyIndexer.begin_loops.<locals>.<genexpr>)r   rB  )rC   r   countsr4   r4   r5   begin_loops  s    zFancyIndexer.begin_loopsc                 C   s   t | jD ]}|  q
d S r   )reversedrB  r  rG  r4   r4   r5   	end_loops  s    zFancyIndexer.end_loopsN)
rV   rW   rX   r  r  r  r  rP  rR  rT  r4   r4   r4   r5   r@    s   :&r@  c                 C   s  t ||j}t ||j}	|j}
t| |||||}|  |j}| }t	| |||}|j}t 
|| tjd}| \}}t j| ||
||	|j|d| jd	}t| |||}||}|||g}t| |||| t ||}||| |  t| ||| S )Nr   Fr   )r
   r   rK   r   rz   r@  r  r   r  _empty_nd_implr   r   r   ro   rR  get_item_pointer2layoutr   ri   r2   geprl   r   r   rT  r   r   )ra   r1   rE   r   r   r   r   r   r   r   rz   rC  Zout_tyZ
out_shapesr   Zout_dataZout_idx_rQ   rk   curZnext_idxr4   r4   r5   r     s<    
   
r   c           	   	   C   s   |j \}}|\}}t|| ||}|jdkrht| |||\}}t| ||j|||f|f}t| ||j|S t| ||||||f|fS dS )z3
    Advanced or basic indexing with an array.
    r   N)r   r]   rU   r|   r   r   r   r   r   r4   r4   r5   fancy_getitem_array6  s$    


   
   r[  c              	   C   s   |j }|d}|d}|jdkr8|}	|||j}
n|}	|}
t|jD ]Z}||| ||| |}|d||}|	||
|
||
}
|	||	|
|	|}	qJ|
|
|}
|d|j|}|	|||
}
|	|||	}	|	|
fS )z
    Compute a half-open range [lower, upper) of byte offsets from the
    array's data pointer, that bound the in-memory extent of the array.

    This mimics offset_bounds_from_strides() from
    numpy/core/src/private/mem_overlap.c
    r   r7   CFr  rH  )r   r/   rW  r   r   r.   rU   rL  r   r>  r(  )ra   r1   arrtyarrr   r   r   r   rN  r<  r=  rS   Zmax_axis_offsetZ
is_upwardsrM  r4   r4   r5   offset_bounds_from_stridesJ  s4    




  
r_  c                 C   s.   | ||j}|||}|||}||fS )z
    Given [lower, upper) byte offsets and a base data pointer,
    compute the memory pointer bounds as pointer-sized integers.
    )ptrtointr/   r(  )ra   r1   r<  r=  rz   Zdata_ptr_as_intr   endr4   r4   r5   compute_memory_extentst  s    rb  c           	      C   s&   t | |||||\}}t| ||||S )zr
    Compute a half-open range [start, end) of pointer-sized integers
    which fully contain the array data.
    )r_  rb  )	ra   r1   r]  r^  r   r   rz   r<  r=  r4   r4   r5   get_array_memory_extents  s
    
 rc  c                 C   s$   | |d|||d||}|S )z[
    Whether two memory extents [a_start, a_end) and [b_start, b_end)
    may overlap.
    r   )and_rK  )ra   r1   Za_startZa_endZb_startZb_endZmay_overlapr4   r4   r5   extents_may_overlap  s
    re  c                    s  j dt d  jdd  |j|j}j |}	|	j  	|	}	 
|	 tj}
t |
F}t 	
j|}t |	|} 
 || W 5 Q R X W 5 Q R X  	
fdd} fdd}||fS )Nr   Fr  c                    s   t | 
jkstt } jddv\}}|.  tj  | dd| W 5 Q R X |*  tj 	
j	| dd| W 5 Q R X W 5 Q R X t
 
 |S )NFr  r   )r   rU   ry   r
   rA   if_elser   rV  r2   rW  ri   )source_indicessrc_ptrZif_copyZ	otherwise)r1   ra   	copy_datacopy_layoutcopy_shapescopy_stridesptrtysrc_data
src_shapessrc_stridessrctyuse_copyr4   r5   src_getitem  s6      
  z&maybe_copy_source.<locals>.src_getitemc               	      sB    j dd*  }  | } j |  W 5 Q R X d S )NFr  )r   r2   bitcastr   freerz   )r1   ra   rj  rs  	voidptrtyr4   r5   src_cleanup  s    
z&maybe_copy_source.<locals>.src_cleanup)r/   r
   r   r   r   r   r   r   allocateru  r   r   r   ro   	loop_nestrV  rW  r2   )ra   r1   rs  rr  srcrp  rq  ro  	allocsizerz   r   r   ri  dest_ptrrt  ry  r4   )r1   ra   rj  rk  rl  rm  rn  ro  rp  rq  rr  rs  rx  r5   maybe_copy_source  s:    
  
  &"r  c           
   	      s   |  tjd}|  tjdt|t|krZt|t| }g| | }|g| | }nt|t|k rt|t| } fdd|d| D }t j|tj} j	 
|dd d}	| j t|	f W 5 Q R X ||d }||d }||fS )	ae  
    Preprocess dimension for broadcasting.
    Returns (shapes, strides) such that the ndim match *target_shape*.
    When expanding to higher ndim, the returning shapes and strides are
    prepended with ones and zeros, respectively.
    When truncating to lower ndim, the shapes are checked (in runtime).
    All extra dimension must have size of 1.
    r   r7   c                    s   g | ]}  d |qS rH  )rK  r}   r   r1   rN  r4   r5   r     s   z(_bc_adjust_dimension.<locals>.<listcomp>NFr  z,cannot broadcast source array for assignment)r   r   rp   r   	functoolsreducerd  r
   true_bitr   r5  r  r  r   )
ra   r1   r   r   target_shaper   Znd_diffZ
dim_is_oneacceptedr   r4   r  r5   _bc_adjust_dimension  s(    	

r  c           
         s   g }g }|  tjd|  tjd fddt||D } fdd|D } fddt||D }	 fddt|	||D } fddt|	|D }||fS )	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.
    r   r7   c                    s   g | ]\}}  d ||qS )r  r   )r}   taroldr1   r4   r5   r     s   z,_bc_adjust_shape_strides.<locals>.<listcomp>c                    s   g | ]}  d |qS r  r  )r}   r  r  r4   r5   r     s     c                    s   g | ]\}}  ||qS r4   )rd  )r}   xyr  r4   r5   r   	  s     c                    s    g | ]\}}}  |||qS r4   r>  )r}   pr  r  r  r4   r5   r   
  s   c                    s   g | ]\}}  ||qS r4   r  )r}   r  r  )r1   r   r4   r5   r     s   )r   r   rp   r   )
ra   r1   r   r   r  Z	bc_shapesZ
bc_stridesmismatchZ
src_is_onepredsr4   )r1   rN  r   r5   _bc_adjust_shape_strides  s     


r  c           
      C   s   t ||j}t ||j}t| ||||\}}t| ||||\}}|jt|dd}t|| |}t	t 
||t 
||d}	t |||	 ||fS )zX
    Broadcast the given array to the target_shape.
    Returns (array_type, array)
    ArU   rW  )rK   r   )r
   r   rK   r   r  r  copyr   r]   r   rP   copy_struct)
ra   r1   arrtyper^  r  r   r   Znew_arrtypeZnew_arrreplr4   r4   r5   _broadcast_to_shape  s     
 
r  c                 C   s,   |j |jddd}|||}dd }||fS )Nr  T)rU   rW  readonlyc           
   	   S   sz   |\}}|j d }t|| ||}t||}t| ||||\}}t|dt| |j	dd  |
 }	t| ||j|	S )Nr   r   )r   r]   r
   r   r  r   r   r   r   r   r   r   r   )
ra   r1   rE   r   r|  Zshape_rr  rY  destr   r4   r4   r5   codegen,  s    
z$_numpy_broadcast_to.<locals>.codegen)r  r   )	typingctxr   rK   retrE   r  r4   r4   r5   _numpy_broadcast_to'  s    
r  c           
      C   s   | j }t|}t|}||kr&td|D ]}|dk r*tdq*d}|| }||k r|| }|| }	||	kst|dkr|d7 }|d7 }qLtdqLd S )NzDinput operand has more dimensions than allowed by the axis remappingr   z4all elements of broadcast shape must be non-negativer7   z=operands could not be broadcast together with remapped shapes)rK   r   r   )
r   Z
dest_shapeZ	src_shapeZsrc_ndimZ	dest_ndimrs   Z	src_indexZ
dest_indexZsrc_dimZdest_dimr4   r4   r5   _can_broadcast>  s"    

r  c                 C   sl   t | stdt|tjr@t|jtjs6tddd }n(t|tjrVdd }nd| }t||S )Nz-The first argument "array" must be array-likez7The second argument "shape" must be a tuple of integersc                 S   s   t | } t| | t| |S r   )npasarrayr  r  r   rK   r4   r4   r5   impli  s    

z numpy_broadcast_to.<locals>.implc                 S   s   t | |fS r   )r  broadcast_tor  r4   r4   r5   r  n  s    z:The argument "shape" must be a tuple or an integer. Got %s)r   r	   TypingErrorrv   r   UniTupler_   rx   )r   rK   r  r   r4   r4   r5   numpy_broadcast_to^  s    




r  c                 C   sr   t t|D ]`}|t| | }|| }|dk r8td|dkrBq| | dkrX|| |< q| | |krtdqd S )Nr   #negative dimensions are not allowedr7   z=shape mismatch: objects cannot be broadcast to a single shape)r.   r   r   )rmrK   rS   r   tmpr4   r4   r5   numpy_broadcast_shapes_listw  s    
r  c                     s   t | D ]n\}}t|tj}t|tjo4t|jtj}t|tjoNt|jdk}|s|s|sd| d| }t	|qd | D ]6}t|tjrt
 d qt|tjrt
 t| q dkrdd S d   fdd	}|S d S )
Nr   z	Argument z* must be either an int or tuple[int]. Got r7   c                  W   s   dS r'  r4   r   r4   r4   r5   <lambda>      z+ol_numpy_broadcast_shapes.<locals>.<lambda>r7   c                     sz   dg  }}t | D ]@}t|tr>t|dkr>t| | qt|trt| |f qt|D ]\}}t|||}q`|S r.  )r   rv   r   r   r  r   	enumerater(   )r   r  r   argrr   elemr  Ztup_initr4   r5   r    s    

z'ol_numpy_broadcast_shapes.<locals>.impl)r  rv   r   rx   r  r_   Tupler   r	   r  maxr   )r   rr   r  Zis_intZis_int_tupleZis_empty_tupler   r  r4   r  r5   ol_numpy_broadcast_shapes  s(    r  )r7      c                     s   t | D ]"\}}t|std| dqd }d }| D ]H}t|tjtjfrV|j}n|}|d krh|}q8||kr8td|  q8d t | D ]T\}}t|tj	rt
 |j qt|tjtjtjfrt
 d qtd| qd   fdd	}|S )
Nz
Argument "z" must be array-likezTMismatch of argument types. Numba cannot broadcast arrays with different types. Got r   r7   zUnhandled type )r   c                     s|   dg  }t | D ]}t| t|j q}t D ]}t|||| }q8g }t | D ]}|tt|| qZ|S r&  )	r   r  r  r  rK   r.   r(   rO   r  )r   rK   r   r   rS   Zoutsr  r4   r5   r    s    
z$numpy_broadcast_arrays.<locals>.impl)r  r   r	   r  rv   r   rw   r   r_   ZArrayCompatibler  rU   NumberrA  )r   rr   r  Zunified_dtypedtr  r4   r  r5   numpy_broadcast_arrays  s.    r  c           %   
      s  |j \}}|\}}t| |}t |j}	t |j}
|j}t ||||}|  t	t
jrj| }t t |\t j}t j}j}tj}t|t|kstt||D ]\}} | d||}q j|dd d}j t|f W 5 Q R X t |||\}}||
|j\}}t |||\}}t ||||}t ||||\}}nt	t
jrRj| }t|dkst tt!t
j"}| f} d|d |} j|dd d}j t|f W 5 Q R X  fdd}d	d
 }nfdd}dd
 }|# \} }!t$dd |!D }"||"}#% |#|j}#tj& ||	|
|j'| dd}$t( ||#|$ |)  |  * S )z
    Implement slice assignment for arrays.  This implementation works for
    basic as well as fancy indexing, since there's no functional difference
    between the two for indexed assignment.
    r  Fr  z0cannot assign slice from input of different sizer7   r   c                    s,   | \} tjttj}| |fS r   )r<   operatorgetitemr    r   ro   )rh  rr   getitem_implr1   ra   r|  Z	src_dtyperr  r4   r5   rt  9  s    z#fancy_setslice.<locals>.src_getitemc                   S   s   d S r   r4   r4   r4   r4   r5   ry  A  s    z#fancy_setslice.<locals>.src_cleanupc                    s    S r   r4   )rh  )r|  r4   r5   rt  I  s    c                   S   s   d S r   r4   r4   r4   r4   r5   ry  L  s    c                 s   s   | ]}|d k	r|V  qd S r   r4   )r}   r2  r4   r4   r5   r   S  s      z!fancy_setslice.<locals>.<genexpr>rf  )+r   r]   r
   r   rK   r   rz   r@  r  rv   r   r   r_   r  r  rI  r   ry   r   rJ  r   r   r  r  r   rc  rP  r   rb  re  r  Sequencer<   r    ro   rR  r   rn   rV  rW  rl   rT  r  )%ra   r1   rE   r   r   r   r   rY  r   Zdest_shapesdest_strides	dest_datarC  Zindex_shaperp  rq  ro  Zshape_errorur   r   Z	src_startZsrc_endZ
dest_lowerZ
dest_upperZ
dest_startZdest_endrs  rt  ry  len_implZseq_lenZdest_indicesrQ  rh  rk   r~  r4   r  r5   r     s    

 
   
    


  r   c                    s   |j d }|j dd  }|d }|dd  } fddt||D }t ||d j}tjtjt|d}	t	
|j||	}
||f}|
|fS )Nr   r7   c                    s"   g | ]\}}  ||tjqS r4   rn   r   ro   )r}   r   rk   r~   r4   r5   r   r  s   z#vararg_to_tuple.<locals>.<listcomp>r_   r   )r   r   r
   rP   r/   r   r  ro   r   r   r    r   )ra   r1   rE   r   r   Zdimtysr   rR   rK   shapetynew_signew_argsr4   r~   r5   vararg_to_tuplek  s    
r  zarray.transposec                 C   s   t | ||jd |d S r   )array_Tr   ra   r1   rE   r   r4   r4   r5   array_transpose~  s    r  c                 C   sn   t | t t| krtdt |}| D ] }||ks@t||kr(tdq(||  |d d < ||  |d d < d S )Nzrepeated axis in transposez2axis is out of bounds for array of given dimension)r   r   r   abs)axisrK   r   r  r  r4   r4   r5   permute_arrays  s    
r  c              
      s  |j d }t| |d }|j d |d  }}|j|j }}	tj}
t|
|||j	|j
g} fdd|D }t||D ]\}} || qtj|	dddtj|
} fdd|D }t||D ]6\}}t| ||
 tj|g|g|d d qވ tttjd	d |D  t|j }t||j |d  |d
 |j|j|jd | }t |j|S )Nr   r7   c                    s   g | ]}t  qS r4   r
   rA   r}   rY  )r1   ll_ary_sizer4   r5   r     s     z)array_transpose_tuple.<locals>.<listcomp>r   r_   rU   rW  c                    s   g | ]}t  qS r4   r]   r  )r1   ra   	np_ary_tyr4   r5   r     s     rz   rK   r   r   r   c                 S   s   g | ]}|  qS r4   r   r}   ar4   r4   r5   r     s        r   ) r   r]   r   r_   r   r   ro   r   	ArrayTyperK   r   r   r   rw   r   r`   r   ru  
as_pointercompile_internalr  r   r    voidr   rz   r2   r   r   r   r   r   )ra   r1   rE   r   r   r   Zaxistyr  Znum_axisr_   r  ZarysZll_arysr|  dstZnp_itemsizeZnp_arysZnp_aryZll_aryr  r   r4   )r1   ra   r  r  r5   array_transpose_tuple  sT    
	  r  c                 C   s    t | |||\}}t| |||S r   )r  r  ra   r1   rE   r   r  r  r4   r4   r5   array_transpose_vararg  s    r  c                 C   s8   t | tjrtd|d kr*ddd}n
ddd}|S )Nz#np.transpose does not accept tuplesc                 S   s   |   S r   	transposer  axesr4   r4   r5   np_transpose_impl  s    z*numpy_transpose.<locals>.np_transpose_implc                 S   s
   |  |S r   r  r  r4   r4   r5   r    s    )N)N)rv   r   r   r	   ZUnsupportedError)r  r  r  r4   r4   r5   numpy_transpose  s    

r  Tc           	      C   s   |j dkr|}nt|| ||}t|| |}t||j|j }t||j|j }t||jt||d d d t||d d d |j	|j
|jd | }t| |||S )Nr7   r   )rU   r]   r
   r   rK   r   r   rz   rP   r   r   r   r   r   )	ra   r1   typr   r   r   r  r   r   r4   r4   r5   r    s     
r  2   c                 C   sT   t | tjstdt |tjs,tdt |ttjfsFtdddd}|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 integerr  c                 S   s   t | ||}t d|S )Ng      $@)r  linspacepower)r   r?  numr  r4   r4   r5   r    s    znumpy_logspace.<locals>.impl)r  )rv   r   r  r	   r  r   rx   )r   r?  r  r  r4   r4   r5   numpy_logspace  s    



r  r7   c                 C   sR   t |ttjfstdt | tjs0td| jdk rDtdddd}|S )	Nz*The second argument "k" must be an integer)The first argument "arr" must be an arrayr  Input must be >= 2-d.r7   c                 S   st   |d }|dkr| d d  S |dkr8t t | ddS |dkrPt t | S |dkrlt t | ddS td S )N   r   r7   r     )r  swapaxesfliplrflipudry   )r^  r   r4   r4   r5   r    s    znumpy_rot90.<locals>.impl)r7   )	rv   r   r   rx   r	   r  rw   rU   NumbaValueError)r^  r   r  r4   r4   r5   numpy_rot90  s    




r  c                 C   s   |  tj}| }|  tj}	t|	||||||||	g}
t|j	|
d}||j
}t||ddd}t||ddd}||}t||dd}t||dd}|	d}|||||||||j|g}|S )a  
    Call into Numba_attempt_nocopy_reshape() for the given array type
    and instance, and the specified new shape.

    Return value is non-zero if successful, and the array pointed to
    by *newstrides* will be filled up with the computed results.
    Znumba_attempt_nocopy_reshaperK   r   r   )r   r   ro   r  Zintcr   FunctionTyper
   Zget_or_insert_functionr0   rU   rN   rM   callr   )ra   r1   r   r   newndnewshape
newstridesr  Zll_intp_starZll_intcfntyfnndrK   r   Z
is_f_orderr   r4   r4   r5   _attempt_nocopy_reshape  sD    	     

    r  c           	      C   s   d}d}t |D ]&\}}|dk r.|d7 }|}q||9 }q|dkrR| |krtdnP|dkr|dkrpd}| dk}n| | }| | dk}|std|||< ntdd S )Nr   r7   z)total size of new array must be unchangedzmultiple negative shape values)r  r   )	origsizerK   Znum_neg_valueZ
known_sizer   r   Zneg_axinferredokr4   r4   r5   normalize_reshape_valueA  s(    



r	  zarray.reshapec              	   C   s  |j d }|j}|j d }|d }| tj}t||j}	t|| ||d }
t	
||	}||| tj|jddd}t|| |}| tj| |}t|||| | tj|jg|g|d d |
j}| |tttjtj||| g |j}t	
||	}t| |||
|||}|d||d}|| d}| j |t!|f W 5 Q R X t|| |}t||
j"|#||#||
j$|
j%|
j&d | }t'| ||j|S )	Nr   r7   r   r  r  rH  zincompatible shape for arrayr   )(r   r   r   r   ro   r   r  r   r]   r
   rA   r   rw   r_   r   r`   r   ru  r  r   r  r	  r   r    r  rp   r   r  rK  r/   r   r  r  r=   rz   r2   r   r   r   r   )ra   r1   rE   r   r   rettyr  rK   r  Zll_shaper   r   Zshape_ary_ty	shape_aryZshape_itemsizers   r  r  r  failr   r  r   r4   r4   r5   array_reshape_  sd    

 
 r  c                 C   s    t | |||\}}t| |||S r   )r  r  r  r4   r4   r5   array_reshape_vararg  s    r  c                 C   s   dd }|S )Nc                 S   s
   |  |S r   )reshape)r  rK   r4   r4   r5   np_reshape_impl  s    z#np_reshape.<locals>.np_reshape_implr4   )r  rK   r  r4   r4   r5   
np_reshape  s    r  c                 C   s\   t | stdt |s$tdt|r8ddd}n t|tjsNtdddd}|S )	Nz+The first argument "arr" must be array-likez/The second argument "values" must be array-likec                 S   s.   t t | } t t |}t | |fS r   )r  ravelr  concatenater^  valuesr  r4   r4   r5   r    s    znp_append.<locals>.implz,The third argument "axis" must be an integerc                 S   s   t j| |f|dS Nr  r  r  r  r4   r4   r5   r    s    )N)N)r   r	   r  r   rv   r   rx   )r^  r  r  r  r4   r4   r5   	np_append  s    



r  zarray.ravelc                 C   sN   dd }dd }|j d jdkr&|}n|}| ||||}t| ||j|}|S )Nc                 S   s   |  | jS )zNo copy version)r  rs   r   r4   r4   r5   
imp_nocopy  s    zarray_ravel.<locals>.imp_nocopyc                 S   s   |   S )zCopy version)flattenr  r4   r4   r5   imp_copy  s    zarray_ravel.<locals>.imp_copyr   r   r   rW  r  r   r   )ra   r1   rE   r   r  r  impr   r4   r4   r5   array_ravel  s    r   c                 C   s   dd }|  ||||S )Nc                 S   s   |   S r   )r  r  r4   r4   r5   np_ravel_impl  s    znp_ravel.<locals>.np_ravel_implr  )ra   r1   rE   r   r"  r4   r4   r5   np_ravel  s    r$  zarray.flattenc                 C   s,   dd }|  ||||}t| ||j|}|S )Nc                 S   s   |   | jS r   )r  r  rs   r  r4   r4   r5   r    s    zarray_flatten.<locals>.impr  r   r   )ra   r1   rE   r   r  r   r4   r4   r5   array_flatten  s    r&  c                 C   sl   |d krt | n|}t | ||\}}}t |jD ]0}|| }	|| }
|| }tt|	|
|||< q6|S r   )r  
empty_likebroadcast_arraysndindexrK   minr  )r  a_mina_maxr   r  a_ba_min_ba_max_br   val_aZ	val_a_minZ	val_a_maxr4   r4   r5   _np_clip_impl  s    r1  c                 C   sH   t | jD ]6}| | }|| }|r4t||||< qt||||< q|S r   )r  r)  rK   r*  r  )r  bZuse_minr   r   r0  Zval_br4   r4   r5   _np_clip_impl_none  s    r3  c                 C   sv  t | stdt|tjs0t |s0tdt|tjsNt |sNtdt|tjspt|spd}t||d kpt|tj}|d kpt|tj}|r|rddd}|S t|tj}t|tj}	|r|	rddd}
|
S |r|	s| rdd	d
}|S ddd}|S nf|s<|	r<|r,ddd}|S ddd}|S n6|rPddd}|S |rdddd}|S ddd}|S d S ) Nz#The argument "a" must be array-likez6The 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 providedc                 S   s   t dd S )Nz&array_clip: must set either max or min)r   r  r+  r,  r   r4   r4   r5   
np_clip_nn$  s    znp_clip.<locals>.np_clip_nnc                 S   sH   |d krt | n|}t | jD ] }| | }tt|||||< q"|S r   )r  r'  r)  rK   r*  r  r  r+  r,  r   r  r   r0  r4   r4   r5   
np_clip_ss-  s
    znp_clip.<locals>.np_clip_ssc                 S   sB   |d krt | n|}t | jD ]}| | }t||||< q"|S r   )r  r'  r)  rK   r  r6  r4   r4   r5   
np_clip_sn;  s
    znp_clip.<locals>.np_clip_snc                 S   s   t | |}t| |||S r   r  	full_liker1  )r  r+  r,  r   Z
a_min_fullr4   r4   r5   
np_clip_saH  s    znp_clip.<locals>.np_clip_sac                 S   sB   |d krt | n|}t | jD ]}| | }t||||< q"|S r   )r  r'  r)  rK   r*  r6  r4   r4   r5   
np_clip_nsS  s
    znp_clip.<locals>.np_clip_nsc                 S   s   t | |}t| |||S r   r9  )r  r+  r,  r   Z
a_max_fullr4   r4   r5   
np_clip_as`  s    znp_clip.<locals>.np_clip_asc                 S   s4   |d krt | n|}t | |\}}t||d|S )NTr  r'  r(  r3  )r  r+  r,  r   r  r-  r/  r4   r4   r5   
np_clip_nal  s    znp_clip.<locals>.np_clip_nac                 S   s4   |d krt | n|}t | |\}}t||d|S )NFr>  )r  r+  r,  r   r  r-  r.  r4   r4   r5   
np_clip_ant  s    znp_clip.<locals>.np_clip_anc                 S   s   t | |||S r   )r1  r4  r4   r4   r5   
np_clip_aa|  s    znp_clip.<locals>.np_clip_aa)N)N)N)N)N)N)N)N)N)	r   r	   r  rv   r   NoneTyperw   r   r  )r  r+  r,  r   r   Za_min_is_noneZa_max_is_noner5  Za_min_is_scalarZa_max_is_scalarr7  r8  r;  r<  r=  r?  r@  rA  r4   r4   r5   np_clip  sV    












rC  clipc                 C   s   ddd}|S )Nc                 S   s   t | |||S r   )r  rD  r4  r4   r4   r5   r    s    zarray_clip.<locals>.impl)NNNr4   )r  r+  r,  r   r  r4   r4   r5   
array_clip  s    
rE  c              	      s  |j |j kst|j|jks tt|j}td tdtdtj fdd}| tjt| |}| tjt| |}| tj|j }	t	
||ddd}
t	
||ddd}tjtjd	dd
}| |}t	|| tj|j g}| | tj}| tj|}t	||g}|| |}t||
|||dd || |}t|||||dd | }| }|	||||| tj|g}ttjtj||tjtjt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  r   Fc           	         s   | kr2|d |kr}n|d |kr2}||krN| ksJ| dkrNdS |kr`| d }nd}||k r|| dkr|dS || }||  |9  < |||< n:||kr|| | }|| dkrdS || ||< |||< n dS )Nr  r   Fr7   Tr4   )	r  rR   r   old_itemsizenew_itemsizerW  rS   newdimZ
bytelengthZ
any_layoutZc_layoutZf_layoutint8r4   r5   r    s.    



z_change_dtype.<locals>.imprK   r   r   r7   r  Nr  )rU   ry   rW  ordr   rK  r   ro   rc   r
   rN   rM   rw   r]   rP   r`   r^   r   r   r    booleanr  r   r   r   )ra   r1   Zoldtynewtyr   Z
new_layoutr  rG  rH  r  Z
shape_dataZstrides_dataZshape_strides_array_typearyclsZshape_constantZsizeof_intpZstrides_constantr  Zstrides_aryrK   r   r   rE   r   r4   rJ  r5   _change_dtype  s    	
0   



	
rP  c                 C   s   t | stddd }|S )Nz+The argument to np.shape must be array-likec                 S   s   t | jS r   )r  r  rK   r!  r4   r4   r5   r  	  s    znp_shape.<locals>.implr   r	   r  r  r  r4   r4   r5   np_shape
	  s    
rS  c                 C   s   dd }|S )Nc                    sJ   t |   t d d } fddt dd  D }t || S )Nr7   c                    s    g | ]\}} | |kr|qS r4   r4   )r}   rS   r  r2  r4   r5   r   	  s      z5np_unique.<locals>.np_unique_impl.<locals>.<listcomp>)r  sortr  r   r  r   )r  headtailr4   rT  r5   np_unique_impl	  s    z!np_unique.<locals>.np_unique_implr4   )r  rX  r4   r4   r5   	np_unique	  s    rY  c                 C   sh   dd }t | tjtjtjtjtjfrdt |tjr6tS t |tjtjfrZt |j	tjrZ|S t
dd S )Nc           	      S   s   t j|t jd}|jd dkr,t| |d S t |dk rBtdt | }| }|jd }|j|jkrrtdt jt 	||j
d}d}t|D ](}|| |||||  < ||| 7 }q|S )Nr_   r   r7   r  z(operands could not be broadcast together)r  r  Zint64rK   np_repeat_impl_repeats_scalerr   r   r  emptyrE  r_   r.   )	r  repeatsZrepeats_arrayasaaraveln	to_returnposrS   r4   r4   r5   !np_repeat_impl_repeats_array_like%	  s$    

z4np_repeat.<locals>.np_repeat_impl_repeats_array_likezIThe repeats argument must be an integer or an array-like of integer dtype)rv   r   rw   Listr   r  rA  rx   r[  r_   r	   r  )r  r]  rc  r4   r4   r5   	np_repeat 	  s    re  c                 C   s   |dk rt dt| }| }|jd }|dkrDtjd|jdS |dkrVt|S tj|| |jd}t|D ] }|| ||| |d | < qr|S d S )Nr   r  rZ  r7   )	r   r  r  r  rK   r\  r_   r  r.   )r  r]  r^  r_  r`  ra  rS   r4   r4   r5   r[  M	  s    


r[  repeatc                 C   s   dd }|S )Nc                 S   s   t | |S r   )r  rf  )r  r]  r4   r4   r5   array_repeat_impla	  s    z'array_repeat.<locals>.array_repeat_implr4   )r  r]  rg  r4   r4   r5   array_repeat_	  s    rh  c                 C   s   t |}dd }||fS )z"Computes the itemsize of the dtypec                 S   s,   |  |jd j}|  |j}|| |S r   )r^   r   r_   r   r`   )cgctxr1   rE   llargsrb   Zllintpr4   r4   r5   r  l	  s    z%_intrin_get_itemsize.<locals>.codegen)r   ro   )tyctxr_   rE   r  r4   r4   r5   _intrin_get_itemsizeg	  s    
rl  c                 C   s   d S r   r4   )r  r_   r4   r4   r5   _compatible_views	  s    rm  Zgeneric)targetc                 C   s   dd }|S )zDDetermines if the array and dtype are compatible for forming a view.c                 S   s   t |}|| jkr| jdkr*d}t|n | jd }| j| dk}| jdk}| j| | jk}|rt|rt|rtd}t||| jk r|dks| j| dkrd}	t|	n(| j| | j }
|
| dkrd}t|d S )Nr   zOChanging the dtype of a 0d array is only supported if the itemsize is unchangedr7   zJTo 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.)rl  r   rU   r   rK   rs   r   )r  r_   Z
dtype_sizeZmsg1r  p1p2Zp3Zmsg2Zmsg3rI  Zmsg4r4   r4   r5   r  }	  s(    






z ol_compatible_view.<locals>.implr4   r  r_   r  r4   r4   r5   ol_compatible_vieww	  s    #rr  z
array.viewc              	   C   s,  |j d }|j}t|| ||d }t|| |}t|jj}t|D ]:}	t||	}
|	dkrt|jj	}|
|
||_qFt||	|
 qFtdkr| j}|t}|||j i }| ||}||| t| ||||}|d|t|j	d}|| d}| j|t|f W 5 Q R X | }t| ||j|S )Nr   rz   )r7      rH  z"new type not compatible with array)r   r   r]   r   r   r   sortedgetattrrz   r/   ru  r   r   Ztyping_contextZresolve_value_typerm  Zget_call_typer<   rP  rK  r   r   r  r  r   r   r   )ra   r1   rE   r   r   r
  r   r  fieldsr   rk   rn  rk  r  Z_compatible_view_sigr  r  r  r   r   r4   r4   r5   
array_view	  s0    



rw  r_   c                 C   s   |   }t| |||S r   )r  r   ra   r1   r  r   r   r4   r4   r5   array_dtype	  s    ry  rK   c                 C   s(   t |}|| ||}|j}t| |||S r   )r]   rK   r   ra   r1   r  r   rh   r   r   r4   r4   r5   array_shape	  s    r{  r   c                 C   s(   t |}|| ||}|j}t| |||S r   )r]   r   r   rz  r4   r4   r5   array_strides	  s    r|  rU   c                 C   s   |  tj|j}t| |||S r   )r   r   ro   rU   r   rx  r4   r4   r5   
array_ndim	  s    r}  rs   c                 C   s(   t |}|| ||}|j}t| |||S r   )r]   r   r   rz  r4   r4   r5   
array_size	  s    r~  r   c                 C   s(   t |}|| ||}|j}t| |||S r   )r]   r   r   rz  r4   r4   r5   array_itemsize	  s    r  nbytesc                 C   s2   t |}|| ||}||j|j}t| |||S )z"
    nbytes = size * itemsize
    )r]   r   r   r   r   rz  r4   r4   r5   array_nbytes	  s    r  
contiguousc                 C   s   |  tj|j}t| |||S r   )r   r   rM  	is_contigr   rx  r4   r4   r5   array_contiguous	
  s    r  c_contiguousc                 C   s   |  tj|j}t| |||S r   )r   r   rM  Zis_c_contigr   rx  r4   r4   r5   array_c_contiguous
  s    r  f_contiguousc                 C   s   |  tj|j}t| |||S r   )r   r   rM  Zis_f_contigr   rx  r4   r4   r5   array_f_contiguous
  s    r  r  c                 C   s    |  tj|j }t| |||S r   )r   r   rM  mutabler   rx  r4   r4   r5   array_readonly
  s    r  ctypesc           	      C   sP   t |}|| ||}t|}| ||}|j|_|j|_| }t| |||S r   )r]   r   ArrayCTypesr   rz   r   r   r   )	ra   r1   r  r   rh   r   Zactctinfor   r4   r4   r5   array_ctypes#
  s    
r  rz   c                 C   s8   | j |||d}|j}||| tj}t| |||S Nr   )r   rz   r`  r   r   ro   r   )ra   r1   r  r   r  r   r4   r4   r5   array_ctypes_data0
  s    r  c                 C   s6   | j |||d}|j}||| |}t| |||S r  )r   rz   ru  r   r   )ra   r1   fromtytotyrk   r  r   r4   r4   r5   array_ctypes_to_pointer9
  s    r  c           
      C   sr   t ||||d}ttj|j}|||j}ttj	||tj}|j
|j|tj|g}||| ||}	|	S )a)  Helper to invoke the contiguous checker function on an array

    Args
    ----
    checker :
        ``numba.numpy_supports.is_contiguous``, or
        ``numba.numpy_supports.is_fortran``.
    context : target context
    builder : llvm ir builder
    aryty : numba type
    ary : llvm value
    r   )r]   r   r  ro   rU   r`   r   r_   r    Zbool_rK   r   r   r  )
checkerra   r1   r   r   Ztup_intpr   Z	check_sigZ
check_argsr  r4   r4   r5   _call_contiguous_checkB
  s    
r  r   c                 C   s>   |  |t|}||_| }| j||| t| |||S r   )r   r   
ArrayFlagsr   r   r   r   r   )ra   r1   r  r   flagsobjr   r4   r4   r5   array_flags\
  s
    r  c                 C   sZ   |j jdkr2| j|||d}tt| ||j |j}n|j jdk}| tj|}t	| |||S )Nr   r   )
rI   rW  r   r  r   r   r   r   rM  r   )ra   r1   r  r   r  r   rk   r4   r4   r5   array_flags_c_contiguouse
  s     r  c                 C   sr   |j jdkr2| j|||d}tt| ||j |j}n2|j j}|j jdkrN|dkn|dk}| tj	|}t
| |||S )NrF  r   r7   r\  )rI   rW  r   r  r   r   rU   r   r   rM  r   )ra   r1   r  r   r  r   rW  rk   r4   r4   r5   array_flags_f_contiguouss
  s     r  realc                 C   sL   |j tjkrt| |||ddS |j tjkr8t| |||S tdtj d S )Nr  attrzunsupported .real for {})	r_   r   complex_domainarray_complex_attrnumber_domainr   r=   r   r/   )ra   r1   r  r   r4   r4   r5   array_real_part
  s
    r  imagc                 C   s   |j tjkrt| |||ddS |j tjkrt|jdd|}t| |||g\}}t| |||}t	
||j||j|jd t| ||j| S tdtj d S )Nr  r  T)r  r   zunsupported .imag for {})r_   r   r  r  r  r    r  _parse_empty_like_argsrU  r
   memsetrz   r   r   r   r   r   r   r=   r   r/   )ra   r1   r  r   rE   r  r   r   r4   r4   r5   array_imag_part
  s    
r  c                 C   s   |dks|j tjkr"td|t|}|| ||}|j j}| | |}|j	
|}	| | }
||j|
}|dkr||tddg}|j|dd}t|| |}t||	d}t||| t| ||| S )	a  
    Given a complex array, it's memory layout is:

        R C R C R C
        ^   ^   ^

    (`R` indicates a float for the real part;
     `C` indicates a float for the imaginary part;
     the `^` indicates the start of each element)

    To get the real part, we can simply change the dtype and itemsize to that
    of the underlying float type.  The new layout is:

        R x R x R x
        ^   ^   ^

    (`x` indicates unused)

    A load operation will use the dtype to determine the number of bytes to
    load.

    To get the imaginary part, we shift the pointer by 1 float offset and
    change the dtype and itemsize.  The new layout is:

        x C x C x C
          ^   ^   ^
    )r  r  zcannot get attribute `{}`r      r7   r  r_   rW  )rz   r   )r_   r   r  r=   r   r]   Zunderlying_floatr`   r^   r   r/   r   r  ru  rz   rX  r   IntTyper  r   r
   r  r   r   )ra   r1   r  r   r  rh   r   ZfltyZsizeof_fltyr   Z
llfltptrtyr   Zresulttyr   r  r4   r4   r5   r  
  s     r  conj	conjugatec                 C   s   dd }|S )Nc                 S   s
   t | S r   )r  r  r^  r4   r4   r5   r  
  s    zarray_conj.<locals>.implr4   r^  r  r4   r4   r5   
array_conj
  s    r  c                 C   s   |   S r   )r  )ra   r1   ZdtypetyZdtypevalr4   r4   r5   
dtype_type
  s    r  r/   kindc              	      s  t |}| ||}|j}t|tjs6td||f ||}||}	t|tjrr|j	|j|j
|j
 dd}
n|j	|dd}
t |
}| |} tj|	}tj||j||jjd}t|tjr.t||j|j
}| fdd|jD 7 }t||j|j
}| fdd|jD 7 }  |j}n|j}|j}  |}t|||| tj||j|jd	 | }t ||
|S )
zq
    Generic getattr() implementation for record arrays: fetch the given
    record member, i.e. a subarray.
    zattribute %r of %s not definedr  r  r  )r   c                    s   g | ]}  tj|qS r4   r   r   ro   rD  ra   r4   r5   r     s     z(array_record_getattr.<locals>.<listcomp>c                    s   g | ]}  tj|qS r4   r  rD  r  r4   r5   r     s     r   )r]   r_   rv   r   Recordr=   typeofr   NestedArrayr  rU   r   ro   r
   r   rz   r/   r   rK   r   r`   r^   r   r   r   r   r   )ra   r1   r  r   r  rh   r   Zrectyper_   r   ZrestyZrarytyZraryZconstoffsetZ
newdataptrrK   r   Zdatasizer   r4   r  r5   array_record_getattr
  sX    

 
 
   r  Zstatic_getitemc                 C   s0   |d }t |tstt| ||jd |d |S r.  )rv   strr=   r  r   )ra   r1   rE   r   r   r4   r4   r5   array_record_getitem&  s    
r  c              	      s    || ||}||}t|tjrt|}| |}|j}	 fdd|jD }
 fdd|j	D }t
||| |	}t||t
||
t
|| tj|jddd | }t |||S t
||| |}|jrdnd} ||||}t |||S dS )zT
    Generic getattr() implementation for records: get the given record member.
    c                    s   g | ]}  tj|qS r4   r  r}   r   r  r4   r5   r   >  s     z"record_getattr.<locals>.<listcomp>c                    s   g | ]}  tj|qS r4   r  r  r  r4   r5   r   @  s     Nr   r7   )sentry_record_alignmentr   r  rv   r   r  r]   r_   rK   r   r
   get_record_memberr^   r   rP   r   ro   rs   r   r   rf   rg   )ra   r1   r  r   r  r   elemtyr   r   r_   r   r  newdatar   dptrre   r4   r  r5   record_getattr/  sB    







	
r  c              	   C   s   |j \}}|\}}| || ||}	||}
t|
tjrt|| ||d d}|j	}t
|||	|jj}t|||| tj|
j nHt
|||	| |
}| ||||
}|jrdnd}| j||
|||d dS )zT
    Generic setattr() implementation for records: set the given record member.
    r7   r   Nrd   )r   r  r   r  rv   r   r  r
   r\   rz   r  r/   ZpointeeZmemcpyr   ro   r   r^   rn   rf   rj   )ra   r1   rE   r   r  r  r   rn  rk   r   r  Z
val_structr|  r  r  re   r4   r4   r5   record_setattrW  s,    





r  c                 C   s4   |  |jd |d }|| ||jd |d |d S )3
    Record.__getitem__ redirects to getattr()
    r   r7   )get_getattrr   )ra   r1   rE   r   r  r4   r4   r5   record_static_getitem_stru  s    r  c                 C   s^   |j d j}t|j d j}| |j|| }| |j d |}|| ||j d |d || S )r  r7   r   )r   literal_valuer   rv  Zinsert_const_stringr0   r  )ra   r1   rE   r   rr   rv  Zll_fieldr  r4   r4   r5   record_static_getitem_int~  s
    r  Zstatic_setitemc                 C   sJ   |j \}}}|\}}}	t|j||}
| ||
}|dk	s<t||||	fS )3
    Record.__setitem__ redirects to setattr()
    N)r   r    r   get_setattrry   )ra   r1   rE   r   rectyrY  r   recrr   rk   getattr_sigr  r4   r4   r5   record_static_setitem_str  s    
r  c                 C   s^   |j \}}}|\}}}	t|j||}
t|j d j}| || |
}|dk	sPt||||	fS )r  r   N)r   r    r   r   rv  r  ry   )ra   r1   rE   r   r  rY  r   r  rr   rk   r  rv  r  r4   r4   r5   record_static_setitem_int  s    
r  c                 C   s   |  |||S )zB
    Create a constant array (mechanism is target-dependent).
    )make_constant_array)ra   r1   r   pyvalr4   r4   r5   constant_array  s    r  c                 C   s0   t t d|j}|t| }t||S )zG
    Create a record constant as a stack-allocated array of bytes.
       )r   r  r  r  	bytearraytostringr
   r   )ra   r1   r   r  Zltyrk   r4   r4   r5   constant_record  s    r  c                 C   s"   t jt|t jd}| |||S )zM
    Create a constant array from bytes (mechanism is target-dependent).
    rZ  )r  r   r  Zuint8r  )ra   r1   r   r  bufr4   r4   r5   constant_bytes  s    r  c                 C   s0   |j \}}||krtjS dd }| ||||S )Nc                 S   s(   | j |j ko&| j|jko&| jj|jjkS r   )rK   r   r  rz   r  r2  r4   r4   r5   array_is_impl  s
    
zarray_is.<locals>.array_is_impl)r   r
   rI  r  )ra   r1   rE   r   atyZbtyr  r4   r4   r5   array_is  s
    
r  c                 C   s
   t | dS )zq
    Return the Structure representation of the given *flatiterty* (an
    instance of types.NumpyFlatType).
    flat_make_flattening_iter_cls)
flatitertyr4   r4   r5   make_array_flat_cls  s    r  c                 C   s
   t | dS )zv
    Return the Structure representation of the given *nditerty* (an
    instance of types.NumpyNdEnumerateType).
    ndenumerater  nditertyr4   r4   r5   make_array_ndenumerate_cls  s    r  c              
   C   s   |  tjd}|d}	|d k	r.|tj| tt|D ]}
t	|||
}t
|||}||
 }|d||}t||, ||| |d k	r||
 ||	 W 5 Q R X ||| |d k	r:||
 q:|d k	r|tj| ||	 ||	 d S )Nr   Zend_incrementr   )r   r   ro   r  r   r
   
false_byterS  r.   rN   r   r2   r   	if_likelyr  	true_byter   )ra   r1   rU   rK   r   end_flagloop_continue
loop_breakr   bbendr  idxptrrr   r   	in_boundsr4   r4   r5   _increment_indices  s*    


r  c                 C   s*   t ||j|j}t| ||j||| d S r   )r
   r   rK   rU   r  )ra   r1   r]  r^  r   r  rK   r4   r4   r5   _increment_indices_array	  s    r  c                    s   j jtjjr nd	G dd dt}G dd d| G fddd|G dd	 d	|G d
d d|G dd d|G  	f
dddt}|S )zq
    Return the Structure representation of the given *nditerty* (an
    instance of types.NumpyNdIterType).
    r7   c                   @   sF   e Zd ZdZdd Zdd Zejdd Zdd	 Z	d
d Z
dd ZdS )z$make_nditer_cls.<locals>.BaseSubIterzF
        Base class for sub-iterators of a nditer() instance.
        c                 S   s&   || _ || _|| _|| _|| | _d S r   )nditermember_name	start_dimend_dimrU   )rC   r  r  r  r  r4   r4   r5   r    s
    z-make_nditer_cls.<locals>.BaseSubIter.__init__c                 S   s   t | j| j| d S r   )r   r  r  )rC   rQ   r4   r4   r5   set_member_ptr%  s    z3make_nditer_cls.<locals>.BaseSubIter.set_member_ptrc                 S   s   t | j| jS r   )ru  r  r  r  r4   r4   r5   
member_ptr(  s    z/make_nditer_cls.<locals>.BaseSubIter.member_ptrc                 S   s   d S r   r4   rC   ra   r1   r4   r4   r5   init_specific,  s    z2make_nditer_cls.<locals>.BaseSubIter.init_specificc                 S   s   d S r   r4   rC   ra   r1   logical_dimr4   r4   r5   r  /  s    z2make_nditer_cls.<locals>.BaseSubIter.loop_continuec                 S   s   d S r   r4   r  r4   r4   r5   r  2  s    z/make_nditer_cls.<locals>.BaseSubIter.loop_breakN)rV   rW   rX   r  r  r  r   cached_propertyr  r  r  r  r4   r4   r4   r5   BaseSubIter  s   
r  c                   @   s0   e Zd ZdZdd Zdd Zdd Zdd	 Zd
S )z$make_nditer_cls.<locals>.FlatSubIterz
        Sub-iterator walking a contiguous array in physical order, with
        support for broadcasting (the index is reset on the outer dimension).
        c                 S   s$   | tjd}| t|| d S r   )r   r   ro   r  r
   r   )rC   ra   r1   r   r4   r4   r5   r  ;  s    z2make_nditer_cls.<locals>.FlatSubIter.init_specificc                 S   s   | | j}||j|gS r   )r2   r  rX  rz   )rC   ra   r1   r   r]  r^  r   r4   r4   r5   compute_pointer?  s    z4make_nditer_cls.<locals>.FlatSubIter.compute_pointerc                 S   s8   || j d kr4|| j}t||}||| j d S r&  )rU   r2   r  r
   r   r   )rC   ra   r1   r  r   r4   r4   r5   r  C  s    z2make_nditer_cls.<locals>.FlatSubIter.loop_continuec                 S   s^   |dkr&| tjd}||| j n4|| jd krZ|| j}t||}||| j d S Nr   r7   )	r   r   ro   r   r  rU   r2   r
   r   )rC   ra   r1   r  r   r   r4   r4   r5   r  J  s    z/make_nditer_cls.<locals>.FlatSubIter.loop_breakN)rV   rW   rX   r  r  r  r  r  r4   r4   r4   r5   FlatSubIter5  s
   r  c                       s$   e Zd ZdZ fddZdd ZdS )z+make_nditer_cls.<locals>.TrivialFlatSubIterzx
        Sub-iterator walking a contiguous array in physical order,
        *without* support for broadcasting.
        c                    s    j r
td S r   )need_shaped_indexingry   r  r  r4   r5   r  [  s    z9make_nditer_cls.<locals>.TrivialFlatSubIter.init_specificc                 S   s&   t |dkstt |||j|S r&  )r   ry   rX  rz   rC   ra   r1   r   r]  r^  r4   r4   r5   r  ^  s    z;make_nditer_cls.<locals>.TrivialFlatSubIter.compute_pointerN)rV   rW   rX   r  r  r  r4   r  r4   r5   TrivialFlatSubIterU  s   r  c                   @   s   e Zd ZdZdd ZdS )z'make_nditer_cls.<locals>.IndexedSubIterzA
        Sub-iterator walking an array in logical order.
        c                 S   s(   t || jksttj|||||ddS NFrf  )r   rU   ry   r
   r   r  r4   r4   r5   r  g  s
     z7make_nditer_cls.<locals>.IndexedSubIter.compute_pointerNrV   rW   rX   r  r  r4   r4   r4   r5   IndexedSubIterb  s   r  c                   @   s   e Zd ZdZdd ZdS )z'make_nditer_cls.<locals>.ZeroDimSubIterz5
        Sub-iterator "walking" a 0-d array.
        c                 S   s   |j S r   rw  r  r4   r4   r5   r  q  s    z7make_nditer_cls.<locals>.ZeroDimSubIter.compute_pointerNr   r4   r4   r4   r5   ZeroDimSubIterl  s   r  c                   @   s   e Zd ZdZdd ZdS )z&make_nditer_cls.<locals>.ScalarSubIterz8
        Sub-iterator "walking" a scalar value.
        c                 S   s   |S r   r4   r  r4   r4   r5   r  y  s    z6make_nditer_cls.<locals>.ScalarSubIter.compute_pointerNr   r4   r4   r4   r5   ScalarSubItert  s   r  c                       s|   e Zd ZdZej fddZ	fddZfddZdd	 Z	d
d Z
	fddZdd Zdd ZdS )zmake_nditer_cls.<locals>.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                    sd   g }j r nd}tjD ]8\}}|\}}}}d| }	|| }
||
| |	|| q&|S )N)r  ZindexedZ0dZscalarzindex%d)r  r  rB  rO   )rC   lZ	factoriesrS   rL  r  r  r  rY  r  factory)r  r  r  r  r  r  r4   r5   subiters  s    
z(make_nditer_cls.<locals>.NdIter.subitersc                    s@  | tjd}||t||| _t|D ]8\}}t|tjs,d| }t	
||| }	t| ||	 q,| ||||}ttj}
d}d}t|D ]6\}}t|tjr|jkr|| j}|| j} qqdkst|||
d}| tjd}dd }t||D ]T\}}t|tjr|jdkrttjttj|j|
}|||||j|f qt	||} dkr|ddd	 }|d
||}||t	jt	j}js|f}t|kstt	j||jd}tD ] }t	 |||}|!|| q|| _"t	#|||j| _t	
||| _$| j%D ]}|&|| q(dS )zY
            Initialize the nditer() instance for the specific array inputs.
            r   scalar%dNr4   r7   c                 S   s>   t | }t|D ](}| | |t || |  krtdqd S )Nz2nditer(): operands could not be broadcast together)r   r.   r   )rK   
main_shaper`  rS   r4   r4   r5   check_shape  s    zBmake_nditer_cls.<locals>.NdIter.init_specific.<locals>.check_shaperF  r  rH  r  )'r   r   ro   
make_tupler  arraysr  rv   rw   r
   r   r   _arrays_or_scalarsr  rU   rK   r   ry   r   r    noner  r   r   r>  r  r  r  r   rA   r/   r.   rN   r   r   rP   	exhaustedr  r  )rC   ra   r1   arrtysr  r   rS   r   r  ZslotZmain_shape_tyr  Zmain_nitemsr]  r	  r^  rE   r   Zshape_is_emptyr  r   r  r  subiter)rW  rU   r  nshapesr4   r5   r    sf    

 


z-make_nditer_cls.<locals>.NdIter.init_specificc                    s*  | d}t||| j}t|| |d || W 5 Q R X  j}t	|| j}| 
||||}| j}|d | |||||}	dd |	D }	t|	dkr||	d  n||| j|	 t	|| j}
t||t|
|
|| jt| j||t| j|| || || dS )	zJ
            Compute next iteration of the nditer() instance.
            ra  FTc                 S   s   g | ]}|  qS r4   r  r}   r   r4   r4   r5   r     s     zEmake_nditer_cls.<locals>.NdIter.iternext_specific.<locals>.<listcomp>r7   r   N)r  r
   as_bool_bitr2   r  if_unlikelyr   r  r  r   r  r   _make_viewsr   r   r
  r   rK   r  r  partial_loop_continue_loop_breakr   )rC   ra   r1   r   r  r  r  r  r   viewsrK   r  r4   r5   iternext_specific  sD    



 

z1make_nditer_cls.<locals>.NdIter.iternext_specificc                 S   s@   | j D ]4}|j|  kr"|jk rn q|||||j  qd S r   )r  r  r  r  rC   ra   r1   r  rL  r4   r4   r5   r    s    
z.make_nditer_cls.<locals>.NdIter._loop_continuec                 S   s@   | j D ]4}|j|  kr"|jk rn q|||||j  qd S r   )r  r  r  r  r  r4   r4   r5   r    s    
z+make_nditer_cls.<locals>.NdIter._loop_breakc                    s   dg }j }| j}j}	t|	tjr2t|	}	n|	g}	 fddtD t||D ]z\}
}|
\}}}}|j	|j
 }dkr|ddd }|D ]:}|| dkst| | ||	| || || |||< qqZtdd |D st|S )z:
            Compute the views to be yielded.
            Nc              	      s    g | ]}  t |qS r4   r2   r
   rN   rD  r1   r   r4   r5   r   #  s   z?make_nditer_cls.<locals>.NdIter._make_views.<locals>.<listcomp>rF  r  c                 s   s   | ]
}|V  qd S r   r4   r  r4   r4   r5   r   0  s     z>make_nditer_cls.<locals>.NdIter._make_views.<locals>.<genexpr>)rB  r  r   rv   r   r   r   r.   r   r  r  ry   
_make_viewall)rC   ra   r1   r   r  r  r  rB  r  rettysrL  r  rY  Zarray_indicesZsub_indicesrS   )rW  narraysr  r  r  r5   r    s2    


  z+make_nditer_cls.<locals>.NdIter._make_viewsc                 S   s   t |tjr|jdkst||||||}||||}	t||}
||t	tj
dd}||t	tj
dd}t|	||||
dd |	S )zD
            Compute a 0d view for a given input array.
            r   r4   N)r   )rv   r   rw   rU   ry   r  r]   rc   r
  r  ro   r   )rC   ra   r1   r   r
  r]  r^  r  rQ   viewr   rK   r   r4   r4   r5   r  3  s    
z*make_nditer_cls.<locals>.NdIter._make_viewc           	      S   s`   g }t t||D ]H\}\}}t|tjrF||||||d q|t| d|  q|S )Nr   r  )r  r   rv   r   rw   rO   r]   ru  )	rC   ra   r1   r  r  r  rS   r]  r^  r4   r4   r5   r  G  s    
z2make_nditer_cls.<locals>.NdIter._arrays_or_scalarsN)rV   rW   rX   r  r   r  r  r  r  r  r  r  r  r  r4   
r  r  r  r  r  rW  r!  rU   r  r  r4   r5   NdIter|  s   O*r$  )rU   rW  r   r  r  objectr
   r\   )r  r  r$  r4   r#  r5   make_nditer_cls  s    
 
, Yr&  c                    s$   | j  G  fdddt| }|S )zr
    Return the Structure representation of the given *nditerty* (an
    instance of types.NumpyNdIndexType).
    c                       s(   e Zd ZdZ fddZ fddZdS )z%make_ndindex_cls.<locals>.NdIndexIterz,
        .ndindex() implementation.
        c              
      s   | tjd}tj||j| tj d}t|tj}t D ]Z}t	|||}|
|| || }	|d|	|}
t||
 |
tj| W 5 Q R X q@|| _|| _t|||j| _d S Nr   r  rH  )r   r   ro   r
   rA   r/   r   r  r.   rN   r   rK  r  r  r   r  rP   rK   )rC   ra   r1   r   r   r   r  r  r  r9  dim_is_emptyrU   r4   r5   r  c  s"    
z3make_ndindex_cls.<locals>.NdIndexIter.init_specificc           
   	      s   | tjd} d}t  j}t | |	d  
| W 5 Q R X  fddtD }|D ]}t | qt|t ||j |	d t j}	t| |	jj  
|  | d S )Nr   ra  Fc              	      s"   g | ]}  t j|qS r4   )r2   r
   rN   r   r}   r  r1   rC   r4   r5   r     s
   
zKmake_ndindex_cls.<locals>.NdIndexIter.iternext_specific.<locals>.<listcomp>T)r   r   ro   r  r
   r  r2   r  r  r   r  r.   r9   r   rP   r/   r   rK   r  r   r   )
rC   ra   r1   r   r   r  r  r   r2   rK   r)  r+  r5   r  y  s,    




 
z7make_ndindex_cls.<locals>.NdIndexIter.iternext_specificN)rV   rW   rX   r  r  r  r4   r)  r4   r5   NdIndexIter^  s   r,  )rU   r
   r\   )r  r,  r4   r)  r5   make_ndindex_clsW  s    7r-  c                    s\    dkst | j}|jdkr:G  fdddt| }|S G  fdddt| }|S d S )N)r  r  r   c                       s8   e Zd ZdZ fddZ fddZdd Zdd	 Zd
S )z6_make_flattening_iter_cls.<locals>.CContiguousFlatIterzZ
            .flat() / .ndenumerate() implementation for C-contiguous arrays.
            c           	         s~   | tjd}t||| _|j| _ dkrztj||j	| tj|j
d}t|j
D ]}t|||}||| qT|| _d S )Nr   r  r  )r   r   ro   r
   r   r   r   rO  rA   r/   rU   r.   rN   r   r   )	rC   ra   r1   r]  r^  r   r   r  r  r  r4   r5   r    s     zD_make_flattening_iter_cls.<locals>.CContiguousFlatIter.init_specificc              	      s   |j }|j} | j} d||}	||	 t |	  |j	|g}
t
| ||
}dkrp|| nP| j fddt|D }t |}|t ||g t| || t |} || j W 5 Q R X d S )Nr   r  c              	      s    g | ]}  t |qS r4   r  r*  r  r4   r5   r     s
   
z\_make_flattening_iter_cls.<locals>.CContiguousFlatIter.iternext_specific.<locals>.<listcomp>)rU   r   r2   r   r   r   r
   r  rX  rz   ri   r   r   r.   rP   make_anonymous_structr  r   r   )rC   ra   r1   r]  r^  r   rU   r   r   r   rQ   r   idxvalsidxtupler.  r  r5   r    s4    
 zH_make_flattening_iter_cls.<locals>.CContiguousFlatIter.iternext_specificc                 S   s   | |j|g}t||||S r   )rX  rz   ri   rC   ra   r1   r]  r^  r   rQ   r4   r4   r5   r    s    z>_make_flattening_iter_cls.<locals>.CContiguousFlatIter.getitemc                 S   s$   | |j|g}t||||| d S r   )rX  rz   rl   rC   ra   r1   r]  r^  r   r   rQ   r4   r4   r5   setitem  s    z>_make_flattening_iter_cls.<locals>.CContiguousFlatIter.setitemN)rV   rW   rX   r  r  r  r  r4  r4   r.  r4   r5   CContiguousFlatIter  s
   r5  c                       s<   e Zd ZdZdd Z fddZdd Zdd	 Zd
d ZdS )z+_make_flattening_iter_cls.<locals>.FlatIterz
            Generic .flat() / .ndenumerate() implementation for
            non-contiguous arrays.
            It keeps track of pointers along each dimension in order to
            minimize computations.
            c              
   S   s  | tjd}|j}|j}t||j|}tj||j	| tj|jd}	tj||j	| tj|jd}
t
|tj}t|D ]t}t||	|}t||
|}||| ||| || }|d||}t|| |tj| W 5 Q R X q||	| _|
| _|| _d S r'  )r   r   ro   rz   rU   r
   r   rK   rA   r/   r   r  r.   rN   r   rK  r  r  r   pointersr  )rC   ra   r1   r]  r^  r   rz   rU   r   r   r6  r  r  r  ptrptrr9  r(  r4   r4   r5   r    sB        z9_make_flattening_iter_cls.<locals>.FlatIter.init_specificc              
      s"  |j }t |j|}t |j|}| j| j}	|tj	d}
 
d}t  | j}t | |d  | W 5 Q R X |d t |	|d } |}t| ||}dkr|| n: fddt|D }t |}|t ||g tt|D ]}t |}t  |}|| }|| } d	||}t |~  || t |	|} |}t ||} || t|d |D ] }t |	|} || q | W 5 Q R X  |
| q tj| j  |  | d S )
Nr   ra  FTr7   r  c              	      s    g | ]}  t |qS r4   r  r*  r  r4   r5   r   )  s
   
zQ_make_flattening_iter_cls.<locals>.FlatIter.iternext_specific.<locals>.<listcomp>r   )rU   r
   r   rK   r   r   r6  r   r   ro   r  r  r2   r  r  r   r  rN   ri   r   r.   rP   r/  rS  r   r   r  r   r   r  r   )rC   ra   r1   r]  r^  r   rU   r   r   r6  r   r  is_exhaustedZlast_ptrrQ   r   r0  r1  r  r  rr   r   rO  r  r7  Z	inner_dimr.  r  r5   r    sl    
 





z=_make_flattening_iter_cls.<locals>.FlatIter.iternext_specificc              	   S   s   |j }tj||j|d}tj||j|d}g }	tt|D ]*}
|	||||
  |	|||
 }q:|	
  t|||j|||j|	}|S )Nr   )rU   r
   r   rK   r   rS  r.   rO   ZuremZudivreverserV  rz   rW  )rC   ra   r1   r]  r^  r   rU   r   r   r   r  rQ   r4   r4   r5   _ptr_for_indexS  s      z:_make_flattening_iter_cls.<locals>.FlatIter._ptr_for_indexc                 S   s    |  |||||}t||||S r   )r:  ri   r2  r4   r4   r5   r  d  s    z3_make_flattening_iter_cls.<locals>.FlatIter.getitemc                 S   s&   |  |||||}t||||| d S r   )r:  rl   r3  r4   r4   r5   r4  h  s    z3_make_flattening_iter_cls.<locals>.FlatIter.setitemN)	rV   rW   rX   r  r  r  r:  r  r4  r4   r.  r4   r5   FlatIter  s   !Er;  )ry   rI   rW  r
   r\   )r  r  rI   r5  r;  r4   r.  r5   r    s    
D r  r  c                 C   sh   t t|}|| |}||_| |}|| ||dd}|| ||| | }t| |t||S Nr   )rD   )	r  r   NumpyFlatTyper   r]   rM   r  r   r   )ra   r1   r]  r^  flatiterclsflatiterarrclsr   r4   r4   r5   make_array_flatitero  s    

rA  c                 C   sZ   |j \}|\}t|}|| ||d}|j}| |}	|	| ||jd}
|| |||
| d S r  )r   r  rI   r]   r   r  )ra   r1   rE   r   r   r  r?  r>  r]  r@  r^  r4   r4   r5   iternext_numpy_flatiter  s    
rB  c                 C   sj   |j d }|\}}t|}|| ||d}|j}| |}	|	| ||jd}
|| |||
|}t| ||j|S Nr   r   )r   r  rI   r]   r   r  r   r   )ra   r1   rE   r   r  r?  r   r>  r]  r@  r^  r   r4   r4   r5   iternext_numpy_getitem  s    

rD  c                 C   sf   |j d }|\}}}t|}|| ||d}|j}	| |	}
|
| ||jd}|| ||	||| |  S rC  )r   r  rI   r]   r   r4  r  )ra   r1   rE   r   r  r?  r   r   r>  r]  r@  r^  r4   r4   r5   iternext_numpy_getitem_any  s    


rE  c           	      C   sF   |j d }t|}|| ||d d}| |j}|| ||jd}|jS rC  )r   r  r]   rI   r   r   )	ra   r1   rE   r   r  r>  r?  r@  r^  r4   r4   r5   iternext_numpy_getitem_flat  s    
rF  c           
      C   sr   |j \}|\}tt|}|| |}||_| |}|| ||dd}|| ||| | }	t	| ||j
|	S r<  )r   r  r   NumpyNdEnumerateTyper   r]   rM   r  r   r   r   )
ra   r1   rE   r   r]  r^  	nditerclsr  r@  r   r4   r4   r5   make_array_ndenumerate  s    

rI  c                 C   sZ   |j \}|\}t|}|| ||d}|j}| |}	|	| ||jd}
|| |||
| d S r  )r   r  rI   r]   r   r  )ra   r1   rE   r   r   r  r  rH  r]  r@  r^  r4   r4   r5   iternext_numpy_nditer  s    
rJ  c                    s^    fddt |j|D }ttt|}| }| | | }t |j	|S )zndindex(*shape)c                    s"   g | ]\}}  ||tjqS r4   r  )r}   Zargtyr  r~   r4   r5   r     s   z&make_array_ndindex.<locals>.<listcomp>)
r   r   r-  r   NumpyNdIndexTyper   r  r   r   r   )ra   r1   rE   r   rK   rH  r  r   r4   r~   r5   make_array_ndindex  s    

rL  c           
         s   |j j}|dkrJ|jd j|d }t ||} fdd|D }ng }ttt	|}| }|
 | | }	t |j |	S )zndindex(shape)r   c                    s   g | ]}  |tjqS r4   r  )r}   rr   r1   ra   rq   r4   r5   r     s   z,make_array_ndindex_tuple.<locals>.<listcomp>)r   rU   r   r_   r
   r   r-  r   rK  r   r  r   r   )
ra   r1   rE   r   rU   r   rK   rH  r  r   r4   rM  r5   make_array_ndindex_tuple  s    
rN  c                 C   s6   |j \}|\}t|}|| ||d}|| || d S r  )r   r-  r  )ra   r1   rE   r   r   r  r  rH  r4   r4   r5   iternext_numpy_ndindex  s
    rO  c           	      C   sn   |j }|j}t|jd tjr0t||d }n
|d g}t|| |}|	| ||| |
 }t| |||S )z
    nditer(...)
    r   )r   r  rv   r   r   r   r
   r   r&  r  r   r   )	ra   r1   rE   r   r  r  r  r  r   r4   r4   r5   make_array_nditer  s    
rP  c                 C   s2   |j \}|\}t|| ||d}|| || d S r  )r   r&  r  )ra   r1   rE   r   r   r  r  r4   r4   r5   iternext_numpy_nditer2#  s    rQ  c              	   C   sP  t |}|| |}| |j}| tjt| |}| tjd}tt	dd}	|D ]0}
|
||
}||d}||	||d}	qT|jdkrd}n|jdkr|g}t|dd D ]}|||d | qtt|}nT|jdkr$|g}|dd D ]}|||d | qt|}ntd|j|
||}||d}||	||d}	|j|	d	d
 | j|td W 5 Q R X |j}| |}| tj|}|  ||f}ttj}tt|}t ||tjtj}| !|t"||}| j#$||}| %tj}t&j'|||d}t&j'|||d}t(||)||* ||||d |S )a	  Utility function used for allocating a new array during LLVM code
    generation (lowering).  Given a target context, builder, array
    type, and a tuple or list of lowered dimension sizes, returns a
    LLVM value pointing at a Numba runtime allocated array.
    r7   r   r4   r   Nr  rF  z3Don't know how to allocate array with layout '{0}'.Fr  )z[array is too big; `arr.size * arr.dtype.itemsize` is larger than the maximum possible size.)r   r  )+r]   r^   r_   r   r   ro   rc   r   r   r  Zsmul_with_overflowr   rJ  rU   rW  rS  rO   r   r   r=   r   r   r  r  r   Zget_preferred_array_alignmentZuint32r  MemInfoPointervoidptrZTypeRefr/   r    r  _call_allocatorr   Zmeminfo_datar   r
   rP   r   ru  r  )ra   r1   r  r   rO  r   datatyper   ZarrlenZoverflowr   Zarrlen_multr   Zdimension_sizeZallocsize_multr}  r_   Z	align_valre   r   mipZarytypeclassargtypesr   rz   r   Zshape_arrayZstrides_arrayr4   r4   r5   rU  0  sv    
 



 
rU  	_allocatec                 C   s   dd }|S )zPImplements a Numba-only default target (cpu) classmethod on the array type.
    c                 S   s
   t ||S r   )intrin_alloc)clsr}  re   r4   r4   r5   r    s    z _ol_array_allocate.<locals>.implr4   )rZ  r}  re   r  r4   r4   r5   _ol_array_allocate  s    r[  c                 C   s   |  ||S )z9Trampoline to call the intrinsic used for allocation
    )rX  )r  rs   re   r4   r4   r5   rT    s    rT  c                 C   s(   dd }t t j}t|||}||fS )z3Intrinsic to call into the allocator for Array
    c                 S   s   |\}}| j |||}|S r   )r   Zmeminfo_alloc_aligned)ra   r1   r    r   r}  re   r   r4   r4   r5   r    s    zintrin_alloc.<locals>.codegen)r   rR  rS  r    )r  r}  re   r  rV  rE   r4   r4   r5   rY    s    rY  c              
   C   s   dd }t |tjr.d}| |||tjg}n&t |tjs>t|j}tj	|||d}g }|D ]}|
|| ||j| q\| |tjd}	t|D ]>}
|d||
 |	}t|| | j|td W 5 Q R X q|S )z;
    Parse the shape argument to an array constructor.
    c           
   	   S   s   |  tj}|j}t|}t|d|d > d }|j|k rJ|||}n^|j|kr|d||}	|j	|	dd | j
|td W 5 Q R X |j|kr|||}n|}|S )z0Cast src to intp only if value can be maintainedr7   >Fr  )z#Cannot safely convert value to intp)r   r   ro   r8   r   r  r   Zsextr   r   r  r  r   trunc)
ra   r1   Zsrc_tr|  r   Z
intp_widthZintp_irmaxvalr   Z	is_largerr4   r4   r5   safecast_intp  s$    


 
z#_parse_shape.<locals>.safecast_intpr7   r   r   r   )znegative dimensions not allowed)rv   r   rx   rn   ro   r   ry   r   r
   r   rO   r/   get_constant_genericr.   r   r  r  r  r   )ra   r1   r   rk   r_  rU   Zpassed_shapesr   r   r   r  Zis_negr4   r4   r5   _parse_shape  s(      ra  c                 C   s*   |j d }|d }|j}|t| |||fS )zL
    Parse the arguments of a np.empty(), np.zeros() or np.ones() call.
    r   )r   r   ra  )ra   r1   rE   r   ZarrshapetypeZarrshaper  r4   r4   r5   _parse_empty_args  s    
rb  c                 C   sX   |j d }t|tjrJt|| ||d d}tj||j|jd}|j	|fS |j	dfS dS )z_
    Parse the arguments of a np.empty_like(), np.zeros_like() or
    np.ones_like() call.
    r   r   r   r4   N)
r   rv   r   rw   r]   r
   r   rK   rU   r   )ra   r1   rE   r   arytyper   r   r4   r4   r5   r    s    

r  c                 C   s&   t |tjr"d|  d}t|d S )NzIf np.z0 dtype is a string it must be a string constant.)rv   r   ZUnicodeTyper	   r  )fnamer_   r   r4   r4   r5   _check_const_str_dtype  s    re  c                 C   s"   |j }||||}dd }||fS )Nc                 S   s(   t | |||\}}t| |||}| S r   )rb  rU  r   ri  r1   rE   rj  r  r   r   r4   r4   r5   r    s    znumpy_empty_nd.<locals>.codegenZinstance_type)rk  Zty_shapety_dtypety_retty_refty_rettyrE   r  r4   r4   r5   numpy_empty_nd  s    rk  c                    s   t d| |tks0t|tjr(|jtks0t|r8tj}nt|}t	| }|d k	r||d k	r|tj
||dd tf fdd	}|S d|  d| d}t|d S )	Nr\  r   r  c                    s   t | | S r   )rk  )rK   r_   r
  r4   r5   r    s    zol_np_empty.<locals>.implz.Cannot parse input types to function np.empty(, ))re  floatrv   r   ZFunctionZ
typing_keyr   doublety_parse_dtypety_parse_shaperw   r	   r  )rK   r_   nb_dtyperU   r  r   r4   rl  r5   ol_np_empty  s"    

rt  c                 C   s"   |j }||||}dd }||fS )Nc                 S   s(   t | |||\}}t| |||}| S r   )r  rU  r   rf  r4   r4   r5   r    s    z$numpy_empty_like_nd.<locals>.codegenrg  )rk  Zty_prototyperh  ri  rj  rE   r  r4   r4   r5   numpy_empty_like_nd  s    ru  c                    s   t d| t|st|}nt| tjr0| j}n| }|d k	r~t| tjrn| jdkrX| jnd}| j||dd qt|dd nd|  d| d	}t	
|d fd
d	}|S )Nr'  r  r   F)r_   rW  r  r   z3Cannot parse input types to function np.empty_like(rm  rn  c                    s   t | | S r   )ru  )r^  r_   rl  r4   r5   r  ,  s    zol_np_empty_like.<locals>.impl)N)re  r   rq  rv   r   rw   r_   rW  r  r	   r  )r^  r_   rs  rW  r   r  r4   rl  r5   ol_np_empty_like  s    


rv  c                 C   s   t |}dd }||fS )Nc                 S   s<   t |jd | ||d }t||j||j|jd d S r   )r]   r   r
   r  rz   r   r   r   )ri  r1   rE   rj  r   r4   r4   r5   r  5  s    z(_zero_fill_array_method.<locals>.codegen)r   r  )rk  rC   rE   r  r4   r4   r5   _zero_fill_array_method1  s    
rw  
_zero_fillc                 C   s   dd }|S )z?Adds a `._zero_fill` method to zero fill an array using memset.c                 S   s   t |  d S r   )rw  r  r4   r4   r5   r  ?  s    z ol_array_zero_fill.<locals>.implr4   )rC   r  r4   r4   r5   ol_array_zero_fill<  s    ry  c                 C   s   t d| tfdd}|S )Nzerosc                 S   s   t j| |d}|  |S NrZ  )r  r\  rx  )rK   r_   r^  r4   r4   r5   r  H  s    zol_np_zeros.<locals>.impl)re  ro  rK   r_   r  r4   r4   r5   ol_np_zerosD  s    
r}  c                 C   s   t d| ddd}|S )N
zeros_likec                 S   s   t j| |d}|  |S r{  )r  r'  rx  )r  r_   r^  r4   r4   r5   r  T  s    zol_np_zeros_like.<locals>.impl)Nre  rq  r4   r4   r5   ol_np_zeros_likeO  s    

r  c                 C   s   t d| ddd}|S )N	ones_likec                 S   s2   t j| |d}|j}tt|D ]}d||< q |S NrZ  r7   r  r'  r  r.   r   )r  r_   r^  arr_flatrr   r4   r4   r5   r  `  s
    
zol_np_ones_like.<locals>.impl)Nr  rq  r4   r4   r5   ol_np_ones_like[  s    

r  c                 C   s(   dd }|  ||||}t| ||j|S )Nc                 S   s4   t | t|}|j}tt|D ]}|||< q"|S r   )r  r\  r/   r  r.   r   )rK   r   r^  r  rr   r4   r4   r5   fulll  s
    
znumpy_full_nd.<locals>.fullr%  ra   r1   rE   r   r  r   r4   r4   r5   numpy_full_ndi  s    r  c                 C   s(   dd }|  ||||}t| ||j|S )Nc                 S   s0   t | |}|j}tt|D ]}|||< q|S r   r  r\  r  r.   r   )rK   r   r_   r^  r  rr   r4   r4   r5   r  {  s
    
z!numpy_full_dtype_nd.<locals>.fullr%  r  r4   r4   r5   numpy_full_dtype_ndw  s    r  c                 C   s(   dd }|  ||||}t| ||j|S )Nc                 S   s.   t | } | j}tt|D ]}|||< q| S r   r  )r^  r   r  rr   r4   r4   r5   r:    s
    

z%numpy_full_like_nd.<locals>.full_liker%  ra   r1   rE   r   r:  r   r4   r4   r5   numpy_full_like_nd  s    r  c                 C   s(   dd }|  ||||}t| ||j|S )Nc                 S   s0   t | |} | j}tt|D ]}|||< q| S r   r  )r^  r   r_   r  rr   r4   r4   r5   r:    s
    
z/numpy_full_like_nd_type_spec.<locals>.full_liker%  r  r4   r4   r5   numpy_full_like_nd_type_spec  s    r  c                 C   s   t d| ddd}|S )Nonesc                 S   s2   t j| |d}|j}tt|D ]}d||< q |S r  r  )rK   r_   r^  r  rr   r4   r4   r5   r    s
    
zol_np_ones.<locals>.impl)Nr  r|  r4   r4   r5   
ol_np_ones  s    

r  c                 C   s(   dd }|  ||||}t| ||j|S )Nc                 S   s,   t | | f}t| D ]}d|||f< q|S r&  r  rz  r.   )r`  r^  rS   r4   r4   r5   identity  s    z numpy_identity.<locals>.identityr%  ra   r1   rE   r   r  r   r4   r4   r5   numpy_identity  s    r  c                 C   s(   dd }|  ||||}t| ||j|S )Nc                 S   s.   t | | f|}t| D ]}d|||f< q|S r&  r  )r`  r_   r^  rS   r4   r4   r5   r    s    z*numpy_identity_type_spec.<locals>.identityr%  r  r4   r4   r5   numpy_identity_type_spec  s    r  c                 C   s   d S r   r4   NMr4   r4   r5   _eye_none_handler  s    r  c                 C   s"   t |tjrdd }ndd }|S )Nc                 S   s   | S r   r4   r  r4   r4   r5   r    s    z$_eye_none_handler_impl.<locals>.implc                 S   s   |S r   r4   r  r4   r4   r5   r    s    rv   r   rB  )r  r  r  r4   r4   r5   _eye_none_handler_impl  s    
r  c                    sf   |d kst |tjr tt n.t |tjtjfrDtt	|d| n
t| d dtf fdd	}|S )Nr_   r   c                    s   t | |}t| |f }|dkrPt| || }t|D ]}d|||| f< q8n,t| | |}t|D ]}d||| |f< qf|S r  )r  r  rz  r*  r.   )r  r  r   r_   Z_Mr^  drS   r  r4   r5   r    s    
znumpy_eye.<locals>.impl)
rv   r   rB  r  r_   ro  	DTypeSpecr  r   ru  )r  r  r   r_   r  r4   r  r5   	numpy_eye  s    
r  c                 C   s   dd }|  ||||S )Nc                 S   s   t j| ddS )Nr   )r   )r  diag)rk   r4   r4   r5   	diag_impl  s    znumpy_diag.<locals>.diag_implr#  )ra   r1   rE   r   r  r4   r4   r5   
numpy_diag  s    r  c                 C   s^   |j d }|jdkr ddd}n|jdkr6d	dd}ntd| ||||}t| ||j|S )
Nr   r7   c                 S   s   | j }|d t| }t||f| j}|dkrXt|| D ]}| | |||| f< q<n&t|| D ]}| | ||| |f< qd|S r   )rK   r  r  rz  r_   r.   )r^  r   r   r`  r  rS   r4   r4   r5   r    s    z#numpy_diag_kwarg.<locals>.diag_implr  c                 S   s   | j \}}|dk r|| }|dkr*|| }tt||d}t|| j}|dkrtt|D ]}| ||| f ||< qXn"t|D ]}| || |f ||< q||S r   )rK   r  r*  r  r\  r_   r.   )r^  r   Zrowscolsr`  r  rS   r4   r4   r5   r    s    
zInput must be 1- or 2-d.)r   )r   )r   rU   r   r  r   r   )ra   r1   rE   r   r  r  r   r4   r4   r5   numpy_diag_kwarg  s    


r  z
array.takec                 C   s(   dd }|  ||||}t| ||j|S )Nc                 S   s.   || j d ks|| j  k r"td|  | S )Nr7   Index out of bounds)rs   
IndexErrorr  )r  r   r4   r4   r5   	take_impl+  s    znumpy_take_1.<locals>.take_implr%  ra   r1   rE   r   r  r   r4   r4   r5   numpy_take_1'  s    r  c                    s<   |j d jdk  fdd}| ||||}t| ||j|S )Nr7   rF  c                    s   t j|j| jd} r | }n|}t |}d}|  }|D ]:}|| jd ks\|| j k rdtd|| ||< |d }q>||j	S NrZ  r   r7   r  )
r  r\  rs   r_   r  r  r  r  r  rK   )r  r   r  walkeritrS   r  r  ZF_orderr4   r5   r  :  s    


znumpy_take_2.<locals>.take_implr  r  r4   r  r5   numpy_take_24  s    r  c                 C   s(   dd }|  ||||}t| ||j|S )Nc                 S   s~   t |}t j|j| jd}t |}d}|  }|D ]:}|| jd ksT|| j k r\td|| ||< |d }q6||j	S r  )
r  r   r\  rs   r_   r  r  r  r  rK   )r  r   convertr  r  rS   r  r  r4   r4   r5   r  T  s    


znumpy_take_3.<locals>.take_implr%  r  r4   r4   r5   numpy_take_3N  s    r  c                  G   s|   dd | D }t dd |D r(tj}nPt dd |D rBtj}n6ttddttj  }dd |D }t	||g }|S )	Nc                 S   s   g | ]}t |tjs|qS r4   r  r  r4   r4   r5   r   f  s      z!_arange_dtype.<locals>.<listcomp>c                 s   s   | ]}t |tjV  qd S r   rv   r   Complexr  r4   r4   r5   r   h  s     z _arange_dtype.<locals>.<genexpr>c                 s   s   | ]}t |tjV  qd S r   )rv   r   Floatr  r4   r4   r5   r   j  s     zint%sr  c                 S   s   g | ]}t |qS r4   )r   Z	unliteralr}   r  r4   r4   r5   r   y  s     )
r   r   Z
complex128r   ru  r  r_   r   r   r  )r   Zboundsr_   ZNPY_TYZunliteral_boundsr4   r4   r5   _arange_dtypee  s    r  c                    s  t |tjr|j}t |tjr$|j}t |tjr6|j}|d krDtj}|d krRtj}|d kr`tj}t | tjrt |tjtjfrt |tjtjfrt |tjtjfsd S t |tjrt| ||n|j	t
dd | ||fD t| dd  t|dd t|dd d fdd	}|S )Nc                 S   s   g | ]}t |tjqS r4   r  r  r4   r4   r5   r     s   znp_arange.<locals>.<listcomp>r  c                    s    d k	r n| }d k	rn|}d k	r,n|}|d k	r<|nd}|d krTd| }}	n
|| }}	|dkrnt d|	| | }
tt|
j}dkrtt|
j}tt||d}n
t|d}t	|}|}t
|D ]}|||  ||< q|S )Nr7   r   zMaximum allowed size exceededT)r   r   mathceilr  r  r  r*  r  r\  r.   )r   r?  r:  r_   Z	lit_startZlit_stopZlit_stepZ_step_start_stopZnitems_cZnitems_rZnitems_ir   r^  rk   rS   Zstart_valueZ
step_valueZ
stop_valueZ
true_dtypeZuse_complexr4   r5   r    s(    

znp_arange.<locals>.impl)NNN)rv   r   Optionalr/   r  r  rB  r  r  r_   r   ru  )r   r?  r:  r_   r  r4   r  r5   	np_arange  s>    r  c                 C   s(   dd }|  ||||}t| ||j|S )Nc                 S   s   t | |dS )Nr  )r  r  )r   r?  r4   r4   r5   r    s    z"numpy_linspace_2.<locals>.linspacer%  ra   r1   rE   r   r  r   r4   r4   r5   numpy_linspace_2  s    r  c                    s8   t |jj  fdd}| ||||}t| ||j|S )Nc                    s   t | }| d } |d }|dkr(|S |d }|dkrn||  }t ||}td|D ]}| ||  ||< qVn| |d< |dkr||d< |S )Ng      ?r   r7   r  )r  r\  divider.   )r   r?  r  r^  divdeltar:  rS   rZ  r4   r5   r    s    z"numpy_linspace_3.<locals>.linspace)r   r   r_   r  r   r  r4   rZ  r5   numpy_linspace_3  s    r  c              
   C   s  |j d }t|| ||d d}t||j}|j}t| |||}|j}	|j}
|jdks\t	|j|jkrtj
||
|	|j|jdd nt||j}t||j}| tj}t|||H}t| ||	|||j|}t| ||
|||j|}|||| W 5 Q R X t| ||j| S )z
    Array copy.
    r   r   r\  r7   rd   )r   r]   r
   r   rK   r   rU  rz   rW  ry   Z
raw_memcpyr   r   r   r   r   ro   r{  rV  r   r2   r   r   )ra   r1   rE   r   rc  r   r   rettyper  ro  r  rq  r  r   r   ri  r~  r4   r4   r5   _array_copy  s>    
 
  
  r  z
array.copyc                 C   s   t | |||S r   r  r  r4   r4   r5   
array_copy  s    r  c                 C   s   t | |||S r   r  r  r4   r4   r5   
numpy_copy  s    r  c              
   C   s  |j }|jd }|j|ks"td|jdkr|jdks:tt|| ||d d}t|| |}| |ttj	dd}	| 
|ttj	d|jf}
t||j|	|
|j|j|j t| ||| S |j|jks|jdkr|jdkrt| |||d S |jdkr|dkst|dkrtnt}t|| |||d }||V\}}| t| |||d }|j}W 5 Q R X | t| |||}|j}W 5 Q R X W 5 Q R X ||j}||| ||| |S t| |||S d	S )
zd
    Common logic for layout conversion function;
    e.g. ascontiguousarray and asfortranarray
    r   z return-type has incorrect layoutr7   r   r  r\  r  r   N)r   r   rW  ry   rU   r]   r`  r   r  ro   r
  r   r   rz   r   r   r   r   r   r   r  rg  blockr  phir/   Zadd_incoming)ra   r1   rE   r   output_layoutr
  r   r   r  rK   r   Z
check_funcr  ZthenZorelseZout_thenZthen_blkZ
out_orelseZ
orelse_blkZret_phir4   r4   r5   _as_layout_array  sd    

   r  c                 C   s   t | |||ddS )NrF  r  r  r  r4   r4   r5   array_asfortranarray]  s    r  c                 C   s   t | |||ddS )Nr   r  r  r  r4   r4   r5   array_ascontiguousarrayb  s    r  c                 C   s"   t | tjtjfrdd }|S dS )z^
    This is an implementation for scalar.
    For arrays, see `array_ascontiguousarray`.
    c                 S   s   t t | S r   )r  ascontiguousarrayr   r!  r4   r4   r5   r  n  s    z,array_ascontiguousarray_scalar.<locals>.implNrv   r   r  rA  rR  r4   r4   r5   array_ascontiguousarray_scalarg  s    r  c                 C   s"   t | tjtjfrdd }|S dS )z[
    This is an implementation for scalar.
    For arrays, see `array_asfortranarray`.
    c                 S   s   t t | S r   )r  asfortranarrayr   r!  r4   r4   r5   r  z  s    z)array_asfortranarray_scalar.<locals>.implNr  rR  r4   r4   r5   array_asfortranarray_scalars  s    r  zarray.astypec              
   C   s  |j d }t|| ||d d}t||j}|j}t| |||}|j}	|j}
t||j}t||j}| 	t
j}t|||h}t| ||	|||j|}t| ||
|||j|}t| |||}| |||j|j}t| |||| W 5 Q R X t| ||j| S rC  )r   r]   r
   r   rK   r   rU  rz   r   r   r   ro   r{  rV  rW  ri   rn   r_   rl   r   r   )ra   r1   rE   r   rc  r   r   r  r  ro  r  rq  r  r   r   ri  r~  itemr4   r4   r5   array_astype  s6    

  
  r  c              	   C   s  |j d }|j}t|| ||d d}t|}|| |}|j}	t| |}
t|jj|
}||j	|j}|
||}t||}|j|dd d}| j|t|f W 5 Q R X t||||g}t||g}||j| |	d}t||||||j|jd | }t| ||j|S )Nr   r   Fr  z.buffer size must be a multiple of element sizerz   r   )r   r   r]   r   rc   r   r   r/   r   r   Zsremr
   Zis_not_nullr   r  r  r   rP   Zsdivru  rz   r   r   r   r   r   r   r   )ra   r1   rE   r   Zbuftyr   r  Z
out_ary_tyout_aryZout_datamodelr   ll_itemsizer  remZis_incompatibler   rK   r   rz   r   r4   r4   r5   np_frombuffer  s<    


 r  c                    s<  |j dd \}}|dd \}}|j}|jdks6tt| }	t|}
t|
}t|t	j
rrt |}n|f}|f} fddt||D }|}g }|jdkr|D ]}||  ||}qn,t|D ]}||  ||}q|   ||j }t|	||||dd |	 }t |j|S )zR
    numba.numpy_support.carray(...) and
    numba.numpy_support.farray(...).
    Nr  r\  c                    s"   g | ]\}}  ||tjqS r4   r  )r}   r  r   r~   r4   r5   r     s   znp_cfarray.<locals>.<listcomp>rF  r  )r   r   rW  ry   r]   rc   r
   r   rv   r   r   r   r   rO   r   rS  r9  ru  r^   r_   r  r   r   r   )ra   r1   rE   r   rn  r  rQ   rK   r   r  r   r  r   offr   r   rz   r   r4   r~   r5   
np_cfarray  sH    	




	r  c                 C   sV   t |tjr| tjt|S t |tjrJ| tttj|}|||fS dsRt	d S r   )
rv   r   r   r   ro   r   r  r<   r    ry   )ra   r1   seqtyseqr  r4   r4   r5   _get_seq_size  s    r  c                    s2   |j  tjt|tj fdd}|S )zK
    Return a getitem() implementation that doesn't incref its result.
    c                    s$   | |} j r  j| | |S r   )r   r   Zdecref)r1   r   r  ra   r  r
  r4   r5   wrap  s    
z$_get_borrowing_getitem.<locals>.wrap)r_   r<   r  r  r    r   ro   )ra   r  r  r4   r  r5   _get_borrowing_getitem	  s    r  c                    st    tj}t|d fdd}g }|| }}	t|D ].}
|
dkrV|||	\}}	|t ||	 q<t|S )zF
    Compute the likely shape of a nested sequence (possibly 0d).
    r   c                    sT   t | tjr2t| dkrdS | d  |dfS nt| }| j| |ffS d S )Nr   )NN)rv   r   r   r   r   r  r_   )r  r  r  r1   ra   r   r4   r5   get_first_item!  s    
z.compute_sequence_shape.<locals>.get_first_item)r   r   ro   r   r.   rO   r  r   )ra   r1   rU   r  r  r   r  r   innertyinnerrS   r4   r  r5   compute_sequence_shape  s    

r  c                    s0   fdd  fdd||| dS )z?
    Check the nested sequence matches the given *shapes*.
    c                      s   j  td d S )N)zincompatible sequence shape)r  r  r   r4   r~   r4   r5   _fail=  s    
z#check_sequence_shape.<locals>._failc              	      s  t |dkrd S t| |}|d }d||}j|dd    W 5 Q R X t |dkrdd S t| tjrt| }t	|0}| j
}|||jf}	||	|dd   W 5 Q R X nXt| tjrtt | D ],}
| |
 }||
}	||	|dd   qndst| d S )Nr   r  Fr  r7   )r   r  r   r   rv   r   r  r  r
   r0  r_   r   r   r.   r   ry   )r  r  r   rs   expectedr  r  r1  r  r  rS   r  r1   check_seq_sizera   r4   r5   r  A  s*    
 z,check_sequence_shape.<locals>.check_seq_sizeNr4   )ra   r1   r  r  r   r4   r  r5   check_sequence_shape8  s    r  c                    s:    fddfdd||d dS )zl
    Assign a nested sequence contents to an array.  The shape must match
    the sequence's structure.
    c              
      sB   t j j| dd}|| j}t || d S r  )r
   rV  rW  rn   r_   rl   )r   r   rk   rQ   )r]  r1   ra   rz   r   r   r4   r5   assign_itemh  s      z-assign_sequence_to_array.<locals>.assign_itemc              	      s  t |dkr2t| tjtjfr"t|| | d S |d }t| tjrt| }t|:}| j	}|||j
f} |||dd  ||j
f  W 5 Q R X nlt| tjrtt | D ]B}	| |	 }||	}tj|	}
 |||dd  ||
f  qnds
t| d S r  )r   rv   r   r  r   ry   r  r
   r0  r_   r   r.   r   r   ro   )r  r  r   r   rs   r  r1  r  r  rS   r   )assignr  r1   ra   r4   r5   r  n  s$    
* z(assign_sequence_to_array.<locals>.assignr4   Nr4   )ra   r1   rz   r   r   r]  r  r  r4   )r]  r  r  r1   ra   rz   r   r   r5   assign_sequence_to_arraya  s    r  c           
   	   C   s   |j }|j}|jd }|d }t| ||||}t||ks>tt| |||| t| |||}	t| ||	j	||	j
||| t| ||j |	 S r   )r   rU   r   r  r   ry   r  rU  r  rz   r   r   r   )
ra   r1   rE   r   r]  rU   r  r  r   r^  r4   r4   r5   np_array  s    
  r  c           
   	   C   s   | d}| |}|d||}||||||}||d|||d||}|j|dd  d| }	| j|t|	f W 5 Q R X |S )Nr   r   r  Fr  z%s(): axis out of bounds)	r/   r   r>  r(  rJ  r   r  r  r  )
ra   r1   	func_namerU   r  r   Zll_ndimZis_neg_axisZaxis_out_of_boundsr   r4   r4   r5   _normalize_axis  s    

r  c              
   C   s   t ||d kstttj|}t||}td}t|d D ]R}t|}	|d|	|}
|| }|	|
|
|	||	}||t||d| qD||t||d| t|||S )z
    Compute shape with the new axis inserted
    e.g. given original shape (2, 3, 4) and axis=2,
    the returned new shape is (2, 3, 1, 4).
    r7   r  r   r   ry   r   r  r
   r   rA   r.   r   r>  r(  r   rN   r   r2   )ra   r1   
orig_shaperU   r  ll_shtyr   rN  r  ll_dim
after_axisr   rr   r4   r4   r5   _insert_axis_in_shape  s    


r  c              
   C   s   t ||d kstttj|}t||}td}td}t|d D ]N}	t|	}
|d|
|}|	||
|
||
}|||	 t||d| qN||t||d| t|||S )zD
    Same as _insert_axis_in_shape(), but with a strides array.
    r7   r   r  r  )ra   r1   orig_stridesrU   r  r  r   rN  r   r  r  r  rr   r4   r4   r5   _insert_axis_in_strides  s"    




r  c              	   C   s   |j }|j}|jd }t|| ||d d}t|| |}	t||j}
t||j}t| ||
||}t	| ||||}t
|	|j|||j|j|jd |	 S )z/
    np.expand_dims() with the given axis.
    r   r   r   )r   rU   r   r]   r
   r   rK   r   r  r  r   rz   r   r   r   r   )ra   r1   rE   r   r  r
  rU   r]  r^  r  r   r   Z
new_shapesZnew_stridesr4   r4   r5   expand_dims  s$    
r  c                 C   sP   |  ||d |jd tj}t| |d|jj|}t| ||||}t| ||j|S )Nr7   znp.expand_dims)	rn   r   r   ro   r  r   rU   r  r   )ra   r1   rE   r   r  r  r4   r4   r5   np_expand_dims  s     r  c           
         s   |j }|}t|jtjr$t|j}n|jg}t|t|ks@t fddt|||D }t|jtjr~	 |j|}	n|d }	t
 |j|	S )Nc                    s"   g | ]\}}} |||qS r4   r4   )r}   r^  r]  r
  r1   ra   	transformr4   r5   r     s   z_atleast_nd.<locals>.<listcomp>r   )r   rv   r   r   r   r   r   ry   r   r
  r   )
ra   r1   rE   r   r  r  arrsr   Zretsr  r4   r  r5   _atleast_nd  s    
r  c                    s"   t  kst fdd}|S )z`
    Return a callback successively inserting 1-sized dimensions at the
    following axes.
    c           	         sb   t D ]T}|d }|j|k rt | }|j|jd d}t| |t|||f|}|}q|S )Nr7   r)  )r.   rU   r
   r   r  r  r   r    )	ra   r1   r^  r]  r
  rS   rU   r  Znewarrtyr  min_ndimr4   r5   r  ,  s    

 z(_atleast_nd_transform.<locals>.transform)r   ry   )r  r  r  r4   r   r5   _atleast_nd_transform%  s    r  c                 C   s   t ddg}t| ||||S r.  r  r  ra   r1   rE   r   r  r4   r4   r5   np_atleast_1d<  s    r  c                 C   s   t dddg}t| ||||S )Nr  r   r  r  r4   r4   r5   np_atleast_2dC  s    r  c                 C   s    t ddddg}t| ||||S )Nr  r   r  r  r  r4   r4   r5   np_atleast_3dJ  s    r  c	                 C   s  t |t |  kr.t |  kr.t |ks4n ttd}	t| |||}
t||
j}g }|D ]d}|	}tt||D ]B\}\}}|	d|
||}|||}||||||}qx|| qb|
j}t|||||D ]\}}}}}|j}tj||tj|jd}|h}t| |||||j|}t| |||}| |||j|j}t| |||||j|}t| |||| W 5 Q R X t|||}q|
S )z2
    Concatenate arrays along the given axis.
    r   rH  )order)r   ry   r
   r   rU  r   r   r  r   r   r/   r   r>  r(  rO   rz   r{  rW  rV  ri   rn   r_   rl   r   )ra   r1   r  r  r  
arr_shapesarr_stridesr
  
ret_shapesr   r  Zret_stridesZcopy_offsetsZarr_shr   r  rs   rO  is_axisaddendZret_datar]  r^  Zarr_stZarr_datar{  r   ri  rk   r~  r4   r4   r5   _do_concatenateQ  sT    4

 
  
  r  c                    s  |j } fddt||D }t d||} fdd|D } fdd|D } fdd|d D }	t|D ] d||}
|	 } |}fd	d|d
d  D } |
\}}|& t	 j
||g } || W 5 Q R X |d tj}|D ]} | d||}q j |dd j td f W 5 Q R X W 5 Q R X W 5 Q R X qr fdd|	D }	t |||||||		}t || S )Nc                    s"   g | ]\}}t | |d qS r   r  r}   r  r  r~   r4   r5   r     s   z#_np_concatenate.<locals>.<listcomp>znp.concatenatec                    s   g | ]}t  |jqS r4   )r
   r   rK   r}   r^  r  r4   r5   r     s     c                    s   g | ]}t  |jqS r4   r
   r   r   r  r  r4   r5   r     s     c                    s   g | ]}t  |qS r4   )r
   r   r  r  r4   r5   r     s   r   rH  c                    s   g | ]}|  qS r4   r4   r  )r  r4   r5   r     s     r7   Fr  z<np.concatenate(): input sizes over dimension %d do not matchc                    s   g | ]}  |qS r4   )r2   r  r  r4   r5   r     s     )rU   r   r  r.   r   r/   r2   rg  r  r  r(  r   r
   r  rd  r   r5  r  r  r   r  r   r   )ra   r1   r  r  r
  r  rU   r	  r
  r  r  Zret_shape_ptrZret_shZother_shapesZon_axisZon_other_dimr   is_okr  r4   )r1   ra   r  r5   _np_concatenate  s\    

 $    r  c                    s  |j }td}td}tt|}	 fddt||D }t d||}t |d j}
|dd  D ]n}tj}tt |j|
D ]N\}} 	| 
d||} j |dd j td	 W 5 Q R X qqp fd
d|D }ttj|t }t }t|d D ]l}t|} 
d||}|
| } | |||} |t |d|  |t |d| q$ |t |d|  |	t |d| t  |}|gt| }t  |} fddtt|D }t|d D ]l}t|} 
d||} | |||}tt|D ]*} || | t || d| qZqtt|D ]"} |t || d| q fdd|D }t |||||||	}t || S )Nr   r7   c                    s"   g | ]\}}t | |d qS r  r  r  r~   r4   r5   r     s   z_np_stack.<locals>.<listcomp>znp.stackrH  Fr  )z5np.stack(): all input arrays must have the same shapec                    s   g | ]}t  |jqS r4   r  r  r  r4   r5   r     s     r  c                    s   g | ]}t  qS r4   r  rD  )r1   r  r4   r5   r     s   c                    s   g | ]}t   |qS r4   )r
   r   r2   )r}   r   r  r4   r5   r     s   )rU   r
   r   r   r   r  r   rK   r  rd  r   r   r5  r  r  r   r   r  rA   r.   r>  r(  r   rN   r2   r  r   r   )ra   r1   r  r  r
  r  rU   r   rN  Z
ll_narraysr  r^  r  r   Zorig_shr  Zinput_shapesr  r  r  r  rr   Zinput_stridesrS   r  r4   )r1   ra   r  r5   	_np_stack  s    

 






    r  c              	   C   s8   |  tjd}t| |t|jd t||d |j|S r   )	r   r   ro   r  r   r   r
   r   r   ra   r1   rE   r   r  r4   r4   r5   np_concatenate  s    r  c              	   C   sF   |  ||d |jd tj}t| |t|jd t||d |j|S r.  )	rn   r   r   ro   r  r   r
   r   r   r  r4   r4   r5   np_concatenate_axis#  s    r  c                 C   s   t |jd }t||d }g }g }| tjd}t||D ]t\}	}
|	jdkrf|	|	 |	|
 q>|	jdkstt
|	jdd}t||	}t| |||
f|}|	| |	| q>t| ||||j|S )Nr   r7   r  r)  )r   r   r
   r   r   r   ro   r   rU   rO   ry   r  r   r    r  r  r   )ra   r1   rE   r   Zorig_arrtysZ	orig_arrsr  r  r  r]  r^  rN  
expand_sigZnewarrr4   r4   r5   np_column_stack-  s&    



 r  c              	   C   s*   t | |t|jd t||d |j|S )z/
    np.stack() with the given axis value.
    r   )r  r   r   r
   r   r   r  r4   r4   r5   _np_stack_commonI  s    r  c                 C   s   |  tjd}t| ||||S r   )r   r   ro   r  r  r4   r4   r5   np_stackT  s    r  c                 C   s,   |  ||d |jd tj}t| ||||S r&  )rn   r   r   ro   r  r  r4   r4   r5   np_stack_axisZ  s    r  c                    sj   |j d }|d j}|dkr:| tjd t| ||| S |dkrFdnd  fdd}| ||||S d S )Nr   r7   c                    s   t j|  dS r  r  r  r  r4   r5   np_hstack_impln  s    z!np_hstack.<locals>.np_hstack_implr   rU   r   r   ro   r  r  )ra   r1   rE   r   r   rU   r  r4   r  r5   	np_hstack`  s    

r!  c                 C   sd   |j d }|d j}|dkr&dd }n.|dkrL| tjd}t| ||||S dd }| ||||S )Nr   c                 S   s   t t | dS r&  )r  r  hstackr  r4   r4   r5   np_vstack_implz  s    z!np_vstack.<locals>.np_vstack_implr7   c                 S   s   t j| ddS )Nr   r  r  r  r4   r4   r5   r#    s    r   )ra   r1   rE   r   r   rU   r#  r  r4   r4   r5   	np_vstackt  s    


r$  c                 C   s   |j d }|j}|d j}|dkr:dd }| ||||S |dkr| tjd}|j|jd d}	tj	|	f|j  }
t
| ||
||}| tjd}t	||	}t| |||f|S |dkr| tjd}t
| ||||S dd }| ||||S d S )Nr   c                 S   s   t | dddS )Nr7   r  )r  r"  r  r  r4   r4   r5   r#    s    z!np_dstack.<locals>.np_vstack_implr7   r)  r  c                 S   s   t j| ddS )Nr  r  r  r  r4   r4   r5   r#    s    )r   r   rU   r  r   r   ro   r  r   r    r  r  )ra   r1   rE   r   r   r
  rU   r#  r  Zstack_rettyZ	stack_sigZ	stack_retr  r4   r4   r5   	np_dstack  s&    

r%  fillc                 C   s   dd }|S )Nc                 S   s   || d d < d S r   r4   )r^  rk   r4   r4   r5   	fill_impl  s    zarr_fill.<locals>.fill_implr4   )r^  rk   r'  r4   r4   r5   arr_fill  s    r(  dotc                 C   s   dd }|S )Nc                 S   s   t | |S r   )r  r)  )r^  otherr4   r4   r5   dot_impl  s    zarray_dot.<locals>.dot_implr4   )r^  r*  r+  r4   r4   r5   	array_dot  s    r,  c                 C   s"   t | std|  dd }|S )NzCannot np.fliplr on %s typec                 S   s4   t | }|jdk rtd|d d d d ddf S )Nr  r  r  .r  r  rU   r   r  r  r4   r4   r5   r    s    

znp_flip_lr.<locals>.implrQ  rR  r4   r4   r5   
np_flip_lr  s    r/  c                 C   s"   t | std|  dd }|S )NzCannot np.flipud on %s typec                 S   s.   t | }|jdk rtd|d d ddf S )Nr7   zInput must be >= 1-d.r  .r-  r.  r4   r4   r5   r    s    

znp_flip_ud.<locals>.implrQ  rR  r4   r4   r5   
np_flip_ud  s    r0  c                    sN   t |tjst|t|j tjtj d|} fdd}||fS )zY Creates a tuple of slices for np.flip indexing like
    `(slice(None, None, -1),) * sz` r  c                    sX   dd }t jg}tjf| }| t j}| }| |g}	| ||||	}
|
S )Nc                 S   s*   |}t | D ]}t||td d d}q|S )Nr  )r.   r(   r   )lengthempty_tupler   rS   r4   r4   r5   r    s    z6_build_flip_slice_tuple.<locals>.codegen.<locals>.impl)r   ro   r   r    r   Zget_constant_undefr  )ra   r1   r    r   r  Zinner_argtypesZ	inner_sigZll_idx_typer2  Z
inner_argsr   rs   Z
tuple_typer4   r5   r    s    

z(_build_flip_slice_tuple.<locals>.codegen)	rv   r   IntegerLiteralr	   ZRequireLiteralValuer   r  r  Zslice3_type)rk  szrE   r  r4   r3  r5   _build_flip_slice_tuple  s    

r6  c                 C   s&   t | tjstd|  dd }|S )NzCannot np.flip on %s typec                 S   s   t | j}| | S r   )r6  rU   )r  slr4   r4   r5   r    s    
znp_flip.<locals>.impl)rv   r   rw   r	   r  rR  r4   r4   r5   np_flip  s    r8  c                 C   s   t | tjtjtjfr$d	dd}|S t |tjr>d
dd}|S t |tjrht |jjtjrhddd}|S t |tj	rt
dd |jD rddd}|S d S )Nr   c                 S   s   t jt | ||dS r  )r  array_splitr  r   indices_or_sectionsr  r4   r4   r5   r    s
    znp_array_split.<locals>.implc                 S   sP   t | j| |\}}tt|d g| |g|| d   }tj| ||dS )Nr7   r  )divmodrK   r  Zcumsumr   r9  )r   r;  r  r  r  r   r4   r4   r5   r    s    c              	   S   sb   t | j}t }d}|D ](}t||t||}|| |  |}q|| t||t|d   |S r   )r)   rU   r   r(   r   rO   r   r;  r  Z	slice_tupr   prevrZ  rr   r4   r4   r5   r  *  s    
c                 s   s   | ]}t |tjV  qd S r   rv   r   rx   )r}   tr4   r4   r5   r   9  s     z!np_array_split.<locals>.<genexpr>c              	   S   sf   t | j}t }d}t|D ](}t||t||}|| |  |}q|| t||t|d   |S r   )r)   rU   r   r   r(   r   rO   r=  r4   r4   r5   r  ;  s    
)r   )r   )r   )r   )rv   r   r  ListTyperd  rx   ZIterableTypeZiterator_typer   r  r  r   r;  r  r  r4   r4   r5   np_array_split  s*    





rC  c                 C   sP   t | tjtjtjfr$ddd}|S t |tjr>ddd}|S t| ||dS d S )Nr   c                 S   s   t jt | ||dS r  )r  splitr  r:  r4   r4   r5   r  N  s    znp_split.<locals>.implc                 S   s4   t | j| |\}}|dkr$tdtj| ||dS )Nr   z0array split does not result in an equal divisionr  )r<  rK   r   r  r9  )r   r;  r  rY  r  r4   r4   r5   r  T  s      r  )r   )r   )rv   r   r  rA  rd  rx   rC  rB  r4   r4   r5   np_splitI  s    


rE  c                 C   s   t |p| |k S r   )r  isnanr  r4   r4   r5   	lt_floatsj  s    rG  Fc                 C   s   | ||f}z
t | W S  tk
r   | dkrLtj|r8tnd|dd}|j}n$| dkrptj|r`tnd|d}|j}|t |< | Y S X dS )z6
    Get a sort implementation of the given kind.
    r%   NT)lt
is_argsortZis_np_arrayr&   )rH  rI  )	_sortsKeyErrorr%   Zmake_jit_quicksortrG  Zrun_quicksortr&   Zmake_jit_mergesortZrun_mergesort)r  is_floatrI  keyrU  funcr4   r4   r5   get_sort_funcn  s&    



rO  z
array.sortc                    s<   |j d }tdt|jtjd  fdd}| ||||S )Nr   r%   )r  rL  c                    s    |  d S r   r4   r  Z	sort_funcr4   r5   array_sort_impl  s    z#array_sort.<locals>.array_sort_impl)r   rO  rv   r_   r   r  r  )ra   r1   rE   r   rc  rQ  r4   rP  r5   
array_sort  s    
rR  c                 C   s   dd }|  ||||S )Nc                 S   s   |   }|  |S r   )r  rU  )r  r   r4   r4   r5   np_sort_impl  s    znp_sort.<locals>.np_sort_implr#  )ra   r1   rE   r   rS  r4   r4   r5   np_sort  s    rT  zarray.argsortc           	         sb   |j \}}t|jt|jtjdd  fdd}|j|j d d d}|d d }| ||||S )NT)r  rL  rI  c                    s    | S r   r4   r  rP  r4   r5   array_argsort_impl  s    z)array_argsort.<locals>.array_argsort_implr7   r  )	r   rO  r  rv   r_   r   r  replacer  )	ra   r1   rE   r   rc  r  rU  ZinnersigZ	innerargsr4   rP  r5   array_argsort  s    
 rW  c                 C   s   |j |j ks|jdkst|S )Nr  )r  rW  ry   )ra   r1   r  r  rk   r4   r4   r5   array_to_array  s    rX  c                 C   s4   dd }t ||}| ||||g}t| ||j|S )Nc                 S   s
   |  dS r   )taker!  r4   r4   r5   r    s    zarray0d_to_scalar.<locals>.impl)r    r  r   r   ra   r1   r  r  rk   r  rE   r   r4   r4   r5   array0d_to_scalar  s    
r[  c                 C   s4   dd }t ||}| ||||g}t| ||j|S )Nc                 S   s   t | d S r'  )r  r!  r4   r4   r5   r    s    z array_to_unichrseq.<locals>.impl)r    r  r   r   rZ  r4   r4   r5   array_to_unichrseq  s    
r\  c                 C   s   t dS )zR
    An intrinsic returning a derived array with the given shape and strides.
    Nr
  r  rK   r   r4   r4   r5   reshape_unchecked  s    r^  c                    s   dd   fdd}|S )Nc                 S   s   t | tjotdd | D S )Nc                 s   s   | ]}t |tjV  qd S r   r?  r  r4   r4   r5   r     s     z>type_reshape_unchecked.<locals>.check_shape.<locals>.<genexpr>)rv   r   r   r  rK   r4   r4   r5   r	    s    z+type_reshape_unchecked.<locals>.check_shapec                    sJ   t | tjsd S  |r  |s$d S t|t|kr8d S | jt|ddS )Nr  r  )rv   r   rw   r   r  r]  r	  r4   r5   typer  s    z%type_reshape_unchecked.<locals>.typerr4   )ra   ra  r4   r`  r5   type_reshape_unchecked  s    	rb  c                 C   s   |j d }|j}t|| ||d }t|| |}t||d }t||d }	t||j||	|j|jd |	 }
t
| |||
S )Nr   r7   r  r  )r   r   r]   r
   r   r   rz   r   r   r   r   )ra   r1   rE   r   r   r
  r   r   rK   r   r   r4   r4   r5   impl_shape_unchecked  s    
rc  c                    s`   |d t jfkrtdd  ntdd  |d t jfkr@tdntdd d	 fdd	}|S )
Nc                 S   s   | j S r   r_  r  rK   r4   r4   r5   r    s    zas_strided.<locals>.get_shapec                 S   s   |S r   r4   rd  r4   r4   r5   r    s    z*as_strided() strides argument is mandatoryc                 S   s   |S r   r4   )r  r   r4   r4   r5   get_strides  s    zas_strided.<locals>.get_stridesc                    s   t |  | || |} | S r   )r^  )r  rK   r   r  re  r4   r5   as_strided_impl  s    z#as_strided.<locals>.as_strided_impl)NN)r   r  r!   r=   )r  rK   r   rg  r4   rf  r5   
as_strided  s    


rh  c                 C   s   t | tjrdd }|S d S )Nc                 S   s6   | j dkrdS | j dkr&t| dS d}t|d S )Nr   Fr7   z[The truth value of an array with more than one element is ambiguous. Use a.any() or a.all())rs   r   rY  r   )r^  r   r4   r4   r5   r  %  s    

zol_bool.<locals>.implr   r  r4   r4   r5   ol_bool"  s    	ri  c                    sn   t |ttjfstdt |ttjfs4tdt | tjsJtd| jtt	  fdd}|S )Nz.The second argument "axis1" must be an integerz-The third argument "axis2" must be an integerr  c                    s|   |kst |krtd|ks0t |kr8td|dk rH|7 }|dk rX|7 }t ||}t|||}t| |S )NzIThe second argument "axis1" is out of bounds for array of given dimensionzHThe third argument "axis2" is out of bounds for array of given dimensionr   )r  r   r(   r  r  )r^  axis1axis2Z
axes_tupleZ	axes_listrU   r4   r5   r  @  s    znumpy_swapaxes.<locals>.impl)
rv   r   r   rx   r	   r  rw   rU   r   r.   )r^  rj  rk  r  r4   rl  r5   numpy_swapaxes1  s    


rm  c                 C   s  |dk r| j | }t| j}d||< tt||jD ]H\}\}}	|dkrN|	}
n"|	dkr\|}
n||	krltd|}
t|||
}q4t||| j| }t| |} t||}|}t	|dkrt
t	|D ]}t||| j| }q|}t	|dkrt
t	|D ]}t||| j|d |  }q|j| }t||f | | j}td d d f}t|D ]h}t|D ]V}| || |  }||| |  }||| |  }t
|D ]}|||  ||< qqbqT|S )Nr   r7   z*`arr` and `indices` dimensions don't match)rU   r   rK   r  r   r   r(   r  r  r   r.   r\  r_   r   r)  )r^  r   r  ZNi_origZNk_origindices_broadcast_shapeZ	arr_shaperS   d1Zd2new_valZarr_broadcast_shapeNiNkJr   Znp_s_iikkZa_1dZ
indices_1dZout_1djr4   r4   r5   _take_along_axis_implU  sZ    

    
rw  c                    s  t | tjstdt |tjs,tdt |jtjsDtdt|rRd}n| j}||jkrltdt	t
|jt|rfdd}nt|d t |tjstd	|j}|d
k r| j| }|d
k s|| jkrtdt	t
| t	t
|d | j fdd}|S )Nr  z.The second argument "indices" must be an arrayz'The indices array must contain integersr7   z;`indices` and `arr` must have the same number of dimensionsc                    s   t |  |ddd S )Nr   r4   )rw  r  r^  r   r  )rn  r4   r5   take_along_axis_impl  s    z1arr_take_along_axis.<locals>.take_along_axis_implr  zaxis must be a literal valuer   zaxis is out of boundsc                    s   t | || S r   )rw  rx  rq  rr  rn  r4   r5   ry    s    )rv   r   rw   r	   r  r_   rx   r   rU   r   r.   r   r4  r  r  )r^  r   r  Zarr_ndimry  r4   rz  r5   arr_take_along_axis  s<    






r{  )N)N)N)r  )r7   )N)N)NNN)NNN)N)N)N)N)N)NNN)r   )r   )F)NN(  r  r  r  r  Zllvmliter   Zllvmlite.irr   Znumpyr  Znumbar   r   Z
numba.corer   r   r   r	   r
   r   Znumba.np.numpy_supportr   r   r   r   r   r   r   r   r   Znumba.core.imputilsr   r   r   r   r   r   r   r   r   r   r   Znumba.core.typingr    Znumba.core.extendingr!   r"   r#   r$   Z
numba.miscr%   r&   Znumba.cpythonr'   Znumba.cpython.unsafe.tupler(   r)   Znumba.core.overload_gluer*   r+   Znumba.core.typing.npydeclr,   rq  r-   rr  r6   r9   r]   rc   ri   rl   ru   r|   r   r   r   r   r   r   ZArrayIteratorZBORROWEDr   r   r   r   r  rx   r   r   r   r   r4  Anyr   r   r  rw   r  r  r%  r	  r  r%  r)  r-  r8  r@  r   r[  r_  rb  rc  re  r  r  r  r  r  r  r  r  r  r  Zbroadcast_shapesr(  r  r   r  r  r  r  ZVarArgr  r  r  r  Zlogspacer  Zrot90r  r  r	  r  r  r  r  rO   r  r   r  r$  r&  r1  r3  rD  rC  rE  rP  rK   rS  uniquerY  rf  re  r[  rh  rl  rm  rr  r  rw  ry  Z
MemoryViewr{  r|  r}  r~  r  r  r  r  r  r  r  r  r  ZCPointerrS  r  r  r  r  r  r  r  r  r  r  r  ZDTyper  ZStringLiteralr  r  r  r  r  r4  r  r  r  r  r  ZBytesr  is_r  r  r  r  r  r&  r-  r  rA  r=  rB  rD  rE  rF  r  rI  rG  rJ  r)  rL  rN  rK  rO  r  rP  ZNumpyNdIterTyperQ  rU  r[  rT  rY  ra  rb  r  re  rk  r\  ro  rt  ru  r'  rv  rw  ry  rz  r}  r~  r  r  r  r  r  r  r:  r  r  r  r  r  r  r  r  r  Zeyer  r  r  r  rY  r  r  rd  r  r  Zaranger  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  Z
frombufferr  r  r  r  r  r  r  r   r  r  r  r  r  r  r  r  Z
atleast_1dr  Z
atleast_2dr  Z
atleast_3dr  r  r  r  r  r  r  Zcolumn_stackr  r  stackr  r  r"  r!  Zvstackr$  Zdstackr%  r(  r,  r  r/  r  r0  r6  Zflipr8  r9  rC  rD  rE  rJ  rG  rO  rR  rU  rT  ZargsortrW  rX  ZUnicodeCharSeqr  r  rA  ZNPTimedeltaZ
NPDatetimer[  r\  r^  Ztype_callablerb  rc  libZstride_tricksrh  r   ri  r  rm  rw  Ztake_along_axisr{  r4   r4   r4   r5   <module>   s    4<	
E



>

(





22=QEz+
*>%



(

9}


6


$
@









y
~

	
,




+
*





































7

	
7'	   "  JA X







O0









)
C	%A

&4
))	=2Y		"	



<



#<
