B
     \                @   s  d Z ddlmZmZmZ ddlZddlZddlZddlm	Z	 ddl
m  mZ ddl
mZ ddl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 ddl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* dd
l+m,Z, ddl-m.Z.m/Z/m0Z0 ddl1m2Z2m3Z3m4Z4 dd Z5dd Z6dd Z7dd Z8dd Z9dd Z:dd Z;dd Z<dd Z=dd d!Z>d"d# Z?e!d$ej@d%d& ZAd'd( ZBe!d)ejCe'd*d+ ZDd,d- ZEd.d/ ZFd0d1 ZGe!ejHej@ejIe!ejHej@ejJd2d3 ZKe!ejHej@ejLd4d5 ZMe!ejNej@ejOejOd6d7 ZPe!eQej@d8d9 ZRe!d:ejSd;d< ZTe!d=ejSejOd>d? ZUG d@dA dAeVZWG dBdC dCeWZXG dDdE dEeWZYG dFdG dGeWZZG dHdI dIeWZ[G dJdK dKeWZ\G dLdM dMeVZ]dNdO Z^e!ejHej@ejSdPdQ Z_dRdS Z`dTdU ZadVdW ZbdXdY ZcdZd[ Zdd\d] Zed^d_ Zfd`da Zgdbdc Zhddde Zie!dfejSdgdh Zjdidj Zke!dfejSejLdkdl Zle!dfejSemejOdmdn Zne/ejoddodpZpe"ejSdqdrds Zqdtdu Zrdvdw Zse!dxejSejLdydz Zte!dxejSemejOd{d| Zue/ejvd}d~ Zwe!dejSdd Zxe!ejyejSdd Zze!dejSdd Z{dd Z|e/ej}dd Z~e!dejSejdd Ze"ejSddd Ze"ejSde"ejddd Ze"ejSde"ejddd Ze"ejSde"ejddd Ze"ejSddd Ze"ejSd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jSddd Ze"ejddd Ze%ejeje%ejejdd Zdd Ze"ejSddd Ze"ejde"ejddd Ze"ejddd Ze"ejSddd Ze"ejSdÃddń Ze0ejSdƃe0ejSdǃddɄ Zdd˄ Ze"ejd̃dd΄ Ze"ejdσdd΄ Ze#ejSdd҄ Ze!dejSejddՄ Ze#ejddׄ Ze$ejddل Ze!dejejddۄ Ze!dejejejOddބ Ze&ejSdd Ze&ejdd Ze!ejejSejSdd Zdd Zdd ZdddZdddZdd Zdd Zdd Ze"ejSddd Ze!d)eje'dd Ze!ejHejejIdd Ze!ejNejejIejOdd Ze!eQejdd Ze!ejejSdd Ze!d)eje'dd Ze!eemejIe!ejemejIdd  Ze!eejLe!ejejLdd  Ze!d)eje'dd Ze!ejejOdd Ze!d)eje'dd Zdd Zd	d
 Zdd Zdd Zdd Ze!ejejOe!ejejOejOdd Ze!ejejOe!ejejOejdd Ze!ejejOe!ejejOejOdd Ze!ejejOe!ejejOejdd Zedk
rfe!ejejOejOdd Ze!ejejOejOejdd Ze!ejejOejOdd Ze!ejejOejOejd d Ze!ejejOd!d" Ze!ejejOejd#d$ Ze!ejejOd%d& Ze!ejejOejd'd( Ze!ejejId)d* Ze!ejejIejd+d* Zؐd,d- Ze/e١d.d/ Ze/ejۡddefd0d1Ze!ejejSd2d3 Ze!ejejSejId4d5 Ze!ejejSejIe!d6ejSejId7d8 Ze!d6ejSejSe!ejejSejSd9d: Ze!d6ejSeje!ejejSeje!d6ejSejLe!ejejSejLd;d< Ze!ejejd=d> Ze!ejejejd?d@ Ze!ejejejejdAdB Ze!ejejejejejdCdD Ze!ejejejdEdF Ze!ejejejejIdGdH ZdIdJ Ze!dKejSdLdM Ze!ejejSdNdO ZdPdQ Ze!ejejSdRdS Ze!ejejSdTdU Ze!dVejSejdWdX Ze!ejej@e!ejej@ejdYdZ Ze!eejOejOe!eejOejOeje!eejOejOe!eejOejOejd[d\ Zd]d^ Zd_d` Zdadb Zdcdd Zdedf Z e!ejejOe!ejejOejdgdh Zdidj Zdkdl Zdmdn Zdodp Ze!ejejSejIdqdr Zdsdt Zdudv Z	e!ej
emejSdwdx Ze!ejemejSdydz Ze!ejemejSd{dz Zd|d} Zd~d Zdd Ze!ejejLdd Ze!ejejLejIdd Ze!ejejLdd Zdd ZedkrNe!ejejLdd Ze!ejejLejIdd Ze!ejejLdd Ze!ejejLdd Ze!ejejLdd Z e0ejSddd Z!e0ejSddd Z"i Z#dd Z$dddZ%e!dejSdd Z&e!ej'ejSdd Z(e!dejSeje!ej)ejSejdd Z*e%ejSejSdd Z+dd Z,e-e,dd Z.e!e,ejSejLejLdd Z/e/ej0j1j2dddZ2dS (  z[
Implementation of operations on Array objects and objects supporting
the buffer protocol.
    )print_functionabsolute_importdivisionN)ir)Constant)typescgutilstypingutils	extendingpndindex)as_dtypecarrayfarrayis_contiguous
is_fortran)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)	signature)register_jitableoverloadoverload_method   )	quicksort	mergesortslicingc             C   s8   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   inttypemoduleZadd_metadataZset_metadata)builderloadZlower_boundupper_boundZrange_operandsZmd r,   5lib/python3.7/site-packages/numba/targets/arrayobj.pyset_range_metadata!   s    r.   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!   r   N)r'   widthr.   )r)   r*   r+   r,   r,   r-   mark_positive,   s    r0   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 }y| jd|}W n  tk
r<   t | |S X | jj }| |}|d krptj	| j
|dd}n|}|| j
|f}||fS )NZ	__array__T)zfill)r   _contextget_functionNotImplementedErrorsuper
_make_refsZ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_typer,   r-   r6   B   s    

z*make_array.<locals>.ArrayStruct._make_refsc                st   | j }dkr | dS | d}g }x>tD ]2}t||d|}||}|| t|| q2W t	||S )z\
            Override .shape to inform LLVM that its elements are all positive.
            r   shape)
r8   __getattr___get_ptr_by_namer%   r   gep_inboundsr*   appendr0   
pack_array)r9   r)   ptrdimsiZdimptrr*   )basendimr,   r-   rA   U   s    


z%make_array.<locals>.ArrayStruct.shape)__name__
__module____qualname__r6   propertyrA   __classcell__r,   )r=   r?   rJ   rK   r@   )r>   r-   r=   @   s   r=   )Zas_arrayr   create_struct_proxyrK   )r?   r,   )r=   r?   rJ   rK   r@   r-   
make_array4   s
    
,rR   c             C   s   |  |j}| |S )zB
    Return the item size for the given array or buffer type.
    )get_data_typedtypeget_abi_sizeof)contextr?   Zlltyr,   r,   r-   get_itemsizeo   s    rW   c             C   s"   |j r
dnd}| j||j||dS )z3
    Load the item at the given array pointer.
    Nr!   )align)alignedunpack_valuerT   )rV   r)   arraytyrG   rX   r,   r,   r-   	load_itemw   s    r\   c             C   s$   |j r
dnd}| j||j|||dS )z4
    Store the item at the given array pointer.
    Nr!   )rX   )rY   
pack_valuerT   )rV   r)   r[   valrG   rX   r,   r,   r-   
store_item   s    r_   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)rV   r)   idxtyidxsizeindr,   r,   r-   fix_integer_index   s
    rh   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   ArrayrK   rT   IntegerAssertionErrorrR   r\   data)rV   r)   rd   re   idxaryZidxvalr,   r,   r-   normalize_index   s    
ro   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 r,   )ro   ).0rd   re   )r)   rV   r,   r-   
<listcomp>   s   z%normalize_indices.<locals>.<listcomp>)lenzip)rV   r)   index_typesindicesr,   )r)   rV   r-   normalize_indices   s    rv   c             C   sh  | j }| j}| j}	t|	j}
|dkr:t||	d}|t	j
}t|ttfrbt|||}t|ttfr~t|||}t|tjr||}t|||||d}|dkrt||	d|d< n||d< |t	j
d}t|||jj}x|D ]}|j||dgd}qW ||d< t| }||
kr@td	|
| x"| D ]\}}t| || qJW | S )
z
    Helper function for populating array structures.
    This avoids forgetting to set fields.

    *shape* and *strides* can be Python tuples or LLVM arrays.
    Nmeminfo)rA   stridesrm   itemsizerw   parentr!   nsw)flagsnitemszmissing {0})r2   r8   
_datamodelset_fieldsr   Znullget_value_typeget_typer   rb   ri   tuplelistr   rF   r
   Z	INT_TYPESdictget_constantunpack_tupler'   countmulkeys
ValueErrorformatitemssetattr)arrayrm   rA   rx   ry   rw   rz   rV   r)   r<   Zrequired_fieldsintp_tZattrsr}   unpacked_shapeaxlenZ
got_fieldskvr,   r,   r-   populate_array   sD    


r   c             C   sl   |j }|j}|tjd}t||j| j}x|D ]}|j	||dgd}q2W ||_
|tjt|| |_dS )z
    Update some auxiliary information in *array* after some of its fields
    were changed.  `itemsize` and `nitems` are updated.
    r!   r{   )r|   N)r2   r8   r   r   rb   r   r   rA   rK   r   r}   rW   ry   )arytyr   rV   r)   r}   r   r   r,   r,   r-   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   rb   r   alloca_once_valueindexr   
enable_nrtnrtZincref	_getvaluer   )rV   r)   r;   r   r[   r   iterobjzeroZindexptrresoutr,   r,   r-   getiter_array   s    r   c             C   s$   t j||||g|d}t| |||S )z8
    Look up and return an element from a 1D array.
    )
wraparound)r   get_item_pointerr\   )rV   r)   r[   r   re   r   rG   r,   r,   r-   _getitem_array1d  s    r   Ziternextc          	   C   s   |j \}|\}|j}|jdkr,td|j | j|||d}t|| ||jd}	tj||	j	dd\}
|
|j}|tj||
}|| ||> t| |||	|dd}|| t||}|||j W d Q R X d S )Nr!   ziterating over %dD array)value)r   F)r   )r   r?   rK   r4   r   rR   r   r   r   rA   r*   r   icmplcICMP_SLT	set_validif_thenr   yield_increment_indexstore)rV   r)   r;   r   resultZitertyiterr[   r   aryr}   r   is_validr   Znindexr,   r,   r-   iternext_array  s"    


r   c             C   s  |  tjd}t||j|j}t||j|j}g }	g }
g }d}x:t||D ]*\}}|tj	kr|jt
| d }x>t|D ]2}|	| |
||  |||  |d7 }qW qPt|tjr8| j|||d}t| ||| t||||  |	|j t||}t|||| }|
| || n<t|tjrft| ||||| }|	| ntd|f |d7 }qPW ||jkstx6||jk r|
||  |||  |d7 }qW tj||||	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   r!   )r   zunexpected index type: %sF)r   )r   r   rb   r   r   rA   rK   rx   rs   ellipsisrr   r%   rE   ri   	SliceTyper   r$   guard_invalid_slice	fix_slicestartget_slice_lengthZ
fix_striderk   rh   r4   rl   r   )rV   r)   r   r   rt   ru   r   shapesrx   Zoutput_indicesZoutput_shapesZoutput_stridesaxindexvalrd   	n_missingrI   sliceshstrg   dataptrr,   r,   r-   basic_indexing6  sP    





r   c       	   	   C   s.   t || |}t|||||j|j|jd |S )zF
    Build a view over the given array with the given parameters.
    )rm   rA   rx   ry   rw   rz   )rR   r   ry   rw   rz   )	rV   r)   r   r   r   rm   r   rx   retaryr,   r,   r-   	make_viewq  s    
r   c          	   C   s\   t | |||||\}}}	t|tjrBt| |||||||	}
|
 S |rJtt| |||S dS )zp
    Return the result of indexing *ary* with the given *indices*,
    returning either a scalar or a view.
    N)r   ri   r   Bufferr   r   rl   r\   )rV   r)   r   r   r   rt   ru   r   Zview_shapesZview_stridesr   r,   r,   r-   _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.
    r!   )r   rK   rl   rR   r   r   r   )	rV   r)   r;   r   r   rd   r   re   r   r,   r,   r-   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)ri   r   rj   )rp   tyr,   r,   r-   	<genexpr>  s    z&getitem_array_tuple.<locals>.<genexpr>)r   rR   r   r   r   rr   rv   anyfancy_getitemr   r   r   )rV   r)   r;   r   r   tuptyr   tuprt   ru   r   r,   r,   r-   getitem_array_tuple  s    


r   c             C   s   |j \}}}|\}}}	t|tjr>|j}
tj||t|d}n|f}
|f}t|| ||}t| ||
|\}
}yt	| ||||
|\}}}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   TN)r   ri   r   	BaseTupler   r   rr   rR   rv   r   r4   boolfancy_setslicera   rT   r_   )rV   r)   r;   r   r   rd   valtyr   re   r^   rt   ru   r   r   rx   Zuse_fancy_indexingr,   r,   r-   setitem_array  s(    


r   c       	      C   sD   |j \}|\}t|}|| ||}|j}||d}t| ||j|S )Nr   )r   rR   rA   extract_valuer   r   )	rV   r)   r;   r   r   r   ZarysttyZshapearyr   r,   r,   r-   	array_len  s    r   z
array.itemc          	   C   st   |j \}|\}t|| ||}|j}|j|d||ddd d}| j|t|f W d Q R X t	| |||j
S )Nz!=r!   F)likelyz>item(): can only convert an array of size 1 to a Python scalar)r   rR   r}   r   icmp_signedr'   	call_convreturn_user_excr   r\   rm   )rV   r)   r;   r   r   r   r}   msgr,   r,   r-   
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 d Q R X t| ||||j |  S )Nz!=r!   F)r   z/itemset(): can only write to an array of size 1)r   rT   rl   rR   r}   r   r   r'   r   r   r   r_   rm   get_dummy_value)
rV   r)   r;   r   r   r   r   r^   r}   r   r,   r,   r-   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)r4   )r9   r,   r,   r-   prepare  s    zIndexer.preparec             C   s   t dS )z=
        Return this dimension's size as an integer.
        N)r4   )r9   r,   r,   r-   get_size#  s    zIndexer.get_sizec             C   s   t dS )z;
        Return this dimension's shape as a tuple.
        N)r4   )r9   r,   r,   r-   	get_shape)  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.
        N)r4   )r9   r,   r,   r-   get_index_bounds/  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.
        N)r4   )r9   r,   r,   r-   	loop_head6  s    	zIndexer.loop_headc             C   s   t dS )z)
        Finish indexation loop.
        N)r4   )r9   r,   r,   r-   	loop_tailA  s    zIndexer.loop_tailN)
rL   rM   rN   __doc__r   r   r   r   r   r   r,   r,   r,   r-   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 )N)	rV   r)   r   r   dimr   r   rb   ll_intp)r9   rV   r)   r   r   r   r,   r,   r-   __init__M  s    zEntireIndexer.__init__c             C   sB   | j }|| jj| j| _t|| j| _	|
 | _|
 | _d S )N)r)   r   r   rA   r   rf   r   r7   r   r   append_basic_blockbb_startbb_end)r9   r)   r,   r,   r-   r   U  s
    
zEntireIndexer.preparec             C   s   | j S )N)rf   )r9   r,   r,   r-   r   \  s    zEntireIndexer.get_sizec             C   s   | j fS )N)rf   )r9   r,   r,   r-   r   _  s    zEntireIndexer.get_shapec             C   s   |  d| jfS )Nr   )r   rf   )r9   r,   r,   r-   r   b  s    zEntireIndexer.get_index_boundsc          	   C   s~   | j }| j t| jd| j || j || j |	| j}|j
|d|| jdd || j W d Q R X ||fS )Nr   z>=F)r   )r)   r   r   r&   r   r   branchr   position_at_endr*   r   r   rf   r   )r9   r)   	cur_indexr,   r,   r-   r   f  s    
zEntireIndexer.loop_headc             C   sD   | j }t||| j}||| j || j || j	 d S )N)
r)   r   r   r*   r   r   r   r   r   r   )r9   r)   
next_indexr,   r,   r-   r   r  s
    zEntireIndexer.loop_tailN)rL   rM   rN   r   r   r   r   r   r   r   r   r,   r,   r,   r-   r   H  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 )N)rV   r)   re   r   r   rb   r   )r9   rV   r)   re   r,   r,   r-   r     s    zIntegerIndexer.__init__c             C   s   d S )Nr,   )r9   r,   r,   r-   r     s    zIntegerIndexer.preparec             C   s   t | jdS )Nr!   )r   r&   r   )r9   r,   r,   r-   r     s    zIntegerIndexer.get_sizec             C   s   dS )Nr,   r,   )r9   r,   r,   r-   r     s    zIntegerIndexer.get_shapec             C   s   | j | j| j |  fS )N)re   r)   addr   )r9   r,   r,   r-   r     s    zIntegerIndexer.get_index_boundsc             C   s
   | j d fS )N)re   )r9   r,   r,   r-   r     s    zIntegerIndexer.loop_headc             C   s   d S )Nr,   )r9   r,   r,   r-   r     s    zIntegerIndexer.loop_tailN)rL   rM   rN   r   r   r   r   r   r   r   r   r,   r,   r,   r-   r   z  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 )Nr!   )rV   r)   rd   rn   rf   rK   rl   r   r   rb   r   )r9   rV   r)   rd   rn   rf   r,   r,   r-   r     s    zIntegerArrayIndexer.__init__c             C   sD   | j }t|| jjd | _t|| j| _|	 | _
|	 | _d S )Nr   )r)   r   r   rn   rA   idx_sizer7   r   	idx_indexr   r   r   )r9   r)   r,   r,   r-   r     s
    
zIntegerArrayIndexer.preparec             C   s   | j S )N)r   )r9   r,   r,   r-   r     s    zIntegerArrayIndexer.get_sizec             C   s   | j fS )N)r   )r9   r,   r,   r-   r     s    zIntegerArrayIndexer.get_shapec             C   s   |  d| jfS )Nr   )r   rf   )r9   r,   r,   r-   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 d Q R X t| j|| j| j|dd}t| j|| jj|| j}||fS )Nr   z>=F)r   )r   )r)   r   r   r&   r   r   r   r   r   r*   r   r   r   r   r   rV   rd   rn   rh   rT   rf   )r9   r)   r   r   r,   r,   r-   r     s    

zIntegerArrayIndexer.loop_headc             C   sD   | j }t||| j}||| j || j || j	 d S )N)
r)   r   r   r*   r   r   r   r   r   r   )r9   r)   r   r,   r,   r-   r     s    zIntegerArrayIndexer.loop_tailN)rL   rM   rN   r   r   r   r   r   r   r   r   r,   r,   r,   r-   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   sJ   || _ || _|| _|| _|jdks&t| j tj| _	t
| j	d| _d S )Nr!   r   )rV   r)   rd   rn   rK   rl   r   r   rb   r   r   r&   r   )r9   rV   r)   rd   rn   r,   r,   r-   r     s    zBooleanArrayIndexer.__init__c             C   s^   | j }t|| jjd | _t|| j| _t|| j| _	|
 | _|
 | _|
 | _d S )Nr   )r)   r   r   rn   rA   rf   r7   r   r   r   r   r   bb_tailr   )r9   r)   r,   r,   r-   r     s    

zBooleanArrayIndexer.preparec          	   C   s   | j }t|| j}t|| jN}||}t| j|| j	| j
|jdd}|||||j}||| W d Q R X ||S )NF)r   )r)   r   r   r   	for_rangerf   r*   r   rV   rd   rn   r   r   Zzextr'   r   )r9   r)   r   loopcpredr,   r,   r-   r     s    
zBooleanArrayIndexer.get_sizec             C   s
   |   fS )N)r   )r9   r,   r,   r-   r     s    zBooleanArrayIndexer.get_shapec             C   s   |  d| jfS )Nr   )r   rf   )r9   r,   r,   r-   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 d Q R X t| j|| j| j|dd}|	|| || j W d Q R X t||}||| j ||fS )Nz>=F)r   )r   )r)   r   r   r   r   r   r   r   r*   r   r   rf   r   r   rV   rd   rn   not_r   r   r   )r9   r)   r   	cur_countr   
next_countr,   r,   r-   r      s$    

zBooleanArrayIndexer.loop_headc             C   s\   | j }|| j || j t||| j}||| j || j	 || j
 d S )N)r)   r   r   r   r   r   r*   r   r   r   r   )r9   r)   r   r,   r,   r-   r     s    zBooleanArrayIndexer.loop_tailN)rL   rM   rN   r   r   r   r   r   r   r   r   r,   r,   r,   r-   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   sN   || _ || _|| _|| _|| _|| _|| _| j tj	| _
t| j
d| _d S )Nr   )rV   r)   r   r   r   rd   r   r   r   rb   r   r   r&   r   )r9   rV   r)   r   r   r   rd   r   r,   r,   r-   r   '  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 )N)r)   r   r   rA   r   dim_sizer$   r   rV   rd   r   r   r   Z
is_neg_intstepis_step_negativer7   r   r   r   r   r   r   )r9   r)   r,   r,   r-   r   2  s    
zSliceIndexer.preparec             C   s   t | j| jS )N)r$   r   r)   r   )r9   r,   r,   r-   r   @  s    zSliceIndexer.get_sizec             C   s
   |   fS )N)r   )r9   r,   r,   r-   r   C  s    zSliceIndexer.get_shapec             C   s   t | j| j\}}||fS )N)r$   Zget_slice_boundsr)   r   )r9   lowerupperr,   r,   r-   r   F  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 d Q R X ||fS )Nz<=z>=F)r   )r)   r   r   r   r   r   r   r   r   r   r*   selectr  r   stopr   r   )r9   r)   r   r   Zis_finishedr,   r,   r-   r   J  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|   )r)   r   r*   r   r   r  r   r   r   r   r   r   r   r   )r9   r)   r   r   r,   r,   r-   r   \  s    
zSliceIndexer.loop_tailN)rL   rM   rN   r   r   r   r   r   r   r   r   r,   r,   r,   r-   r  "  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 )FancyIndexerz4
    Perform fancy indexing on the given array.
    c          	   C   sD  || _ || _|| _t||j|j| _t||j|j| _| j 	t
j| _g }d}xrt||D ]b\}	}
|
t
jkr|jt| d }x2t|D ]&}t|||||}|| |d7 }qW q`t|
t
jr|||
|	}t||||||
|}|| nt|
t
jr2t|||
|	| j| }t|||}|| nt|
t
jrt|
|||	}t|
jt
jrxt|||
|| j| }n*t|
jt
jrt|||
|}n
dst || nt d|
f |d7 }q`W ||jkst ||jfx4||jk rt|||||}|| |d7 }qW t||jks:t t||jf|| _!d S )Nr   r!   zunexpected index type: %s)"rV   r)   r   r   r   rA   rK   r   rx   r   r   rb   r   rs   r   rr   r%   r   rE   ri   r   r   r  rk   rh   r   rj   rR   rT   r   ZBooleanr   rl   indexers)r9   rV   r)   r   r   rt   ru   r
  r   r   rd   r   rI   indexerr   rg   rn   r,   r,   r-   r   l  s\    





"zFancyIndexer.__init__c             C   s4   x| j D ]}|  qW tdd | j D d| _d S )Nc             S   s   g | ]}|  qS r,   )r   )rp   rI   r,   r,   r-   rq     s    z(FancyIndexer.prepare.<locals>.<listcomp>r,   )r
  r   sumindexers_shape)r9   rI   r,   r,   r-   r     s    zFancyIndexer.preparec             C   s   | j S )z?
        Get the resulting data shape as Python tuple.
        )r  )r9   r,   r,   r-   r     s    zFancyIndexer.get_shapec          	   C   s  t || jjkst| j}tj}| d}| d}|}|}xt| j	| j
|D ]\}	}
}|||d|
|}|	 \}}|||}|||||}|d||}||||||}||||||}qNW |||}||||}||||}||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   r!   z==<)rr   r   rK   rl   r)   r   	false_bitr   rs   r
  r  or_icmp_unsignedr   r   subr   r   r  )r9   rx   ry   r)   is_emptyr   oner  r  r  rA   strideZlower_indexZupper_indexZlower_offsetZupper_offsetZis_downwardsr,   r,   r-   get_offset_bounds  s.    

zFancyIndexer.get_offset_boundsc             C   s    t dd | jD  \}}||fS )Nc             s   s   | ]}|  V  qd S )N)r   )rp   rI   r,   r,   r-   r     s    z+FancyIndexer.begin_loops.<locals>.<genexpr>)rs   r
  )r9   ru   countsr,   r,   r-   begin_loops  s    zFancyIndexer.begin_loopsc             C   s    xt | jD ]}|  qW d S )N)reversedr
  r   )r9   rI   r,   r,   r-   	end_loops  s    zFancyIndexer.end_loopsN)
rL   rM   rN   r   r   r   r   r  r  r  r,   r,   r,   r-   r	  g  s   :"r	  c          	   C   s  t ||j}t ||j}	|j}
t| |||||}|  |j}| }t	| |||}|j}t 
|| tjd}| \}}t j||
||	|j|dd}t| |||}||}|||g}t| |||| t ||}||| |  t| ||| S )Nr   F)r   )r   r   rA   rx   rm   r	  r   r   r   _empty_nd_implr   r   r   rb   r  get_item_pointer2layoutr\   r*   gepr_   r   r   r  r   r   )rV   r)   r;   r   r   r   rt   ru   r   rx   rm   r  Zout_tyZ
out_shapesr   Zout_dataZout_idx_rG   r^   ZcurZnext_idxr,   r,   r-   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   rR   rK   ro   r   r   r   r   )	rV   r)   r;   r   r   rd   r   re   r   r,   r,   r-   fancy_getitem_array  s    



r   c          	   C   s   |j }|d}|d}|jdkr8|}	|||j}
n|}	|}
xht|jD ]Z}||| ||| |}|d||}|	||
|
||
}
|	||	|
|	|}	qLW |
|
|}
|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 mimicks offset_bounds_from_strides() from numpy/core/src/private/mem_overlap.c
    r   r!   CFz>=z==)ry   r'   r  r   r}   r%   rK   r  r   r  r   )rV   r)   arrtyarrr   rx   ry   r   r  r  r  rI   Zmax_axis_offsetZ
is_upwardsr  r,   r,   r-   offset_bounds_from_strides  s*    



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   )rV   r)   r  r  rm   Zdata_ptr_as_intr   endr,   r,   r-   compute_memory_extentsD  s    r'  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$  r'  )	rV   r)   r"  r#  r   rx   rm   r  r  r,   r,   r-   get_array_memory_extentsN  s    
r(  c             C   s$   | |d|||d||}|S )z[
    Whether two memory extents [a_start, a_end) and [b_start, b_end)
    may overlap.
    r  )and_r  )rV   r)   Za_startZa_endZb_startZb_endZmay_overlapr,   r,   r-   extents_may_overlapX  s    r*  c                s  j dt d  jdd  |j|j}j |}	|	j  	|	}	 
|	 tj}
t |
B}t 	
j|}t |	|} 
 || W d Q R X W d Q R X  	
fdd} fdd}||fS )NCF)r   c                s   t | 
jkstt } jddr\}}|,  tj  | dd| W d Q R X |(  tj 	
j	| dd| W d Q R X W d Q R X t
 
 |S )NF)r   )r   )rr   rK   rl   r   r7   if_elser   r  r*   r  r\   )source_indicessrc_ptrZif_copyZ	otherwise)r)   rV   	copy_datacopy_layoutcopy_shapescopy_stridesptrtysrc_data
src_shapessrc_stridessrctyuse_copyr,   r-   src_getitem  s$    z&maybe_copy_source.<locals>.src_getitemc           	      sB    j dd*  }  | } j |  W d Q R X d S )NF)r   )r   r*   bitcastr   Zfree)rm   )r)   rV   r/  r8  	voidptrtyr,   r-   src_cleanup  s    
z&maybe_copy_source.<locals>.src_cleanup)r'   r   r   r   r   ry   r}   r   allocater:  r   r   r   rb   	loop_nestr  r  r*   )rV   r)   r8  r7  srcr5  r6  r4  	allocsizerm   r   ru   r.  dest_ptrr9  r<  r,   )r)   rV   r/  r0  r1  r2  r3  r4  r5  r6  r7  r8  r;  r-   maybe_copy_sourcee  s.    
&"rB  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 d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   r!   c                s   g | ]}  d |qS )z==)r  )rp   r   )r)   r  r,   r-   rq     s   z(_bc_adjust_dimension.<locals>.<listcomp>NF)r   z,cannot broadcast source array for assignment)r   r   rc   rr   	functoolsreducer)  r   true_bitr   r   r   r   r   )
rV   r)   r   rx   target_shaper   Znd_diffZ
dim_is_oneZacceptedr   r,   )r)   r  r-   _bc_adjust_dimension  s$    	
rG  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   r!   c                s   g | ]\}}  d ||qS )z!=)r   )rp   tarold)r)   r,   r-   rq     s   z,_bc_adjust_shape_strides.<locals>.<listcomp>c                s   g | ]}  d |qS )z==)r   )rp   rI  )r)   r  r,   r-   rq     s    c                s   g | ]\}}  ||qS r,   )r)  )rp   xy)r)   r,   r-   rq     s    c                s    g | ]\}}}  |||qS r,   )r  )rp   prH  rI  )r)   r,   r-   rq     s   c                s   g | ]\}}  ||qS r,   )r  )rp   rL  rI  )r)   r   r,   r-   rq     s   )r   r   rc   rs   )
rV   r)   r   rx   rF  Z	bc_shapesZ
bc_stridesmismatchZ
src_is_oneZpredsr,   )r)   r  r   r-   _bc_adjust_shape_strides  s    

rN  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)rK   r  )rA   rx   )r   r   rA   rx   rG  rN  copyrr   rR   r   rF   copy_struct)
rV   r)   arrtyper#  rF  r   rx   Znew_arrtypeZnew_arrreplr,   r,   r-   _broadcast_to_shape  s    

rT  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x,t||D ]\}} | d||}qW  j|dd d}j t|f W dQ R X t |||\}}||
|j\}}t |||\}}t ||||}t ||||\}}nt	t
jrVj| }t|dkst tt!t
j"}| f} d|d |} j|dd d}j t|f W d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.
    z!=F)r   z0cannot assign slice from input of different sizeNr!   r   c                s,   | \} tjttj}| |fS )N)r3   operatorgetitemr   r   rb   )r-  re   getitem_impl)r)   rV   r?  	src_dtyper7  r,   r-   r9  :  s
    z#fancy_setslice.<locals>.src_getitemc               S   s   d S )Nr,   r,   r,   r,   r-   r<  B  s    z#fancy_setslice.<locals>.src_cleanupc                s    S )Nr,   )r-  )r?  r,   r-   r9  J  s    c               S   s   d S )Nr,   r,   r,   r,   r-   r<  M  s    c             s   s   | ]}|d k	r|V  qd S )Nr,   )rp   r   r,   r,   r-   r   T  s    z!fancy_setslice.<locals>.<genexpr>)r   )+r   rR   r   r   rA   rx   rm   r	  r   ri   r   r   rT   r   rT  r  rr   rl   rs   r  r   r   r   r   r   r(  r  ry   r'  r*  rB  Sequencer3   r   rb   r  r   ra   r  r  r_   r  r   )%rV   r)   r;   r   rt   ru   r   r  r   Zdest_shapesdest_strides	dest_datar  Zindex_shaper5  r6  r4  Zshape_errorur   r   Z	src_startZsrc_endZ
dest_lowerZ
dest_upperZ
dest_startZdest_endr8  r9  r<  len_implZseq_lenZdest_indicesr  r-  r^   rA  r,   )r)   rV   r?  rX  r7  r-   r     sz    



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   r!   c                s"   g | ]\}}  ||tjqS r,   )ra   r   rb   )rp   r   r^   )r)   rV   r,   r-   rq   s  s   z#vararg_to_tuple.<locals>.<listcomp>)rT   r   )r   rs   r   rF   r'   r   UniTuplerb   rr   r	   r   r   )rV   r)   r;   r   r   Zdimtysr   rH   rA   shapetynew_signew_argsr,   )r)   rV   r-   vararg_to_tuplel  s    
rb  zarray.transposec             C   s   t | ||jd |d S )Nr   )array_Tr   )rV   r)   r;   r   r,   r,   r-   array_transpose  s    rd  c             C   sr   t | t t| krtdt |}x(| D ] }||ksBt||kr*tdq*W ||  |d d < ||  |d d < d S )Nzrepeated axis in transposez2axis is out of bounds for array of given dimension)rr   r   r   abs)axisrA   rx   r   rJ  r,   r,   r-   permute_arrays  s    
rg  c          
      s  |j d }t| |d }|j d |d  }}|j|j }}	tj}
tj	|
|||j
|jg} fdd|D }x"t||D ]\}} || qW tj|	dddtj|
} fdd|D }xDt||D ]6\}}t| ||
 tj|g|g|d d qW  tttjd	d |D  t|j }t||j |d  |d
 |j|j|jd | }t  |j|S )Nr   r!   c                s   g | ]}t  qS r,   )r   r7   )rp   r  )r)   ll_ary_sizer,   r-   rq     s    z)array_transpose_tuple.<locals>.<listcomp>r+  )rT   rK   r  c                s   g | ]}t  qS r,   )rR   )rp   r  )r)   rV   	np_ary_tyr,   r-   rq     s    )rm   rA   rx   ry   rw   c             S   s   g | ]}|  qS r,   )r   )rp   ar,   r,   r-   rq     s       )rm   rA   rx   ry   rw   rz   )!r   rR   r   rT   r   r   rb   r   Typer   rA   rx   rs   r   rj   r   rU   r   r:  
as_pointercompile_internalrg  r	   r   voidr   rm   r*   ry   rw   rz   r   r   )rV   r)   r;   r   r   r   Zaxistyrf  Znum_axisrT   r   ZarysZll_arysr?  dstZnp_itemsizeZnp_arysZnp_aryZll_aryretr   r,   )r)   rV   rh  ri  r-   array_transpose_tuple  sF    

rr  c             C   s    t | |||\}}t| |||S )N)rb  rr  )rV   r)   r;   r   r`  ra  r,   r,   r-   array_transpose_vararg  s    rs  c             C   s"   |d krddd}n
ddd}|S )Nc             S   s   |   S )N)	transpose)rj  axesr,   r,   r-   np_transpose_impl  s    z*numpy_transpose.<locals>.np_transpose_implc             S   s
   |  |S )N)rt  )rj  ru  r,   r,   r-   rv    s    )N)Nr,   )rj  ru  rv  r,   r,   r-   numpy_transpose  s    
rw  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 )Nr!   )rm   rA   rx   ry   rw   rz   )rK   rR   r   r   rA   rx   r   rm   rF   ry   rw   rz   r   r   )	rV   r)   typr   r   r   rq  r   rx   r,   r,   r-   rc    s    

rc  c             C   s   |  tj}| }|  tj}	tj|	||||||||	g}
|jj	|
d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_reshape)namerA   r   rx   )r   r   rb   rm  Zintcr   rl  Zfunctionr(   Zget_or_insert_functionrK   r   rD   rC   Zcallry   )rV   r)   r   r   newndnewshape
newstridesr   Zll_intp_starZll_intcZfntyfnndrA   rx   Z
is_f_orderr   r,   r,   r-   _attempt_nocopy_reshape  s(    	


r  c       	      C   s   d}d}x2t |D ]&\}}|dk r0|d7 }|}q||9 }qW |dkrV| |krtdnP|dkr|dkrtd}| dk}n| | }| | dk}|std|||< ntdd S )Nr   r!   z)total size of new array must be unchangedzmultiple negative shape values)	enumerater   )	ZorigsizerA   Znum_neg_valueZ
known_sizer   sZneg_axZinferredokr,   r,   r-   normalize_reshape_value  s(    


r  zarray.reshapec          	   C   s  |j d }|j}|j d }|d }| tj}tj||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 d Q R X t	|| |}t||
j#|$||$||
j%|
j&|
j'd | }t(| ||j|S )	Nr   r!   r+  )rT   rK   r  )rm   rA   rx   ry   rw   z==zincompatible shape for array)rm   rA   rx   ry   rw   rz   ))r   r   r   r   rb   r   rl  r   r   rR   r   r7   r   rj   rT   r   rU   r   r:  rm  r}   rn  r  r	   r   ro  rc   r   r  r  r'   r   r   r   r4   rm   r*   ry   rw   rz   r   )rV   r)   r;   r   r   rettyr_  rA   r   Zll_shaper   r}  Zshape_ary_ty	shape_aryZshape_itemsizerf   r|  r~  r  failr   rq  r   r,   r,   r-   array_reshape1  sT    


r  c             C   s    t | |||\}}t| |||S )N)rb  r  )rV   r)   r;   r   r`  ra  r,   r,   r-   array_reshape_varargr  s    r  c             C   s   dd }|S )Nc             S   s
   |  |S )N)reshape)rj  rA   r,   r,   r-   np_reshape_implz  s    z#np_reshape.<locals>.np_reshape_implr,   )rj  rA   r  r,   r,   r-   
np_reshapex  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  rf   )r   r,   r,   r-   
imp_nocopy  s    zarray_ravel.<locals>.imp_nocopyc             S   s   |   S )zCopy version)Zflatten)r   r,   r,   r-   imp_copy  s    zarray_ravel.<locals>.imp_copyr   r+  )r   r  rn  r   r   )rV   r)   r;   r   r  r  impr   r,   r,   r-   array_ravel  s    r  c             C   s   dd }|  ||||S )Nc             S   s   |   S )N)ravel)rj  r,   r,   r-   np_ravel_impl  s    znp_ravel.<locals>.np_ravel_impl)rn  )rV   r)   r;   r   r  r,   r,   r-   np_ravel  s    r  zarray.flattenc             C   s,   dd }|  ||||}t| ||j|}|S )Nc             S   s   |   | jS )N)rP  r  rf   )r   r,   r,   r-   r    s    zarray_flatten.<locals>.imp)rn  r   r   )rV   r)   r;   r   r  r   r,   r,   r-   array_flatten  s    r  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.
    rO  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 )Nry  r   Fr!   Tr,   )	r  rH   rx   old_itemsizenew_itemsizer  rI   ZnewdimZ
bytelength)
any_layoutc_layoutf_layoutint8r,   r-   r    s.    



z_change_dtype.<locals>.imprA   r   rx   r!   )rT   rK   r  N)rm   rA   rx   ry   rw   )rK   rl   r  ordr   r  r   rb   rW   r   rD   rC   rj   rR   rF   rU   rS   r   r   r   booleanrn  r   r   r   )rV   r)   Zoldtynewtyr   Z
new_layoutr  r  r  r  Z
shape_dataZstrides_dataZshape_strides_array_typearyclsZshape_constantZsizeof_intpZstrides_constantr  Zstrides_aryrA   rx   r   r;   r   r,   )r  r  r  r  r-   _change_dtype  sl    	
0




r  c             C   s   dd }|S )Nc                sJ   t |   t d d } fddt dd  D }t || S )Nr!   c                s    g | ]\}} | |kr|qS r,   r,   )rp   rI   rJ  )br,   r-   rq   ,  s    z5np_unique.<locals>.np_unique_impl.<locals>.<listcomp>)npsortr  r   r  r   )rj  headtailr,   )r  r-   np_unique_impl)  s    z!np_unique.<locals>.np_unique_implr,   )rj  r  r,   r,   r-   	np_unique'  s    r  z
array.viewc          	   C   s   |j d }|j}t|| ||d }t|| |}t|jj}xFt|D ]:}	t||	}
|	dkrv|jj	}|
|
||_qHt||	|
 qHW t| ||||}|d|tj|j	d}|| d}| j|t|f W d Q R X | }t| ||j|S )Nr   rm   z==z"new type not compatible with array)r   r   rR   r   r~   r   sortedgetattrrm   r'   r:  r   r  r  r   r   r&   r   r   r   r   r   r   )rV   r)   r;   r   r   r  r   rq  Zfieldsr   r^   r3  r  r  r   r   r,   r,   r-   
array_view1  s$    

r  rT   c             C   s   |   }t| |||S )N)r   r   )rV   r)   rz  r   r   r,   r,   r-   array_dtypeP  s    r  rA   c             C   s(   t |}|| ||}|j}t| |||S )N)rR   rA   r   )rV   r)   rz  r   r[   r   r   r,   r,   r-   array_shapeU  s    r  rx   c             C   s(   t |}|| ||}|j}t| |||S )N)rR   rx   r   )rV   r)   rz  r   r[   r   r   r,   r,   r-   array_strides^  s    r  rK   c             C   s   |  tj|j}t| |||S )N)r   r   rb   rK   r   )rV   r)   rz  r   r   r,   r,   r-   
array_ndimg  s    r  rf   c             C   s(   t |}|| ||}|j}t| |||S )N)rR   r}   r   )rV   r)   rz  r   r[   r   r   r,   r,   r-   
array_sizen  s    r  ry   c             C   s(   t |}|| ||}|j}t| |||S )N)rR   ry   r   )rV   r)   rz  r   r[   r   r   r,   r,   r-   array_itemsizev  s    r  nbytesc             C   sD   t |}|| ||}t||j|j}||j|j}t| |||S )z"
    nbytes = size * itemsize
    )	rR   r   r   rA   rK   r   r}   ry   r   )rV   r)   rz  r   r[   r   rH   r   r,   r,   r-   array_nbytes  s
    r  
contiguousc             C   s   |  tj|j}t| |||S )N)r   r   r  	is_contigr   )rV   r)   rz  r   r   r,   r,   r-   array_contiguous  s    r  c_contiguousc             C   s   |  tj|j}t| |||S )N)r   r   r  Zis_c_contigr   )rV   r)   rz  r   r   r,   r,   r-   array_c_contiguous  s    r  f_contiguousc             C   s   |  tj|j}t| |||S )N)r   r   r  Zis_f_contigr   )rV   r)   rz  r   r   r,   r,   r-   array_f_contiguous  s    r  readonlyc             C   s    |  tj|j }t| |||S )N)r   r   r  mutabler   )rV   r)   rz  r   r   r,   r,   r-   array_readonly  s    r  ctypesc       	      C   sP   t |}|| ||}t|}| ||}|j|_|j|_| }t| |||S )N)rR   r   ArrayCTypesr   rm   rw   r   r   )	rV   r)   rz  r   r[   r   Zactctinfor   r,   r,   r-   array_ctypes  s    
r  rm   c             C   s8   | j |||d}|j}||| tj}t| |||S )N)r   )r   rm   r%  r   r   rb   r   )rV   r)   rz  r   r  r   r,   r,   r-   array_ctypes_data  s    r  c             C   s6   | j |||d}|j}||| |}t| |||S )N)r   )r   rm   r:  r   r   )rV   r)   fromtytotyr^   r  r   r,   r,   r-   array_ctypes_to_pointer  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   )rR   r   r^  rb   rK   rU   r   rT   r   Zbool_rA   rx   r   rn  )
ZcheckerrV   r)   r   r   Ztup_intpry   Z	check_sigZ
check_argsr  r,   r,   r-   _call_contiguous_check  s    
r  r|   c             C   s.   |  |t|}||_| }t| |||S )N)r   r   
ArrayFlagsrz   r   r   )rV   r)   rz  r   flagsobjr   r,   r,   r-   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   )
r?   r  r   r  r   rz   r   r   r  r   )rV   r)   rz  r   r  r   r^   r,   r,   r-   array_flags_c_contiguous  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 )Nr  )r   r!   r!  )r?   r  r   r  r   rz   rK   r   r   r  r   )rV   r)   rz  r   r  r   r  r^   r,   r,   r-   array_flags_f_contiguous  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 {})	rT   r   complex_domainarray_complex_attrnumber_domainr   r4   r   r'   )rV   r)   rz  r   r,   r,   r-   array_real_part  s
    r  imagc             C   s`   |j tjkrt| |||ddS |j tjkrLt|jdd|}t| |||gS td	t
j d S )Nr  )r  T)r  zunsupported .imag for {})rT   r   r  r  r  r   rP  numpy_zeros_like_ndr4   r   r'   )rV   r)   rz  r   r;   r,   r,   r-   array_imag_part
  s    r  conj	conjugatec             C   s   dd }|S )Nc             S   s
   t | S )N)r  r  )r#  r,   r,   r-   impl  s    zarray_conj.<locals>.implr,   )r#  r  r,   r,   r-   
array_conj  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 imaginery part;
     the `^` indicates the start of each element)

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

        R x R x R x
        ^   ^   ^

    (`x` indicates unused)

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

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

        x C x C x C
          ^   ^   ^
    )r  r  zcannot get attribute `{}`r      r!   rO  )rT   r  )rm   ry   )rT   r   r  r4   r   rR   Zunderlying_floatrU   rS   ry   r'   r   rm  r:  rm   r  r   IntTyperP  r   r   rQ  r   r   )rV   r)   rz  r   r  r[   r   ZfltyZsizeof_fltyry   Z
llfltptrtyr   Zresulttyr   rS  r,   r,   r-   r    s     r  r'   c             C   s   |   S )N)r   )rV   r)   dtypetydtypevalr,   r,   r-   
dtype_typeV  s    r  kindc             C   s   |   S )N)r   )rV   r)   r  r  r,   r,   r-   r  [  s    c          	   C   s   t |}|| ||}|j}t|tjs6td||f ||}||}	|j|dd}
t |
}|| |}| 	tj
|	}| tj
}|||j||}|||jj}| | |}t|||j|j| 	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 definedrO  )rT   r  )rm   rA   rx   ry   rw   rz   )rR   rT   ri   r   Recordr4   typeofoffsetrP  r   rb   r   r   r%  rm   Zinttoptrr'   rU   rS   r   rA   rx   rw   rz   r   r   )rV   r)   rz  r   r  r[   r   ZrectyperT   r  ZrestyZrarytyZraryZconstoffsetZllintpnewdataZ
newdataptrZdatasizer   r,   r,   r-   array_record_getattrc  s0    



r  Zstatic_getitemc             C   s0   |d }t |tstt| ||jd |d |S )Nr!   r   )ri   strr4   r  r   )rV   r)   r;   r   r   r,   r,   r-   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 )zi
    Generic getattr() implementation for records: fetch the given
    record member, i.e. a scalar.
    c                s   g | ]}  tj|qS r,   )r   r   rb   )rp   r  )rV   r,   r-   rq     s    z"record_getattr.<locals>.<listcomp>c                s   g | ]}  tj|qS r,   )r   r   rb   )rp   r  )rV   r,   r-   rq     s    N)rm   rA   rx   ry   rw   rz   r!   )sentry_record_alignmentr  r  ri   r   ZNestedArrayrR   rT   rA   rx   r   get_record_memberrS   r   rF   r   rb   rf   r   r   rY   rZ   )rV   r)   rz  r   r  r  elemtyr   r   rT   r}  r~  r  r   dptrrX   r,   )rV   r-   record_getattr  s8    










r  c             C   s~   |j \}}|\}}| || ||}	||}
t|||	| |
}| ||||
}|jrbdnd}| j	||
|||d dS )zg
    Generic setattr() implementation for records: set the given
    record member, i.e. a scalar.
    Nr!   )rX   )
r   r  r  r  r   r  rS   ra   rY   r]   )rV   r)   r;   r   r  rz  r   targetr^   r  r  r  rX   r,   r,   r-   record_setattr  s    



r  c             C   s4   |  |jd |d }|| ||jd |d |d S )z3
    Record.__getitem__ redirects to getattr()
    r   r!   )Zget_getattrr   )rV   r)   r;   r   r  r,   r,   r-   record_getitem  s    r  Zstatic_setitemc             C   sJ   |j \}}}|\}}}	t|j||}
| ||
}|dk	s<t||||	fS )z3
    Record.__setitem__ redirects to setattr()
    N)r   r   r   Zget_setattrrl   )rV   r)   r;   r   Zrectyr  r   Zrecre   r^   Zgetattr_sigr  r,   r,   r-   record_setitem  s    
r  c             C   s   |  |||S )zB
    Create a constant array (mechanism is target-dependent).
    )Zmake_constant_array)rV   r)   r   pyvalr,   r,   r-   constant_record  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   	ArrayTyper  r  	bytearrayZtostringr   r   )rV   r)   r   r  Zltyr^   r,   r,   r-   r    s    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 )N)rA   rx   r  rm   )rj  r  r,   r,   r-   array_is_impl	  s    zarray_is.<locals>.array_is_impl)r   r   r  rn  )rV   r)   r;   r   atyZbtyr  r,   r,   r-   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)
flatitertyr,   r,   r-   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).
    ndenumerate)r  )nditertyr,   r,   r-   make_array_ndenumerate_cls	  s    r  c          
   C   s  |  tjd}|d}	|d k	r.|tj| xtt|D ]}
t	|||
}t
|||}||
 }|d||}t||, ||| |d k	r||
 ||	 W d Q R X ||| |d k	r<||
 q<W |d k	r|tj| ||	 ||	 d S )Nr   Zend_incrementr  )r   r   rb   r   r   r   
false_byter  r%   rD   r   r*   r   	if_likelyr   	true_byter   )rV   r)   rK   rA   ru   end_flagloop_continue
loop_breakr   bbendr   idxptrre   r   	in_boundsr,   r,   r-   _increment_indices	  s*    

r  c             C   s*   t ||j|j}t| ||j||| d S )N)r   r   rA   rK   r  )rV   r)   r"  r#  ru   r  rA   r,   r,   r-   _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).
    r!   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 )N)nditermember_name	start_dimend_dimrK   )r9   r	  r
  r  r  r,   r,   r-   r   P	  s
    z-make_nditer_cls.<locals>.BaseSubIter.__init__c             S   s   t | j| j| d S )N)r   r	  r
  )r9   rG   r,   r,   r-   set_member_ptrW	  s    z3make_nditer_cls.<locals>.BaseSubIter.set_member_ptrc             S   s   t | j| jS )N)r  r	  r
  )r9   r,   r,   r-   
member_ptrZ	  s    z/make_nditer_cls.<locals>.BaseSubIter.member_ptrc             S   s   d S )Nr,   )r9   rV   r)   r,   r,   r-   init_specific^	  s    z2make_nditer_cls.<locals>.BaseSubIter.init_specificc             S   s   d S )Nr,   )r9   rV   r)   logical_dimr,   r,   r-   r  a	  s    z2make_nditer_cls.<locals>.BaseSubIter.loop_continuec             S   s   d S )Nr,   )r9   rV   r)   r  r,   r,   r-   r  d	  s    z/make_nditer_cls.<locals>.BaseSubIter.loop_breakN)rL   rM   rN   r   r   r  r
   cached_propertyr  r  r  r  r,   r,   r,   r-   BaseSubIterK	  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 )Nr   )r   r   rb   r  r   r   )r9   rV   r)   r   r,   r,   r-   r  n	  s    z2make_nditer_cls.<locals>.FlatSubIter.init_specificc             S   s   | | j}||j|gS )N)r*   r  r  rm   )r9   rV   r)   ru   r"  r#  r   r,   r,   r-   compute_pointerr	  s    z4make_nditer_cls.<locals>.FlatSubIter.compute_pointerc             S   s8   || j d kr4|| j}t||}||| j d S )Nr!   )rK   r*   r  r   r   r   )r9   rV   r)   r  r   r,   r,   r-   r  v	  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   r!   )	r   r   rb   r   r  rK   r*   r   r   )r9   rV   r)   r  r   r   r,   r,   r-   r  }	  s    z/make_nditer_cls.<locals>.FlatSubIter.loop_breakN)rL   rM   rN   r   r  r  r  r  r,   r,   r,   r-   FlatSubIterh	  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 )N)need_shaped_indexingrl   )r9   rV   r)   )r  r,   r-   r  	  s    z9make_nditer_cls.<locals>.TrivialFlatSubIter.init_specificc             S   s&   t |dkstt |||j|S )Nr!   )rr   rl   r  rm   )r9   rV   r)   ru   r"  r#  r,   r,   r-   r  	  s    z;make_nditer_cls.<locals>.TrivialFlatSubIter.compute_pointerN)rL   rM   rN   r   r  r  r,   )r  r,   r-   TrivialFlatSubIter	  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 )NF)r   )rr   rK   rl   r   r   )r9   rV   r)   ru   r"  r#  r,   r,   r-   r  	  s    
z7make_nditer_cls.<locals>.IndexedSubIter.compute_pointerN)rL   rM   rN   r   r  r,   r,   r,   r-   IndexedSubIter	  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 )N)rm   )r9   rV   r)   ru   r"  r#  r,   r,   r-   r  	  s    z7make_nditer_cls.<locals>.ZeroDimSubIter.compute_pointerN)rL   rM   rN   r   r  r,   r,   r,   r-   ZeroDimSubIter	  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 )Nr,   )r9   rV   r)   ru   r"  r#  r,   r,   r-   r  	  s    z6make_nditer_cls.<locals>.ScalarSubIter.compute_pointerN)rL   rM   rN   r   r  r,   r,   r,   r-   ScalarSubIter	  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                sh   g }j r nd}xFtjD ]8\}}|\}}}}d| }	|| }
||
| |	|| q(W |S )N)r  ZindexedZ0dZscalarzindex%d)r  r  r
  rE   )r9   lZ	factoriesrI   r  r  r  r  r  r
  factory)r  r  r  r  r  r  r,   r-   subiters	  s    
z(make_nditer_cls.<locals>.NdIter.subitersc                sN  | tjd}||t||| _xDt|D ]8\}}t|tjs.d| }t	
||| }	t| ||	 q.W | ||||}ttj}
d}d}xht|D ]4\}}t|tjr|jkr|| j}|| j}P qW dkst|||
d}| tjd}dd }x^t||D ]P\}}t|tjr|jdkr|||ttjttj|j|
|j|f qW t	||} dkr|ddd	 }|d
||}||t	jt	j}js|f}t|kstt	j||jd}x,tD ] }t	 |||}|!|| qW || _"t	#|||j| _t	
||| _$x| j%D ]}|&|| q4W dS )zY
            Initialize the nditer() instance for the specific array inputs.
            r   zscalar%dNr,   r!   c             S   sB   t | }x4t|D ](}| | |t || |  krtdqW d S )Nz2nditer(): operands could not be broadcast together)rr   r%   r   )rA   
main_shapenrI   r,   r,   r-   check_shape	  s    zBmake_nditer_cls.<locals>.NdIter.init_specific.<locals>.check_shaper  ry  z==)rf   )'r   r   rb   
make_tupleZTuplearraysr  ri   rj   r   r   r   _arrays_or_scalarsr^  rK   rA   r}   rl   rs   rn  r   noner   r   r  r   r  r  rr   r7   r'   r%   rD   r   ru   rF   	exhaustedr  r  )r9   rV   r)   arrtysr!  r   rI   r   r
  ZslotZmain_shape_tyr  Zmain_nitemsr"  r  r#  r   Zshape_is_emptyr$  ru   r   r  subiter)r  rK   r  nshapesr,   r-   r  	  s\    



z-make_nditer_cls.<locals>.NdIter.init_specificc                s*  | d}t||| j}t|| |d || W d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.
            r&  FNTc             S   s   g | ]}|  qS r,   )r   )rp   r   r,   r,   r-   rq   .
  s    zEmake_nditer_cls.<locals>.NdIter.iternext_specific.<locals>.<listcomp>r!   r   )r   r   as_bool_bitr*   r$  if_unlikelyr   r   r!  r   r"  ru   _make_viewsrr   r   r   
yield_typerA   r  rC  partial_loop_continue_loop_breakr   )r9   rV   r)   r   r  r$  r%  r!  ru   viewsrA   )r  r,   r-   iternext_specific
  s.    



z1make_nditer_cls.<locals>.NdIter.iternext_specificc             S   sD   x>| j D ]4}|j|  kr$|jk rn q|||||j  qW d S )N)r  r  r  r  )r9   rV   r)   r   r  r,   r,   r-   r-  ?
  s    z.make_nditer_cls.<locals>.NdIter._loop_continuec             S   sD   x>| j D ]4}|j|  kr$|jk rn q|||||j  qW d S )N)r  r  r  r  )r9   rV   r)   r   r  r,   r,   r-   r.  D
  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 xt||D ]~\}
}|
\}}}}|j	|j
 }dkr|ddd }xB|D ]:}|| dkst| | ||	| || || |||< qW q\W tdd |D st|S )z:
            Compute the views to be yielded.
            Nc          	      s    g | ]}  t |qS r,   )r*   r   rD   )rp   rI   )r)   ru   r,   r-   rq   U
  s   z?make_nditer_cls.<locals>.NdIter._make_views.<locals>.<listcomp>r  ry  c             s   s   | ]
}|V  qd S )Nr,   )rp   r   r,   r,   r-   r   b
  s    z>make_nditer_cls.<locals>.NdIter._make_views.<locals>.<genexpr>)r
  r  r+  ri   r   r   r   r%   rs   r  r  rl   
_make_viewall)r9   rV   r)   ru   r%  r!  r/  r
  r  rettysr  r&  r  Zarray_indicesZsub_indicesrI   )r  narraysr  r'  )r)   ru   r-   r*  I
  s*    



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   r,   N)rw   )ri   r   rj   rK   rl   r  rR   rW   r   r^  rb   r   )r9   rV   r)   ru   r  r"  r#  r&  rG   Zviewry   rA   rx   r,   r,   r-   r1  e
  s    
z*make_nditer_cls.<locals>.NdIter._make_viewc       	      S   sd   g }xZt t||D ]H\}\}}t|tjrH||||||d q|t| d|  qW |S )N)r   zscalar%d)r  rs   ri   r   rj   rE   rR   r  )	r9   rV   r)   r%  r!  r  rI   r"  r#  r,   r,   r-   r"  v
  s    z2make_nditer_cls.<locals>.NdIter._arrays_or_scalarsN)rL   rM   rN   r   r
   r  r  r  r0  r-  r.  r*  r1  r"  r,   )
r  r  r  r  r  r  r4  rK   r  r'  r,   r-   NdIter	  s   N%r5  )rK   r  rr   r!  r  objectr   rQ   )r  r  r5  r,   )
r  r  r  r  r  r  r4  rK   r  r'  r-   make_nditer_clsA	  s    
!		, Nr7  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}xht D ]\}t	|||}|
|| || }	|tj|	|}
t||
 |
tj| W d Q R X qBW || _|| _t|||j| _d S )Nr   )rf   )r   r   rb   r   r7   r'   r   r  r%   rD   r   r   r   ICMP_EQr)  r   ru   r$  rF   rA   )r9   rV   r)   r   r   ru   r$  r   r  r  dim_is_empty)rK   r,   r-   r  
  s    

z3make_ndindex_cls.<locals>.NdIndexIter.init_specificc       
   	      s   | tjd} d}t  j}t | |	d  
| W d Q R X  fddtD }x|D ]}t | qvW |t ||j |	d t j}	t| |	jj  
|  | d S )Nr   r&  Fc          	      s"   g | ]}  t j|qS r,   )r*   r   rD   ru   )rp   r   )r)   r9   r,   r-   rq   
  s   zKmake_ndindex_cls.<locals>.NdIndexIter.iternext_specific.<locals>.<listcomp>T)r   r   rb   r   r   r(  r*   r$  r)  r   r   r%   r0   r   rF   r'   r   rA   r  ru   r   )
r9   rV   r)   r   r   r  r$  ru   r*   rA   )rK   )r)   r9   r-   r0  
  s"    





z7make_ndindex_cls.<locals>.NdIndexIter.iternext_specificN)rL   rM   rN   r   r  r0  r,   )rK   r,   r-   NdIndexIter
  s   r:  )rK   r   rQ   )r  r:  r,   )rK   r-   make_ndindex_cls
  s    4r;  c                sb    dkst | j}|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r~tj||j	| tj|j
d}x,t|j
D ]}t|||}||| qVW || _d S )Nr   r  )rf   )r   r   rb   r   r   r   ry   r  r7   r'   rK   r%   rD   r   ru   )	r9   rV   r)   r"  r#  r   ru   r   r  )r  r,   r-   r  
  s    zD_make_flattening_iter_cls.<locals>.CContiguousFlatIter.init_specificc          	      s   | tjd}|j}|j} | j}	 tj	|	|}
|
|
 t |
  |j|	g}t| ||}dkr|| nP| j fddt|D }t |}|t ||g t| || t |	}	 |	| j W d Q R X d S )Nr   r  c          	      s    g | ]}  t |qS r,   )r*   r   rD   )rp   r   )r)   ru   r,   r-   rq   
  s   z\_make_flattening_iter_cls.<locals>.CContiguousFlatIter.iternext_specific.<locals>.<listcomp>)r   r   rb   rK   r}   r*   r   r   r   r   r   r   r  r  rm   r\   r   ru   r%   rF   make_anonymous_structr  r   r   )r9   rV   r)   r"  r#  r   r   rK   r}   r   r   rG   r   idxvalsidxtuple)r  )r)   ru   r-   r0  
  s(    
zH_make_flattening_iter_cls.<locals>.CContiguousFlatIter.iternext_specificc             S   s   | |j|g}t||||S )N)r  rm   r\   )r9   rV   r)   r"  r#  r   rG   r,   r,   r-   rV    s    z>_make_flattening_iter_cls.<locals>.CContiguousFlatIter.getitemc             S   s$   | |j|g}t||||| d S )N)r  rm   r_   )r9   rV   r)   r"  r#  r   r   rG   r,   r,   r-   setitem  s    z>_make_flattening_iter_cls.<locals>.CContiguousFlatIter.setitemN)rL   rM   rN   r   r  r0  rV  r?  r,   )r  r,   r-   CContiguousFlatIter
  s
   r@  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}xt|D ]v}t||	|}t||
|}||| ||| || }|tj||}t|| |tj| W d Q R X q~W |	| _|
| _|| _d S )Nr   )rf   )r   r   rb   rm   rK   r   r   rA   r7   r'   r   r  r%   rD   r   r   r   r8  r)  r   ru   pointersr$  )r9   rV   r)   r"  r#  r   rm   rK   r   ru   rA  r$  r   r  ptrptrr  r9  r,   r,   r-   r    s.    

z9_make_flattening_iter_cls.<locals>.FlatIter.init_specificc          
      s2  |j }|j}t |j|}t |j|}	| j| j}
|t	j
d} d}t  | j}t | |d  | W d Q R X |d t |
|d } |}t| ||}dkr|| n: fddt|D }t |}|t ||g xtt|D ]}t |}t  |}|| }|	| } tj||}t |  || t |
|} |}t ||} || x2t|d |D ] }t |
|} || qW  | W d Q R X  || q W  tj | j  |  !| d S )	Nr   r&  FTr!   r  c          	      s    g | ]}  t |qS r,   )r*   r   rD   )rp   r   )r)   ru   r,   r-   rq   R  s   zQ_make_flattening_iter_cls.<locals>.FlatIter.iternext_specific.<locals>.<listcomp>)"rK   rm   r   r   rA   rx   ru   rA  r   r   rb   r   r(  r*   r$  r)  r   r   rD   r\   r   r%   rF   r<  r  r   r   r   r   r  r   pointer_addr   r   )r9   rV   r)   r"  r#  r   rK   rm   r   rx   rA  r   r  Zis_exhaustedZlast_ptrrG   r   r=  r>  r   r  re   r   r  r  rB  Z	inner_dim)r  )r)   ru   r-   r0  6  sZ    





z=_make_flattening_iter_cls.<locals>.FlatIter.iternext_specificc             S   s   |j }tj||j|d}tj||j|d}g }	x:tt|D ]*}
|	||||
  |	|||
 }q<W |	
  t||j|||j|	}|S )N)r   )rK   r   r   rA   rx   r  r%   rE   ZuremZudivreverser  rm   r  )r9   rV   r)   r"  r#  r   rK   r   rx   ru   r   rG   r,   r,   r-   _ptr_for_indexw  s    z:_make_flattening_iter_cls.<locals>.FlatIter._ptr_for_indexc             S   s    |  |||||}t||||S )N)rE  r\   )r9   rV   r)   r"  r#  r   rG   r,   r,   r-   rV    s    z3_make_flattening_iter_cls.<locals>.FlatIter.getitemc             S   s&   |  |||||}t||||| d S )N)rE  r_   )r9   rV   r)   r"  r#  r   r   rG   r,   r,   r-   r?    s    z3_make_flattening_iter_cls.<locals>.FlatIter.setitemN)	rL   rM   rN   r   r  r0  rE  rV  r?  r,   )r  r,   r-   FlatIter  s    ArF  )rl   r?   rT   r  r   rQ   )r  r  r?   rT   r@  rF  r,   )r  r-   r  
  s    
B r  r  c             C   sh   t t|}|| |}||_| |}|| ||dd}|| ||| | }t| |t||S )Nr   )r:   )	r  r   NumpyFlatTyper   rR   rC   r  r   r   )rV   r)   r"  r#  flatiterclsflatiterarrclsr   r,   r,   r-   make_array_flatiter  s    

rK  c             C   sZ   |j \}|\}t|}|| ||d}|j}| |}	|	| ||jd}
|| |||
| d S )N)r   )r   r  r?   rR   r   r0  )rV   r)   r;   r   r   r  rI  rH  r"  rJ  r#  r,   r,   r-   iternext_numpy_flatiter  s    
rL  c             C   sj   |j d }|\}}t|}|| ||d}|j}| |}	|	| ||jd}
|| |||
|}t| ||j|S )Nr   )r   )r   r  r?   rR   r   rV  r   r   )rV   r)   r;   r   r  rI  r   rH  r"  rJ  r#  r   r,   r,   r-   iternext_numpy_getitem  s    

rM  c             C   sf   |j d }|\}}}t|}|| ||d}|j}	| |	}
|
| ||jd}|| ||	|||}|  S )Nr   )r   )r   r  r?   rR   r   r?  r   )rV   r)   r;   r   r  rI  r   r   rH  r"  rJ  r#  r   r,   r,   r-   rM    s    


c       	      C   sF   |j d }t|}|| ||d d}| |j}|| ||jd}|jS )Nr   )r   )r   r  rR   r?   r   r}   )	rV   r)   r;   r   r  rH  rI  rJ  r#  r,   r,   r-   rM    s    
c       
      C   sr   |j \}|\}tt|}|| |}||_| |}|| ||dd}|| ||| | }	t	| ||j
|	S )Nr   )r:   )r   r  r   NumpyNdEnumerateTyper   rR   rC   r  r   r   r   )
rV   r)   r;   r   r"  r#  	nditerclsr	  rJ  r   r,   r,   r-   make_array_ndenumerate  s    

rP  c             C   sZ   |j \}|\}t|}|| ||d}|j}| |}	|	| ||jd}
|| |||
| d S )N)r   )r   r  r?   rR   r   r0  )rV   r)   r;   r   r   r  r	  rO  r"  rJ  r#  r,   r,   r-   iternext_numpy_nditer  s    
rQ  c                s^    fddt |j|D }ttt|}| }| | | }t |j	|S )zndindex(*shape)c                s"   g | ]\}}  ||tjqS r,   )ra   r   rb   )rp   Zargtyarg)r)   rV   r,   r-   rq     s   z&make_array_ndindex.<locals>.<listcomp>)
rs   r   r;  r   NumpyNdIndexTyperr   r  r   r   r   )rV   r)   r;   r   rA   rO  r	  r   r,   )r)   rV   r-   make_array_ndindex   s    
rT  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 r,   )ra   r   rb   )rp   re   )r)   rV   rd   r,   r-   rq     s   z&make_array_ndindex.<locals>.<listcomp>)r   rK   r   rT   r   r   r;  r   rS  rr   r  r   r   )
rV   r)   r;   r   rK   r   rA   rO  r	  r   r,   )r)   rV   rd   r-   rT    s    

c             C   s6   |j \}|\}t|}|| ||d}|| || d S )N)r   )r   r;  r0  )rV   r)   r;   r   r   r  r	  rO  r,   r,   r-   iternext_numpy_ndindex$  s
    rU  c       	      C   sn   |j }|j}t|jd tjr0t||d }n
|d g}t|| |}|	| ||| |
 }t| |||S )z
    nditer(...)
    r   )r   r!  ri   r   r   r   r   r   r7  r  r   r   )	rV   r)   r;   r   r  r%  r!  r	  r   r,   r,   r-   make_array_nditer0  s    
rV  c             C   s2   |j \}|\}t|| ||d}|| || d S )N)r   )r   r7  r0  )rV   r)   r;   r   r   r  r	  r,   r,   r-   rU  C  s    c             C   s  t |}|| |}| |j}| tjt| |}| tjd}x|D ]}	|||	}qFW |jdkrjd}
n|j	dkr|g}
x.t
|dd D ]}|
||
d | qW tt
|
}
nV|j	dkr|g}
x*|dd D ]}|
||
d | qW t|
}
ntd|j	|||}| |j}| jj|||d	}| 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.
    r!   r   r,   r+  Nry  r  z3Don't know how to allocate array with layout '{0}'.)rf   rX   )r   )rm   rA   rx   ry   rw   )rR   rS   rT   r   r   rb   rW   r   rK   r  r  rE   r   r4   r   Zget_preferred_array_alignmentr   Zmeminfo_alloc_alignedZmeminfo_datar   r   rF   r   r:  rm  )rV   r)   rR  r   r  r   Zdatatypery   Zarrlenr  rx   Zdimension_sizer@  rX   rw   rm   r   Zshape_arrayZstrides_arrayr,   r,   r-   r  P  sJ    







r  c             C   s"   t ||j||j|jd dS )z<
    Zero-fill an array.  The array must be contiguous.
    r   N)r   Zmemsetrm   r   ry   r}   )rV   r)   r   r,   r,   r-   _zero_fill_array  s    rW  c       
   
   C   s   t |tjr&d}| |||tjg}n@t |tjs6t|j}| |||ttj|}t	j
|||d}| |tjd}xJt|D ]>}|d|| |}	t	||	 | j|td W dQ R X qW |S )z;
    Parse the shape argument to an array constructor.
    r!   )r   r   r  )znegative dimensions not allowedN)ri   r   rk   ra   rb   r   rl   r   r^  r   r   get_constant_genericr%   r   r)  r   r   r   )
rV   r)   r   r^   rK   r   arrshaper   r   Zis_negr,   r,   r-   _parse_shape  s    

rZ  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   rZ  )rV   r)   r;   r   ZarrshapetyperY  rR  r,   r,   r-   _parse_empty_args  s    
r[  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   r,   N)
r   ri   r   rj   rR   r   r   rA   rK   r   )rV   r)   r;   r   arytyper   r   r,   r,   r-   _parse_empty_like_args  s    

r]  c             C   s4   t | |||\}}t| |||}t| ||j| S )N)r[  r  r   r   r   )rV   r)   r;   r   rR  r   r   r,   r,   r-   numpy_empty_nd  s    r^  c             C   s4   t | |||\}}t| |||}t| ||j| S )N)r]  r  r   r   r   )rV   r)   r;   r   rR  r   r   r,   r,   r-   numpy_empty_like_nd  s    r_  c             C   s@   t | |||\}}t| |||}t| || t| ||j| S )N)r[  r  rW  r   r   r   )rV   r)   r;   r   rR  r   r   r,   r,   r-   numpy_zeros_nd  s    r`  c             C   s@   t | |||\}}t| |||}t| || t| ||j| S )N)r]  r  rW  r   r   r   )rV   r)   r;   r   rR  r   r   r,   r,   r-   r    s    r  )r!   r  c             C   s:   t dk rdd }ndd }| ||||}t| ||j|S )N)r!      c             S   s8   t | }t |j}xt |jD ]}|||< q$W |S )N)r  emptyZfloat64r  ndindexrA   )rA   r   r#  r^   re   r,   r,   r-   full  s
    
znumpy_full_nd.<locals>.fullc             S   s2   t | t|}xt |jD ]}|||< qW |S )N)r  rb  r'   rc  rA   )rA   r   r#  re   r,   r,   r-   rd    s    )numpy_versionrn  r   r   )rV   r)   r;   r   rd  r   r,   r,   r-   numpy_full_nd  s
    
rf  c             C   s(   dd }|  ||||}t| ||j|S )Nc             S   s.   t | |}xt |jD ]}|||< qW |S )N)r  rb  rc  rA   )rA   r   rT   r#  re   r,   r,   r-   rd    s    z!numpy_full_dtype_nd.<locals>.full)rn  r   r   )rV   r)   r;   r   rd  r   r,   r,   r-   numpy_full_dtype_nd  s    rg  c             C   s(   dd }|  ||||}t| ||j|S )Nc             S   s,   t | } xt | jD ]}|| |< qW | S )N)r  
empty_likerc  rA   )r#  r   re   r,   r,   r-   	full_like  s    
z%numpy_full_like_nd.<locals>.full_like)rn  r   r   )rV   r)   r;   r   ri  r   r,   r,   r-   numpy_full_like_nd   s    rj  c             C   s(   dd }|  ||||}t| ||j|S )Nc             S   s.   t | |} xt | jD ]}|| |< qW | S )N)r  rh  rc  rA   )r#  r   rT   re   r,   r,   r-   ri    s    z%numpy_full_like_nd.<locals>.full_like)rn  r   r   )rV   r)   r;   r   ri  r   r,   r,   r-   rj    s    c             C   s8   dd }|j j}| j||||d|id}t| ||j |S )Nc             S   s,   t | }xt |jD ]}d||< qW |S )Nr!   )r  rb  rc  rA   )rA   r#  re   r,   r,   r-   ones  s    
znumpy_ones_nd.<locals>.onesr   )locals)r   rT   rn  r   )rV   r)   r;   r   rk  r   r   r,   r,   r-   numpy_ones_nd  s
    rm  c             C   s(   dd }|  ||||}t| ||j|S )Nc             S   s.   t | |}xt |jD ]}d||< qW |S )Nr!   )r  rb  rc  rA   )rA   rT   r#  re   r,   r,   r-   rk  +  s    z!numpy_ones_dtype_nd.<locals>.ones)rn  r   r   )rV   r)   r;   r   rk  r   r,   r,   r-   numpy_ones_dtype_nd(  s    rn  c             C   s(   dd }|  ||||}t| ||j|S )Nc             S   s,   t | } xt | jD ]}d| |< qW | S )Nr!   )r  rh  rc  rA   )r#  re   r,   r,   r-   	ones_like7  s    
z%numpy_ones_like_nd.<locals>.ones_like)rn  r   r   )rV   r)   r;   r   ro  r   r,   r,   r-   numpy_ones_like_nd4  s    rp  c             C   s(   dd }|  ||||}t| ||j|S )Nc             S   s.   t | |} xt | jD ]}d| |< qW | S )Nr!   )r  rh  rc  rA   )r#  rT   re   r,   r,   r-   ro  C  s    z+numpy_ones_like_dtype_nd.<locals>.ones_like)rn  r   r   )rV   r)   r;   r   ro  r   r,   r,   r-   numpy_ones_like_dtype_nd@  s    rq  c             C   s(   dd }|  ||||}t| ||j|S )Nc             S   s0   t | | f}xt| D ]}d|||f< qW |S )Nr!   )r  zerosr%   )r  r#  rI   r,   r,   r-   identityP  s    z numpy_identity.<locals>.identity)rn  r   r   )rV   r)   r;   r   rs  r   r,   r,   r-   numpy_identityM  s    rt  c             C   s(   dd }|  ||||}t| ||j|S )Nc             S   s2   t | | f|}xt| D ]}d|||f< qW |S )Nr!   )r  rr  r%   )r  rT   r#  rI   r,   r,   r-   rs  \  s    z numpy_identity.<locals>.identity)rn  r   r   )rV   r)   r;   r   rs  r   r,   r,   r-   rt  Y  s    c             C   s   d S )Nr,   )NMr,   r,   r-   _eye_none_handlerf  s    rw  c             C   s"   t |tjrdd }ndd }|S )Nc             S   s   | S )Nr,   )ru  rv  r,   r,   r-   r  l  s    z$_eye_none_handler_impl.<locals>.implc             S   s   |S )Nr,   )ru  rv  r,   r,   r-   r  o  s    )ri   r   NoneType)ru  rv  r  r,   r,   r-   _eye_none_handler_impli  s    
ry  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 )NrT   r   c                s   t | |}t| |f }|dkrTt| || }xRt|D ]}d|||| f< q:W n0t| | |}x t|D ]}d||| |f< qlW |S )Nr   r!   )rw  r  rr  minr%   )ru  rv  r   rT   Z_Mr#  drI   )dtr,   r-   r  ~  s    
znumpy_eye.<locals>.impl)
ri   r   rx  r  rT   float	DTypeSpecNumberr   r  )ru  rv  r   rT   r  r,   )r|  r-   	numpy_eyes  s    
r  c             C   s   dd }|  ||||S )Nc             S   s   t j| ddS )Nr   )r   )r  diag)r^   r,   r,   r-   	diag_impl  s    znumpy_diag.<locals>.diag_impl)rn  )rV   r)   r;   r   r  r,   r,   r-   
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   r!   c             S   s   | j }|d t| }t||f| j}|dkr\xTt|| D ]}| | |||| f< q>W n*x(t|| D ]}| | ||| |f< qjW |S )Nr   )rA   re  r  rr  rT   r%   )r#  r   r  r  rq  rI   r,   r,   r-   r    s    z#numpy_diag_kwarg.<locals>.diag_implrk  c       	      S   s   | j \}}|}|}|dk r"|| }|dkr2|| }tt||d}t|| j}|dkrxLt|D ]}| ||| f ||< qbW n&x$t|D ]}| || |f ||< qW |S )Nr   )rA   maxrz  r  rb  rT   r%   )	r#  r   ZrowsZcolsrr   r  rq  rI   r,   r,   r-   r    s    
zInput must be 1- or 2-d.)r   )r   )r   rK   r   rn  r   r   )rV   r)   r;   r   rR  r  r   r,   r,   r-   numpy_diag_kwarg  s    


r  z
array.takec             C   s(   dd }|  ||||}t| ||j|S )Nc             S   s4   || j d ks|| j  k r"td|  t| S )Nr!   zIndex out of bounds)rf   
IndexErrorr  r  r&   )rj  ru   r,   r,   r-   	take_impl  s    znumpy_take_1.<locals>.take_impl)rn  r   r   )rV   r)   r;   r   r  r   r,   r,   r-   numpy_take_1  s    r  c                s<   |j d jdk  fdd}| ||||}t| ||j|S )Nr!   r  c                s   t j|j| jd} r | }n|}t |}d}|  }xB|D ]:}|| jd ks^|| j k rftd|| ||< |d }q@W ||j	S )N)rT   r   r!   zIndex out of bounds)
r  rb  rf   rT   rP  r	  r  r  r  rA   )rj  ru   rq  ZwalkeritrI   r  rJ  )F_orderr,   r-   r    s    


znumpy_take_2.<locals>.take_impl)r   r  rn  r   r   )rV   r)   r;   r   r  r   r,   )r  r-   numpy_take_2  s    r  c             C   s(   dd }|  ||||}t| ||j|S )Nc             S   s   t |}t j|j| jd}t |}d}|  }xB|D ]:}|| jd ksV|| j k r^td|| ||< |d }q8W ||j	S )N)rT   r   r!   zIndex out of bounds)
r  r   rb  rf   rT   r	  r  r  r  rA   )rj  ru   Zconvertrq  r  rI   r  rJ  r,   r,   r-   r    s    


znumpy_take_3.<locals>.take_impl)rn  r   r   )rV   r)   r;   r   r  r   r,   r,   r-   numpy_take_3  s    r  c                s8   t |jj  fdd}| ||||}t| ||j|S )Nc                s   t d| d S )Nr   r!   )r  arange)r  )rT   r,   r-   r    s    znumpy_arange_1.<locals>.arange)r   r   rT   rn  r   )rV   r)   r;   r   r  r   r,   )rT   r-   numpy_arange_1  s    r  c                s8   t |jj  fdd}| ||||}t| ||j|S )Nc                s   t | |d S )Nr!   )r  r  )r   r  )rT   r,   r-   r    s    znumpy_arange_2.<locals>.arange)r   r   rT   rn  r   )rV   r)   r;   r   r  r   r,   )rT   r-   numpy_arange_2  s    r  c                s8   t |jj  fdd}| ||||}t| ||j|S )Nc                s   t | || S )N)r  r  )r   r  r  )rT   r,   r-   r    s    znumpy_arange_3.<locals>.arange)r   r   rT   rn  r   )rV   r)   r;   r   r  r   r,   )rT   r-   numpy_arange_3  s    r  c             C   sP   t dd |jD rdd }ndd }| j||||dtjid}t| ||j|S )Nc             s   s   | ]}t |tjV  qd S )N)ri   r   ZComplex)rp   rj  r,   r,   r-   r     s    z!numpy_arange_4.<locals>.<genexpr>c             S   sj   ||  | }t |j}t |j}tt||d}t||}| }	x t|D ]}
|	||
< |	|7 }	qNW |S )Nr   )	mathceilr  r  r  rz  r  rb  r%   )r   r  r  rT   Znitems_cnitems_rZnitems_ir}   r#  r^   rI   r,   r,   r-   r    s    znumpy_arange_4.<locals>.arangec       	      S   sR   t ||  | }t|d}t||}| }x t|D ]}|||< ||7 }q6W |S )Nr   )r  r  r  r  rb  r%   )	r   r  r  rT   r  r}   r#  r^   rI   r,   r,   r-   r  *  s    
r}   )rl  )r   r   rn  r   rb   r   r   )rV   r)   r;   r   r  r   r,   r,   r-   numpy_arange_4  s    

r  c             C   s(   dd }|  ||||}t| ||j|S )Nc             S   s   t | |dS )N2   )r  linspace)r   r  r,   r,   r-   r  ;  s    z"numpy_linspace_2.<locals>.linspace)rn  r   r   )rV   r)   r;   r   r  r   r,   r,   r-   numpy_linspace_28  s    r  c                s8   t |jj  fdd}| ||||}t| ||j|S )Nc                sP   t | }|d }||  }| |d< x&td|D ]}| |||   ||< q0W |S )Nr!   r   )r  rb  r%   )r   r  Znumr#  ZdivZdeltarI   )rT   r,   r-   r  F  s    z"numpy_linspace_3.<locals>.linspace)r   r   rT   rn  r   )rV   r)   r;   r   r  r   r,   )rT   r-   numpy_linspace_3A  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|||D}t||	|||j|}t||
|||j|}|||| W dQ R X t| ||j| S )z
    Array copy.
    r   )r   r!  r!   )rX   N)r   rR   r   r   rA   r   r  rm   r  rl   Z
raw_memcpyr}   ry   rx   r   r   rb   r>  r  r   r*   r   r   )rV   r)   r;   r   r\  r   r   rettyperq  r4  r[  r6  rZ  r   ru   r.  rA  r,   r,   r-   _array_copyS  s.    


r  z
array.copyc             C   s   t | |||S )N)r  )rV   r)   r;   r   r,   r,   r-   
array_copyx  s    r  c             C   s   t | |||S )N)r  )rV   r)   r;   r   r,   r,   r-   
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 d	Q R X | t| |||}|j}W d	Q R X W d	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 layoutr!   )r   )r!   r!  rO  r+  N)r   r   r  rl   rK   rR   rX  r   r^  rb   r   ry   r   rm   rw   rz   r   r   r   r   r  r,  blockr  Zphir'   Zadd_incoming)rV   r)   r;   r   output_layoutr  r   r   rq  rA   rx   Z
check_funcr  ZthenZorelseZout_thenZthen_blkZ
out_orelseZ
orelse_blkZret_phir,   r,   r-   _as_layout_array  sF    



r  c             C   s   t | |||ddS )Nr  )r  )r  )rV   r)   r;   r   r,   r,   r-   array_asfortranarray  s    r  c             C   s   t | |||ddS )Nr+  )r  )r  )rV   r)   r;   r   r,   r,   r-   array_ascontiguousarray  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|||d}t||	|||j|}t||
|||j|}t| |||}| |||j|j}t| |||| W d Q R X t| ||j| S )Nr   )r   )r   rR   r   r   rA   r   r  rm   rx   r   r   rb   r>  r  r  r\   ra   rT   r_   r   r   )rV   r)   r;   r   r\  r   r   r  rq  r4  r[  r6  rZ  r   ru   r.  rA  itemr,   r,   r-   array_astype  s*    


r  c          	   C   s"  |j d }|j}t|| ||d d}t|}|| |}|j}	t| |}
tj|jj	|
}|
|j|j}|||}t||}|j|dd d}| j|t|f W d Q R X t||||g}t||g}||j| |	d}t||||||j|jd | }t| ||j|S )Nr   )r   F)r   z.buffer size must be a multiple of element sizerm   )rm   rA   rx   ry   rw   rz   )r   r   rR   r~   rW   r   r   r&   ry   r'   r   r}   Zsremr   Zis_not_nullr   r   r   r   rF   Zsdivr:  rm   r   r   r   rw   rz   r   r   )rV   r)   r;   r   Zbuftyr   ZbufZ
out_ary_tyout_aryZout_datamodelry   ll_itemsizer  ZremZis_incompatibler   rA   rx   rm   r   r,   r,   r-   np_frombuffer  s6    



r  c                sJ  |j dd \}}|dd \}}|j}|j}	|jdks<tt| }
t|}t|}t	|t
jrxt |}n|f}|f} fddt||D }|}g }|jdkrxT|D ]}||  ||}qW n0x&t|D ]}||  ||}qW |   ||j }t|
||||dd |
 }t |j|S )zR
    numba.numpy_support.carray(...) and
    numba.numpy_support.farray(...).
    Nrk  r!  c                s"   g | ]\}}  ||tjqS r,   )ra   r   rb   )rp   r  r   )r)   rV   r,   r-   rq   '  s   znp_cfarray.<locals>.<listcomp>r  )rm   rA   rx   ry   rw   )r   r   rT   r  rl   rR   rW   r   r   ri   r   r   r   rs   rE   r   r  rD  r:  rS   rm  r   r   r   )rV   r)   r;   r   r3  r_  rG   rA   r   rT   r  ry   r  r   Zoffrx   r  rm   r   r,   )r)   rV   r-   
np_cfarray  sD    	





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 )Nr   )
ri   r   r   r   rb   rr   rY  r3   r   rl   )rV   r)   seqtyseqr]  r,   r,   r-   _get_seq_sizeF  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 )N)r   r   Zdecref)r)   r   rq  )rV   rW  r  r,   r-   wrapV  s    
z$_get_borrowing_getitem.<locals>.wrap)rT   r3   rU  rV  r   r   rb   )rV   r  r  r,   )rV   rW  r  r-   _get_borrowing_getitemO  s
    r  c                sz    tj}t|d fdd}g }|| }}	x:t|D ].}
|
dkrZ|||	\}}	|t ||	 q@W 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)ri   r   r   rr   r   r  rT   )r  r  rW  )r)   rV   r   r,   r-   get_first_itemf  s    
z.compute_sequence_shape.<locals>.get_first_item)	r   r   rb   r   r&   r%   rE   r  r   )rV   r)   rK   r  r  r   r  r   innertyinnerrI   r,   )r)   rV   r   r-   compute_sequence_shape_  s    
r  c                s<    tj}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   r,   )r)   rV   r,   r-   _fail  s    
z#check_sequence_shape.<locals>._failc          	      s  t |dkrd S t| |}|d }d||}j|dd    W d Q R X t |dkrdd S t| tjrt| }t	|0}| j
}|||jf}	||	|dd   W d Q R X n\t| tjrxLtt | D ],}
| |
 }||
}	||	|dd   qW ndst| d S )Nr   z!=F)r   r!   )rr   r  r   r   ri   r   rY  r  r   r   rT   r   r   r%   r   rl   )r  r  r   rf   ZexpectedrM  rW  r   r  r  rI   )r  r)   check_seq_sizerV   r,   r-   r    s*    
 z,check_sequence_shape.<locals>.check_seq_sizeN)r   r   rb   )rV   r)   r  r  r   r   r,   )r  r)   r  rV   r-   check_sequence_shape}  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          	      s@   t j j| dd}|| j}t || d S )NF)r   )r   r  r  ra   rT   r_   )ru   r   r^   rG   )r"  r)   rV   rm   r   rx   r,   r-   assign_item  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 d Q R X nrt| tjrxbtt | D ]B}	| |	 }||	}tj|	}
 |||dd  ||
f  qW ndst| d S )Nr   r!   )rr   ri   r   rY  r   rl   r  r   r   rT   r   r%   r   r   rb   )r  r  r   ru   rf   rW  r   r  r  rI   r   )assignr  r)   rV   r,   r-   r    s$    
*"z(assign_sequence_to_array.<locals>.assignr,   Nr,   )rV   r)   rm   r   rx   r"  r  r  r,   )r"  r  r  r)   rV   rm   r   rx   r-   assign_sequence_to_array  s    r  c       
   	   C   s   |j }|j}|jd }|d }t| ||||}t||ks>tt| |||| t| |||}	t| ||	j	||	j
||| t| ||j |	 S )Nr   )r   rK   r   r  rr   rl   r  r  r  rm   rx   r   r   )
rV   r)   r;   r   r"  rK   r  r  r   r#  r,   r,   r-   np_array  s    

r  c       
   	   C   s   | d}| |}|d||}||||||}||d|||d||}|j|dd  d| }	| j|t|	f W d Q R X |S )Nr   r  z>=F)r   z%s(): axis out of bounds)	r'   r   r  r   r  r   r   r   r  )
rV   r)   Z	func_namerK   rf  r   ll_ndimZis_neg_axisZaxis_out_of_boundsr   r,   r,   r-   _normalize_axis  s    

r  c          
   C   s   t ||d kstttj|}t||}td}xbt|d D ]R}t|}	|d|	|}
|| }|	|
|
|	||	}||t||d| qFW ||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).
    r!   z>=r   )rr   rl   r   r  r   r   r7   r%   r   r  r   r   rD   r   r*   )rV   r)   
orig_shaperK   rf  ll_shtyr   r  r   ll_dim
after_axisr   re   r,   r,   r-   _insert_axis_in_shape  s    


r  c          
   C   s   t ||d kstttj|}t||}td}td}x^t|d D ]N}	t|	}
|d|
|}|	||
|
||
}|||	 t||d| qPW ||t||d| t|||S )zD
    Same as _insert_axis_in_shape(), but with a strides array.
    r!   r   z>=)rr   rl   r   r  r   r   r7   r%   r   r  r   r   rD   r   r*   )rV   r)   orig_stridesrK   rf  r  rx   r  r   r   r  r  re   r,   r,   r-   _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   )rm   rA   rx   ry   rw   rz   )r   rK   r   rR   r   r   rA   rx   r  r  r   rm   ry   rw   rz   r   )rV   r)   r;   r   rf  r  rK   r"  r#  rq  r   rx   Z
new_shapesZnew_stridesr,   r,   r-   expand_dims0  s"    

r  c             C   sP   |  ||d |jd tj}t| |d|jj|}t| ||||}t| ||j|S )Nr!   znp.expand_dims)	ra   r   r   rb   r  r   rK   r  r   )rV   r)   r;   r   rf  rq  r,   r,   r-   np_expand_dimsL  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 r,   r,   )rp   r#  r"  r  )r)   rV   	transformr,   r-   rq   `  s   z_atleast_nd.<locals>.<listcomp>r   )r   ri   r   r   r   r   rr   rl   rs   r   r   )
rV   r)   r;   r   r  r%  arrsr3  Zretsrq  r,   )r)   rV   r  r-   _atleast_ndV  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       	         sf   x`t D ]T}|d }|j|k r
t | }|j|jd d}t| |t|||f|}|}q
W |S )Nr!   )rK   )r%   rK   r   r   rP  r  r	   r   )	rV   r)   r#  r"  r  rI   rK   rf  Znewarrty)ru  min_ndimr,   r-   r  q  s    
z(_atleast_nd_transform.<locals>.transform)rr   rl   )r  ru  r  r,   )ru  r  r-   _atleast_nd_transformj  s    r  c             C   s   t ddg}t| ||||S )Nr!   r   )r  r  )rV   r)   r;   r   r  r,   r,   r-   np_atleast_1d  s    r  c             C   s   t dddg}t| ||||S )Nrk  r   )r  r  )rV   r)   r;   r   r  r,   r,   r-   np_atleast_2d  s    r  c             C   s    t ddddg}t| ||||S )N   r   rk  )r  r  )rV   r)   r;   r   r  r,   r,   r-   r    s    c	          
   C   s  t |t |  kr.t |  kr.t |ks4n ttd}	t| |||}
t||
j}g }xp|D ]h}|	}xTtt||D ]B\}\}}|	d|
||}|||}||||||}q|W || qdW |
j}xt|||||D ]\}}}}}|j}tj||tj|jd}|d}t|||||j|}t| |||}| |||j|j}t|||||j|}t| |||| W dQ R X t|||}qW |
S )z2
    Concatenate arrays along the given axis.
    r   z==)orderN)rr   rl   r   r   r  r   rx   r  rs   r   r'   r   r  r   rE   rm   r>  r  r  r\   ra   rT   r_   rC  )rV   r)   rf  r%  r  
arr_shapesarr_stridesr  
ret_shapesr   rq  Zret_stridesZcopy_offsetsZarr_shr  r   rf   r  is_axisZaddendZret_datar"  r#  Zarr_stZarr_datar>  ru   r.  r^   rA  r,   r,   r-   _do_concatenate  s@    4







r  c                s  |j }td} fddt||D }t d||} fdd|D } fdd|D }	 fdd|d D }
xt|D ]  d||}|
 } |}fd	d|d
d  D } 	|\}}|& t
 j||g } || W d Q R X |h tj}x$|D ]} | d||}qW  j |dd j td f W d Q R X W d Q R X W d Q R X qW  fdd|
D }
t |||||	||
	}t || S )Nr   c                s"   g | ]\}}t | |d qS ))r   )rR   )rp   r  rj  )r)   rV   r,   r-   rq     s   z#_np_concatenate.<locals>.<listcomp>znp.concatenatec                s   g | ]}t  |jqS r,   )r   r   rA   )rp   r#  )r)   r,   r-   rq     s    c                s   g | ]}t  |jqS r,   )r   r   rx   )rp   r#  )r)   r,   r-   rq     s    c                s   g | ]}t  |qS r,   )r   r   )rp   r   )r)   r,   r-   rq     s   z==c                s   g | ]}|  qS r,   r,   )rp   r   )r   r,   r-   rq     s    r!   F)r   z<np.concatenate(): input sizes over dimension %d do not matchc                s   g | ]}  |qS r,   )r*   )rp   r   )r)   r,   r-   rq     s    )rK   r   r   rs   r  r%   r   r'   r*   r,  rC  rD  r   r   rE  r)  r   r   r   r   r   r  r   r   )rV   r)   r%  r  r  rf  rK   r   r  r  r  r  Zret_shape_ptrZret_shZother_shapesZon_axisZon_other_dimr   is_okrq  r,   )r)   rV   r   r-   _np_concatenate  sD    



.r  c                s  |j }td}td}t|}	tt|}
 fddt||D }t d||}t |d j}x|dd  D ]r}tj}xftt |j|D ]N\}} 	| 
d||} j |dd j td	 W d Q R X qW q|W  fd
d|D }ttj|t }t }x|t|d D ]l}t|} 
d||}|| } | |||} |t |d|  |t |d| q8W  |t |d|  |
t |d| t  |gt| }t  |} fddtt|D }xt|d D ]p}t|} 
d||} | |||}x:tt|D ]*} || | t || d| qpW q0W x2tt|D ]"} |t || d| qW  fdd|D }t |||||||	}t || S )Nr   r!   c                s"   g | ]\}}t | |d qS ))r   )rR   )rp   r  rj  )r)   rV   r,   r-   rq     s   z_np_stack.<locals>.<listcomp>znp.stackz==F)r   )z5np.stack(): all input arrays must have the same shapec                s   g | ]}t  |jqS r,   )r   r   rx   )rp   r#  )r)   r,   r-   rq     s    z>=c                s   g | ]}t  qS r,   )r   r7   )rp   rI   )r)   r  r,   r-   rq   ;  s   c                s   g | ]}t   |qS r,   )r   r   r*   )rp   r   )r)   r,   r-   rq   N  s   )rK   r   r   rr   rs   r  r   rA   rE  r)  r   r   r   r   r   r   r   r  r7   r%   r  r   r   rD   r*   r  r   r   )rV   r)   r%  r  r  rf  rK   r   r  r  Z
ll_narraysr  r#  r  r   Zorig_shr  Zinput_shapesr  r   r  r  re   Zinput_stridesrI   rq  r,   )r)   rV   r  r-   	_np_stack  sl    






""
r  c          	   C   s8   |  tjd}t| |t|jd t||d |j|S )Nr   )	r   r   rb   r  r   r   r   r   r   )rV   r)   r;   r   rf  r,   r,   r-   np_concatenateY  s    r  c          	   C   sF   |  ||d |jd tj}t| |t|jd t||d |j|S )Nr!   r   )	ra   r   r   rb   r  r   r   r   r   )rV   r)   r;   r   rf  r,   r,   r-   np_concatenate_axisb  s    r  c             C   s   t |jd }t||d }g }g }| tjd}xt||D ]t\}	}
|	jdkrh|	|	 |	|
 q@|	jdksvt
|	jdd}t||	}t| |||
f|}|	| |	| q@W t| ||||j|S )Nr   r!   rk  )rK   )r   r   r   r   r   r   rb   rs   rK   rE   rl   rP  r	   r   r  r  r   )rV   r)   r;   r   Zorig_arrtysZ	orig_arrsr%  r  rf  r"  r#  r  
expand_sigZnewarrr,   r,   r-   np_column_stackl  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   )rV   r)   r;   r   rf  r,   r,   r-   _np_stack_common  s
    r  )r!   
   c             C   s   |  tjd}t| ||||S )Nr   )r   r   rb   r  )rV   r)   r;   r   rf  r,   r,   r-   np_stack  s    r  c             C   s,   |  ||d |jd tj}t| ||||S )Nr!   )ra   r   r   rb   r  )rV   r)   r;   r   rf  r,   r,   r-   np_stack_axis  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   r!   c                s   t j|  dS )N)rf  )r  concatenate)r!  )rf  r,   r-   np_hstack_impl  s    z!np_hstack.<locals>.np_hstack_impl)r   rK   r   r   rb   r  rn  )rV   r)   r;   r   r   rK   r  r,   )rf  r-   	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 )Nr!   )r  r  hstack)r!  r,   r,   r-   np_vstack_impl  s    z!np_vstack.<locals>.np_vstack_implr!   c             S   s   t j| ddS )Nr   )rf  )r  r  )r!  r,   r,   r-   r    s    )r   rK   r   r   rb   r  rn  )rV   r)   r;   r   r   rK   r  rf  r,   r,   r-   	np_vstack  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 )Nr!   ry  )r  r  r  )r!  r,   r,   r-   r    s    z!np_dstack.<locals>.np_vstack_implr!   )rK   rk  c             S   s   t j| ddS )Nrk  )rf  )r  r  )r!  r,   r,   r-   r    s    )r   r   rK   rn  r   r   rb   rP  r	   r   r  r  )rV   r)   r;   r   r   r  rK   r  rf  Zstack_rettyZ	stack_sigZ	stack_retr  r,   r,   r-   	np_dstack  s&    

r  Zfillc             C   s   dd }|S )Nc             S   s   || d d < d S )Nr,   )r#  r^   r,   r,   r-   	fill_impl  s    zarr_fill.<locals>.fill_implr,   )r#  r^   r  r,   r,   r-   arr_fill  s    r  dotc             C   s   dd }|S )Nc             S   s   t | |S )N)r  r  )r#  otherr,   r,   r-   dot_impl  s    zarray_dot.<locals>.dot_implr,   )r#  r  r  r,   r,   r-   	array_dot  s    r  c             C   s   t |p| |k S )N)r  Zisnan)rj  r  r,   r,   r-   	lt_floats  s    r  Fc             C   s~   | ||f}yt | S  tk
rx   | dkrHtj|r6tnd|d}|j}n$| dkrltj|r\tnd|d}|j}|t |< |S X dS )z6
    Get a sort implementation of the given kind.
    r"   N)lt
is_argsortr#   )	_sortsKeyErrorr"   Zmake_jit_quicksortr  Zrun_quicksortr#   Zmake_jit_mergesortZrun_mergesort)r  is_floatr  keyr  funcr,   r,   r-   get_sort_func  s     


r  z
array.sortc                s<   |j d }tdt|jtjd  fdd}| ||||S )Nr   r"   )r  r  c                s    |  d S )Nr,   )r#  )	sort_funcr,   r-   array_sort_impl  s    z#array_sort.<locals>.array_sort_impl)r   r  ri   rT   r   Floatrn  )rV   r)   r;   r   r\  r  r,   )r  r-   
array_sort  s
    
r  c             C   s   dd }|  ||||S )Nc             S   s   |   }|  |S )N)rP  r  )rj  r   r,   r,   r-   np_sort_impl&  s    znp_sort.<locals>.np_sort_impl)rn  )rV   r)   r;   r   r  r,   r,   r-   np_sort#  s    r  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  r  r  c                s    | S )Nr,   )r#  )r  r,   r-   array_argsort_impl5  s    z)array_argsort.<locals>.array_argsort_implr!   )r   )	r   r  Zliteral_valueri   rT   r   r  replacern  )	rV   r)   r;   r   r\  r  r  ZinnersigZ	innerargsr,   )r  r-   array_argsort-  s    
r  c             C   s   |j |j ks|jdkst|S )NrO  )r  r  rl   )rV   r)   r  r  r^   r,   r,   r-   array_to_arrayA  s    r  c             C   s   t dS )zR
    An intrinsic returning a derived array with the given shape and strides.
    N)r4   )rj  rA   rx   r,   r,   r-   reshape_uncheckedK  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 )N)ri   r   rk   )rp   r   r,   r,   r-   r   U  s    z>type_reshape_unchecked.<locals>.check_shape.<locals>.<genexpr>)ri   r   r   r2  )rA   r,   r,   r-   r  S  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 )NrO  )rK   r  )ri   r   rj   rr   rP  )rj  rA   rx   )r  r,   r-   typerW  s    z%type_reshape_unchecked.<locals>.typerr,   )rV   r  r,   )r  r-   type_reshape_uncheckedQ  s    	r  c             C   s   |j d }|j}t|| ||d }t|| |}t||d }t||d }	t||j||	|j|jd |	 }
t
| |||
S )Nr   r!   rk  )rm   rA   rx   ry   rw   )r   r   rR   r   r   r   rm   ry   rw   r   r   )rV   r)   r;   r   r   r  r   r   rA   rx   r   r,   r,   r-   impl_shape_uncheckedb  s    

r   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 )N)rA   )rJ  rA   r,   r,   r-   r   {  s    zas_strided.<locals>.get_shapec             S   s   |S )Nr,   )rJ  rA   r,   r,   r-   r     s    z*as_strided() strides argument is mandatoryc             S   s   |S )Nr,   )rJ  rx   r,   r,   r-   get_strides  s    zas_strided.<locals>.get_stridesc                s   t |  | || |} | S )N)r  )rJ  rA   rx   )r   r  r,   r-   as_strided_impl  s    z#as_strided.<locals>.as_strided_impl)NN)r   r#  r   r4   )rJ  rA   rx   r  r,   )r   r  r-   
as_stridedx  s    
r  )N)N)NNN)N)F)NN(3  r   Z
__future__r   r   r   rC  r  rU  Zllvmliter   Zllvmlite.llvmpy.coreZllvmpyZcorer   r   Znumpyr  Znumbar   r   r	   r
   r   r   Znumba.numpy_supportr   r   r   r   r   r   re  Znumba.targets.imputilsr   r   r   r   r   r   r   r   r   r   Znumba.typingr   Znumba.extendingr   r   r     r"   r#   r$   r.   r0   rR   rW   r\   r_   rh   ro   rv   r   r   r   r   r   ZArrayIteratorr   r   r   r   rV  rk   r   r   r   r   r?  ZAnyr   rr   r   rj   r   r   r6  r   r   r   r   r   r  r	  r   r   r$  r'  r(  r*  rB  rG  rN  rT  r   rb  rd  rg  rr  ZVarArgrs  rt  rw  rc  r  r  r  r  r  r  r  r  r  r  r  uniquer  r~  r  r  Z
MemoryViewr  r  r  r  r  r  r  r  r  r  r  r  r  ZCPointerZvoidptrr  r  r  r  r  r  r  r  r  r  ZDTyper  r  ZStringLiteralr  r  r  r  r  r  r  is_r  r  r  r  r  r7  r;  r  rK  rG  rL  rM  r  rP  rN  rQ  rc  rT  rS  rU  r	  rV  ZNumpyNdIterTyper  rW  rZ  r[  r]  rb  r^  rh  r_  rr  r`  Z
zeros_liker  rd  rf  rg  ri  rj  rk  rm  rn  ro  rp  rq  rs  rt  rw  ry  Zeyer}  r  r  r  r  Ztaker  r  ZListr  r  r  r  r  r  r  r  r  r  r  r  rP  r  r  Zasfortranarrayr  Zascontiguousarrayr  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  Zcolumn_stackr  r  stackr  r  r  r  Zvstackr  Zdstackr  r  r  r  r  r  r  r  r  Zargsortr  r  r  Ztype_callabler  r   libZstride_tricksr  r,   r,   r,   r-   <module>   s   0;8
;(22:OEv*)

=%x7#A~






:&	(   E> Q

 


6
    ""

+  $

	%= &&6	*)$"
$$$=3U	"

"#


$
$