o
    i\                 	   @   s0  d Z ddlZddlZddlZddlZddlmZ ddlmZ ddl	Z
ddlmZmZ ddlmZmZmZmZmZmZ ddlmZmZmZmZmZmZmZmZmZmZ ddlm Z m!Z!m"Z" dd	l#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z. dd
l/m0Z0 ddl1m2Z2 ddl3m4Z4m5Z5m6Z6m7Z7m8Z8 ddl9m:Z:m;Z; ddl<m=Z= ddl>m?Z?m@Z@ ddlAmBZBmCZC ddl3mDZD ddlEmFZGmHZImJZJmKZKmLZL dd ZMdd ZNdd ZOdd ZPdd ZQdd ZRdd  ZSd!d" ZTd#d$ ZU	d[d%d&ZVd'd( ZWd)d* ZXe5eXd+d, ZYe$d-ejZd.d/ Z[d0d1 Z\e$d2ej]e*e.j^d3d4 Z_	d[d5d6Z`d7d8 Zad9d: Zbe$ejcejZejde$ejcejZejed;d< Zfe$ejcejZejgd=d> Zhe$ejiejZejjejjd?d@ Zke$elejZdAdB Zme$dCejndDdE Zoe"dFk re$dGejnejjdHdI ZpG dJdK dKeqZrG dLdM dMerZsG dNdO dOerZtG dPdQ dQerZuG dRdS dSerZvG dTdU dUerZwG dVdW dWeqZxdXdY Zye$ejcejZejndZd[ Zzd\d] Z{d^d_ Z|d`da Z}dbdc Z~ddde Zdfdg Zdhdi Zdjdk Ze7dldm Ze7dndo Ze4dpdq Zdrds Ze5e
jdtdu Ze4dvdw Ze5e
jdxdy Ze5e
jdzd{ Zd|d} Ze5ed~ddd Ze5edddd Zdd Zdd Ze$dejndd Zdd Ze$dejnejgdd Ze$dejneejjdd Ze5e
jd[ddZe%ejnddd Ze5e
jd\ddZe5e
jd\ddZe5e
jd]ddZdd Zdd Ze$dejnejgdd Ze$dejneejjdd Ze"dk re5e
jdd Zn	e5e
jdd Ze5e
jdd Ze5e
jd[ddZe$dejndd Ze$e
jejndd Ze$dejndd Ze4dd Ze4dd Ze5e
jd[ddZe6ejndd^ddZdd Ze5e
jddĄ Ze5e
jddƄ Ze5e
jddȄ Ze5e
jddʄ Ze4dd̄ Ze6ejnd͡ddτ Ze7ddф Zddӄ Ze5ed~dddՄ Ze$dejnejdd؄ Ze%ejndكddۄ Ze%ejnd܃e%ejd܃ddބ Ze%ejnd߃e%ejd߃dd Ze%ejnde%ejddd Ze%ejnddd Ze%ejnde%ejddd Ze%ejnde%ejddd Ze%ejddd Ze%ejddd Ze%ejddd Ze%ejddd Ze%ejnddd Ze%ejddd Ze(ejejӃe(ejejԃd d ZՐdd Ze%ejnddd Ze%ejde%ejddd Ze%ejdd	d
 Ze%ejnddd Ze%ejnddd Zܐdd Ze6ejnde6ejnddd Zސdd Ze%ejde߃ e%ejde߃ e$dejejjdd Ze&ejndd Ze$dejnej2d d! Ze&ejd"d# Ze'ejd$d% Ze$dejej2d&d' Ze$dejejd(d) Ze$d*ejej2ejjd+d, Ze$d*ejejejjd-d. Ze)ejnd/d0 Ze)ejd1d2 Ze)ejd3d4 Ze$ejejnejnd5d6 Ze8ejnd7d8d9 Zd:d; Zd<d= Z		d^d>d?Z	d[d@dAZdBdC ZdDdE ZdFdG Ze%ejndHdIdJ Ze$d2eje*e.j^dKdL Ze$ejcejejddMdN Ze$ejiejejdejjdOdP Ze$elejdQdR Z e$e
jejndSdT Ze$d2eje*e.j^dUdV Ze$eeejde$e
jeejddWdX Ze$eejge$e
jejgdYdZ Ze$d2eje*e.j^d[d\ Z	e$e
j
ejjd]d^ Ze$d2eje*e.j^d_d` Ze$ejejejdadb Zdcdd ZeDejndedddfdg Zdhdi Ze7djdk Zdldm Zdndo Zdpdq Zdrds Ze7dtdu Ze5e
jefdvdwZe7dxdy Ze5e
jd[dzd{Ze7d|d} Ze6ejnd~dd Z e5e
j!efddZ"e5e
j#d[ddZ$e5e
j%d[ddZ&e5e
j'd[ddZ(e5e
j)d[ddZ*e5e
j+d[ddZ,e5e
j-d[ddZ.dd Z/e5e/dd Z0e5e
j1ddefddZ2e5e
j3d_ddZ4e5e
j5dd Z6e5e
j7d_ddZ8dd Z9e5e
j:e6ejndd[ddZ;dd Z<e5e
j=d^ddZ>e5e
j?d\ddZ@dd ZAe7dd ZBe$dejndd ZCe5e
jDdd ZEdd ZFe7dd ZGe5e
jHdd ZIe5e
jJdd ZKe$dejneje$dejnej2dd ZLe7dd ZMe6ejnddd ZNe7dd ZOe5e
jPeddfddÄZQe5ed[dĐdńZRe5ed[dƐdǄZSdȐdɄ ZTdʐd˄ ZUd̐d̈́ ZVdΐdτ ZWdАdф ZXdҐdӄ ZYdԐdՄ ZZd֐dׄ Z[e7dؐdل Z\e5e
j]d[dڐdۄZ^dܐd݄ Z_dސd߄ Z`dd Zadd Zbe7dd Zce5e
jbdd Zddd Zedd Zfe5e
jgdd Zhe5e
jidd Zje5e
jkdd Zldd Zmdd Zndd Zodd Zpe7dd Zqe5e
jrd_ddZsdd Zte7d d Zue5e
jvdd Zwdd Zxe7dd Zye5e
jzd_dd	Z{d
d Z|e7dd Z}e5e
j~dd Ze7dd Ze5e
jdd Ze"dFk
r6e5e
je e7dd Ze5e
jdd Ze6ejnddd Ze6ejnddd Ze5e
jdd Ze5e
jd d! Ze7d"d# Ze5e
jd$d% Ze5e
jd_d&d'Ze5e
jd_d(d)Ze5e
jd*d+ Ze5e
jd,d- Ze5e
jd.d/ Zi Zd0d1 Zd`d3d4Zd5d6 Ze$d7ejnd8d9 Ze5e
jd:d; Ze$d<ejnej2e$e
jejnej2d=d> Ze(ejnejnd?d@ Ze(ejneje(ejneje(ejnejde(ejneje(ejneje(ejneje(ejnejdAdB Ze(ejnejdCdD ZdEdF ZeedGdH Ze$eejnejgejgdIdJ Ze5e
jjjdadKdLZe5e
jjjd[dMdNZe5edOdP Ze5e
jdQdR Ze4dSdT Ze5e
jdUdV Ze5e
jdbdYdZZdS (c  z[
Implementation of operations on Array objects and objects supporting
the buffer protocol.
    N)ir)Constant)pndindexliteral_unroll)typestypingerrorscgutils	extendingconfig)
as_dtype
from_dtypecarrayfarrayis_contiguous
is_fortrancheck_is_integertype_is_scalar
lt_complex	lt_floats)type_can_asarrayis_nonelikenumpy_version)lower_builtinlower_getattrlower_getattr_genericlower_setattr_generic
lower_castlower_constantiternext_implimpl_ret_borrowedimpl_ret_new_refimpl_ret_untrackedRefType)	signature)StringLiteral)register_jitableoverloadoverload_method	intrinsicoverload_attribute)	quicksort	mergesort)slicing)_make_constant_bytes
bytes_type)tuple_setitembuild_full_slice_tuple)overload_classmethod)parse_dtypeparse_shape_parse_nested_sequence_sequence_of_arrays_choose_concatenation_layoutc                 C   s4   t |j|t |j|g}| j|}|d| dS )zz
    Set the "range" metadata on a load instruction.
    Note the interval is in the form [lower_bound, upper_bound).
    rangeN)r   typemoduleadd_metadataset_metadata)builderloadlower_boundupper_boundrange_operandsmd rC   T/home/ubuntu/maya3_transcribe/venv/lib/python3.10/site-packages/numba/np/arrayobj.pyset_range_metadata.   s
   

rE   c                 C   s&   d|j jd > d }t| |d| dS )zF
    Mark the result of a load instruction as positive (or zero).
       r   N)r9   widthrE   )r=   r>   r@   rC   rC   rD   mark_positive9   s   rH   c                    s6   j tjG  fddd  S )z
    Return the Structure representation of the given *array_type*
    (an instance of types.ArrayCompatible).

    Note this does not call __array_wrap__ in case a new array structure
    is being created (rather than populated).
    c                       s4   e Zd Z fddZefddZ  ZS )zmake_array.<locals>.ArrayStructc                    s   t }z	| jd|}W n ty   t | | Y S w | jj }| |}|d u r9tj	| j
|dd}n|}|| j
|f}||fS )N	__array__T)zfill)r$   _contextget_functionNotImplementedErrorsuper
_make_refsdata_model_manager_get_be_typer	   alloca_once_builder)selfrefsig
array_impl	datamodelbe_type	outer_ref)ArrayStruct	__class__
array_typereal_array_typerC   rD   rO   O   s   


z*make_array.<locals>.ArrayStruct._make_refsc                    sp   | j }dkr | dS | d}g }tD ]}t||d|}||}|| t|| qt	||S )z\
            Override .shape to inform LLVM that its elements are all positive.
            r   shape)
rS   __getattr___get_ptr_by_namer8   r	   gep_inboundsr>   appendrH   
pack_array)rT   r=   ptrdimsidimptrr>   )basendimrC   rD   r_   c   s   


z%make_array.<locals>.ArrayStruct.shape)__name__
__module____qualname__rO   propertyr_   __classcell__rC   r[   r]   ri   rj   r^   )r\   rD   r[   M   s    r[   )as_arrayr	   create_struct_proxyrj   )r]   rC   rp   rD   
make_arrayA   s
   
-rs   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]   lltyrC   rC   rD   get_itemsize}   s   
ry   c                 C   s"   |j rdnd}| j||j||dS )z3
    Load the item at the given array pointer.
    NrF   align)alignedunpack_valueru   )rw   r=   arraytyre   r{   rC   rC   rD   	load_item   s   r   c                 C   s$   |j rdnd}| j||j|||dS )z4
    Store the item at the given array pointer.
    NrF   rz   )r|   
pack_valueru   )rw   r=   r~   valre   r{   rC   rC   rD   
store_item   s   r   c                 C   s@   |j r| |||tj}t|||}|S | |||tj}|S )zM
    Fix the integer index' type and value for the given dimension size.
    )signedcastr   intpr-   	fix_indexuintp)rw   r=   idxtyidxsizeindrC   rC   rD   fix_integer_index   s   r   c                 C   sZ   t |tjr)|jdkr)t |jtjsJ t|| ||}t| |||j}|j|fS ||fS )zS
    Normalize the index type and value.  0-d arrays are converted to scalars.
    r   )	
isinstancer   Arrayrj   ru   Integerrs   r   data)rw   r=   r   r   idxaryidxvalrC   rC   rD   normalize_index   s   
r   c                    s2   t |rt fddt||D  \}}||fS )z^
    Same as normalize_index(), but operating on sequences of
    index types and values.
    c                    s   g | ]\}}t  ||qS rC   )r   ).0r   r   r=   rw   rC   rD   
<listcomp>   s
    z%normalize_indices.<locals>.<listcomp>)lenzip)rw   r=   index_typesindicesrC   r   rD   normalize_indices   s
   r   c                 C   s  | j }| j}| j}	ttjdd}
|j|
 }t|j}t|	j}||@ |krC|| }d| j	 dt
|dkr7dnd d| d}t||d	u rRt||	d
d	}|tj}t|ttfrft|||}t|ttfrtt|||}t|tr}||}t|||||d}|d	u rt||	dd	|d< n||d< |tjd}t|||jj}|D ]}|j||dgd}q||d< t| }||krtd|| | D ]
\}}t| || q| S )z
    Helper function for populating array structures.
    This avoids forgetting to set fields.

    *shape* and *strides* can be Python tuples or LLVM arrays.
    rF   CzThe datamodel for type z is missing fields  .Nmeminfo)r_   stridesr   itemsizer   parentnswflagsnitemszmissing {0}) rK   rS   
_datamodelr   r   float64rP   set_fields_fe_typer   
ValueErrorr   get_value_typeget_typer   r   tuplelistr	   rd   intdictget_constantunpack_tupler9   countmulkeysformatitemssetattr)arrayr   r_   r   r   r   r   rw   r=   rX   standard_arraystandard_array_type_datamodelrequired_fieldsdatamodel_fieldsmissingmsgintp_tattrsr   unpacked_shapeaxlen
got_fieldskvrC   rC   rD   populate_array   sh   





r   c                 C   sh   |j }|j}|tjd}t||j| j}|D ]}|j	||dgd}q||_
|tjt|| |_dS )z
    Update some auxiliary information in *array* after some of its fields
    were changed.  `itemsize` and `nitems` are updated.
    rF   r   r   N)rK   rS   r   r   r   r	   r   r_   rj   r   r   ry   r   )arytyr   rw   r=   r   r   r   rC   rC   rD   update_array_info  s   
r   c                 C   s   t  )z/Constrain axis values to valid positive values.rM   	func_namearg_namerj   axisrC   rC   rD   normalize_axis     r   c                    sL   t | ts
tdt |tstd| j d|j d  fdd}|S )Nz func_name must be a str literal.zarg_name must be a str literal.z: Argument z* out of bounds for dimensions of the arrayc                    s,   |dk r||7 }|dk s||krt  |S Nr   r   r   r   rC   rD   impl%  s
   z&normalize_axis_overloads.<locals>.impl)r   r%   r   TypingErrorliteral_value)r   r   rj   r   r   rC   r   rD   normalize_axis_overloads  s   



r   getiterc                 C   st   |j \}|\}| ||j}| tjd}t||}||_||_	| j
r,| j||| | }	t| ||j|	}
|
S r   )argsmake_helperreturn_typer   r   r   r	   alloca_once_valueindexr   
enable_nrtnrtincref	_getvaluer!   )rw   r=   rV   r   r~   r   iterobjzeroindexptrresoutrC   rC   rD   getiter_array0  s   r   c              	   C   s   t j||j|jd}t j||j|jd}||d |}t ||j|}	|dd }
|dd }t|t	j
rEt| |||||	|
|}| S |
rIJ t| |||	S )z1 Evaluate `ary[idx]`, where idx is a single int. r   r   rF   N)r	   r   r_   rj   r   r   pointer_addr   r   r   Buffer	make_viewr   r   )rw   r=   r   r   aryr   shapesr   offsetdataptrview_shapesview_stridesretaryrC   rC   rD   _getitem_array_single_intH  s   r   iternextc                 C   s   |j \}|\}|j}| j|||d}t|| ||jd}	tj||	jdd\}
||j	}|
d||
}|| ||% t| ||j||	|}|| t||}|||j	 W d    d S 1 sew   Y  d S )NvaluerF   r   <)r   r]   r   rs   r   r	   r   r_   r>   r   icmp_signed	set_validif_thenr   
yield_typeyield_increment_indexstore)rw   r=   rV   r   resultitertyiterr~   r   r   r   r   is_validr   nindexrC   rC   rD   iternext_array]  s"   

"r  c              	   C   s>  |  tjd}|  tjd}t||j|j}	t||j|j}
g }g }g }tdd |D }d}t	||D ]\}}|tj
u ri|jt| d | }t|D ]}|| ||	|  ||
|  |d7 }qNq6t|tjr| j|||d}t| ||| t|||	|  ||j t||}t|||
| }|| || n=t|tjrt| ||||	| }|rt| |||	| | || nt|r|| || |d8 }ntd|f |d7 }q6||jksJ ||jk r||	|  ||
|  |d7 }||jk stj| ||||ddd}|||fS )	z
    Perform basic indexing on the given array.
    A (data pointer, shapes, strides) tuple is returned describing
    the corresponding view.
    r   rF   c                 S      g | ]}t |r|qS rC   r   r   r   rC   rC   rD   r         z"basic_indexing.<locals>.<listcomp>r   unexpected index type: %sF
wraparoundboundscheck)r   r   r   r	   r   r_   rj   r   r   r   ellipsisr8   rc   r   	SliceTyper   r-   guard_invalid_slice	fix_slicestartget_slice_length
fix_strider   r   do_boundscheckr   rM   get_item_pointer)rw   r=   r   r   r   r   r  r   oner   r   output_indicesoutput_shapesoutput_stridesnum_newaxesaxindexvalr   	n_missingrg   sliceshstr   r   rC   rC   rD   basic_indexingy  sf   










r%  c           	   	   C   s.   t || |}t|||||j|j|jd |S )zF
    Build a view over the given array with the given parameters.
    r   r_   r   r   r   r   )rs   r   r   r   r   )	rw   r=   r   r   r   r   r   r   r   rC   rC   rD   r     s   r   c              	   C   s^   t | |||||| jd\}}}	t|tjr$t| |||||||	}
|
 S |r(J t| |||S )zp
    Return the result of indexing *ary* with the given *indices*,
    returning either a scalar or a view.
    r  )r%  enable_boundscheckr   r   r   r   r   r   )rw   r=   r   r   r   r   r   r   r   r   r   rC   rC   rD   _getitem_array_generic  s   r)  c           	      C   sZ   |j \}}|\}}|jdksJ t|| ||}t| ||j|||f|f}t| ||j|S )z4
    Basic indexing with an integer or a slice.
    rF   )r   rj   rs   r)  r   r    	rw   r=   rV   r   r   r   r   r   r   rC   rC   rD   getitem_arraynd_intp  s   

r+  c              	   C   s   |j \}}|\}}t|| ||}|j}tj||t|d}	t| |||	\}}	tdd |D r;t| |||||||	S t	| ||j
||||	}
t| ||j
|
S )z2
    Basic or advanced indexing with a tuple.
    r   c                 s       | ]	}t |tjV  qd S Nr   r   r   )r   tyrC   rC   rD   	<genexpr>      z&getitem_array_tuple.<locals>.<genexpr>)r   rs   r   r	   r   r   r   anyfancy_getitemr)  r   r    )rw   r=   rV   r   r   tuptyr   tupr   r   r   rC   rC   rD   getitem_array_tuple  s    


r6  c              	   C   s   |j \}}}|\}}}	t|tjr|j}
tj||t|d}n|f}
|f}t|| ||}t| ||
|\}
}zt	| ||||
|| j
d\}}}W n tyR   d}Y nw t|}|rbt| ||||
|S | ||	||j}	t| |||	| dS )zH
    array[a] = scalar_or_array
    array[a,..,b] = scalar_or_array
    r   r'  TN)r   r   r   	BaseTupler	   r   r   rs   r   r%  r(  rM   boolfancy_setslicer   ru   r   )rw   r=   rV   r   r   r   valtyr   r   r   r   r   r   r   r   use_fancy_indexingrC   rC   rD   setitem_array  s4   

r<  c           	      C   sD   |j \}|\}t|}|| ||}|j}||d}t| ||j|S r   )r   rs   r_   extract_valuer"   r   )	rw   r=   rV   r   r   r   arysttyshapearyr   rC   rC   rD   	array_len5  s   r@  z
array.itemc                 C   s   |j \}|\}t|| ||}|j}|j|d||ddd d}| j|t|f W d    n1 s7w   Y  t	| |||j
S )N!=rF   Flikelyz>item(): can only convert an array of size 1 to a Python scalar)r   rs   r   r   r   r9   	call_convreturn_user_excr   r   r   )rw   r=   rV   r   r   r   r   r   rC   rC   rD   
array_item@  s   rF     r   zarray.itemsetc           
      C   s   |j \}}|\}}||jksJ t|| ||}|j}|j|d||ddd d}	| j|t	|	f W d    n1 s@w   Y  t
| ||||j |  S )NrA  rF   FrB  z/itemset(): can only write to an array of size 1)r   ru   rs   r   r   r   r9   rD  rE  r   r   r   get_dummy_value)
rw   r=   rV   r   r   r:  r   r   r   r   rC   rC   rD   array_itemsetP  s   
rJ  c                   @   @   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      t )ze
        Prepare the indexer by initializing any required variables, basic
        blocks...
        r   rT   rC   rC   rD   preparek     zIndexer.preparec                 C   rM  )z=
        Return this dimension's size as an integer.
        r   rN  rC   rC   rD   get_sizer     zIndexer.get_sizec                 C   rM  )z;
        Return this dimension's shape as a tuple.
        r   rN  rC   rC   rD   	get_shapex  rR  zIndexer.get_shapec                 C   rM  )z}
        Return a half-open [lower, upper) range of indices this dimension
        is guaranteed not to step out of.
        r   rN  rC   rC   rD   get_index_bounds~  rP  zIndexer.get_index_boundsc                 C   rM  )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.
        r   rN  rC   rC   rD   	loop_head  s   	zIndexer.loop_headc                 C   rM  )z)
        Finish indexation loop.
        r   rN  rC   rC   rD   	loop_tail  rR  zIndexer.loop_tailN)
rk   rl   rm   __doc__rO  rQ  rS  rT  rU  rV  rC   rC   rC   rD   rL  e  s    rL  c                   @   H   e Zd ZdZdd Zdd Zdd Zdd	 Zd
d Zdd Z	dd Z
dS )EntireIndexerz:
    Compute indices along an entire array dimension.
    c                 C   s2   || _ || _|| _|| _|| _| j tj| _d S r-  )	rw   r=   r   r   dimr   r   r   ll_intp)rT   rw   r=   r   r   rZ  rC   rC   rD   __init__  s   zEntireIndexer.__init__c                 C   sB   | j }|| jj| j| _t|| j| _	|
 | _|
 | _d S r-  )r=   r=  r   r_   rZ  r   r	   rR   r[  r   append_basic_blockbb_startbb_endrT   r=   rC   rC   rD   rO    s
   
zEntireIndexer.preparec                 C      | j S r-  r   rN  rC   rC   rD   rQ       zEntireIndexer.get_sizec                 C      | j fS r-  rb  rN  rC   rC   rD   rS       zEntireIndexer.get_shapec                 C      |  d| jfS r   r[  r   rN  rC   rC   rD   rT       zEntireIndexer.get_index_boundsc                 C   s   | j }| j t| jd| j || j || j || j}|j	|
d|| jdd || j W d    ||fS 1 sBw   Y  ||fS Nr   >=FrB  )r=   r  r   r[  r   branchr^  position_at_endr>   r   r   r   r_  )rT   r=   	cur_indexrC   rC   rD   rU    s   
zEntireIndexer.loop_headc                 C   D   | j }t||| j}||| j || j || j	 d S r-  )
r=   r	   r  r>   r   r  rk  r^  rl  r_  rT   r=   
next_indexrC   rC   rD   rV    s
   zEntireIndexer.loop_tailNrk   rl   rm   rW  r\  rO  rQ  rS  rT  rU  rV  rC   rC   rC   rD   rY    s    rY  c                   @   rX  )IntegerIndexerz0
    Compute indices from a single integer.
    c                 C   s&   || _ || _|| _| j tj| _d S r-  )rw   r=   r   r   r   r   r[  )rT   rw   r=   r   rC   rC   rD   r\    s   zIntegerIndexer.__init__c                 C      d S r-  rC   rN  rC   rC   rD   rO       zIntegerIndexer.preparec                 C   s   t | jdS NrF   )r   r[  rN  rC   rC   rD   rQ       zIntegerIndexer.get_sizec                 C      dS NrC   rC   rN  rC   rC   rD   rS    rt  zIntegerIndexer.get_shapec                 C   s   | j | j| j |  fS r-  )r   r=   addrQ  rN  rC   rC   rD   rT    s   zIntegerIndexer.get_index_boundsc                 C   s
   | j d fS r-  )r   rN  rC   rC   rD   rU       
zIntegerIndexer.loop_headc                 C   rs  r-  rC   rN  rC   rC   rD   rV    rt  zIntegerIndexer.loop_tailNrq  rC   rC   rC   rD   rr    s    rr  c                   @   rX  )IntegerArrayIndexerz;
    Compute indices from an array of integer indices.
    c                 C   s@   || _ || _|| _|| _|| _|jdksJ | j tj| _	d S ru  )
rw   r=   r   r   r   rj   r   r   r   r[  )rT   rw   r=   r   r   r   rC   rC   rD   r\    s   zIntegerArrayIndexer.__init__c                 C   sD   | j }t|| jjd | _t|| j| _|	 | _
|	 | _d S r   )r=   r	   r   r   r_   idx_sizerR   r[  	idx_indexr]  r^  r_  r`  rC   rC   rD   rO    s
   
zIntegerArrayIndexer.preparec                 C   ra  r-  r|  rN  rC   rC   rD   rQ    rc  zIntegerArrayIndexer.get_sizec                 C   rd  r-  r~  rN  rC   rC   rD   rS     re  zIntegerArrayIndexer.get_shapec                 C   rf  r   rg  rN  rC   rC   rD   rT    rh  z$IntegerArrayIndexer.get_index_boundsc                 C   s   | j }| j t| jd| j || j || j || j}|j	|
d|| jdd || j W d    n1 s?w   Y  t| j|| jj| j| j|}t| j|| jj|| j}||fS ri  )r=   r  r   r[  r}  rk  r^  rl  r>   r   r   r|  r_  r   rw   r   ru   r   r   r   )rT   r=   rm  r   rC   rC   rD   rU    s&   zIntegerArrayIndexer.loop_headc                 C   rn  r-  )
r=   r	   r  r>   r}  r  rk  r^  rl  r_  ro  rC   rC   rD   rV    s   
zIntegerArrayIndexer.loop_tailNrq  rC   rC   rC   rD   r{    s    	r{  c                   @   rX  )BooleanArrayIndexerz>
    Compute indices from an array of boolean predicates.
    c                 C   sH   || _ || _|| _|| _|jdksJ | j tj| _t	| jd| _
d S NrF   r   )rw   r=   r   r   rj   r   r   r   r[  r   r   )rT   rw   r=   r   r   rC   rC   rD   r\  *  s   zBooleanArrayIndexer.__init__c                 C   s^   | j }t|| jjd | _t|| j| _t|| j| _	|
 | _|
 | _|
 | _d S r   )r=   r	   r   r   r_   r   rR   r[  r}  r   r]  r^  bb_tailr_  r`  rC   rC   rD   rO  3  s   

zBooleanArrayIndexer.preparec                 C   s   | j }t|| j}t|| j-}||}t| j|| j	j
| j	| j|j}|||||j}||| W d    n1 sAw   Y  ||S r-  )r=   r	   r   r   	for_ranger   r>   r   rw   r   ru   r   r   ry  zextr9   r  )rT   r=   r   loopcpredrC   rC   rD   rQ  <  s   

	zBooleanArrayIndexer.get_sizec                 C   
   |   fS r-  rQ  rN  rC   rC   rD   rS  K  rz  zBooleanArrayIndexer.get_shapec                 C   rf  r   rg  rN  rC   rC   rD   rT  N  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    n1 sKw   Y  t| j|| jj| j| j|}|	|| || j W d    n1 sww   Y  t||}||| j ||fS )Nrj  FrB  )r=   r  r   r}  r   rk  r^  rl  r>   r   r   r   r_  r   rw   r   ru   r   not_r  r	   r  )rT   r=   rm  	cur_countr  
next_countrC   rC   rD   rU  S  s,   zBooleanArrayIndexer.loop_headc                 C   s\   | j }|| j || j t||| j}||| j || j	 || j
 d S r-  )r=   rk  r  rl  r	   r  r>   r}  r  r^  r_  ro  rC   rC   rD   rV  k  s   
zBooleanArrayIndexer.loop_tailNrq  rC   rC   rC   rD   r  %  s    		r  c                   @   rX  )SliceIndexerz(
    Compute indices along a slice.
    c                 C   sL   || _ || _|| _|| _|| _|| _|| _| j tj	| _
t| j
d| _d S r   )rw   r=   r   r   rZ  r   r"  r   r   r   r[  r   r   )rT   rw   r=   r   r   rZ  r   r"  rC   rC   rD   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 r-  )r=   r=  r   r_   rZ  dim_sizer-   r  rw   r   r"  r  r	   
is_neg_intstepis_step_negativerR   r[  r   r   r]  r^  r_  r`  rC   rC   rD   rO    s   
zSliceIndexer.preparec                 C   s   t | j| jS r-  )r-   r  r=   r"  rN  rC   rC   rD   rQ       zSliceIndexer.get_sizec                 C   r  r-  r  rN  rC   rC   rD   rS    rz  zSliceIndexer.get_shapec                 C   s   t | j| j\}}||fS r-  )r-   get_slice_boundsr=   r"  )rT   lowerupperrC   rC   rD   rT    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    ||fS 1 s_w   Y  ||fS )Nz<=rj  FrB  )r=   r  r"  r  r   r   r   rk  r^  rl  r>   selectr  r   stopr   r_  )rT   r=   rm  r  is_finishedrC   rC   rD   rU    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=   ry  r>   r   r"  r  r  r	   r  r   rk  r^  rl  r_  )rT   r=   rp  r  rC   rC   rD   rV    s   zSliceIndexer.loop_tailNrq  rC   rC   rC   rD   r  v  s    r  c                   @   rK  )FancyIndexerz4
    Perform fancy indexing on the given array.
    c              	   C   s|  || _ || _|| _t||j|j| _t||j|j| _| j 	t
j| _g | _g }tdd |D }d}	d}
t||D ]\}}|t
ju rm|jt| d | }t|D ]}t|||||	}|| |	d7 }	|
d7 }
qTq<t|t
jr||||}t|||||	||}|| nkt|t
jrt||||| j|	 }t|||}|| nNt|t
jrt||||}t|jt
jrt||||| j|	 }nt|jt
jrt ||||}nJ || nt!|r| j|
 |	d8 }	nt"d|f |	d7 }	|
d7 }
q<|	|jksJ |	|jf|	|jk r(t|||||	}|| |	d7 }	|	|jk st||jks9J t||jf|| _#d S )Nc                 S   r	  rC   r
  r  rC   rC   rD   r     r  z)FancyIndexer.__init__.<locals>.<listcomp>r   rF   r  )$rw   r=   r   r	   r   r_   rj   r   r   r   r   r   r[  newaxesr   r   r  r8   rY  rc   r   r  r   r  r   r   rr  r   rs   ru   r{  Booleanr  r   AssertionErrorindexers)rT   rw   r=   r   r   r   r   r  r  r  new_axr   r   r!  rg   indexerr"  r   r   rC   rC   rD   r\    sv   






"
zFancyIndexer.__init__c                 C   s^   | j D ]}|  q| jtjd}dd | j D }| jD ]	}|||f qt|d| _	d S )NrF   c                 S      g | ]}|  qS rC   )rS  r   rg   rC   rC   rD   r   	      z(FancyIndexer.prepare.<locals>.<listcomp>rC   )
r  rO  rw   r   r   r   r  insertsumindexers_shape)rT   rg   r  	res_shaperC   rC   rD   rO    s   


zFancyIndexer.preparec                 C   ra  )z?
        Get the resulting data shape as Python tuple.
        )r  rN  rC   rC   rD   rS    s   zFancyIndexer.get_shapec              	   C   s  t || jjks
J | j}tj}| d}| d}|}|}t| j| j	|D ]C\}	}
}|
||d|
|}|	 \}}|||}|||||}|d||}||||||}||||||}q&|||}||||}||||}||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   rF   ==r   )r   r   rj   r=   r	   	false_bitr[  r   r  r  or_icmp_unsignedrT  r   subr   ry  r  )rT   r   r   r=   is_emptyr   r  r  r  r  r_   stridelower_indexupper_indexlower_offsetupper_offsetis_downwardsrC   rC   rD   get_offset_bounds  sB   


zFancyIndexer.get_offset_boundsc                 C   s    t dd | jD  \}}||fS )Nc                 s   s    | ]}|  V  qd S r-  )rU  r  rC   rC   rD   r0  B  s    z+FancyIndexer.begin_loops.<locals>.<genexpr>)r   r  )rT   r   countsrC   rC   rD   begin_loopsA  s   zFancyIndexer.begin_loopsc                 C   s   t | jD ]}|  qd S r-  )reversedr  rV  )rT   rg   rC   rC   rD   	end_loopsE  s   
zFancyIndexer.end_loopsN)
rk   rl   rm   rW  r\  rO  rS  r  r  r  rC   rC   rC   rD   r    s    B&r  c                 C   s  t ||j}t ||j}	|j}
t| |||||}|  |j}| }t	| |||}|j}t 
|| tjd}| \}}t j| ||
||	|j|d| jd	}t| |||}||}|||g}t| |||| t ||}||| |  t| ||| S )Nr   Fr  )r	   r   r_   r   r   r  rO  r   rS  _empty_nd_implr   r   r   r   r  get_item_pointer2layoutr(  r   r>   gepr   r  r  r  r!   r   )rw   r=   rV   r   r   r   r   r   r   r   r   r  out_ty
out_shapesr   out_dataout_idx_re   r   curnext_idxrC   rC   rD   r3  J  s6   

r3  c           	   	   C   s   |j \}}|\}}t|| ||}|jdkr4t| |||\}}t| ||j|||f|f}t| ||j|S t| ||||||f|fS )z3
    Advanced or basic indexing with an array.
    r   )r   rs   rj   r   r)  r   r    r3  r*  rC   rC   rD   fancy_getitem_arrayu  s   



r  c              	   C   s   |j }|d}|d}|jdv r|}	|||j}
|	|
fS |}	|}
t|jD ]-}||| ||| |}|d||}|	||
|
||
}
|	||	|
|	|}	q(|
|
|}
|d|j|}|	|||
}
|	|||	}	|	|
fS )z
    Compute a half-open range [lower, upper) of byte offsets from the
    array's data pointer, that bound the in-memory extent of the array.

    This mimics offset_bounds_from_strides() from
    numpy/core/src/private/mem_overlap.c
    r   rF   CFrj  r  )r   r9   r  r   r   r8   rj   r  r   r  ry  )rw   r=   arrtyarrr   r   r   r   r  r  r  rg   max_axis_offset
is_upwardsr  rC   rC   rD   offset_bounds_from_strides  s2   



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.
    )ptrtointr9   ry  )rw   r=   r  r  r   data_ptr_as_intr  endrC   rC   rD   compute_memory_extents  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  )	rw   r=   r  r  r   r   r   r  r  rC   rC   rD   get_array_memory_extents  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  )rw   r=   a_starta_endb_startb_endmay_overlaprC   rC   rD   extents_may_overlap  s
   r  c                    s@  j dt d  jddc  |j|j}j |}	|	j  	|	}	 
|	 tj}
t |
(}t 	
j|}t |	|} 
 || W d    n1 smw   Y  W d    n1 s|w   Y   	
fdd} fdd}||fS )Nr   FrB  c                    s   t  } jddT\}}|  t j  | dd| W d    n1 s1w   Y  |  t j 	
j| dd| W d    n1 sUw   Y  W d    n1 sdw   Y  t 
 |S )NFrB  r  )r	   rR   if_elser  r  r>   r  r   )source_indicessrc_ptrif_copy	otherwise)r=   rw   	copy_datacopy_layoutcopy_shapescopy_stridesptrtysrc_data
src_shapessrc_stridessrctyuse_copyrC   rD   src_getitem  s4   
z&maybe_copy_source.<locals>.src_getitemc                     sX    j dd  }  | } j |  W d    d S 1 s%w   Y  d S )NFrB  )r   r>   bitcastr   freer   )r=   rw   r  r  	voidptrtyrC   rD   src_cleanup	  s
   
"z&maybe_copy_source.<locals>.src_cleanup)r9   r	   r   r   r   r   r   r   allocater  r  r   r   r   	loop_nestr  r  r>   )rw   r=   r  r  srcr  r  r  	allocsizer   r   r   r  dest_ptrr  r  rC   )r=   rw   r  r  r  r  r  r  r  r  r  r  r  rD   maybe_copy_source  s8   

"r  c           
         s  |  tjd}|  tjdt|t|kr0t|t| }g| | }|g| | }||fS t|t|k rt|t| } fdd|d| D }t j|tj} j	 
|dd d}	| j t|	f W d   n1 sww   Y  ||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   rF   c                       g | ]	}  d |qS r  )r  r   r#  r=   r  rC   rD   r   )      z(_bc_adjust_dimension.<locals>.<listcomp>NFrB  z,cannot broadcast source array for assignment)r   r   r   r   	functoolsreducer  r	   true_bitr   r  rD  rE  r   )
rw   r=   r   r   target_shaper   nd_diff
dim_is_oneacceptedr   rC   r  rD   _bc_adjust_dimension  s,   	

r  c           
         s   g }g }|  tjd|  tjd fddt||D } fdd|D } fddt||D }	 fddt|	||D } fddt|	|D }||fS )	z
    Broadcast shapes and strides to target_shape given that their ndim already
    matches.  For each location where the shape is 1 and does not match the
    dim for target, it is set to the value at the target and the stride is
    set to zero.
    r   rF   c                    s   g | ]\}}  d ||qS )rA  r   )r   taroldr=   rC   rD   r   D      z,_bc_adjust_shape_strides.<locals>.<listcomp>c                    r  r  r  )r   r   r  rC   rD   r   F      c                    s   g | ]
\}}  ||qS rC   )r  )r   xyr  rC   rD   r   G      c                    s    g | ]\}}}  |||qS rC   r  )r   pr  r   r  rC   rD   r   H  s    c                    s   g | ]\}}  ||qS rC   r  )r   r  r   )r=   r   rC   rD   r   J  r  )r   r   r   r   )
rw   r=   r   r   r  	bc_shapes
bc_stridesmismatch
src_is_onepredsrC   )r=   r  r   rD   _bc_adjust_shape_strides8  s    


r  c           	   	   C   s   t ||j}t ||j}t| ||||\}}t| ||||\}}|jt|dd}t|| |}t	||j
t ||t |||j|j|jd ||fS )zX
    Broadcast the given array to the target_shape.
    Returns (array_type, array)
    Arj   r  r&  )r	   r   r_   r   r  r  copyr   rs   r   r   rd   r   r   r   )	rw   r=   arrtyper  r  r   r   new_arrtypenew_arrrC   rC   rD   _broadcast_to_shapeO  s&   


r  c                 C   s,   |j |jddd}|||}dd }||fS )Nr  T)rj   r  readonlyc           
   	   S   sz   |\}}|j d }t|| ||}t||}t| ||||\}}t|dt| |j	dd  |
 }	t| ||j|	S )Nr   r   )r   rs   r	   r   r  r   r   r   r   r   r   r    r   )
rw   r=   rV   r   r  shape_r  r  destr   rC   rC   rD   codegenn  s   
z$_numpy_broadcast_to.<locals>.codegen)r  r   )	typingctxr   r_   retrV   r  rC   rC   rD   _numpy_broadcast_toi  s   
r  c                 C   s$   |j dd}||}dd }||fS )NTr  c                 S   sH   |\}|j d }t|| ||}t|jj|_| }t| ||j|S r   )	r   rs   r	   get_null_valuer   r9   r   r    r   )rw   r=   rV   r   r  r  r  r   rC   rC   rD   r    s   
z#get_readonly_array.<locals>.codegen)r  )r  r  r  rV   r  rC   rC   rD   get_readonly_array  s   	r  c           
      C   s   | j }t|}t|}||krtd|D ]
}|dk rtdqd}|| }||k rM|| }|| }	||	ks:|dkrC|d7 }|d7 }ntd||k s*d S d S )NzDinput operand has more dimensions than allowed by the axis remappingr   z4all elements of broadcast shape must be non-negativerF   z=operands could not be broadcast together with remapped shapes)r_   r   r   )
r   
dest_shape	src_shapesrc_ndim	dest_ndimr   	src_index
dest_indexsrc_dimdest_dimrC   rC   rD   _can_broadcast  s&   
r(  c                 C   s   t | } t| | t| |S r-  )npasarrayr(  r  r   r_   rC   rC   rD   _default_broadcast_to_impl  s   


r,  c                 C   s   t | s	tdt|tjrdd }|S t|tjr+t|jtjs)d}t|tS t|tj	rL|j
dkrLtdd |D sJd| d	}t|tS t|tj	ru|j
dkrut| tjoa| jdk}t| sh|rnd
d }|S d}t|d| }t|)Nz-The first argument "array" must be array-likec                 S   s   t | |fS r-  )r)  broadcast_tor+  rC   rC   rD   r        z numpy_broadcast_to.<locals>.implz7The second argument "shape" must be a tuple of integersr   c                 S      g | ]}t |tjqS rC   )r   r   IntegerLiteral)r   typrC   rC   rD   r     r  z&numpy_broadcast_to.<locals>.<listcomp>"z," object cannot be interpreted as an integerc                 S   s   t | } t| S r-  )r)  r*  r  r+  rC   rC   rD   r     s   
z/Cannot broadcast a non-scalar to a scalar arrayz:The argument "shape" must be a tuple or an integer. Got %s)r   r   r   r   r   r   UniTupleru   r,  Tupler   allr   rj   r   )r   r_   r   r   is_scalar_arrayrC   rC   rD   numpy_broadcast_to  s4   




r7  c                 C   sr   t t|D ]0}|t| | }|| }|dk rtd|dkr!q| | dkr,|| |< q| | |kr6tdqd S )Nr   #negative dimensions are not allowedrF   z=shape mismatch: objects cannot be broadcast to a single shape)r8   r   r   )rmr_   rg   r   tmprC   rC   rD   numpy_broadcast_shapes_list  s   
r<  c                     s   t | D ]7\}}t|tj}t|tjot|jtj}t|tjo't|jdk}|s;|s;|s;d| d| }t	|qd | D ]}t|tjrNt
 d q@t|tjr[t
 t| q@ dkrddd S d   fdd	}|S )
Nr   z	Argument z* must be either an int or tuple[int]. Got rF   c                  W   rw  rx  rC   r   rC   rC   rD   <lambda>
      z+ol_numpy_broadcast_shapes.<locals>.<lambda>rF   c                     sz   dg  }}t | D ] }t|trt|dkrt| | qt|tr+t| |f qt|D ]
\}}t|||}q0|S r  )r   r   r   r   r<  r   	enumerater0   )r   r9  r5  argr   elemr:  tup_initrC   rD   r     s   

z'ol_numpy_broadcast_shapes.<locals>.impl)rA  r   r   r   r3  ru   r4  r   r   r   maxr7  )r   r   rB  is_intis_int_tupleis_empty_tupler   r   rC   rD  rD   ol_numpy_broadcast_shapes  s0   
rJ  c                     s   t | D ]\}}t|std| dqd }d }| D ]$}t|tjtjfr+|j}n|}|d u r4|}q||kr@td|  qd t | D ])\}}t|tj	rXt
 |j qGt|tjtjtjfrit
 d qGtd| d   fdd	}|S )
Nz
Argument "z" must be array-likezTMismatch of argument types. Numba cannot broadcast arrays with different types. Got r   rF   zUnhandled type r   c                     s|   dg  }t | D ]}t| t|j q	}t D ]
}t|||| }qg }t | D ]}|tt|| q-|S ru  )	r   r<  r)  r*  r_   r8   r0   rc   r-  )r   r_   r   r5  rg   outsrD  rC   rD   r   @  s   
z$numpy_broadcast_arrays.<locals>.impl)rA  r   r   r   r   r   r   r7  ru   ArrayCompatiblerF  rj   Numberr  )r   r   rB  unified_dtypedtr   rC   rD  rD   numpy_broadcast_arrays  s6   rQ  c                 C   rM  )zTargets should implement this if they wish to specialize the error
    handling/messages. The overload implementation takes two tuples as arguments
    and should raise a ValueError.r   r  index_shaperC   rC   rD   raise_with_shape_contextW  rR  rT  generic)targetc                 C   N   t | tjrt |tjr!| j|jkr#t | jtjr%dd }|S d S d S d S d S )Nc                 S      t d)Nz0cannot assign slice from input of different sizer   rR  rC   rC   rD   r   g  re  z1ol_raise_with_shape_context_generic.<locals>.implr   r   r3  ru   r   r  rS  r   rC   rC   rD   #ol_raise_with_shape_context_generic^  s   
r[  CPUc                 C   rW  )Nc                 S   s   t | dkrd| d  d}ndddd | D  d}t |dkr,d|d  d}nddd	d |D  d}d
| d| }t|)NrF   (r   z,), c                 S      g | ]}t |qS rC   strr   r  rC   rC   rD   r   w  r  zAol_raise_with_shape_context_cpu.<locals>.impl.<locals>.<listcomp>)c                 S   r_  rC   r`  rb  rC   rC   rD   r   {  r  zcannot assign slice of shape z from input of shape )r   joinr   )r  rS  	shape_str	index_strr   rC   rC   rD   r   s  s   z-ol_raise_with_shape_context_cpu.<locals>.implrY  rZ  rC   rC   rD   ol_raise_with_shape_context_cpul  s   
rg  c           '         s:  |j \}}|\}}t| |}t |j}	t |j}
|j}t ||||}|  dd }t	t
jrۈj| }t t |\t j}t j}j}tj}t|t|ksrJ t||D ]\}} | d||}qw j|dd | || W d   n1 sw   Y  t |||\}}||
|j\}}t |||\}}t ||||}t ||||\}}nmt	t
jr<j| }t|dksJ ttt
j}| f} d|d |} j|dd | |f|d f W d   n	1 s(w   Y   fd	d
}dd }nfdd
}dd }t
j d} |! \}!}"t"|"}"|j#D ]	}#|"$|#|  q\dd |"D }$||$}%% |%|j}%tj& ||	|
|j'|!dj(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.
    c                 S   s~   | j t}ttjt|ttjt|f}|| j |i }| ||}||| 	||j
d || 	||j
d |f d S Nr   rF   )typing_contextresolve_value_typerT  r   r3  int64r   get_call_typerL   
make_tupler   )rw   r=   r  rS  fntyargtys	raise_sigfuncrC   rC   rD   raise_shape_mismatch_error  s   
z2fancy_setslice.<locals>.raise_shape_mismatch_errorrA  FrB  NrF   r   c                    s,   | \} tjttj}| |fS r-  )rL   operatorgetitemr$   r   r   )r  r   getitem_implr=   rw   r  	src_dtyper  rC   rD   r    s   z#fancy_setslice.<locals>.src_getitemc                   S   rs  r-  rC   rC   rC   rC   rD   r    rt  z#fancy_setslice.<locals>.src_cleanupc                    s    S r-  rC   )r  )r  rC   rD   r    rt  c                   S   rs  r-  rC   rC   rC   rC   rD   r    rt  c                 S   s   g | ]}|d ur|qS r-  rC   )r   r  rC   rC   rD   r     r  z"fancy_setslice.<locals>.<listcomp>r  ),r   rs   r	   r   r_   r   r   r  rO  r   r   r   ru   rS  r  r  r   r   r  r   r   r  r  r   r  r  r  SequencerL   r$   r   r   r   r  r   r  r  r   r  r  r(  r   r  rI  )'rw   r=   rV   r   r   r   r   r  r   dest_shapesdest_strides	dest_datar  rr  rS  r  r  r  shape_errorur   	src_startsrc_end
dest_lower
dest_upper
dest_startdest_endr  r  r  len_implseq_lenr   dest_indicesr  rg   r  r   r  rC   rv  rD   r9    s   








r9  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   rF   c                    "   g | ]\}}  ||tjqS rC   r   r   r   )r   r/  r   r   rC   rD   r   $      z#vararg_to_tuple.<locals>.<listcomp>ru   r   )r   r   r	   rd   r9   r   r3  r   r   r   r$   r   )rw   r=   rV   r   r   dimtysr   rf   r_   shapetynew_signew_argsrC   r   rD   vararg_to_tuple  s   
r  zarray.transposec                 C   s   t | ||jd |d S r   )array_Tr   rw   r=   rV   r   rC   rC   rD   array_transpose0  s   r  c                 C   sn   t | t t| krtdt |}| D ]}||ks t||kr$tdq||  |d d < ||  |d d < d S )Nzrepeated axis in transposez2axis is out of bounds for array of given dimension)r   r   r   abs)r   r_   r   rZ  r  rC   rC   rD   permute_arrays5  s   r  c              
      s  |j d }t| |d }|j d |d }}|j|j}}	tj}
t|
|||j	|j
g} fdd|D }t||D ]
\}} || qBtj|	dddtj|
} fdd|D }t||D ]\}}t| ||
 tj|g|g|d d qo tttjd	d |D  t|j }t||j |d  |d
 |j|j|jd | }t |j|S )Nr   rF   c                       g | ]}t  qS rC   r	   rR   r   r  )r=   ll_ary_sizerC   rD   r   Q  r  z)array_transpose_tuple.<locals>.<listcomp>r   ru   rj   r  c                    s   g | ]	}t  qS rC   rs   r  )r=   rw   	np_ary_tyrC   rD   r   \  r  r   r_   r   r   r   c                 S   r  rC   r   r   arC   rC   rD   r   l  r  rH  r&  ) r   rs   r   ru   r   r   r   r   	ArrayTyper_   r   r   r  r   r   rv   r   r  
as_pointercompile_internalr  r   r$   voidr   r   r>   r   r   r   r   r    )rw   r=   rV   r   r   r   axistyr   num_axisru   r[  arysll_arysr  dstnp_itemsizenp_arysnp_aryll_aryr  r   rC   )r=   rw   r  r  rD   array_transpose_tupleD  sP   
	r  c                 C       t | |||\}}t| |||S r-  )r  r  rw   r=   rV   r   r  r  rC   rC   rD   array_transpose_vararg{     r  c                 C   s:   t | tjrtd|d u rddd}|S ddd}|S )Nz#np.transpose does not accept tuplesc                 S      |   S r-  	transposer  axesrC   rC   rD   np_transpose_impl  re  z*numpy_transpose.<locals>.np_transpose_implc                 S   
   |  |S r-  r  r  rC   rC   rD   r    rz  r-  )r   r   r7  r   r   )r  r  r  rC   rC   rD   numpy_transpose  s   


r  Tc           	      C   s   |j dkr|}nFt|| ||}t|| |}t||j|j }t||j|j }t||jt||d d d t||d d d |j	|j
|jd | }t| |||S )NrF   r&  )rj   rs   r	   r   r_   r   r   r   rd   r   r   r   r   r    )	rw   r=   r1  r   r   r   r  r   r   rC   rC   rD   r    s    
r  2   c                 C   sT   t | tjstdt |tjstdt |ttjfs#tdddd}|S )Nz+The first argument "start" must be a numberz+The second argument "stop" must be a numberz+The third argument "num" must be an integerr  c                 S   s   t | ||}t d|S )Ng      $@)r)  linspacepower)r  r  numr  rC   rC   rD   r     s   znumpy_logspace.<locals>.implr  )r   r   rN  r   r   r   r   )r  r  r  r   rC   rC   rD   numpy_logspace  s   



r  c                    s   t | tjsd}t|t |tjsd}t|t |ttjfs)d}t|tdd | |fD rJtt	
t| t|d  d
 fdd	}|S d
d	d}|S )Nz%The argument "start" must be a numberz$The argument "stop" must be a number%The argument "num" must be an integerc                 s   r,  r-  r   r   Complexr   rB  rC   rC   rD   r0    r1  z"numpy_geomspace.<locals>.<genexpr>r  c           	         s   | dks|dkrt d | }  |}tdk rH| jdk|jdk@ }t| dkt|dk@ }d}|r<| j} |j}d}|rG|  } | }| }nt| }| | } || }t| }t|}t|||}|dkrv| |d< |dkrv||d< || S )Nr   &Geometric sequence cannot include zerorG  r  rF   y              ?)r   r   realr)  signimaglog10logspace)	r  r  r  both_imaginaryboth_negativeout_signlogstartlogstopr  result_dtyperC   rD   r     s8   


znumpy_geomspace.<locals>.implc                 S   s   | dks|dkrt dt| dkt|dk@ }d}|r'|  } | }| }t| }t|}t|||}|dkrH| |d< |dkrH||d< || S )Nr   r  r  rF   )r   r)  r  r  r  )r  r  r  r  r  r  r  r  rC   rC   rD   r     s    

r  )r   r   rN  r   r   r   r   r2  r   r)  result_typer   )r  r  r  r   r   rC   r  rD   numpy_geomspace  s"   


8
r  rF   c                 C   sR   t |ttjfstdt | tjstd| jdk r"tdddd}|S )	Nz*The second argument "k" must be an integerz'The first argument "m" must be an arrayrH  Input must be >= 2-d.rF   c                 S   sp   |d }|dkr| d d  S |dkrt t | ddS |dkr(t t | S |dkr6t t | ddS t)N   r   rF   rH     )r)  swapaxesfliplrflipudr  )r:  r   rC   rC   rD   r     s   znumpy_rot90.<locals>.implr@  )	r   r   r   r   r   r   r   rj   NumbaValueError)r:  r   r   rC   rC   rD   numpy_rot90  s   




r  c                 C   s   |  tj}| }|  tj}	t|	||||||||	g}
t|j	|
d}||j
}t||ddd}t||ddd}||}t||dd}t||dd}|	d}|||||||||j|g}|S )a  
    Call into Numba_attempt_nocopy_reshape() for the given array type
    and instance, and the specified new shape.

    Return value is non-zero if successful, and the array pointed to
    by *newstrides* will be filled up with the computed results.
    numba_attempt_nocopy_reshaper_   r   r   )r   r   r   r  intcr   FunctionTyper	   get_or_insert_functionr:   rj   rb   ra   callr   )rw   r=   r   r   newndnewshape
newstridesr[  ll_intp_starll_intcrn  fnndr_   r   
is_f_orderr   rC   rC   rD   _attempt_nocopy_reshape  s2   	

r  c           	      C   s   d}d}t |D ]\}}|dk r|d7 }|}q||9 }q|dkr*| |kr(tdd S |dkrO|dkr9d}| dk}n
| | }| | dk}|sItd|||< d S td)Nr   rF   z)total size of new array must be unchangedzmultiple negative shape values)rA  r   )	origsizer_   num_neg_value
known_sizer  r   neg_axinferredokrC   rC   rD   normalize_reshape_value@  s*   

r  zarray.reshapec              	   C   s  |j d }|j}|j d }|d }| tj}t||j}	t|| ||d }
t	
||	}||| tj|jddd}t|| |}| tj| |}t|||| | tj|jg|g|d d |
j}| |tttjtj||| g |j}t	
||	}t| |||
|||}|d||d}|| d}| j |t!|f W d    n1 sw   Y  t|| |}t||
j"|#||#||
j$|
j%|
j&d | }t'| ||j|S )	Nr   rF   r   r  r  r  zincompatible shape for arrayr&  )(r   r   r   r   r   r   r  r   rs   r	   rR   r  r   ru   r   rv   r   r  r  r   r  r  r   r$   r  r   r   r  r  r9   r   rD  rE  rM   r   r>   r   r   r   r    )rw   r=   rV   r   r   rettyr  r_   r[  ll_shaper   r  shape_ary_ty	shape_aryshape_itemsizer   r  r  r  failr   r  r   rC   rC   rD   array_reshape^  sb   


r  c                 C   r  r-  )r  r  r  rC   rC   rD   array_reshape_vararg  r  r  )rH  rF   c                 C      dd }|S )Nc                 S   r  r-  reshape)r  r  rC   rC   rD   np_reshape_impl  rz  #np_reshape.<locals>.np_reshape_implrC   )r  r  r  rC   rC   rD   
np_reshape     r  c                 C   r  )Nc                 S   r  r-  r  )r  r_   rC   rC   rD   r    rz  r  rC   )r  r_   r  rC   rC   rD   r    r   c                 C   sV   t | sd}t|t|tjrt|jtjs%t|tjs%d}t|dd }|S )N#The argument "a" must be array-likezBThe argument "new_shape" must be an integer or a tuple of integersc           	      S   s   t | } t | } t|tr(d}t |D ]}||9 }|dk r&d}t|qn|dk r2d}t||}| jdkrBt || j	S | | j  }| }t
|d D ]	}t || f}qQ|d | }t ||S )NrF   r   z0All elements of `new_shape` must be non-negative)r)  r*  ravelr   r   r   r   zerosastyperu   r8   concatenater  )	r  	new_shapenew_size
dim_lengthr   msg2repeatsr   rg   rC   rC   rD   r     s.   



znumpy_resize.<locals>.impl)r   r   r   r   r   r3  ru   r   )r  r  r   r   rC   rC   rD   numpy_resize  s   


r  c                 C   s^   t | s	tdt |stdt|rddd}|S t|tjs(tdddd}|S )Nz+The first argument "arr" must be array-likez/The second argument "values" must be array-likec                 S   s.   t t | } t t |}t | |fS r-  )r)  r  r*  r  r  valuesr   rC   rC   rD   r     s   znp_append.<locals>.implz,The third argument "axis" must be an integerc                 S   s   t j| |f|dS Nr   r)  r  r  rC   rC   rD   r        r-  )r   r   r   r   r   r   r   )r  r  r   r   rC   rC   rD   	np_append  s   




r  zarray.ravelc                 C   sN   dd }dd }|j d jdkr|}n|}| ||||}t| ||j|}|S )Nc                 S   s   |  | jS )zNo copy version)r  r   r   rC   rC   rD   
imp_nocopy     zarray_ravel.<locals>.imp_nocopyc                 S   r  )zCopy version)flattenr  rC   rC   rD   imp_copy	     zarray_ravel.<locals>.imp_copyr   r   )r   r  r  r!   r   )rw   r=   rV   r   r  r  impr   rC   rC   rD   array_ravel  s   r  c                 C   s   dd }|  ||||S )Nc                 S   r  r-  )r  r  rC   rC   rD   np_ravel_impl	  re  znp_ravel.<locals>.np_ravel_impl)r  )rw   r=   rV   r   r  rC   rC   rD   np_ravel	  s   r  zarray.flattenc                 C   s,   dd }|  ||||}t| ||j|}|S )Nc                 S   s   |   | jS r-  )r  r  r   r  rC   rC   rD   r  	  r  zarray_flatten.<locals>.imp)r  r!   r   )rw   r=   rV   r   r  r   rC   rC   rD   array_flatten	  s   r  c                 C   sl   |d u r	t | n|}t | ||\}}}t |jD ]}|| }	|| }
|| }tt|	|
|||< q|S r-  )r)  
empty_likebroadcast_arraysndindexr_   minrF  )r  a_mina_maxr   r  a_ba_min_ba_max_br   val_a	val_a_min	val_a_maxrC   rC   rD   _np_clip_impl&	  s   r+  c                 C   sH   t | jD ]}| | }|| }|rt||||< qt||||< q|S r-  )r)  r!  r_   r"  rF  )r  buse_minr   r   r(  val_brC   rC   rD   _np_clip_impl_none4	  s   r/  c                 C   s^  t | s	tdt|tjst |stdt|tjs't |s'tdt|tjs8t|s8d}t||d u pAt|tj}|d u pKt|tj}|rW|rWddd}|S t|tj}t|tj}	|rn|	rnddd}
|
S |r|	s|r{dd	d
}|S ddd}|S |s|	r|rddd}|S ddd}|S |rddd}|S |rddd}|S ddd}|S )Nr  z6The argument "a_min" must be a number or an array-likez6The argument "a_max" must be a number or an array-likez5The argument "out" must be an array if it is providedc                 S   rX  )Nz&array_clip: must set either max or minr   r  r#  r$  r   rC   rC   rD   
np_clip_nnY	  re  znp_clip.<locals>.np_clip_nnc                 S   sH   |d u r	t | n|}t | jD ]}| | }tt|||||< q|S r-  )r)  r  r!  r_   r"  rF  r  r#  r$  r   r  r   r(  rC   rC   rD   
np_clip_ssb	  s
   znp_clip.<locals>.np_clip_ssc                 S   sB   |d u r	t | n|}t | jD ]}| | }t||||< q|S r-  )r)  r  r!  r_   rF  r2  rC   rC   rD   
np_clip_snp	  
   znp_clip.<locals>.np_clip_snc                 S   s   t | |}t| |||S r-  r)  	full_liker+  )r  r#  r$  r   
a_min_fullrC   rC   rD   
np_clip_sa}	     znp_clip.<locals>.np_clip_sac                 S   sB   |d u r	t | n|}t | jD ]}| | }t||||< q|S r-  )r)  r  r!  r_   r"  r2  rC   rC   rD   
np_clip_ns	  r5  znp_clip.<locals>.np_clip_nsc                 S   s   t | |}t| |||S r-  r6  )r  r#  r$  r   
a_max_fullrC   rC   rD   
np_clip_as	  r:  znp_clip.<locals>.np_clip_asc                 S   s4   |d u r	t | n|}t | |\}}t||d|S )NTr)  r  r   r/  )r  r#  r$  r   r  r%  r'  rC   rC   rD   
np_clip_na	     znp_clip.<locals>.np_clip_nac                 S   s4   |d u r	t | n|}t | |\}}t||d|S )NFr>  )r  r#  r$  r   r  r%  r&  rC   rC   rD   
np_clip_an	  r@  znp_clip.<locals>.np_clip_anc                 S      t | |||S r-  )r+  r0  rC   rC   rD   
np_clip_aa	  s   znp_clip.<locals>.np_clip_aar-  )	r   r   r   r   r   NoneTyper   r   rN  )r  r#  r$  r   r   a_min_is_nonea_max_is_noner1  a_min_is_scalara_max_is_scalarr3  r4  r9  r;  r=  r?  rA  rC  rC   rC   rD   np_clip@	  sV   












rI  clipc                 C   s   ddd}|S )Nc                 S   s   t | |||S r-  )r)  rJ  r0  rC   rC   rD   r   	  r  zarray_clip.<locals>.implNNNrC   )r  r#  r$  r   r   rC   rC   rD   
array_clip	  s   
rL  c              	      s  |j |j ksJ |j|jksJ t|j}td tdtdtj fdd}| tjt| |}| tjt| |}| tj|j }	t	||
ddd}
t	||
ddd}tjtjd	dd
}| |}t|| tj|j g}| | tj}| tj|}t||g}|| |}t||
|||dd || |}t|||||dd | }| }|	||||| tj|g}ttjtj||tjtjtj}| ||||}t|| t| ||j|}|S )a  
    Attempt to fix up *ary* for switching from *oldty* to *newty*.

    See Numpy's array_descr_set()
    (np/core/src/multiarray/getset.c).
    Attempt to fix the array's shape and strides for a new dtype.
    False is returned on failure, True on success.
    r  r   Fc           	         s   | kr|d |kr}n
|d |kr}||kr'| ks%| dkr'dS |kr0| d }nd}||k rP|| dkr>dS || }||  |9  < |||< dS ||krn|| | }|| dkrbdS || ||< |||< dS 	 dS )Nr  r   FrF   TrC   )	r  rf   r   old_itemsizenew_itemsizer  rg   newdim
bytelength
any_layoutc_layoutf_layoutint8rC   rD   r  	  s4   

z_change_dtype.<locals>.impr_   r   r   rF   r  Nr  )rj   r  ordr   rV  r   r   ry   r	   rb   ra   r   rs   rd   rv   rt   r   r   r$   booleanr  r   r    r   )rw   r=   oldtynewtyr   
new_layoutr  rN  rO  r  
shape_datastrides_datashape_strides_array_typearyclsshape_constantsizeof_intpstrides_constantr  strides_aryr_   r   r   rV   r   rC   rR  rD   _change_dtype	  s   	
0



	
rd  c                 C      t | s	tddd }|S )Nz+The argument to np.shape must be array-likec                 S      t | jS r-  )r)  r*  r_   r  rC   rC   rD   r   D
  rv  znp_shape.<locals>.implr   r   r   r  r   rC   rC   rD   np_shape?
     
ri  c                 C   re  )Nz*The argument to np.size must be array-likec                 S   rf  r-  )r)  r*  r   r  rC   rC   rD   r   N
  rv  znp_size.<locals>.implrg  rh  rC   rC   rD   np_sizeI
  rj  rk  c                 C      dd }|S )Nc                    sT   dd t |   t d d } fddt dd  D }t || S )Nc                 S   s
   | | k S r-  rC   )r  rC   rC   rD   isnanX
     
z0np_unique.<locals>.np_unique_impl.<locals>.isnanrF   c                    s4   g | ]\}} | |kr | r|s|qS rC   rC   )r   rg   r  r,  rm  rC   rD   r   ]
  s
     z5np_unique.<locals>.np_unique_impl.<locals>.<listcomp>)r)  sortr  r   rA  r   )arheadtailrC   ro  rD   np_unique_implW
  s   z!np_unique.<locals>.np_unique_implrC   )rq  rt  rC   rC   rD   	np_uniqueU
  s   ru  c                 C   sh   dd }t | tjtjtjtjtjfr2t |tjrtS t |tjtjfr-t |j	tjr-|S t
dd S )Nc           	      S   s   t j|t jd}|jd dkrt| |d S t |dk r!tdt | }| }|jd }|j|jkr9tdt jt 	||j
d}d}t|D ]}|| |||||  < ||| 7 }qJ|S )Nru   r   rF   r8  z(operands could not be broadcast together)r)  r*  rk  r_   np_repeat_impl_repeats_scalerr2  r   r  emptyr  ru   r8   )	r  r
  repeats_arrayasaaraveln	to_returnposrg   rC   rC   rD   !np_repeat_impl_repeats_array_likej
  s$   

z4np_repeat.<locals>.np_repeat_impl_repeats_array_likezIThe repeats argument must be an integer or an array-like of integer dtype)r   r   r   Listr7  rN  r  r   rw  ru   r   r   )r  r
  r  rC   rC   rD   	np_repeate
  s    r  c                 C   s   |dk rt dt| }| }|jd }|dkr"tjd|jdS |dkr+t|S tj|| |jd}t|D ]}|| ||| |d | < q9|S )Nr   r8  rv  rF   )	r   r)  r*  r  r_   rx  ru   r  r8   )r  r
  rz  r{  r|  r}  rg   rC   rC   rD   rw  
  s   


rw  repeatc                 C   r  )Nc                 S      t | |S r-  )r)  r  )r  r
  rC   rC   rD   array_repeat_impl
  rv  z'array_repeat.<locals>.array_repeat_implrC   )r  r
  r  rC   rC   rD   array_repeat
     r  c                 C      t |}dd }||fS )z"Computes the itemsize of the dtypec                 S   s,   |  |jd j}|  |j}|| |S r   )rt   r   ru   r   rv   )cgctxr=   rV   llargsrx   llintprC   rC   rD   r  
  s   z%_intrin_get_itemsize.<locals>.codegen)r   r   )tyctxru   rV   r  rC   rC   rD   _intrin_get_itemsize
  s   
r  c                 C   rs  r-  rC   )r  ru   rC   rC   rD   _compatible_view
  rt  r  c                 C   r  )zDDetermines if the array and dtype are compatible for forming a view.c                 S   s   t |}|| jkrf| jdkrd}t|	 | jd }| j| dk}| jdk}| j| | jk}|r:|r:|r:d}t||| jk rR|dksJ| j| dkrPd}	t|	d S | j| | j }
|
| dkrhd}t|d S d S )Nr   zOChanging the dtype of a 0d array is only supported if the itemsize is unchangedrF   zJTo change to a dtype of a different size, the last axis must be contiguouszZWhen changing to a smaller dtype, its size must be a divisor of the size of original dtypezuWhen changing to a larger dtype, its size must be a divisor of the total size in bytes of the last axis of the array.)r  r   rj   r   r_   r   r   )r  ru   
dtype_sizemsg1r   p1p2p3r	  msg3rP  msg4rC   rC   rD   r   
  s0   




z ol_compatible_view.<locals>.implrC   r  ru   r   rC   rC   rD   ol_compatible_view
  s   #r  z
array.viewc                 C   sD  |j d }|j}t|| ||d }t|| |}t|jj}t|D ]}	t||	}
|	dkr:|jj	}|
|
||_q#t||	|
 q#tdkrc| j}|t}||g |j R i }| ||}||| t| ||||}|d|t|j	d}|| d}| j|t|f W d    n1 sw   Y  | }t| ||j|S )Nr   r   )rF      r  z"new type not compatible with array)r   r   rs   r   r   r   sortedgetattrr   r9   r  r   r   ri  rj  r  rl  rL   rd  r  r   r   rD  rE  r   r   r    )rw   r=   rV   r   r   r  r   r  fieldsr   r   r  r  rn  _compatible_view_sigr   r  r  r   r   rC   rC   rD   
array_view
  s2   



r  ru   c                 C   s   |   }t| |||S r-  )rI  r"   rw   r=   r1  r   r   rC   rC   rD   array_dtype  s   r  r_   c                 C   (   t |}|| ||}|j}t| |||S r-  )rs   r_   r"   rw   r=   r1  r   r~   r   r   rC   rC   rD   array_shape     r  r   c                 C   r  r-  )rs   r   r"   r  rC   rC   rD   array_strides"  r  r  rj   c                 C      |  tj|j}t| |||S r-  )r   r   r   rj   r"   r  rC   rC   rD   
array_ndim+  s   r  r   c                 C   r  r-  )rs   r   r"   r  rC   rC   rD   
array_size2  s   r  r   c                 C   r  r-  )rs   r   r"   r  rC   rC   rD   array_itemsize:  r  r  nbytesc                 C   s2   t |}|| ||}||j|j}t| |||S )z"
    nbytes = size * itemsize
    )rs   r   r   r   r"   r  rC   rC   rD   array_nbytesC  s   r  
contiguousc                 C   r  r-  )r   r   rX  	is_contigr"   r  rC   rC   rD   array_contiguousO     r  c_contiguousc                 C   r  r-  )r   r   rX  is_c_contigr"   r  rC   rC   rD   array_c_contiguousU  r  r  f_contiguousc                 C   r  r-  )r   r   rX  is_f_contigr"   r  rC   rC   rD   array_f_contiguous[  r  r  r  c                 C   s    |  tj|j }t| |||S r-  )r   r   rX  mutabler"   r  rC   rC   rD   array_readonlya  r  r  ctypesc           	      C   sP   t |}|| ||}t|}| ||}|j|_|j|_| }t| |||S r-  )rs   r   ArrayCTypesr   r   r   r   r    )	rw   r=   r1  r   r~   r   actctinfor   rC   rC   rD   array_ctypesi  s   
r  r   c                 C   s8   | j |||d}|j}||| tj}t| |||S Nr   )r   r   r  r   r   r   r"   )rw   r=   r1  r   r  r   rC   rC   rD   array_ctypes_datav  s   r  c                 C   s6   | j |||d}|j}||| |}t| |||S r  )r   r   r  r   r"   )rw   r=   fromtytotyr   r  r   rC   rC   rD   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   )rs   r   r3  r   rj   rv   r   ru   r$   bool_r_   r   r   r  )
checkerrw   r=   r   r   tup_intpr   	check_sig
check_argsr  rC   rC   rD   _call_contiguous_check  s   
r  r   c                 C   s>   |  |t|}||_| }| j||| t| |||S r-  )r   r   
ArrayFlagsr   r   r   r   r!   )rw   r=   r1  r   flagsobjr   rC   rC   rD   array_flags  s
   r  c                 C   sZ   |j jdkr| j|||d}tt| ||j |j}n|j jdk}| tj|}t	| |||S )Nr   r   )
r]   r  r   r  r   r   r   r   rX  r"   )rw   r=   r1  r   r  r   r   rC   rC   rD   array_flags_c_contiguous  s   r  c                 C   sr   |j jdkr| j|||d}tt| ||j |j}n|j j}|j jdkr'|dkn|dv }| tj	|}t
| |||S )NrM  r   rF   r  )r]   r  r   r  r   r   rj   r   r   rX  r"   )rw   r=   r1  r   r  r   r  r   rC   rC   rD   array_flags_f_contiguous  s   r  r  c                 C   sH   |j tjv rt| |||ddS |j tjv rt| |||S tdtj )Nr  attrzunsupported .real for {})	ru   r   complex_domainarray_complex_attrnumber_domainr    rM   r   r9   )rw   r=   r1  r   rC   rC   rD   array_real_part  s
   r  r  c                 C   s   |j tjv rt| |||ddS |j tjv rHt|jdd|}t| |||g\}}t| |||}t	
||j||j|jd t| ||j| S tdtj )Nr  r  Tr  r   zunsupported .imag for {})ru   r   r  r  r  r$   r  _parse_empty_like_argsr  r	   memsetr   r   r   r   r!   r   r   rM   r   r9   )rw   r=   r1  r   rV   r  r   r   rC   rC   rD   array_imag_part  s   
r  c                 C   s   |dvs
|j tjvrtd|t|}|| ||}|j j}| | |}|j	
|}	| | }
||j|
}|dkrK||tddg}|j|dd}t|| |}t||	d}t||| t| ||| S )	a  
    Given a complex array, it's memory layout is:

        R C R C R C
        ^   ^   ^

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

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

        R x R x R x
        ^   ^   ^

    (`x` indicates unused)

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

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

        x C x C x C
          ^   ^   ^
    )r  r  zcannot get attribute `{}`r      rF   r  ru   r  )r   r   )ru   r   r  rM   r   rs   underlying_floatrv   rt   r   r9   r   r  r  r   r  r   IntTyper  r   r	   copy_structr    r   )rw   r=   r1  r   r  r~   r   fltysizeof_fltyr   
llfltptrtyr   resulttyr  replrC   rC   rD   r    s    r  conj	conjugatec                 C   rl  )Nc                 S   
   t | S r-  )r)  r  r  rC   rC   rD   r      rz  zarray_conj.<locals>.implrC   r  r   rC   rC   rD   
array_conj     r  c                 C   r  r-  )rI  )rw   r=   dtypetydtypevalrC   rC   rD   
dtype_type(  r  r  r9   kindstatic_getitemc                 C   s<   |j }t|tjr| |d}t| |||S d}t|)zThis handles the "static_getitem" when a Numba type is subscripted e.g:
    var = typed.List.empty_list(float64[::1, :])
    It only allows this on simple numerical types. Compound types, like
    records, are not supported.
    NzlUnreachable; the definition of __getitem__ on the numba.types.abstract.Type metaclass should prevent access.)r   r   r   r   r   r"   r   LoweringError)rw   r=   rV   r   r  r   r   rC   rC   rD   static_getitem_number_clazz5  s   
r  c              	      s  t |}| ||}|j}t|tjstd||f ||}||}	t|tjr9|j	|j|j
|j
 dd}
n|j	|dd}
t |
}| |} tj|	}tj||j||jjd}t|tjrt||j|j
}| fdd|jD 7 }t||j|j
}| fdd|jD 7 }  |j}n|j}|j}  |}t|||| tj||j|jd	 | }t ||
|S )
zq
    Generic getattr() implementation for record arrays: fetch the given
    record member, i.e. a subarray.
    zattribute %r of %s not definedr  r  r  )r   c                       g | ]	}  tj|qS rC   r   r   r   r  rw   rC   rD   r   o  r  z(array_record_getattr.<locals>.<listcomp>c                    r  rC   r  r  r  rC   rD   r   r  r  r&  )rs   ru   r   r   RecordrM   typeofr   NestedArrayr  rj   r   r   r	   r   r   r9   r   r_   r   rv   rt   r   r   r   r   r    )rw   r=   r1  r   r  r~   r   rectyperu   r   restyrarytyraryconstoffset
newdataptrr_   r   datasizer   rC   r  rD   array_record_getattrM  sN   


r  c                 C   s0   |d }t |tstt| ||jd |d |S r  )r   ra  rM   r  r   )rw   r=   rV   r   r   rC   rC   rD   array_record_getitem  s   
r  c              	      s    || ||}||}t|tjret|}| |}|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rudnd} ||||}t |||S )zT
    Generic getattr() implementation for records: get the given record member.
    c                    r  rC   r  r   r   r  rC   rD   r     r  z"record_getattr.<locals>.<listcomp>c                    r  rC   r  r  r  rC   rD   r     r  Nr&  rF   )sentry_record_alignmentr   r  r   r   r  rs   ru   r_   r   r	   get_record_memberrt   r   rd   r   r   r   r   r    r|   r}   )rw   r=   r1  r   r  r   elemtyr   r   ru   r  r  newdatar   dptrr{   rC   r  rD   record_getattr  sB   







	
r  c              	   C   s   |j \}}|\}}| || ||}	||}
t|
tjrHt|| ||d d}|j	}t
|||	|jj}t|||| tj|
j dS t
|||	| |
}| ||||
}|jr`dnd}| j||
|||d dS )zT
    Generic setattr() implementation for records: set the given record member.
    rF   r   Nrz   )r   r  r   r  r   r   r  r	   rr   r   r  r9   pointeememcpyr   r   r   rt   r   r|   r   )rw   r=   rV   r   r  r1  r:  rV  r   r   r  
val_structr  r  r   r{   rC   rC   rD   record_setattr  s,   





r  c                 C   s4   |  |jd |d }|| ||jd |d |d S )3
    Record.__getitem__ redirects to getattr()
    r   rF   )get_getattrr   )rw   r=   rV   r   r   rC   rC   rD   record_static_getitem_str  s   r  c                 C   s^   |j d j}t|j d j}| |j|| }| |j d |}|| ||j d |d || S )r  rF   r   )r   r   r   r  insert_const_stringr:   r  )rw   r=   rV   r   r   r  ll_fieldr   rC   rC   rD   record_static_getitem_int  s
   r  static_setitemc                 C   sJ   |j \}}}|\}}}	t|j||}
| ||
}|dusJ ||||	fS )3
    Record.__setitem__ redirects to setattr()
    N)r   r$   r   get_setattr)rw   r=   rV   r   rectyr  r:  recr   r   getattr_sigr   rC   rC   rD   record_static_setitem_str  s   
r  c                 C   s^   |j \}}}|\}}}	t|j||}
t|j d j}| || |
}|dus(J ||||	fS )r  r   N)r   r$   r   r   r  r  )rw   r=   rV   r   r  r  r:  r  r   r   r  r  r   rC   rC   rD   record_static_setitem_int  s   
r  c                 C   s   |  |||S )zB
    Create a constant array (mechanism is target-dependent).
    )make_constant_array)rw   r=   r/  pyvalrC   rC   rD   constant_array  s   r  c                 C   s0   t t d|j}|t| }t||S )zG
    Create a record constant as a stack-allocated array of bytes.
       )r   r  r  r  	bytearraytobytesr	   r   )rw   r=   r/  r  ltyr   rC   rC   rD   constant_record  s   r  c                 C   s"   t jt|t jd}| |||S )zM
    Create a constant array from bytes (mechanism is target-dependent).
    rv  )r)  r   r  uint8r  )rw   r=   r/  r  bufrC   rC   rD   constant_bytes  s   r  c                 C   s0   |j \}}||krtjS dd }| ||||S )Nc                 S   s(   | j |j ko| j|jko| jj|jjkS r-  )r_   r   r  r   r  r,  rC   rC   rD   array_is_impl,  s
   
zarray_is.<locals>.array_is_impl)r   r	   r  r  )rw   r=   rV   r   atybtyr   rC   rC   rD   array_is&  s
   
r#  __hash__c                 C   s   dd S )Nc                 S   rs  r-  rC   r  rC   rC   rD   r>  9  r?  zol_array_hash.<locals>.<lambda>rC   r  rC   rC   rD   ol_array_hash7  r  r%  c                 C   
   t | dS )zq
    Return the Structure representation of the given *flatiterty* (an
    instance of types.NumpyFlatType).
    flat_make_flattening_iter_cls)
flatitertyrC   rC   rD   make_array_flat_cls?     
r+  c                 C   r&  )zv
    Return the Structure representation of the given *nditerty* (an
    instance of types.NumpyNdEnumerateType).
    ndenumerater(  nditertyrC   rC   rD   make_array_ndenumerate_clsG  r,  r0  c              	   C   s  |  tjd}|d}	|d ur|tj| tt|D ]T}
t	|||
}t
|||}||
 }|d||}t|| ||| |d urO||
 ||	 W d    n1 s^w   Y  ||| |d urq||
 q|d ur}|tj| ||	 ||	 d S )Nr   end_incrementr   )r   r   r   r]  r  r	   
false_byter  r8   rb   r  r>   r   	if_likelyrk  	true_byterl  )rw   r=   rj   r_   r   end_flagloop_continue
loop_breakr   bbendrZ  idxptrr   r   	in_boundsrC   rC   rD   _increment_indicesO  s.   

r;  c                 C   s*   t ||j|j}t| ||j||| d S r-  )r	   r   r_   rj   r;  )rw   r=   r  r  r   r5  r_   rC   rC   rD   _increment_indices_arrayp  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).
    rF   c                   @   sF   e Zd ZdZdd Zdd Zejdd Zdd	 Z	d
d Z
dd ZdS )z$make_nditer_cls.<locals>.BaseSubIterzF
        Base class for sub-iterators of a nditer() instance.
        c                 S   s&   || _ || _|| _|| _|| | _d S r-  )nditermember_name	start_dimend_dimrj   )rT   r=  r>  r?  r@  rC   rC   rD   r\    s
   z-make_nditer_cls.<locals>.BaseSubIter.__init__c                 S   s   t | j| j| d S r-  )r   r=  r>  )rT   re   rC   rC   rD   set_member_ptr     z3make_nditer_cls.<locals>.BaseSubIter.set_member_ptrc                 S   s   t | j| jS r-  )r  r=  r>  rN  rC   rC   rD   
member_ptr     z/make_nditer_cls.<locals>.BaseSubIter.member_ptrc                 S   rs  r-  rC   rT   rw   r=   rC   rC   rD   init_specific  rt  z2make_nditer_cls.<locals>.BaseSubIter.init_specificc                 S   rs  r-  rC   rT   rw   r=   logical_dimrC   rC   rD   r6    rt  z2make_nditer_cls.<locals>.BaseSubIter.loop_continuec                 S   rs  r-  rC   rG  rC   rC   rD   r7    rt  z/make_nditer_cls.<locals>.BaseSubIter.loop_breakN)rk   rl   rm   rW  r\  rA  r  cached_propertyrC  rF  r6  r7  rC   rC   rC   rD   BaseSubIter  s    
rJ  c                   @   s0   e Zd ZdZdd Zdd Zdd Zdd	 Zd
S )z$make_nditer_cls.<locals>.FlatSubIterz
        Sub-iterator walking a contiguous array in physical order, with
        support for broadcasting (the index is reset on the outer dimension).
        c                 S   s$   | tjd}| t|| d S r   )r   r   r   rA  r	   r   )rT   rw   r=   r   rC   rC   rD   rF    s   z2make_nditer_cls.<locals>.FlatSubIter.init_specificc                 S   s   | | j}||j|gS r-  )r>   rC  r  r   )rT   rw   r=   r   r  r  r   rC   rC   rD   compute_pointer  s   z4make_nditer_cls.<locals>.FlatSubIter.compute_pointerc                 S   s<   || j d kr|| j}t||}||| j d S d S ru  )rj   r>   rC  r	   r  r  )rT   rw   r=   rH  r   rC   rC   rD   r6    s
   z2make_nditer_cls.<locals>.FlatSubIter.loop_continuec                 S   sd   |dkr| tjd}||| j d S || jd kr0|| j}t||}||| j d S d S rh  )	r   r   r   r  rC  rj   r>   r	   r  )rT   rw   r=   rH  r   r   rC   rC   rD   r7    s   z/make_nditer_cls.<locals>.FlatSubIter.loop_breakN)rk   rl   rm   rW  rF  rK  r6  r7  rC   rC   rC   rD   FlatSubIter  s    rL  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J d S r-  )need_shaped_indexingrE  r.  rC   rD   rF    r.  z9make_nditer_cls.<locals>.TrivialFlatSubIter.init_specificc                 S   s&   t |dksJ t |||j|S ru  )r   r  r   rT   rw   r=   r   r  r  rC   rC   rD   rK    s   z;make_nditer_cls.<locals>.TrivialFlatSubIter.compute_pointerN)rk   rl   rm   rW  rF  rK  rC   r.  rC   rD   TrivialFlatSubIter  s    rO  c                   @      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	J tj|||||ddS NFr  )r   rj   r	   r  rN  rC   rC   rD   rK    s   z7make_nditer_cls.<locals>.IndexedSubIter.compute_pointerNrk   rl   rm   rW  rK  rC   rC   rC   rD   IndexedSubIter      rS  c                   @   rP  )z'make_nditer_cls.<locals>.ZeroDimSubIterz5
        Sub-iterator "walking" a 0-d array.
        c                 S   s   |j S r-  r  rN  rC   rC   rD   rK    rc  z7make_nditer_cls.<locals>.ZeroDimSubIter.compute_pointerNrR  rC   rC   rC   rD   ZeroDimSubIter  rT  rU  c                   @   rP  )z&make_nditer_cls.<locals>.ScalarSubIterz8
        Sub-iterator "walking" a scalar value.
        c                 S   s   |S r-  rC   rN  rC   rC   rD   rK    rt  z6make_nditer_cls.<locals>.ScalarSubIter.compute_pointerNrR  rC   rC   rC   rD   ScalarSubIter  rT  rV  c                       s|   e Zd ZdZej fddZ	fddZfddZdd	 Z	d
d Z
	fddZdd Zdd ZdS )zmake_nditer_cls.<locals>.NdIterz
        .nditer() implementation.

        Note: 'F' layout means the shape is iterated in reverse logical order,
        so indices and shapes arrays have to be reversed as well.
        c                    sd   g }j r nd}tjD ]\}}|\}}}}d| }	|| }
||
| |	|| q|S )N)r'  indexed0dscalarzindex%d)rM  rA  r  rc   )rT   l	factoriesrg   r  r  r?  r@  r  r>  factory)rL  rS  rV  rO  rU  r/  rC   rD   subiters  s   
z(make_nditer_cls.<locals>.NdIter.subitersc                    s2  | tjd}||t||| _t|D ]\}}t|tjs2d| }t	
||| }	t| ||	 q| ||||}ttj}
d}d}t|D ]\}}t|tjre|jkre|| j}|| j} nqJdkslJ |||
d}| tjd}dd }t||D ]'\}}t|tjr|jdkrttjttj|j|
}|||||j|f qt	||} dkr|ddd	 }|d
||}||t	jt	j}js|f}t|ksJ t	j||jd}tD ]}t	|||}| || q|| _!t	"|||j| _t	
||| _#| j$D ]	}|%|| qdS )zY
            Initialize the nditer() instance for the specific array inputs.
            r   scalar%dNrC   rF   c                 S   s>   t | }t|D ]}| | |t || |  krtdqd S )Nz2nditer(): operands could not be broadcast together)r   r8   r   )r_   
main_shaper|  rg   rC   rC   rD   check_shape  s   zBmake_nditer_cls.<locals>.NdIter.init_specific.<locals>.check_shaperM  r  r  rb  )&r   r   r   rm  r4  arraysrA  r   r   r	   r   r   _arrays_or_scalarsr3  rj   r_   r   r   r$   noner  r   r   r  r4  r2  rM  r   rR   r9   r8   rb   r  r   rd   	exhaustedr]  rF  )rT   rw   r=   arrtysra  r   rg   r/  r>  slotmain_shape_tyr_  main_nitemsr  r`  r  rV   r   shape_is_emptyrd  r   rZ  r9  subiter)r  rj   r/  nshapesrC   rD   rF    sl   




z-make_nditer_cls.<locals>.NdIter.init_specificc                    s>  | d}t||| j}t|| |d || W d   n1 s*w   Y   j}t	|| j}| 
||||}| j}|d | |||||}	dd |	D }	t|	dkrg||	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   r  rC   r  r   r   rC   rC   rD   r   _  r  zEmake_nditer_cls.<locals>.NdIter.iternext_specific.<locals>.<listcomp>rF   r   )r]  r	   as_bool_bitr>   rd  if_unlikelyr   rk  ra  r   rb  r   _make_viewsr   r   rm  r   r_   r;  r  partial_loop_continue_loop_breakrl  )rT   rw   r=   r  r8  rd  re  ra  r   viewsr_   r.  rC   rD   iternext_specificJ  sD   





z1make_nditer_cls.<locals>.NdIter.iternext_specificc                 S   @   | j D ]}|j|  kr|jk rn q|||||j  qd S r-  )r]  r?  r@  r6  rT   rw   r=   rZ  r  rC   rC   rD   rq  t  
   
z.make_nditer_cls.<locals>.NdIter._loop_continuec                 S   ru  r-  )r]  r?  r@  r7  rv  rC   rC   rD   rr  y  rw  z+make_nditer_cls.<locals>.NdIter._loop_breakc                    s   dg }j }| j}j}	t|	tjrt|	}	n|	g}	 fddtD t||D ]=\}
}|
\}}}}|j	|j
 }dkrJ|ddd }|D ]}|| du sVJ | | ||	| || || |||< qLq-tdd |D svJ |S )z:
            Compute the views to be yielded.
            Nc              	          g | ]}  t |qS rC   r>   r	   rb   r  r=   r   rC   rD   r     s    z?make_nditer_cls.<locals>.NdIter._make_views.<locals>.<listcomp>rM  r  c                 s   s    | ]}|V  qd S r-  rC   rl  rC   rC   rD   r0    s    z>make_nditer_cls.<locals>.NdIter._make_views.<locals>.<genexpr>)r  r]  r   r   r   r7  r   r8   r   r?  r@  
_make_viewr5  )rT   rw   r=   r   re  ra  rs  r  r]  rettysr  rj  r  array_indicessub_indicesrg   )r  narraysr/  rk  rz  rD   ro  ~  s0   



z+make_nditer_cls.<locals>.NdIter._make_viewsc                 S   s   t |tjr|jdksJ ||||||}||||}	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   rC   N)r   )r   r   r   rj   rK  rs   ry   rm  r3  r   r   )rT   rw   r=   r   r  r  r  rj  re   viewr   r_   r   rC   rC   rD   r{    s   
z*make_nditer_cls.<locals>.NdIter._make_viewc           	      S   s`   g }t t||D ]$\}\}}t|tjr#||||||d q	|t| d|  q	|S )Nr   r^  )rA  r   r   r   r   rc   rs   r  )	rT   rw   r=   re  ra  rZ  rg   r  r  rC   rC   rD   rb    s   
z2make_nditer_cls.<locals>.NdIter._arrays_or_scalarsN)rk   rl   rm   rW  r  rI  r]  rF  rt  rq  rr  ro  r{  rb  rC   
rL  rS  rV  rO  rU  r  r  rj   r/  rk  rC   rD   NdIter  s    O*r  )rj   r  r   ra  rM  objectr	   rr   )r/  rJ  r  rC   r  rD   make_nditer_clsv  s   
 
, Yr  c                    s$   | j  G  fdddt| }|S )zr
    Return the Structure representation of the given *nditerty* (an
    instance of types.NumpyNdIndexType).
    c                       s(   e Zd ZdZ fddZ fddZdS )z%make_ndindex_cls.<locals>.NdIndexIterz,
        .ndindex() implementation.
        c              	      s   | tjd}tj||j| tj d}t|tj}t D ]7}t	|||}|
|| || }	|d|	|}
t||
 |
tj| W d    n1 sRw   Y  q || _|| _t|||j| _d S Nr   rb  r  )r   r   r   r	   rR   r9   r   r2  r8   rb   r  r  rn  r4  r   rd  rd   r_   )rT   rw   r=   r   r   r   rd  rZ  r9  r  dim_is_emptyrj   rC   rD   rF    s&   
z3make_ndindex_cls.<locals>.NdIndexIter.init_specificc           
         s   | tjd} d}t  j}t | |	d  
| W d    n1 s1w   Y   fddtD }|D ]}t | qD|t ||j |	d t j}	t| |	jj  
|  | d S )Nr   r  Fc              	      s"   g | ]}  t j|qS rC   )r>   r	   rb   r   r   rZ  r=   rT   rC   rD   r     s    

zKmake_ndindex_cls.<locals>.NdIndexIter.iternext_specific.<locals>.<listcomp>T)r   r   r   r]  r	   rm  r>   rd  rn  r   rk  r8   rH   r   rd   r9   r   r_   r;  r   rl  )
rT   rw   r=   r  r   r8  rd  r   r>   r_   r  r  rD   rt    s,   





z7make_ndindex_cls.<locals>.NdIndexIter.iternext_specificN)rk   rl   rm   rW  rF  rt  rC   r  rC   rD   NdIndexIter  s    r  )rj   r	   rr   )r/  r  rC   r  rD   make_ndindex_cls  s   7r  c                    sX    dv sJ | j }|jdkrG  fdddt| }|S G  fdddt| }|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}t|j
D ]}t|||}||| q*|| _d S d S )Nr   r-  rb  )r   r   r   r	   r   r   r   r  rR   r9   rj   r8   rb   r  r   )	rT   rw   r=   r  r  r   r   rZ  r9  r  rC   rD   rF  
  s   
zD_make_flattening_iter_cls.<locals>.CContiguousFlatIter.init_specificc                    s
  |j }|j} | j} d||}	||	 t |	]  |j	|g}
t
| ||
}dkr8|| n.| j fddt|D }tj ||tjd}|t ||g t| || t |} || j W d    d S 1 s~w   Y  d S )Nr   r'  c              	      rx  rC   ry  r  rz  rC   rD   r   3      

z\_make_flattening_iter_cls.<locals>.CContiguousFlatIter.iternext_specific.<locals>.<listcomp>r/  )rj   r   r>   r   r   r   r	   r3  r  r   r   r   r   r8   rd   rt   r   r   make_anonymous_structr<  r  r  )rT   rw   r=   r  r  r  rj   r   r   r  re   r   idxvalsidxtupler  rz  rD   rt  #  s<   
"zH_make_flattening_iter_cls.<locals>.CContiguousFlatIter.iternext_specificc                 S   s   | |j|g}t||||S r-  )r  r   r   rT   rw   r=   r  r  r   re   rC   rC   rD   rt  C  s   z>_make_flattening_iter_cls.<locals>.CContiguousFlatIter.getitemc                 S   s$   | |j|g}t||||| d S r-  )r  r   r   rT   rw   r=   r  r  r   r   re   rC   rC   rD   setitemG  s   z>_make_flattening_iter_cls.<locals>.CContiguousFlatIter.setitemN)rk   rl   rm   rW  rF  rt  rt  r  rC   r  rC   rD   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}t|D ]D}t||	|}t||
|}||| ||| || }|d||}t|| |tj| W d    n1 s}w   Y  q>|	| _|
| _|| _d S r  )r   r   r   r   rj   r	   r   r_   rR   r9   r   r2  r8   rb   r  r  rn  r4  r   pointersrd  )rT   rw   r=   r  r  r   r   rj   r   r   r  rd  rZ  r9  ptrptrr  r  rC   rC   rD   rF  V  s>   
z9_make_flattening_iter_cls.<locals>.FlatIter.init_specificc              	      sH  |j }t |j|}t |j|}| j| j}	|tj	d}
 
d}t  | j}t | |d  | W d    n1 sJw   Y  |d t |	|d } |}t| ||}dkrs|| n fddt|D }t |}|t ||g tt|D ]y}t |}t  |}|| }|| } d	||}t |C  || t |	|} |}t ||} || t|d |D ]}t |	|} || q | W d    n	1 sw   Y   |
| q tj| j  |  | d S )
Nr   r  FTrF   r'  c              	      rx  rC   ry  r  rz  rC   rD   r     r  zQ_make_flattening_iter_cls.<locals>.FlatIter.iternext_specific.<locals>.<listcomp>r   )rj   r	   r   r_   r   r   r  r   r   r   r]  rm  r>   rd  rn  r   rk  rb   r   r   r8   rd   r  r  r  r   r3  r  r   r4  rl  )rT   rw   r=   r  r  r  rj   r   r   r  r   r8  is_exhaustedlast_ptrre   r   r  r  rZ  r9  r   r   r  r:  r  	inner_dimr  rz  rD   rt  w  sn   





z=_make_flattening_iter_cls.<locals>.FlatIter.iternext_specificc              	   S   s   |j }tj||j|d}tj||j|d}g }	tt|D ]}
|	||||
  |	|||
 }q|	
  t|||j|||j|	}|S )Nr   )rj   r	   r   r_   r   r  r8   rc   uremudivreverser  r   r  )rT   rw   r=   r  r  r   rj   r   r   r   rZ  re   rC   rC   rD   _ptr_for_index  s   z:_make_flattening_iter_cls.<locals>.FlatIter._ptr_for_indexc                 S   s    |  |||||}t||||S r-  )r  r   r  rC   rC   rD   rt    s   z3_make_flattening_iter_cls.<locals>.FlatIter.getitemc                 S   s&   |  |||||}t||||| d S r-  )r  r   r  rC   rC   rD   r    s   z3_make_flattening_iter_cls.<locals>.FlatIter.setitemN)	rk   rl   rm   rW  rF  rt  r  rt  r  rC   r  rC   rD   FlatIterN  s    !Er  )r]   r  r	   rr   )r*  r  r]   r  r  rC   r  rD   r)    s   
F r)  r'  c                 C   sh   t t|}|| |}||_| |}|| ||dd}|| ||| | }t| |t||S Nr   )rU   )	r+  r   NumpyFlatTyper   rs   ra   rF  r   r    )rw   r=   r  r  flatiterclsflatiterarrclsr   rC   rC   rD   make_array_flatiter  s   

r  c                 C   Z   |j \}|\}t|}|| ||d}|j}| |}	|	| ||jd}
|| |||
| d S r  )r   r+  r]   rs   r   rt  )rw   r=   rV   r   r  r*  r  r  r  r  r  rC   rC   rD   iternext_numpy_flatiter     
r  c                 C   sj   |j d }|\}}t|}|| ||d}|j}| |}	|	| ||jd}
|| |||
|}t| ||j|S Nr   r   )r   r+  r]   rs   r   rt  r    r   )rw   r=   rV   r   r*  r  r   r  r  r  r  r   rC   rC   rD   iternext_numpy_getitem  s   

r  c                 C   sf   |j d }|\}}}t|}|| ||d}|j}	| |	}
|
| ||jd}|| ||	||| |  S r  )r   r+  r]   rs   r   r  rI  )rw   r=   rV   r   r*  r  r   r   r  r  r  r  rC   rC   rD   iternext_numpy_getitem_any  s   


r  c           	      C   sF   |j d }t|}|| ||d d}| |j}|| ||jd}|jS r  )r   r+  rs   r]   r   r   )	rw   r=   rV   r   r*  r  r  r  r  rC   rC   rD   iternext_numpy_getitem_flat  s   
r  c           
      C   sr   |j \}|\}tt|}|| |}||_| |}|| ||dd}|| ||| | }	t	| ||j
|	S r  )r   r0  r   NumpyNdEnumerateTyper   rs   ra   rF  r   r    r   )
rw   r=   rV   r   r  r  	nditerclsr=  r  r   rC   rC   rD   make_array_ndenumerate$  s   

r  c                 C   r  r  )r   r0  r]   rs   r   rt  )rw   r=   rV   r   r  r/  r=  r  r  r  r  rC   rC   rD   iternext_numpy_nditer6  r  r  c                    s^    fddt |j|D }ttt|}| }| | | }t |j	|S )zndindex(*shape)c                    r  rC   r  )r   argtyrB  r   rC   rD   r   J  r  z&make_array_ndindex.<locals>.<listcomp>)
r   r   r  r   NumpyNdIndexTyper   rF  r   r    r   )rw   r=   rV   r   r_   r  r=  r   rC   r   rD   make_array_ndindexF  s   

r  c           
         s   |j j}|dkr%|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 rC   r  r  r=   rw   r   rC   rD   r   _      z,make_array_ndindex_tuple.<locals>.<listcomp>)r   rj   r   ru   r	   r   r  r   r  r   rF  r   r    )
rw   r=   rV   r   rj   r5  r_   r  r=  r   rC   r  rD   make_array_ndindex_tupleU  s   
r  c                 C   s6   |j \}|\}t|}|| ||d}|| || d S r  )r   r  rt  )rw   r=   rV   r   r  r/  r=  r  rC   rC   rD   iternext_numpy_ndindexl  s
   r  c           	      C   sn   |j }|j}t|jd tjrt||d }n|d g}t|| |}|	| ||| |
 }t| |||S )z
    nditer(...)
    r   )r   ra  r   r   r   r7  r	   r   r  rF  r   r    )	rw   r=   rV   r   r/  re  ra  r=  r   rC   rC   rD   make_array_nditerx  s   
r  c                 C   s2   |j \}|\}t|| ||d}|| || d S r  )r   r  rt  )rw   r=   rV   r   r  r/  r=  rC   rC   rD   iternext_numpy_nditer2  s   r  c                 C   s4   |j \}}ttdt||k}t| ||j|S ru  )r   r   r   r  r   r"   r   )rw   r=   rV   r   arg1arg2r   rC   rC   rD   dtype_eq_impl  s   
r  c                 C   sb  t |}|| |}| |j}| tjt| |}| tjd}tt	dd}	|D ]}
|
||
}||d}||	||d}	q*|jdkrKd}nN|jdkrp|g}t|dd D ]}|||d | q[tt|}n)|jdkr|g}|dd D ]}|||d | q~t|}ntd|j|
||}||d}||	||d}	|j|	d	d
 | j|td W d   n1 sw   Y  |j}| |}| tj|}|  ||f}ttj}tt|}t ||tjtj}| !|t"||}| j#$||}| %tj}t&j'|||d}t&j'|||d}t(||)||* ||||d |S )a	  Utility function used for allocating a new array during LLVM code
    generation (lowering).  Given a target context, builder, array
    type, and a tuple or list of lowered dimension sizes, returns a
    LLVM value pointing at a Numba runtime allocated array.
    rF   r   rC   r   Nr  rM  z3Don't know how to allocate array with layout '{0}'.FrB  )z[array is too big; `arr.size * arr.dtype.itemsize` is larger than the maximum possible size.r  r  )+rs   rt   ru   r   r   r   ry   r   r   r  smul_with_overflowr=  r  rj   r  r  rc   r   r   rM   r   r   rD  rE  r   get_preferred_array_alignmentuint32rI  MemInfoPointervoidptrTypeRefr9   r$   r  _call_allocatorr   meminfo_datar   r	   rd   r   r  r  )rw   r=   r  r   r_  r   datatyper   arrlenoverflowr   arrlen_multr   dimension_sizeallocsize_multr  ru   	align_valr{   r   miparytypeclassargtypesr   r   r   shape_arraystrides_arrayrC   rC   rD   r    st   




	
r  	_allocatec                 C   s   dd }|S )zTImplements a Numba-only default target (cpu) classmethod on the array
    type.
    c                 S   s
   t ||S r-  )intrin_alloc)clsr  r{   rC   rC   rD   r     rz  z _ol_array_allocate.<locals>.implrC   )r  r  r{   r   rC   rC   rD   _ol_array_allocate  s   r  c                 C   s   |  ||S )z9Trampoline to call the intrinsic used for allocation
    )r  )r  r   r{   rC   rC   rD   r    s   r  c                 C   s(   dd }t t j}t|||}||fS )z3Intrinsic to call into the allocator for Array
    c                 S   s   |\}}| j |||}|S r-  )r   meminfo_alloc_aligned)rw   r=   r$   r   r  r{   r   rC   rC   rD   r    s   zintrin_alloc.<locals>.codegen)r   r  r  r$   )r  r  r{   r  r  rV   rC   rC   rD   r    s   r  c              	   C   s   dd }t |tjrd}| |||tjg}nt |tjsJ |j}tj|||d}g }|D ]}|	|| ||j
| q.| |tjd}	t|D ])}
|d||
 |	}t|| | j|td W d   n1 slw   Y  qH|S )	z;
    Parse the shape argument to an array constructor.
    c           
      S   s   |  tj}|j}t|}t|d|d > d }|j|k r&|||}|S |j|kr`|d||}	|j	|	dd | j
|td W d   n1 sLw   Y  |j|kr^|||}|S |}|S )z0Cast src to intp only if value can be maintainedrF   >FrB  )z#Cannot safely convert value to intpN)r   r   r   rG   r   r  r   sextr   r   rD  rE  r   trunc)
rw   r=   src_tr  r   
intp_widthintp_irmaxvalr   	is_largerrC   rC   rD   safecast_intp  s(   



z#_parse_shape.<locals>.safecast_intprF   r   r   r   )znegative dimensions not allowedN)r   r   r   r   r   r7  r   r	   r   rc   r9   get_constant_genericr8   r   rn  rD  rE  r   )rw   r=   r/  r   r  rj   passed_shapesr   r   r   rZ  is_negrC   rC   rD   _parse_shape  s(   r  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   r  )rw   r=   rV   r   arrshapetypearrshaper  rC   rC   rD   _parse_empty_args=  s   
r  c                 C   sT   |j d }t|tjr%t|| ||d d}tj||j|jd}|j	|fS |j	dfS )z_
    Parse the arguments of a np.empty_like(), np.zeros_like() or
    np.ones_like() call.
    r   r   r   rC   )
r   r   r   r   rs   r	   r   r_   rj   r   )rw   r=   rV   r   arytyper   r   rC   rC   rD   r  G  s   


r  c                 C   s&   t |tjrd|  d}t|d S )NzIf np.z0 dtype is a string it must be a string constant.)r   r   UnicodeTyper   r   )fnameru   r   rC   rC   rD   _check_const_str_dtypeU  s   
r  c                 C   "   |j }||||}dd }||fS )Nc                 S   (   t | |||\}}t| |||}| S r-  )r  r  r   r  r=   rV   r  r  r   r   rC   rC   rD   r  `     znumpy_empty_nd.<locals>.codegeninstance_type)r  ty_shapety_dtypety_retty_refty_rettyrV   r  rC   rC   rD   numpy_empty_nd[     r  c                    s   t d| |tu st|tjr|jtu st|rtj}nt|}t	| }|d ur>|d ur>tj
||dd tf fdd	}|S d|  d| d}t|)	Nrx  r   r  c                       t | | S r-  )r  )r_   ru   r  rC   rD   r   u  rv  zol_np_empty.<locals>.implz.Cannot parse input types to function np.empty(r^  rc  )r  floatr   r   Function
typing_keyr   doublety_parse_dtypety_parse_shaper   r   r   )r_   ru   nb_dtyperj   r   r   rC   r  rD   ol_np_emptyg  s    



r  c                 C   r  )Nc                 S   r  r-  )r  r  r   r  rC   rC   rD   r    r  z$numpy_empty_like_nd.<locals>.codegenr  )r  ty_prototyper  r  r  rV   r  rC   rC   rD   numpy_empty_like_nd}  r  r  c                    s   t d| t|st|}nt| tjr| j}n| }|d ur?t| tjr7| jdkr,| jnd}| j||dd nt|dd nd|  d| d	}t	
|d fd
d	}|S )Nr  r  r   F)ru   r  r  r   z3Cannot parse input types to function np.empty_like(r^  rc  c                    r  r-  )r  )r  ru   r  rC   rD   r     rv  zol_np_empty_like.<locals>.implr-  )r  r   r  r   r   r   ru   r  r  r   r   )r  ru   r  r  r   r   rC   r  rD   ol_np_empty_like  s&   


r  c                 C   r  )Nc                 S   s<   t |jd | ||d }t||j||j|jd d S r   )rs   r   r	   r  r   r   r   r   )r  r=   rV   r  r   rC   rC   rD   r    s   z(_zero_fill_array_method.<locals>.codegen)r   rc  )r  rT   rV   r  rC   rC   rD   _zero_fill_array_method  s   
r  
_zero_fillc                 C   rl  )z?Adds a `._zero_fill` method to zero fill an array using memset.c                 S   s   t |  d S r-  )r  rN  rC   rC   rD   r     rv  z ol_array_zero_fill.<locals>.implrC   )rT   r   rC   rC   rD   ol_array_zero_fill  r  r  c                 C   s   t d| tfdd}|S )Nr  c                 S      t j| |d}|  |S Nrv  )r)  rx  r  )r_   ru   r  rC   rC   rD   r        zol_np_zeros.<locals>.impl)r  r  r_   ru   r   rC   rC   rD   ol_np_zeros  s   
r
  c                 C      t d| ddd}|S )N
zeros_likec                 S   r  r  )r)  r  r  )r  ru   r  rC   rC   rD   r     r  zol_np_zeros_like.<locals>.implr-  r  r  rC   rC   rD   ol_np_zeros_like  s   

r  c                 C   r  )N	ones_likec                 S   2   t j| |d}|j}tt|D ]}d||< q|S Nrv  rF   r)  r  r'  r8   r   )r  ru   r  arr_flatr   rC   rC   rD   r     
   
zol_np_ones_like.<locals>.implr-  r  r  rC   rC   rD   ol_np_ones_like  s   

r  c                    s2   t d| t|st| n| d fdd	}|S )Nfullc                    s0   t |  }|j}tt|D ]}|||< q|S r-  r)  rx  r'  r8   r   )r_   
fill_valueru   r  r  r   r  rC   rD   r    
   
zimpl_np_full.<locals>.fullr-  )r  r   r  )r_   r  ru   r  rC   r  rD   impl_np_full  s   

r  c                 C   s   t d| ddd}|S )Nr7  c                 S   s0   t | |}|j}tt|D ]}|||< q|S r-  r  )r  r  ru   r  r  r   rC   rC   rD   r7    r  z$impl_np_full_like.<locals>.full_liker-  r  )r  r  ru   r7  rC   rC   rD   impl_np_full_like  s   

r  c                 C   r  )Nonesc                 S   r  r  r  )r_   ru   r  r  r   rC   rC   rD   r     r  zol_np_ones.<locals>.implr-  r  r	  rC   rC   rD   
ol_np_ones  s   

r  c                    s4   t d| t|st| ntj d fdd	}|S )Nidentityc                    s.   t | | f }t| D ]}d|||f< q|S ru  )r)  r  r8   )r|  ru   r  rg   r  rC   rD   r    s   z"impl_np_identity.<locals>.identityr-  )r  r   r  r   r  )r|  ru   r  rC   r  rD   impl_np_identity  s   

r   c                 C   rs  r-  rC   NMrC   rC   rD   _eye_none_handler  rt  r$  c                 C   s$   t |tjrdd }|S dd }|S )Nc                 S      | S r-  rC   r!  rC   rC   rD   r     rt  z$_eye_none_handler_impl.<locals>.implc                 S      |S r-  rC   r!  rC   rC   rD   r   "  rt  r   r   rD  )r"  r#  r   rC   rC   rD   _eye_none_handler_impl  s
   r(  c                    sf   |d u s
t |tjrtt nt |tjtjfr"tt	|d| nt| d dtf fdd	}|S )Nru   r   c                    s   t | |}t| |f }|dkr)t| || }t|D ]
}d|||| f< q|S t| | |}t|D ]
}d||| |f< q4|S rh  )r$  r)  r  r"  r8   )r"  r#  r   ru   _Mr  drg   rP  rC   rD   r   2  s   
znumpy_eye.<locals>.impl)
r   r   rD  r)  ru   r  	DTypeSpecrN  r   r  )r"  r#  r   ru   r   rC   r+  rD   	numpy_eye'  s   
r-  c                 C   sD   t | s	tdt| tjr | jdvrtdddd}|S d S )N#The argument "v" must be array-like)rF   rH  zInput must be 1- or 2-d.r   c                 S   s*  | j dkrG| j}|d t| }t||f| j}|dkr2t|| D ]}| | |||| f< q#|S t|| D ]}| | ||| |f< q8|S | j\}}|dk rT|| }|dkr\|| }tt||d}t	|| j}|dkrt|D ]}| ||| f ||< qs|S t|D ]}| || |f ||< q|S r  )
rj   r_   r  r)  r  ru   r8   rF  r"  rx  )r   r   r   r|  r  rg   rowscolsrC   rC   rD   	diag_implJ  s2   

zimpl_np_diag.<locals>.diag_implrK  )r   r   r   r   r   r   rj   NumbaTypeError)r   r   r1  rC   rC   rD   impl_np_diagA  s   



r3  c                    sX   t | tjsd}t|t | jtjsd}t|t|  d   fdd}|S )Nz5The argument "dimensions" must be a tuple of integersr@  c                    sV   t j f|  t jd}d}| D ]}t j|t jdt||}|||< |d7 }q|S )Nrv  r   rF   )r)  rx  rk  aranger  r0   )
dimensionsr   rg   rZ  r   r"  r_   rC   rD   r   u  s   

znumpy_indices.<locals>.impl)r   r   r3  r   r   ru   r   r   )r5  r   r   rC   r6  rD   numpy_indicesh  s   

r7  c                 C   sB   t | sd}t|t|ttjfsd}t|ddd}|S )Nr.  z#The argument "k" must be an integerr   c           	      S   s   t | } |  } t| }t|}|| }t ||f| j}t d| }t d|}t|D ]}| | ||| || f< q/|S r   )	r)  r*  r  r   r  r  ru   maximumr8   )	r   r   r   abs_kr|  r   rg   jtrC   rC   rD   r     s   
znumpy_diagflat.<locals>.implrK  )r   r   r   r   r   r   r   )r   r   r   r   rC   rC   rD   numpy_diagflat  s   


r<  c                 C   s   |dv sJ |dkr'd}t d| D ]}d| }|d| dd| d	7 }qnd
}t d| D ]}d| }|d| dd| d7 }q.t|}t|t  t d|  }t|S )N)rt  r  rt  zv
            def _getitem(a, idx, axis):
                if axis == 0:
                    return a[idx, ...]
        rF   ):z
                elif axis == z:
                    return a[r^  z, idx, ...]
            z|
            def _setitem(a, idx, axis, vals):
                if axis == 0:
                    a[idx, ...] = vals
        z:
                    a[z, idx, ...] = vals
            r  )r8   rd  textwrapdedentexecglobalsr&   )rj   r  r  rg   lstrC   rC   rD   "generate_getitem_setitem_with_axis  s.   
rC  takec                    s8  t |rLt| tjrt|tjrddd}|S t| tjr2t|tjr2|jdk d fdd	}|S t| tjrHt|tjtjfrJddd}|S d S d S t| tjrpt|tjrpd| j	d  t
fdd	dfd
d	}|S t| tjrt|tjtjtjfr| j	}t|dt|ddfdd	}|S d S d S )Nc                 S   s.   || j d ks|| j  k rtd|  | S )NrF   Index out of bounds)r   
IndexErrorr  )r  r   r   rC   rC   rD   	take_impl  s   znumpy_take.<locals>.take_implrM  c           	         s   t j|j| jd} r| }n|}t |}d}|  }|D ]}|| jd ks.|| j k r2td|| ||< |d }q||j	S )Nrv  r   rF   rE  )
r)  rx  r   ru   r  r=  r  rF  r  r_   )	r  r   r   r  walkeritrg   r'  r  )F_orderrC   rD   rG    s   


c                 S   s   t |}t | |S r-  )r)  r   rD  )r  r   r   convertrC   rC   rD   rG    s   
rK  rF   c                    sv   t  }d}|t| jk r| j| dksJ | jtt| jD ]}| j| }||kr5t|||}|d7 }q | |S rh  )r   r   r_   r8   r0   r  )r9  r   r5  r:  r   r   )r;  rC   rD   _squeeze  s   &

znumpy_take.<locals>._squeezec                    s@   t j| |f|d}| jdkr|d S |dk r|| j7 } ||S )Nr  rF   r   )r)  rD  rj   )r  r   r   r9  )rL  rC   rD   rG    s   


rt  r  c           	         s   |}|dk r|| j 7 }|dk s|| j kr!d| d| j  }t|t| j|t|}tj|| jd}tt|D ]} | || |}|||| q8|S )Nr   zaxis z) is out of bounds for array of dimension rv  )	rj   r   r0   r_   r   r)  rx  ru   r8   )	r  r   r   r  r   r_   r   rg   r  )_getitem_setitemrC   rD   rG    s   
r-  )r	   r   r   r   r   r   r  r  r7  rj   r&   rC  )r  r   r   rG  rj   rC   )rJ  rM  rN  rL  r;  rD   
numpy_take  s:   





rO  c                  G   s   dd | D }t dd |D rtj}|S t dd |D r#tj}|S ttddttj  }dd |D }t	||g }|S )	Nc                 S   s   g | ]
}t |tjs|qS rC   r'  r  rC   rC   rD   r   &  r  z!_arange_dtype.<locals>.<listcomp>c                 s   r,  r-  r  r  rC   rC   rD   r0  (  r1  z _arange_dtype.<locals>.<genexpr>c                 s   r,  r-  )r   r   Floatr  rC   rC   rD   r0  *  r1  zint%sr  c                 S   s   g | ]}t |qS rC   )r   	unliteralrb  rC   rC   rD   r   9      )
r2  r   
complex128r   r  r)  ru   r   r   rF  )r   boundsru   NPY_TYunliteral_boundsrC   rC   rD   _arange_dtype%  s   rW  c                   s  t |tjr	|j}t |tjr|j}t |tjr|j}|d u r"tj}|d u r)tj}|d u r0tj}t | tjrQt |tjtjfrQt |tjtjfrQt |tjtjfsSd S t |tjr`t| ||n|j	t
dd | ||fD t| dd  t|dd t|dd d fdd	}|S )Nc                 S   r/  rC   r  rb  rC   rC   rD   r   [      znp_arange.<locals>.<listcomp>r   c                   s    d ur n| }d urn|}d urn|}|d ur|nd}|d u r*d|}}	n||}}	|dkr7t d|	| | }
tt|
j}du rZtt|
j}tt||d}nt|d}t	|}|}t
|D ]
}|||  ||< qk|S )NrF   r   zMaximum allowed size exceededT)r   r   mathceilr  r  rF  r"  r)  rx  r8   )r  r  r  ru   	lit_startlit_stoplit_step_step_start_stopnitems_cnitems_rnitems_ir   r  r   rg   start_value
step_value
stop_value
true_dtypeuse_complexrC   rD   r   b  s(   

znp_arange.<locals>.implrK  )r   r   Optionalr9   rc  rN  rD  r,  rW  ru   r2  r  )r  r  r  ru   r   rC   rd  rD   	np_arange?  s>   rk  c                    s|   t dd | |fD sd S t|ttjfsd}t|tdd | |fD r2tj	r.tj
 ntj ntj d fdd	}|S )	Nc                 s   r,  r-  )r   r   rN  r  rC   rC   rD   r0    r1  z!numpy_linspace.<locals>.<genexpr>r  c                 s   r,  r-  r  r  rC   rC   rD   r0    r1  r  c                    s   t | }| d } |d }|dkr|S |d }|dkr7||  }t ||}td|D ]
}| ||  ||< q+n| |d< |dkrC||d< |S )Ng      ?r   rF   r  )r)  rx  divider8   )r  r  r  r  divdeltar  rg   rv  rC   rD   r    s    z numpy_linspace.<locals>.linspacer  )r5  r   r   r   r   r   r   r2  r   USE_LEGACY_TYPE_SYSTEMrS  np_complex128r   )r  r  r  r   r  rC   rv  rD   numpy_linspace  s   
rq  c              
   C   s0  |j d }t|| ||d d}t||j}|j}t| |||}|j}	|j}
|jdv s.J |j|jkrBtj	||
|	|j
|jdd nLt||j}t||j}| tj}t|||)}t| ||	|||j|}t| ||
|||j|}|||| W d   n1 sw   Y  t| ||j| S )z
    Array copy.
    r   r   r  rF   rz   N)r   rs   r	   r   r_   r   r  r   r  
raw_memcpyr   r   r   r   r   r   r  r  r  r>   r!   r   )rw   r=   rV   r   r  r   r   rettyper  r  r{  r  rz  r   r   r  r  rC   rC   rD   _array_copy  s6   


	rt  c                 C   s@   t |tjsJ |jdkrdnd}|j|dd}||}|tfS )NrM  r   F)r  r  )r   r   r   r  r  rt  )r  r  r  r  rV   rC   rC   rD   _array_copy_intrinsic  s
   ru  z
array.copyc                 C   rB  r-  )rt  r  rC   rC   rD   
array_copy  rD  rv  c                 C   s6   t | s	tdt| tjrdd }|S dd }|S )Nr  c                 S      t | S r-  )ru  r  rC   rC   rD   
numpy_copy  re  z#impl_numpy_copy.<locals>.numpy_copyc                 S   r  r-  )r)  r*  r  rC   rC   rD   rx    rn  )r   r   r   r   r   r   )r  rx  rC   rC   rD   impl_numpy_copy  s   
ry  c              	   C   s  |j }|jd }|j|ksJ d|jdkr`|jdksJ 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sp|jdkry|jdv ryt| |||d S |jdkr|dv sJ |dkrtnt}t|| |||d }||D\}}| t| |||d }|j}W d	   n1 sw   Y  | t| |||}|j}W d	   n1 sw   Y  W d	   n1 sw   Y  ||j}||| ||| |S t| |||S )
zd
    Common logic for layout conversion function;
    e.g. ascontiguousarray and asfortranarray
    r   z return-type has incorrect layoutrF   r   r@  r  r  r   N)r   r   r  rj   rs   r  r   r3  r   rm  r   r   r   r   r   r    r   r   r   r  r  blockrt  phir9   add_incoming)rw   r=   rV   r   output_layoutr  r   r   r  r_   r   
check_funcr  thenorelseout_thenthen_blk
out_orelse
orelse_blkret_phirC   rC   rD   _as_layout_array  s`   


r  c                    sH   t  tjst |j jt|jdd}|| }| fddfS )NrF   )r  rj   c                    s   t | ||| jdS )Nr}  )r  r   )r  r,  r   r  r  rC   rD   r>  :  s    z,_as_layout_array_intrinsic.<locals>.<lambda>)	r   r   r%   r   RequireLiteralValuer  r   rF  rj   )r  r  r}  r  rV   rC   r  rD   _as_layout_array_intrinsic2  s
   

r  c                 C   sH   t | s	tdt| tjtjfrdd }|S t| tjr"dd }|S )Nr  c                 S      t t | S r-  )r)  ascontiguousarrayr   r  rC   rC   rD   r   D  r  z%array_ascontiguousarray.<locals>.implc                 S   r&  Nr   r  r  rC   rC   rD   r   G  rz  r   r   r   r   r   rN  r  r   rh  rC   rC   rD   array_ascontiguousarray>  s   
r  c                 C   sL   t | s	tdt| tjtjfrdd }|S t| tjr$dd }|S d S )Nr  c                 S   r  r-  )r)  asfortranarrayr   r  rC   rC   rD   r   R  r  z"array_asfortranarray.<locals>.implc                 S   r&  )NrM  r  r  rC   rC   rD   r   V  rz  r  rh  rC   rC   rD   array_asfortranarrayL  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|||9}t| ||	|||j|}t| ||
|||j|}t| |||}| |||j|j}t| |||| W d    n1 s~w   Y  t| ||j| S r  )r   rs   r	   r   r_   r   r  r   r   r   r   r   r  r  r  r   r   ru   r   r!   r   )rw   r=   rV   r   r  r   r   rs  r  r  r{  r  rz  r   r   r  r  itemrC   rC   rD   array_astype[  s0   


r  c                 C   s(   t |tjsJ t|}dd }||fS )Nc              
   S   sR  |j \}t|}|| ||d }|j}|||j}t| ||}	|jr8|jdkr8t	||	j
|j
|j| |	 S t||j}
t||j}|j}| tj}tj||ddd}t||
|>}t| ||j
|
|||}|||	j
j}||}||	j
|g}t|||| ||||| W d    |	 S 1 sw   Y  |	 S )Nr   r   byteptrT)namerJ   )r   rs   r   r   r   r.   r  r  r	   rr  r   r   r_   r   r   r   r   rR   r  r  r  r9   r>   r  r  r  ry  r   )rw   r=   rV   r   r/  r  r  r   r  bstrr_   r   r  r   byteidxr   re   srcptrr   destptrrC   rC   rD   r    s>   

z)_array_tobytes_intrinsic.<locals>.codegen)r   r   r   r/   )r  r,  rV   r  rC   rC   rD   _array_tobytes_intrinsicz  s   #r  r  c                 C      t | tjrdd }|S d S )Nc                 S   rw  r-  )r  r  rC   rC   rD   r     re  z impl_array_tobytes.<locals>.implr.  r  rC   rC   rD   impl_array_tobytes     r  c           	      C   s&   |j }||||||}dd }||fS )Nc           !   	   S   s  |j d }|d }|d }|j}t|| ||d d}t|}	|	| |}
|
j}t| |}t|jj|}||j	|j}|||}|
||}|d|t|jd}d}|j|dd | j|t|f W d    n1 spw   Y  |d|t|jd}|||}t||}|j|dd d	}| j|t|f W d    n1 sw   Y  ||:\}}| |j}|||}W d    n1 sw   Y  | |j}W d    n1 sw   Y  W d    n1 sw   Y  ||j}||| ||| |||}|d
||}|j|dd d}| j|t|f W d    n	1 s3w   Y  t||g}t||g}||j|g}||| |d}t |
|||||j!|j"d |
# } t$| ||j| S )Nr   rH  r  r   r   z=offset must be non-negative and no greater than buffer lengthFrB  z.buffer size must be a multiple of element sizer  z%buffer is smaller than requested sizer   r&  )%r   r   rs   r   ry   r   r   r9   r   r   r  r   r   r   rD  rE  r   sremr	   is_not_nullr  basic_blocksdivr{  r|  r  rd   r  r   r  r   r   r   r   r   r   r    )!rw   r=   rV   r   bufty	arg_count
arg_offsetr   r  
out_ary_tyout_aryout_datamodelr   ll_itemsizer  ll_offset_sizenbytes_is_negativer   ll_count_is_negativeremis_incompatible
then_block
else_blockbb_if	num_wholebb_elsell_itemcountll_required_sizeis_too_larger_   r   r   r   rC   rC   rD   r    s   


znp_frombuffer.<locals>.codegenr  )	r  bufferru   r   r   r  r/  rV   r  rC   rC   rD   np_frombuffer  s   Pr  r  c                    s   t d| t| tjr| jdkrd|  }t||tu s-t|tjr)|j	tu s-t
|r1tj}nt|}|d urEtj|dd| j d nd|  d| d}t|td	d
f fdd	}|S )N
frombufferr   z+Argument "buffer" must be buffer-like. Got rF   )ru   rj   r  r  z3Cannot parse input types to function np.frombuffer(r^  rc  r  r   c                    s   t | ||| S r-  )r  )r  ru   r   r   r  rC   rD   r     r  z impl_np_frombuffer.<locals>.impl)r  r   r   r   r  r   r   r  r  r  r   r  r  r   r  )r  ru   r   r   r   r  r   rC   r  rD   impl_np_frombuffer  s0   






r  c                    P   t |rtdd  d fdd	}|S t|tjr&td| d fdd	}|S d S )Nr   c                    
    | |S r-  rC   re   r_   ru   intrinsic_cfarrayrC   rD   r   '  rz  zimpl_carray.<locals>.implc                    r  r-  rC   r  r  rC   rD   r   -  rz  r-  r   get_cfarray_intrinsicr   r   r,  re   r_   ru   r   rC   r  rD   impl_carray"     

r  c                    r  )NrM  c                    r  r-  rC   r  r  rC   rD   r   7  rz  zimpl_farray.<locals>.implc                    r  r-  rC   r  r  rC   rD   r   =  rz  r-  r  r  rC   r  rD   impl_farray2  r  r  c                    s   t  fdd}|S )Nc           	         s   |t ju rd }nt|t jr|j}nd| d}t| d u r/|d u r,d}t||}n+t t jrO j}|d urN||krNd| d| d}t|nd  d}t|t|}|d u rmd| d}t|t 	||}t
|||}|tfS )Nz pointer argument expected, got ''z*explicit dtype required for void* argumentzmismatching dtype 'z' for pointer type 'zinvalid dtype spec 'zinvalid shape ')r   r  r   CPointerru   r   r2  r,  r  r   r$   
np_cfarray)	r  re   r_   	ptr_dtyper   ru   rj   r  rV   dtype_r  rC   rD   r  C  s4   





z0get_cfarray_intrinsic.<locals>.intrinsic_cfarrayr)   )r  r  r  rC   r  rD   r  B  s   r  c                    s<  |j dd \}}|dd \}}|j}|jdv sJ t| }	t|}
t|
}t|tj	r9t
 |}n|f}|f} fddt||D }|}g }|jdkrf|D ]}||  ||}qWnt|D ]}||  ||}qj|   ||j }t|	||||dd |	 }t |j|S )zR
    numba.numpy_support.carray(...) and
    numba.numpy_support.farray(...).
    NrH  r  c                    r  rC   r  )r   r  r   r   rC   rD   r   {  r  znp_cfarray.<locals>.<listcomp>rM  r  )r   r   r  rs   ry   r	   r   r   r   r7  r   r   rc   r   r  r  r  rt   ru   r  r   r   r!   )rw   r=   rV   r   r  r  re   r_   r   r  r   r  r   offr   r   r   r   rC   r   rD   r  f  sJ   




	r  c                 C   sN   t |tjr| tjt|S t |tjr%| tttj|}|||fS J r-  )	r   r   r7  r   r   r   rx  rL   r$   )rw   r=   seqtyseqr  rC   rC   rD   _get_seq_size  s   r  c                    s2   |j  tjt|tj fdd}|S )zK
    Return a getitem() implementation that doesn't incref its result.
    c                    s$   | |} j r j| | |S r-  )r   r   decref)r=   r   r  rw   ru  r  rC   rD   wrap  s   
z$_get_borrowing_getitem.<locals>.wrap)ru   rL   rs  rt  r$   r   r   )rw   r  r  rC   r  rD   _get_borrowing_getitem  s   r  c                    st    tj}t|d fdd}g }||}}	t|D ]}
|
dkr+|||	\}}	|t ||	 qt|S )zF
    Compute the likely shape of a nested sequence (possibly 0d).
    r   c                    sN   t | tjrt| dkrdS | d  |dfS t| }| j| |ffS )Nr   NN)r   r   r7  r   r=  r  ru   )r  r  ru  r=   rw   r   rC   rD   get_first_item  s   
z.compute_sequence_shape.<locals>.get_first_item)r   r   r   r   r8   rc   r  r   )rw   r=   rj   r  r  r   r  r   innertyinnerrg   rC   r  rD   compute_sequence_shape  s   

r  c                    s0   fdd  fdd||| dS )z?
    Check the nested sequence matches the given *shapes*.
    c                      s   j  td d S )N)zincompatible sequence shape)rD  rE  r   rC   r   rC   rD   _fail  s   
z#check_sequence_shape.<locals>._failc                    s<  t |dkrd S t| |}|d }d||}j|dd    W d    n1 s/w   Y  t |dkr<d S t| tjrut| }t	|}| j
}|||jf}	||	|dd   W d    d S 1 snw   Y  d S t| tjrtt | D ]}
| |
 }||
}	||	|dd   qd S J | )Nr   rA  FrB  rF   )r   r  r   r   r   r   rx  r  r	   r  ru   r   r7  r8   r=  )r  r  r   r   expectedr  ru  r  r  r  rg   r  r=   check_seq_sizerw   rC   rD   r    s0   
"z,check_sequence_shape.<locals>.check_seq_sizeNrC   )rw   r=   r  r  r   rC   r  rD   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              
      sB   t j j| dd}|| j}t || d S rQ  )r	   r  r  r   ru   r   )r   r:  r   re   )r  r=   rw   r   r   r   rC   rD   assign_item  s
   z-assign_sequence_to_array.<locals>.assign_itemc                    s  t |dkrt| tjtjfrJ || | d S |d }t| tjr[t| }t|#}| j}|||j	f} |||dd  ||j	f  W d    d S 1 sTw   Y  d S t| tjrt
t | D ]!}	| |	 }||	}tj|	}
 |||dd  ||
f  qgd S J | rh  )r   r   r   rx  r7  r  r	   r  ru   r   r8   r=  r   r   )r  r  r   r   r   ru  r  r  r  rg   r   )assignr  r=   rw   rC   rD   r  	  s(   
 "z(assign_sequence_to_array.<locals>.assignrC   NrC   )rw   r=   r   r   r   r  r  r  rC   )r  r  r  r=   rw   r   r   r   rD   assign_sequence_to_array  s   r  c                 C   s>   t | |\}}t|r|}n
t|}|d u rd S t||dS r  )r5   r   r  r   r   )r  r  ru   rj   	seq_dtyperC   rC   rD   np_array_typer%  s   r  c                 C   s0   t d| t| ||}|||}dd }||fS )Nr   c           
   	   S   s   |j }|j}|jd }|d }t| ||||}t||ksJ t| |||| t| |||}	t| ||	j||	j	||| t
| ||j |	 S r   )r   rj   r   r  r   r  r  r  r   r   r!   r   )
rw   r=   rV   r   r  rj   r  r  r   r  rC   rC   rD   r  6  s   


znp_array.<locals>.codegen)r  r  )r  objru   r  rV   r  rC   rC   rD   np_array0  s
   

r  c                 C   sL   t d| t| stdt|st|d u rd}t|ddd}|S )Nr   z(The argument "object" must be array-likez:The argument "dtype" must be a data-type if it is providedc                 S   
   t | |S r-  )r  )r  ru   rC   rC   rD   r   T  rz  zimpl_np_array.<locals>.implr-  )r  r   r   r   r   r  )r  ru   r   r   rC   rC   rD   impl_np_arrayJ  s   



r  c           
      C   s   | d}| |}|d||}||||||}||d|||d||}|j|dd d| }	| j|t|	f W d    |S 1 sLw   Y  |S )Nr   r   rj  FrB  z%s(): axis out of bounds)	r9   r   r  ry  r  r   rD  rE  rF  )
rw   r=   r   rj   r   r   ll_ndimis_neg_axisaxis_out_of_boundsr   rC   rC   rD   _normalize_axisY  s   


r  c              
   C   s   t ||d ks
J ttj|}t||}td}t|d D ])}t|}	|d|	|}
|| }||
|	|	||	}|
|t||d| q"|
|t||d| t|||S )z
    Compute shape with the new axis inserted
    e.g. given original shape (2, 3, 4) and axis=2,
    the returned new shape is (2, 3, 1, 4).
    rF   rj  r   r   r   r  r	   r   rR   r8   r   r  ry  r  rb   r   r>   )rw   r=   
orig_shaperj   r   ll_shtyr   r  rZ  ll_dim
after_axisr#  r   rC   rC   rD   _insert_axis_in_shapel  s   


r  c              
   C   s   t ||d ks
J ttj|}t||}td}td}t|d D ]'}	t|	}
|d|
|}|||	|
||
}|
||	 t||d| q'|
|t||d| t|||S )zD
    Same as _insert_axis_in_shape(), but with a strides array.
    rF   r   rj  r  )rw   r=   orig_stridesrj   r   r  r   r  r   rZ  r  r  r   rC   rC   rD   _insert_axis_in_strides  s"   




r  c              	   C   s   |j }|j}|jd }t|| ||d d}t|| |}	t||j}
t||j}t| ||
||}t	| ||||}t
|	|j|||j|j|jd |	 S )z/
    np.expand_dims() with the given axis.
    r   r   r&  )r   rj   r   rs   r	   r   r_   r   r  r  r   r   r   r   r   r   )rw   r=   rV   r   r   r  rj   r  r  r  r   r   
new_shapesnew_stridesrC   rC   rD   expand_dims  s$   
r  c                 C   sB   |j dkr|jnd}|j|j d |d}|||}dd }||fS )NrF   r  r  c                 S   sP   |  ||d |jd tj}t| |d|jj|}t| ||||}t| ||j|S )NrF   znp.expand_dims)	r   r   r   r   r  r   rj   r  r    )rw   r=   rV   r   r   r  rC   rC   rD   r    s   znp_expand_dims.<locals>.codegen)rj   r  r  )r  r  r   r  r  rV   r  rC   rC   rD   np_expand_dims  s
   
r  c                 C   sL   t | tjsd|  }t|t |tjs d| }t|dd }|S )Nz)First argument "a" must be an array. Got z(Argument "axis" must be an integer. Got c                 S   r  r-  )r  )r  r   rC   rC   rD   r     rz  z!impl_np_expand_dims.<locals>.impl)r   r   r   r   r   r   )r  r   r   r   rC   rC   rD   impl_np_expand_dims  s   



r  c                    s   t  fddfddS )Nc                    sX   | fdd|D  fdd}t tdkr tnd tj||fS )Nc                    s    g | ]}|j t|j d qS )r  )r  rF  rj   r  )minimumrC   rD   r     s     z-_atleast_nd.<locals>.impl.<locals>.<listcomp>c                    sn   t t |d } fddt|D }t|dkr+ |j|}n|d }t |j|S )Nr   c                    s"   g | ]\}}} |||qS rC   rC   )r   r  r  r  r=   rw   	transformrC   rD   r     s    z>_atleast_nd.<locals>.impl.<locals>.codegen.<locals>.<listcomp>rF   )_atleast_nd_transformr	   r   r   r   rm  r   r    )rw   r=   rV   r   arrsretsr  )re  r  r  r|  r  rD   r    s   

z*_atleast_nd.<locals>.impl.<locals>.codegenrF   r   )r$   r   r   r4  StarArgTuple
from_types)typingcontextr   r  )r  r  )re  r|  rD   r     s   
z_atleast_nd.<locals>.implc                     s    |  S r-  rC   r=  )r   rC   rD   r>    s    z_atleast_nd.<locals>.<lambda>r  )r  r  rC   )r  r   r  rD   _atleast_nd  s   r  c                    s"   t  ksJ  fdd}|S )z`
    Return a callback successively inserting 1-sized dimensions at the
    following axes.
    c           	         sb   t D ]*}|d }|j|k r.t | }|j|jd d}t| |t|||f|}|}q|S )NrF   r  )r8   rj   r	   r   r  r  r   r$   )	rw   r=   r  r  r  rg   rj   r   newarrtyr  min_ndimrC   rD   r    s   
z(_atleast_nd_transform.<locals>.transform)r   )r  r  r  rC   r  rD   r    s   r  c                  G   s"   t dd | D rtddgS d S )Nc                 s   r,  r-  r.  r  rC   rC   rD   r0    r1  z np_atleast_1d.<locals>.<genexpr>rF   r   r5  r  r=  rC   rC   rD   np_atleast_1d  s   r  c                  G   s$   t dd | D rtdddgS d S )Nc                 s   r,  r-  r.  r  rC   rC   rD   r0    r1  z np_atleast_2d.<locals>.<genexpr>rH  r   r  r=  rC   rC   rD   np_atleast_2d     r  c                  G   s$   t dd | D rtdg dS d S )Nc                 s   r,  r-  r.  r  rC   rC   rD   r0     r1  z np_atleast_3d.<locals>.<genexpr>r  )r   r   rH  r  r=  rC   rC   rD   np_atleast_3d  r	  r
  c	                 C   s  t |t |  krt |  krt |ksJ  J td}	t| |||}
t||
j}g }|D ]2}|	}tt||D ]!\}\}}|d|	||}|
||}||||||}q=|| q2|
j}t|||||D ]_\}}}}}|j}tj||tj|jd}|9}t| |||||j|}t| |||}| |||j|j}t| |||||j|}t| |||| W d   n1 sw   Y  t|||}qp|
S )z2
    Concatenate arrays along the given axis.
    r   r  )orderN)r   r	   r   r  r   r   rA  r   r   r9   r   r  ry  rc   r   r  r  r  r   r   ru   r   r   )rw   r=   r   re  r  
arr_shapesarr_stridesr  
ret_shapesr   r  ret_stridescopy_offsetsarr_shr   rZ  r   r  is_axisaddendret_datar  r  arr_starr_datar  r   r  r   r  rC   rC   rD   _do_concatenate$  sL   6



r  c                    s  |j } fddt||D }t d||} fdd|D } fdd|D } fdd|d D }	t|D ] d||}
|	 } |}fd	d|d
d  D } |
v\}}| t	 j
||g } || W d    n1 sw   Y  |@ tj}|D ]} | d||}q j |dd j td f W d    n1 sw   Y  W d    n1 sw   Y  W d    n1 sw   Y  q9 fdd|	D }	t |||||||		}t || S )Nc                    "   g | ]\}}t | |d qS r   r  r   r!  r  r   rC   rD   r   d  r  z#_np_concatenate.<locals>.<listcomp>np.concatenatec                       g | ]	}t  |jqS rC   )r	   r   r_   r   r  r  rC   rD   r   j  r  c                    r  rC   r	   r   r   r  r  rC   rD   r   k  r  c                    s   g | ]}t  |qS rC   )r	   r   r  r  rC   rD   r   p  rX  r   r  c                    s   g | ]}|  qS rC   rC   r  )rZ  rC   rD   r   w  r  rF   FrB  z<np.concatenate(): input sizes over dimension %d do not matchc                    s   g | ]}  |qS rC   )r>   r  r  rC   rD   r     rR  )rj   r   r  r8   r   r9   r>   r  r  r  ry  r  r	   r  r  r   r  rD  rE  r   r  r!   r   )rw   r=   re  r  r  r   rj   r  r  r  r  ret_shape_ptrret_shother_shapeson_axison_other_dimr#  is_okr  rC   )r=   rw   rZ  rD   _np_concatenatea  s`   

r%  c                    s  |j }td}td}tt|}	 fddt||D }t d||}t |d j}
|dd  D ]A}tj}tt |j|
D ]1\}} 	| 
d||} j |dd j td	 W d    n1 ssw   Y  qGq8 fd
d|D }ttj|t }t }t|d D ]5}t|} 
d||}|
| } | |||} |t |d|  |t |d| q |t |d|  |	t |d| t  |}|gt| }t  |} fddtt|D }t|d D ]6}t|} 
d||} | |||}tt|D ]} || | t || d| q6qtt|D ]} |t || d| qT fdd|D }t |||||||	}t || S )Nr   rF   c                    r  r  r  r  r   rC   rD   r     r  z_np_stack.<locals>.<listcomp>np.stackr  FrB  )z5np.stack(): all input arrays must have the same shapec                    r  rC   r  r  r  rC   rD   r     r  rj  c                    r  rC   r  r  )r=   r  rC   rD   r     rX  c                    s   g | ]}t   |qS rC   )r	   r   r>   )r   r$  r  rC   rD   r     r  )rj   r	   r   r   r   r  r   r_   r  r  r   r   r  rD  rE  r   r   r  rR   r8   r  ry  r  rb   r>   r  r!   r   )rw   r=   re  r  r  r   rj   r   r  
ll_narraysr  r  r$  r#  orig_shr  input_shapesr  rZ  r  r  r   input_stridesrg   r  rC   )r=   rw   r  rD   	_np_stack  s   








r+  c                 C   sT   |d urt |tjsd S t| d|\}}|dkrd}t|t|}t|||S )Nr  r   z.zero-dimensional arrays cannot be concatenated)r   r   r   r6   r   r2  r7   r   )r  ra  r   ru   rj   r   r  rC   rC   rD   np_concatenate_typer  s   
r,  c                 C   s6   t | ||}t|tjsJ |||}dd }||fS )Nc              	   S   sF   |  ||d |jd tj}t| |t|jd t||d |j|S r  )	r   r   r   r   r%  r   r	   r   r   rw   r=   rV   r   r   rC   rC   rD   r    s   znp_concatenate.<locals>.codegen)r,  r   r   r   )r  ra  r   r  rV   r  rC   rC   rD   np_concatenate  s
   
r.  c                 C      t | tjrddd}|S d S )Nr   c                 S   r  r-  )r.  ra  r   rC   rC   rD   r     rz  z!impl_np_concatenate.<locals>.implrK  r   r   r7  ra  r   r   rC   rC   rD   impl_np_concatenate     
r3  c                 C   s0   |D ]}|j dk s|j dkrd}t|qdS )NrF   rH  z7np.column_stack() is only defined on 1-d and 2-d arrays)rj   r   r2  )rw   r   ra  r  r   rC   rC   rD   _column_stack_dims  s   
r5  c                 C   sB   t | d|td\}}t|}t|||}||}dd }||fS )Nznp.column_stack)dim_chooserc                 S   s   t |jd }t||d }g }g }| tjd}t||D ]:\}	}
|	jdkr3|	|	 |	|
 q|	jdks:J |	j
dd}t||	}t| |||
f|}|	| |	| qt| ||||j|S )Nr   rF   rH  r  )r   r   r	   r   r   r   r   r   rj   rc   r  r   r$   r  r%  r   )rw   r=   rV   r   orig_arrtys	orig_arrsre  r  r   r  r  rZ  
expand_signewarrrC   rC   rD   r  )  s$   



z np_column_stack.<locals>.codegen)r6   r5  r7   r   r   )r  r5  ru   rj   r  r  rV   r  rC   rC   rD   np_column_stack   s   
r;  c                 C   r  )Nc                 S   rw  r-  )r;  r5  rC   rC   rD   r   I  re  zimpl_column_stack.<locals>.implr1  r5  r   rC   rC   rD   impl_column_stackF  r  r>  c              	   C   s*   t | |t|jd t||d |j|S )z/
    np.stack() with the given axis value.
    r   )r+  r   r   r	   r   r   r-  rC   rC   rD   _np_stack_commonN  s   r?  c           	      C   sV   t | d|\}}tdd |D rdnd}t||d |}|||}dd }||fS )	Nr&  c                 s   s    | ]}|j d kV  qdS )rM  N)r  r  rC   rC   rD   r0  ^  s    z"np_stack_common.<locals>.<genexpr>rM  r   rF   c                 S   s,   |  ||d |jd tj}t| ||||S ru  )r   r   r   r   r?  r-  rC   rC   rD   r  b  s   z np_stack_common.<locals>.codegen)r6   r5  r   r   )	r  ra  r   ru   rj   r  r  rV   r  rC   rC   rD   np_stack_commonY  s   
r@  c                 C   r/  )Nr   c                 S   r  r-  )r@  r0  rC   rC   rD   r   l  rz  zimpl_np_stack.<locals>.implrK  r1  r2  rC   rC   rD   impl_np_stacki  r4  rA  c                 C   s4   t | ||\}}t||}t|}t|||}|S r-  )r6   rF  r7   r   r   )r  r   ra  ndim_minru   rj   r  r  rC   rC   rD   NdStack_typerq  s
   
rC  c                 C   &   t | d|d}||}dd }||fS )Nz	np.hstackrF   c                    sf   |j d }|d j}|dkr| tjd t| ||| S |dkr#dnd  fdd}| ||||S )Nr   rF   c                    s   t j|  dS r  r  ra  r  rC   rD   np_hstack_impl  r.  z3_np_hstack.<locals>.codegen.<locals>.np_hstack_implr   rj   r   r   r   r?  r  )rw   r=   rV   r   r4  rj   rF  rC   r  rD   r    s   

z_np_hstack.<locals>.codegenrC  r  r5  r  rV   r  rC   rC   rD   
_np_hstackz     rJ  c                 C   r  )Nc                 S   rw  r-  )rJ  r<  rC   rC   rD   r     re  zimpl_np_hstack.<locals>.implr1  r=  rC   rC   rD   impl_np_hstack  r  rL  c                 C   rD  )Nz	np.vstackrH  c                 S   sd   |j d }|d j}|dkrdd }n|dkr&| tjd}t| ||||S dd }| ||||S )Nr   c                 S   s   t t | dS ru  )r)  r  hstackrE  rC   rC   rD   np_vstack_impl  r  z3_np_vstack.<locals>.codegen.<locals>.np_vstack_implrF   c                 S      t j| ddS )Nr   r  r  rE  rC   rC   rD   rN    r.  rG  )rw   r=   rV   r   r4  rj   rN  r   rC   rC   rD   r    s   


z_np_vstack.<locals>.codegenrH  rI  rC   rC   rD   
_np_vstack  rK  rP  c                 C   r  )Nc                 S   rw  r-  )rP  r<  rC   rC   rD   r     re  zimpl_np_vstack.<locals>.implr1  r=  rC   rC   rD   impl_np_vstack  r  rQ  c                 C   rD  )Nz	np.dstackr  c                 S   s   |j d }|j}|d j}|dkrdd }| ||||S |dkrY| tjd}|j|jd d}	tj	|	g|j R  }
t
| ||
||}| tjd}t	||	}t| |||f|S |dkrl| tjd}t
| ||||S dd }| ||||S )Nr   c                 S   s   t | dddS )NrF   r  )r)  rM  r  rE  rC   rC   rD   rN    rB  z3_np_dstack.<locals>.codegen.<locals>.np_vstack_implrF   r  rH  c                 S   rO  )NrH  r  r  rE  rC   rC   rD   rN    r.  )r   r   rj   r  r   r   r   r  r   r$   r?  r  )rw   r=   rV   r   r4  r  rj   rN  r   stack_retty	stack_sig	stack_retr9  rC   rC   rD   r    s*   


z_np_dstack.<locals>.codegenrH  rI  rC   rC   rD   
_np_dstack  s   "rU  c                 C   r  )Nc                 S   rw  r-  )rU  r<  rC   rC   rD   r     re  zimpl_np_dstack.<locals>.implr1  r=  rC   rC   rD   impl_np_dstack  r  rV  fillc                 C   r  )Nc                 S   s   || d d < d S r-  rC   )r  r   rC   rC   rD   	fill_impl  s   zarr_fill.<locals>.fill_implrC   )r  r   rX  rC   rC   rD   arr_fill  s   rY  dotc                 C   r  )Nc                 S   r  r-  )r)  rZ  )r  otherrC   rC   rD   dot_impl  rv  zarray_dot.<locals>.dot_implrC   )r  r[  r\  rC   rC   rD   	array_dot   r  r]  c                 C   "   t | std|  dd }|S )NzCannot np.fliplr on %s typec                 S   s4   t | }|jdk rtd|d d d d ddf S )NrH  r  r  .r)  r*  rj   r   r:  r  rC   rC   rD   r     s   

znp_flip_lr.<locals>.implrg  r:  r   rC   rC   rD   
np_flip_lr     rb  c                 C   r^  )NzCannot np.flipud on %s typec                 S   s.   t | }|jdk rtd|d d ddf S )NrF   zInput must be >= 1-d.r  .r_  r`  rC   rC   rD   r     s   

znp_flip_ud.<locals>.implrg  ra  rC   rC   rD   
np_flip_ud  rc  rd  c                    sN   t |tjst|t|j tjtj d|} fdd}||fS )zY Creates a tuple of slices for np.flip indexing like
    `(slice(None, None, -1),) * sz` r  c                    sZ   dd }t jg}tjg|R  }| t j}| }| |g}	| ||||	}
|
S )Nc                 S   s*   |}t | D ]}t||td d d}q|S )Nr  )r8   r0   r"  )lengthempty_tupler   rg   rC   rC   rD   r   5  s   z6_build_flip_slice_tuple.<locals>.codegen.<locals>.impl)r   r   r   r$   r   get_constant_undefr  )rw   r=   r$   r   r   inner_argtypes	inner_sigll_idx_typerf  
inner_argsr   r   
tuple_typerC   rD   r  4  s   

z(_build_flip_slice_tuple.<locals>.codegen)	r   r   r0  r   r  r   r   r3  slice3_type)r  szrV   r  rC   rl  rD   _build_flip_slice_tuple*  s   

rp  c                 C   s&   t | tjstd|  dd }|S )NzCannot np.flip on %s typec                 S   s   t | j}| | S r-  )rp  rj   )r:  slrC   rC   rD   r   O  s   
znp_flip.<locals>.impl)r   r   r   r   r   ra  rC   rC   rD   np_flipH  s   rr  c                 C   s   t | tjtjtjfrd	dd}|S t |tjrd	dd}|S t |tjr4t |jjtjr4d	dd}|S t |tj	rKt
dd |jD rMd	dd}|S d S d S )
Nr   c                 S      t jt | ||dS r  )r)  array_splitr*  r   indices_or_sectionsr   rC   rC   rD   r   Y  s
   znp_array_split.<locals>.implc                 S   sP   t | j| |\}}tt|d g| |g|| d   }tj| ||dS )NrF   r  )divmodr_   r)  cumsumr   rt  )r   rv  r   rZ  r  r   rC   rC   rD   r   c  s   c              	   S   sp   t | j}tdd| j|}g }d}|D ]}t||t||}|| |  |}q|| t||t|d   |S Nznp.splitr   r   )r1   rj   r   r0   r"  rc   r   rv  r   	slice_tupr   prevr  r   rC   rC   rD   r   t  s   
c                 s   r,  r-  r   r   r   )r   r;  rC   rC   rD   r0    r1  z!np_array_split.<locals>.<genexpr>c              	   S   st   t | j}tdd| j|}g }d}t|D ]}t||t||}|| |  |}q|| t||t|d   |S ry  )r1   rj   r   r   r0   r"  rc   rz  rC   rC   rD   r     s   
rK  )r   r   r3  ListTyper  r   IterableTypeiterator_typer   r4  r5  r   rv  r   r   rC   rC   rD   np_array_splitV  s,   





r  c                 C   sL   t | tjtjtjfrddd}|S t |tjrddd}|S t| ||dS )Nr   c                 S   rs  r  )r)  splitr*  ru  rC   rC   rD   r     s   znp_split.<locals>.implc                 S   s4   t | j| |\}}|dkrtdtj| ||dS )Nr   z0array split does not result in an equal divisionr  )rw  r_   r   r)  rt  )r   rv  r   r  r  rC   rC   rD   r     s   r  rK  )r   r   r3  r~  r  r   r  r  rC   rC   rD   np_split  s   


r  c                 C   N   t | tjsd}t|t |tjtjtjtjfs!d}t|dd }|S )N#The argument "ary" must be an array:The argument "indices_or_sections" must be int or 1d-arrayc                 S   "   | j dk r	tdtj| |ddS )NrH  z3vsplit only works on arrays of 2 or more dimensionsr   r  rj   r   r)  r  r   rv  rC   rC   rD   r        
znumpy_vsplit.<locals>.implr   r   r   r   r   r   r  r3  r   rv  r   r   rC   rC   rD   numpy_vsplit     

r  c                 C   r  )Nr  r  c                 S   s<   | j dkr	td| j dkrtj| |ddS tj| |ddS )Nr   z3hsplit only works on arrays of 1 or more dimensionsrF   r  r  r  rC   rC   rD   r     s
   

znumpy_hsplit.<locals>.implr  r  rC   rC   rD   numpy_hsplit  s   

r  c                 C   r  )Nr  r  c                 S   r  )Nr  z3dsplit only works on arrays of 3 or more dimensionsrH  r  r  r  rC   rC   rD   r     r  znumpy_dsplit.<locals>.implr  r  rC   rC   rD   numpy_dsplit  r  r  c                 C   s   | |k S )z7
    Trivial comparison function between two keys.
    rC   r  rC   rC   rD   
default_lt  s   r  Fc                 C   sr   | |j |f}zt| W S  ty8   | dkr"tj||dd}|j}n| dkr0tj||d}|j}|t|< | Y S w )z6
    Get a sort implementation of the given kind.
    r+   T)lt
is_argsortis_np_arrayr,   )r  r  )	rk   _sortsKeyErrorr+   make_jit_quicksortrun_quicksortr,   make_jit_mergesortrun_mergesort)r  lt_implr  keyrp  rq  rC   rC   rD   get_sort_func  s(   
r  c                 C   s$   t | tjrtS t | tjrtS tS r-  )r   r   rP  r   r  r   r  rv  rC   rC   rD   lt_implementation  s
   r  z
array.sortc                    s8   |j d }tdt|jd  fdd}| ||||S )Nr   r+   )r  r  c                    s    |  d S r-  rC   r  	sort_funcrC   rD   array_sort_impl#  r  z#array_sort.<locals>.array_sort_impl)r   r  r  ru   r  )rw   r=   rV   r   r  r  rC   r  rD   
array_sort  s   
r  c                 C   re  )NzArgument "a" must be array-likec                 S   s   |   }|  |S r-  )r  rp  )r  r   rC   rC   rD   np_sort_impl0  s   z"impl_np_sort.<locals>.np_sort_implrg  )r  r  rC   rC   rD   impl_np_sort*  s   
r  zarray.argsortc           	         s^   |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 r-  rC   r  r  rC   rD   array_argsort_impl@  re  z)array_argsort.<locals>.array_argsort_implrF   r=  )r   r  r   r  ru   replacer  )	rw   r=   rV   r   r  r  r  innersig	innerargsrC   r  rD   array_argsort7  s   
r  c                 C   s   |j |j ks|jdksJ |S )Nr  )r  r  )rw   r=   r  r  r   rC   rC   rD   array_to_arrayL  s   r  c                 C   4   dd }t ||}| ||||g}t| ||j|S )Nc                 S   s
   |  dS r   )rD  r  rC   rC   rD   r   [  rn  zarray0d_to_scalar.<locals>.impl)r$   r  r"   r   rw   r=   r  r  r   r   rV   r   rC   rC   rD   array0d_to_scalarS  s   
r  c                 C   r  )Nc                 S   s   t | d S rx  r`  r  rC   rC   rD   r   f  rv  z array_to_unichrseq.<locals>.impl)r$   r  r    r   r  rC   rC   rD   array_to_unichrseqd  s   
r  c                 C   rM  )zR
    An intrinsic returning a derived array with the given shape and strides.
    r   r  r_   r   rC   rC   rD   reshape_uncheckedq  rR  r  c                    s   dd   fdd}|S )Nc                 S   s   t | tjotdd | D S )Nc                 s   r,  r-  r}  rl  rC   rC   rD   r0  |  r1  z>type_reshape_unchecked.<locals>.check_shape.<locals>.<genexpr>)r   r   r7  r5  r_   rC   rC   rD   r`  z  s   z+type_reshape_unchecked.<locals>.check_shapec                    sJ   t | tjsd S  |r |sd S t|t|krd S | jt|ddS )Nr  r  )r   r   r   r   r  r  r`  rC   rD   typer~  s   z%type_reshape_unchecked.<locals>.typerrC   )rw   r  rC   r  rD   type_reshape_uncheckedx  s   	r  c                 C   s   |j d }|j}t|| ||d }t|| |}t||d }t||d }	t||j||	|j|jd |	 }
t
| |||
S )Nr   rF   rH  r  )r   r   rs   r	   r   r   r   r   r   r   r    )rw   r=   rV   r   r   r  r   r   r_   r   r   rC   rC   rD   impl_shape_unchecked  s   
r  c                    s`   |d t jfv rtdd  ntdd  |d t jfv r tdtdd d	 fdd	}|S )
Nc                 S   ra  r-  r  r  r_   rC   rC   rD   rS    r   zas_strided.<locals>.get_shapec                 S   r&  r-  rC   r  rC   rC   rD   rS       z,as_strided() strides argument cannot be Nonec                 S   r&  r-  rC   )r  r   rC   rC   rD   get_strides  r  zas_strided.<locals>.get_stridesc                    s   t |  | || |} | S r-  )r  )r  r_   r   rS  r  rC   rD   as_strided_impl  s   z#as_strided.<locals>.as_strided_implr  )r   rc  r&   r   r   )r  r_   r   r  rC   r  rD   
as_strided  s   


r  c                    s  t |tjrtt| jd tt| jd tdd n/t |tjrIt |jtjrItt| jt	| tt| jt	| tdd nt
dt|rYtdd  n&t |tjrftdd  nt |tjrzt |jtjrztd	d  nt
d
d fdd	}|S )NrF   c                 S   s   | fS r-  rC   window_shaperC   rC   rD   get_window_shape  r   z-sliding_window_view.<locals>.get_window_shapec                 S   r%  r-  rC   r  rC   rC   rD   r    r  z4window_shape must be an integer or tuple of integersc                 S   s   t t|S r-  )r   r8   r  r   rj   rC   rC   rD   get_axis  r  z%sliding_window_view.<locals>.get_axisc                 S   s   t dd||gS )Nsliding_window_viewr   r   r  rC   rC   rD   r    s   c                    s    fdd|D S )Nc                    s   g | ]	}t d d |qS )r  r   r  r  r  rC   rD   r     r  z9sliding_window_view.<locals>.get_axis.<locals>.<listcomp>rC   r  rC   r  rD   r    s   
z2axis must be None, an integer or tuple of integersc           
         s   |} ||| j }t|t|krtd}}t| j D ]}t||| j| }t||| j| }q | j }t||D ]7\}}|dk rItd|| |k rStd|| | d }t|||}t|||}t||| j| }|d7 }q=t| ||}	|	S )Nz2Must provide matching length window_shape and axisr   z-`window_shape` cannot contain negative valuesz4window_shape cannot be larger than input array shaperF   )	rj   r   r   r8   r0   r_   r   r   r  )
r  r  r   	out_shapeout_stridesrg   r  rZ  trimmedr  r  r  shape_bufferstride_bufferrC   rD   sliding_window_view_impl  s8   
z5sliding_window_view.<locals>.sliding_window_view_implr-  )r   r   r   r   r8   rj   r&   r3  ru   r   r   r   r   )r  r  r   r  rC   r  rD   r    s>   'r  c                 C   r  )Nc                 S   s>   | j dkrtdk rdS td| j dkrt| dS td)Nr   )rH  rH  FziThe truth value of an empty array is ambiguous. Use `array.size > 0` to check that an array is not empty.rF   z[The truth value of an array with more than one element is ambiguous. Use a.any() or a.all())r   r   r   r8  rD  r  rC   rC   rD   r     s   

zol_bool.<locals>.implr.  r  rC   rC   rD   ol_bool  s   r  c                    sn   t |ttjfstdt |ttjfstdt | tjs%td| jtt	  fdd}|S )Nz.The second argument "axis1" must be an integerz-The third argument "axis2" must be an integerz'The first argument "a" must be an arrayc                    s`   t dd|}t dd|}|dk r|7 }|dk r|7 }t ||}t|||}t| |S )Nznp.swapaxesaxis1axis2r   )r   r0   r)  r  )r  r  r  
axes_tuple	axes_listrj   rC   rD   r   ?  s   znumpy_swapaxes.<locals>.impl)
r   r   r   r   r   r   r   rj   r   r8   )r  r  r  r   rC   r  rD   numpy_swapaxes0  s   


r  c                 C   s  t dd| j|}t| j}d||< tt||jD ]$\}\}}	|dkr&|	}
n|	dkr-|}
n
||	kr5td|}
t|||
}qt||| j| }t	| |} t	||}|}t
|dkrmtt
|D ]}t||| j| }qa|}t
|dkrtt
|D ]}t||| j|d |  }q{|j| }t||f | | j}td d d f}t|D ]1}t|D ])}| || |  }||| |  }||| |  }t|D ]
}|||  ||< qqq|S )Nznp.take_along_axisr   rF   z*`arr` and `indices` dimensions don't matchr   )r   rj   r   r_   rA  r   r   r0   r)  r-  r   r8   rx  ru   r"  r!  )r  r   r   Ni_origNk_origindices_broadcast_shape	arr_shaperg   d1d2new_valarr_broadcast_shapeNiNkJr   np_s_iikka_1d
indices_1dout_1dr:  rC   rC   rD   _take_along_axis_implP  sT   

r  c                    s  t | tjstdt |tjstdt |jtjs"tdt|r)d}n| j}||jkr6tdt	t
|jt|rIfdd}|S t|d t |tjsYtd	|j}|d
k re| j| }|d
k sn|| jkrstdt	t
| t	t
|d | j fdd}|S )Nz)The first argument "arr" must be an arrayz.The second argument "indices" must be an arrayz'The indices array must contain integersrF   z;`indices` and `arr` must have the same number of dimensionsc                    s   t |  |ddd S )Nr   rC   )r  r  r  r   r   )r  rC   rD   take_along_axis_impl  s   z1arr_take_along_axis.<locals>.take_along_axis_implr   zaxis must be a literal valuer   zaxis is out of boundsc                    s   t | || S r-  )r  r  r  r  r  rC   rD   r    s   )r   r   r   r   r   ru   r   r   rj   r   r8   r   r0  r  r   )r  r   r   arr_ndimr  rC   r  rD   arr_take_along_axis  s>   






r  T        c                 C   s   t | tjr2t | tjrddd}|S t | tjr ddd}|S t | tjr-ddd}|S tdt| ret | j	tjrDddd}|S t | j	tjrRdd	d}|S t | j	tjr`dd
d}|S tdtd)NTr  c                 S   r%  r-  rC   r  r  nanposinfneginfrC   rC   rD   r     rt  znan_to_num_impl.<locals>.implc                 S   sf   |d ur|nt t| j}|d ur|nt t| j}t | r#|S t | r*|S t | r1|S | S r-  )r)  finfor9   r"  rF  rm  isneginfisposinf)r  r  r  r  r  min_infmax_infrC   rC   rD   r     s   


c                 S   s2   t j| j|||d}t j| j|||d}t||S )N)r  r  r  )r)  
nan_to_numr  r  complex)r  r  r  r  r  r9  r  rC   rC   rD   r     s   
z4Only Integer, Float, and Complex values are acceptedc                 S   r%  r-  rC   r  rC   rC   rD   r     rt  c                 S   s   |d ur|nt | jj}|d ur|nt | jj}t | }|r&t |n|}|j}	t|j	D ]%}
t 
|	|
 r>||	|
< q0t |	|
 rJ||	|
< q0t |	|
 rU||	|
< q0|S r-  )r)  r  ru   r"  rF  r*  r  r'  r8   r   rm  r  r  )r  r  r  r  r  r  r  x_outputoutput_flatrg   rC   rC   rD   r     s(   


c                 S   sL   t | }|rt |n|}t j|jd|||d t j|jd|||d |S )NF)r  r  r  r  )r)  r*  r  r  r  r  )r  r  r  r  r  r  r  rC   rC   rD   r     s"   
z4The first argument must be a scalar or an array-likeTr  NN)
r   r   rN  r   rP  r  r   r   r   ru   )r  r  r  r  r  r   rC   rC   rD   nan_to_num_impl  s6   
Z
V
B
6
3

r  r-  r  r@  rK  rK  )Fr  r  (  rW  r  rY  rs  r>  llvmliter   llvmlite.irr   numpyr)  numbar   r   
numba.corer   r   r   r	   r
   r   numba.np.numpy_supportr   r   r   r   r   r   r   r   r   r   r   r   r   numba.core.imputilsr   r   r   r   r   r   r   r    r!   r"   r#   numba.core.typingr$   numba.core.typesr%   numba.core.extendingr&   r'   r(   r)   r*   
numba.miscr+   r,   numba.cpythonr-   numba.cpython.charseqr.   r/   numba.cpython.unsafe.tupler0   r1   r2   numba.core.typing.npydeclr3   r  r4   r  r5   r6   r7   rE   rH   rs   ry   r   r   r   r   r   r   r   r   r   r   r   r   ArrayIteratorBORROWEDr  r%  r   r)  rt  r   r  r+  r7  r6  r  Anyr<  r   r@  r   rF  rJ  r  rL  rY  rr  r{  r  r  r  r3  r  r  r  r  r  r  r  r  r  r  r  r(  r,  r-  r7  r<  broadcast_shapesrJ  r   rQ  rT  r[  rg  r9  r  r  r  r  VarArgr  r  r  r  r  r  	geomspacer  rot90r  r  r  r  r  r  r  resizer  rc   r  r  r  r  r  r+  r/  rJ  rI  rL  rd  r_   ri  r   rk  uniqueru  r  r  rw  r  r  r  r  r,  r  r  
MemoryViewr  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  DTypeNumberClassr  r  r  r  r  r  r  r0  r  r  r  r  r  Bytesr  is_r#  r%  r+  r0  r;  r<  r  r  r)  r  r  r  r  r  r  r-  r  r  r  r!  r  r  r  r  r=  r  NumpyNdIterTyper  eqr  r  r  r  r  r  r  r  r  r  rx  r  r  r  r  r  r  r  r  r
  r  r  r  r  r  r  r7  r  r  r  r  r   r$  r(  eyer-  diagr3  r   r7  diagflatr<  rC  rD  rO  rW  r4  rk  r  rq  rt  ru  rv  r  ry  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r   r  r  r  r  r  r  r  r  r  
atleast_1dr  
atleast_2dr  
atleast_3dr
  r  r%  r+  r,  r.  r  r3  r5  r;  column_stackr>  r?  r@  stackrA  rC  rJ  rM  rL  rP  vstackrQ  	row_stackrU  dstackrV  rY  r]  r  rb  r  rd  rp  fliprr  rt  r  r  r  vsplitr  hsplitr  dsplitr  r  r  r  r  r  rp  r  argsortr  r  UnicodeCharSeqrP  r  r  NPTimedelta
NPDatetimer  r  r  type_callabler  r  libstride_tricksr  r  r8  r  r  r  r  take_along_axisr  r  r  rC   rC   rC   rD   <module>   s    04<	E



D


(





22=QE +
*=%



*

(
9



 


6


L$
@



.






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


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










&

#a

C*%
A

*
W$4
))




=2Y
	
%
	



)	




>


	

^

;
+