o
    Tdg                    @   sX  d Z ddlZddlZddlmZ ddlZddlZddlm	Z	m
Z
mZmZ ddlmZ ddlmZmZmZ ddlmZmZ ddlmZmZmZ d	d
lmZmZmZ ddlmZ  e!dZ"e"# Z$e$Z%e!dZ&e&# Z'ej(Z(e(# Z)ej*Z+ej*Z,ej-dej.dej/dej0diZ1dddZ2dd Z3dd Z4dd Z5G dd dZ6G dd dZ7ej8dd  Z9d!d" Z:d#d$ Z;d%d& Z<d'd( Z=d)d* Z>d+d, Z?d-d. Z@d/d0 ZAd1d2 ZBdd4d5ZCeejDd6d7 ZEeejFd8d9 ZGd:d; ZHeejId<d= ZId>d? ZJd@dA ZKdBdC ZLdDdE ZMeejDdFdG ZNeOdHeP ZQedIdJ ZRddLdMZSdNdO ZTdPdQ ZUeeUdRdS ZVedTdU ZWedVdW ZXeejYjZdXdY Z[edZd[ Z\dd\d]Z]eejYj^d^d_ Z_eejYj`d`da ZaeejYjbdbdc ZceejYjdddde ZeeejYjfdfdg ZgeejYjhddhdiZieejYjjdjdk Zkdldm Zleeldndo Zmdpdq Zneendrds Zodtdu Zpeepdvdw Zqdxdy Zreerdzd{ Zsd|d} Zteetd~d Zudd Zveevdd ZweejYjxdddZydd Zzeezdd Z{eejYj|dd Z}eejYj~dddZdd ZeejYjdd ZeejYjdd Zdd Zeedd Zdd Zeedd Zdd ZeejYjdddZeejYjdddZedd ZeejYjdddZeejYjdd ZeejdddZdddZedd Zedd Zdd ZeejdddZdd Zdd Zeejdd ZdS )z.
Implementation of linear algebra operations.
    N)ir)lower_builtinimpl_ret_borrowedimpl_ret_new_refimpl_ret_untracked)	signature)	intrinsicoverloadregister_jitable)typescgutils)TypingErrorNumbaTypeErrorNumbaPerformanceWarning   )
make_array_empty_nd_impl
array_copy)numpy_support       sdcz<BLAS function>c                 C   s$   t | }|d u rtd|f |S )Nzunsupported dtype for %s())_blas_kindsget	TypeError)dtype	func_namekind r"   b/home/ncw/WWW/www-new/content/articles/pi-bbp/venv/lib/python3.10/site-packages/numba/np/linalg.pyget_blas_kind0   s   
r$   c                  C   &   zdd l } W d S  ty   tdw Nr   z*scipy 0.16+ is required for linear algebra)scipy.linalg.cython_blasImportErrorscipyr"   r"   r#   ensure_blas7   
   r+   c                  C   r%   r&   )scipy.linalg.cython_lapackr(   r)   r"   r"   r#   ensure_lapack>   r,   r.   c                 C   s   |  |||}t||S N)get_constant_genericr   alloca_once_value)contextbuildertyvalconstr"   r"   r#   make_constant_slotE   s   r7   c                   @   s0   e Zd ZdZdd Zedd Zedd ZdS )	_BLASzM
    Functions to return type signatures for wrapped
    BLAS functions.
    c                 C   
   t   d S r/   )r+   selfr"   r"   r#   __init__P      
z_BLAS.__init__c              	   C   s<   t |d|}ttjtjt|tjt|}td|S )Nunderlying_floatnumba_xxnrm2getattrr   intccharintpCPointerExternalFunctionclsr   rtypesigr"   r"   r#   r?   S   s   z_BLAS.numba_xxnrm2c                 C   s`   t t jt jt jt jt jt jt |t |t jt |t jt |t |t j}t d|S )Nnumba_xxgemmr   rB   rC   rD   rE   rF   rH   r   rJ   r"   r"   r#   rK   ^   s"   z_BLAS.numba_xxgemmN)__name__
__module____qualname____doc__r<   classmethodr?   rK   r"   r"   r"   r#   r8   J   s    

r8   c                   @   s   e Zd ZdZdd Zedd Zedd Zedd	 Zed
d Z	edd Z
edd Zedd Zedd Zedd Zedd Zedd ZdS )_LAPACKzO
    Functions to return type signatures for wrapped
    LAPACK functions.
    c                 C   r9   r/   )r.   r:   r"   r"   r#   r<   y   r=   z_LAPACK.__init__c              
   C   s4   t t jt jt jt |t jt t}t d|S )Nnumba_xxgetrfr   rB   rC   rD   rE   F_INT_nbtyperF   rM   r"   r"   r#   rT   |   s   z_LAPACK.numba_xxgetrfc              	   C   s0   t t jt jt |t jt t}t d|S )Nnumba_ez_xxgetrirU   rM   r"   r"   r#   rW      s   z_LAPACK.numba_ez_xxgetric                 C   sX   t t jt jt jt jt |t jt |t |t |t jt |t j}t d|S )Nnumba_ez_rgeevrL   rM   r"   r"   r#   rX      s   z_LAPACK.numba_ez_rgeevc                 C   sP   t t jt jt jt jt |t jt |t |t jt |t j}t d|S )Nnumba_ez_cgeevrL   rM   r"   r"   r#   rY      s   z_LAPACK.numba_ez_cgeevc                 C   sD   t |d|}ttjtjtjtjt|tjt|}td|S )Nr>   numba_ez_xxxevdr@   )rH   r   wtyperJ   r"   r"   r#   rZ      s   z_LAPACK.numba_ez_xxxevdc                 C   s,   t t jt jt jt |t j}t d|S )Nnumba_xxpotrfrL   rM   r"   r"   r#   r\      s   z_LAPACK.numba_xxpotrfc                 C   s\   t |d|}ttjtjtjtjt|tjt|t|tjt|tj}td|S )Nr>   numba_ez_gesddr@   )rH   r   styperJ   r"   r"   r#   r]      s   z_LAPACK.numba_ez_gesddc              
   C   s4   t t jt jt jt |t jt |}t d|S )Nnumba_ez_geqrfrL   rM   r"   r"   r#   r_      s   z_LAPACK.numba_ez_geqrfc                 C   s8   t t jt jt jt jt |t jt |}t d|S )Nnumba_ez_xxgqrrL   rM   r"   r"   r#   r`      s   	z_LAPACK.numba_ez_xxgqrc                 C   s^   t |d|}ttjtjtjtjt|tjt|tjt|tjttj}td|S )Nr>   numba_ez_gelsd)rA   r   rB   rC   rD   rE   float64rF   rG   r"   r"   r#   ra      s   
z_LAPACK.numba_ez_gelsdc                 C   s@   t t jt jt jt |t jt tt |t j}t d|S )Nnumba_xgesvrU   rM   r"   r"   r#   rc     s   
z_LAPACK.numba_xgesvN)rN   rO   rP   rQ   r<   rR   rT   rW   rX   rY   rZ   r\   r]   r_   r`   ra   rc   r"   r"   r"   r#   rS   s   s2    


	



	



rS   c                 c   s    g }g }g }t |j|D ]9\}}t|tjr|jdv r"||}	}
n|jdd}	t|	|}t| |||f}
|	|	|
f |	|	 |	|
 qt|j
g|R  t|fV  |D ]\}}| j||| qWdS )z
    Ensure that all array arguments are contiguous, if necessary by
    copying them.
    A new (sig, args) tuple is yielded.
    CFClayoutN)zipargs
isinstancer   Arrayrg   copyr   r   appendreturn_typetuplenrtdecref)r2   r3   rJ   ri   newtysnewargscopiesr4   r5   newtynewvalcopysigr"   r"   r#   make_contiguous  s"   

rx   c                    s0   d  fdd}|  ||ttjtj|f dS )z.
    Check whether *n* fits in a C `int`.
    ic                    s   |  krt dd S )Nz$array size too large to fit in C int)OverflowError)n_maxintr"   r#   impl5  s   zcheck_c_int.<locals>.implN)compile_internalr   r   nonerD   )r2   r3   rz   r}   r"   r{   r#   check_c_int/  s
   r   c                 C   X   |j t||dd | |}|  |d W d   dS 1 s%w   Y  dS )z[
    Check the integer error return from one of the BLAS wrappers in
    _helperlib.c.
    Flikelyz#BLAS wrapper returned with an errorNif_thenr   is_not_nullget_python_api
gil_ensurefatal_errorr2   r3   respyapir"   r"   r#   check_blas_return=  
   
"r   c                 C   r   )z]
    Check the integer error return from one of the LAPACK wrappers in
    _helperlib.c.
    Fr   z%LAPACK wrapper returned with an errorNr   r   r"   r"   r#   check_lapack_returnI  r   r   c                 C   s   t t dttttttg}t|j|d}	t	|}
t 
tt|
}t 
tt|}||	|||||t||t||tf}t| || dS )zQ
    Call the BLAS vector * vector product function for the given arguments.
    r   numba_xxdotN)r   FunctionTypeIntTypell_charintp_t	ll_void_pr   get_or_insert_functionmoduler$   Constantordintcallbitcastr   )r2   r3   	conjugater   rz   a_datab_dataout_datafntyfnr!   kind_valr   r"   r"   r#   
call_xxdotU  s   


r   c                 C   s  t t dttttttttttg
}t|j|d}	|j	}
t
| ||
d}t
| ||
d}|jdkr:|\}}|d }n|\}}|d }t|
}t tt|}t t|rWtdntd	}||	||||||t||t|||t||t||tf
}t| || d
S )zQ
    Call the BLAS matrix * vector product function for the given arguments.
    r   numba_xxgemv      ?        Fr   r   trz   N)r   r   r   r   r   r   r   r   r   r   r7   rg   r$   r   r   r   r   r   )r2   r3   do_transm_typem_shapesm_datav_datar   r   r   r   alphabetamrz   ldar!   r   transr   r"   r"   r#   call_xxgemvk  s6   





r   c           !         s8  t t dttttttttttttttg}t j|d}|\}}|\}}|j	}t
|  |d}t
|  |d}t ttdt ttd fdd}||||\}}}||||\}}}||	|
\}}}t|}t tt|} ||||||| |t|||| |t||f} t|  |  d	S )
zQ
    Call the BLAS matrix * matrix product function for the given arguments.
    r   rK   r   r   r   rz   c                    s8   | j j krn| j dkr|d n|d  |tfS )Nre   r   r   )rg   r   r   )r4   shapesdatar3   notransout_typer   r"   r#   get_array_param  s   
z$call_xxgemm.<locals>.get_array_paramN)r   r   r   r   r   r   r   r   r   r   r7   r   r   r$   r   r   r   )!r2   r3   x_typex_shapesx_datay_typey_shapesy_datar   
out_shapesr   r   r   r   k_krz   r   r   r   r   transar   data_atransbldbdata_b_ldcdata_cr!   r   r   r"   r   r#   call_xxgemm  s:   
r   c                 C   (   dd }|  ||||}t| ||j|S )z 
    np.dot(matrix, matrix)
    c                 S   sN   | j \}}|j \}}|dkrt||f| jS t||f| j}t| ||S Nr   shapenpzerosr   emptydot)abr   r   r   rz   outr"   r"   r#   dot_impl  s   

zdot_2_mm.<locals>.dot_implr~   r   rn   r2   r3   rJ   ri   r   r   r"   r"   r#   dot_2_mm     r   c                 C   r   )z 
    np.dot(vector, matrix)
    c                 S   sH   | j \}|j \}}|dkrt|f| jS t|f| j}t| ||S r   r   )r   r   r   _mrz   r   r"   r"   r#   r     s   
zdot_2_vm.<locals>.dot_implr   r   r"   r"   r#   dot_2_vm  r   r   c                 C   r   )z 
    np.dot(matrix, vector)
    c                 S   sH   | j \}}|j \}|dkrt|f| jS t|f| j}t| ||S r   r   )r   r   r   rz   _nr   r"   r"   r#   r     s   
zdot_2_mv.<locals>.dot_implr   r   r"   r"   r#   dot_2_mv  r   r   Fc              	   C   s   |j \}}|j}t|| ||d }t|| ||d }	t||j\}
dd }| ||ttj	g|j R  | t
| ||
 t|| |}t| ||||
|j|	j| ||S )z<
    np.dot(vector, vector)
    np.vdot(vector, vector)
    r   r   c                 S   s$   | j \}|j \}||krtdd S )Nz;incompatible array sizes for np.dot(a, b) (vector * vector)r   
ValueError)r   r   r   rz   r"   r"   r#   
check_args  s
   zdot_2_vv.<locals>.check_args)ri   rn   r   r   unpack_tupler   r~   r   r   r   r   alloca_onceget_value_typer   r   load)r2   r3   rJ   ri   r   atybtyr   r   r   rz   r   r   r"   r"   r#   dot_2_vv  s   

r   c                 C      t d| |S )z
    np.dot(a, b)
    znp.dot()
dot_2_implleftrightr"   r"   r#   dot_2     r   c                 C   r   )z
    a @ b
    z'@'r   r   r"   r"   r#   matmul_2  r   r   c                    sh   t |tjr0t |tjr2tfdd |jdvs|jdvr*td||ff t  fddS d S d S )Nc                    s   |j |j f  fdd}|j|jkrtd  dkr%t|jdd}n dks- dkr6t|jd	d}n d
kr>|j}ntd t||||fS )Nc                    s   t   t| |||O\}} dkrt| |||W  d    S  dkr1t| |||W  d    S  dkrCt| |||W  d    S  dkrUt| |||W  d    S td1 s\w   Y  d S )N   r   r   r   r   r   r   r   unreachable)r+   rx   r   r   r   r   AssertionErrorr2   r3   rJ   ri   ndimsr"   r#   _dot2_codegen#  s    
z0dot_2_impl.<locals>._impl.<locals>._dot2_codegenz)%s arguments must all have the same dtyper   r   re   r   r   r   r   z*%s: inputs must have compatible dimensions)ndimr   r   r   rk   r   )typingcontextr   r   r   rn   )namer   r#   _impl  s    zdot_2_impl.<locals>._implrd   z/%s is faster on contiguous arrays, called on %sc                    
    | |S r/   r"   r   r  r"   r#   <lambda>F     
 zdot_2_impl.<locals>.<lambda>rj   r   rk   r   rg   warningswarnr   )r  r   r   r"   )r  r  r#   r     s   !r   c                    sb   t | tjr-t |tjr/tdd  | jdvs|jdvr'td| |ff t  fddS dS dS )z
    np.vdot(a, b)
    c                 S   sJ   dd }|j dks|j dkrtd|j|jkrtdt|j|||fS )Nc                 S   sN   t   t| |||\}}t| |||ddW  d    S 1 s w   Y  d S )NT)r   )r+   rx   r   r   r"   r"   r#   codegenQ  s
   $z$vdot.<locals>._impl.<locals>.codegenr   z&np.vdot() only supported on 1-D arraysz0np.vdot() arguments must all have the same dtype)r   r   r   r   )r   r   r   r
  r"   r"   r#   r  O  s   zvdot.<locals>._implrd   6np.vdot() is faster on contiguous arrays, called on %sc                    r  r/   r"   r   r  r"   r#   r  e  r  zvdot.<locals>.<lambda>Nr  r   r"   r  r#   vdotI  s   
r  c                 C   s:   | j \}|j \}}||krtd|j |fkrtdd S )Nz;incompatible array sizes for np.dot(a, b) (vector * matrix)zFincompatible output array size for np.dot(a, b, out) (vector * matrix)r   )r   r   r   r   r   rz   r"   r"   r#   dot_3_vm_check_argsh  s   
r  c                 C   s:   | j \}}|j \}||krtd|j |fkrtdd S )Nz;incompatible array sizes for np.dot(a, b) (matrix * vector)zFincompatible output array size for np.dot(a, b, out) (matrix * vector)r   )r   r   r   r   r   rz   r"   r"   r#   dot_3_mv_check_argss  s   
r  c                 C   s.  |j \}}}||jksJ |j}t|| ||d }t|| ||d }	t|| ||d }
t||j}t||	j}t||
j}|j|jk rd|}|}|d }|d }|jdk}|	j	|j	}}t
}n|}|}|d }|d }|jdk}|j	|	j	}}t}| ||ttjg|j R  | |D ]}t| || q| tjd}|d||}|d||}|||}|j|ddI\}}| t||
j	||
j|
jd W d	   n1 sw   Y  | t| |||||||
j	 W d	   n1 sw   Y  W d	   n	1 sw   Y  t| ||j|
 S )
zE
    np.dot(vector, matrix, out)
    np.dot(matrix, vector, out)
    r   r   r   r   re   ==Fr   N)ri   rn   r   r   r   r   r   r   rg   r   r  r  r~   r   r   r   r   get_constantrD   icmp_signedor_if_elsememsetmulitemsizenitemsr   r   	_getvalue)r2   r3   rJ   ri   xtyytyouttyr   xyr   r   r   r   mtyr   v_shaper   r   r   r   r   r5   zero
both_emptymatrix_emptyis_emptyr   nonemptyr"   r"   r#   dot_3_vm~  sb   



r%  c           '      C   s  |j \}}}||jksJ |j}t|| ||d }t|| ||d }	t|| ||d }
t||j}t||	j}t||
j}|\}}|\}}|jdksRJ dd }| ||t	t
jg|j R  | t| || t| || t| || |j}|	j}|
j}| t
jd}|d||}|d||}|d||}|||||}|j|dd	I\}}| t||
j||
j|
jd W d
   n1 sw   Y  | | t
jd}|d||}|d||}||\} }!| b ||L\}"}#|" t| |d||||| W d
   n	1 sw   Y  |# |j|jk}$t| ||$||||| W d
   n	1 s<w   Y  W d
   n	1 sLw   Y  W d
   n	1 s\w   Y  |!e ||O\}%}&|% |j|jk}$t| ||$||||| W d
   n	1 sw   Y  |& t| |||||||||| W d
   n	1 sw   Y  W d
   n	1 sw   Y  W d
   n	1 sw   Y  W d
   n	1 sw   Y  W d
   n	1 sw   Y  W d
   n	1 sw   Y  t| ||j|
 S )z%
    np.dot(matrix, matrix, out)
    r   r   r   re   c                 S   s>   | j \}}|j \}}||krtd|j ||fkrtdd S )Nz;incompatible array sizes for np.dot(a, b) (matrix * matrix)zFincompatible output array size for np.dot(a, b, out) (matrix * matrix)r   )r   r   r   r   r   r   rz   r"   r"   r#   r     s   

zdot_3_mm.<locals>.check_argsr  Fr   N)ri   rn   r   r   r   r   r   rg   r~   r   r   r   r   r   r  rD   r  r  r  r  r  r  r  r   r   r   r   r  )'r2   r3   rJ   ri   r  r  r  r   r  r  r   r   r   r   r   r   r   rz   r   r   r   r   r   r!  x_emptyy_emptyr#  r   r$  oneis_left_vecis_right_vecr_vecr_matv_vm_vr   v_mm_mr"   r"   r#   dot_3_mm  s   





&r1  c                    s|   t | tjr8t |tjr:t |tjr<tdd  | jdvs'|jdvs'|jdvr2td| |ff t  fddS dS dS dS )z
    np.dot(a, b, out)
    c                 S   s:   dd }|j |j ks|j |j krtdt|||||fS )Nc                 S   s   t   t| |||<\}}tdd |jd d D }|dhkr.t| |||W  d    S |ddhkrBt| |||W  d    S td1 sIw   Y  d S )Nc                 s   s    | ]}|j V  qd S r/   r   ).0r  r"   r"   r#   	<genexpr>  s    z8dot_3.<locals>._impl.<locals>.codegen.<locals>.<genexpr>r   r   r   )r+   rx   setri   r1  r%  r   )r2   r3   rJ   ri   r   r"   r"   r#   r
    s   
z%dot_3.<locals>._impl.<locals>.codegenz/np.dot() arguments must all have the same dtype)r   r   r   )r   r   r   r   r
  r"   r"   r#   r    s   zdot_3.<locals>._implrd   r  c                        | ||S r/   r"   r   r   r   r  r"   r#   r  1  s    zdot_3.<locals>.<lambda>Nr  r7  r"   r  r#   dot_3  s    

r8  numba_fatal_errorc                 C   s.   t | D ]}t | st jdqd S )Nz$Array must not contain infs or NaNs.)r   nditerisfiniteitemlinalgLinAlgError)r   vr"   r"   r#   _check_finite_matrix7  s   r@  Tc                 C   s   |rdnd}||f}t | tjr| j} t | tjs#d| }t|dd| jdks2d| }t|ddt | jtjtj	fsFd| }t|ddd S )	N	np.linalgr   z&%s.%s() only supported for array typesFhighlightingr   z%%s.%s() only supported on 2-D arrays.3%s.%s() only supported on float and complex arrays.)
rj   r   Optionaltyperk   r   r   r   FloatComplex)r   r    	la_prefixprefixinterpmsgr"   r"   r#   _check_linalg_matrix?  s    
rM  c                 G   s>   |d j }|dd  D ]}|j |krd|  }t|ddqd S )Nr   r   zAnp.linalg.%s() only supports inputs that have homogeneous dtypes.FrB  )r   r   )r    r   t0r   rL  r"   r"   r#   _check_homogeneous_typesT  s   

rO  c                   C   s   d S r/   r"   r"   r"   r"   r#   _copy_to_fortran_order\     rP  c                    s&   | j dk| j dk  fdd}|S )Nr   Ac                    sP   r	t | }|S  r!| jj}|rt | jj}|S t | }|S t | }|S r/   )r   rl   flagsf_contiguousTasfortranarray)r   acpyflag_fA_layoutF_layoutr"   r#   r}   f  s   


z&ol_copy_to_fortran_order.<locals>.implrf   )r   r}   r"   rY  r#   ol_copy_to_fortran_order`  s   

r\  c                 C   s6   | dkr| dk rt   J | dkrtjdd S d S )Nr   z(Matrix is singular to machine precision.)fatal_error_funcr   r=  r>  rr"   r"   r#   _inv_err_handler|  s   r`  c                 C   s   | d S )zFpass a list of variables to be preserved through dead code eliminationr   r"   r   r"   r"   r#   _dummy_liveness_func  s   rb  c                    P   t   t| d t | jt | jtt| jd  fdd}|S )Ninvc                    s   | j d }| j d |krd}tj|t|  t| }|dkr"|S tj|td} |||j||j}t	|  ||j||j}t	| t
|j|jg |S )N.Last 2 dimensions of the array must be square.r   r   )r   r   r=  r>  r@  rP  r   F_INT_nptypectypesr`  rb  size)r   rz   rL  rW  ipivr_  r!   rT   numba_xxgetrir"   r#   inv_impl  s   
zinv_impl.<locals>.inv_impl)r.   rM  rS   rT   r   rW   r   r$   )r   ro  r"   rm  r#   ro    s   
ro  c                 C   s2   | dkr| dk rt   J | dkrtdd S d S )Nr   z&Internal algorithm failed to converge.)r]  r   r^  r"   r"   r#   %_handle_err_maybe_convergence_problem  s   rp  c                 C   sf   |rdnd}||f}t | tjstd| | jdks!td| t | jtjtjfs1td| d S )NrA  r   z'%s.%s() only supported for array types r   +%s.%s() only supported on 1 and 2-D arrays rD  )rj   r   rk   r   r   r   rG  rH  r   r    rI  rJ  rK  r"   r"   r#   _check_linalg_1_or_2d_matrix  s   
rs  c                    sR   t   t| d t | jtt| jdtd td} fdd}|S )NcholeskyULc                    s   | j d }| j d |krd}tj||  }|dkr|S  ||j|}|dkr>|dk r4t  J |dkr>tjdt|D ]
}d|d ||f< qB|S )Nre  rf  rg  r   z Matrix is not positive definite.)r   r   r=  r>  rl   rj  r]  range)r   rz   rL  r   r_  colUPr!   r\   r"   r#   cho_impl  s&   
zcho_impl.<locals>.cho_impl)r.   rM  rS   r\   r   r   r$   )r   LOr{  r"   ry  r#   r{    s   
r{  c                    s   t   t| d t | jt | jtt| jdtd td fdd} fdd}t| jt	j
jrB|S |S )NeigNVc                    s  | j d }| j d |krd}tj|t|  t| }d}|}tj|| jd}tj|| jd}tj||f| jd}tj||f| jd}	|dkrM||	jfS  ||j	||j	|j	|j	||	j	|}
t
|
 t|rntdt|j|j|	j|j|jg ||	jfS )z7
        eig() implementation for real arrays.
        re  rf  rg  r   rh  r   z.eig() argument must not cause a domain change.)r   r   r=  r>  r@  rP  r   r   rU  rj  rp  anyr   rb  rk  r   rz   rL  rW  ldvlldvrwrwivlvrr_  JOBVLJOBVRr!   rX   r"   r#   real_eig_impl
  sD   



zeig_impl.<locals>.real_eig_implc           
         s   | j d }| j d |krd}tj|t|  t| }d}|}tj|| jd}tj||f| jd}tj||f| jd}|dkrE||jfS  ||j	||j	|j	||j	|}	t
|	 t|j|j|j|jg ||jfS )z:
        eig() implementation for complex arrays.
        re  rf  rg  r   rh  r   )r   r   r=  r>  r@  rP  r   r   rU  rj  rp  rb  rk  
r   rz   rL  rW  r  r  wr  r  r_  r  r  r!   rY   r"   r#   cmplx_eig_implB  s8   


z eig_impl.<locals>.cmplx_eig_implr.   rM  rS   rX   r   rY   r   r$   rj   r   scalarsrH  )r   r  r  r"   r  r  r!   rY   rX   r#   eig_impl  s   
8(r  c                    s   t   t| d t | jt | jtt| jdtd td fdd} fdd}t| jt	j
jrB|S |S )Neigvalsr~  c                    s   | j d }| j d |krd}tj|t|  t| }d}d}tj|| jd}|dkr.|S tj|| jd}tjd| jd}tjd| jd}	 ||j||j|j|j||	j|}
t	|
 t
|rgtdt|j|j|	j|j|jg |S )z;
        eigvals() implementation for real arrays.
        re  rf  rg  r   rh  r   z2eigvals() argument must not cause a domain change.)r   r   r=  r>  r@  rP  r   r   rj  rp  r  r   rb  rk  r  r  r"   r#   real_eigvals_impl}  sD   

z'eigvals_impl.<locals>.real_eigvals_implc           
         s   | j d }| j d |krd}tj|t|  t| }d}d}tj|| jd}|dkr.|S tjd| jd}tjd| jd} ||j||j|j||j|}	t	|	 t
|j|j|j|jg |S )z>
        eigvals() implementation for complex arrays.
        re  rf  rg  r   rh  r   )r   r   r=  r>  r@  rP  r   r   rj  rp  rb  rk  r  r  r"   r#   cmplx_eigvals_impl  s8   
z(eigvals_impl.<locals>.cmplx_eigvals_implr  )r   r  r  r"   r  r#   eigvals_implo  s   
;)r  c                    p   t   t| d t| jd| j}t|t | jtt	| jdtd td fdd}|S )Neighr>   r  rv  c                    s   | j d }| j d |krd}tj|t|  t| }tj|d}|dkr+||fS  ||j||j}t| t	|j
|j
g ||fS Nre  rf  rg  rh  r   r   r   r=  r>  r@  rP  r   rj  rp  rb  rk  r   rz   rL  rW  r  r_  JOBZUPLOr!   rZ   w_dtyper"   r#   	eigh_impl  s(   
zeigh_impl.<locals>.eigh_impl
r.   rM  rA   r   
np_supportas_dtyperS   rZ   r   r$   )r   w_typer  r"   r  r#   r       

r  c                    r  )Neigvalshr>   r~  rv  c                    s   | j d }| j d |krd}tj|t|  t| }tj|d}|dkr)|S  ||j||j}t| t	|j
|j
g |S r  r  r  r  r"   r#   eigvalsh_impl(  s(   
z$eigvalsh_impl.<locals>.eigvalsh_implr  )r   r  r  r"   r  r#   r    r  r  c                    sr   t   t| d t| jd| j}t|t | jtt	| jdtd tdd fdd	}|S )	Nsvdr>   rR  Sr   c                    s   | j d }| j d }|dks|dkrtjdt|  t| }|}t||}|r0 }|}|}	n}|}|}	tj||f| jd}
tj|d}tj||	f| jd}||||j	||j	|
j	||j	|	}t
| t|j|j|
j|jg |
j||jfS )Nre  rf  r   Arrays cannot be emptyrh  )r   r   r=  r>  r@  rP  minr   r   rj  rp  rb  rk  rU  )r   full_matricesrz   r   rW  lduminmnr  ucolldvtur   vtr_  JOBZ_AJOBZ_Sr!   r]   s_dtyper"   r#   svd_implY  sD   


zsvd_impl.<locals>.svd_implr   )
r.   rM  rA   r   r  r  rS   r]   r   r$   )r   r  s_typer  r"   r  r#   r  H  s   

.r  c                    rc  )Nqrc                    sJ  | j d }| j d }|dks|dkrtjdt|  t| }|}t||}tj|| jd} |||j	||j	}|dk rCt
  J tj||f| jdj}t|D ]}	t|	d D ]}
||
|	f ||
|	f< qZqRt||D ]}	t|D ]}
||
|	f ||
|	f< qsqm ||||j	||j	}t| t|j|jg |d d d |f |fS )Nre  rf  r   r  rh  r   )r   r   r=  r>  r@  rP  r  r   r   rj  r]  r   rU  rw  rp  rb  rk  )r   rz   r   qr   r  tauretr_  ijr!   r_   r`   r"   r#   qr_impl  sR   


	zqr_impl.<locals>.qr_impl)r.   rM  rS   r_   r   r`   r   r$   )r   r  r"   r  r#   r    s   
9r  c                 C      t )z;
    Correctly copy 'b' into the 'bcpy' scratch space.
    NotImplementedErrorbcpyr   nrhsr"   r"   r#   _system_copy_in_b     r  c                 C   s"   |j dkrdd }|S dd }|S )Nr   c                 S   s   || d |j d df< d S )Nre  r   r   r  r"   r"   r#   	oneD_impl  s   z)_system_copy_in_b_impl.<locals>.oneD_implc                 S   s   || d |j d d |f< d S )Nrf  r  r  r"   r"   r#   	twoD_impl  s   z)_system_copy_in_b_impl.<locals>.twoD_implr2  )r  r   r  r  r  r"   r"   r#   _system_copy_in_b_impl  
   
r  c                 C   r  )zK
    Compute the number of right hand sides in the system of equations
    r  r   r"   r"   r#   _system_compute_nrhs  r  r  c                 C   s"   | j dkrdd }|S dd }|S )Nr   c                 S   s   dS Nr   r"   r  r"   r"   r#   r    rQ  z,_system_compute_nrhs_impl.<locals>.oneD_implc                 S   s
   | j d S )Nre  r  r  r"   r"   r#   r    r=   z,_system_compute_nrhs_impl.<locals>.twoD_implr2  )r   r  r  r"   r"   r#   _system_compute_nrhs_impl  r  r  c                 C   r  )zD
    Check that AX=B style system input is dimensionally valid.
    r  r   r   r"   r"   r#   !_system_check_dimensionally_valid  r  r  c                 C   &   |j }|dkrdd }|S dd }|S )Nr   c                 S   s,   | j d }|j d }||krtjdd S )Nrf  re  <Incompatible array sizes, system is not dimensionally valid.r   r   r=  r>  r   r   ambmr"   r"   r#   r       

z9_system_check_dimensionally_valid_impl.<locals>.oneD_implc                 S   s,   | j d }|j d }||krtjdd S )Nrf  r  r  r  r"   r"   r#   r    r  z9_system_check_dimensionally_valid_impl.<locals>.twoD_implr2  r   r   r   r  r  r"   r"   r#   &_system_check_dimensionally_valid_impl  s   r  c                 C   r  )z:
    Check that AX=B style system input is not empty.
    r  r  r"   r"   r#   _system_check_non_empty  r  r  c                 C   r  )Nr   c                 S   sF   | j d }| j d }|j d }|dks|dks|dkr!tjdd S Nrf  re  r   r  r  )r   r   r  anr  r"   r"   r#   r  (  s   


z/_system_check_non_empty_impl.<locals>.oneD_implc                 S   sX   | j d }| j d }|j d }|j d }|dks$|dks$|dks$|dkr*tjdd S r  r  )r   r   r  r  r  bnr"   r"   r#   r  0  s   



 z/_system_check_non_empty_impl.<locals>.twoD_implr2  r  r"   r"   r#   _system_check_non_empty_impl$  s   r  c                 C   r  )z:
    Compute the residual from the 'b' scratch space.
    r  )r   rz   r  r"   r"   r#   _lstsq_residual:  r  r  c                    s   | j }| j}tt|d| |dkr)t|tjr! fdd}|S  fdd}|S |dks/J t|tjr= fdd}|S  fd	d}|S )
Nr>   r   c                    s6   t jd d}t t | |d df d |d< |S Nr  rh  r   r   )r   r   sumabsr   rz   r  r   
real_dtyper"   r#   
cmplx_implI  s   $z(_lstsq_residual_impl.<locals>.cmplx_implc                    s0   t jd d}t | |d df d |d< |S r  )r   r   r  r  r  r"   r#   	real_implO  s   z'_lstsq_residual_impl.<locals>.real_implr   c                    sD   t j| d}t|D ]}t t | |d |f d ||< q|S Nrh  r   )r   r   rw  r  r  r   rz   r  r   r   r  r"   r#   r  W  s   &c                    s>   t j| d}t|D ]}t | |d |f d ||< q|S r  )r   r   rw  r  r  r  r"   r#   r  ^  s    )r   r   r  r  rA   rj   r   rH  )r   rz   r  r   r   r  r  r"   r  r#   _lstsq_residual_implA  s   r  c                 C   r  )z
    Extract 'x' (the lstsq solution) from the 'bcpy' scratch space.
    Note 'b' is only used to check the system input dimension...
    r  r   r  rz   r"   r"   r#   _lstsq_solutionf     r  c                 C   s"   | j dkrdd }|S dd }|S )Nr   c                 S   s   |j  d | S r/   rU  ravelr  r"   r"   r#   r  q  s   z'_lstsq_solution_impl.<locals>.oneD_implc                 S   s   |d |d d f   S r/   rl   r  r"   r"   r#   r  u  s   z'_lstsq_solution_impl.<locals>.twoD_implr2  )r   r  rz   r  r  r"   r"   r#   _lstsq_solution_impln  r  r        c                    s   t   t| d t|d td| | t| j| j}t|d|}t|t 	| jt
t|d d fdd	}|S )Nlstsqr>   r  c                    s2  | j d }| j d }t|}t|  t| t| | t| | t||}t||}t| }tj	||fdj
}	t|	|| tj	|d}
tj	dtjd} ||||j||	j||
j||j}t| |d }||k so||krwtj	dd}nt|	||}t||	|}t|j|	j|
j|jg ||||
d | fS )Nre  rf  rh  r   r   )r   r  r@  r  r  r  maxrP  r   r   rU  r  int32rj  rp  r  r  rb  rk  )r   r   rcondrz   r   r  r  maxmnrW  r  r   rank_ptrr_  rankr   r  r!   np_dtra   r  r"   r#   
lstsq_impl  sF   





zlstsq_impl.<locals>.lstsq_implr  )r.   rM  rs  rO  r  r  r   rA   rS   ra   r   r$   )r   r   r  nb_dtr_typer  r"   r  r#   r  z  s   


?r  c                 C   r  )z
    Extract 'x' (the solution) from the 'bcpy' scratch space.
    Note 'b' is only used to check the system input dimension...
    r  r   r  r"   r"   r#   _solve_compute_return  r  r  c                 C   s"   | j dkrdd }|S dd }|S )Nr   c                 S   s
   |j  S r/   r  r  r"   r"   r#   r    r=   z-_solve_compute_return_impl.<locals>.oneD_implc                 S   s   |S r/   r"   r  r"   r"   r#   r    rQ  z-_solve_compute_return_impl.<locals>.twoD_implr2  )r   r  r  r  r"   r"   r#   _solve_compute_return_impl  r  r  c                    sh   t   t| d t|d td| | t| j| j}t | jt	t
|d  fdd}|S )Nsolvec              	      s   | j d }t|}t|  t| t| | t| }tj||fdj}|dkr-t||S t	||| tj|t
d} |||j||j|j|}t| t|j|j|jg t||S )Nre  rh  r   )r   r  r@  r  rP  r   r   rU  r  r  ri  rj  r`  rb  rk  )r   r   rz   r  rW  r  rl  r_  r!   r   rc   r"   r#   
solve_impl  s0   




zsolve_impl.<locals>.solve_impl)r.   rM  rs  rO  r  r  r   rS   rc   r   r$   )r   r   r  r
  r"   r	  r#   r
    s   

)r
  V瞯<c              
      s   t   t| d t| jd| j}t|t | jt 	| jt
t| jdt
d t
dt
dt| j}tjdg|dtjdg|dd f	d	d
	}|S )Npinvr>   r  re   r   rh  r   r  c                    s  | j d }| j d }t|  t| }|dks|dkr$|j | j jS t||}tj||f| j	d}tj|d}tj||f| j	d} |||j
||j
|j
||j
|}	t|	 |d | }
d}t|D ]}|| |
krxd||  ||< |}qf|d7 }||krt|D ]}t|D ]}|||f ||  |||f< qqnt|D ]}|| }t|D ]}|||f | |||f< qq|||j
|j
||j
|j
|j
|}	t|j|j|j|jjjg |j | j jS )Nre  rf  r   rh  r   r   )r   r@  rP  rU  r  reshaper  r   r   r   rj  rp  rw  rb  rk  )r   r  rz   r   rW  r  r  r   r  r_  cut_atcut_idxr   r  r  s_local	JOBTRANSATRANSBr!   r]   rK   r(  r  r   r"   r#   	pinv_implD  s~   
'


zpinv_impl.<locals>.pinv_implr  )r.   rM  rA   r   r  r  rS   r]   r8   rK   r   r$   r   array)r   r  r  dtr  r"   r  r#   r  *  s    

 r  c                 C   s.   t | jtjrtdd }|S tdd }|S )z
    Walks the diag of a LUP decomposed matrix
    uses that det(A) = prod(diag(lup(A)))
    and also that log(a)+log(b) = log(a*b)
    The return sign is adjusted based on the values found
    such that the log(value) stays in the real domain.
    c                 S   sV   |d }d}t | D ]}t|||f }||||f |  }|t| }q
||fS )Ny                r   )rw  r   r  log)rz   r   sgncsgnaccr   abselr"   r"   r#   cmplx_diag_walker  s   z3_get_slogdet_diag_walker.<locals>.cmplx_diag_walkerc                 S   sL   d}t | D ]}|||f }|dk r| }| }|t| }q|d |fS )Nr   )rw  r   r  )rz   r   r  r  r   r?  r"   r"   r#   real_diag_walker  s   z2_get_slogdet_diag_walker.<locals>.real_diag_walker)rj   r   r   rH  r
   )r   r  r  r"   r"   r#   _get_slogdet_diag_walker  s   
	
r   c                    sl   t   t| d t | jtt| jdt| | d t| jd| jd fdd}|S )Nslogdetr   r>   r   c                    s   | j d }| j d |krd}tj||dkr fS t|  t| }tj|td}|||j||j}|dkr@dtj	 fS t
| d}t|D ]}||| |d k }qJ|d@ }|dkrad}t|jg |||S )Nre  rf  rg  r   rh  r   r   )r   r   r=  r>  r@  rP  r   ri  rj  infr`  rw  rb  rk  )r   rz   rL  rW  rl  r_  r  r   ONEZEROdiag_walkerr!   rT   r"   r#   slogdet_impl  s*   
	z"slogdet_impl.<locals>.slogdet_impl)	r.   rM  rS   rT   r   r   r$   r   rA   )r   r'  r"   r#  r#   r'    s   

)r'  c                 C   s   t   t| d dd }|S )Ndetc                 S   s   t j| \}}|t | S r/   )r   r=  r!  exp)r   r  r!  r"   r"   r#   det_impl4  s   zdet_impl.<locals>.det_implr.   rM  )r   r*  r"   r"   r#   r*  -  s   
r*  c                 C   r  )z)
    Compute singular values of *a*.
    r  ra  r"   r"   r#   _compute_singular_values;  r  r,  c                    s   t  | jtt| jdtd t| jd| j}t|t| j}tj	d|dtj	d|d fdd}|S )z>
    Returns a function to compute singular values of `a`
    r  r~  r>   r   rh  c           
         s   | j d }| j d }|dks|dkrtjdt|  |}t||}d}d}t| }tj|d} |||j||jj|j|}	t	|	 t
|jjj|jg |S )z+
        Computes singular values.
        re  rf  r   r  r   rh  )r   r   r=  r>  r@  r  rP  r   rj  rp  rb  rk  )
r   rz   r   r  r  r  r  rW  r   r_  JOBZ_Nr!   np_ret_typer]   r  r  r"   r#   sv_functionW  s6   


z2_compute_singular_values_impl.<locals>.sv_function)
rS   r]   r   r   r$   rA   r  r  r   r   )r   nb_ret_typenp_dtyper0  r"   r-  r#   _compute_singular_values_implB  s   
/r3  c                 C   r  )z.
    Compute the L2-norm of 1D-array *a*.
    r  ra  r"   r"   r#   _oneD_norm_2  r  r4  c                    sL   t | jd| j}t|t | jtt| jd  fdd}|S )Nr>   normc                    sh   t | }tjdd}t| jd | j } || j||j}|dk r(t  J t|j	| j	g |d S )Nr  rh  r   )
lenr   r   r   stridesr  rj  r]  rb  rk  )r   rz   r  jmpr_  r!   r/  xxnrm2r"   r#   r}     s   z_oneD_norm_2_impl.<locals>.impl)rA   r   r  r  r8   r?   r   r$   )r   r1  r}   r"   r9  r#   _oneD_norm_2_impl  s   
r;  c           	         s  t | jd| j}t|}t| j}t | j}tt| jd}| jdkr<|d t	j
fv r5ddd}|S ddd}|S | jdkr|d t	j
fv ro| jdkrTtd	d
  n| jdkr`tdd
  ntdd
  d fdd	}|S t|jjdfdd	}|S J )Nr>   r5  r   c                 S   s   t | S r/   )r4  r   r   r"   r"   r#   r    s   z!_get_norm_impl.<locals>.oneD_implc                 S   s<  t | }|dkr
dS |dkrt| S |tjkr3t| d }td|D ]}t| | }||kr0|}q"|S |tj krUt| d }td|D ]}t| | }||k rR|}qD|S |dkrnd}t|D ]}| | dkrk|d7 }q_|S |dkrd}t|D ]
}|t| | 7 }qx|S d}t|D ]}|t| | | 7 }q|d|  S )Nr   r   r   r   r   )r6  r4  r   r"  r  rw  )r   r   rz   r  r   r5   r"   r"   r#   r    sJ   
r   re   c                 S   s   | S r/   r"   ra  r"   r"   r#   array_prepare	     z%_get_norm_impl.<locals>.array_preparer   c                 S   s   | j S r/   )rU  ra  r"   r"   r#   r=  	  s   c                 S   s   |   S r/   r  ra  r"   r"   r#   r=   	     c                    s(   | j }|dkr	dS  | }t||S )Nr   r   )rk  r4  r  )r   r   rz   a_c)r=  r"   r#   r  &	  s
   z!_get_norm_impl.<locals>.twoD_implc           	         s  | j d }| j d }| jdkrdS |tjkr:d}t|D ]}d}t|D ]}|t| ||f 7 }q$||kr7|}q|S |tj krd }t|D ]}d}t|D ]}|t| ||f 7 }qN||k ra|}qF|S |dkrd}t|D ]}d}t|D ]}|t| ||f 7 }qv||kr|}qn|S |dkr }t|D ]}d}t|D ]}|t| ||f 7 }q||k r|}q|S |dkrt| d S |dkrt| d S td)Nre  rf  r   r   r   r   z Invalid norm order for matrices.)r   rk  r   r"  rw  r  r,  r   )	r   r   rz   r   
global_maxiitmpjj
global_min)max_valr"   r#   r  1	  sb   



r   r/   )rA   r   r  r  r8   r?   r   r$   r   r   r   rg   r
   r   finforF  r  )	r   ord_flagr1  r/  r2  r:  r!   r  r  r"   )r=  rF  r#   _get_norm_impl  s6   


<
9



PErI  c                 C   s   t   t| d t| |S )Nr5  )r.   rs  rI  r<  r"   r"   r#   	norm_impl{	  s   

rJ  c                 C   s   t   t| d ddd}|S )Ncondc                 S   s   |dks|dks|d u r.t | }|dks|d u r#t|d |d }n!t|d |d }ntj| |}tjtj| |}|| }t|rLtjS |S )Nr   rf  r   re  )r,  r   divider=  r5  rd  isnanr"  )r   pr   r_  norm_a
norm_inv_ar"   r"   r#   r}   	  s   
zcond_impl.<locals>.implr/   r+  )r   rN  r}   r"   r"   r#   	cond_impl	  s   

$rQ  c                 C   s4   d}t t| D ]}| | |kr|d }q |S |S )zJ
    Gets rank from singular values with cut-off at a given tolerance
    r   r   rw  r6  )svr   r  r   r"   r"   r#   _get_rank_from_singular_values	  s   
rT  c                    s.   t   t| d dd   fdd}|| |S )ah  
    Computes rank for matrices and vectors.
    The only issue that may arise is that because numpy uses double
    precision lapack calls whereas numba uses type specific lapack
    calls, some singular values may differ and therefore counting the
    number of them above a tolerance may lead to different counts,
    and therefore rank, in some cases.
    matrix_rankc                    sT   |d t jfv r#t| jd| j}t|}t|j d fdd	}|S ddd}|S )Nr>   c                    s@   t | }| jd }| jd }t||}|d |   }t||S )Nr   r   )r,  r   r  rT  )r   tolr   r_  r   lr   eps_valr"   r#   _2d_tol_none_impl	  s   



zImatrix_rank_impl.<locals>._2d_matrix_rank_impl.<locals>._2d_tol_none_implc                 S   s   t | }t||S r/   )r,  rT  )r   rV  r   r"   r"   r#   _2d_tol_not_none_impl	  s   
zMmatrix_rank_impl.<locals>._2d_matrix_rank_impl.<locals>._2d_tol_not_none_implr/   )	r   r   rA   r   r  r  r   rG  eps)r   rV  nb_typenp_typerZ  r[  r"   rX  r#   _2d_matrix_rank_impl	  s   

z.matrix_rank_impl.<locals>._2d_matrix_rank_implc                    s2   | j }|dkrddd}|S |dkr | |S J )Nr   c                 S   s(   t t| D ]}| | dkr dS qdS )Nr   r   r   rR  )r   rV  r   r"   r"   r#   _1d_matrix_rank_impl	  s
   zMmatrix_rank_impl.<locals>._get_matrix_rank_impl.<locals>._1d_matrix_rank_implr   r   r/   r2  )r   rV  r   r`  r_  r"   r#   _get_matrix_rank_impl	  s   

z/matrix_rank_impl.<locals>._get_matrix_rank_impl)r.   rs  )r   rV  rb  r"   ra  r#   matrix_rank_impl	  s
   


rc  c                    sF   t | d t| j t|d|}t|tjstd fdd}|S )zL
    Computes matrix power. Only integer powers are supported in numpy.
    matrix_powerr   zExponent must be an integer.c           
         sH  |dkrt j| j d}t| jd D ]}d|||f< q|S | jd | jd }}||kr1td|dkr9|  S |dk rOt j|  }|dkrK|S | }n
|dkrW|  S | }|dk rw|d	krgt ||S |d
krut t |||S d S |}|}|}d}	|dkr|d@ r|	r|}d}	nt ||}t ||}|d? }|dks|S )Nr   rh  r   re  rf  zinput must be a square arrayr      r      TF)	r   r   r   rw  r   rl   r=  rd  r   )
r   rz   rR  r   r  r  r  r)  r  flagr2  r"   r#   matrix_power_impl
  sL   
z,matrix_power_impl.<locals>.matrix_power_impl)	rM  r  r  r   rA   rj   r   Integerr   )r   rz   ntri  r"   rh  r#   ri  
  s   
?ri  c                 C   s8   t | ddd t|ttjfstd| d	dd}|S )
z)
    Computes the trace of an array.
    traceFrI  z!integer argument expected, got %sr   c                 S   s   | j \}}|}|dk r|| }|dkr|| }tt||d}d}|dkr8t|D ]}|| ||| f 7 }q)|S t|D ]}|| || |f 7 }q<|S r   )r   r  r  rw  )r   offsetrowscolsr   rz   r  r  r"   r"   r#   matrix_trace_impl]
  s   
z,matrix_trace_impl.<locals>.matrix_trace_implNr   )rM  rj   r   r   rj  r   )r   rn  rq  r"   r"   r#   rq  R
  s
   
rq  c                 C   sB   |rdnd}||f}t | tjr| jdkstd| ddd S d S )NrA  r   r   rq  FrB  )rj   r   rk   r   r   rr  r"   r"   r#   _check_scalar_or_lt_2d_matq
  s   
rs  c                 C   s@   t | }t |}t | |jdf| d|jfS r  r   asarraymultiplyr  r  rk  r   r   r   aabbr"   r"   r#   outer_impl_none{
  s
   

rz  c                 C   sF   t | }t |}t | |jdf| d|jf| |S r  rt  rw  r"   r"   r#   outer_impl_arr
  s   

r{  c                 C   s   |d t jfv r	tS tS r/   )r   r   rz  r{  r   r   r   r"   r"   r#   _get_outer_impl
  s   r}  c                    s:   t | ddd t |ddd t| || d fdd	}|S )NouterFrm  c                    r6  r/   r"   r|  r}   r"   r#   
outer_impl
  s   zouter_impl.<locals>.outer_implr/   )rs  r}  )r   r   r   r  r"   r  r#   r  
  s
   r  c                 C   s`   t | tjr(| jdvrtd| j| jdkr tdd }|S tdd }|S tdd }|S )N)re   r   z^np.linalg.kron only supports 'C' or 'F' layout input arrays. Received an input of layout '{}'.r   c                 S   s    | j d }| j d }| ||S )Nre  rf  r   r  )r  xnxmr"   r"   r#   	nrm_shape
  s   

z(_kron_normaliser_impl.<locals>.nrm_shapec                 S   s   | j d }| d|S )Nre  r   r  )r  r  r"   r"   r#   r  
  s   
c                 S   s   t dt| }| |d< |S )Nr   r   )r   r   rF  )r  r   r"   r"   r#   r  
  s   )rj   r   rk   rg   r   formatr   r
   )r  r  r"   r"   r#   _kron_normaliser_impl
  s   




r  c                 C   s   t | tj}t |tj}|r*|r*| jdks|jdkr"tdd }|S tdd }|S |r4tdd }|S |r>tdd }|S tdd }|S )Nr   c                 S   s   |S r/   r"   r   r   r   r"   r"   r#   r  
  r>  z_kron_return.<locals>.retc                 S   s   | |jS r/   )r  rk  r  r"   r"   r#   r  
     c                 S   s   | | jS r/   r  r   r  r"   r"   r#   r  
  r  c                 S   s   | |jS r/   r  r  r"   r"   r#   r  
  r  c                 S   s   |d S r   r"   r  r"   r"   r#   r  
  r?  )rj   r   rk   r   r
   )r   r   a_is_arrb_is_arrr  r"   r"   r#   _kron_return
  s*   




r  c                    sX   t | ddd t |ddd t| t|t| |t| d|   fdd}|S )NkronFrm  r   c              	      s   | }|}|j d }|j d }|j d }|j d }|| }|| }	tj||	f d}
t|D ]4}|| }t|D ])}|| }||d d f }t|D ]}|| }|||f | |
|||| f< qMq;q1| ||
S )Nrf  re  rh  )r   r   r   rw  )r   r   rx  ry  r  r  r  r  cmcnre   r  rjmpr   irjmpslcr  cjmpr  fix_afix_bret_cr"   r#   	kron_impl
  s(   



"zkron_impl.<locals>.kron_impl)rs  r  r  rA   )r   r   r  r"   r  r#   r  
  s   
(r  )r   )F)Tr  r  r  r/   rr  )rQ   
contextlibr  llvmliter   numpyr   operatornumba.core.imputilsr   r   r   r   numba.core.typingr   numba.core.extendingr   r	   r
   
numba.corer   r   numba.core.errorsr   r   r   arrayobjr   r   r   numba.npr   r  r   r   
as_pointer	ll_char_pr   ll_intc	ll_intc_pr   	ll_intp_pr  ri  rV   float32rb   	complex64
complex128r   r$   r+   r.   r7   r8   rS   contextmanagerrx   r   r   r   r   r   r   r   r   r   r   r   r   matmulr   r   r  r  r  r%  r1  r8  rF   rB   r]  r@  rM  rO  rP  r\  r`  rb  r=  rd  ro  rp  rs  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
  r  r  r   r!  r'  r(  r*  r,  r3  r4  r;  rI  r5  rJ  rK  rQ  rT  rU  rc  rd  ri  rl  rq  rs  rz  r{  r}  r~  r  r  r  r  r  r"   r"   r"   r#   <module>   s6   


) $
%2


,
9Y
#



	


'

	


+

r

v

0

0
A
P




$

^



< $
$

:

F
# 
H
,


A
P



	"