U
    ,d9[                    @   sp  d 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 ddl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 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j/diZ0dddZ1dd Z2dd Z3dd Z4G dd dZ5G dd dZ6ej7d d! Z8d"d# Z9d$d% Z:d&d' Z;d(d) Z<d*d+ Z=d,d- Z>d.d/ Z?d0d1 Z@d2d3 ZAdd5d6ZBeejCejDejDd7d8 ZEeejFejDejDeE eejGejDejDd9d: ZGd;d< ZHd=d> ZId?d@ ZJdAdB ZKeejCejDejDejDdCdD ZLeM ZNeOdEeNZPedFdG ZQddIdJZRdKdL ZSdMdN ZTeeTdOdP ZUedQdR ZVedSdT ZWeejXjYdUdV ZZedWdX Z[ddYdZZ\eejXj]d[d\ Z^eejXj_d]d^ Z`eejXjad_d` ZbeejXjcdadb ZdeejXjedcdd ZfeejXjgddedfZheejXjidgdh Zjdidj Zkeekdkdl Zldmdn Zmeemdodp Zndqdr Zoeeodsdt Zpdudv Zqeeqdwdx Zrdydz Zseesd{d| Ztd}d~ Zueeudd ZveejXjwdddZxdd Zyeeydd ZzeejXj{dd Z|eejXj}dddZ~dd ZeejXjdd ZeejXjdd Zdd Zeedd Zdd Zeedd Zdd ZeejXjdddZeejXjdddZedd ZeejXjdddZeejXj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)overloadregister_jitable)typescgutils)TypingErrorNumbaTypeError   )
make_array_empty_nd_impl
array_copy)numpy_support)glue_lowering       sdcz<BLAS function>c                 C   s$   t | }|d kr td|f |S )Nzunsupported dtype for %s())_blas_kindsget	TypeError)dtype	func_namekind r!   3/tmp/pip-unpacked-wheel-eu7e0c37/numba/np/linalg.pyget_blas_kind/   s    
r#   c                  C   s.   zdd l } W n tk
r(   tdY nX d S Nr   z*scipy 0.16+ is required for linear algebra)Zscipy.linalg.cython_blasImportErrorZscipyr!   r!   r"   ensure_blas6   s    r'   c                  C   s.   zdd l } W n tk
r(   tdY nX d S r$   )Zscipy.linalg.cython_lapackr%   r&   r!   r!   r"   ensure_lapack=   s    r(   c                 C   s   |  |||}t||S N)Zget_constant_genericr   Zalloca_once_value)contextbuildertyvalconstr!   r!   r"   make_constant_slotD   s    r/   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   s
   t   d S r)   )r'   selfr!   r!   r"   __init__O   s    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   Zrtypesigr!   r!   r"   r5   R   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
   r8   r9   r:   r;   r<   r>   r   r?   r!   r!   r"   r@   ]   s"    z_BLAS.numba_xxgemmN)__name__
__module____qualname____doc__r3   classmethodr5   r@   r!   r!   r!   r"   r0   I   s   

r0   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   s
   t   d S r)   )r(   r1   r!   r!   r"   r3   x   s    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
   r8   r9   r:   r;   F_INT_nbtyper<   rB   r!   r!   r"   rI   {   s    z_LAPACK.numba_xxgetrfc              	   C   s0   t t jt jt |t jt t}t d|S )Nnumba_ez_xxgetrirJ   rB   r!   r!   r"   rL      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_rgeevrA   rB   r!   r!   r"   rM      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_cgeevrA   rB   r!   r!   r"   rN      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 )Nr4   numba_ez_xxxevdr6   )r>   r   Zwtyper?   r!   r!   r"   rO      s    z_LAPACK.numba_ez_xxxevdc                 C   s,   t t jt jt jt |t j}t d|S )Nnumba_xxpotrfrA   rB   r!   r!   r"   rP      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 )Nr4   numba_ez_gesddr6   )r>   r   styper?   r!   r!   r"   rQ      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_geqrfrA   rB   r!   r!   r"   rS      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_xxgqrrA   rB   r!   r!   r"   rT      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 )Nr4   numba_ez_gelsd)r7   r
   r8   r9   r:   r;   float64r<   r=   r!   r!   r"   rU      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_xgesvrJ   rB   r!   r!   r"   rW     s    
z_LAPACK.numba_xgesvN)rC   rD   rE   rF   r3   rG   rI   rL   rM   rN   rO   rP   rQ   rS   rT   rU   rW   r!   r!   r!   r"   rH   r   s0   


	



	



rH   c                 c   s   g }g }g }t |j|D ]r\}}t|tjr6|jdkrB|| }	}
n4|jdd}	t|	|}t| |||f}
|	|	|
f |	|	 |	|
 qt|j
f| t|fV  |D ]\}}| j||| qdS )z
    Ensure that all array arguments are contiguous, if necessary by
    copying them.
    A new (sig, args) tuple is yielded.
    ZCFClayoutN)zipargs
isinstancer
   ArrayrZ   copyr   r   appendreturn_typetupleZnrtZdecref)r*   r+   r?   r\   ZnewtysZnewargsZcopiesr,   r-   ZnewtyZnewvalZcopysigr!   r!   r"   make_contiguous  s    

rc   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Z_maxintr!   r"   impl4  s    zcheck_c_int.<locals>.implN)compile_internalr   r
   noner:   )r*   r+   re   rg   r!   rf   r"   check_c_int.  s     rj   c              	   C   sB   |j t||dd" | |}|  |d W 5 Q R X dS )z[
    Check the integer error return from one of the BLAS wrappers in
    _helperlib.c.
    FZlikelyz#BLAS wrapper returned with an errorNZif_thenr   Zis_not_nullZget_python_apiZ
gil_ensureZfatal_errorr*   r+   resZpyapir!   r!   r"   check_blas_return<  s    
ro   c              	   C   sB   |j t||dd" | |}|  |d W 5 Q R X dS )z]
    Check the integer error return from one of the LAPACK wrappers in
    _helperlib.c.
    Frk   z%LAPACK wrapper returned with an errorNrl   rm   r!   r!   r"   check_lapack_returnH  s    
rp   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   Znumba_xxdotN)r   FunctionTypeIntTypell_charintp_t	ll_void_pr   get_or_insert_functionmoduler#   Constantordintcallbitcastro   )r*   r+   	conjugater   re   Za_dataZb_dataout_datafntyfnr    kind_valrn   r!   r!   r"   
call_xxdotT  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rt|\}}|d }n|\}}|d }t|
}t tt|}t t|rt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   Znumba_xxgemv      ?        Fr   r   tre   N)r   rq   rr   rs   rt   ru   r   rv   rw   r   r/   rZ   r#   rx   ry   r{   r|   ro   )r*   r+   do_transZm_typem_shapesm_datav_datar~   r   r   r   alphabetamre   ldar    r   transrn   r!   r!   r"   call_xxgemvj  sB         



 


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   r@   r   r   r   re   c                    s8   | j j krn| j dkr$|d n|d  |tfS )NrX   r   r   )rZ   r|   ru   )r,   Zshapesdatar+   Znotransout_typer   r!   r"   get_array_param  s    
z$call_xxgemm.<locals>.get_array_paramN)r   rq   rr   rs   rt   ru   r   rv   rw   r   r/   rx   ry   r#   r{   r|   ro   )!r*   r+   Zx_typex_shapesx_dataZy_typey_shapesy_datar   
out_shapesr~   r   r   r   k_kre   r   r   r   r   Ztransar   Zdata_aZtransbZldbZdata_b_ZldcZdata_cr    r   rn   r!   r   r"   call_xxgemm  sT            

    
 r   c                 C   s(   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   re   outr!   r!   r"   dot_impl  s    

zdot_2_mm.<locals>.dot_implrh   r   ra   r*   r+   r?   r\   r   rn   r!   r!   r"   dot_2_mm  s    r   c                 C   s(   dd }|  ||||}t| ||j|S )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   _mre   r   r!   r!   r"   r     s    
zdot_2_vm.<locals>.dot_implr   r   r!   r!   r"   dot_2_vm  s    r   c                 C   s(   dd }|  ||||}t| ||j|S )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   re   _nr   r!   r!   r"   r     s    
zdot_2_mv.<locals>.dot_implr   r   r!   r!   r"   dot_2_mv  s    r   Fc              	   C   s   |j \}}|j}t|| ||d }t|| ||d }	t||j\}
dd }| ||ttj	f|j  | 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   re   r!   r!   r"   
check_args  s    zdot_2_vv.<locals>.check_args)r\   ra   r   r   unpack_tupler   rh   r   r
   ri   rj   Zalloca_onceZget_value_typer   r   load)r*   r+   r?   r\   r}   ZatyZbtyr   r   r   re   r   r   r!   r!   r"   dot_2_vv  s    
 r   c              
   C   s   t   t| |||\}}dd |jdd D }|ddgkrXt| |||W  5 Q R  S |ddgkr~t| |||W  5 Q R  S |ddgkrt| |||W  5 Q R  S |ddgkrt| |||W  5 Q R  S dstW 5 Q R X dS )z 
    np.dot(a, b)
    a @ b
    c                 S   s   g | ]
}|j qS r!   ndim.0xr!   r!   r"   
<listcomp>  s     zdot_2.<locals>.<listcomp>N   r   r   )r'   rc   r\   r   r   r   r   AssertionErrorr*   r+   r?   r\   Zndimsr!   r!   r"   dot_2  s    r   c              
   C   sB   t   t| |||$\}}t| |||ddW  5 Q R  S Q R X dS )z
    np.vdot(a, b)
    T)r}   N)r'   rc   r   )r*   r+   r?   r\   r!   r!   r"   vdot$  s    r   c                 C   s:   | j \}|j \}}||kr"td|j |fkr6t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   re   r!   r!   r"   dot_3_vm_check_args/  s    
r   c                 C   s:   | j \}}|j \}||kr"td|j |fkr6t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   re   r!   r!   r"   dot_3_mv_check_args:  s    
r   c                 C   s  |j \}}}||jkst|j}t|| ||d }t|| ||d }	t|| ||d }
t||j}t||	j}t||
j}|j|jk r|}|}|d }|d }|j	dk}|	j
|j
 }}t}n4|}|}|d }|d }|j	dk}|j
|	j
 }}t}| ||ttjf|j  | |D ]}t| || q| tjd}|d||}|d||}|||}|j|dd`\}}|$ t||
j
||
j|
jd W 5 Q R X | t| |||||||
j
 W 5 Q R X W 5 Q R X t| ||j|
 S )	zE
    np.dot(vector, matrix, out)
    np.dot(matrix, vector, out)
    r   r   r   r   rX   ==Frk   )r\   ra   r   r   r   r   r   r   r   rZ   r   r   r   rh   r   r
   ri   rj   get_constantr:   icmp_signedor_if_elsememsetmulitemsizenitemsr   r   	_getvalue)r*   r+   r?   r\   xtyytyouttyr   r   yr   r   r   r   Zmtyr   Zv_shaper   r   r   r   r   r-   zero
both_emptyZmatrix_emptyis_emptyr   nonemptyr!   r!   r"   dot_3_vmE  s`    

 
  
r   c           '      C   s  |j \}}}||jkst|j}t|| ||d }t|| ||d }	t|| ||d }
t||j}t||	j}t||
j}|\}}|\}}|jdkstdd }| 	||t
tjf|j  | t| || t| || t| || |j}|	j}|
j}| tjd}|d||}|d||}|d||}|||||}|j|dd	\}}|$ t||
j||
j|
jd W 5 Q R X |V | tjd}|d||}|d||}||\} }!| x ||b\}"}#|" t| |d||||| W 5 Q R X |#( |j|jk}$t| ||$||||| W 5 Q R X W 5 Q R X W 5 Q R X |!~ ||h\}%}&|%( |j|jk}$t| ||$||||| W 5 Q R X |&" t| |||||||||| W 5 Q R X W 5 Q R X W 5 Q R X W 5 Q R X W 5 Q R X W 5 Q R X t| ||j|
 S )
z%
    np.dot(matrix, matrix, out)
    r   r   r   rX   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   re   r!   r!   r"   r     s    

zdot_3_mm.<locals>.check_argsr   Frk   )r\   ra   r   r   r   r   r   r   rZ   rh   r   r
   ri   rj   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   re   r   r   r   r~   r   r   Zx_emptyZy_emptyr   r   r   oneZis_left_vecZis_right_vecZr_vecZr_matZv_vZm_vr   Zv_mZm_mr!   r!   r"   dot_3_mm~  s    
 
 
       "          @
r   c              
   C   s   t   t| |||\}}tdd |jdd D }|tdgkr^t| |||W  5 Q R  S |tddgkrt| |||W  5 Q R  S dstW 5 Q R X dS )z
    np.dot(a, b, out)
    c                 s   s   | ]}|j V  qd S r)   r   r   r!   r!   r"   	<genexpr>  s     zdot_3.<locals>.<genexpr>Nr   r   r   )r'   rc   setr\   r   r   r   r   r!   r!   r"   dot_3  s    r   Znumba_fatal_errorc                 C   s.   t | D ]}t | s
t jdq
d S )Nz$Array must not contain infs or NaNs.)r   ZnditerisfiniteitemlinalgLinAlgError)r   vr!   r!   r"   _check_finite_matrix  s
    r   Tc                 C   s   |rdnd}||f}t | tjr&| j} t | tjsFd| }t|dd| jdksdd| }t|ddt | jtjtj	fsd| }t|ddd S )	N	np.linalgr   z&%s.%s() only supported for array typesFZhighlightingr   z%%s.%s() only supported on 2-D arrays.3%s.%s() only supported on float and complex arrays.)
r]   r
   Optionaltyper^   r   r   r   FloatComplex)r   r   	la_prefixprefixinterpmsgr!   r!   r"   _check_linalg_matrix  s    
r   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.Fr   )r   r   )r   r
   t0r   r   r!   r!   r"   _check_homogeneous_types  s
    

r   c                   C   s   d S r)   r!   r!   r!   r!   r"   _copy_to_fortran_order  s    r   c                    s&   | j dk| j dk  fdd}|S )Nr   Ac                    sJ   rt | }n6 r<| jj}|r0t | jj}qFt | }n
t | }|S r)   )r   r_   flagsf_contiguousTZasfortranarray)r   acpyZflag_fZA_layoutZF_layoutr!   r"   rg     s    
z&ol_copy_to_fortran_order.<locals>.implrY   )r   rg   r!   r   r"   ol_copy_to_fortran_order  s    

r   c                 C   s6   | dkr2| dk rt   dst| dkr2tjdd S )Nr   z(Matrix is singular to machine precision.)fatal_error_funcr   r   r   r   rr!   r!   r"   _inv_err_handler0  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    r   c                    sP   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rD|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   r   r   F_INT_nptypectypesr   r   size)r   re   r   r   ipivr   r    rI   Znumba_xxgetrir!   r"   inv_implL  s    
zinv_impl.<locals>.inv_impl)r(   r   rH   rI   r   rL   ry   r#   )r   r  r!   r  r"   r  @  s    
r  c                 C   s2   | dkr.| dk rt   dst| dkr.tdd S )Nr   z&Internal algorithm failed to converge.)r   r   r   r   r!   r!   r"   %_handle_err_maybe_convergence_problemh  s    r  c                 C   sf   |rdnd}||f}t | tjs,td| | jdksBtd| t | jtjtjfsbtd| d S )Nr   r   z'%s.%s() only supported for array types r   +%s.%s() only supported on 1 and 2-D arrays r   )r]   r
   r^   r   r   r   r   r   r   r   r   r   r   r!   r!   r"   _check_linalg_1_or_2d_matrixr  s    
r  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 rlt  dslt|dkrtjdt|D ]}d|d ||f< q|S )Nr   r   r   r   z Matrix is not positive definite.)	r   r   r   r   r_   r  r   r   range)r   re   r   r   r   colUPr    rP   r!   r"   cho_impl  s&    
zcho_impl.<locals>.cho_impl)r(   r   rH   rP   r   ry   r#   )r   ZLOr  r!   r  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r|S |S d 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r||	jfS  ||j	||j	|j	|j	||	j	|}
t
|
 t|rtdt|j|j|	j|j|jg ||	jfS )z7
        eig() implementation for real arrays.
        r   r   r   r   r  r   z.eig() argument must not cause a domain change.)r   r   r   r   r   r   r   r   r   r  r  anyr   r   r  r   re   r   r   ldvlldvrwrZwivlvrr   JOBVLJOBVRr    rM   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r||jfS  ||j	||j	|j	||j	|}	t
|	 t|j|j|j|jg ||jfS )z:
        eig() implementation for complex arrays.
        r   r   r   r   r  r   )r   r   r   r   r   r   r   r   r   r  r  r   r  
r   re   r   r   r  r  wr  r  r   r  r   r    rN   r!   r"   cmplx_eig_impl  s8    

z eig_impl.<locals>.cmplx_eig_implr(   r   rH   rM   r   rN   ry   r#   r]   r
   Zscalarsr   )r   r!  r%  r!   r  r   r    rN   rM   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r|S |S d 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
|rtdt|j|j|	j|j|jg |S )z;
        eigvals() implementation for real arrays.
        r   r   r   r   r  r   z2eigvals() argument must not cause a domain change.)r   r   r   r   r   r   r   r   r  r  r  r   r   r  r  r  r!   r"   real_eigvals_impl1  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.
        r   r   r   r   r  r   )r   r   r   r   r   r   r   r   r  r  r   r  r"  r$  r!   r"   cmplx_eigvals_impll  s8    
z(eigvals_impl.<locals>.cmplx_eigvals_implr&  )r   r*  r+  r!   r'  r"   eigvals_impl#  s    
;)r,  c                    sp   t   t| d t| jd| j}t|t | jtt	| jdtd td fdd}|S )Neighr4   r  r  c                    s   | j d }| j d |kr(d}tj|t|  t| }tj|d}|dkrV||fS  ||j||j}t| t	|j
|j
g ||fS Nr   r   r   r  r   r   r   r   r   r   r   r   r  r  r   r  r   re   r   r   r#  r   JOBZZUPLOr    rO   Zw_dtyper!   r"   	eigh_impl  s(    
zeigh_impl.<locals>.eigh_impl
r(   r   r7   r   
np_supportas_dtyperH   rO   ry   r#   )r   w_typer3  r!   r1  r"   r3    s    

r3  c                    sp   t   t| d t| jd| j}t|t | jtt	| jdtd td fdd}|S )Neigvalshr4   r  r  c                    s   | j d }| j d |kr(d}tj|t|  t| }tj|d}|dkrR|S  ||j||j}t| t	|j
|j
g |S r.  r/  r0  r1  r!   r"   eigvalsh_impl  s(    
z$eigvalsh_impl.<locals>.eigvalsh_implr4  )r   r7  r9  r!   r1  r"   r9    s    

r9  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svdr4   r   Sr   c                    s   | j d }| j d }|dks$|dkr0tjdt|  t| }|}t||}|r` }|}|}	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 )Nr   r   r   Arrays cannot be emptyr  )r   r   r   r   r   r   minr   r   r  r  r   r  r   )r   full_matricesre   r   r   lduminmnr2  ucolldvtur   vtr   ZJOBZ_AZJOBZ_Sr    rQ   s_dtyper!   r"   svd_impl  sD    


zsvd_impl.<locals>.svd_impl)r   )
r(   r   r7   r   r5  r6  rH   rQ   ry   r#   )r   r>  s_typerG  r!   rE  r"   rG    s    

.rG  c                    sP   t   t| d t | jt | jtt| jd  fdd}|S )Nqrc                    sN  | j d }| j d }|dks$|dkr0tjdt|  t| }|}t||}tj|| jd} |||j	||j	}|dk rt
  dsttj||f| jdj}t|D ]*}	t|	d D ]}
||
|	f ||
|	f< qqt||D ]&}	t|D ]}
||
|	f ||
|	f< qqވ ||||j	||j	}t| t|j|jg |d d d |f |fS )Nr   r   r   r<  r  r   )r   r   r   r   r   r   r=  r   r   r  r   r   r   r   r  r  r   r  )r   re   r   qr   r@  tauretr   ijr    rS   rT   r!   r"   qr_implO  sN    


	zqr_impl.<locals>.qr_impl)r(   r   rH   rS   r   rT   ry   r#   )r   rP  r!   rO  r"   rP  >  s    
9rP  c                 C   s   t dS )z;
    Correctly copy 'b' into the 'bcpy' scratch space.
    NNotImplementedErrorbcpyr   nrhsr!   r!   r"   _system_copy_in_b  s    rV  c                 C   s&   |j dkrdd }|S dd }|S d S )Nr   c                 S   s   || d |j d df< d S )Nr   r   r   rS  r!   r!   r"   	oneD_impl  s    z)_system_copy_in_b_impl.<locals>.oneD_implc                 S   s   || d |j d d |f< d S )Nr   rW  rS  r!   r!   r"   	twoD_impl  s    z)_system_copy_in_b_impl.<locals>.twoD_implr   )rT  r   rU  rX  rY  r!   r!   r"   _system_copy_in_b_impl  s
    
rZ  c                 C   s   t dS )zK
    Compute the number of right hand sides in the system of equations
    NrQ  r   r!   r!   r"   _system_compute_nrhs  s    r\  c                 C   s&   | j dkrdd }|S dd }|S d S )Nr   c                 S   s   dS Nr   r!   r[  r!   r!   r"   rX    s    z,_system_compute_nrhs_impl.<locals>.oneD_implc                 S   s
   | j d S )Nr   rW  r[  r!   r!   r"   rY    s    z,_system_compute_nrhs_impl.<locals>.twoD_implr   )r   rX  rY  r!   r!   r"   _system_compute_nrhs_impl  s
    
r^  c                 C   s   t dS )zD
    Check that AX=B style system input is dimensionally valid.
    NrQ  r   r   r!   r!   r"   !_system_check_dimensionally_valid  s    r`  c                 C   s*   |j }|dkrdd }|S dd }|S d S )Nr   c                 S   s,   | j d }|j d }||kr(tjdd S )Nr   r   <Incompatible array sizes, system is not dimensionally valid.r   r   r   r   r   r   ambmr!   r!   r"   rX    s    

z9_system_check_dimensionally_valid_impl.<locals>.oneD_implc                 S   s,   | j d }|j d }||kr(tjdd S )Nr   ra  rb  rc  r!   r!   r"   rY    s    

z9_system_check_dimensionally_valid_impl.<locals>.twoD_implr   r   r   r   rX  rY  r!   r!   r"   &_system_check_dimensionally_valid_impl  s    rg  c                 C   s   t dS )z:
    Check that AX=B style system input is not empty.
    NrQ  r_  r!   r!   r"   _system_check_non_empty  s    rh  c                 C   s*   |j }|dkrdd }|S dd }|S d S )Nr   c                 S   sF   | j d }| j d }|j d }|dks6|dks6|dkrBtjdd S Nr   r   r   r<  rb  )r   r   rd  anre  r!   r!   r"   rX    s
    


z/_system_check_non_empty_impl.<locals>.oneD_implc                 S   sX   | j d }| j d }|j d }|j d }|dksH|dksH|dksH|dkrTtjdd S ri  rb  )r   r   rd  rj  re  bnr!   r!   r"   rY    s    



 z/_system_check_non_empty_impl.<locals>.twoD_implr   rf  r!   r!   r"   _system_check_non_empty_impl  s    rl  c                 C   s   t dS )z:
    Compute the residual from the 'b' scratch space.
    NrQ  )r   re   rU  r!   r!   r"   _lstsq_residual  s    rm  c                    s   | j }| j}tt|d| |dkrTt|tjrB fdd}|S  fdd}|S n8|dks`tt|tjr| fdd}|S  fd	d}|S d S )
Nr4   r   c                    s6   t jd d}t t | |d df d |d< |S Nr   r  r   r   )r   r   sumabsr   re   rU  rn   
real_dtyper!   r"   
cmplx_impl  s    $z(_lstsq_residual_impl.<locals>.cmplx_implc                    s0   t jd d}t | |d df d |d< |S rn  )r   r   rp  rr  rs  r!   r"   	real_impl  s    z'_lstsq_residual_impl.<locals>.real_implr   c                    sD   t j| d}t|D ](}t t | |d |f d ||< q|S Nr  r   )r   r   r  rp  rq  r   re   rU  rn   r   rs  r!   r"   ru    s    &c                    s>   t j| d}t|D ]"}t | |d |f d ||< q|S rw  )r   r   r  rp  rx  rs  r!   r"   rv    s     )	r   r   r5  r6  r7   r]   r
   r   r   )r   re   rU  r   r   ru  rv  r!   rs  r"   _lstsq_residual_impl  s    ry  c                 C   s   t dS )z
    Extract 'x' (the lstsq solution) from the 'bcpy' scratch space.
    Note 'b' is only used to check the system input dimension...
    NrQ  r   rT  re   r!   r!   r"   _lstsq_solution  s    r{  c                 C   s&   | j dkrdd }|S dd }|S d S )Nr   c                 S   s   |j  d | S r)   r   ravelrz  r!   r!   r"   rX  %  s    z'_lstsq_solution_impl.<locals>.oneD_implc                 S   s   |d |d d f   S r)   r_   rz  r!   r!   r"   rY  )  s    z'_lstsq_solution_impl.<locals>.twoD_implr   )r   rT  re   rX  rY  r!   r!   r"   _lstsq_solution_impl"  s
    
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lstsqr4   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 s||krtj	dd}nt|	||}t||	|}t|j|	j|
j|jg ||||
d | fS )Nr   r   r  r   r   )r   r\  r   rh  r`  r=  maxr   r   r   r   rV  int32r  r  rm  r{  r   r  )r   r   rcondre   r   rU  r@  Zmaxmnr   rT  r   Zrank_ptrr   rankrn   r   r    np_dtrU   rt  r!   r"   
lstsq_implK  sF    





zlstsq_impl.<locals>.lstsq_impl)r  )r(   r   r  r   r5  r6  r   r7   rH   rU   ry   r#   )r   r   r  nb_dtZr_typer  r!   r  r"   r  .  s    


?r  c                 C   s   t dS )z
    Extract 'x' (the solution) from the 'bcpy' scratch space.
    Note 'b' is only used to check the system input dimension...
    NrQ  r   rT  r!   r!   r"   _solve_compute_return  s    r  c                 C   s&   | j dkrdd }|S dd }|S d S )Nr   c                 S   s
   |j  S r)   r|  r  r!   r!   r"   rX    s    z-_solve_compute_return_impl.<locals>.oneD_implc                 S   s   |S r)   r!   r  r!   r!   r"   rY    s    z-_solve_compute_return_impl.<locals>.twoD_implr   )r   rT  rX  rY  r!   r!   r"   _solve_compute_return_impl  s
    
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rZt||S t	||| tj|t
d} |||j||j|j|}t| t|j|j|jg t||S )Nr   r  r   )r   r\  r   r`  r   r   r   r   r  rV  r  r  r   r   r  )r   r   re   rU  r   rT  r  r   r    r  rW   r!   r"   
solve_impl  s0    



zsolve_impl.<locals>.solve_impl)r(   r   r  r   r5  r6  r   rH   rW   ry   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pinvr4   r;  rX   r   r  r   r  c                    s  | j d }| j d }t|  t| }|dks4|dkrH|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rd||  ||< |}q|d7 }||krBt|D ]2}t|D ]"}|||f ||  |||f< qqn@t|D ]6}|| }t|D ]}|||f | |||f< q^qJ|||j
|j
||j
|j
|j
|}	t|j|j|j|jjjg |j | j jS )Nr   r   r   r  r   r   )r   r   r   r   r}  reshaper=  r   r   r   r  r  r  r   r  )r   r  re   r   r   r@  rC  r   rD  r   Zcut_atZcut_idxr   rM  rN  Zs_local	ZJOBZTRANSAZTRANSBr    rQ   r@   r   rF  r   r!   r"   	pinv_impl  sv    '



& 	zpinv_impl.<locals>.pinv_impl)r  )r(   r   r7   r   r5  r6  rH   rQ   r0   r@   ry   r#   r   array)r   r  rH  dtr  r!   r  r"   r    s     

 r  c                 C   s2   t | jtjrtdd }|S tdd }|S 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 ]8}t|||f }||||f |  }|t| }q||fS )Ny                r   )r  r   rq  log)re   r   sgnZcsgnaccr   Zabselr!   r!   r"   cmplx_diag_walker  s    z3_get_slogdet_diag_walker.<locals>.cmplx_diag_walkerc                 S   sL   d}t | D ]2}|||f }|dk r0| }| }|t| }q|d |fS )Nr   )r  r   r  )re   r   r  r  r   r   r!   r!   r"   real_diag_walker  s    z2_get_slogdet_diag_walker.<locals>.real_diag_walkerN)r]   r   r
   r   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   r4   r   c                    s   | j d }| j d |kr(d}tj||dkr8 fS t|  t| }tj|td}|||j||j}|dkrdtj	 fS t
| d}t|D ]}||| |d k }q|d@ }|dkrd}t|jg |||S )Nr   r   r   r   r  r   r   )r   r   r   r   r   r   r   r  r  infr   r  r   r  )r   re   r   r   r  r   r  r   ZONEZZEROZdiag_walkerr    rI   r!   r"   slogdet_impl  s*    
	z"slogdet_impl.<locals>.slogdet_impl)	r(   r   rH   rI   r   ry   r#   r  r7   )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_impl  s    zdet_impl.<locals>.det_implr(   r   )r   r  r!   r!   r"   r    s    
r  c                 C   s   t dS )z)
    Compute singular values of *a*.
    NrQ  r   r!   r!   r"   _compute_singular_values  s    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  r4   r   r   r  c           
         s   | j d }| j d }|dks$|dkr0t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.
        r   r   r   r<  r   r  )r   r   r   r   r   r=  r   r   r  r  r   r  )
r   re   r   r?  r@  rA  rB  r   r   r   ZJOBZ_Nr    np_ret_typerQ   rC  rD  r!   r"   sv_function  s6    


z2_compute_singular_values_impl.<locals>.sv_function)
rH   rQ   r   ry   r#   r7   r5  r6  r   r   )r   nb_ret_typenp_dtyper  r!   r  r"   _compute_singular_values_impl  s    
/r  c                 C   s   t dS )z.
    Compute the L2-norm of 1D-array *a*.
    NrQ  r   r!   r!   r"   _oneD_norm_2=  s    r  c                    sL   t | jd| j}t|t | jtt| jd  fdd}|S )Nr4   normc                    sl   t | }tjdd}t| jd | j } || j||j}|dk rTt  dsTtt	|j
| j
g |d S )Nro  r  r   )lenr   r   rz   stridesr   r  r   r   r   r  )r   re   rL  Zjmpr   r    r  xxnrm2r!   r"   rg   M  s    z_oneD_norm_2_impl.<locals>.impl)r7   r   r5  r6  r0   r5   ry   r#   )r   r  rg   r!   r  r"   _oneD_norm_2_implD  s    
r  c           	         s
  t | jd| j}t|}t| j}t | j}tt| jd}| jdkrv|d t	j
fkrhddd}n
ddd}|S | jdk r|d t	j
fkr| jdkrtd	d
  n$| jdkrtdd
  ntdd
  d fdd	}nt|jjdfdd	}|S dstd S )Nr4   r  r   c                 S   s   t | S r)   )r  r   ry   r!   r!   r"   rX    s    z!_get_norm_impl.<locals>.oneD_implc                 S   sD  t | }|dkrdS |dkr$t| S |tjkrft| d }td|D ]}t| | }||krD|}qD|S |tj krt| d }td|D ]}t| | }||k r|}q|S |dkrd}t|D ]}| | dkr|d7 }q|S |dkrd}t|D ]}|t| | 7 }q|S d}t|D ]}|t| | | 7 }q|d|  S d S )Nr   r   r   r   r   )r  r  r   r  rq  r  )r   ry   re   rL  r   r-   r!   r!   r"   rX    sD    


r   rX   c                 S   s   | S r)   r!   r   r!   r!   r"   array_prepare  s    z%_get_norm_impl.<locals>.array_preparer   c                 S   s   | j S r)   )r   r   r!   r!   r"   r    s    c                 S   s   |   S r)   r~  r   r!   r!   r"   r    s    c                    s(   | j }|dkrdS  | }t||S )Nr   r   )r  r  r  )r   ry   re   Za_c)r  r!   r"   rY    s
    z!_get_norm_impl.<locals>.twoD_implc           	         s  | j d }| j d }| jdkr"dS |tjkrtd}t|D ]6}d}t|D ]}|t| ||f 7 }qH||kr8|}q8|S |tj krȈ }t|D ]6}d}t|D ]}|t| ||f 7 }q||k r|}q|S |dkrd}t|D ]6}d}t|D ]}|t| ||f 7 }q||kr|}q|S |dkrr }t|D ]<}d}t|D ]}|t| ||f 7 }q@||k r0|}q0|S |dkrt| d S |dkrt| d S tdd S )Nr   r   r   r   r   r   z Invalid norm order for matrices.)r   r  r   r  r  rq  r  r   )	r   ry   re   r   Z
global_maxiitmpZjjZ
global_min)max_valr!   r"   rY    sZ    








r   )N)N)N)N)r7   r   r5  r6  r0   r5   ry   r#   r   r
   ri   rZ   r	   r   finfor   r  r   )	r   Zord_flagr  r  r  r  r    rX  rY  r!   )r  r  r"   _get_norm_implh  s2    


9


	Er  c                 C   s   t   t| d t| |S )Nr  )r(   r  r  r  r!   r!   r"   	norm_impl/	  s    
r  c                 C   s   t   t| d ddd}|S )Ncondc                 S   s   |dks|dks|d kr\t | }|dks0|d krFt|d |d }qt|d |d }n,tj| |}tjtj| |}|| }t|rtjS |S d S )Nr   r   r   r   )r  r   divider   r  r   isnanr  )r   pr   r   Znorm_aZ
norm_inv_ar!   r!   r"   rg   >	  s    
zcond_impl.<locals>.impl)Nr  )r   r  rg   r!   r!   r"   	cond_impl8	  s    

$r  c                 C   s4   d}t t| D ]}| | |kr*|d }q q0q|S )zJ
    Gets rank from singular values with cut-off at a given tolerance
    r   r   r  r  )svr   r  r   r!   r!   r"   _get_rank_from_singular_valuese	  s    
r  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                    sX   |d t jfkrFt| jd| j}t|}t|j d fdd	}|S ddd}|S d S )Nr4   c                    s@   t | }| jd }| jd }t||}|d |   }t||S )Nr   r   )r  r   r  r  )r   tolr   r   r   lr   Z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  r  )r   r  r   r!   r!   r"   _2d_tol_not_none_impl	  s    zMmatrix_rank_impl.<locals>._2d_matrix_rank_impl.<locals>._2d_tol_not_none_impl)N)N)	r
   ri   r7   r   r5  r6  r   r  Zeps)r   r  Znb_typeZnp_typer  r  r!   r  r"   _2d_matrix_rank_impl	  s    

z.matrix_rank_impl.<locals>._2d_matrix_rank_implc                    s:   | j }|dkrddd}|S |dkr. | |S ds6td S )Nr   c                 S   s(   t t| D ]}| | dkr dS qdS )Nr   r   r   r  )r   r  r   r!   r!   r"   _1d_matrix_rank_impl	  s    zMmatrix_rank_impl.<locals>._get_matrix_rank_impl.<locals>._1d_matrix_rank_implr   r   )N)r   r   )r   r  r   r  r  r!   r"   _get_matrix_rank_impl	  s    

z/matrix_rank_impl.<locals>._get_matrix_rank_impl)r(   r  )r   r  r  r!   r  r"   matrix_rank_impls	  s
    

r  c                    sF   t | d t| j t|d|}t|tjs6t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           
         sJ  |dkr<t j| j d}t| jd D ]}d|||f< q&|S | jd | jd  }}||krbtd|dkrr|  S |dk rt j|  }|dkr|S | }n|dkr|  S | }|dk r|d	krt ||S |d
krt t |||S nZ|}|}|}d}	|dkrB|d@ r,|	r |}d}	nt ||}t ||}|d? }q|S d S )Nr   r  r   r   r   zinput must be a square arrayr      r      TF)	r   r   r   r  r   r_   r   r   r   )
r   re   r   r   rd  rj  r  r  rL  flagr  r!   r"   matrix_power_impl	  sH    


z,matrix_power_impl.<locals>.matrix_power_impl)	r   r5  r6  r   r7   r]   r
   Integerr   )r   re   ntr  r!   r  r"   r  	  s    
?r  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r   z!integer argument expected, got %sr   c                 S   s   | j \}}|}|dk r|| }|dkr.|| }tt||d}d}|dkrnt|D ]}|| ||| f 7 }qRn"t|D ]}|| || |f 7 }qv|S r   )r   r  r=  r  )r   offsetZrowscolsr   re   rL  rM  r!   r!   r"   matrix_trace_impl
  s    
z,matrix_trace_impl.<locals>.matrix_trace_impl)r   )r   r]   rz   r
   r  r   )r   r  r  r!   r!   r"   r  
  s
    
r  c                 C   s>   |rdnd}||f}t | tjr:| jdks:td| ddd S )Nr   r   r   r	  Fr   )r]   r
   r^   r   r   r
  r!   r!   r"   _check_scalar_or_lt_2d_mat%
  s    
r  c                 C   s@   t | }t |}t | |jdf| d|jfS r]  r   Zasarraymultiplyr}  r  r  r   r   r   aabbr!   r!   r"   outer_impl_none/
  s
    

r  c                 C   sF   t | }t |}t | |jdf| d|jf| |S r]  r  r  r!   r!   r"   outer_impl_arr7
  s    

r  c                 C   s   |d t jfkrtS tS d S r)   )r
   ri   r  r  r   r   r   r!   r!   r"   _get_outer_implA
  s    r  c                    s:   t | ddd t |ddd t| || d fdd	}|S )NouterFr  c                    s    | ||S r)   r!   r  rg   r!   r"   
outer_implP
  s    zouter_impl.<locals>.outer_impl)N)r  r  )r   r   r   r  r!   r  r"   r  H
  s
    r  c                 C   sh   t | tjrT| jdkr(td| jqd| jdkrBtdd }|S tdd }|S ntdd }|S d S )N)rX   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 )Nr   r   r   r  )r   xnZxmr!   r!   r"   	nrm_shape^
  s    

z(_kron_normaliser_impl.<locals>.nrm_shapec                 S   s   | j d }| d|S )Nr   r   r  )r   r  r!   r!   r"   r  e
  s    
c                 S   s   t dt| }| |d< |S )Nr  r   )r   r   r   )r   r   r!   r!   r"   r  k
  s    )r]   r
   r^   rZ   r   formatr   r	   )r   r  r!   r!   r"   _kron_normaliser_implV
  s    




r  c                 C   s   t | tj}t |tj}|rV|rV| jdks4|jdkrDtdd }|S tdd }|S n8|rjtdd }|S |r~tdd }|S tdd }|S d S )Nr   c                 S   s   |S r)   r!   r   r   r   r!   r!   r"   rL  z
  s    z_kron_return.<locals>.retc                 S   s   | |jS r)   )r  r  r  r!   r!   r"   rL  
  s    c                 S   s   | | jS r)   r  r   r  r!   r!   r"   rL  
  s    c                 S   s   | |jS r)   r  r  r!   r!   r"   rL  
  s    c                 S   s   |d S r   r!   r  r!   r!   r"   rL  
  s    )r]   r
   r^   r   r	   )r   r   Za_is_arrZb_is_arrrL  r!   r!   r"   _kron_returns
  s*    




r  c                    sX   t | ddd t |ddd t| t|t| |t| d|   fdd}|S )NkronFr  r   c              	      s   | }|}|j d }|j d }|j d }|j d }|| }|| }	tj||	f d}
t|D ]h}|| }t|D ]R}|| }||d d f }t|D ],}|| }|||f | |
|||| f< qqvqb| ||
S )Nr   r   r  )r   r   r   r  )r   r   r  r  rd  rj  re  rk  cmZcnrX   rM  Zrjmpr   ZirjmpZslcrN  Zcjmpr  Zfix_aZfix_bZret_cr!   r"   	kron_impl
  s$    



&zkron_impl.<locals>.kron_impl)r  r  r  r7   )r   r   r  r!   r  r"   r  
  s    
(r  )r   )F)T)T)r   )r  )r  )N)N)N)r   )T)N)rF   
contextlibZllvmliter   Znumpyr   operatorZnumba.core.imputilsr   r   r   r   Znumba.core.typingr   Znumba.core.extendingr   r	   Z
numba.corer
   r   Znumba.core.errorsr   r   Zarrayobjr   r   r   Znumba.npr   r5  Znumba.core.overload_gluer   rr   rs   Z
as_pointerZ	ll_char_pru   Zll_intcZ	ll_intc_prt   Z	ll_intp_pr  r  rK   Zfloat32rV   Z	complex64Z
complex128r   r#   r'   r(   r/   r0   rH   contextmanagerrc   rj   ro   rp   r   r   r   r   r   r   r   r   r^   r   matmulr   r   r   r   r   r   r8   Zfatal_error_sigr<   r   r   r   r   r   r   r   r   r   r   r  r  r  r  r  r  r(  r)  r,  r-  r3  r8  r9  r:  rG  rI  rP  rV  rZ  r\  r^  r`  rg  rh  rl  rm  ry  r{  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r!   r!   r!   r"   <module>   s:  

    
) $
%2



9Y




	


'
	


+

r

v

0

0
A

P




$

^


<
 $$

:


F
# H

,

A

P

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