
    ih             
       /   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l3mAZA ddlBmCZDmEZFmGZGmHZHmIZI d ZJd ZKd ZLd ZMd ZNd ZOd ZPd ZQd ZR	 dQdZSd ZTd ZU e5eU      d        ZV e$dej                        d         ZXd! ZY e$d"ej                         e*e.j                        d#               Z\	 dQd$Z]d% Z^d& Z_ e$ej                  ej                  ej                         e$ej                  ej                  ej                        d'               Zc e$ej                  ej                  ej                        d(        Ze e$ej                  ej                  ej                  ej                        d)        Zh e$eiej                        d*        Zj e$d+ej                        d,        Zle"d-k  r$ e$d.ej                  ej                        d/        Zm G d0 d1en      Zo G d2 d3eo      Zp G d4 d5eo      Zq G d6 d7eo      Zr G d8 d9eo      Zs G d: d;eo      Zt G d< d=en      Zud> Zv e$ej                  ej                  ej                        d?        Zwd@ ZxdA ZydB ZzdC Z{dD Z|dE Z}dF Z~dG Ze7dH        Ze7dI        Ze4dJ        ZdK Z e5e
j                        dL        Ze4dM        Z e5e
j                        dN        Z e5e
j                        dO        ZdP Z e5edQR      dS        Z e5edTR      dU        ZdV ZdW Z e$dXej                        dY        ZdZ Z e$dXej                  ej                        d[        Z e$dXej                   ej&                  ej                              d\        Z e5e
j*                        dQd]       Z e%ej                  d^      d_        Z e5e
j0                        dRd`       Z e5e
j4                        dRda       Z e5e
j8                        dSdb       Zdc Zdd Z e$deej                  ej                        df        Z e$deej                   ej&                  ej                              dg        Ze"dhk  r e5e
jD                        di        Zn e5e
jD                        dj        Z e5e
jH                        dk        Z e5e
jL                        dQdl       Z e$dmej                        dn        Z e$e
jR                  ej                        do        Z e$dpej                        dq        Ze4dr        Ze4ds        Z e5e
j\                        dQdt       Z e6ej                  du      dTdv       Zdw Z e5e
jd                        dx        Z e5e
jh                        dy        Z e5e
jl                        dz        Z e5e
jp                        d{        Ze4d|        Z ejl                  ej                  d}      d~        Ze7d        Zd Z e5edQR      d        Z e$dej                  ej~                        d        Z e%ej                  d      d        Z e%ej                  d       e%ej                  d      d               Z e%ej                  d       e%ej                  d      d               Z e%ej                  d       e%ej                  d      d               Z e%ej                  d      d        Z e%ej                  d       e%ej                  d      d               Z e%ej                  d       e%ej                  d      d               Z e%ej                  d      d        Z e%ej                  d      d        Z e%ej                  d      d        Z e%ej                  d      d        Z e%ej                  d      d        Z e%ej                  d      d        Z e(ej                  ej                         e(ej                  ej                        d               Zd Z e%ej                  d      d        Z e%ej                  d       e%ej                  d      d               Z e%ej                  d      d        Z e%ej                  d      d        Z e%ej                  d      d        Zd Z e6ej                  d       e6ej                  d      d               Zd Z  e%ej                  d      eܫ         e%ej                  d      eܫ        e$dej                  ej                        d        Z e&ej                        d        Z e$dej                  ejd                        d        Z e&ej                        d        Z e'ej                        d        Z e$dej                  ejd                        d        Z e$dej                  ej                        d        Z e$dej                  ejd                  ej                        d        Z e$dej                  ej                  ej                        d        Z e)ej                        d        Z e)ej                        d        Z e)ej                        d        Z e$ej                  ej                  ej                        d        Z e8ej                  d      d        Zd Zd Z	 	 dTdZ	 dQdÄZdĄ Zdń ZdƄ Z e%ej                  dǫ      dȄ        Z e$d"ej                         e*e.j                        dɄ               Z e$ej                  ej                  ej                        dʄ        Z e$ej                  ej                  ej                  ej                        d˄        Z e$eiej                        d̄        Z e$e
j                  ej                        d̈́        Z e$d"ej                          e*e.j                        d΄               Z e$e ej&                  ej                               e$e
j                   ej&                  ej                              dτ               Z e$eej                         e$e
j                  ej                        dЄ               Z e$d"ej
                         e*e.j                        dф               Z e$e
j                  ej                        d҄        Z e$d"ej                         e*e.j                        dӄ               Z
 e$ej                  ej                  ej                        dԄ        ZdՄ Z eAej                  d֫      dׄ        Zd؄ Ze7dل        Zdڄ Zdۄ Zd܄ Zd݄ Ze7dބ        Z e5e
j,                        efd߄       Ze7d        Z e5e
j4                        dQd       Ze7d        Z e6ej                  d      d        Z e5e
j<                        efd       Z e5e
j@                        dQd       Z! e5e
jD                        dQd       Z# e5e
jH                        dQd       Z% e5e
jL                        dQd       Z' e5e
jP                        dQd       Z) e5e
jT                        dQd       Z+d Z, ejj                  e,      d        Z- ejj                  e
j\                        ddefd       Z/ e5e
j`                        dUd       Z1 e5e
jd                        d        Z3 e5e
jh                        dUd       Z5d Z6 e5e
jn                         e6ej                  d      dQd              Z8d Z9 e5e
jt                        dTd       Z; e5e
jx                        dRd       Z=d Z>e7d        Z? e$dej                        d        Z@ e5e
j                        d        ZBd ZCe7d        ZD e5e
j                        d        ZF e5e
j                        d         ZH e$dej                  ej~                         e$dej                  ejd                        d               ZIe7d        ZJ e5e
j                        efd       ZL e5e      dQd       ZM e5e      dQd       ZNd ZOd ZPd	 ZQd
 ZRd ZSd ZTd ZUd ZVe7d        ZW e5e
j                        dQd       ZYd ZZd Z[d Z\d Z]e7d        Z^ e5e
j                        d        Z_d Z`d Za e5e
j                        d        Zc e5e
j                        d        Ze e5e
j                        d        Zgd Zhd Zid Zjd Zke7d         Zl e5e
j                        dUd!       Znd" Zoe7d#        Zp e5e
j                        d$        Zrd% Zse7d&        Zt e5e
j                        dUd'       Zvd( Zwe7d)        Zx e5e
j                        d*        Zze7d+        Z{ e5e
j                        d,        Z}e"d-k\  r  e5e
j                        e}       e7d-        Z e5e
j                         d.        Z ejl                  ej                  d/      d0        Z ejl                  ej                  d1      d2        Z e5e
j                        d3        Z e5e
j                        d4        Ze7d5        Z e5e
j                        d6        Z e5e
j                        dUd7       Z e5e
j                        dUd8       Z e5e
j                        d9        Z e5e
j"                        d:        Z e5e
j&                        d;        Zi Zd< ZdVd=Zd> Z e$d?ej                        d@        Z e5e
j4                        dA        Z e$dBej                  ejd                         e$e
j8                  ej                  ejd                        dC               Z e(ej                  ej                        dD        Z e(ej                  ej>                         e(ej                  ej@                         e(ej                  ej                         e(ej                  ejB                         e(ej                  ejD                         e(ej                  ejF                         e(ej                  ejH                        dE                                                  Z e(ej                  ej>                        dF        ZdG Z ejP                  e      dH        Z e$eej                  ej                  ej                        dI        Z ejj                  e
jV                  jX                  jZ                        dWdJ       Z ejj                  e
jV                  jX                  j\                        dQdK       Z e5e      dL        Z e5e
jb                        dM        Ze4dN        Z e5e
jh                        dO        Z e5e
jl                        dXdP       Zy(Y  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)tuple_setitembuild_full_slice_tuple)overload_classmethod)parse_dtypeparse_shape_parse_nested_sequence_sequence_of_arrays_choose_concatenation_layoutc                     t        |j                  |      t        |j                  |      g}| j                  j                  |      }|j	                  d|       y)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mds         O/var/www/html/dev/engine/venv/lib/python3.12/site-packages/numba/np/arrayobj.pyset_range_metadatarD   -   sK    
 tyy+6tyy+68N		$	$^	4Bgr"    c                 ^    d|j                   j                  dz
  z  dz
  }t        | |d|       y)zF
    Mark the result of a load instruction as positive (or zero).
       r   N)r9   widthrD   )r=   r>   r@   s      rC   mark_positiverI   8   s.     1,-2Kwa5rE   c                       j                   t        j                        j                   G  f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                   <     e Zd Z fdZefd       Z xZS )make_array.<locals>.ArrayStructc                 d   t        
	      }	 | j                  j                  d|      }| j                  j                  	   }| j                  |      }|#t        j                  | j                  |d      }n|} || j                  |f      }||fS # t        $ r t        |   |      cY S w xY w)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_types          rC   rT   z*make_array.<locals>.ArrayStruct._make_refsN   s    OZ8C@!]]77SI

 88DI''	2G{#//w6:<	  	 T]]YL9Cc>! ' @[$:3??@s   B B/.B/c                 H   | j                   }dk(  rj                  | d      S | j                  d      }g }t              D ]H  }t	        j
                  ||d|      }|j                  |      }|j                  |       t        ||       J t	        j                  ||      S )z\
            Override .shape to inform LLVM that its elements are all positive.
            r   shape)
rX   __getattr___get_ptr_by_namer8   r
   gep_inboundsr>   appendrI   
pack_array)	rY   r=   ptrdimsidimptrr>   basendims	          rC   re   z%make_array.<locals>.ArrayStruct.shapeb   s    
 mmGqy''g66 ''0CD4[ - --gsAqA||F+D!gt,	- %%gt44rE   )__name__
__module____qualname__rT   propertyre   __classcell__)ra   r`   rb   ro   rp   rc   s   @rC   r`   rL   L   s    	"( 
	5 
	5rE   r`   )as_arrayr
   create_struct_proxyrp   )rb   r`   ro   rp   rc   s   `@@@@rC   
make_arrayrx   @   sE     !))O&&7DD+5 +5d +5Z rE   c                 Z    | j                  |j                        }| j                  |      S )zB
    Return the item size for the given array or buffer type.
    )get_data_typedtypeget_abi_sizeof)contextrb   lltys      rC   get_itemsizer   |   s+       !1!12D!!$''rE   c                 `    |j                   rdnd}| j                  ||j                  ||      S )z3
    Load the item at the given array pointer.
    NrG   align)alignedunpack_valuer{   )r}   r=   arraytyrk   r   s        rC   	load_itemr      s6     OODE&+   - -rE   c                 b    |j                   rdnd}| j                  ||j                  |||      S )z4
    Store the item at the given array pointer.
    NrG   r   )r   
pack_valuer{   )r}   r=   r   valrk   r   s         rC   
store_itemr      s1     OODEgw}}c3eLLrE   c                     |j                   r;| j                  |||t        j                        }t	        j
                  |||      }|S | j                  |||t        j                        }|S )zM
    Fix the integer index' type and value for the given dimension size.
    )signedcastr   intpr.   	fix_indexuintp)r}   r=   idxtyidxsizeinds         rC   fix_integer_indexr      s]     ||ll7C

;d3 J ll7C<JrE   c                    t        |t        j                        rn|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   Arrayrp   r{   Integerrx   r   data)r}   r=   r   r   idxaryidxvals         rC   normalize_indexr      sv     %%%**/%++u}}555"E"7GS97GUFKK@{{F""czrE   c                     t        |      r4t        t        ||      D cg c]  \  }}t        | |||       c}} \  }}||fS c c}}w )z^
    Same as normalize_index(), but operating on sequences of
    index types and values.
    )lenzipr   )r}   r=   index_typesindicesr   r   s         rC   normalize_indicesr      s[    
 7|"7:;7P%')3 &5Wgu58&: %'  (W 	%'s   A
c                 "   | j                   }| j                  }| j                  }	t        j                  t        j
                  dd      }
|j                  |
   }t        |j                        }t        |	j                        }||z  |k7  r6||z
  }d| j                   dt        |      dkD  rdnd d| d}t        |      |*t        |j                  |	j                  d
            d	      }|j                  t        j                        }t!        |t"        t$        f      rt'        j(                  |||      }t!        |t"        t$        f      rt'        j(                  |||      }t!        |t*              r ||      }t-        |||||      }|.t        |j                  |	j                  d            d	      |d<   n||d<   |j/                  t        j                  d      }t'        j0                  |||j2                  j4                        }|D ]  }|j7                  ||dg      } ||d<   t        |j9                               }||k7  rt        dj;                  ||z
              |j=                         D ]  \  }}t?        | ||        | S )z
    Helper function for populating array structures.
    This avoids forgetting to set fields.

    *shape* and *strides* can be Python tuples or LLVM arrays.
    rG   CzThe datamodel for type z is missing fields  .Nmeminfo)re   stridesr   itemsizer   parentnswflagsnitemszmissing {0}) rP   rX   
_datamodelr   r   float64rU   set_fields_fe_typer   
ValueErrorr   get_value_typeget_typer   r   tuplelistr
   rj   intdictget_constantunpack_tupler9   countmulkeysformatitemssetattr)arrayr   re   r   r   r   r   r}   r=   r]   standard_arraystandard_array_type_datamodelrequired_fieldsdatamodel_fieldsmissingmsgintp_tattrsr   unpacked_shapeaxlen
got_fieldskvs                           rC   populate_arrayr      s{    nnGnnG  I [[37N$+$>$>~$N!7??@O9,,- 	**>!$44((8 9!'lQ.sB7q	Do711y)+,02 ##EJJ/F%%'""7E6:'E4=)$$Wgv>(C (#u " 	#E ~"7#9#9x($*+/1h !h!!%**a0F))'5%**:J:JKN ;VU5':;E(O UZZ\"J_$--o
.JKLL  1q! LrE   c                 n   |j                   }|j                  }|j                  t        j                  d      }t        j                  ||j                  | j                        }|D ]  }|j                  ||dg      } ||_
        |j                  t        j                  t        ||             |_        y)z
    Update some auxiliary information in *array* after some of its fields
    were changed.  `itemsize` and `nitems` are updated.
    rG   r   r   N)rP   rX   r   r   r   r
   r   re   rp   r   r   r   r   )arytyr   r}   r=   r   r   r   s          rC   update_array_infor      s    
 nnGnnG !!%**a0F))'5;;

KN ;VU5':;EL))%***6w*FHENrE   c                     t               )z/Constrain axis values to valid positive values.rR   )	func_namearg_namerp   axiss       rC   normalize_axisr     s    

rE   c                     t        | t              st        j                  d      t        |t              st        j                  d      | j                   d|j                   df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                 F    |dk  r||z  }|dk  s||k\  rt              |S Nr   r   )r   r   rp   r   r   s       rC   implz&normalize_axis_overloads.<locals>.impl$  s/    !8DLD!8tt|S/!rE   )r   r&   r	   TypingErrorliteral_value)r   r   rp   r   r   r   s        @rC   normalize_axis_overloadsr     sr    i/  !CDDh.  !BCC ""
#;x/E/E.F G4 	4 
 KrE   getiterc                    |j                   \  }|\  }| j                  ||j                        }| j                  t        j
                  d      }t        j                  ||      }||_        ||_	        | j                  r| j                  j                  |||       |j                         }	t        | ||j                  |	      }
|
S r   )argsmake_helperreturn_typer   r   r   r
   alloca_once_valueindexr   
enable_nrtnrtincref	_getvaluer"   )r}   r=   r[   r   r   r   iterobjzeroindexptrresouts              rC   getiter_arrayr   /  s    IWGU!!'3??;G

A.D(($7HGMGM 7GU3



C 7GS__c
BCJrE   c           
         t        j                  ||j                  |j                        }t        j                  ||j                  |j                        }|j                  |d   |      }t        j                  ||j                  |      }	|dd }
|dd }t        |t        j                        r"t        | |||||	|
|      }|j                         S |
rJ t        | |||	      S )z1 Evaluate `ary[idx]`, where idx is a single int. r   r   rG   N)r
   r   re   rp   r   r   pointer_addr   r   r   Buffer	make_viewr   r   )r}   r=   r   r   aryr   shapesr   offsetdataptrview_shapesview_stridesretarys                rC   _getitem_array_single_intr  G  s     !!'399EJJGF""7CKKuzzJG[[S)F!!'388V<G*K12;L+u||,7GUC"K?!! '5'::rE   iternextc           	      p   |j                   \  }|\  }|j                  }| j                  |||      } t        |      | ||j                        }	t        j                  ||	j                  d      \  }
|j                  |j                        }|j                  d||
      }|j                  |       |j                  |      5  t        | ||j                  ||	|      }|j                  |       t        j                   ||      }|j#                  ||j                         d d d        y # 1 sw Y   y xY w)NvaluerG   r   <)r   rb   r   rx   r   r
   r   re   r>   r   icmp_signed	set_validif_thenr  
yield_typeyield_increment_indexstore)r}   r=   r[   r   resultitertyiterr   r   r   r   r   is_validr  nindexs                  rC   iternext_arrayr  \  s    xxHVFTG!!'6!>G
*W
gwgmm
DC""7CIIQ?GFLL'E""3v6H
X		" -)Wf//#u
 	e((%8fgmm,- - -s   AD,,D5c           	         | j                  t        j                  d      }| j                  t        j                  d      }t        j                  ||j
                  |j                        }	t        j                  ||j                  |j                        }
g }g }g }t        |D cg c]  }t        |      s| c}      }d}t        ||      D ]  \  }}|t        j                  u rm|j                  t        |      z
  dz   |z   }t        |      D ]@  }|j                  |       |j                  |	|          |j                  |
|          |dz  }B t        |t        j                        r| j!                  |||      }t#        j$                  | |||       t#        j&                  |||	|          |j                  |j(                         t#        j*                  ||      }t#        j,                  |||
|         }|j                  |       |j                  |       nt        |t        j.                        rBt1        | ||||	|         }|rt        j2                  | |||	|   |       |j                  |       nAt        |      r(|j                  |       |j                  |       |dz  }nt5        d|      |dz  } ||j                  k  sJ ||j                  k  r=|j                  |	|          |j                  |
|          |dz  }||j                  k  r=t        j6                  | ||||dd      }|||fS c c}w )z
    Perform basic indexing on the given array.
    A (data pointer, shapes, strides) tuple is returned describing
    the corresponding view.
    r   rG   r  unexpected index type: F
wraparoundboundscheck)r   r   r   r
   r   re   rp   r   r   r   r   ellipsisr8   ri   r   	SliceTyper   r.   guard_invalid_slice	fix_slicestartget_slice_length
fix_strider   r   do_boundscheckrR   get_item_pointer)r}   r=   r   r   r   r   r  r   oner   r   output_indicesoutput_shapesoutput_stridesr   num_newaxesaxindexvalr   	n_missingrm   sliceshstr   r   s                             rC   basic_indexingr/  x  s    

A.D


uzz1
-C!!'399ejjAF""7CKKDGNMNkFs[5EsFGK	
Bw4  %ENN"

S\1A5CI9% %%d+$$VBZ0%%gbk2a	
 eU__-''h'GE''%GgufRj9!!%++.))'59B##GUGBK@B  $!!"%u}}-#GWeX$*2J0C&&wfRj"M!!#&  %!!$'!GB%U&LMM
aA F 
uzz/VBZ(gbk*
a uzz/ &&w'527ULG ]N33a Gs   &M7Mc           	           t        |      | |      }t        |||||j                  |j                  |j                         |S )zF
    Build a view over the given array with the given parameters.
    r   re   r   r   r   r   )rx   r   r   r   r   )	r}   r=   r   r   r   r   r   r   r  s	            rC   r   r     sF    
 %Z$Wg6F6"LL;;**& MrE   c           
          t        | |||||| j                        \  }}}	t        |t        j                        r"t        | |||||||	      }
|
j                         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   )r}   r=   r   r   r   r   r   r   r   r  r  s              rC   _getitem_array_genericr5    s     	w['#*#=#=	? 'G[, +u||,7GUC"K?!! '5'::rE   c           	          |j                   \  }}|\  }}|j                  dk\  sJ  t        |      | ||      }t        | ||j                  |||f|f      }t        | ||j                  |      S )z4
    Basic indexing with an integer or a slice.
    rG   )r   rp   rx   r5  r   r!   	r}   r=   r[   r   r   r   r   r   r   s	            rC   getitem_arraynd_intpr8    su     88LE5HC::??
*U
GWc
2C
 '3??!&eXv?CWgsDDrE   c           
      z   |j                   \  }}|\  }} t        |      | ||      }|j                  }t        j                  ||t        |            }	t        | |||	      \  }}	t        d |D              rt        | |||||||	      S t        | ||j                  ||||	      }
t        | ||j                  |
      S )z2
    Basic or advanced indexing with a tuple.
    r   c              3   P   K   | ]  }t        |t        j                           y wNr   r   r   ).0tys     rC   	<genexpr>z&getitem_array_tuple.<locals>.<genexpr>  s     
=2:b%++&
=   $&)r   rx   r   r
   r   r   r   anyfancy_getitemr5  r   r!   )r}   r=   r[   r   r   tuptyr   tupr   r   r   s              rC   getitem_array_tuplerE    s    
 88LE5HC
*U
GWc
2C++K""7Cs5zBG,Wg-8'CK 
=
==WgsD"Cg? 	? !'3??!&['CCWgsDDrE   c           	         |j                   \  }}}|\  }}}	t        |t        j                        r.|j                  }
t	        j
                  ||t        |            }n|f}
|f} t        |      | ||      }t        | ||
|      \  }
}	 t        | ||||
|| j                        \  }}}t        |      }|rt        | ||||
|      S | j                  ||	||j                        }	t!        | |||	       y# t        $ r d}Y Mw xY w)zH
    array[a] = scalar_or_array
    array[a,..,b] = scalar_or_array
    r   r3  TN)r   r   r   	BaseTupler
   r   r   rx   r   r/  r4  boolrR   fancy_setslicer   r{   r   )r}   r=   r[   r   r   r   valtyr   r   r   r   r   r   r   r   use_fancy_indexings                   rC   setitem_arrayrL    s&    ((E5%MCc%)kk&&w3u:Fh&
*U
GWc
2C -Wg-8'CK*7GUCg'.'A'AC 	! "&\ gwT)74 	4 ,,wUEKK
8CwW5  "!"s   
 C5 5DDc                     |j                   \  }|\  }t        |      } || ||      }|j                  }|j                  |d      }t	        | ||j
                  |      S r   )r   rx   re   extract_valuer#   r   )	r}   r=   r[   r   r   r   arysttyshapearyr   s	            rC   	array_lenrQ  4  s\    xxHUFSG
'7C
(CyyH


!
,CgwEErE   z
array.itemc           	      l   |j                   \  }|\  } t        |      | ||      }|j                  }|j                  |j	                  d||j                  d            d      5  d}| j                  j                  |t        |f       d d d        t        | |||j                        S # 1 sw Y   !xY w)N!=rG   Flikelyz>item(): can only convert an array of size 1 to a Python scalar)r   rx   r   r  r	  r9   	call_convreturn_user_excr   r   r   )r}   r=   r[   r   r   r   r   r   s           rC   
array_itemrX  ?  s    XXFEDC
*U
GWc
2CZZF	,,T66;;q>J % 
 
' GN))':vFG
 Wguchh77G Gs   %%B**B3   r   zarray.itemsetc           	         |j                   \  }}|\  }}||j                  k(  sJ  t        |      | ||      }|j                  }|j	                  |j                  d||j                  d            d      5  d}	| j                  j                  |t        |	f       d d d        t        | ||||j                         | j                         S # 1 sw Y   2xY w)NrS  rG   FrT  z/itemset(): can only write to an array of size 1)r   r{   rx   r   r  r	  r9   rV  rW  r   r   r   get_dummy_value)
r}   r=   r[   r   r   rJ  r   r   r   r   s
             rC   array_itemsetr]  O  s    xxuS###j#6__W00vv{{1~N$)  + 	KCC--gzC6J	K
 	7GUC:&&((	K 	Ks   8%CCc                   4    e Zd ZdZd Zd Zd Zd Zd Zd Z	y)	Indexerzq
    Generic indexer interface, for generating indices over a fancy indexed
    array on a single dimension.
    c                     t         )ze
        Prepare the indexer by initializing any required variables, basic
        blocks...
        r   rY   s    rC   preparezIndexer.preparej  
    
 "!rE   c                     t         )z=
        Return this dimension's size as an integer.
        r   ra  s    rC   get_sizezIndexer.get_sizeq  
     "!rE   c                     t         )z;
        Return this dimension's shape as a tuple.
        r   ra  s    rC   	get_shapezIndexer.get_shapew  rf  rE   c                     t         )z}
        Return a half-open [lower, upper) range of indices this dimension
        is guaranteed not to step out of.
        r   ra  s    rC   get_index_boundszIndexer.get_index_bounds}  rc  rE   c                     t         )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   ra  s    rC   	loop_headzIndexer.loop_head  s
     "!rE   c                     t         )z)
        Finish indexation loop.
        r   ra  s    rC   	loop_tailzIndexer.loop_tail  rf  rE   N)
rq   rr   rs   __doc__rb  re  rh  rj  rl  rn   rE   rC   r_  r_  d  s%    
""""	""rE   r_  c                   :    e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
y	)
EntireIndexerz:
    Compute indices along an entire array dimension.
    c                     || _         || _        || _        || _        || _        | j                   j                  t        j                        | _        y r;  )	r}   r=   r   r   dimr   r   r   ll_intp)rY   r}   r=   r   r   rt  s         rC   __init__zEntireIndexer.__init__  s?    
||225::>rE   c                 $   | j                   }|j                  | j                  j                  | j                        | _        t        j                  || j                        | _	        |j                         | _        |j                         | _        y r;  )r=   rN  r   re   rt  r   r
   rW   ru  r   append_basic_blockbb_startbb_endrY   r=   s     rC   rb  zEntireIndexer.prepare  sc    ,,))$((..$((C	(($,,?
224002rE   c                     | j                   S r;  r   ra  s    rC   re  zEntireIndexer.get_size  s    yyrE   c                     | j                   fS r;  r}  ra  s    rC   rh  zEntireIndexer.get_shape  s    		|rE   c                 <    | j                  d      | j                  fS r   ru  r   ra  s    rC   rj  zEntireIndexer.get_index_bounds      Q++rE   c                    | j                   }| j                   j                  t        | j                  d      | j                         |j                  | j                         |j                  | j                         |j                  | j                        }|j                  |j                  d|| j                        d      5  |j                  | j                         d d d        ||fS # 1 sw Y   ||fS xY wNr   >=FrT  )r=   r  r   ru  r   branchry  position_at_endr>   r  r	  r   rz  )rY   r=   	cur_indexs      rC   rl  zEntireIndexer.loop_head  s    ,,8DLL!4djjAt}}%.LL,	__W00y$))L$)  + 	(NN4;;'	( )##	( )##s   C..C:c                    | j                   }t        j                  ||j                  | j                              }|j                  || j                         |j                  | j                         |j                  | j                         y r;  )
r=   r
   r  r>   r   r  r  ry  r  rz  rY   r=   
next_indexs      rC   rn  zEntireIndexer.loop_tail  s^    ,,,,Wgll4::6NO
j$**-t}}%,rE   Nrq   rr   rs   ro  rv  rb  re  rh  rj  rl  rn  rp  rE   rC   rr  rr    s*    ?3,
$-rE   rr  c                   :    e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
y	)
IntegerIndexerz0
    Compute indices from a single integer.
    c                     || _         || _        || _        | j                   j                  t        j
                        | _        y r;  )r}   r=   r   r   r   r   ru  )rY   r}   r=   r   s       rC   rv  zIntegerIndexer.__init__  s1    ||225::>rE   c                      y r;  rp  ra  s    rC   rb  zIntegerIndexer.prepare      rE   c                 .    t        | j                  d      S NrG   )r   ru  ra  s    rC   re  zIntegerIndexer.get_size  s    a((rE   c                      yNrp  rp  ra  s    rC   rh  zIntegerIndexer.get_shape  s    rE   c                     | j                   | j                  j                  | j                   | j                               fS r;  )r   r=   addre  ra  s    rC   rj  zIntegerIndexer.get_index_bounds  s,    $,,**488T]]_EFFrE   c                     | j                   d fS r;  )r   ra  s    rC   rl  zIntegerIndexer.loop_head  s    xx~rE   c                      y r;  rp  ra  s    rC   rn  zIntegerIndexer.loop_tail  r  rE   Nr  rp  rE   rC   r  r    s+    ?)GrE   r  c                   :    e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
y	)
IntegerArrayIndexerz;
    Compute indices from an array of integer indices.
    c                     || _         || _        || _        || _        || _        |j
                  dk(  sJ | j                   j                  t        j                        | _	        y r  )
r}   r=   r   r   r   rp   r   r   r   ru  )rY   r}   r=   r   r   r   s         rC   rv  zIntegerArrayIndexer.__init__  sO    
	zzQ||225::>rE   c                    | j                   }t        j                  || j                  j                        d   | _        t        j                  || j                        | _        |j                         | _
        |j                         | _        y r   )r=   r
   r   r   re   idx_sizerW   ru  	idx_indexrx  ry  rz  r{  s     rC   rb  zIntegerArrayIndexer.prepare  sf    ,,,,Wdkk6G6GHK ,,WdllC224002rE   c                     | j                   S r;  r  ra  s    rC   re  zIntegerArrayIndexer.get_size  s    }}rE   c                     | j                   fS r;  r  ra  s    rC   rh  zIntegerArrayIndexer.get_shape  s    rE   c                 <    | j                  d      | j                  fS r   r  ra  s    rC   rj  z$IntegerArrayIndexer.get_index_bounds  r  rE   c                    | j                   }| j                   j                  t        | j                  d      | j                         |j                  | j                         |j                  | j                         |j                  | j                        }|j                  |j                  d|| j                        d      5  |j                  | j                         d d d        t        | j                  || j                  j                   | j                  | j"                  |      }t%        | j                  || j                  j                   || j&                        }||fS # 1 sw Y   xY wr  )r=   r  r   ru  r  r  ry  r  r>   r  r	  r  rz  r  r}   r   r{   r   r   r   )rY   r=   r  r   s       rC   rl  zIntegerArrayIndexer.loop_head  s   ,,8DLL!4dnnEt}}%.LL0	__i?  
 	( NN4;;'		( *LL'4::#3#3TZZ
 "$,,"&**"2"2E499Fi	( 	(s   E''E0c                    | j                   }t        j                  ||j                  | j                              }|j                  || j                         |j                  | j                         |j                  | j                         y r;  )
r=   r
   r  r>   r  r  r  ry  r  rz  r  s      rC   rn  zIntegerArrayIndexer.loop_tail  sb    ,,,,W-4\\$..-IK
j$..1t}}%,rE   Nr  rp  rE   rC   r  r    s*    ?3 , *-rE   r  c                   :    e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
y	)
BooleanArrayIndexerz>
    Compute indices from an array of boolean predicates.
    c                     || _         || _        || _        || _        |j                  dk(  sJ | j                   j                  t        j                        | _        t        | j                  d      | _
        y NrG   r   )r}   r=   r   r   rp   r   r   r   ru  r   r   )rY   r}   r=   r   r   s        rC   rv  zBooleanArrayIndexer.__init__)  sZ    
zzQ||225::>T\\1-	rE   c                    | j                   }t        j                  || j                  j                        d   | _        t        j                  || j                        | _        t        j                  || j                        | _	        |j                         | _        |j                         | _        |j                         | _        y r   )r=   r
   r   r   re   r   rW   ru  r  r   rx  ry  bb_tailrz  r{  s     rC   rb  zBooleanArrayIndexer.prepare2  s    ,,(($++2C2CDQG	 ,,WdllC(($,,?
224113002rE   c           	         | j                   }t        j                  || j                        }t        j                  || j
                        5 }|j                  |      }t        | j                  || j                  j                  | j                  | j                  |j                        }|j                  ||j                  ||j                              }|j!                  ||       d d d        |j                  |      S # 1 sw Y   xY wr;  )r=   r
   r   r   	for_ranger   r>   r  r}   r   r{   r   r   r  zextr9   r  )rY   r=   r   loopcpreds         rC   re  zBooleanArrayIndexer.get_size;  s    ,,))'499=w		2 	$dU#A,gtzz'7'7

DKKD Aw||D!&&9:AMM!U#	$ ||E""	$ 	$s   BDDc                 $    | j                         fS r;  re  ra  s    rC   rh  zBooleanArrayIndexer.get_shapeJ      !!rE   c                 <    | j                  d      | j                  fS r   r  ra  s    rC   rj  z$BooleanArrayIndexer.get_index_boundsM  s     Q++rE   c                    | j                   }| j                   j                  | j                  | j                         | j                   j                  | j                  | j                         |j                  | j                         |j                  | j                         |j                  | j                        }|j                  | j                        }|j                  |j                  d|| j                        d      5  |j                  | j                         d d d        t        | j                  || j                  j                   | j                  | j"                  |      }|j                  |j%                  |            5  |j                  | j&                         d d d        t)        j*                  ||      }|j                  || j                         ||fS # 1 sw Y   xY w# 1 sw Y   KxY w)Nr  FrT  )r=   r  r   r  r   r  ry  r  r>   r  r	  r   rz  r  r}   r   r{   r   not_r  r
   r  )rY   r=   r  	cur_countr  
next_counts         rC   rl  zBooleanArrayIndexer.loop_headR  st   ,,499dnn5499djj1t}}%.LL0	LL,	__W00y$))L$)  + 	(NN4;;'	( )LL'4::#3#3TZZ
 __W\\$/0 	)NN4<<(	) ,,Wi@
j$**-)##	( 	(	) 	)s   G'G3'G03G<c                    | j                   }|j                  | j                         |j                  | j                         t	        j
                  ||j                  | j                              }|j                  || j                         |j                  | j                         |j                  | j                         y r;  )r=   r  r  r  r
   r  r>   r  r  ry  rz  r  s      rC   rn  zBooleanArrayIndexer.loop_tailj  s    ,,t||$-,,W-4\\$..-IK
j$..1t}}%,rE   Nr  rp  rE   rC   r  r  $  s*    .3#",
$0-rE   r  c                   :    e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
y	)
SliceIndexerz(
    Compute indices along a slice.
    c                     || _         || _        || _        || _        || _        || _        || _        | j                   j                  t        j                        | _
        t        | j                  d      | _        y r   )r}   r=   r   r   rt  r   r,  r   r   r   ru  r   r   )rY   r}   r=   r   r   rt  r   r,  s           rC   rv  zSliceIndexer.__init__z  s_    


||225::>T\\1-	rE   c                    | j                   }|j                  | j                  j                  | j                        | _        t        j                  | j                  || j                  | j                         t        j                  || j                  | j
                         t        j                  || j                  j                        | _        t        j                   || j"                        | _        t        j                   || j"                        | _        |j)                         | _        |j)                         | _        y r;  )r=   rN  r   re   rt  dim_sizer.   r  r}   r   r,  r  r
   
is_neg_intstepis_step_negativerW   ru  r   r   rx  ry  rz  r{  s     rC   rb  zSliceIndexer.prepare  s    ,,--dhhnndhhG##DLL'4::$(JJ	0'4::t}}= ' 2 27DJJOO L(($,,?
(($,,?
224002rE   c                 V    t        j                  | j                  | j                        S r;  )r.   r   r=   r,  ra  s    rC   re  zSliceIndexer.get_size  s    ''djjAArE   c                 $    | j                         fS r;  r  ra  s    rC   rh  zSliceIndexer.get_shape  r  rE   c                 d    t        j                  | j                  | j                        \  }}||fS r;  )r.   get_slice_boundsr=   r,  )rY   loweruppers      rC   rj  zSliceIndexer.get_index_bounds  s*    //djjIue|rE   c           	      (   | j                   }| j                   j                  | j                  j                  | j                         | j                   j                  | j
                  | j                         |j                  | j                         |j                  | j                         |j                  | j                        }|j                  | j                        }|j                  | j                  |j                  d|| j                  j                        |j                  d|| j                  j                              }|j                  |d      5  |j                  | j                          d d d        ||fS # 1 sw Y   ||fS xY w)Nz<=r  FrT  )r=   r  r,  r  r   r   r   r  ry  r  r>   selectr  r	  stopr  rz  )rY   r=   r  r  is_finisheds        rC   rl  zSliceIndexer.loop_head  s*   ,,4::++TZZ8499djj1t}}%.LL,	LL,	nnT%:%:%,%8%8y9=&J%,%8%8y9=&JK
 __[_7 	(NN4;;'	()##	()##s   FFc                    | j                   }|j                  |j                  | j                        | j                  j
                  dg      }|j                  || j                         t        j                  ||j                  | j                              }|j                  || j                         |j                  | j                         |j                  | j                         y )Nr   r   )r=   r  r>   r   r,  r  r  r
   r  r   r  ry  r  rz  )rY   r=   r  r  s       rC   rn  zSliceIndexer.loop_tail  s    ,,[[djj!94::??(-w ! 0
j$**-,,Wgll4::6NO
j$**-t}}%,rE   Nr  rp  rE   rC   r  r  u  s+    	.3B"$$-rE   r  c                   4    e Zd ZdZd Zd Zd Zd Zd Zd Z	y)	FancyIndexerz4
    Perform fancy indexing on the given array.
    c           
      :   || _         || _        || _        t        j                  ||j
                  |j                        | _        t        j                  ||j                  |j                        | _        | j                   j                  t        j                        | _        g | _        g }t        |D cg c]  }t        |      s| c}      }	d}
d}t!        ||      D ]  \  }}|t        j"                  u rY|j                  t        |      z
  dz   |	z   }t%        |      D ],  }t'        |||||
      }|j)                  |       |
dz  }
|dz  }. rt+        |t        j,                        r7|j/                  |||      }t1        |||||
||      }|j)                  |       nDt+        |t        j2                        r;t5        ||||| j                  |
         }t7        |||      }|j)                  |       nt+        |t        j8                        r t;        |      |||      }t+        |j<                  t        j2                        rt?        ||||| j                  |
         }n5t+        |j<                  t        j@                        rtC        ||||      }nJ |j)                  |       n:t        |      r!| j                  j)                  |       |
dz  }
ntE        d|      |
dz  }
|dz  } |
|j                  k  sJ |
|j                  f       |
|j                  k  r5t'        |||||
      }|j)                  |       |
dz  }
|
|j                  k  r5t        |      |j                  k(  sJ t        |      |j                  f       || _#        y c c}w )Nr   rG   r  )$r}   r=   r   r
   r   re   rp   r   r   r   r   r   ru  newaxesr   r   r   r  r8   rr  ri   r   r  r   r  r   r   r  r   rx   r{   r  Booleanr  AssertionErrorindexers)rY   r}   r=   r   r   r   r   r  r   r(  r)  new_axr*  r   r+  rm   indexerr,  r   r   s                       rC   rv  zFancyIndexer.__init__  s%   
**7CIIuzzJ++GS[[%**M||225::>+J3S9I3JK"7K8 (	OHe&!JJW59KG	y)  A+GWeS"MGOOG,!GBaKF	 
  %1++GUHE&wR',e5(E5==1'%(,B9('3?(E5;;/*E*7GXFekk5==91'72726++b/CG  U]];1'727AG 1(U###F+a$E%KLL!GBaKFQ(	V UZZ1"ejj!115::o#GWeS"EGOOG$!GB 5::o
 8}

*GS]EJJ,GG* m Ks   6NNc                 \   | j                   D ]  }|j                           | j                  j                  t        j
                  d      }| j                   D cg c]  }|j                          }}| j                  D ]  }|j                  ||f        t        |d      | _
        y c c}w )NrG   rp  )r  rb  r}   r   r   r   rh  r  insertsumindexers_shape)rY   rm   r$  	res_shapes       rC   rb  zFancyIndexer.prepare  s     	AIIK	 ll''

A6 -1MM:qQ[[]:	:  	(AQ'	( ")R0 ;s   B)c                     | j                   S )z?
        Get the resulting data shape as Python tuple.
        )r  ra  s    rC   rh  zFancyIndexer.get_shape  s     """rE   c           	          t        |      | j                  j                  k(  sJ | j                  }t        j
                  }| j                  d      }| j                  d      }|}|}t        | j                  | j                  |      D ]  \  }	}
}|j                  ||j                  d|
|            }|	j                         \  }}|j                  ||      }|j                  ||j                  ||            }|j                  d||      }|j!                  ||j#                  |||            }|j!                  ||j#                  |||            } |j!                  ||      }|j#                  |||      }|j#                  |||      }||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   rG   ==r  )r   r   rp   r=   r
   	false_bitru  r   r  r  or_icmp_unsignedrj  r   subr	  r  r  )rY   r   r   r=   is_emptyr   r$  r  r  r  re   stridelower_indexupper_indexlower_offsetupper_offsetis_downwardss                    rC   get_offset_boundszFancyIndexer.get_offset_bounds  s    7|tzz...,,$$||All1o&)$--9L9L*1'3 	>"GUF{{8#*#8#8ud#KMH (/'?'?'A$K";;v{;L";;vw{{;/LML"..sFDALKK '|/;/;!=>E KK '|/;/;!=>E	>& E8,xu5xu5e|rE   c                 B    t        d | j                  D         \  }}||fS )Nc              3   <   K   | ]  }|j                           y wr;  )rl  )r=  rm   s     rC   r?  z+FancyIndexer.begin_loops.<locals>.<genexpr>A  s     E!Es   )r   r  )rY   r   countss      rC   begin_loopszFancyIndexer.begin_loops@  s$    Et}}EFrE   c                 X    t        | j                        D ]  }|j                           y r;  )reversedr  rn  )rY   rm   s     rC   	end_loopszFancyIndexer.end_loopsD  s#    $--( 	AKKM	rE   N)
rq   rr   rs   ro  rv  rb  rh  r  r  r  rp  rE   rC   r  r    s(    @!D1&#$LrE   r  c                 b   t        j                  ||j                        }t        j                  ||j                        }	|j                  }
t        | |||||      }|j                          |j                  }|j                         }t        | |||      }|j                  }t        j                  || j                  t        j                  d            }|j                         \  }}t        j                  | ||
||	|j                   |d| j"                  	      }t%        | |||      }|j'                  |      }|j)                  ||g      }t+        | ||||       t        j,                  ||      }|j/                  ||       |j1                          t3        | |||j5                               S )Nr   Fr  )r
   r   re   r   r   r  rb  r   rh  _empty_nd_implr   r   r   r   r  get_item_pointer2layoutr4  r   r>   gepr   r  r  r  r"   r   )r}   r=   r[   r   r   r   r   r   r   r   r   r  out_ty
out_shapesr   out_dataout_idx_rk   r   curnext_idxs                         rC   rB  rB  I  s    !!'3995F""7CKK8G88D7GUC&1GOO __F""$J
'6:
>CxxH''(/(<(<UZZ(KMG $$&JGQ 
#
#GWdFG$)LL'e070J0JLC GWeS
1C ,,w
C
++h
&Cwc2&&w4HMM(G$GWfcmmoFFrE   c           
      "   |j                   \  }}|\  }} t        |      | ||      }|j                  dk(  rFt        | |||      \  }}t	        | ||j
                  |||f|f      }t        | ||j
                  |      S t        | ||||||f|f      S )z3
    Advanced or basic indexing with an array.
    r   )r   rx   rp   r   r5  r   r!   rB  r7  s	            rC   fancy_getitem_arrayr  t  s    
 88LE5HC
*U
GWc
2CzzQ$WgucB
s$Wgs%*C%C6C '3??CHH WgsD"C%C6; 	;rE   c           	         |j                   }|j                  d      }|j                  d      }|j                  dv r"|}	|j                  ||j                        }
|	|
fS |}	|}
t        |j                        D ]  }|j                  ||   |j                  ||   |            }|j                  d||      }|j                  ||j                  |
|      |
      }
|j                  ||	|j                  |	|            }	 |j                  |
|      }
|j                  d|j                  |      }|j                  |||
      }
|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   rG   CFr  r  )r   r9   r  r   r   r8   rp   r  r	  r  r  )r}   r=   arrtyarrr   r   r   r   r$  r  r  rm   max_axis_offset
is_upwardsr  s                  rC   offset_bounds_from_stridesr    sX    ||H==D
))A,C||t Hcjj10 %<+ uzz" 	OA &kk'!**1++fQi*EGO ,,T?DIJNN:#*;;uo#FOENN:#('++e_*MOE	O E8,&&tSZZ>xu5xu5%<rE   c                     |j                  ||j                        }|j                  ||      }|j                  ||      }||fS )z
    Given [lower, upper) byte offsets and a base data pointer,
    compute the memory pointer bounds as pointer-sized integers.
    )ptrtointr9   r  )r}   r=   r  r  r   data_ptr_as_intr  ends           rC   compute_memory_extentsr
    sD    
 &&tUZZ8OKK/E
++ou
-C#:rE   c                 F    t        | |||||      \  }}t        | ||||      S )zr
    Compute a half-open range [start, end) of pointer-sized integers
    which fully contain the array data.
    )r  r
  )	r}   r=   r  r  r   r   r   r  r  s	            rC   get_array_memory_extentsr    s2     .gws.4g?LE5!'7E5$GGrE   c                 n    |j                  |j                  d||      |j                  d||            }|S )z[
    Whether two memory extents [a_start, a_end) and [b_start, b_end)
    may overlap.
    r  )and_r  )r}   r=   a_starta_endb_startb_endmay_overlaps          rC   extents_may_overlapr    s>     ,,c7E2c7E2K rE   c                 2    j                   dt        j                        d j                  d      5  j	                  |j
                  |j                        } j                  j                  |      }	|	j                   j                  |	      }	j                  |	        j                  t        j                        }
t        j                  |
      5 }t        j                   j                   |      }t        j                   |	|      }j                  j#                  |      |       d d d        d d d         fd} fd}||fS # 1 sw Y   .xY w# 1 sw Y   2xY w)Nr   FrT  c                    t        j                  
      }j                  d      5 \  }}|5  j                  t        j                  j                        	| d      |       d d d        |5  j                  t        j                  j                  | d      |       d d d        d d d        t        j                  |            S # 1 sw Y   pxY w# 1 sw Y   :xY w# 1 sw Y   >xY w)NFrT  r  )r
   rW   if_elser  r  r>   r  r   )source_indicessrc_ptrif_copy	otherwiser=   r}   	copy_datacopy_layoutcopy_shapescopy_stridesptrtysrc_data
src_shapessrc_stridessrctyuse_copys       rC   src_getitemz&maybe_copy_source.<locals>.src_getitem  s   %%gu5__Xe_4 	8L) --gw.5ll9.E.9<.9>9>	@
   --gw.8+.3llN9>@ 	  '5',,w2GHH  	 	s:   C5=C.
C588C)0C5C&	"C5)C2	.C55C>c                      j                  d      5  j                        } j                  |       } j                  j	                  |        d d d        y # 1 sw Y   y xY w)NFrT  )r  r>   bitcastr   free)r   r=   r}   r  r&  	voidptrtys    rC   src_cleanupz&maybe_copy_source.<locals>.src_cleanup  sZ    __Xe_4 	,<<	*D??43DKKWd+	, 	, 	,s   A AA')r9   r
   r   r  r   r   r   r   allocater)  r  r   r   r   	loop_nestr  r  r>   )r}   r=   r&  r%  srcr#  r$  r"  	allocsizer   r   r   r  dest_ptrr'  r,  r  r  r  r   r!  r+  s   ```` ```        @@@@@@rC   maybe_copy_sourcer2    sn   MMEK))'8<IKL	%	0 ; KKcjj9	{{##GY7II	tU+dI& ''

3w
F; 	;w//(0:K05gGG 00'41<l1<gGH MM',,w/:	;;,I I(, , ##I	; 	;; ;s&   	B)F2A"FFF
	FFc                    | j                  t        j                  d      }| j                  t        j                  d      }t        |      t        |      kD  r-t        |      t        |      z
  }|g|z  |z   }|g|z  |z   }||fS t        |      t        |      k  rt        |      t        |      z
  }|d| D cg c]  }|j	                  d||       }	}t        j                  |j                  |	t        j                        }
|j                  |j                  |
      d      5  d}| j                  j                  |t        |f       ddd       ||d }||d }||fS c c}w # 1 sw Y   xY w)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   rG   Nr  FrT  z,cannot broadcast source array for assignment)r   r   r   r   r  	functoolsreducer  r
   true_bitr  r  rV  rW  r   )r}   r=   r   r   target_shaper   r$  nd_diffr-  
dim_is_oneacceptedr   s               rC   _bc_adjust_dimensionr;    sy    Q/D


u{{A
.C <3v;&l#c&k16)&7"W," 7? 
\	S[	(f+L 11 &x 02 ++D"c: 2
 2##GLL*$+$4$46 __W\\(3E_B 	K@C--gzC6J	K !'(#7?2
	K 	Ks   :E"'%E''E0c           
         g }g }| j                  t        j                  d      }| j                  t        j                  d      }t        ||      D 	
cg c]  \  }	}
|j	                  d|	|
       }}	}
|D 
cg c]  }
|j	                  d|
|       }}
t        ||      D cg c]  \  }}|j                  ||       }}}t        |||      D 	
cg c]  \  }}	}
|j                  ||	|
       }}	}}
t        ||      D 
cg c]  \  }}
|j                  |||
       }}}
||fS c c}
}	w c c}
w c c}}w c c}
}	}w c c}
}w )z
    Broadcast shapes and strides to target_shape given that their ndim already
    matches.  For each location where the shape is 1 and does not match the
    dim for target, it is set to the value at the target and the stride is
    set to zero.
    r   rG   rS  r  )r   r   r   r   r	  r  r  )r}   r=   r   r   r7  	bc_shapes
bc_stridesr   r$  taroldmismatch
src_is_onexypredsps                    rC   _bc_adjust_shape_stridesrG  7  sX    IJQ/D


u{{A
.C !$L& 9;C ##D#s3 ;H ;AGH#'%%dC5HJH,/*,EFDAqW\\!QFEF$'|V$DF F QS 3, FI F !$E7 35a ..D#. 5J 5j  ;HFF5s   D(8D.#D3D9E c           	         t        j                  ||j                        }t        j                  ||j                        }t	        | ||||      \  }}t        | ||||      \  }}|j                  t        |      d      } t        |      | |      }t        ||j                  t        j                  ||      t        j                  ||      |j                  |j                  |j                         ||fS )zX
    Broadcast the given array to the target_shape.
    Returns (array_type, array)
    Arp   r  r1  )r
   r   re   r   r;  rG  copyr   rx   r   r   rj   r   r   r   )	r}   r=   arrtyper  r7  r   r   new_arrtypenew_arrs	            rC   _broadcast_to_shaperO  N  s     !!'3995F""7CKK8G*7GVW+79OFG.w/6FOFG,,C$5c,BK%j%gw7G7 ++GV<"--gw?LL;;**& rE   c                 ^    |j                  |j                  dd      } |||      }d }||fS )NrI  T)rp   r  readonlyc                 n   |\  }}|j                   d   } t        |      | ||      }t        j                  ||      }t	        | ||||      \  }}t        |dt        | j                  |j                  j                  d            d              |j                         }	t        | ||j                  |	      S )Nr   r   )r   rx   r
   r   rO  r   r   r   r   r   r   r!   r   )
r}   r=   r[   r   r/  shape_r%  r  destr   s
             rC   codegenz$_numpy_broadcast_to.<locals>.codegenm  s    Vj#6%%gv6%gwsFL4 	h&&t'?'?'IJ! 	 nn '3??CHHrE   )rK  r   )	typingctxr   re   retr[   rU  s         rC   _numpy_broadcast_torX  h  s8    
**%++cD*
AC
eU
CI <rE   c                 D    |j                  d      } ||      }d }||fS )NTrQ  c                     |\  }|j                   d   } t        |      | ||      }t        j                  |j                  j
                        |_        |j                         }t        | ||j                  |      S r   )	r   rx   r
   get_null_valuer   r9   r   r!   r   )r}   r=   r[   r   r/  r%  rT  r   s           rC   rU  z#get_readonly_array.<locals>.codegen  sh     z% '37,,T[[-=-=>nn '3??CHHrE   )rK  )rV  r  rW  r[   rU  s        rC   get_readonly_arrayr]    s/     ((D(
!C
c(CI <rE   c                    | j                   }t        |      }t        |      }||kD  rt        d      |D ]  }|dk  s	t        d       d}||z
  }||k  r1||   }||   }	||	k(  s|dk(  r|dz  }|dz  }nt        d      ||k  r0y y )NzDinput operand has more dimensions than allowed by the axis remappingr   z4all elements of broadcast shape must be non-negativerG   z=operands could not be broadcast together with remapped shapes)re   r   r   )
r   
dest_shape	src_shapesrc_ndim	dest_ndimr   	src_index
dest_indexsrc_dimdest_dims
             rC   _can_broadcastrg    s    I9~HJI) 1 2 	2 -!8 , - -- IX%J
h
I&j) h'Q,NI!OJ 4 5 5 h
rE   c                 \    t        j                  |       } t        | |       t        | |      S r;  )npasarrayrg  rX  r   re   s     rC   _default_broadcast_to_implrl    s'    JJuE5% ue,,rE   c           	      d   t        |       st        j                  d      t        |t        j
                        rd }|S t        |t        j                        rAt        |j                  t        j
                        sd}t        j                  |      t        S t        |t        j                        ra|j                  dkD  rRt        |D cg c]  }t        |t        j                         c}      sd| d}t        j                  |      t        S t        |t        j                        rc|j                  dk(  rTt        | t        j                        xr | j                  dk(  }t        |       s|rd }|S d}t        j                  |      d	|z  }t        j                  |      c c}w )
Nz-The first argument "array" must be array-likec                 0    t        j                  | |f      S r;  )ri  broadcast_tork  s     rC   r   z numpy_broadcast_to.<locals>.impl  s    ??55(33rE   z7The second argument "shape" must be a tuple of integersr   "z," object cannot be interpreted as an integerc                 B    t        j                  |       } t        |       S r;  )ri  rj  r]  rk  s     rC   r   z numpy_broadcast_to.<locals>.impl  s     

5))%00rE   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   UniTupler{   rl  Tupler   allIntegerLiteralr   rp   r   )r   re   r   r   typis_scalar_arrays         rC   numpy_broadcast_torx    sa   E"   "1 2 	2 %'	4	E5>>	*%++u}}5KC$$S))))	E5;;	'EKK!OUKcJsE$8$89KLeWHIC$$S))))	E5;;	'EKK1,<$UEKK8LUZZ1_% O1
 K DC$$S))   %%+ Ls   !F-c                     t        t        |            D ]O  }|t        |      z
  |z   }||   }|dk  rt        d      |dk(  r/| |   dk(  r|| |<   =| |   |k7  sFt        d       y )Nr   #negative dimensions are not allowedrG   z=shape mismatch: objects cannot be broadcast to a single shape)r8   r   r   )rmre   rm   r   tmps         rC   numpy_broadcast_shapes_listr~    s    3u: 3E
NQAh7BCC!8Q419AaDqTS[ 2 3 33rE   c                  |  	 t        |       D ]  \  }}t        |t        j                        }t        |t        j                        xr$ t        |j
                  t        j                        }t        |t        j                        xr t        |j                        dk(  }|r|r|rd| d| }t        j                  |       d| D ]Y  }t        |t        j                        rt        d      *t        |t        j                        sEt        t        |            [ dk(  rd S dz  		fd}|S )Nr   z	Argument z* must be either an int or tuple[int]. Got rG   c                       yr  rp  r   s    rC   <lambda>z+ol_numpy_broadcast_shapes.<locals>.<lambda>	      rE   rG   c                     dgz  }}t        |       D ]M  }t        |t              rt        |      dkD  rt	        ||       /t        |t
              s@t	        ||f       O t        |      D ]  \  }}t        |||      } |S r  )r   r   r   r   r~  r   	enumerater/   )r   r{  rD  argr   elemr|  tup_inits         rC   r   z'ol_numpy_broadcast_shapes.<locals>.impl  s    aAC%d+ >c5)c#hl/1c:S)/1sf=	>
 'q\ 4	T#Cd34JrE   )r  r   r   r   rr  r{   rs  r   r	   r   maxrG  )
r   r   r  is_intis_int_tupleis_empty_tupler   r   r|  r  s
           @@rC   ol_numpy_broadcast_shapesr    s    dO *SC/!#u~~6 1syy%--0 	#C5M#cii.A:M,.se $ C$$S))* 	
A !c5==)Aq	AU__-As3x A	! 	Av!8	 rE   c                     t        |       D ])  \  }}t        |      rt        j                  d| d       d }d }| D ]]  }t	        |t
        j                  t
        j                  f      r|j                  }n|}||}A||k7  sGt        j                  d|         dt        |       D ]  \  }}t	        |t
        j                        rt        |j                        7t	        |t
        j                  t
        j                  t
        j                  f      rt        d      }t        j                  d|        dz  fd}|S )	Nz
Argument "z" must be array-likezTMismatch of argument types. Numba cannot broadcast arrays with different types. Got r   rG   zUnhandled type r   c                  `   dgz  }t        |       D ],  }t        |t        j                  |      j                         . }t              D ]  }t        ||||         } g }t        |       D ]:  }|j                  t        j                  t        j                  |      |             < |S r  )	r   r~  ri  rj  re   r8   r/   ri   ro  )r   re   r   rD  rm   outsr|  r  s         rC   r   z$numpy_broadcast_arrays.<locals>.impl?  s    
 a#D) 	KE'q"**U2C2I2IJ	K q 	2AQa1C	2 #D) 	AEKK

5(93?@	ArE   )r  r   r	   r   r   r   r   rG  r{   ArrayCompatibler  rp   Numberr  )r   r   r  unified_dtypedtr   r|  r  s         @@rC   numpy_broadcast_arraysr    sQ    dO 6S$$$z# 75 &5 6 66
 M	B 4cEKK9:BB Mb $$ &,,06&3 4 44 	
AdO >Sc5001Asxx AellEMM5??KLAq	A$$se%<==> axH( KrE   c                     t         )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_shapes     rC   raise_with_shape_contextr  V  
     rE   generic)targetc                     t        | t        j                        r_t        |t        j                        rD| j                  |j                  k(  r*t        | j                  t        j                        rd }|S y y y y )Nc                     t        d      )Nz0cannot assign slice from input of different sizer   r  s     rC   r   z1ol_raise_with_shape_context_generic.<locals>.implf  s    OPPrE   r   r   rr  r{   r   r#  r  r   s      rC   #ol_raise_with_shape_context_genericr  ]  sg     	:u~~.;/K---z''7	Q	 8 	. 	0 	/rE   CPUc                     t        | t        j                        r_t        |t        j                        rD| j                  |j                  k(  r*t        | j                  t        j                        rd }|S y y y y )Nc           	      L   t        |       dk(  r
d| d    d}n,ddj                  | D cg c]  }t        |       c}       d}t        |      dk(  r
d|d    d}n,ddj                  |D cg c]  }t        |       c}       d}d| d| }t        |      c c}w c c}w )	NrG   (r   z,), )zcannot assign slice of shape z from input of shape )r   joinstrr   )r#  r  	shape_strrC  	index_strr   s         rC   r   z-ol_raise_with_shape_context_cpu.<locals>.implr  s    :!#
1b1			:*Fa3q6*F GHJ	;1$A/r2			;*Ga3q6*G HIK	29+ >%;(CS/! +G +Hs   B
-B!
r  r  s      rC   ol_raise_with_shape_context_cpur  k  sf    :u~~.;/K---z''7	"  8 	. 	0 	/rE   c                 ^   ()* |j                   \  }}*|\  }}( t        |       |      }t        j                  |j                        }	t        j                  |j
                        }
|j                  }t         ||||      }|j                          d }t        *t        j                        r*j                  )|j                         } t        *       (      (t         *(|      \  *(t        j                  (j                        }t        j                  (j
                        }(j                  }t        j                  }t!        |      t!        |      k(  sJ t#        ||      D ](  \  }}j%                  |j'                  d||            }* j)                  |d      5   | ||       ddd       t+         *(|||      \  }}|j-                  |
|j.                        \  }}t1         |||      \  }}t3         ||||      }t5         |*(|||      \  }}nt        *t        j6                        r*j                  )|j                         }t!        |      dk(  sJ  j9                  t         t;        t        j<                  *            } |(f      }j'                  d|d   |      }j)                  |d      5   | |f|d   f       ddd        ()*fd}d	 }n
*)(fd
}d } j?                  t        j@                  d      } |jC                         \  }!}"tE        |"      }"|jF                  D ]  }#|"jI                  |#|         |"D $cg c]  }$|$|$	 }%}$ ||%      }& jK                  |&)|j                        }&t        jL                   ||	|
|jN                  |!d jP                  	      }'tS         ||&|'       |jU                           |         jW                         S # 1 sw Y   MxY w# 1 sw Y   /xY wc c}$w )z
    Implement slice assignment for arrays.  This implementation works for
    basic as well as fancy indexing, since there's no functional difference
    between the two for indexed assignment.
    c           	         | j                   j                  t              }t        j                  t        j
                  t        |            t        j                  t        j
                  t        |            f}|j                  | j                   |i       }| j                  ||      } ||| j                  ||j                  d   |      | j                  ||j                  d   |      f       y Nr   rG   )typing_contextresolve_value_typer  r   rr  int64r   get_call_typerQ   
make_tupler   )r}   r=   r#  r  fntyargtys	raise_sigfuncs           rC   raise_shape_mismatch_errorz2fancy_setslice.<locals>.raise_shape_mismatch_error  s     %%88$&..c*o>..c+.>?A&&w'='=vrJ	##D)4Ww))'9>>!3D*46))'9>>!3D*578 	9rE   rS  FrT  NrG   r   c                     | \  }j                  t        j                  t        t        j
                              } ||f      S r;  )rQ   operatorgetitemr%   r   r   )r  r   getitem_implr=   r}   r/  	src_dtyper%  s      rC   r'  z#fancy_setslice.<locals>.src_getitem  sF    !DC"//  )UEJJ7L  #s44rE   c                       y r;  rp  rp  rE   rC   r,  z#fancy_setslice.<locals>.src_cleanup      rE   c                     S r;  rp  )r  r/  s    rC   r'  z#fancy_setslice.<locals>.src_getitem  s    JrE   c                       y r;  rp  rp  rE   rC   r,  z#fancy_setslice.<locals>.src_cleanup  r  rE   r  ),r   rx   r
   r   re   r   r   r  rb  r   r   r   r{   rh  rO  r  r   r   r  r	  r  r  r  r   r
  r  r2  SequencerQ   r%   r   r   r   r  r   r  r  r   r  r  r4  r   r  r\  )+r}   r=   r[   r   r   r   r   r  r   dest_shapesdest_strides	dest_datar  r  r  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  rm   r  r  r   r1  r/  r  r%  s+   ``                                      @@@rC   rI  rI    s0    hhOE1eKCC
*U
GWc
2C&&w		:K''=LI7GUC&1GOO9 %&KK	'')j#6('5#)46
s))'399=
**7CKK@88 '';3z?222
K0 	GDAq!++k&-&9&9$1&EGK	G __[_7 	4&w'24	4
 6gw69:6A8M	7 ")!:!:<;><<"I
J5gw6@*6? A
H 'wG'18= $5Wgx5:C5@($L [ 
E5>>	*KK	 '');1$$$''Yuzz5-IJ7SF+))$AH__[_7 	:&w'(3A'8:	:	5 	5	 			 Q/D"..0L& &\F
 __ a "(9A1=a9N9
n
%C ,,wY
<C (('9)4l).|495<5O5O	QH
 wX6M""$$A	4 	4B	: 	:V :s$   9PP4P*<P*PP'c           
         |j                   d   }|j                   dd  }|d   }|dd  }t        ||      D 	cg c]'  \  }}	| j                  ||	|t        j                        ) }}}	t        j                  |||d   j                        }
t        j                  t        j                  t        |            }t        j                  |j                  ||      }||
f}||fS c c}	}w )Nr   rG   r{   r   )r   r   r   r   r   r
   rj   r9   rr  r   r   r%   r   )r}   r=   r[   r   r   dimtysr   rl   r>  r   re   shapetynew_signew_argss                 rC   vararg_to_tupler    s    HHQKEXXab\F
q'C8D vt,.C LL#r5::6 .D . wd1gll;Enn5::SY?Gsw?GEzHH.s   ,C"zarray.transposec                 >    t        | ||j                  d   |d         S r   )array_Tr   r}   r=   r[   r   s       rC   array_transposer  /  s    7GSXXa[$q'::rE   c                     t        |       t        t        |             k7  rt        d      t        |      }| D ]   }||k\  st        |      |kD  st        d       ||    |d d  ||    |d d  y )Nzrepeated axis in transposez2axis is out of bounds for array of given dimension)r   r   r   abs)r   re   r   rt  rC  s        rC   permute_arraysr  4  sy    
4yCD	N"566
e*C 08s1v| / 0 00
 T{E!HGAJrE   c           
      v   |j                   d   } t        |      | ||d         }|j                   d   |d   }}|j                  |j                  }	}| j	                  t
        j                        }
t        j                  |
|      }||j                  |j                  g}|D cg c]  }t        j                  ||       }}t        ||      D ]  \  }}|j                  ||        t        j                  |	dd      }| j!                  t
        j                  | j#                  |
            }|D cg c]  } t        |      | |       }}t        ||      D ]T  \  }}t%        ||j'                  ||
j)                               | j!                  t
        j                  |      g|g|d        V | j+                  |t,        t/        j0                  t
        j2                  |||      |D cg c]  }|j5                          c}        t        |j6                        | |      }t%        ||j8                  |j;                  |d         |j;                  |d         |j<                  |j>                  |j@                         |j5                         }tC        | ||j6                  |      S c c}w c c}w c c}w )Nr   rG   r   r{   rp   r  r   re   r   r   r   rZ  r1  )"r   rx   r   r{   r   r   r   r   	ArrayTypere   r   r
   rW   r   r  r   r   r|   r   r)  
as_pointercompile_internalr  r   r%   voidr   r   r   r>   r   r   r   r!   )r}   r=   r[   r   r   r   axistyr   num_axisr{   ru  ll_ary_sizearysr  ll_arysr/  dst	np_ary_tynp_itemsizenp_arysnp_aryll_aryarW  r   s                            rC   array_transpose_tupler  C  sg   HHQKE
*U
GWd1g
6C88A;QDFllFLLeH$$UZZ0G,,w1K #))S[[)DBFGQw""7K8GGG g&  Sc3  %a<I&&uzz'.'='=g'FHK AEE1$z)$Wg6EGE gw/ %v#OOFG4F4F4HI%225::xHI +} +#	%% Wn#--ejj.7IO5<=akkm=? &*S__
%gw
7C3 gaj1"<<
3LL;;**& --/CWgsDDO H F  >s   $J,4J1,J6c                 @    t        | |||      \  }}t        | |||      S r;  )r  r  r}   r=   r[   r   r  r  s         rC   array_transpose_varargr  z  s(    '#tDGX '7HEErE   c                 |    t        | t        j                        rt        j                  d      |dd}|S dd}|S )Nz#np.transpose does not accept tuplesc                 "    | j                         S r;  	transposer  axess     rC   np_transpose_implz*numpy_transpose.<locals>.np_transpose_impl  s    ;;= rE   c                 $    | j                  |      S r;  r  r  s     rC   r  z*numpy_transpose.<locals>.np_transpose_impl  s    ;;t$$rE   r;  )r   r   rG  r	   r   )r  r  r  s      rC   numpy_transposer    sA    !U__%  !FGG|	! 	% rE   Tc                 4   |j                   dk  r|}n t        |      | ||      } t        |      | |      }t        j                  ||j                  |j                         }t        j                  ||j
                  |j                         }t        ||j                  t        j                  ||d d d         t        j                  ||d d d         |j                  |j                  |j                         |j                         }t        | |||      S )NrG   r1  )rp   rx   r
   r   re   r   r   r   rj   r   r   r   r   r!   )	r}   r=   rv  r  r   r   rW  r   r   s	            rC   r  r    s    
xx1}jogw6jogw/%%gsyy#((C&&wSXXFsHH$//"F&11'74R4=I #"{{!jj	* mmoWgsC88rE   c                 4   t        | t        j                        st        j                  d      t        |t        j                        st        j                  d      t        |t
        t        j                  f      st        j                  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 integerc                 \    t        j                  | ||      }t        j                  d|      S )Ng      $@)ri  linspacepower)r  r  numrD  s       rC   r   znumpy_logspace.<locals>.impl  s%    KKtS)xxa  rE   2   )r   r   r  r	   r   r   r   )r  r  r	  r   s       rC   numpy_logspacer    ss    eU\\*  !NOOdELL)  !NOOcC/0  !NOO! KrE   c                    t        | t        j                        sd}t        j                  |      t        |t        j                        sd}t        j                  |      t        |t
        t        j                  f      sd}t        j                  |      t        d | |fD              r:t        t        j                  t        |       t        |      d             dfd	}|S 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              3   P   K   | ]  }t        |t        j                           y wr;  r   r   Complexr=  r  s     rC   r?  z"numpy_geomspace.<locals>.<genexpr>       
Cc:c5==)
Cr@  c                 F   | dk(  s|dk(  rt        d       	|       }  	|      }t        dk  rz| j                  dk(  |j                  dk(  z  }t        j                  |       dk(  t        j                  |      dk(  z  }d}|r| j
                  } |j
                  }d}|r)|  } | }| }nt        j                  |       }| |z  } ||z  }t        j                  |       }t        j                  |      }t        j                  |||      }|dkD  r| |d<   |dkD  r||d<   ||z  S )Nr   &Geometric sequence cannot include zerorY  r  rG   y              ?)r   r   realri  signimaglog10logspace)
r  r  r	  both_imaginaryboth_negativeout_signlogstartlogstopr  result_dtypes
            rC   r   znumpy_geomspace.<locals>.impl  s'   zTQY !IJJ 'E%Dv%"'**/dii1n!E!#2!5"''$-2:M N!!JJE99D!H "FE 5D (yH775>! xxHhhtnG[[7C8F Qw!q	7!%F2Jf$$rE   c                 \   | dk(  s|dk(  rt        d      t        j                  |       dk(  t        j                  |      dk(  z  }d}|r	|  } | }| }t        j                  |       }t        j                  |      }t        j                  |||      }|dkD  r| |d<   |dkD  r||d<   ||z  S )Nr   r  r  rG   )r   ri  r  r  r  )r  r  r	  r  r  r  r  r  s           rC   r   znumpy_geomspace.<locals>.impl  s    zTQY !IJJWWU^r1bggdmr6IJMHu$9xxHhhtnG[[7C8F Qw!q	7!%F2Jf$$rE   r
  )r   r   r  r	   r   r   r   rA  r   ri  result_typer   )r  r  r	  r   r   r   s        @rC   numpy_geomspacer#    s    eU\\*5  %%dELL)4  %%cC/05  %%

CeT]
CC!"..%19$#G H 	%p K+	%* KrE   c                    t        |t        t        j                  f      st	        j
                  d      t        | t        j                        st	        j
                  d      | j                  dk  rt	        j                  d      dd}|S )Nz*The second argument "k" must be an integerz'The first argument "m" must be an arrayrZ  Input must be >= 2-d.c                 B   |dz  }|dk(  r| d d  S |dk(  r*t        j                  t        j                  |       dd      S |dk(  r(t        j                  t        j                  |             S |dk(  r*t        j                  t        j                  | dd            S t        )N   r   rG   rZ     )ri  swapaxesfliplrflipudr  )r|  r   s     rC   r   znumpy_rot90.<locals>.impl  s    E6Q4K!V;;ryy|Q22!V99RYYq\**!V99R[[Aq122  rE   r  )	r   r   r   r   r	   r   r   rp   NumbaValueError)r|  r   r   s      rC   numpy_rot90r-     sr     a#u}}-.  !MNNa%  !JKKvvz$$%<==! KrE   c                    | j                  t        j                        }|j                         }| j                  t        j                        }	t        j                  |	||||||||	g      }
t        j                  |j                  |
d      } ||j                        }t        j                  ||j                  d      dd      }t        j                  ||j                  d      dd      } ||      }t        j                  ||dd      }t        j                  ||dd      } |	d      }|j                  ||||||||j                  |g      }|S )a  
    Call into Numba_attempt_nocopy_reshape() for the given array type
    and instance, and the specified new shape.

    Return value is non-zero if successful, and the array pointed to
    by *newstrides* will be filled up with the computed results.
    numba_attempt_nocopy_reshapere   r   r   )r   r   r   r  intcr   FunctionTyper
   get_or_insert_functionr:   rp   rh   rg   callr   )r}   r=   r   r   newndnewshape
newstridesru  ll_intp_starll_intcr  fnndre   r   
is_f_orderr   s                    rC   _attempt_nocopy_reshaper<    sE    $$UZZ0G%%'L$$UZZ0G??7||% D 
	'	'(F
HB 
	B  #*>*>w*GANE""7C,@,@,K#$a)GENE##GXq!<H%%gz1a@JJ
,,rBw!8ZLL*6 7C JrE   c                     d}d}t        |      D ]  \  }}|dk  r|dz  }|}||z  } |dk(  r| |k7  rt        d      y |dk(  r-|dk(  rd}| dk(  }n| |z  }| |z  dk(  }|st        d      ||<   y t        d      )Nr   rG   z)total size of new array must be unchangedzmultiple negative shape values)r  r   )	origsizere   num_neg_value
known_sizer)  r   neg_axinferredoks	            rC   normalize_reshape_valuerD  ?  s    MJ5! Aq5QMF!OJ z!HII " 
!	?HQB:-HJ&!+BHII f 9::rE   zarray.reshapec           	         |j                   d   }|j                  }|j                   d   }|d   }| j                  t        j                        }t        j                  ||j                        }	 t        |      | ||d         }
t        j                  ||	      }|j                  ||       t        j                  |j                  dd      } t        |      | |      }| j                  t        j                  | j                  |            }t!        ||j#                  ||j%                               | j                  t        j                  |j                        g|g|d        |
j&                  }| j)                  |t*        t-        j.                  t        j0                  t        j2                  |      ||j5                         g       |j                  }t        j                  ||	      }t7        | |||
|||      }|j9                  d||j;                  d            }|j=                  |      5  d}| j>                  jA                  |tB        |f       d d d         t        |      | |      }t!        ||
jD                  |jG                  |      |jG                  |      |
jH                  |
jJ                  |
jL                         |j5                         }tO        | ||j                  |      S # 1 sw Y   xY w)	Nr   rG   r   r  r  r  zincompatible shape for arrayr1  )(r   r   r   r   r   r   r  r   rx   r
   rW   r  r   r{   r   r|   r   r)  r  r   r  rD  r   r%   r  r   r   r<  r  r9   r  rV  rW  rR   r   r>   r   r   r   r!   )r}   r=   r[   r   r   rettyr  re   ru  ll_shaper   r5  shape_ary_ty	shape_aryshape_itemsizer   r4  r6  rC  failr   rW  r   s                          rC   array_reshaperL  ]  s   HHQKEOOEhhqkGGE$$UZZ0G||GW]]3H
*U
GWd1g
6C ""7H5HMM%" ;;W]]3GL(
<(':I))%***1*@*@*IKN9'2D2D2FG!..uzz7==IJ*+*! ::D W&=#--ejj.3kk<I"I$7$7$9:< MME$$Wh7J	 '5#u!):
7B  r2771:6D		 P,))'3FOP *U
GW
-C3 h/"<<
3LL;;**& --/CWgsDDP Ps   4%K33K<c                 @    t        | |||      \  }}t        | |||      S r;  )r  rL  r  s         rC   array_reshape_varargrN    s(    '#tDGX'7H==rE   )rZ  rG   c                     d }|S )Nc                 $    | j                  |      S r;  reshape)r  r5  s     rC   np_reshape_implz#np_reshape.<locals>.np_reshape_impl  s    99X&&rE   rp  )r  r5  rS  s      rC   
np_reshaperT    s    	'rE   c                     d }|S )Nc                 $    | j                  |      S r;  rQ  )r  re   s     rC   rS  z#np_reshape.<locals>.np_reshape_impl  s    99U##rE   rp  )r  re   rS  s      rC   rT  rT    s    	$rE   c                 .   t        |       sd}t        j                  |      t        |t        j
                        r$t        |j                  t        j                        s1t        |t        j                        sd}t        j                  |      d }|S )N#The argument "a" must be array-likezBThe argument "new_shape" must be an integer or a tuple of integersc                 0   t        j                  |       } t        j                  |       } t        |t              r4d}t        j                  |      D ]  }||z  }|dk  sd}t        |       n|dk  rd}t        |      |}| j                  dk(  r.t        j                  |      j                  | j                        S | | j                  z   }| }t        |dz
        D ]  }t        j                  || f      } |d | }t        j                  ||      S )NrG   r   z0All elements of `new_shape` must be non-negative)ri  rj  ravelr   r   r   r   zerosastyper{   r8   concatenaterR  )	r  	new_shapenew_size
dim_lengthr   msg2repeatsr   rm   s	            rC   r   znumpy_resize.<locals>.impl  s   JJqMHHQKi'H jj3 *
J&>LC$S/)	* 1}I && H66Q;88I&--agg66I'(w{# 	+A..#q*C	+)8nzz#y))rE   )r   r	   r   r   r   rr  r{   r   )r  r^  r   r   s       rC   numpy_resizerc    st     A3  %%	5>>2	7y%--0%  %%*8 KrE   c                    t        |       st        j                  d      t        |      st        j                  d      t        |      rdd}|S t	        |t
        j                        st        j                  d      dd}|S )Nz+The first argument "arr" must be array-likez/The second argument "values" must be array-likec                     t        j                  t        j                  |             } t        j                  t        j                  |            }t        j                  | |f      S r;  )ri  rZ  rj  r]  r  valuesr   s      rC   r   znp_append.<locals>.impl  sB    ((2::c?+CXXbjj01F>>3-00rE   z,The third argument "axis" must be an integerc                 4    t        j                  | |f|      S Nr   ri  r]  rf  s      rC   r   znp_append.<locals>.impl  s    >>3-d;;rE   r;  )r   r	   r   r   r   r   r   )r  rg  r   r   s       rC   	np_appendrl    s     C   !NOOF#   ". / 	/ 4	1 K $.$$ &/ 0 0	<KrE   zarray.ravelc                     d }d }|j                   d   j                  dk(  r|}n|}| j                  ||||      }t        | ||j                  |      }|S )Nc                 8    | j                  | j                        S )zNo copy version)rR  r   r   s    rC   
imp_nocopyzarray_ravel.<locals>.imp_nocopy  s    {{388$$rE   c                 "    | j                         S )zCopy version)flattenro  s    rC   imp_copyzarray_ravel.<locals>.imp_copy	  s    {{}rE   r   r   )r   r  r  r"   r   )r}   r=   r[   r   rp  rs  impr   s           rC   array_ravelru    s_    %
 xx{S  

"
"7Cd
;C
7GS__c
BCJrE   c                 0    d }| j                  ||||      S )Nc                 "    | j                         S r;  )rZ  r  s    rC   np_ravel_implznp_ravel.<locals>.np_ravel_impl	  s    wwyrE   )r  )r}   r=   r[   r   ry  s        rC   np_ravelrz  	  s      ##G]CFFrE   zarray.flattenc                 d    d }| j                  ||||      }t        | ||j                  |      }|S )Nc                 T    | j                         j                  | j                        S r;  )rK  rR  r   ro  s    rC   rt  zarray_flatten.<locals>.imp	  s    xxz!!#((++rE   )r  r"   r   )r}   r=   r[   r   rt  r   s         rC   array_flattenr}  	  s8    , 
"
"7Cd
;C
7GS__c
BCJrE   c                    |t        j                  |       n|}t        j                  | ||      \  }}}t        j                  |j                        D ]*  }||   }	||   }
||   }t        t        |	|
      |      ||<   , |S r;  )ri  
empty_likebroadcast_arraysndindexre   minr  )r  a_mina_maxr   rW  a_ba_min_ba_max_br   val_a	val_a_min	val_a_maxs               rC   _np_clip_implr  %	  s     "k"--
sC//5%@C'CII& ;E
EN	EN	UI.	:E
	; JrE   c                     t        j                  | j                        D ]-  }| |   }||   }|rt        ||      ||<   t	        ||      ||<   / |S r;  )ri  r  re   r  r  )r  buse_minr   r   r  val_bs          rC   _np_clip_impl_noner  3	  sZ    AGG$ +%%UE*CJUE*CJ+ JrE   c                 &   t        |       st        j                  d      t        |t        j
                        s t        |      st        j                  d      t        |t        j
                        s t        |      st        j                  d      t        |t        j                        s"t        |      sd}t        j                  |      |d u xs t        |t        j
                        }|d u xs t        |t        j
                        }|r|rdd}|S t        |t        j                        }t        |t        j                        }	|r|	rdd}
|
S |r|	s|rdd}|S dd}|S |s|	r|rdd	}|S dd
}|S |rdd}|S |rdd}|S dd}|S )NrX  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                     t        d      )Nz&array_clip: must set either max or minr   r  r  r  r   s       rC   
np_clip_nnznp_clip.<locals>.np_clip_nnX	  s    EFFrE   c                     |t        j                  |       n|}t        j                  | j                        D ]   }| |   }t	        t        ||      |      ||<   " |S r;  )ri  r  r  re   r  r  r  r  r  r   rW  r   r  s          rC   
np_clip_ssznp_clip.<locals>.np_clip_ssa	  s[     '*k"--"sCAGG, ;% UE!2E:E
; JrE   c                     |t        j                  |       n|}t        j                  | j                        D ]  }| |   }t	        ||      ||<    |S r;  )ri  r  r  re   r  r  s          rC   
np_clip_snznp_clip.<locals>.np_clip_sno	  T     +.+bmmA&3ZZ0 3EeHE!$UE!2CJ3 
rE   c                 J    t        j                  | |      }t        | |||      S r;  ri  	full_liker  )r  r  r  r   
a_min_fulls        rC   
np_clip_saznp_clip.<locals>.np_clip_sa|	  s%    
  \\!U3
$Q
E3??rE   c                     |t        j                  |       n|}t        j                  | j                        D ]  }| |   }t	        ||      ||<    |S r;  )ri  r  r  re   r  r  s          rC   
np_clip_nsznp_clip.<locals>.np_clip_ns	  r  rE   c                 J    t        j                  | |      }t        | |||      S r;  r  )r  r  r  r   
a_max_fulls        rC   
np_clip_asznp_clip.<locals>.np_clip_as	  s%    
  \\!U3
$Qz3??rE   c                     |t        j                  |       n|}t        j                  | |      \  }}t        ||d|      S )NTri  r  r  r  )r  r  r  r   rW  r  r  s          rC   
np_clip_naznp_clip.<locals>.np_clip_na	  s=    *-+bmmA&3!221e<W)#wcBBrE   c                     |t        j                  |       n|}t        j                  | |      \  }}t        ||d|      S )NFr  )r  r  r  r   rW  r  r  s          rC   
np_clip_anznp_clip.<locals>.np_clip_an	  s=    *-+bmmA&3!221e<W)#wsCCrE   c                     t        | |||      S r;  )r  r  s       rC   
np_clip_aaznp_clip.<locals>.np_clip_aa	  s     %Quc::rE   r;  )	r   r	   r   r   r   NoneTyper   r   r  )r  r  r  r   r   a_min_is_nonea_max_is_noner  a_min_is_scalara_max_is_scalarr  r  r  r  r  r  r  r  s                     rC   np_clipr  ?	  s   A  !FGGuenn- '   #4 6 	6 uenn- '   "4 5 	5 sEKK(K,<E  %% TMFZu~~%FMTMFZu~~%FM	G  5O 5O?		 		 @ 	 @  C D ; rE   clipc                     dd}|S )Nc                 2    t        j                  | |||      S r;  )ri  r  r  s       rC   r   zarray_clip.<locals>.impl	  s    wwq%,,rE   NNNrp  )r  r  r  r   r   s        rC   
array_clipr  	  s    -KrE   c           	      v   |j                   |j                   k(  sJ |j                  |j                  k(  sJ t        |j                        }t        d      t        d      t        d      t        j                  fd}| j                  t        j                  t        | |            }| j                  t        j                  t        | |            }| j                  t        j                  |j                         }	t        j                  ||j                  d      dd      }
t        j                  ||j                  d      dd      }t        j                  t        j                  dd	      }| j                  |      }t        j                  || j                  t        j                  |j                         g      }| j                  | j                  t        j                              }| j                  t        j                  |      }t        j                  ||g      } || |      }t!        ||
|||d
        || |      }t!        |||||d
       |j#                         }|j#                         }|	||||| j                  t        j                  |      g}t%        t        j&                  t        j                  ||t        j                  t        j                  t        j                        }| 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.
    rI  r   Fc                 "   |	k(  r!|d   |k(  r	 
      }n|d   |k(  r       }||k7  r|	k(  s| dk(  ry|
k(  r| dz
  }nd}||k  r!||z  dk7  ry||z  }||xx   |z  cc<   |||<   y||kD  r||   |z  }||z  dk7  ry||z  ||<   |||<   y	 y)Nr  r   FrG   Trp  )r:  rl   r   old_itemsizenew_itemsizer  rm   newdim
bytelength
any_layoutc_layoutf_layoutint8s            rC   rt  z_change_dtype.<locals>.imp	  s     Zr{l*h|+h<'Vz-AR1WXQAA,& |+1!\1FGvG%GAJ"  L( a</J\)a/ L0DG%GAJ  rE   re   r   r   rG   r  Nr  )rp   r  ordr   r  r   r   r   r
   rh   rg   r   rx   rj   r|   rz   r   r   r%   booleanr  r   r!   r   )r}   r=   oldtynewtyr   
new_layoutrt  r  r  r:  
shape_datastrides_datashape_strides_array_typearyclsshape_constantsizeof_intpstrides_constantrI  strides_aryre   r   r   r[   r   r  r  r  r  s                           @@@@rC   _change_dtyper  	  s    ::###<<5<<'''U\\"JSJ3xH3xH::D.` ''

(4We(DFL''

(4We(DFL 
		ejj%**	5B%%gs/C/CG/L&',J''(+(<(<Y(GAOL  %{{!CP 89F'')0)=)=ejj>Cjj*J )KLN (()>)>uzz)JKK&&uzz;?K))'K=Aw(I9"'+'! '*K;$'+'! !E##%Gwl  Z8:D EMMJJ,,JJJJJJC 
"
"7Cd
;CeS!
GWcoos
CCJrE   c                 L    t        |       st        j                  d      d }|S )Nz+The argument to np.shape must be array-likec                 @    t        j                  |       j                  S r;  )ri  rj  re   rx  s    rC   r   znp_shape.<locals>.implC
  s    zz!}"""rE   r   r	   r   r  r   s     rC   np_shaper  >
  s&    A  !NOO#KrE   c                 L    t        |       st        j                  d      d }|S )Nz*The argument to np.size must be array-likec                 @    t        j                  |       j                  S r;  )ri  rj  r   rx  s    rC   r   znp_size.<locals>.implM
  s    zz!}!!!rE   r  r  s     rC   np_sizer  H
  s&    A  !MNN"KrE   c                     d }|S )Nc                     t        j                  | j                               }t        |d d       }t	        |dd        D cg c]  \  }}||   |k7  s| }}}t        j
                  ||z         S c c}}w r  )ri  sortrZ  r   r  r   )arr  headrm   rC  tails         rC   np_unique_implz!np_unique.<locals>.np_unique_implV
  si    GGBHHJAbqE{'!".<da!A$!)<<xxt$$ =s   A3A3rp  )r  r  s     rC   	np_uniquer  T
  s    %
 rE   c                    d }t        | t        j                  t        j                  t        j                  t        j
                  t        j                  f      rt        |t        j                        rt        S t        |t        j                  t        j                  f      r&t        |j                  t        j                        r|S t        j                  d      y )Nc                 @   t        j                  |t         j                        }|j                  d   dk(  rt	        | |d         S t        j
                  |dk        rt        d      t        j                  |       }|j                         }|j                  d   }|j                  |j                  k7  rt        d      t        j                  t        j                  |      |j                        }d}t        |      D ]  }||   |||||   z    |||   z  } |S )Nr{   r   rG   rz  z(operands could not be broadcast together)ri  rj  r  re   np_repeat_impl_repeats_scalerrA  r   rZ  emptyr  r{   r8   )	r  rb  repeats_arrayasaaraveln	to_returnposrm   s	            rC   !np_repeat_impl_repeats_array_likez4np_repeat.<locals>.np_repeat_impl_repeats_array_likec
  s   

7"((;q!Q&0M!4DEE66-!#$BCCjjmLLO<<=...:< <HHRVVM2#))D	q 	$A6<QiIcC-"223=##C	$ rE   zIThe repeats argument must be an integer or an array-like of integer dtype)r   r   r   ListrG  r  r  r   r  r{   r	   r   )r  rb  r  s      rC   	np_repeatr  ^
  s    
, !ekkjjoollmm	  gu}}-00%++uzz!:;'--788  01 	1rE   c                    |dk  rt        d      t        j                  |       }|j                         }|j                  d   }|dk(  r!t        j
                  d|j                        S |dk(  rt        j                  |      S t        j
                  ||z  |j                        }t        |      D ]  }||   |||z  |dz   |z    |S )Nr   rz  r  rG   )	r   ri  rj  rZ  re   r  r{   rK  r8   )r  rb  r  r  r  r  rm   s          rC   r  r  
  s    {>??
**Q-CYY[FQA!|xx++	AwwvHHQ[		:	q 	CA9?Ia'kQUg$56	CrE   repeatc                     d }|S )Nc                 .    t        j                  | |      S r;  )ri  r  )r  rb  s     rC   array_repeat_implz'array_repeat.<locals>.array_repeat_impl
  s    yyG$$rE   rp  )r  rb  r  s      rC   array_repeatr  
  s    % rE   c                 :    t        j                  |      }d }||fS )z"Computes the itemsize of the dtypec                     | j                  |j                  d   j                        }| j                  |j                        } || j	                  |            S r   )rz   r   r{   r   r|   )cgctxr=   r[   llargsr~   llintps         rC   rU  z%_intrin_get_itemsize.<locals>.codegen
  sJ    ""388A;#4#45$$S__5e**4011rE   )r   r   )tyctxr{   r[   rU  s       rC   _intrin_get_itemsizer  
  s#     **U
C2 <rE   c                      y r;  rp  )r  r{   s     rC   _compatible_viewr  
      rE   c                     d }|S )zDDetermines if the array and dtype are compatible for forming a view.c                    t        |      }|| j                  k7  r| j                  dk(  rd}t        |      	 | j                  dz
  }| j                  |   dk7  }| j
                  dk7  }| j                  |   | j                  k7  }|r|r|rd}t        |      || j                  k  r%|dk(  s| j                  |z  dk7  rd}	t        |	      y | j                  |   | j                  z  }
|
|z  dk7  rd}t        |      y y )Nr   zOChanging the dtype of a 0d array is only supported if the itemsize is unchangedrG   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   rp   r   re   r   r   )r  r{   
dtype_sizemsg1r   p1p2p3ra  msg3r  msg4s               rC   r   z ol_compatible_view.<locals>.impl
  s   )%0
#vv{7 &&  66A:D!#B1B4AJJ.Brb2 &&AJJ&?ajj:&=&BID$T** 'C
 3J&!+1D %T**	 ,9 $rE   rp  r  r{   r   s      rC   ol_compatible_viewr  
  s    "+F KrE   z
array.viewc                    |j                   d   }|j                  } t        |      | ||d         } t        |      | |      }t        |j                  j
                        }t        |      D ]N  }	t        ||	      }
|	dk(  r.|j                  j                  }|j                  |
|      |_        Bt        ||	|
       P | j                  }|j                  t              }|j                  |g |j                   i       }| j!                  ||      } |||       t#        | ||||      }|j%                  d|t'        |j                  d            }|j)                  |      5  d}| j*                  j-                  |t.        |f       d d d        |j1                         }t3        | ||j                  |      S # 1 sw Y   1xY w)Nr   r   r  z"new type not compatible with array)r   r   rx   r   r   r   sortedgetattrr   r9   r)  r   r  r  r  r  rQ   r  r  r   r  rV  rW  r   r   r!   )r}   r=   r[   r   r   rF  r   rW  fieldsr   r   r!  r  r  _compatible_view_sigr   rC  rK  r   r   s                       rC   
array_viewr  
  s   HHQKEOOE
*U
GWd1g
6C
*U
GW
-C''(FF^ !c1o;HHMMEsE2CHCC ! ""E##$45D--e\sxx\2F&:;D$	ws	;B  r8BGGQ+?@D		 G2))':vFG --/CWgsDDG Gs   "%F77G r{   c                 >    | j                         }t        | |||      S r;  )r\  r#   r}   r=   rv  r  r   s        rC   array_dtyper    s!    

!
!
#CgwS99rE   re   c                 `    t        |      } || ||      }|j                  }t        | |||      S r;  )rx   re   r#   r}   r=   rv  r  r   r   r   s          rC   array_shaper    s5     oGGWe,E
++CgwS99rE   r   c                 `    t        |      } || ||      }|j                  }t        | |||      S r;  )rx   r   r#   r  s          rC   array_stridesr    s5     oGGWe,E
--CgwS99rE   rp   c                 r    | j                  t        j                  |j                        }t	        | |||      S r;  )r   r   r   rp   r#   r  s        rC   
array_ndimr    s/     

uzz388
4CgwS99rE   r   c                 `    t        |      } || ||      }|j                  }t        | |||      S r;  )rx   r   r#   r  s          rC   
array_sizer  %  s3    oGGWe,E
,,CgwS99rE   r   c                 `    t        |      } || ||      }|j                  }t        | |||      S r;  )rx   r   r#   r  s          rC   array_itemsizer  -  s5     oGGWe,E
..CgwS99rE   nbytesc                     t        |      } || ||      }|j                  |j                  |j                        }t	        | |||      S )z"
    nbytes = size * itemsize
    )rx   r   r   r   r#   r  s          rC   array_nbytesr  6  sD     oGGWe,E
++ellENN
3CgwS99rE   
contiguousc                 r    | j                  t        j                  |j                        }t	        | |||      S r;  )r   r   r  	is_contigr#   r  s        rC   array_contiguousr#  B  s-    


u}}cmm
<CgwS99rE   c_contiguousc                 r    | j                  t        j                  |j                        }t	        | |||      S r;  )r   r   r  is_c_contigr#   r  s        rC   array_c_contiguousr'  H  -    


u}}coo
>CgwS99rE   f_contiguousc                 r    | j                  t        j                  |j                        }t	        | |||      S r;  )r   r   r  is_f_contigr#   r  s        rC   array_f_contiguousr,  N  r(  rE   rQ  c                 t    | j                  t        j                  |j                         }t	        | |||      S r;  )r   r   r  mutabler#   r  s        rC   array_readonlyr/  T  s/    


u}}#++o
>CgwS99rE   ctypesc                     t        |      } || ||      }t        j                  |      }| j                  ||      }|j                  |_        |j
                  |_        |j                         }t        | |||      S r;  )rx   r   ArrayCTypesr   r   r   r   r!   )	r}   r=   rv  r  r   r   actctinfor   s	            rC   array_ctypesr5  \  sp    oGGWe,E


C
 C  #.F**FK]]FN



CWgsC88rE   r   c                     | j                  |||      }|j                  }|j                  || j                  t        j
                              }t        | |||      S Nr  )r   r   r  r   r   r   r#   )r}   r=   rv  r  r4  r   s         rC   array_ctypes_datar8  i  sT      #U ;F
++C


3 6 6uzz B
CCgwS99rE   c                     | j                  |||      }|j                  }|j                  || j                  |            }t	        | |||      S r7  )r   r   r)  r   r#   )r}   r=   fromtytotyr   r4  r   s          rC   array_ctypes_to_pointerr<  r  sP       & <F
++C
//#w55d;
<Cgwc::rE   c                     t        |      |||      }t        j                  t        j                  |j                        }|j                  |j                  |j                              }t        t        j                  ||t        j                        }|j                  |j                  |j                  t        j                  |      g}|j                  || ||      }	|	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  )rx   r   rr  r   rp   r|   r   r{   r%   bool_re   r   r   r  )
checkerr}   r=   r   r   tup_intpr   	check_sig
check_argsr"  s
             rC   _call_contiguous_checkrC  {  s     *U
GWC
8C~~ejj%**5H%%g&<&<U[[&IJH%++x5::FI))S[[&&uzz8<>J(('9)35IrE   r   c                     | j                  |t        j                  |            }||_        |j	                         }| j
                  j                  |||       t        | |||      S r;  )r   r   
ArrayFlagsr   r   r   r   r"   )r}   r=   rv  r  flagsobjr   s         rC   array_flagsrG    s[    ""7E,<,<S,ABHHO



CKKwU+GWc377rE   c                 :   |j                   j                  dk7  r<| j                  |||      }t        t        | ||j                   |j
                        }n9|j                   j                  dk(  }| j                  t        j                  |      }t        | |||      S )Nr   r  )
rb   r  r   rC  r   r   r   r   r  r#   )r}   r=   rv  r  rF  r   r   s          rC   array_flags_c_contiguousrI    s     ~~#&&w5&A$]GW%(^^X__F nn##s*""5==#6gwS99rE   c                 x   |j                   j                  dk7  r<| j                  |||      }t        t        | ||j                   |j
                        }nX|j                   j                  }|j                   j                  dkD  r|dk(  n|dv }| j                  t        j                  |      }t        | |||      S )Nr  r  rG   r   )rb   r  r   rC  r   r   rp   r   r   r  r#   )r}   r=   rv  r  rF  r   r  r   s           rC   array_flags_f_contiguousrK    s    
~~#&&w5&A$Z'%(^^X__F &&"~~22Q6fmFdN""5==#6gwS99rE   r  c                     |j                   t        j                  v rt        | |||d      S |j                   t        j                  v rt        | |||      S t        dj                  t        j                               )Nr  attrzunsupported .real for {})	r{   r   complex_domainarray_complex_attrnumber_domainr!   rR   r   r9   )r}   r=   rv  r  s       rC   array_real_partrR    se    
yyE(((!'7CVLL	e))	) '3>>!"<"C"CDJJ"OPPrE   r  c                 2   |j                   t        j                  v rt        | |||d      S |j                   t        j                  v rt        |j                  d      |      }t        | |||g      \  }}t        | |||      }t        j                  ||j                  |j                  |j                  |j                        d       t        | ||j                   |j#                               S t%        dj'                  t(        j                               )Nr  rM  TrZ  r   zunsupported .imag for {})r{   r   rO  rP  rQ  r%   rK  _parse_empty_like_argsr  r
   memsetr   r   r   r   r"   r   r   rR   r   r9   )r}   r=   rv  r  r[   rL  r   r   s           rC   array_imag_partrV    s    
yyE(((!'7CVLL	e))	)$/50'3PWgw?w'++cll69jj+BCD	F#// #1 	1 ""<"C"CDJJ"OPPrE   c                    |dvs|j                   t        j                  vrt        dj	                  |            t        |      } || ||      }|j                   j                  }| j                  | j                  |            }|j                  j                  |      }	| j                  |      j                         }
|j                  |j                  |
      }|dk(  r,|j                  | t!        j"                  d      d      g      }|j%                  |d      } t        |      | |      }t'        ||	      }t)        j*                  |||       t-        | |||j/                               S )	a  
    Given a complex array, it's memory layout is:

        R C R C R C
        ^   ^   ^

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

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

        R x R x R x
        ^   ^   ^

    (`x` indicates unused)

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

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

        x C x C x C
          ^   ^   ^
    )r  r  zcannot get attribute `{}`r      rG   rI  r{   r  )r   r   )r{   r   rO  rR   r   rx   underlying_floatr|   rz   r   r9   r   r  r)  r   r  r   IntTyperK  r   r
   copy_structr!   r   )r}   r=   rv  r  rN  r   r   fltysizeof_fltyr   
llfltptrtyr   resulttyr  repls                  rC   rP  rP    sE   8 ##syy8L8L'L!"="D"DT"JKKoGGWe,E 99%%D(()>)>t)DEK~~"";/H ''-88:Jooejj*5G v~++g

2q(9':; xxd3x/H!Z!'73FWx0Dt,Wgx9I9I9KLLrE   conj	conjugatec                     d }|S )Nc                 ,    t        j                  |       S r;  )ri  rb  r  s    rC   r   zarray_conj.<locals>.impl  s    wws|rE   rp  r  r   s     rC   
array_conjrh    s    KrE   c                 "    | j                         S r;  )r\  )r}   r=   dtypetydtypevals       rC   
dtype_typerl    s    ""$$rE   r9   kindstatic_getitemc                     |j                   }t        |t        j                        r% | j	                  |      d      }t        | |||      S d}t        j                  |      )zThis handles the "static_getitem" when a Numba type is subscripted e.g:
    var = typed.List.empty_list(float64[::1, :])
    It only allows this on simple numerical types. Compound types, like
    records, are not supported.
    NzlUnreachable; the definition of __getitem__ on the numba.types.abstract.Type metaclass should prevent access.)r   r   r   r   r   r#   r	   LoweringError)r}   r=   r[   r   rF  r   r   s          rC   static_getitem_number_clazzrq  (  s^     OOE%% ,g$$U+D1!'7E3??L""3''rE   c           
         t        |      } || ||      }|j                  }t        |t        j                        st        d|d|d      |j                  |      }|j                  |      }	t        |t        j                        r6|j                  |j                  |j                  |j                  z   d      }
n|j                  |d      }
t        |
      } || |      }| j                  t        j                  |	      }t        j                  ||j                  ||j                  j                         }t        |t        j                        rt        j"                  ||j$                  |j                        }||j$                  D cg c]"  }| j                  t        j                  |      $ c}z  }t        j"                  ||j&                  |j                        }||j&                  D cg c]"  }| j                  t        j                  |      $ c}z  }| j)                  | j+                  |j                              }n8|j$                  }|j&                  }| j)                  | j+                  |            }t-        ||||| j                  t        j                  |      |j.                  |j0                         |j3                         }t5        | ||
|      S c c}w c c}w )	zq
    Generic getattr() implementation for record arrays: fetch the given
    record member, i.e. a subarray.
    z
attribute z of z not definedrI  r  rY  )r   r1  )rx   r{   r   r   RecordrR   typeofr   NestedArrayrK  rp   r   r   r
   r   r   r9   r   re   r   r|   rz   r   r   r   r   r!   )r}   r=   rv  r  rN  r   r   rectyper{   r   restyrarytyraryconstoffset
newdataptrre   rm   r   datasizer   s                       rC   array_record_getattrr}  @  sR    oGGWe,EiiGgu||,!%)3#0 1 	1NN4 E^^D!F%**+++CHHuzz$9#  G uS1F'7#D&&uzz6:K$$[tyy~~J %**+$$Wekk388Du{{K!'&&uzz15KK&&wsxxHOAG((Q7OO))'*?*?*LM --))'*?*?*FG4""#00XF ==,,( ..
CWguc::' L Ps   'K)8'K.c                 v    |d   }t        |t              st        t        | ||j                  d   |d   |      S r  )r   r  rR   r}  r   )r}   r=   r[   r   r   s        rC   array_record_getitemr  x  s:    GEeS!!!#((1+tAwNNrE   c           
         | j                  ||       |j                  |      }|j                  |      }t        |t        j
                        r5t        |      } || |      }|j                  }	|j                  D 
cg c]"  }
| j                  t        j                  |
      $ }}
|j                  D 
cg c]"  }
| j                  t        j                  |
      $ }}
t        j                  |||| j                  |	            }t        ||t        j                   ||      t        j                   ||      | j                  t        j                  |j"                        dd       |j%                         }t'        | |||      S t        j                  |||| j                  |            }|j(                  rdnd}| j+                  ||||      }t'        | |||      S c c}
w c c}
w )zT
    Generic getattr() implementation for records: get the given record member.
    Nr1  rG   )sentry_record_alignmentr   rt  r   r   ru  rx   r{   re   r   r   r   r
   get_record_memberrz   r   rj   r   r   r!   r   r   )r}   r=   rv  r  rN  r   elemtyr   r   r{   r   r5  r6  newdatar   dptrr   s                    rC   record_getattrr    s   
 ##C.ZZFZZF&%++, 6"GW%LL"AG((Q7 " " nn&ag**5::q9 &
 &++GUF,3,A,A%,HJ$$Wh7&&w
;))%**fkkB	
 mmo '3<<((%)0)>)>v)FH""7FD%@ '3<<-"&s   >'G5'G#c           	         |j                   \  }}|\  }}| j                  ||       |j                  |      }	|j                  |      }
t	        |
t
        j                        r t        j                  |      | ||d         }|j                  }t        j                  |||	|j                  j                        }t        j                  |||| j                  t
        j                  |
j                                yt        j                  |||	| j#                  |
            }| j%                  ||||
      }|j&                  rdnd}| j)                  ||
|||       y)zT
    Generic setattr() implementation for records: set the given record member.
    rG   r  Nr   )r   r  r   rt  r   r   ru  r
   rw   r   r  r9   pointeememcpyr   r   r   rz   r   r   r   )r}   r=   r[   r   rN  rv  rJ  r  r   r   r  
val_structr/  rT  r  r   s                   rC   record_setattrr    s1   
 JCKFC##C.ZZFZZF&%++,7W007>B1gG
oo((&&),)9)9;wc++EJJF	H ((&&)0)>)>v)FHll7C77FCUCrE   c                     | j                  |j                  d   |d         } || ||j                  d   |d   |d         S )3
    Record.__getitem__ redirects to getattr()
    r   rG   )get_getattrr   )r}   r=   r[   r   r   s        rC   record_static_getitem_strr    sE    
 sxx{DG4D#((1+tAwQ@@rE   c                 2   |j                   d   j                  }t        |j                   d   j                        }| j	                  |j
                  ||         }| j                  |j                   d   |      } || ||j                   d   |d   ||         S )r  rG   r   )r   r   r   r  insert_const_stringr:   r  )r}   r=   r[   r   r   r  ll_fieldr   s           rC   record_static_getitem_intr    s    
 ((1+
#
#C#((1+$$%F**7>>6#;GHsxx{H5D#((1+tAwsDDrE   static_setitemc                     |j                   \  }}}|\  }}}	t        |j                  ||      }
| j                  ||
      }|J  ||||	f      S )3
    Record.__setitem__ redirects to setattr()
    )r   r%   r   get_setattr)r}   r=   r[   r   rectyr  rJ  recr   r   getattr_sigr   s               rC   record_static_setitem_strr    s_    
 hhOE1eMCcCOOUE:KsK0D#s$$rE   c                     |j                   \  }}}|\  }}}	t        |j                  ||      }
t        |j                   d   j                        }| j                  ||   |
      }|J  ||||	f      S )r  r   )r   r%   r   r   r  r  )r}   r=   r[   r   r  r  rJ  r  r   r   r  r  r   s                rC   record_static_setitem_intr    s{    
 hhOE1eMCcCOOUE:K#((1+$$%Fvc{K8D#s$$rE   c                 (    | j                  |||      S )zB
    Create a constant array (mechanism is target-dependent).
    )make_constant_array)r}   r=   r>  pyvals       rC   constant_arrayr    s    
 &&wE::rE   c                     t        j                  t        j                  d      |j                        } |t	        |j                                     }t        j                  ||      S )zG
    Create a record constant as a stack-allocated array of bytes.
       )r   r  r[  r  	bytearraytostringr
   r   )r}   r=   r>  r  ltyr   s         rC   constant_recordr    sI    
 ,,rzz!}ell
3C
i()
*C$$Wc22rE   c                     t        j                  t        |      t         j                        }| j	                  |||      S )zM
    Create a constant array from bytes (mechanism is target-dependent).
    r  )ri  r   r  uint8r  )r}   r=   r>  r  bufs        rC   constant_bytesr    s2    
 ((9U#288
4C&&wC88rE   c                 x    |j                   \  }}||k7  rt        j                  S d }| j                  ||||      S )Nc                     | j                   |j                   k(  xrH | j                  |j                  k(  xr- | j                  j                  |j                  j                  k(  S r;  )re   r   r0  r   r  r  s     rC   array_is_implzarray_is.<locals>.array_is_impl  sI    177" /		QYY&/.	0rE   )r   r
   r  r  )r}   r=   r[   r   atybtyr  s          rC   array_isr    s@    xxHC
cz   0
 ##G]CFFrE   __hash__c                     d S )Nc                      y r;  rp  rf  s    rC   r  zol_array_hash.<locals>.<lambda>,  r  rE   rp  rf  s    rC   ol_array_hashr  *  s    rE   c                     t        | d      S )zq
    Return the Structure representation of the given *flatiterty* (an
    instance of types.NumpyFlatType).
    flat_make_flattening_iter_cls)
flatitertys    rC   make_array_flat_clsr  2  s    
 %Z88rE   c                     t        | d      S )zv
    Return the Structure representation of the given *nditerty* (an
    instance of types.NumpyNdEnumerateType).
    ndenumerater  nditertys    rC   make_array_ndenumerate_clsr  :  s    
 %X}==rE   c                    | j                  t        j                  d      }|j                  d      }	| |j	                  t
        j                  |       t        t        |            D ]  }
t        j                  |||
      }t        j                  ||j                  |            }||
   }|j                  d||      }t        j                  ||      5  |j	                  ||       | ||
       |j                  |	       d d d        |j	                  ||       | ||
        | |j	                  t
        j                  |       |j                  |	       |j!                  |	       y # 1 sw Y   mxY w)Nr   end_incrementr  )r   r   r   rx  r  r
   
false_byter  r8   rh   r  r>   r	  	if_likelyr  	true_byter  )r}   r=   rp   re   r   end_flagloop_continue
loop_breakr   bbendrt  idxptrr   r   	in_boundss                  rC   _increment_indicesr  B  sF   

A.D&&7Eg(((3d$ %%gw<%%gw||F/CDc
''S%8	w	2 	"MM#v&(c"NN5!	" 	dF#!sO" g''2NN5E"	" 	"s   .E//E8	c                     t        j                  ||j                  |j                        }t	        | ||j                  |||       y r;  )r
   r   re   rp   r  )r}   r=   r  r  r   r  re   s          rC   _increment_indices_arrayr  c  s4      #))UZZ@EwUGXNrE   c                 v   	
  j                   
 j                  t         j                        	 j                  r
nd G d dt
              } G d d|       G  fdd|       G d d	|       G d
 d|       G d d|       G 	
 f
ddt        j                               }|S )zq
    Return the Structure representation of the given *nditerty* (an
    instance of types.NumpyNdIterType).
    rG   c                   R    e Zd ZdZd Zd Zej                  d        Zd Z	d Z
d Zy)	$make_nditer_cls.<locals>.BaseSubIterzF
        Base class for sub-iterators of a nditer() instance.
        c                 P    || _         || _        || _        || _        ||z
  | _        y r;  )nditermember_name	start_dimend_dimrp   )rY   r  r  r  r  s        rC   rv  z-make_nditer_cls.<locals>.BaseSubIter.__init__x  s+     DK*D&DN"DL)+DIrE   c                 F    t        | j                  | j                  |       y r;  )r   r  r  )rY   rk   s     rC   set_member_ptrz3make_nditer_cls.<locals>.BaseSubIter.set_member_ptr  s    DKK!1!137rE   c                 B    t        | j                  | j                        S r;  )r  r  r  ra  s    rC   
member_ptrz/make_nditer_cls.<locals>.BaseSubIter.member_ptr  s    4;;(8(899rE   c                      y r;  rp  )rY   r}   r=   s      rC   init_specificz2make_nditer_cls.<locals>.BaseSubIter.init_specific  r  rE   c                      y r;  rp  rY   r}   r=   logical_dims       rC   r  z2make_nditer_cls.<locals>.BaseSubIter.loop_continue  r  rE   c                      y r;  rp  r  s       rC   r  z/make_nditer_cls.<locals>.BaseSubIter.loop_break  r  rE   N)rq   rr   rs   ro  rv  r  r4  cached_propertyr  r  r  r  rp  rE   rC   BaseSubIterr  s  s:    		,	8 
	"	"	: 
#	:			rE   r  c                   (    e Zd ZdZd Zd Zd Zd Zy)$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                     |j                  t        j                  d      }| j                  t	        j
                  ||             y r   )r   r   r   r  r
   r   )rY   r}   r=   r   s       rC   r  z2make_nditer_cls.<locals>.FlatSubIter.init_specific  s3    ''

A6D 9 9'4 HIrE   c                 r    |j                  | j                        }|j                  |j                  |g      S r;  )r>   r  r  r   )rY   r}   r=   r   r  r  r   s          rC   compute_pointerz4make_nditer_cls.<locals>.FlatSubIter.compute_pointer  s+    LL1E;;sxx%11rE   c                     || j                   dz
  k(  rN|j                  | j                        }t        j                  ||      }|j                  || j                         y y r  )rp   r>   r  r
   r  r  )rY   r}   r=   r  r   s        rC   r  z2make_nditer_cls.<locals>.FlatSubIter.loop_continue  sM    dii!m+T__5//?eT__5	 ,rE   c                 H   |dk(  r=|j                  t        j                  d      }|j                  || j                         y || j
                  dz
  k(  rN|j                  | j                        }t        j                  ||      }|j                  || j                         y y r  )	r   r   r   r  r  rp   r>   r
   r  )rY   r}   r=   r  r   r   s         rC   r  z/make_nditer_cls.<locals>.FlatSubIter.loop_break  s}    a++EJJ:dDOO4		A-T__5//?eT__5	 .rE   N)rq   rr   rs   ro  r  r  r  r  rp  rE   rC   FlatSubIterr    s    	
	J	2	6		6rE   r  c                   "    e Zd ZdZ fdZd Zy)+make_nditer_cls.<locals>.TrivialFlatSubIterzx
        Sub-iterator walking a contiguous array in physical order,
        *without* support for broadcasting.
        c                 "    j                   rJ y r;  )need_shaped_indexing)rY   r}   r=   r  s      rC   r  z9make_nditer_cls.<locals>.TrivialFlatSubIter.init_specific  s    44444rE   c                 v    t        |      dk  sJ t        |             |j                  |j                  |      S r  )r   r  r   rY   r}   r=   r   r  r  s         rC   r  z;make_nditer_cls.<locals>.TrivialFlatSubIter.compute_pointer  s2    w<1$2c'l2$;;sxx11rE   N)rq   rr   rs   ro  r  r  r  s   rC   TrivialFlatSubIterr    s    	
	5	2rE   r  c                       e Zd ZdZd Zy)'make_nditer_cls.<locals>.IndexedSubIterzA
        Sub-iterator walking an array in logical order.
        c                 l    t        |      | j                  k(  sJ t        j                  |||||d      S NFr  )r   rp   r
   r#  r  s         rC   r  z7make_nditer_cls.<locals>.IndexedSubIter.compute_pointer  s:    w<499,,,++GWeS,3G GrE   Nrq   rr   rs   ro  r  rp  rE   rC   IndexedSubIterr    s    		GrE   r  c                       e Zd ZdZd Zy)'make_nditer_cls.<locals>.ZeroDimSubIterz5
        Sub-iterator "walking" a 0-d array.
        c                     |j                   S r;  )r   r  s         rC   r  z7make_nditer_cls.<locals>.ZeroDimSubIter.compute_pointer  s    88OrE   Nr  rp  rE   rC   ZeroDimSubIterr    s    		rE   r  c                       e Zd ZdZd Zy)&make_nditer_cls.<locals>.ScalarSubIterz8
        Sub-iterator "walking" a scalar value.
        c                     |S r;  rp  r  s         rC   r  z6make_nditer_cls.<locals>.ScalarSubIter.compute_pointer  s    JrE   Nr  rp  rE   rC   ScalarSubIterr    s    		rE   r   c                      
 e Zd ZdZej
                   fd       Z	fdZfdZd Z	d Z
	fdZd Zd	 Zy
)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           	          g }j                   rnd}t        j                        D ]0  \  }}|\  }}}}d|z  }	||   }
|j                   |
| |	||             2 |S )N)r  indexed0dscalarzindex%d)r  r  r  ri   )rY   l	factoriesrm   r  rm  r  r  r  r  factoryr  r  r   r  r  r  s              rC   subitersz(make_nditer_cls.<locals>.NdIter.subiters  s    A080M0M0$2-#0	I $H$5$56 I3.1+i!'!m#D/{IwGH	I
 HrE   c                    |j                  t        j                  d      }|j                  |t        j                  |      |      | _        t        |      D ]K  \  }}t        |t        j                        r!d|z  }t        j                  |||         }	t        | ||	       M | j                  ||||      }t        j                  t        j                        }
d}d}t        |      D ]O  \  }}t        |t        j                        s!|j                  k(  s1||   j                  }||   j                   } n; dk(  sJ |j                  ||
d      }|j                  t        j                  d      }d }t#        ||      D ]  \  }}t        |t        j                        s!|j                  dkD  s1t%        t        j&                  t        j                  t        j                  |j                        |
      }|j)                  ||||j                  |f        t        j*                  ||      }dk(  r|ddd   }|j-                  d	||      }|j/                  |t        j0                  t        j2                        }j4                  s|f}t7        |      k(  sJ t        j8                  ||j:                  
      }t=              D ]+  }t        j>                  |||      }|jA                  ||       - || _!        t        jD                  |||j:                        | _        t        j                  ||      | _#        | jH                  D ]  }|jK                  ||        y)zY
            Initialize the nditer() instance for the specific array inputs.
            r   scalar%dNrp  rG   c                     t        |       }t        |      D ]'  }| |   |t        |      |z
  |z      k7  st        d       y )Nz2nditer(): operands could not be broadcast together)r   r8   r   )re   
main_shaper  rm   s       rC   check_shapezBmake_nditer_cls.<locals>.NdIter.init_specific.<locals>.check_shape  sO    Jq ?AQx:c*o.AA.E#FF( *> ? ??rE   r  r  r  r}  )&r   r   r   r  rs  arraysr  r   r   r
   r   r   _arrays_or_scalarsrr  rp   re   r   r   r%   noner  r   r	  r  r  r  r  r   rW   r9   r8   rh   r  r   rj   	exhaustedr
  r  )rY   r}   r=   arrtysr  r   rm   r>  r  slotmain_shape_tyr  main_nitemsr  r  r  r[   r   shape_is_emptyr  r   rt  r  subiterr  rp   r  nshapess                           rC   r  z-make_nditer_cls.<locals>.NdIter.init_specific  s	    ''

A6D ",,Wekk&6I-35DK #6* 52!"ekk2",q.K"44WfQiHDD+t45 ,,WgvvNF "NN5::t<MJK%f- 	B5eU[[1ejjD6H!'J"()"2"2K		B qy y$//K
%225::qA? "&&1 K
seU[[1ejj1n#EJJ$)NN5::uzz$J$13C ,,Wk-0399j2IKK ))':>F}" %00{DIN~w7H7H'.'9'9;I 00 &v;')))))'4997KGW~ , --gwDdF+, #DL ++GVTYYGDJ$66w	JDN  == 8%%gw78rE   c                 2   |j                  d      }t        j                  ||j                  | j                              }t        j
                  ||      5  |j                  d       |j                  |       ddd       j                  }t        j                  || j                        }| j                  ||||      }| j                  }|j                  d       | j                  |||||      }	|	D 
cg c]  }
|
j                          }	}
t        |	      dk(  r|j                  |	d          n,|j                  |j!                  |j"                  |	             t        j                  || j$                        }t'        ||t        |      ||| j                  t)        j*                  | j,                  ||      t)        j*                  | j.                  ||             |j                  |       |j1                  |       y# 1 sw Y   xY wc c}
w )zJ
            Compute next iteration of the nditer() instance.
            r	  FNTrG   r   )rx  r
   as_bool_bitr>   r  if_unlikelyr
  r  r  r   r  r   _make_viewsr   r   r  r  r  re   r  r4  partial_loop_continue_loop_breakr  )rY   r}   r=   r  r  r  r  r  r   viewsr   re   r  s               rC   iternext_specificz1make_nditer_cls.<locals>.NdIter.iternext_specific=  s    ..u5E  ++G,3LL,HJI$$Wi8 &  'u%& __F))'4;;?F,,WgvvNFllG T"$$WgwOE,12qQ[[]2E25zQeAh'g00(:M:M168 9 (($**=EwUU&(001D1D1818 :  )001A1A1818 :! NN5!##E*?& & 3s   #H9HHc                     | j                   D ]E  }|j                  |cxk  r|j                  k  s#n &|j                  ||||j                  z
         G y r;  )r
  r  r  r  rY   r}   r=   rt  r  s        rC   r   z.make_nditer_cls.<locals>.NdIter._loop_continueg  sG    }} M==C5#++5%%gwcmm8KLMrE   c                     | j                   D ]E  }|j                  |cxk  r|j                  k  s#n &|j                  ||||j                  z
         G y r;  )r
  r  r  r  r%  s        rC   r!  z+make_nditer_cls.<locals>.NdIter._loop_breakl  sE    }} J==C5#++5NN7GS3==5HIJrE   c                 <   dgz  }j                   }| j                  }j                  }	t        |	t        j
                        rt        |	      }	n|	g}	t              D 
cg c](  }
|j                  t        j                  |||
            * }}
t        ||      D ]c  \  }}|\  }}}}||j                  |j                   }dk(  r|ddd   }|D ],  }
||
   J | j                  ||||	|
   ||
   ||
   |      ||
<   . e t        d |D              sJ |S c c}
w )z:
            Compute the views to be yielded.
            Nr  r  c              3       K   | ]  }|  y wr;  rp  r=  r   s     rC   r?  z>make_nditer_cls.<locals>.NdIter._make_views.<locals>.<genexpr>  s     (Qq(s   )r  r
  r  r   r   rG  r   r8   r>   r
   rh   r   r  r  
_make_viewrt  )rY   r}   r=   r   r  r  r"  r  r
  rettysrm   r  r  r  array_indicessub_indicesr  narraysr  r  s                   rC   r  z+make_nditer_cls.<locals>.NdIter._make_viewsq  sN    FW$E((H}}H((F&%//2f  %g0 ||G$8$8'1$MN 0G 0 !$Hh 7 	NW),&1a%g&7&7HS="-dd"3K& NA 8+++#w/5ay/5ay&)W NE!HN	N (%((((L0s   "-Dc                    t        |t        j                        r|j                  dk(  sJ |j	                  |||||      } |j                  |      ||      }	t        ||      }
|j                  |t        j                  t        j                  d      d      }|j                  |t        j                  t        j                  d      d      }t        |	||||
d       |	S )zD
            Compute a 0d view for a given input array.
            r   rp  N)r   )r   r   r   rp   r  rx   r   r  rr  r   r   )rY   r}   r=   r   rF  r  r  r  rk   viewr   re   r   s                rC   r*  z*make_nditer_cls.<locals>.NdIter._make_view  s    
 eU[[1ejjAoEE))'7GUCPC,7%%e,Wg>D#GU3H&&wuzz10M')+E((%..Q2O)+-G 4eWhMKrE   c                    g }t        t        ||            D ]j  \  }\  }}t        |t        j                        r*|j                   |j                  |      |||             M|j                  t        | d|z               l |S )Nr  r  )r  r   r   r   r   ri   rx   r  )	rY   r}   r=   r  r  r  rm   r  r  s	            rC   r  z2make_nditer_cls.<locals>.NdIter._arrays_or_scalars  s     A#,S-@#A <<E3eU[[1HH6W//6w7>=@B C HHWT:>:;< HrE   N)rq   rr   rs   ro  r4  r  r
  r  r#  r   r!  r  r*  r  )
r  r  r   r  r  r  r.  rp   r  r  s
   rC   NdIterr    sO    	 
	"	"	 	 
#	M	8^(	+T	M
	J
	8	(	rE   r2  )rp   r  r   r  r  objectr
   rw   )r  r  r2  r  r  r   r  r  r  r.  rp   r  s   `  @@@@@@@@@rC   make_nditer_clsr4  i  s    
 ==D__F(//"G33dGf 86k 6@2[ 2G G  V V,,X6 Vp MrE   c                 `    | j                    G fddt        j                  |             }|S )zr
    Return the Structure representation of the given *nditerty* (an
    instance of types.NumpyNdIndexType).
    c                   &    e Zd ZdZ fdZ fdZy)%make_ndindex_cls.<locals>.NdIndexIterz,
        .ndindex() implementation.
        c                    |j                  t        j                  d      }t        j                  ||j
                  |j                  t        j                              }t        j                  |t        j                        }t              D ]  }t        j                  |||      }|j                  ||       ||   }	|j                  d|	|      }
t        j                  ||
      5  |j                  t        j                  |       d d d         || _        || _        t        j                   |||j
                        | _        y # 1 sw Y   xY wNr   r}  r  )r   r   r   r
   rW   r9   r   r  r8   rh   r  r  r  r  r   r  rj   re   )rY   r}   r=   r   r   r   r  rt  r  r  dim_is_emptyrp   s              rC   r  z3make_ndindex_cls.<locals>.NdIndexIter.init_specific  s'   ''

A6D))'499/6/C/CEJJDH0JKG  11'7;M;MNIT{ 	@ --gwDdF+ "#;&44T8TJ((,? @MM'"3"3Y?@ @	@ #DL&DN ++GVTYYGDJ@ @s   +!EE	c           
      n   |j                  t        j                  d      }|j                  d      }t	        j
                  ||j                  | j                              }t	        j                  ||      5  |j                  d       |j                  |       d d d        t              D cg c]2  }|j                  t	        j                  || j                  |            4 }}|D ]  }	t        ||	        |j                  t	        j                   |||j"                               |j                  d       t	        j$                  || j&                        }
t)        |||
| j                  | j                         |j                  |       |j+                  |       y # 1 sw Y   xY wc c}w )Nr   r	  FT)r   r   r   rx  r
   r  r>   r  r  r
  r  r8   rh   r   rI   r  rj   r9   r   re   r  r  )rY   r}   r=   r  r   r  r  rt  r   r>   re   rp   s              rC   r#  z7make_ndindex_cls.<locals>.NdIndexIter.iternext_specific  sq   ''

A6D..u5E++G,3LL,HJI$$Wi8 &  'u%& #(+/  ||G$8$89=9<%> ? /G /   -gt,- MM',,WgtyyIJT"(($**dCEwu#||T^^= NN5!##E*'& &/s   8#F%07F2%F/N)rq   rr   rs   ro  r  r#  rp   s   rC   NdIndexIterr7    s    		H,	+rE   r=  )rp   r
   rw   )r  r=  rp   s     @rC   make_ndindex_clsr>    s.    
 ==D5+g11(; 5+n rE   c                     dv sJ | j                   }|j                  dk(  r" G fddt        j                  |             }|S  G fddt        j                  |             }|S )N)r  r  r   c                   2    e Zd ZdZ fdZ fdZd Zd Zy)6_make_flattening_iter_cls.<locals>.CContiguousFlatIterzZ
            .flat() / .ndenumerate() implementation for C-contiguous arrays.
            c                    |j                  t        j                  d      }t        j                  ||      | _        |j                  | _        	dk(  rt        j                  ||j                  |j                  t        j                  |j                              }t        |j                        D ]+  }t        j                  |||      }|j                  ||       - || _        y y )Nr   r  r}  )r   r   r   r
   r   r   r   r  rW   r9   rp   r8   rh   r  r   )
rY   r}   r=   r  r  r   r   rt  r  rm  s
            rC   r  zD_make_flattening_iter_cls.<locals>.CContiguousFlatIter.init_specific  s    ++EJJ:$66wE
 "ll=(%11$11%**ejjIKG  %UZZ0 4!(!5!5gw!LdF34 $+DL )rE   c                 $   |j                   }|j                  }|j                  | j                        }|j	                  d||      }	|j                  |	       t        j                  ||	      5  |j                  |j                  |g      }
t        ||||
      }dk(  r|j                  |       n| j                  }t        |      D cg c](  }|j                  t        j                  |||            * }}t        j                  ||      }|j                  t        j                   |||g             t#        |||||       t        j$                  ||      }|j'                  || j                         d d d        y c c}w # 1 sw Y   y xY w)Nr  r  )rp   r   r>   r   r	  r
  r
   r  r  r   r   r  r   r8   rh   rj   make_anonymous_structr  r  r  )rY   r}   r=   r  r  r  rp   r   r   r  rk   r  r   rt  idxvalsidxtuplerm  s                   rC   r#  zH_make_flattening_iter_cls.<locals>.CContiguousFlatIter.iternext_specific  sv   zzTZZ0"..sE6B  *&&w9 5!++chh8C%gwsCEv~e, #',, /4Dk#; (+ $+<<0D0DWELEH1J $K #; #; $+#5#5gw#G#99';CU:KMN 1'514g? $33GUCEMM%4)5 5#;5 5s    /AF-F8B FFFc                 X    |j                  |j                  |g      }t        ||||      S r;  )r  r   r   rY   r}   r=   r  r  r   rk   s          rC   r  z>_make_flattening_iter_cls.<locals>.CContiguousFlatIter.getitem4  s)    kk#((UG4 '5#>>rE   c                 \    |j                  |j                  |g      }t        |||||       y r;  )r  r   r   rY   r}   r=   r  r  r   r  rk   s           rC   setitemz>_make_flattening_iter_cls.<locals>.CContiguousFlatIter.setitem8  s(    kk#((UG47GUE3?rE   N)rq   rr   rs   ro  r  r#  r  rK  rm  s   rC   CContiguousFlatIterrA    s    +25<?@rE   rM  c                   4    e Zd ZdZd Z fdZd Zd Zd Zy)+_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                    |j                  t        j                  d      }|j                  }|j                  }t        j                  ||j                  |      }t        j                  ||j                  |j                  t        j                  |j                              }	t        j                  ||j                  |j                  t        j                  |j                              }
t        j                  |t
        j                        }t        |      D ]  }t        j                  ||	|      }t        j                  ||
|      }|j                  ||       |j                  ||       ||   }|j                  d||      }t        j                   ||      5  |j                  t
        j"                  |       d d d         |	| _        |
| _        || _        y # 1 sw Y   xY wr9  )r   r   r   r   rp   r
   r   re   rW   r9   r   r  r8   rh   r  r  r  r  r   pointersr  )rY   r}   r=   r  r  r   r   rp   r   r   rQ  r  rt  r  ptrptrr  r:  s                    rC   r  z9_make_flattening_iter_cls.<locals>.FlatIter.init_specificG  s   ++EJJ:xxzz --gsyy$G!--TYYW-A-A%**BG**.NO #..TYYW-A-A%**BG**.NO $55g6=6H6HJ	 !; DC$11'7CHF$11'8SIFMM$/MM$/  &c{H#*#8#8x#NL ,,WlC Dg&7&7CD DD  ' (!*D Ds    !G!!G*	c           
      H   |j                   }t        j                  ||j                  |      }t        j                  ||j                  |      }| j
                  }	| j                  }
|j                  t        j                  d      }|j                  d      }t        j                  ||j                  | j                              }t        j                  ||      5  |j                  d       |j!                  |       d d d        |j                  d       t        j"                  ||
|dz
        }|j                  |      }t%        ||||      }dk(  r|j'                  |       nyt)        |      D cg c](  }|j                  t        j"                  ||	|            * }}t        j*                  ||      }|j'                  t        j,                  |||g             t/        t)        |            D ]>  }t        j"                  ||	|      }t        j0                  ||j                  |            }||   }||   }|j3                  d||      }t        j4                  ||      5  |j7                  ||       t        j"                  ||
|      }|j                  |      }t        j8                  |||      }|j7                  ||       t)        |dz   |      D ]+  }t        j"                  ||
|      }|j7                  ||       - |j!                  |       d d d        |j7                  ||       A |j7                  t        j:                  | j                         |j!                  |       |j=                  |       y # 1 sw Y   xY wc c}w # 1 sw Y   }xY w)Nr   r	  FTrG   r  r  )rp   r
   r   re   r   r   rQ  r   r   r   rx  r  r>   r  r  r
  r  rh   r   r  r8   rj   rD  r  r  r	  r  r  r   r  r  )rY   r}   r=   r  r  r  rp   r   r   r   rQ  r   r  is_exhaustedlast_ptrrk   r  rt  rE  rF  r  r   r   r  r  rR  	inner_dimrm  s                              rC   r#  z=_make_flattening_iter_cls.<locals>.FlatIter.iternext_specifich  s7   zz --gsyy$G!..wTJ,,==++EJJ:2259  '22W\\$..9 ;((,? *$$U+NN5)*   & #//4!8Lll8,!'7E3?6>MM%( +0+7 $'  '||G,@,@AHAD-F  G 7G 7  '11'7CHMM55g7?6GIJ $E$K0 0C$11'7CHF!11'29,,v2FHC #3KE$S\F ' 3 3Ce DI **7I> .c62!(!5!5gx!M%ll62%11'3Gc62).sQw)= 7I%,%9%9':B:C&EF $MM#v6	7
  u-. MM$//04 g//@u%''.k* *7&. .s   #N7-N*B2NNN!	c           	         |j                   }t        j                  ||j                  |      }t        j                  ||j                  |      }g }	t        t        |            D ];  }
|	j                  |j                  |||
                |j                  |||
         }= |	j                          t        j                  |||j                  |||j                  |	      }|S )Nr   )rp   r
   r   re   r   r  r8   ri   uremudivreverser  r   r  )rY   r}   r=   r  r  r   rp   r   r   r   rt  rk   s               rC   _ptr_for_indexz:_make_flattening_iter_cls.<locals>.FlatIter._ptr_for_index  s    zz --gsyyM!..w4P #E$K0 =CNN7<<vc{#CD#LLs<E= !//#((06079 
rE   c                 H    | j                  |||||      }t        ||||      S r;  )r[  r   rH  s          rC   r  z3_make_flattening_iter_cls.<locals>.FlatIter.getitem  s+    ))'7E3N '5#>>rE   c                 L    | j                  |||||      }t        |||||       y r;  )r[  r   rJ  s           rC   rK  z3_make_flattening_iter_cls.<locals>.FlatIter.setitem  s*    ))'7E3N7GUE3?rE   N)	rq   rr   rs   ro  r  r#  r[  r  rK  rL  s   rC   FlatIterrO  ?  s%    +BC/J"?@rE   r^  )rb   r  r
   rw   )r  rm  rb   rM  r^  s    `   rC   r  r    sr    ****&&JCB	@'"="=j"I B	@H #"E	@w22:> E	@N rE   r  c                 >   t        t        j                  |            } || |      }||_        | j	                  |      } || ||j                  d            }|j                  | |||       |j                         }t        | |t        j                  |      |      S Nr   )rZ   )	r  r   NumpyFlatTyper   rx   rg   r  r   r!   )r}   r=   r  r  flatiterclsflatiterarrclsr   s           rC   make_array_flatiterre    s    %e&9&9%&@AK7G,HHN&F
'x'@'@'I
JC7GUC8



CWgu/B/B5/I3OOrE   c                     |j                   \  }|\  }t        |      } || ||      }|j                  }| j                  |      }	 |	| ||j                        }
|j                  | |||
|       y r7  )r   r  rb   rx   r   r#  )r}   r=   r[   r   r  r  rc  rb  r  rd  r  s              rC   iternext_numpy_flatiterrg    sq     88LZJX%j1K7G8<H!!E&F
'
8CwVDrE   c                    |j                   d   }|\  }}t        |      } || ||      }|j                  }| j                  |      }	 |	| ||j                        }
|j                  | |||
|      }t        | ||j                  |      S Nr   r  )r   r  rb   rx   r   r  r!   r   )r}   r=   r[   r   r  rc  r   rb  r  rd  r  r   s               rC   iternext_numpy_getitemrj    s    !JOHe%j1K7G8<H!!E&F
'
8C


7GUC
?CWgsDDrE   c                    |j                   d   }|\  }}}t        |      } || ||      }|j                  }	| j                  |	      }
 |
| ||j                        }|j                  | ||	|||       | j                         S ri  )r   r  rb   rx   r   rK  r\  )r}   r=   r[   r   r  rc  r   r  rb  r  rd  r  s               rC   iternext_numpy_getitem_anyrl    s     !J!HeU%j1K7G8<H!!E&F
'
8CWguc5%@""$$rE   c                     |j                   d   }t        |      } || ||d         }| j                  |j                        } || ||j                        }|j
                  S ri  )r   r  rx   rb   r   r   )	r}   r=   r[   r   r  rb  rc  rd  r  s	            rC   iternext_numpy_getitem_flatrn  
  s]    !J%j1K7G47;H
 5 56F
'
8C::rE   c                 P   |j                   \  }|\  }t        t        j                  |            } || |      }||_        | j                  |      } || ||j                  d            }|j                  | |||       |j                         }	t        | ||j                  |	      S r`  )r   r  r   NumpyNdEnumerateTyper   rx   rg   r  r   r!   r   )
r}   r=   r[   r   r  r  	nditerclsr  rd  r   s
             rC   make_array_ndenumeraterr    s    XXFEDC*5+E+Ee+LMIw(FFL&F
'v'>'>w'G
HC
'5#6



CWgsDDrE   c                     |j                   \  }|\  }t        |      } || ||      }|j                  }| j                  |      }	 |	| ||j                        }
|j                  | |||
|       y r7  )r   r  rb   rx   r   r#  )r}   r=   r[   r   r  r  r  rq  r  rd  r  s              rC   iternext_numpy_nditerrt  '  sq     JXHV*84Iwv6FE&F
'
6C
Wguc6BrE   c           
      t   t        |j                  |      D cg c]'  \  }}| j                  |||t        j                        ) }}}t        t        j                  t        |                  } || |      }|j                  | ||       |j                         }	t        | ||j                  |	      S c c}}w )zndindex(*shape))r   r   r   r   r   r>  NumpyNdIndexTyper   r  r   r!   r   )
r}   r=   r[   r   argtyr  re   rq  r  r   s
             rC   make_array_ndindexrx  7  s    
  #388T24 \\'3uzz: 4E 4 !!7!7E
!CDIw(F
'51



CWgsDD4s   ,B4c           	         |j                   j                  }|dkD  re|j                  d   j                  }|d   }t	        j
                  |||      }|D cg c]$  }| j                  |||t        j                        & }}ng }t        t        j                  t        |                  }	 |	| |      }
|
j                  | ||       |
j                         }t        | ||j                   |      S c c}w )zndindex(shape)r   )r   rp   r   r{   r
   r   r   r   r   r>  rv  r   r  r   r!   )r}   r=   r[   r   rp   r   rD  re   r   rq  r  r   s               rC   make_array_ndindex_tuplerz  F  s     ??Dax!!1g$$Wc48!# gsE5::> # #  !7!7E
!CDIw(F
'51



CWgsDD#s   )C.c                 z    |j                   \  }|\  }t        |      } || ||      }|j                  | ||       y r7  )r   r>  r#  )r}   r=   r[   r   r  r  r  rq  s           rC   iternext_numpy_ndindexr|  ]  s@     JXHV *Iwv6F
Wgv6rE   c                 H   |j                   }|j                  }t        |j                  d   t        j
                        rt        j                  ||d         }n|d   g} t        |      | |      }|j                  | |||       |j                         }t        | |||      S )z
    nditer(...)
    r   )r   r  r   r   r   rG  r
   r   r4  r  r   r!   )	r}   r=   r[   r   r  r  r  r  r   s	            rC   make_array_nditerr~  i  s    
 H__F#((1+u/%%gtAw7q'&_X&w8F
'66:



CWgx==rE   c                 v    |j                   \  }|\  } t        |      | ||      }|j                  | ||       y r7  )r   r4  r#  )r}   r=   r[   r   r  r  r  s          rC   iternext_numpy_nditer2r  }  s=     JXHV&_X&wvFF
Wgv6rE   c                     |j                   \  }}t        j                  t        j                  d      t	        ||k(              }t        | ||j                  |      S r  )r   r   r   r[  r   r#   r   )r}   r=   r[   r   arg1arg2r   s          rC   dtype_eq_implr    sE    JD$
++bjjmS%6
7CgwEErE   c                    t        |      } || |      }| j                  |j                        }| j                  t        j
                  t        | |            }| j                  t        j
                  d      }t        t        j                  d      d      }	|D ]H  }
|j                  ||
      }|j                  |d      }|j                  |	|j                  |d            }	J |j                  dk(  rd}n|j                  dk(  rO|g}t        |dd       D ]&  }|j!                  |j#                  |d   |             ( t%        t        |            }np|j                  dk(  r=|g}|dd D ]&  }|j!                  |j#                  |d   |             ( t%        |      }n$t'        dj)                  |j                              |j                  ||      }|j                  |d      }|j                  |	|j                  |d            }	|j+                  |	d	
      5  | j,                  j/                  |t0        d       ddd       |j                  }| j3                  |      }| j                  t        j4                  |      }| j7                         ||f}t	        j8                  t        j:                        }t	        j<                  t?        |            }tA        ||t        j
                  t        j4                        }| jC                  |tD        ||      }| jF                  jI                  ||      }| jK                  t        j
                        }tM        jN                  |||      }tM        jN                  |||      }tQ        ||jS                  ||jU                               ||||       |S # 1 sw Y   yxY w)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.
    rG   r   rp  r   Nr  r  z3Don't know how to allocate array with layout '{0}'.FrT  )z[array is too big; `arr.size * arr.dtype.itemsize` is larger than the maximum possible size.)r>  r  )+rx   rz   r{   r   r   r   r   r   r   r[  smul_with_overflowrN  r  rp   r  r  ri   r   r   rR   r   r  rV  rW  r   get_preferred_array_alignmentuint32r\  MemInfoPointervoidptrTypeRefr9   r%   r  _call_allocatorr   meminfo_datar   r
   rj   r   r)  r  )r}   r=   rL  r   r  r   datatyper   arrlenoverflowr   arrlen_multr   dimension_sizeallocsize_multr0  r{   	align_valr   r   miparytypeclassargtypesr   r   r   shape_arraystrides_arrays                               rC   r  r    sO     F
'
"C$$W]]3H##EJJWg0NOH !!%**a0F

1q)H 
00;&&{A6;;g++K;

 ||q	3	*&vabz2 	ENNN7;;wr{NCD	E)*	3	*$Sbk 	ENNN7;;wr{NCD	E.!AHH ! 	!
 //AN%%na8I{{8W%:%:>1%MNH	%	0 
 	))Z-	

 MME55e<I  y9E##%y%8D


u}}
-C==g/LlEJJEH&&w4PG;;##GW5D##EJJ/F$$Wf@K&&wFCM3h.A.A.CD$($"$ JA
 
s   "N88O	_allocatec                     d }|S )zTImplements a Numba-only default target (cpu) classmethod on the array
    type.
    c                     t        ||      S r;  )intrin_alloc)clsr0  r   s      rC   r   z _ol_array_allocate.<locals>.impl  s    Iu--rE   rp  )r  r0  r   r   s       rC   _ol_array_allocater    s    
.KrE   c                 &    | j                  ||      S )z9Trampoline to call the intrinsic used for allocation
    )r  )rL  r   r   s      rC   r  r    s     T5))rE   c                 p    d }t        j                  t         j                        }t        |||      }||fS )z3Intrinsic to call into the allocator for Array
    c                 J    |\  }}| j                   j                  |||      }|S r;  )r   meminfo_alloc_aligned)r}   r=   r%   r   r0  r   r   s          rC   rU  zintrin_alloc.<locals>.codegen  s)    !E++33GYNrE   )r   r  r  r%   )rV  r0  r   rU  r  r[   s         rC   r  r    s5    
 

u}}
-C
CE
*C<rE   c           	         d }t        |t        j                        r&d}| j                  |||t        j                        g}n@t        |t        j
                        sJ |j                  }t        j                  |||      }g }|D ]&  }|j                   || ||j                  |             ( | j                  |t        j                  d      }	t        |      D ]X  }
|j                  d||
   |	      }t        j                  ||      5  | j                  j!                  |t"        d       ddd       Z |S # 1 sw Y   fxY w)z;
    Parse the shape argument to an array constructor.
    c                    | j                  t        j                        }|j                  }t	        j
                  |      }t        |d|dz
  z  dz
        }|j                  |k  r|j                  ||      }|S |j                  |k\  ru|j                  d||      }	|j                  |	d      5  | j                  j                  |t        d       ddd       |j                  |kD  r|j                  ||      }|S |}S # 1 sw Y   0xY w)z0Cast src to intp only if value can be maintainedrG   >FrT  )z#Cannot safely convert value to intpN)r   r   r   rH   r   r[  r   sextr	  r  rV  rW  r   trunc)
r}   r=   src_tr/  r   
intp_widthintp_irmaxvalr   	is_largers
             rC   safecast_intpz#_parse_shape.<locals>.safecast_intp  s    ''

3\\
**Z('Q*q.%8A$=?;;#,,sG,C 
 [[J&++Cf=I59 !!11Z<
 {{Z'mmC1 
 
 s   ."C??DrG   r   r   r  )znegative dimensions not allowedN)r   r   r   r   r   rG  r   r
   r   ri   r9   get_constant_genericr8   r	  r  rV  rW  r   )r}   r=   r>  r   r  rp   passed_shapesr   r   r   rt  is_negs               rC   _parse_shaper    s+   * "emm$ gsB

CD"eoo...xx,,WcFF BmGWaffa@AB ''Q?DT{ $$S&+t<  &1 	--%I	 	 M	 	s   "D::E	c                 b    |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  )r}   r=   r[   r   arrshapetypearrshaperL  s          rC   _parse_empty_argsr  .  s9     88A;LAwHooGL'<JJJrE   c                    |j                   d   }t        |t        j                        rQ t	        |      | ||d         }t        j                  ||j                  |j                        }|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   rp  )
r   r   r   r   rx   r
   r   re   rp   r   )r}   r=   r[   r   arytyper   r   s          rC   rT  rT  8  sr    
 hhqkG'5;;'!j!'7$q'B%%gsyyM&&""rE   c                 n    t        |t        j                        rd|  d}t        j                  |      y )NzIf np.z0 dtype is a string it must be a string constant.)r   r   UnicodeTyper	   r   )fnamer{   r   s      rC   _check_const_str_dtyper  F  s7    %**+ugMN  %% ,rE   c                 <    |j                   } ||||      }d }||fS )Nc                 `    t        | |||      \  }}t        | |||      }|j                         S r;  )r  r  r   r  r=   r[   r  rL  r   r   s          rC   rU  znumpy_empty_nd.<locals>.codegenQ  s2    +E7CHUGWf=}}rE   instance_type)r  ty_shapety_dtypety_retty_refty_rettyr[   rU  s          rC   numpy_empty_ndr  L  s,    ))H
8X|
4C <rE   c                 v   t        d|       |t        u s7t        |t        j                        r|j
                  t        u st        |      rt        j                  }nt        |      }t        |       }|'|%t        j                  ||d      t        ffd	}|S d|  d| d}t        j                  |      )Nr  r   r  c                     t        | |      S r;  )r  )re   r{   rF  s     rC   r   zol_np_empty.<locals>.implf  s    !%66rE   z.Cannot parse input types to function np.empty(r  r  )r  floatr   r   Function
typing_keyr   doublety_parse_dtypety_parse_shaper   r	   r   )re   r{   nb_dtyperp   r   r   rF  s         @rC   ol_np_emptyr  X  s    7E*	E5>>	*u/?/?5/H<<!%(% D 0(cB# 	7>ugRwaP  %%rE   c                 <    |j                   } ||||      }d }||fS )Nc                 `    t        | |||      \  }}t        | |||      }|j                         S r;  )rT  r  r   r  s          rC   rU  z$numpy_empty_like_nd.<locals>.codegens  s2    0fMUGWf=}}rE   r  )r  ty_prototyper  r  r  r[   rU  s          rC   numpy_empty_like_ndr  n  s,    ))H
<<
8C <rE   c                    t        d|       t        |      st        |      }n)t        | t        j
                        r| j                  }n| }|dt        | t        j
                        r2| j                  dk7  r| j                  nd}| j                  ||d      n6t	        j
                  |dd      nd|  d| d	}t        j                  |      dfd
	}|S )Nr  rI  r   F)r{   r  rQ  r   z3Cannot parse input types to function np.empty_like(r  r  c                     t        | |      S r;  )r  )r  r{   rF  s     rC   r   zol_np_empty_like.<locals>.impl  s    "3u55rE   r;  )r  r   r  r   r   r   r{   r  rK  r	   r   )r  r{   r  r  r   r   rF  s         @rC   ol_np_empty_liker  z  s    </u!%(	C	%99c5;;'#&::#4SZZ#FHH8FUHKEKK!S1E  #uBugQ0  %%6KrE   c                 :    t        j                  |      }d }||fS )Nc                      t        |j                  d         | ||d         }t        j                  ||j                  |j                  |j                  |j                        d       y r   )rx   r   r
   rU  r   r   r   r   )r  r=   r[   r  r   s        rC   rU  z(_zero_fill_array_method.<locals>.codegen  sO    %j!%eWfQi@w'++cllCJJ*O	rE   )r   r  )r  rY   r[   rU  s       rC   _zero_fill_array_methodr    s!    
**T
C <rE   
_zero_fillc                     d }|S )z?Adds a `._zero_fill` method to zero fill an array using memset.c                     t        |        y r;  )r  ra  s    rC   r   z ol_array_zero_fill.<locals>.impl  s
    %rE   rp  )rY   r   s     rC   ol_array_zero_fillr    s    &KrE   c                 0    t        d|       t        fd}|S )Nr[  c                 T    t        j                  | |      }|j                          |S Nr  )ri  r  r  )re   r{   r  s      rC   r   zol_np_zeros.<locals>.impl  s!    hhuE*
rE   )r  r  re   r{   r   s      rC   ol_np_zerosr    s    7E*  KrE   c                 &    t        d|       dd}|S )N
zeros_likec                 T    t        j                  | |      }|j                          |S r  )ri  r  r  )r  r{   r  s      rC   r   zol_np_zeros_like.<locals>.impl  s!    mmAU+
rE   r;  r  r  s      rC   ol_np_zeros_liker    s    </ KrE   c                 &    t        d|       dd}|S )N	ones_likec                     t        j                  | |      }|j                  }t        t	        |            D ]  }d||<   	 |S Nr  rG   ri  r  r  r8   r   )r  r{   r  arr_flatr   s        rC   r   zol_np_ones_like.<locals>.impl  sA    mmAU+88X' 	CHSM	
rE   r;  r  r  s      rC   ol_np_ones_liker    s    ;. KrE   c                 ^    t        d|       t        |      st        |      n|dfd	}|S )Nfullc                     t        j                  |       }|j                  }t        t	        |            D ]  }|||<   	 |S r;  ri  r  r  r8   r   )re   
fill_valuer{   r  r  r   r  s         rC   r  zimpl_np_full.<locals>.full  sB    hhuh'88X' 	'C&HSM	'
rE   r;  )r  r   r  )re   r  r{   r  r  s       @rC   impl_np_fullr    s0    65)u!%( KrE   c                 &    t        d|       dd}|S )Nr  c                     t        j                  | |      }|j                  }t        t	        |            D ]  }|||<   	 |S r;  r  )r  r  r{   r  r  r   s         rC   r  z$impl_np_full_like.<locals>.full_like  sA    mmAu%88X' 	'C&HSM	'
rE   r;  r  )r  r  r{   r  s       rC   impl_np_full_liker    s    ;. rE   c                 &    t        d|       dd}|S )Nonesc                     t        j                  | |      }|j                  }t        t	        |            D ]  }d||<   	 |S r  r  )re   r{   r  r  r   s        rC   r   zol_np_ones.<locals>.impl  sA    hhuE*88X' 	CHSM	
rE   r;  r  r  s      rC   
ol_np_onesr    s     65) KrE   c                 z    t        d|       t        |      st        |      nt        j                  dfd	}|S )Nidentityc                 f    t        j                  | | f      }t        |       D ]	  }d|||f<    |S r  )ri  r[  r8   )r  r{   r  rm   r  s       rC   r  z"impl_np_identity.<locals>.identity  s<    hh1vx(q 	AC1I	
rE   r;  )r  r   r  r   r  )r  r{   r  r  s      @rC   impl_np_identityr     s4    :u-u!%(<<
 OrE   c                      y r;  rp  NMs     rC   _eye_none_handlerr  	  r  rE   c                 J    t        |t        j                        rd }|S d }|S )Nc                     | S r;  rp  r  s     rC   r   z$_eye_none_handler_impl.<locals>.impl      HrE   c                     |S r;  rp  r  s     rC   r   z$_eye_none_handler_impl.<locals>.impl  r  rE   )r   r   r  )r  r  r   s      rC   _eye_none_handler_implr
    s&    !U^^$	
 K	KrE   c                 :   |t        |t        j                        rt        j                  t
              nVt        |t        j                  t        j                  f      rt        t        |d|            nt        j                  |      d dt
        ffd	}|S )Nr{   r   c                    t        | |      }t        j                  | |f      }|dk\  r+t        | ||z
        }t	        |      D ]  }d||||z   f<    |S t        | |z   |      }t	        |      D ]  }d|||z
  |f<    |S r  )r  ri  r[  r  r8   )	r  r  r   r{   _Mr  drm   r  s	           rC   r   znumpy_eye.<locals>.impl#  s    q!$hh2w#6ArAvA1X " !Aq1uH" 
 AE2A1X " !AE1H"
rE   )
r   r   r  ri  r{   r  	DTypeSpecr  r   r  )r  r  r   r{   r   r  s        @rC   	numpy_eyer    sn     }
5%..9XXe_	EEOOU\\:	;geWe45XXe_!5  KrE   c                     t        |       st        j                  d      t        | t        j
                        r)| j                  dvrt        j                  d      dd}|S y )N#The argument "v" must be array-like)rG   rZ  zInput must be 1- or 2-d.c                 h   | j                   dk(  r| j                  }|d   t        |      z   }t        j                  ||f| j
                        }|dk\  r"t        ||z
        D ]  }| |   ||||z   f<    |S t        ||z         D ]  }| |   |||z
  |f<    |S | j                  \  }}|dk  r||z   }|dkD  r||z
  }t        t        ||      d      }t        j                  || j
                        }|dk\  rt        |      D ]  }| |||z   f   ||<    |S t        |      D ]  }| ||z
  |f   ||<    |S r  )
rp   re   r  ri  r[  r{   r8   r  r  r  )r   r   r   r  rW  rm   rowscolss           rC   	diag_implzimpl_np_diag.<locals>.diag_impl;  sd   vv{GGaD3q6Mhh1vqww/6"1q5\ -()!Aq1uH-
 
 #1q5\ -()!AE1H-
WW
dq5!8Dq5!8DD$+hhq!''*6"1X -!"1a!e8A-
 
 #1X -!"1q5!8A-
rE   r  )r   r	   r   r   r   r   rp   NumbaTypeError)r   r   r  s      rC   impl_np_diagr  2  sZ    A  !FGG!U[[!66''(BCC	6 ? "rE   c                    t        | t        j                        sd}t        j                  |      t        | j
                  t        j                        sd}t        j                  |      t        |       dz  fd}|S )Nz5The argument "dimensions" must be a tuple of integersr  c                     t        j                  f| z   t         j                        }d}| D ]K  }t        j                  |t         j                        j	                  t        ||            }|||<   |dz  }M |S )Nr  r   rG   )ri  r  r  arangerR  r/   )
dimensionsr   rm   rt  r   r  re   s        rC   r   znumpy_indices.<locals>.implf  sx    hhtj(9 	C))Crxx088eQ,C CFFA	 
rE   )r   r   rr  r	   r   r{   r   r   )r  r   r   r  re   s      @@rC   numpy_indicesr  Y  so    j%..1E  %%j&&6E  %%JA1HE
 KrE   c                     t        |       sd}t        j                  |      t        |t        t
        j                  f      sd}t        j                  |      dd}|S )Nr  z#The argument "k" must be an integerc                 d   t        j                  |       } | j                         } t        |       }t	        |      }||z   }t        j
                  ||f| j                        }t        j                  d|       }t        j                  d|      }t        |      D ]  }| |   |||z   ||z   f<    |S r   )	ri  rj  rZ  r   r  r[  r{   maximumr8   )	r   r   r   abs_kr  r   rm   jts	            rC   r   znumpy_diagflat.<locals>.impl  s    JJqMGGIFAIhh1vqww'JJq1"JJq!q 	%A !!CAq1u	% 
rE   r  )r   r	   r   r   r   r   r   )r   r   r   r   s       rC   numpy_diagflatr$  u  sU    A3  %%a#u}}-.3  %% KrE   c                 n   |dv sJ |dk(  r4d}t        d|       D ]"  }d|z  }|d| ddj                  |       d	z  }$ n3d
}t        d|       D ]"  }d|z  }|d| ddj                  |       dz  }$ t        j                  |      }t	        |t                      t               d|    }t        |      S )N)r  rK  r  zv
            def _getitem(a, idx, axis):
                if axis == 0:
                    return a[idx, ...]
        rG   ):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   r  textwrapdedentexecglobalsr'   )rp   rm  r9  rm   lsts        rC   "generate_getitem_setitem_with_axisr,    s   ))))y
 q$ 	A1*C S !"iin- . B	 q$ 	A1*C S !yy~& ' B	 
	BWY	Qtf:	BBrE   takec                   	 t        j                  |      rt        | t        j                        r t        |t        j
                        rdd}|S t        | t        j                        r1t        |t        j                        r|j                  dk(  dfd	}|S t        | t        j                        r1t        |t        j                  t        j                  f      rdd}|S y y t        | t        j                        rBt        |t        j
                        r(d| j                  dz
  z  	t        	fd       dfd	}|S t        | t        j                        rgt        |t        j                  t        j                  t        j                  f      r-| j                  }t        |d	      t        |d
      dfd	}|S y y )Nc                     || j                   dz
  kD  s|| j                    k  rt        d      | j                         |   S )NrG   Index out of bounds)r   
IndexErrorrZ  )r  r   r   s      rC   	take_implznumpy_take.<locals>.take_impl  s<    affqj)Ww->$%:;;wwy))rE   r  c                    t        j                  |j                  | j                        }	r|j	                         }n|}t        j
                  |      }d}| j                         }|D ]<  }|| j                  dz
  kD  s|| j                   k  rt        d      ||   ||<   |dz   }> |j                  |j                        S )Nr  r   rG   r0  )
ri  r  r   r{   rK  r  rZ  r1  rR  re   )
r  r   r   rW  walkeritrm   r  rC  F_orders
            rC   r2  znumpy_take.<locals>.take_impl  s    hhw||177;$\\^F$FYYv&wwy AAFFQJ'1w;()>??!!WCFAA	
 {{7==11rE   c                 X    t        j                  |      }t        j                  | |      S r;  )ri  r   r-  )r  r   r   converts       rC   r2  znumpy_take.<locals>.take_impl  s!    ((7+wwq'**rE   r  rG   c                 J   t              }d}|t        | j                        k  r| j                  |   dk(  sJ | j                         t        t        | j                              D ])  }| j                  |   }||k7  st	        |||      }|dz  }+ | j                  |      S r  )r   r   re   r8   r/   rR  )r{  r   rD  r"  r   r   r#  s         rC   _squeezeznumpy_take.<locals>._squeeze  s    Ahc!''l*qwwt}/AJ177JA QWW. CAd{+CA6Q	
 yy~%rE   c                     t        j                  | |f|      }| j                  dk(  r|d   S |dk  r|| j                  z  } ||      S )Nrj  rG   r   )ri  r-  rp   )r  r   r   r{  r:  s       rC   r2  znumpy_take.<locals>.take_impl  sL    GGAz566Q;Q4K!8AFFND4((rE   r  rK  c                 v   |dk  r|| j                   z  }|dk  s|| j                   k\  rd| d| j                    }t        |      t        | j                  |t	        |            }t        j                  || j                        }t        t	        |            D ]  } | ||   |      } 	||||        |S )Nr   zaxis z) is out of bounds for array of dimension r  )	rp   r   r/   re   r   ri  r  r{   r8   )
r  r   r   r   re   r   rm   rD  _getitem_setitems
           rC   r2  znumpy_take.<locals>.take_impl  s    !8AFFND!8tqvv~"4& )++,66(4C$S/)%aggtS\BhhuAGG4s7|, .A GAJ5AS!T1-. 
rE   r;  )r
   r   r   r   r   r   r  r  rG  rp   r'   r,  )
r  r   r   r2  rp   r6  r=  r>  r:  r#  s
        @@@@@rC   
numpy_taker?    sb    4 a%*Wemm*L* a%*Wekk*Jnn+G2 a%7UZZ$AB+ 	 C & a%*Wemm*L
#A
 	& 	&) a%7U[[%**eoo$NO66D9$	JH9$	JH - P &rE   c                     | D cg c]  }t        |t        j                        r|! }}t        d |D              rt        j                  }|S t        d |D              rt        j
                  }|S t        t        ddt        j                  t              j                  z  z        }|D cg c]  }t        j                  |       }}t        ||gz         }|S c c}w c c}w )Nc              3   P   K   | ]  }t        |t        j                           y wr;  r  r=  r  s     rC   r?  z _arange_dtype.<locals>.<genexpr>  s     
8A:a'
8r@  c              3   P   K   | ]  }t        |t        j                           y wr;  )r   r   FloatrB  s     rC   r?  z _arange_dtype.<locals>.<genexpr>  s     8AZ5;;'8r@  zint%sr  )r   r   r  rA  
complex128r   r  ri  r{   r   r   	unliteralr  )r   r  boundsr{   NPY_TYrC  unliteral_boundss          rC   _arange_dtyperJ    s    CAZ5>>%BaCFC

8
88  & L% 
88	8" L 1rxx}/E/E+E FG 9??1EOOA.??$y01L- D& @s   CC.C"c          	        	
 t        |t        j                        r|j                  }t        |t        j                        r|j                  }t        |t        j                        r|j                  }|t        j                  }|t        j                  }|t        j                  }t        | t        j
                        r~t        |t        j                  t        j
                  f      rTt        |t        j                  t        j
                  f      r*t        |t        j                  t        j                  f      sy t        |t        j                        rt        | ||      	n|j                  	t        | ||fD cg c]  }t        |t        j                         c}      
t        | dd       t        |dd       t        |dd       d	
fd	}|S c c}w )Nr   c                   n| }n|}n|}||nd}|d|}	}n||}	}|dk(  rt        d      |	|z
  |z  }
t        t        j                  |
j                              }du r?t        t        j                  |
j
                              }t        t        ||      d      }nt        |d      }t        j                  |      }|}t        |      D ]  }|||z  z   ||<    |S )NrG   r   zMaximum allowed size exceededT)r   r   mathceilr  r  r  r  ri  r  r8   )r  r  r  r{   	lit_startlit_stoplit_step_step_start_stopnitems_cnitems_rnitems_ir   r  r   rm   start_value
step_value
stop_value
true_dtypeuse_complexs                    rC   r   znp_arange.<locals>.implL  s   #.#:K	!+!7:T!+!7:T$0ayEF%xEFA:<==FNe+tyy/0 $499X]]34HXx0!4F1%Fhhvz*v 	'AAI&CF	'
rE   r  )r   r   Optionalr9   r  r  r  r  rJ  r{   rA  r  r  )r  r  r  r{   rC  r   rX  rY  rZ  r[  r\  s         @@@@@rC   	np_aranger^  )  sb   $'yy$'yy%(

|zz|zz}

uell+tennell;<tennell;<55>>5??"CD%("5$5
[[
!&d 35 "!U]]3 5 6K %$7K5J5J < KK5s   !G"c                 X   t        d | |fD              sy t        |t        t        j                  f      sd}t        j                  |      t        d | |fD              r2t        j                  rt        j                  n!t        j                  nt        j                  dfd	}|S )Nc              3   P   K   | ]  }t        |t        j                           y wr;  )r   r   r  r  s     rC   r?  z!numpy_linspace.<locals>.<genexpr>o  s     Fz#u||,Fr@  r  c              3   P   K   | ]  }t        |t        j                           y wr;  r  r  s     rC   r?  z!numpy_linspace.<locals>.<genexpr>v  r  r@  c                     t        j                  |      }| dz  } |dz  }|dk(  r|S |dz
  }|dkD  r8|| z
  }t        j                  ||      }t        d|      D ]  }| ||z  z   ||<    n| |d<   |dkD  r||d<   |S )Ng      ?r   rG   r  )ri  r  divider8   )	r  r  r	  r  divdeltar  rm   r{   s	           rC   r  z numpy_linspace.<locals>.linspace  s    hhsE" cz!8JAg75LE99UC(D1c] ,!d(+A, CF7CG
rE   r
  )rt  r   r   r   r   r	   r   rA  r   USE_LEGACY_TYPE_SYSTEMrE  np_complex128r   )r  r  r	  r   r  r{   s        @rC   numpy_linspacerh  m  s    FFFcC/05  %%

CeT]
CC(($$E''E, OrE   c           
         |j                   d   } t        |      | ||d         }t        j                  ||j                        }|j
                  }t        | |||      }|j                  }	|j                  }
|j                  dv sJ |j                  |j                  k(  r0t        j                  ||
|	|j                  |j                  d       nt        j                  ||j                        }t        j                  ||j                        }| j                  t        j                        }t        j                   |||      5 }t        j"                  | ||	|||j                  |      }t        j"                  | ||
|||j                  |      }|j%                  |j'                  |      |       ddd       t)        | ||j
                  |j+                               S # 1 sw Y   /xY w)z
    Array copy.
    r   r  r   rG   r   N)r   rx   r
   r   re   r   r  r   r  
raw_memcpyr   r   r   r   r   r   r.  r  r  r>   r"   r   )r}   r=   r[   r   r  r   r   rettyperW  r"  r  r$  r  r   r   r  r1  s                    rC   _array_copyrl    s    hhqkG
*W
gwd1g
>C!!'3995FooG
'7F
;CxxHI>>T!!!~~'7Ix<<q	2 **7CKK@++GS[[A''

3w7 	;7//(0607IG 00'91718JH MM',,w/:	; GWcoos}}OO	; 	;s   A,G""G+c                     t        |t        j                        sJ |j                  dk(  rdnd}|j	                  |d      } ||      }|t
        fS )Nr  r   F)r  rQ  )r   r   r   r  rK  rl  )rV  r  r  rW  r[   s        rC   _array_copy_intrinsicrn    sM    a%%%HHOSF
&&&
/C
a&CrE   z
array.copyc                     t        | |||      S r;  )rl  r  s       rC   
array_copyrp    s    wd33rE   c                 @    t        | t        j                        rd }S )Nc                     t        |       S r;  )rn  rx  s    rC   
numpy_copyz#impl_numpy_copy.<locals>.numpy_copy  s    (++rE   r<  )r  rs  s     rC   impl_numpy_copyrt    s    !U[[!	,rE   c           	      D   |j                   }|j                  d   }|j                  |k(  sJ d       |j                  dk(  r|j                  dk(  sJ  t	        |      | ||d         } t	        |      | |      }| j                  |t        j                  t        j                  d      d      }	| j                  |t        j                  t        j                  d      |j                  f      }
t        ||j                  |	|
|j                  |j                  |j                         t        | |||j!                               S |j                  |j                  k(  s|j                  dk(  r|j                  dv rt        | |||d         S |j                  dk(  r|dv sJ |dk(  rt"        nt$        }t'        || |||d         }|j)                  |      5 \  }}|5  t        | |||d         }|j*                  }d	d	d	       |5  t-        | |||      }|j*                  }d	d	d	       d	d	d	       |j/                  j0                        }|j3                  |       |j3                         |S t-        | |||      S # 1 sw Y   xY w# 1 sw Y   lxY w# 1 sw Y   pxY w)
zd
    Common logic for layout conversion function;
    e.g. ascontiguousarray and asfortranarray
    r   z return-type has incorrect layoutrG   r  r  r   rI  r   N)r   r   r  rp   rx   r  r   rr  r   r  r   r   r   r   r   r!   r   r   r   rC  r  blockrl  phir9   add_incoming)r}   r=   r[   r   output_layoutrF  r   r   rW  re   r   
check_funcr"  thenorelseout_thenthen_blk
out_orelse
orelse_blkret_phis                       rC   _as_layout_arrayr    sq   
 OOEHHQKE<<=(L*LL(zzQzzQjQ@j1,,U^^EJJ2D
 $$W%*^^EJJ%B&)ll_6 	sCHHeWcll{{CJJ	0 '5#--/JJ
,,%,,
&

aELLD$8 '5$q'BB <<3 !D(((*73*>JJ.z/6/6/4/3Aw	8I
 + 	/~f -0'515a :H&}}H-
  /!,WgsD!IJ!(J/	/ kk(--0G  84  Z8N wd;;!- -
/ /	/ 	/s<   JI>:
JJ
J>J	J
J	JJc                     t        t        j                        st        j                        |j                  j                  t        |j                  d            } ||      }|fdfS )NrG   )r  rp   c                 8    t        | |||j                        S )N)ry  )r  r   )r  r  r   r  ry  s       rC   r  z,_as_layout_array_intrinsic.<locals>.<lambda>  s    #3	1a-"="=$? rE   )	r   r   r&   r	   RequireLiteralValuerK  r   r  rp   )rV  r  ry  rW  r[   s     `  rC   _as_layout_array_intrinsicr    sd    mU%8%89((77
&&33#affa.&
IC
a
C ? ? ?rE   c                     t        |       st        j                  d      t        | t        j
                  t        j                  f      rd }|S t        | t        j                        rd }S )NrX  c                 R    t        j                  t        j                  |             S r;  )ri  ascontiguousarrayr   rx  s    rC   r   z%array_ascontiguousarray.<locals>.impl&  s    ''44rE   c                     t        | d      S Nr   r  rx  s    rC   r   z%array_ascontiguousarray.<locals>.impl)      -a55rE   r   r	   r   r   r   r  r  r   r  s     rC   array_ascontiguousarrayr     sY    A  !FGG!ellEMM34	5
 K 
Au{{	#	6KrE   c                     t        |       st        j                  d      t        | t        j
                  t        j                  f      rd }|S t        | t        j                        rd }|S y )NrX  c                 R    t        j                  t        j                  |             S r;  )ri  asfortranarrayr   rx  s    rC   r   z"array_asfortranarray.<locals>.impl4  s    $$RXXa[11rE   c                     t        | d      S )Nr  r  rx  s    rC   r   z"array_asfortranarray.<locals>.impl8  r  rE   r  r  s     rC   array_asfortranarrayr  .  sZ    A  !FGG!ellEMM34	2	Au{{	#	6 
$rE   zarray.astypec           
      r   |j                   d   } t        |      | ||d         }t        j                  ||j                        }|j
                  }t        | |||      }|j                  }	|j                  }
t        j                  ||j                        }t        j                  ||j                        }| j                  t        j                        }t        j                  |||      5 }t        j                  | ||	|||j                  |      }t        j                  | ||
|||j                  |      }t        | |||      }| j!                  |||j"                  |j"                        }t%        | ||||       d d d        t'        | ||j
                  |j)                               S # 1 sw Y   /xY wri  )r   rx   r
   r   re   r   r  r   r   r   r   r   r.  r  r  r   r   r{   r   r"   r   )r}   r=   r[   r   r  r   r   rk  rW  r"  r  r$  r  r   r   r  r1  items                     rC   array_astyper  =  s{    hhqkG
*W
gwd1g
>C!!'3995FooG
'7F
;CxxHI&&w<K''=L##EJJ/F			7FF	3 	>w++GWh,2K,3NNGE ,,Wgy-3\-4^^WF '7G<||GT7=='--H7GWdH=	> GWcoos}}OO	> 	>s   /BF--F6c                 <    |j                   } ||||      }d }||fS )Nc           	         |j                   d   }|j                  } t        |      | ||d         }t        |      } || |      }|j                  }	t	        | |      }
t        |j                  j                  |
      }|j                  |j                  |j                        }|j                  ||      }t        j                  ||      }|j                  |d      5  d}| j                  j                  |t         |f       d d d        t        j"                  ||j%                  ||      g      }t        j"                  ||g      }|j'                  |j(                  | j+                  |	j-                  d                  }t/        ||||||j0                  |j2                         |j5                         }t7        | ||j                  |      S # 1 sw Y   xY w)Nr   r  FrT  z.buffer size must be a multiple of element sizer   r1  )r   r   rx   r   r   r   r   r9   r   r   sremr
   is_not_nullr  rV  rW  r   rj   sdivr)  r   r   r   r   r   r   r   r!   )r}   r=   r[   r   buftyr   r  
out_ary_tyout_aryout_datamodelr   ll_itemsizer  remis_incompatibler   re   r   r   r   s                       rC   rU  znp_frombuffer.<locals>.codegena  s   jQ@&
Wg.**/s||00(;SZZ6 ll6;/!--gs;___U_; 	KBC--gzC6J	K ""7W\\&+-N,OP$$W{m<HHg,,]-C-CF-KL
 	w "& +"{{!jj	+ ! '3??CHH'	K 	Ks    %GGr  )rV  bufferr{   rF  r>  r[   rU  s          rC   np_frombufferr  \  s.    			B
VUE
"C#IH <rE   c                    t        d|       t        | t        j                        r| j                  dk7  rd|  }t        j                  |      |t        u s7t        |t        j                        r|j                  t        u st        |      rt        j                  }nt        |      }|%t        j                  |dd| j                         nd|  d| d}t        j                  |      t        ffd		}|S )
N
frombufferr   z+Argument "buffer" must be buffer-like. Got rG   )r{   rp   r  rQ  z3Cannot parse input types to function np.frombuffer(r  r  c                     t        | |      S r;  )r  )r  r{   rF  s     rC   r   z impl_np_frombuffer.<locals>.impl  s    VUE22rE   )r  r   r   r   r  r	   r   r  r  r  r   r  r  r   r.  )r  r{   r   r  r   rF  s        @rC   impl_np_frombufferr    s    </fell+v}}/C;F8D  %%	E5>>	*u/?/?5/H<<!%((3)/%79  &xr%3  %%  3KrE   c                     t        |      rt        dd       dfd	}|S t        |t        j                        rt        d|      dfd	}|S y )Nr   c                      | |      S r;  rp  rk   re   r{   intrinsic_cfarrays      rC   r   zimpl_carray.<locals>.impl      $S%00rE   c                      | |      S r;  rp  r  s      rC   r   zimpl_carray.<locals>.impl  r  rE   r;  r   get_cfarray_intrinsicr   r   r  rk   re   r{   r   r  s       @rC   impl_carrayr    L    51#t<	1	E5??	+1#u=	1 
,rE   c                     t        |      rt        dd       dfd	}|S t        |t        j                        rt        d|      dfd	}|S y )Nr  c                      | |      S r;  rp  r  s      rC   r   zimpl_farray.<locals>.impl  r  rE   c                      | |      S r;  rp  r  s      rC   r   zimpl_farray.<locals>.impl  r  rE   r;  r  r  s       @rC   impl_farrayr    r  rE   c                 (     t          fd       }|S )Nc                 b   |t         j                  u rd }nBt        |t         j                        r|j                  }nd| d}t        j                  |      	|d}t        j                  |      |}nft        	t         j                        r1	j                  }|>||k7  r9d| d| d}t        j                  |      d	 d}t        j                  |      t        |      }|d| d}t        j                  |      t        j                  ||
      }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   CPointerr{   r	   r  r  r  r   r%   
np_cfarray)rV  rk   re   	ptr_dtyper   r{   rp   rF  r[   dtype_r  s            rC   r  z0get_cfarray_intrinsic.<locals>.intrinsic_cfarray  s1   %--IU^^,		I4SE;C'',,> B++C00E0LLE$));+E72Fse1M++C00(2C'',,e$<#E7!,C'',,E40sE*JrE   r*   )r  r  r  s   `` rC   r  r    s     > rE   c           
         |j                   dd \  }}|dd \  }}|j                  }|j                  dv sJ  t        |      | |      }	t	        | |      }
t        j                  |
      }t        |t        j                        rt        j                  ||      }n|f}|f}t        ||      D cg c]'  \  }}| j                  |||t        j                        ) }}}|}g }|j                  dk(  r+|D ]%  }|j                  |       |j                  ||      }' nCt!        |      D ]%  }|j                  |       |j                  ||      }' |j#                          |j%                  || j'                  |j(                        j+                               }t-        |	||||d       |	j/                         }t1        | ||j                  |      S c c}}w )zR
    numba.numpy_support.carray(...) and
    numba.numpy_support.farray(...).
    NrZ  r   r  r  )r   r   r  rx   r   r
   r   r   r   rG  r   r   r   r   ri   r   r  rZ  r)  rz   r{   r  r   r   r"   )r}   r=   r[   r   r!  r  rk   re   r   r  r   r  r   r:  r  offr   r   r   r   s                       rC   r  r    s   
 XXbq\NE7bqJCOOE<<4j1GGU+H..*K'5??+%%gu5*#&w#79&% ll7E65::> 9F 9 CG||s 	&ANN3++c1%C	& &! 	&ANN3++c1%C	& 	??3"00=HHJLD 7"' 


CGWcoosCC99s   0,Gc                 0   t        |t        j                        r)| j                  t        j                  t        |            S t        |t        j                        r8| j                  t
        t        t        j                  |            } |||f      S J r;  )	r   r   rG  r   r   r   r  rQ   r%   )r}   r=   seqtyseqr  s        rC   _get_seq_sizer    sj    %)##EJJE
;;	E5>>	*''Yuzz5-JK#((qrE   c                      |j                    j                  t        j                  t	        |t
        j                               fd}|S )zK
    Return a getitem() implementation that doesn't incref its result.
    c                 l     | |      }j                   rj                  j                  | |       |S r;  )r   r   decref)r=   r   rW  r}   r  rF  s      rC   wrapz$_get_borrowing_getitem.<locals>.wrap.  s3    7D)KKws3
rE   )r{   rQ   r  r  r%   r   r   )r}   r  r  r  rF  s   `  @@rC   _get_borrowing_getitemr  &  sC     KKE''(8(8(1%

(KML KrE   c           	      
     j                  t        j                        }t        |d       fd}g }||}	}t	        |      D ]0  }
|
dkD  r |||	      \  }}	|j                  t         ||	             2 t        |      S )zF
    Compute the likely shape of a nested sequence (possibly 0d).
    r   c                     t        | t        j                        r&t        |       dk(  ry| d   j	                  |d      fS t        |       }| j                   ||f      fS )Nr   NN)r   r   rG  r   rN  r  r{   )r  r  r  r=   r}   r   s      rC   get_first_itemz.compute_sequence_shape.<locals>.get_first_item>  sa    eU__-5zQ!Qx!6!6sA!>>>1'5AL;;WsDk BBBrE   )r   r   r   r   r8   ri   r  r   )r}   r=   rp   r  r  r   r  r   innertyinnerrm   r   s   ``         @rC   compute_sequence_shaper  7  s     ##EJJ/FFADC FCUG4[ Gq5+GU;NGUmGWguEFG
 =rE   c                 <      fd fd |||       y)z?
    Check the nested sequence matches the given *shapes*.
    c                  H    j                   j                   t        d       y )N)zincompatible sequence shape)rV  rW  r   )r=   r}   s   rC   _failz#check_sequence_shape.<locals>._failZ  s    ))':*J	LrE   c                    t        |      dk(  ry t        | |      }|d   }j                  d||      }j                  |d      5           d d d        t        |      dk(  ry t	        | t
        j                        rZt        |       }t        j                  |      5 }| j                  } |||j                  f      }	 ||	|dd         d d d        y t	        | t
        j                        r>t        t        |             D ]&  }
| |
   }j                  ||
      }	 ||	|dd         ( y J |        # 1 sw Y   xY w# 1 sw Y   y xY w)Nr   rS  FrT  rG   )r   r  r	  r  r   r   r  r  r
   r  r{   r   rG  r8   rN  )r  r  r   r   expectedrA  r  r  r  r  rm   r  r=   check_seq_sizer}   s              rC   r  z,check_sequence_shape.<locals>.check_seq_size^  sP   v;!Wguc:!9&&tT8<__Xe_4 	G	 v;!eU^^,1'5AL""7D1 ;T++$WsDJJ.?@wvabz:; ;
 u/3u:& ;(--c15wvabz:; eO1)	 	; ;s   
D<%/E<EENrp  )r}   r=   r  r  r   r  r  s   ``   @@rC   check_sequence_shaper  U  s    
L: 5#v&rE   c                 N    	  fd		 fd ||d       y)zl
    Assign a nested sequence contents to an array.  The shape must match
    the sequence's structure.
    c           
          t        j                  	j                  | d      }j                  ||j                        }t        ||       y r  )r
   r  r  r   r{   r   )
r   rJ  r   rk   r  r=   r}   r   r   r   s
       rC   assign_itemz-assign_sequence_to_array.<locals>.assign_item  sQ    ''$(-g%Qll7C<7GUC5rE   c                    t        |      dk(  r7t        | t        j                  t        j                  f      rJ  || |       y |d   }t        | t        j                        rit        |       }t        j                  |      5 }| j                  } |||j                  f      } |||dd  ||j                  fz          d d d        y t        | t        j                        rct        t        |             D ]K  }	| |	   }j                  ||	      }j                  t        j                  |	      }
 |||dd  ||
fz          M y J |        # 1 sw Y   y xY wr  )r   r   r   r  rG  r  r
   r  r{   r   r8   rN  r   r   )r  r  r   r   r   r  r  r  r  rm   r   assignr  r=   r}   s              rC   r  z(assign_sequence_to_array.<locals>.assign  sM   v;!!%%..%//)JKKK,ayeU^^,1'5AL""7D1 LT++$WsDJJ.?@wvabz7djj]3JKL L
 u/3u:& G(--c15,,UZZ;wvabz7eX3EF	G eO1L Ls   >EErp  Nrp  )
r}   r=   r   r   r   r  r  r  r  r  s
   ``````  @@rC   assign_sequence_to_arrayr  ~  s"    6 62 5#vr"rE   c                     t        | |      \  }}t        |      r|}nt        |      }|y t        j                  ||d      S r  )r4   r   r  r   r   )rV  r3  r{   rp   	seq_dtypes        rC   np_array_typerr    sD    ,Y?OD)5u%=;;udC((rE   c                 T    t        d|       t        | ||      } |||      }d }||fS )Nr   c           
      j   |j                   }|j                  }|j                  d   }|d   }t        | ||||      }t	        |      |k(  sJ t        | ||||       t        | |||      }	t        | ||	j                  ||	j                  |||       t        | ||j                   |	j                               S r   )r   rp   r   r  r   r  r  r  r   r   r"   r   )
r}   r=   r[   r   r  rp   r  r  r   r  s
             rC   rU  znp_array.<locals>.codegen  s    zz1g'$sK6{d"""Wguc6BWguf= '388V!$eUC	A  #// #1 	1rE   )r  r  )rV  objr{   rW  r[   rU  s         rC   np_arrayr    s6    7E*
C
/C
c5/C1" <rE   c                     t        d|       t        |       st        j                  d      t	        |      s"t        |      d}t        j                  |      dd}|S )Nr   z(The argument "object" must be array-likez:The argument "dtype" must be a data-type if it is providedc                     t        | |      S r;  )r  )r3  r{   s     rC   r   zimpl_np_array.<locals>.impl  s    &&rE   r;  )r  r   r	   r   r   r  )r3  r{   r   r   s       rC   impl_np_arrayr    s^    7E*F#   "1 2 	2u."7"?J  %%'KrE   c                    |j                  d      }|j                  |      }|j                  d||      }|j                  ||j                  ||      |      }|j	                  |j                  d||      |j                  d||            }|j                  |d      5  d|z  }	| j                  j                  |t        |	f       d d d        |S # 1 sw Y   |S xY w)Nr   r  r  FrT  z%s(): axis out of bounds)	r9   r	  r  r  r  r  rV  rW  r1  )
r}   r=   r   rp   r   r   ll_ndimis_neg_axisaxis_out_of_boundsr   s
             rC   _normalize_axisr    s    99Q<DiioG %%c46K>>+w{{4'A4HD !Ct,D$02 
+E	: G(94))':vFG K	G Ks    (CCc           
      v   t        |      |dz
  k(  sJ t        j                  t        j                  |      }t        j
                  ||      }t        j                  d      }t        |dz
        D ]z  }t        j                  |      }	|j                  d|	|      }
||   }|j                  |
|j                  |	|      |	      }|j                  |t        j                  ||d|             | |j                  |t        j                  ||d|             t        j                  ||j                  |            S )z
    Compute shape with the new axis inserted
    e.g. given original shape (2, 3, 4) and axis=2,
    the returned new shape is (2, 3, 1, 4).
    rG   r  r   r   r   r  r
   r   rW   r8   r	  r  r  r  rh   r   r>   )r}   r=   
orig_shaperp   r   ll_shtyr   r$  rt  ll_dim
after_axisr-  r   s                rC   _insert_axis_in_shaper    s    z?dQh&&&ll7>>40G  '2F
..
C TAX I$((vt<
_nnZ$[[5#% 	b'..w3GHI MM#w++GVQEFf)=>>rE   c           
         t        |      |dz
  k(  sJ t        j                  t        j                  |      }t        j
                  ||      }t        j                  d      }t        j                  d      }t        |dz
        D ]x  }	t        j                  |	      }
|j                  d|
|      }|j                  ||j                  |
|      |
      }|j                  ||	   t        j                  ||d|             z |j                  |t        j                  ||d|             t        j                  ||j                  |            S )zD
    Same as _insert_axis_in_shape(), but with a strides array.
    rG   r   r  r  )r}   r=   orig_stridesrp   r   r  r   r$  r   rt  r  r  r   s                rC   _insert_axis_in_stridesr    s"    |q(((ll7>>40G!!'73G
..
C>>!D TAX F$((vt<
nnZ$[[5#% 	l3'**7GQD	FF MM$,,Wgq$GHg)>??rE   c           	         |j                   }|j                  }|j                  d   } t        |      | ||d         } t        |      | |      }	t	        j
                  ||j                        }
t	        j
                  ||j                        }t        | ||
||      }t        | ||||      }t        |	|j                  |||j                  |j                  |j                         |	j                         S )z/
    np.expand_dims() with the given axis.
    r   r  r1  )r   rp   r   rx   r
   r   re   r   r  r  r   r   r   r   r   r   )r}   r=   r[   r   r   rF  rp   r  r  rW  r   r   
new_shapesnew_stridess                 rC   expand_dimsr  (  s     OOE::DHHQKE
*U
GWDG
<C
*U
GW
-C!!'3995F""7CKK8G&wtLJ)'7GT4PK3#&LL;;**& ==?rE   c                     |j                   dk  r|j                  nd}|j                  |j                   dz   |      } |||      }d }||fS )NrG   rI  rJ  c                     | j                  ||d   |j                  d   t        j                        }t	        | |d|j
                  j                  |      }t        | ||||      }t        | ||j
                  |      S )NrG   znp.expand_dims)	r   r   r   r   r  r   rp   r  r!   )r}   r=   r[   r   r   rW  s         rC   rU  znp_expand_dims.<locals>.codegenJ  so    ||GT!Wchhqk5::Fw1A"33T; '7Ct< '3??CHHrE   )rp   r  rK  )rV  r  r   r  rW  r[   rU  s          rC   np_expand_dimsr  D  sN    1QXX#F
&&affqj&
0C
a,CI <rE   c                     t        | t        j                        sd|  }t        j                  |      t        |t        j
                        sd| }t        j                  |      d }|S )Nz)First argument "a" must be an array. Got z(Argument "axis" must be an integer. Got c                     t        | |      S r;  )r  )r  r   s     rC   r   z!impl_np_expand_dims.<locals>.impl_  s    a&&rE   )r   r   r   r	   r   r   )r  r   r   r   s       rC   impl_np_expand_dimsr  U  sb    a%9!=  %%dEMM*8?  %%'KrE   c                 0     t          fd       fdS )Nc           	      0   ||D cg c](  }|j                  t        |j                              * c}fd}t        t	              dkD  rt        j                        nd   t
        j                  j                  |            |fS c c}w )Nr<  c                 F   t              }t        j                  ||d         }t        |      D cg c]  \  }}} || ||||       }	}}}t	        |	      dkD  r| j                  ||j                  |	      }
n|	d   }
t        | ||j                  |
      S c c}}}w r  )_atleast_nd_transformr
   r   r   r   r  r   r!   )r}   r=   r[   r   	transformarrsr  r  rF  retsrW  r  r  minimumr+  s              rC   rU  z*_atleast_nd.<locals>.impl.<locals>.codegenj  s    -gt<I''a9D .1vv-FH H)UE gwUEB HD H 4y1}((#//4H1g$WgsLLHs   BrG   r   )	rK  r  rp   r%   r   r   rs  StarArgTuple
from_types)typingcontextr   r  rU  r  r+  r  r
  s       @@rC   r   z_atleast_nd.<locals>.imple  s    CGHC#((CHHg 6(7H	M FaV,VAY++66t<>?FG 	G Is   -Bc                       |  S r;  rp  )r   r   s    rC   r  z_atleast_nd.<locals>.<lambda>z  s    t rE   r  )r
  r  r   s   ``@rC   _atleast_ndr  d  s    G G( %$rE   c                 6      t              k(  sJ  fd}|S )z`
    Return a callback successively inserting 1-sized dimensions at the
    following axes.
    c           	         t        
      D ]t  }|dz   }|j                  |k  st        j                  	|         }|j	                  |j                  dz         }t        | |t        j                  ||      |f|      }|}v |S )NrG   r<  )r8   rp   r
   r   rK  r  r   r%   )r}   r=   r  r  rF  rm   rp   r   newarrtyr  min_ndims            rC   r  z(_atleast_nd_transform.<locals>.transform  s    x 	!Aq5DzzD ~~d1g. ::5::>::!'7"("2"28U"CcV"&( !	! 
rE   )r   )r  r  r  s   `` rC   r  r  }  s$    
 s4y    rE   c                  B    t        d | D              rt        ddg      S y )Nc              3   P   K   | ]  }t        |t        j                           y wr;  r<  r  s     rC   r?  z np_atleast_1d.<locals>.<genexpr>       
8C:c5;;'
8r@  rG   r   rt  r  r  s    rC   np_atleast_1dr    s$    

84
881qc"" 9rE   c                  D    t        d | D              rt        dddg      S y )Nc              3   P   K   | ]  }t        |t        j                           y wr;  r<  r  s     rC   r?  z np_atleast_2d.<locals>.<genexpr>  r  r@  rZ  r   r  r  s    rC   np_atleast_2dr    s&    

84
881q!f%% 9rE   c                  D    t        d | D              rt        dg d      S y )Nc              3   P   K   | ]  }t        |t        j                           y wr;  r<  r  s     rC   r?  z np_atleast_3d.<locals>.<genexpr>  r  r@  r(  )r   r   rZ  r  r  s    rC   np_atleast_3dr    s"    

84
881i(( 9rE   c	                 f   t        |      t        |      cxk(  rt        |      cxk(  rt        |      k(  sJ  J t        j                  d      }	t        | |||      }
t        j                  ||
j
                        }g }|D ]  }|	}t        t        ||            D ]_  \  }\  }}|j                  d|j                  |      |      }|j                  ||      }|j                  ||j                  ||      |      }a |j                  |        |
j                  }t        |||||      D ]  \  }}}}}|j                  }t        j                  ||t        j                  |j                         }|5 }t        j"                  | |||||j                   |      }t%        | |||      }| j'                  |||j(                  |j(                        }t        j"                  | |||||j                   |      }t+        | ||||       ddd       t        j,                  |||      } |
S # 1 sw Y   $xY w)z2
    Concatenate arrays along the given axis.
    r   r  )orderN)r   r
   r   r  r   r   r  r   r	  r9   r   r  r  ri   r   r.  r  r  r   r   r{   r   r   )r}   r=   r   r  r  
arr_shapesarr_stridesrF  
ret_shapesr   rW  ret_stridescopy_offsetsarr_shr   rt  r   r  is_axisaddendret_datar  r  arr_starr_datar.  r   r  r   r1  s                                 rC   _do_concatenater,    s,    v;#d)Js:J#k:JJJJJJ>>!D '5*
=C&&w<K L 	$#,S-E#F 	,C$))$		#EG[[v.F^^G$+KK$?$*,F	, 	F#	$ xxH.1&$
2=|/M B*sFFF88 %%gvw~~,1LL:	  		?'//(0605gGG GWeW=C,,wU[[%++FC00'81;[16wHH wX>		? &&w&A+B. J		? 		?s   4BH''H0	c                 x   |j                   }t        ||      D cg c]  \  }} t        |      | ||       }}}t        | |d||      }|D 	cg c]"  }	t	        j
                  ||	j                        $ }
}	|D 	cg c]"  }	t	        j
                  ||	j                        $ }}	|
d   D cg c]  }t	        j                  ||       }}t        |      D ]C  }|j                  d|j                  |      |      }||   }|j                  |      }|
dd  D cg c]  }||   	 }}|j                  |      5 \  }}|5  t        j                  |j                   ||gz         }|j#                  ||       d d d        |5  t        j$                  }|D ]%  }|j'                  ||j                  d||            }' |j)                  |j+                  |      d      5  | j,                  j/                  |t0        d|z  f       d d d        d d d        d d d        F |D cg c]  }|j                  |       }}t3        | |||||
|||	      }t5        | |||j7                               S c c}}w c c}	w c c}	w c c}w c c}w # 1 sw Y   xY w# 1 sw Y   xY w# 1 sw Y   xY w# 1 sw Y   xY wc c}w )	Nr  np.concatenater   r  rG   FrT  z<np.concatenate(): input sizes over dimension %d do not match)rp   r   rx   r  r
   r   re   r   r   r8   r	  r9   r>   r  r4  r5  r  r  r6  r  r  r  rV  rW  r   r,  r"   r   )r}   r=   r  r  rF  r   rp   r  r  r  r!  r"  r-  r#  rt  r'  ret_shape_ptrret_shother_shapeson_axison_other_dimis_okrW  s                          rC   _np_concatenater5    s   ::D fd+-Q JsOGWA6 -D - 7G-=tTJD GKKs'&&w		:KJKIMN#7''=NKN 'qM+ ++GR8 +J + T{ >%%dDIIcNDA"3m,*4QR.9B399__W% 	>)@'< 1%%KK F8+- b-0	1  	>((& PB#LL)0)<)<T2v)NPEP __W\\%%8_G >%%5557:; =>>	>	> 	>>0 .88r',,r"8J8
'7D $
K-C GWeS]]_EEY- LN
+ :1 1> >	> 	>	> 	>$ 9sx   I+'I1='I6-I;J 9J*?7J6
J* AJ&J	JJ*"J7J
J*JJJ'#J**J4	c                 	   |j                   }t        j                  d      }t        j                  d      }t        j                  t        |            }	t	        ||      D 
cg c]  \  }
} t        |
      | ||       }}
}t        | |d||      }t        j                  ||d   j                        }|dd  D ]  }t        j                  }t	        t        j                  ||j                        |      D ]t  \  }}|j                  ||j                  d||            }|j                  |j                  |      d      5  | j                  j                  |t         d       d d d        v  |D cg c]"  }t        j                  ||j"                        $ }}t%        j&                  t        j                  |      }t        j(                  ||      }t        j(                  ||      }t+        |dz
        D ]  }t        j                  |      }|j                  d	||      }||   }|j-                  ||j/                  ||      |      }|j1                  |t        j2                  ||d|             |j1                  |t        j2                  ||d|              |j1                  |t        j2                  ||d|             |j1                  |	t        j2                  ||d|             t        j                  ||j5                  |            }|gt        |      z  }t        j                  ||j5                  |            }t+        t        |            D cg c]  }t        j(                  ||       }}t+        |dz
        D ]  }t        j                  |      }|j                  d	||      }|j-                  ||j/                  ||      |      }t+        t        |            D ]3  }|j1                  ||   |   t        j2                  |||   d|             5  t+        t        |            D ]-  }|j1                  |t        j2                  |||   d|             / |D cg c]'  }t        j                  ||j5                  |            ) }}t7        | ||||||||	      }t9        | |||j;                               S c c}}
w # 1 sw Y   xY wc c}w c c}w c c}w )
Nr   rG   r  np.stackr  FrT  )z5np.stack(): all input arrays must have the same shaper  )rp   r
   r   r   r   rx   r  r   re   r6  r  r	  r  r  rV  rW  r   r   r   r  rW   r8   r  r  r  rh   r>   r,  r"   r   )r}   r=   r  r  rF  r   rp   r   r$  
ll_narraysr  r  r  r  r4  r-  orig_shr  r  input_shapesr#  rt  r  r  r   rm   input_stridesr.  rW  s                                rC   	_np_stackr<    s   ::D>>!D
..
CD	*J fd+-Q JsOGWA6 -D - 7GZtDD %%gtAw}}=JABx P  w33GSYYG)+ 	PKBLL(;(;D"g(NOEe!4UC P!!11ZNPP P	PP KOO3G((#++>OLO
 ll7>>40G&&w8L$$Wg6J TAX M$((vt<
_nnZ$[[5#% 	b'..waMNb'..w
AsKLM MM#w++G\1dKLMM*g2273=34379 :
 ''l1KLL >CI-L%%gw||J/GHJ $CI.0 ((': 0M 0 TAX 	5$((vt<
nnZ$[[5#% s4y! 	5AMM,q/#.!..wa8H!/245	5	5 3t9 8dG00-:JA157 	88
  -. ))'7<<3CD .M . '7D $m-C GWeS]]_EE_-P P
 PB0*.s$   $S"S6'S !S%0,S*Sc                     |t        |t        j                        sy t        | d|      \  }}|dk(  rd}t	        j
                  |      t        |      }t        j                  |||      S )Nr.  r   z.zero-dimensional arrays cannot be concatenated)r   r   r   r5   r	   r  r6   r   )rV  r  r   r{   rp   r   r  s          rC   np_concatenate_typerr>  n  sl    
4 ? 	 &i&6@KE4qy>##C(()&1F;;udF++rE   c                 t    t        | ||      }t        |t        j                        sJ  |||      }d }||fS )Nc           
          | j                  ||d   |j                  d   t        j                        }t	        | |t        |j                  d         t        j                  ||d         |j                  |      S r  )	r   r   r   r   r5  r   r
   r   r   r}   r=   r[   r   r   s        rC   rU  znp_concatenate.<locals>.codegen  se    ||GT!Wchhqk5::Fw#CHHQK0&33GT!WE"#	% 	%rE   )r>  r   r   r   )rV  r  r   rW  r[   rU  s         rC   np_concatenaterB    sA    
y&$
7Cc5;;'''
fd
C% <rE   c                 D    t        | t        j                        rdd}|S y )Nc                     t        | |      S r;  )rB  r  r   s     rC   r   z!impl_np_concatenate.<locals>.impl  s    !&$//rE   r  r   r   rG  r  r   r   s      rC   impl_np_concatenaterH    s    &%//*	0 +rE   c                 |    |D ]7  }|j                   dk  s|j                   dkD  s"d}t        j                  |       y)NrG   rZ  z7np.column_stack() is only defined on 1-d and 2-d arrays)rp   r	   r  )r}   r   r  r  r   s        rC   _column_stack_dimsrJ    sA     -66A:!KC'',,- rE   c                     t        | d|t              \  }}t        |      }t        j                  |||      } ||      }d }||fS )Nznp.column_stack)dim_chooserc                 B   t        |j                  d         }t        j                  ||d         }g }g }| j	                  t
        j                  d      }t        ||      D ]  \  }	}
|	j                  dk(  r#|j                  |	       |j                  |
       8|	j                  dk(  sJ |	j                  d      }t        j                  ||	      }t        | |||
f|      }|j                  |       |j                  |        t        | ||||j                  |      S )Nr   rG   rZ  r<  )r   r   r
   r   r   r   r   r   rp   ri   rK  r   r%   r  r5  r   )r}   r=   r[   r   orig_arrtys	orig_arrsr  r  r   r  r  r  
expand_signewarrs                 rC   rU  z np_column_stack.<locals>.codegen  s   388A;'(($q':	##EJJ2k95 	$JE3zzQe$C  zzQ&


*#--eU;
$WgzC64Pe$F#	$ w"6 	6rE   )r5   rJ  r6   r   r   )rV  rD  r{   rp   r  rW  r[   rU  s           rC   np_column_stackrR    sS    %i&72DFKE4 *#.F
++eT6
*C
c(C64 <rE   c                 B    t        | t        j                        rd }|S y )Nc                     t        |       S r;  )rR  rD  s    rC   r   zimpl_column_stack.<locals>.impl  s    "3''rE   rF  rD  r   s     rC   impl_column_stackrW    s    #u'	( (rE   c           
          t        | |t        |j                  d         t        j                  ||d         |j
                  |      S )z/
    np.stack() with the given axis value.
    r   )r<  r   r   r
   r   r   rA  s        rC   _np_stack_commonrY    sC     Wg#((1+&))'47;__	 rE   c                     t        | d|      \  }}t        d |D              rdnd}t        j                  ||dz   |      } |||      }d }||fS )Nr7  c              3   :   K   | ]  }|j                   d k(    yw)r  N)r  rB  s     rC   r?  z"np_stack_common.<locals>.<genexpr>  s     8AC8s   r  r   rG   c                     | j                  ||d   |j                  d   t        j                        }t	        | ||||      S r  )r   r   r   r   rY  rA  s        rC   rU  z np_stack_common.<locals>.codegen  s9    ||GT!Wchhqk5::F#tTBBrE   )r5   rt  r   r   )	rV  r  r   r{   rp   r  rW  r[   rU  s	            rC   np_stack_commonr]    sa     &i&0&:KE4888ScF
++eTAXv
.C
fd
CC <rE   c                 D    t        | t        j                        rdd}|S y )Nc                     t        | |      S r;  )r]  rE  s     rC   r   zimpl_np_stack.<locals>.impl  s    "6400rE   r  rF  rG  s      rC   impl_np_stackr`    s    &%//*	1 +rE   c                     t        | ||      \  }}t        ||      }t        |      }t        j                  |||      }|S r;  )r5   r  r6   r   r   )rV  r   r  ndim_minr{   rp   r  rW  s           rC   NdStack_typerrc    sA    %iFCKE4tXD)&1F
++eT6
*CJrE   c                 <    t        | d|d      } ||      }d }||fS )Nz	np.hstackrG   c                     |j                   d   }|d   j                  }|dk(  r/| j                  t        j                  d      t        | |||      S |dk(  rdndfd}| j                  ||||      S )Nr   rG   c                 2    t        j                  |       S ri  rk  rE  s    rC   np_hstack_implz3_np_hstack.<locals>.codegen.<locals>.np_hstack_impl  s    ~~f488rE   r   rp   r   r   r   rY  r  )r}   r=   r[   r   rC  rp   rg  r   s          @rC   rU  z_np_hstack.<locals>.codegen  sz    Qx}}19''

A6D#GWc4FF
 	1qD9 ++G^S$OOrE   rc  rV  rD  rW  r[   rU  s        rC   
_np_hstackrk    s-    
	;Q
7C
c(CP& <rE   c                 B    t        | t        j                        rd }|S y )Nc                     t        |       S r;  )rk  rU  s    rC   r   zimpl_np_hstack.<locals>.impl      c?"rE   rF  rV  s     rC   impl_np_hstackro        #u'	# (rE   c                 <    t        | d|d      } ||      }d }||fS )Nz	np.vstackrZ  c                     |j                   d   }|d   j                  }|dk(  rd }n7|dk(  r/| j                  t        j                  d      }t        | ||||      S d }| j                  ||||      S )Nr   c                 T    t        j                  t        j                  |       d      S r  )ri  r  hstackr  s    rC   np_vstack_implz3_np_vstack.<locals>.codegen.<locals>.np_vstack_impl)  s    ~~bii&7;;rE   rG   c                 0    t        j                  | d      S )Nr   rj  rk  ru  s    rC   rv  z3_np_vstack.<locals>.codegen.<locals>.np_vstack_impl2      ~~f155rE   rh  )r}   r=   r[   r   rC  rp   rv  r   s           rC   rU  z_np_vstack.<locals>.codegen$  sx    Qx}}19< QY''

A6D#GWc4FF6 ''dKKrE   ri  rj  s        rC   
_np_vstackry    s-    
	;Q
7C
c(CL& <rE   c                 B    t        | t        j                        rd }|S y )Nc                     t        |       S r;  )ry  rU  s    rC   r   zimpl_np_vstack.<locals>.impl=  rn  rE   rF  rV  s     rC   impl_np_vstackr|  :  rp  rE   c                 <    t        | d|d      } ||      }d }||fS )Nz	np.dstackr(  c                    |j                   d   }|j                  }|d   j                  }|dk(  rd }| j                  ||||      S |dk(  r| j	                  t
        j                  d      }|j                  |j                  dz
        }	t        j                  |	g|j                    }
t        | ||
||      }| j	                  t
        j                  d      }t        j                  ||	      }t        | |||f|      S |dk(  r/| j	                  t
        j                  d      }t        | ||||      S d }| j                  ||||      S )Nr   c                 N    t        j                  |       j                  ddd      S )NrG   r  )ri  rt  rR  ru  s    rC   rv  z3_np_dstack.<locals>.codegen.<locals>.np_vstack_implQ  s     yy(00Ar::rE   rG   r<  rZ  c                 0    t        j                  | d      S )NrZ  rj  rk  ru  s    rC   rv  z3_np_dstack.<locals>.codegen.<locals>.np_vstack_implh  rx  rE   )r   r   rp   r  r   r   r   rK  r   r%   rY  r  )r}   r=   r[   r   rC  rF  rp   rv  r   stack_retty	stack_sig	stack_retrP  s                rC   rU  z_np_dstack.<locals>.codegenK  s:   Qx}}19; ++G^S$OOQY''

A6D**%**q.*9K((@sxx@I('9d)-/I ''

A6D))%=Jwi\4PPQY''

A6D#GWc4FF6 ++G^S$OOrE   ri  rj  s        rC   
_np_dstackr  F  s.    
	;Q
7C
c(C PD <rE   c                 B    t        | t        j                        rd }|S y )Nc                     t        |       S r;  )r  rU  s    rC   r   zimpl_np_dstack.<locals>.impls  rn  rE   rF  rV  s     rC   impl_np_dstackr  p  rp  rE   fillc                     d }|S )Nc                     || d d  y r;  rp  )r  r   s     rC   	fill_implzarr_fill.<locals>.fill_impl{  s    ArE   rp  )r  r   r  s      rC   arr_fillr  x  s     rE   dotc                     d }|S )Nc                 .    t        j                  | |      S r;  )ri  r  )r  others     rC   dot_implzarray_dot.<locals>.dot_impl  s    vvc5!!rE   rp  )r  r  r  s      rC   	array_dotr    s    " OrE   c                 R    t        |       st        j                  d| z        d }|S )NzCannot np.fliplr on %s typec                 z    t        j                  |       }|j                  dk  rt        d      |d d d d ddf   S )NrZ  r%  r  .ri  rj  rp   r   r|  rI  s     rC   r   znp_flip_lr.<locals>.impl  s=    JJqM 66A:455TrT3rE   r  r|  r   s     rC   
np_flip_lrr    s/     A  !>!BCC  KrE   c                 R    t        |       st        j                  d| z        d }|S )NzCannot np.flipud on %s typec                 t    t        j                  |       }|j                  dk  rt        d      |d d ddf   S )NrG   zInput must be >= 1-d.r  .r  r  s     rC   r   znp_flip_ud.<locals>.impl  s:    JJqM 66A:4552s|rE   r  r  s     rC   
np_flip_udr    s/     A  !>!BCC KrE   c                     t        |t        j                        st        j                  |      t        |j                        t        j                  t        j                         |      }fd}||fS )zY Creates a tuple of slices for np.flip indexing like
    `(slice(None, None, -1),) * sz` r  c                     d }t         j                  g}t        j                  g| }| j	                  t         j                        }| j                        } |      |g}	| j                  ||||	      }
|
S )Nc           
      Z    |}t        |       D ]  }t        ||t        d d d            } |S )Nr  )r8   r/   r,  )lengthempty_tupler   rm   s       rC   r   z6_build_flip_slice_tuple.<locals>.codegen.<locals>.impl  s8    C6] C#CE$b,ABCJrE   )r   r   r   r%   r   get_constant_undefr  )r}   r=   r%   r   r   inner_argtypes	inner_sigll_idx_typer  
inner_argsr   r   
tuple_types              rC   rU  z(_build_flip_slice_tuple.<locals>.codegen  s{    	  **j1$$ZA.A	,,UZZ800<!$'5
&&wiL
rE   )	r   r   ru  r	   r  r   r   rr  slice3_type)r  szr[   rU  r   r  s       @@rC   _build_flip_slice_tupler    sf     b%../((,,r De&7&7tDJ
R.C" <rE   c                 p    t        | t        j                        st        j                  d| z        d }|S )NzCannot np.flip on %s typec                 6    t        | j                        }| |   S r;  )r  rp   )r|  sls     rC   r   znp_flip.<locals>.impl  s    $QVV,urE   )r   r   r   r	   r   r  s     rC   np_flipr    s5     a%  !<q!@AA KrE   c                    t        | t        j                  t        j                  t        j                  f      rdd}|S t        |t        j
                        rdd}|S t        |t        j                        r4t        |j                  j                  t        j
                        rdd}|S t        |t        j                        r#t        d |j                  D              rdd}|S y y )Nc                 X    t        j                  t        j                  |       ||      S ri  )ri  array_splitrj  r   indices_or_sectionsr   s      rC   r   znp_array_split.<locals>.impl  s$    >>

3# rE   c                     t        | j                  |   |      \  }}t        j                  t        j                  |dz   g|z  |g||z
  dz
  z  z               }t        j
                  | ||      S )NrG   rj  )divmodre   ri  cumsumr   r  )r   r  r   r  r  r   s         rC   r   znp_array_split.<locals>.impl  sp    CIIdO-@AFAsiiQ#*S01456! G >>#wT::rE   c                 "   t        | j                        }t        dd| j                  |      }g }d}|D ]/  }t        ||t	        ||            }|j                  | |          |}1 |j                  | t        ||t	        d                       |S Nznp.splitr   r   )r0   rp   r   r/   r,  ri   r   r  r   	slice_tupr   prevr  r   s           rC   r   znp_array_split.<locals>.impl  s    .sxx8I!*fchhEDCD* #ItU45EF

3s8$ JJs=D%T:JKLMJrE   c              3   P   K   | ]  }t        |t        j                           y wr;  r   r   r   )r=  r#  s     rC   r?  z!np_array_split.<locals>.<genexpr>  s     P
1emm,Pr@  c                 4   t        | j                        }t        dd| j                  |      }g }d}t        |      D ]/  }t	        ||t        ||            }|j                  | |          |}1 |j                  | t	        ||t        d                       |S r  )r0   rp   r   r   r/   r,  ri   r  s           rC   r   znp_array_split.<locals>.impl  s    .sxx8I!*fchhEDCD%&9: #ItU45EF

3s8$ JJs=D%T:JKLMJrE   r  )r   r   rr  ListTyper  r   IterableTypeiterator_typer  rs  rt  r   r  r   r   s       rC   np_array_splitr    s    #

CD	 %u}}5	;  	&(:(:;--88MM


	  	&4P6I6O6OPP
	  Q 	5rE   c                     t        | t        j                  t        j                  t        j                  f      rdd}|S t        |t        j
                        rdd}|S t        | ||      S )Nc                 X    t        j                  t        j                  |       ||      S ri  )ri  splitrj  r  s      rC   r   znp_split.<locals>.impl  s    88BJJsO-@tLLrE   c                     t        | j                  |   |      \  }}|dk7  rt        d      t        j                  | ||      S )Nr   z0array split does not result in an equal divisionrj  )r  re   r   ri  r  )r   r  r   r  r  s        rC   r   znp_split.<locals>.impl"  sM    CIIdO-@AFAsax F  >>(t rE   rj  r  )r   r   rr  r  r  r   r  r  s       rC   np_splitr    s[     #

CD	M %u}}5	  c#6TBBrE   c                 ,   t        | t        j                        sd}t        j                  |      t        |t        j
                  t        j                  t        j                  t        j                  f      sd}t        j                  |      d }|S )N#The argument "ary" must be an array:The argument "indices_or_sections" must be int or 1d-arrayc                 f    | j                   dk  rt        d      t        j                  | |d      S )NrZ  z3vsplit only works on arrays of 2 or more dimensionsr   rj  rp   r   ri  r  r   r  s     rC   r   znumpy_vsplit.<locals>.impl=  s5    88a< ? A Axx0q99rE   r   r   r   r	   r   r   r  rr  r   r  r   r   s       rC   numpy_vsplitr  2  s    c5;;'3  %%)EMM5;;,1JJ,H IK  %%: KrE   c                 ,   t        | t        j                        sd}t        j                  |      t        |t        j
                  t        j                  t        j                  t        j                  f      sd}t        j                  |      d }|S )Nr  r  c                     | j                   dk(  rt        d      | j                   dkD  rt        j                  | |d      S t        j                  | |d      S )Nr   z3hsplit only works on arrays of 1 or more dimensionsrG   rj  r  r  s     rC   r   znumpy_hsplit.<locals>.implQ  sT    88q= ? A A88a<88C!41==xx0q99rE   r  r  s       rC   numpy_hsplitr  F  ss    c5;;'3  %%)EMM5;;,1JJ,H IK  %%: KrE   c                 ,   t        | t        j                        sd}t        j                  |      t        |t        j
                  t        j                  t        j                  t        j                  f      sd}t        j                  |      d }|S )Nr  r  c                 f    | j                   dk  rt        d      t        j                  | |d      S )Nr(  z3dsplit only works on arrays of 3 or more dimensionsrZ  rj  r  r  s     rC   r   znumpy_dsplit.<locals>.implg  s3    88a< * + +xx0q99rE   r  r  s       rC   numpy_dsplitr  \  r  rE   c                     | |k  S )z7
    Trivial comparison function between two keys.
    rp  r  s     rC   
default_ltr  v  s     q5LrE   c                    | |j                   |f}	 t        |   S # t        $ r` | dk(  r%t        j                  ||d      }|j
                  }n(| dk(  r#t        j                  ||      }|j                  }t        |<   |cY S w xY w)z6
    Get a sort implementation of the given kind.
    r,   T)lt
is_argsortis_np_arrayr-   )r  r  )	rq   _sortsKeyErrorr,   make_jit_quicksortrun_quicksortr-   make_jit_mergesortrun_mergesort)rm  lt_implr  keyr  r  s         rC   get_sort_funcr  }  s       *
,Cc{ ;//% "D %%D[ //%'D %%Dss    A&BBc                     t        | t        j                        rt        S t        | t        j                        rt
        S t        S r;  )r   r   rD  r   r  r   r  r  s    rC   lt_implementationr    s0    %%	E5==	)rE   z
array.sortc                     |j                   d   }t        dt        |j                              fd}| j	                  ||||      S )Nr   r,   )rm  r  c                      |        y r;  rp  r  	sort_funcs    rC   array_sort_implz#array_sort.<locals>.array_sort_impl  s
    #rE   )r   r  r  r{   r  )r}   r=   r[   r   r  r  r  s         @rC   
array_sortr    sG    hhqkG;&7&FHI ##G_c4HHrE   c                 L    t        |       st        j                  d      d }|S )NzArgument "a" must be array-likec                 F    | j                         }|j                          |S r;  )rK  r  )r  r   s     rC   np_sort_implz"impl_np_sort.<locals>.np_sort_impl  s    ffh

rE   r  )r  r  s     rC   impl_np_sortr    s/    A   "1 2 	2 rE   zarray.argsortc                    	 |j                   \  }}t        |j                  t        |j                        d      		fd}|j                  |j                   d d       }|d d }| j                  ||||      S )NT)rm  r  r  c                      |       S r;  rp  r  s    rC   array_argsort_implz)array_argsort.<locals>.array_argsort_impl  s    ~rE   rG   r  )r   r  r   r  r{   replacer  )
r}   r=   r[   r   r  rm  r  innersig	innerargsr  s
            @rC   array_argsortr    s|     HHMGT4#5#5&7&F)-/I {{!{-HRaI##G-?$,i9 9rE   c                 Z    |j                   |j                   k7  s|j                  dk(  sJ |S )NrI  )r.  r  )r}   r=   r:  r;  r   s        rC   array_to_arrayr    s*     >>T\\)T[[C-???JrE   c                 z    d }t        ||      }| j                  ||||g      }t        | ||j                  |      S )Nc                 $    | j                  d      S r   )r-  rx  s    rC   r   zarray0d_to_scalar.<locals>.impl  s    vvayrE   )r%   r  r#   r   r}   r=   r:  r;  r   r   r[   r   s           rC   array0d_to_scalarr    sB     D&
!C

"
"7D#u
=CgwEErE   c                 z    d }t        ||      }| j                  ||||g      }t        | ||j                  |      S )Nc                     t        | d         S r  )r  rx  s    rC   r   z array_to_unichrseq.<locals>.impl  s    1R5zrE   )r%   r  r!   r   r  s           rC   array_to_unichrseqr    sB     D&
!C

"
"7D#u
=CWgsDDrE   c                     t         )zR
    An intrinsic returning a derived array with the given shape and strides.
    r   )r  re   r   s      rC   reshape_uncheckedr    r  rE   c                     d fd}|S )Nc                 ^    t        | t        j                        xr t        d | D              S )Nc              3   P   K   | ]  }t        |t        j                           y wr;  r  r)  s     rC   r?  z>type_reshape_unchecked.<locals>.check_shape.<locals>.<genexpr>  s     @QJq%--0@r@  )r   r   rG  rt  re   s    rC   r  z+type_reshape_unchecked.<locals>.check_shape  s*    5%//2 A@%@@	BrE   c                     t        | t        j                        sy  |      r |      sy t        |      t        |      k7  ry | j	                  t        |      d      S )NrI  rJ  )r   r   r   r   rK  )r  re   r   r  s      rC   typerz%type_reshape_unchecked.<locals>.typer   sP    !U[[)5!W)=u:W%vv3u:cv22rE   rp  )r}   r
  r  s     @rC   type_reshape_uncheckedr    s    B3 LrE   c                    |j                   d   }|j                  } t        |      | ||d         } t        |      | |      }t        j                  ||d         }t        j                  ||d         }	t        ||j                  ||	|j                  |j                         |j                         }
t        | |||
      S )Nr   rG   rZ  r  )r   r   rx   r
   r   r   r   r   r   r   r!   )r}   r=   r[   r   r   rF  r   r   re   r   r   s              rC   impl_shape_uncheckedr    s    HHQKEOOE
*U
GWd1g
6C
*U
GW
-C  $q'2E""7DG4G3"LL;; --/CWguc::rE   c                     |d t         j                  fv rt        d        nt        d        |d t         j                  fv rt        j                  d      t        d        dfd	}|S )Nc                     | j                   S r;  r  rC  re   s     rC   rh  zas_strided.<locals>.get_shape%  s    77NrE   c                     |S r;  rp  r  s     rC   rh  zas_strided.<locals>.get_shape)  s    LrE   z,as_strided() strides argument cannot be Nonec                     |S r;  rp  )rC  r   s     rC   get_strideszas_strided.<locals>.get_strides4  s    NrE   c                 >    t        |  | |       | |            } | S r;  )r  )rC  re   r   rh  r  s      rC   as_strided_implz#as_strided.<locals>.as_strided_impl8  s$    a1e!4k!W6MNrE   r  )r   r  r'   r	   r   )rC  re   r   r  rh  r  s       @@rC   
as_stridedr  "  s    uzz""		 
	 
	 
	 4$$
   !OPP		 
	 rE   c                    t        |t        j                        rOt        t	        | j
                  dz               t        t	        | j
                  dz               t        d        nt        |t        j                        rt        |j                  t        j                        rat        t	        | j
                  t        |      z               t        t	        | j
                  t        |      z               t        d        nt        j                  d      t        |      rt        d        nt        |t        j                        rt        d        n`t        |t        j                        r1t        |j                  t        j                        rt        d        nt        j                  d      d
fd		}|S )NrG   c                     | fS r;  rp  window_shapes    rC   get_window_shapez-sliding_window_view.<locals>.get_window_shapeI  s
     ?"rE   c                     | S r;  rp  r  s    rC   r  z-sliding_window_view.<locals>.get_window_shapeR  s    rE   z4window_shape must be an integer or tuple of integersc                 *    t        t        |            S r;  )r   r8   r  r   rp   s      rC   get_axisz%sliding_window_view.<locals>.get_axis]  s    d$$rE   c                      t        dd||      gS Nsliding_window_viewr   r   r  s      rC   r  z%sliding_window_view.<locals>.get_axisb  s     4fdDI rE   c           	      D    |D cg c]  }t        dd||       c}S c c}w r!  r#  )r  r   rp   r  s       rC   r  z%sliding_window_view.<locals>.get_axisj  s0     "# ##8&$J # # #s   z2axis must be None, an integer or tuple of integersc                 P    |      } 
||| j                         }t        |      t        |      k7  rt        d      }}t        | j                         D ]6  }t	        ||| j
                  |         }t	        ||| j                  |         }8 | j                   }t        ||      D ]l  \  }}|dk  rt        d      ||   |k  rt        d      ||   |z
  dz   }t	        |||      }t	        |||      }t	        ||| j                  |         }|dz  }n t        | ||      }	|	S )Nz2Must provide matching length window_shape and axisr   z-`window_shape` cannot contain negative valuesz4window_shape cannot be larger than input array shaperG   )	rp   r   r   r8   r/   re   r   r   r  )rC  r  r   	out_shapeout_stridesrm   r)  rt  trimmedr0  r  r  shape_bufferstride_buffers             rC   sliding_window_view_implz5sliding_window_view.<locals>.sliding_window_view_implt  sP   '5dAFF3|D	)D 
 !	#qvv 	FA%iAGGAJ?I'Q		!EK	F FF4. 	GBQw C  }s" J   mc)A-G%iW=I%iC8I'Q		"FKFA	$ !I{;rE   r;  )r   r   r   r   r8   rp   r'   rr  r{   r   r	   r   r   )rC  r  r   r+  r  r  r)  r*  s       @@@@rC   r"  r"  ?  sx    ,.U166A:./eAFFQJ/0		# 
	# \5>>
2|))5==9U166C,=#=>?eAFFS->$>?@		  
	    B
 	

 4		% 
	% 
D%--	(		 
	
 T5>>
*tzz5==1		# 
	#
   @
 	
% %N $#rE   c                 B    t        | t        j                        rd }|S y )Nc                     | j                   dk(  rt        dk  ryt        d      | j                   dk(  rt        | j	                  d            S t        d      )Nr   )rZ  rZ  FziThe truth value of an empty array is ambiguous. Use `array.size > 0` to check that an array is not empty.rG   z[The truth value of an array with more than one element is ambiguous. Use a.any() or a.all())r   r   r   rH  r-  rf  s    rC   r   zol_bool.<locals>.impl  s_    xx1} 6) $ 'J L L QCHHQK((  #- / /rE   r<  rg  s     rC   ol_boolr.    s!    #u{{#	/  $rE   c                    t        |t        t        j                  f      st	        j
                  d      t        |t        t        j                  f      st	        j
                  d      t        | t        j                        st	        j
                  d      | j                  t        t                    f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                     t        dd|      }t        dd|      }|dk  r|z  }|dk  r|z  }t        ||      }t        |||      }t        j                  | |      S )Nznp.swapaxesaxis1axis2r   )r   r/   ri  r  )r  r1  r2  
axes_tuple	axes_listrp   s       rC   r   znumpy_swapaxes.<locals>.impl  sr    }gtUC}gtUC 19TME19TME"9eU;
":ue<
||Az**rE   )
r   r   r   r   r	   r   r   rp   r   r8   )r  r1  r2  r   r4  rp   s       @@rC   numpy_swapaxesr5    s    ec5==12   "+ , 	,ec5==12   "+ , 	,a%  !JKK 66DeDk"I+ KrE   c                 (   t        dd| j                  |      }t        | j                        }d||<   t	        t        ||j                              D ]7  \  }\  }}	|dk(  r|	}
n|	dk(  r|}
n||	k7  rt        d      |}
t        |||
      }9 t        ||| j                  |         }t        j                  | |      } t        j                  ||      }|}t        |      dkD  r3t        t        |            D ]  }t        ||| j                  |         } |}t        |      dkD  r9t        t        |            D ]"  }t        ||| j                  |dz   |z            }$ |j                  |   }t        j                  ||fz   |z   | j                        }t        d d d       f}t        j                  |      D ]X  }t        j                  |      D ]>  }| ||z   |z      }|||z   |z      }|||z   |z      }t        |      D ]  }|||      ||<    @ Z |S )Nznp.take_along_axisr   rG   z*`arr` and `indices` dimensions don't matchr   )r   rp   r   re   r  r   r   r/   ri  ro  r   r8   r  r{   r,  r  )r  r   r   Ni_origNk_origindices_broadcast_shape	arr_shaperm   d1d2new_valarr_broadcast_shapeNiNkJr   np_s_iikka_1d
indices_1dout_1dr"  s                          rC   _take_along_axis_implrH    s4    .$GD SYYIIdO Y!>? 
8B7G1WGRx @  G"/#Q#

 (syy //#2
3Coog'>?G	B
7|as2w 	4Ar1ciil3B	4	B
7|as2w 	?Ar1ciiq1&=>B	? 	dA
((29r>399
-C4t$&Ejjn 0**R. 	0BrEzB'D eb1Jeb)F1X 0 A/q	0		00 JrE   c                    t        | t        j                        st        j                  d      t        |t        j                        st        j                  d      t        |j
                  t        j                        st        j                  d      t        |      rd}n| j                  }||j                  k7  rt        j                  d      t        t        |j                              t        |      rfd}|S t        |d       t        |t        j                        st        j                  d      |j                  }|d	k  r| j                  |z   }|d	k  s|| j                  k\  rt        j                  d
      t        t        |            t        t        |dz   | j                              fd}|S )Nz)The first argument "arr" must be an arrayz.The second argument "indices" must be an arrayz'The indices array must contain integersrG   z;`indices` and `arr` must have the same number of dimensionsc                 @    t        | j                         |ddd      S )Nr   rp  )rH  rr  )r  r   r   r9  s      rC   take_along_axis_implz1arr_take_along_axis.<locals>.take_along_axis_impl#  s%    (B)@B BrE   r   zaxis must be a literal valuer   zaxis is out of boundsc                 $    t        | ||      S r;  )rH  )r  r   r   r?  r@  r9  s      rC   rK  z1arr_take_along_axis.<locals>.take_along_axis_impl4  s    (gtR)@B BrE   )r   r   r   r	   r   r{   r   r   rp   r   r8   r   ru  r,  r   )r  r   r   arr_ndimrK  r?  r@  r9  s        @@@rC   arr_take_along_axisrN    su   c5;;'  !LMMgu{{+  <> 	>gmmU]]3  !JKK4887<<  I
 	
 $E',,$784	B(  ! 	v&$ 4 45(()GHH!!!888d?D!8tsxx'(()@AA5;5388,-	B  rE   c                    t        | t        j                        rut        | t        j                        rd	d}|S t        | t        j                        rd	d}|S t        | t        j
                        rd	d}|S t        j                  d      t        |       rt        | j                  t        j                        rd	d}|S t        | j                  t        j                        rd	d}|S t        | j                  t        j
                        rd	d}|S t        j                  d      t        j                  d      )
Nc                     | S r;  rp  rC  rK  nans      rC   r   znan_to_num_impl.<locals>.impl?      rE   c                 (   t        j                  |       r|S t        j                  |       r(t        j                  t	        |             j
                  S t        j                  |       r(t        j                  t	        |             j                  S | S r;  )ri  isnanisneginffinfor9   r  isposinfr  rQ  s      rC   r   znan_to_num_impl.<locals>.implC  s_    88A;J[[^88DG,000[[^88DG,000rE   c                     t        j                  | j                  |      }t        j                  | j                  |      }t	        ||      S )N)rR  )ri  
nan_to_numr  r  complex)rC  rK  rR  r{  r  s        rC   r   znan_to_num_impl.<locals>.implL  s6    MM!&&c2MM!&&c2q!}$rE   z4Only Integer, Float, and Complex values are acceptedc                     | S r;  rp  rQ  s      rC   r   znan_to_num_impl.<locals>.implX  rS  rE   c                    t        j                  | j                        j                  }t        j                  | j                        j                  }t        j
                  |       }|rt        j                  |      n|}|j                  }t        |j                        D ]\  }t        j                  ||         r|||<   !t        j                  ||         r|||<   ?t        j                  ||         sX|||<   ^ |S r;  )ri  rW  r{   r  r  rj  rK  r  r8   r   rU  rV  rX  )	rC  rK  rR  min_infmax_infx_outputoutput_flatrm   s	            rC   r   znan_to_num_impl.<locals>.impl[  s    ((177+//((177+//ZZ](,"$kkv{{+ 1AxxA/),A[^4)0A[^4)0A1 rE   c                     t        j                  |       }|rt        j                  |      n|}t        j                  |j                  d|       t        j                  |j
                  d|       |S )NF)rK  rR  )ri  rj  rK  rZ  r  r  )rC  rK  rR  r`  ra  s        rC   r   znan_to_num_impl.<locals>.impll  sM    ZZ](,"fkk3?fkk3?rE   z4The first argument must be a scalar or an array-likeTg        )
r   r   r  r   rD  r  r	   r   r   r{   )rC  rK  rR  r   s       rC   nan_to_num_implre  :  s   !U\\"a'v Kq 5;;'n K_ 5==)%\ KS $$F  
!	aggu}}-D KA -> K / K $$F     ". / 	/rE   r;  r
  r  r  r  )Fr  rd  (  ro  r4  rM  r  r'  llvmliter   llvmlite.irr   numpyri  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.unsafe.tupler/   r0   r1   numba.core.typing.npydeclr2   r  r3   r  r4   r5   r6   rD   rI   rx   r   r   r   r   r   r   r   r   r   r   r   r   r  ArrayIteratorBORROWEDr  r/  r   r5  r  r   r  r8  rG  rE  rK  AnyrL  r   rQ  r   rX  r]  r3  r_  rr  r  r  r  r  r  rB  r  r  r
  r  r  r2  r;  rG  rO  rX  r]  rg  rl  ro  rx  r~  broadcast_shapesr  r  r  r  r  r  rI  r  r  r  r  VarArgr  r  r  r  r  r  	geomspacer#  rot90r-  r<  rD  rL  rN  rR  rT  resizerc  ri   rl  ru  rZ  rz  r}  r  r  r  r  r  r  re   r  r   r  uniquer  r  r  r  r  r  r  r  r  r  r  
MemoryViewr  r  r  r  r  r  r#  r'  r,  r/  r5  r2  r8  r  r  r<  rC  rG  rE  rI  rK  rR  rV  rP  rh  rl  DTypeNumberClassrq  r}  r  rs  r  r  r  ru  r  r  r  r  r  Bytesr  is_r  r  r  r  r  r  r4  r>  r  re  ra  rg  rj  rl  rn  r  rr  rp  rt  r  rx  rz  rv  r|  r  r~  NumpyNdIterTyper  eqr  r  r  r  r  r  r  rT  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
  eyer  diagr  r   r  diagflatr$  r,  r-  r?  rJ  r  r^  r  rh  rl  rn  rp  rK  rt  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,  r5  r<  r>  rB  r]  rH  rJ  rR  column_stackrW  rY  r]  stackr`  rc  rk  rt  ro  ry  vstackr|  	row_stackr  dstackr  r  r  r*  r  r+  r  r  flipr  r  r  r  r  vsplitr  hsplitr  dsplitr  r  r  r  r  r  r  r  argsortr  r  UnicodeCharSeqrD  r  r  NPTimedelta
NPDatetimer  r  r  type_callabler  r  libstride_tricksr  r"  rH  r.  r)  r5  rH  take_along_axisrN  rZ  re  rp  rE   rC   <module>r     s  
         * H H; ; ; P O* * * * ( *A A + ! L 5E E#69x(-M	

  BJH& 
 
. , y%,,' (.;* z5../w - ! 0-6  $A4H ;* xu}}=xu?E @ >E xu?E @E0 xuyy%))D%6 E%6P sELL!F "F |U[[)8 *8 6?EKK;) <)(/"f /"d/-G /-dW >:-' :-zN-' N-bB-7 B-JL6 L^(GV xu{{;; <;&'TH
:$z"J!. 4  ,  " 5 5>- 
"//'& '&T 3 3  
"

% %P 
"

6 6r 

"95
 6
 

"51 2*U%v&  %++.; /;
  %++u?3E @3El  %++|u||EII/FGF HF
 
",,  u{{C 9 !9& 
"++  
",,I IX 
"(( 4!H;< U__==E >=E@ \U\\%))-DE> F>
 6bjj 
 bjj  
"))+ +\ 
")) 2 }ekk* +, rxx%G &G , - 
 
   
"''v vr f% &{| 
"((  
"''  
"))  
")))1 )1X  " 5;;1 2  	 

9-( .(V |U[[%//:E ;EH u{{G$: %:
 u{{G$u): * %: u{{I&u+: , ': u{{F#u(: ) $:
 u{{F#: $: u{{J'u,: - (: u{{H%u*: + &: u.: /:
 u0: 1:
 u0: 1:
 u,: -: u{{H%	9 &	9 u  &): *: Eu~~.Eu}}-; . /;4 u{{G$8 %8 u.u0	: 1 /	: u0
: 1
:  u{{F#Q $Q u{{F#Q $Q 4Mn f%k* + &%
 #ekk6 ": . "ekk6 ": . !2!2EII>( ?(. u{{#4; $4;n e.A.ABO CO u||$$= %$=N u||$D %D: u/B/BCA DA u/C/CDE EE u/B/BEIIN	% O	% u/C/CUYYO
% P
%" ; ; 3 3 9 9 x||U[[%++6
G 7
G  EKK, -9> IM6:#D '+OEP
>BTn u{{F#P $P z5../w E ! 0E x!4!4emmDE EE x!4!4emmyy%% sE''( ) r~~u{{+E ,E" z5556w C ! 7C xemm45rzz<5<<67
E 8 6
E x)rzz5??+E , *E* z5112w 7 ! 37 ryy%))$> %>& z5001w 7 ! 27 x{{EKK5F 6FL^ ekk;/ 0* 
 
-`K#&   
"((" & &*   
"-- 0   l+ , 
"(("   
"--  
",,
 
 
"''   
",,
 
 
"''  
"++ 	 %& ' BFF1E  2 
"''# #L 
"** 6 
"++ 4  F 
"''f%W & Wt4 
"))@ @F 
"++' 'T"PJ   |U[[)4 *4 
"'' ><B ? ? 
"


  
 
"

  ~u{{EOO<~u{{E,?,?@P A =P: ( (V 
"--%*  6 
&  
& !H1Dh"<&'R&#R)  2 
"(( &?:@:8    
".. %2. 
"--# #
 
"--& &
 
"--) )
:z/FdVFr,$    
"..  " "J 
"//    
"((   4 
"))   4 
"))  FHR\\>* & &R 
"))  5;;/ 0 5;;. / 
"))   
"))    : 
"''
 
 
"..; ;| 
"((C C4 
")) & 
")) * 
")) , 
0 |U[[)
I *
I 
"''	 	 U-@-@Arzz5;;(;(;<9 = B9& EKK% & EKK--.EKK%EKK'EKK'EKK'EKK**+EKK))*F + , ( ( ( & /F EKK--.E /E *+ ,"  %++uP; Q;* BFF((334 58 BFF((<<=[$ >[$| 
$ & 
"++ > 8 8v 
"

(  ( V 
"--? ?rE   