U
    hâËd€g ã                   @   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Z1d¼d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„ ZBd½d4d5„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„ ƒZRd¾dLdM„ZSdNdO„ ZTdPdQ„ ZUeeUƒdRdS„ ƒZVedTdU„ ƒZWedVdW„ ƒZXeejYjZƒdXdY„ ƒZ[edZd[„ ƒZ\d¿d\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ƒdÀdhdi„ƒ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„ ƒZud€d�„ Zveevƒd‚dƒ„ ƒZweejYjxƒdÁd…d†„ƒZyd‡dˆ„ Zzeezƒd‰dŠ„ ƒZ{eejYj|ƒd‹dŒ„ ƒZ}eejYj~ƒdÂdŽd�„ƒZd�d‘„ Z€eejYj�ƒd’d“„ ƒZ‚eejYjƒƒd”d•„ ƒZ„d–d—„ Z…ee…ƒd˜d™„ ƒZ†dšd›„ Z‡ee‡ƒdœd�„ ƒZˆdždŸ„ Z‰eejYjŠƒdÃd d¡„ƒZ‹eejYjŒƒdÄd¢d£„ƒZ�ed¤d¥„ ƒZŽeejYj�ƒdÅd¦d§„ƒZ�eejYj‘ƒd¨d©„ ƒZ’eej“ƒdÆdªd«„ƒZ”dÇd¬d­„Z•ed®d¯„ ƒZ–ed°d±„ ƒZ—d²d³„ Z˜eej™ƒdÈd´dµ„ƒZšd¶d·„ Z›d¸d¹„ Zœeej�ƒdºd»„ ƒZžd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 kr td|f ƒ‚|S )Nzunsupported dtype for %s())Ú_blas_kindsÚgetÚ	TypeError)ÚdtypeÚ	func_nameÚkind© r"   úH/home/sam/Atlas/atlas_env/lib/python3.8/site-packages/numba/np/linalg.pyÚget_blas_kind0   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_blas7   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_slotE   s    r0   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__P   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#   r6   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   r9   r:   r;   r<   r=   ©r?   r   r@   r"   r"   r#   rA   ^   s"    òz_BLAS.numba_xxgemmN)Ú__name__Ú
__module__Ú__qualname__Ú__doc__r4   Úclassmethodr6   rA   r"   r"   r"   r#   r1   J   s   

r1   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)   r2   r"   r"   r#   r4   y   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   r9   r:   r;   r<   ÚF_INT_nbtyper=   rC   r"   r"   r#   rJ   |   s    ûz_LAPACK.numba_xxgetrfc              	   C   s0   t  t jt jt  |¡t jt  t¡¡}t  d|¡S )NÚnumba_ez_xxgetrirK   rC   r"   r"   r#   rM   ‡   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_rgeevrB   rC   r"   r"   r#   rN   ‘   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_cgeevrB   rC   r"   r"   r#   rO   ¢   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 )Nr5   Únumba_ez_xxxevdr7   )r?   r   Zwtyper@   r"   r"   r#   rP   ²   s    úz_LAPACK.numba_ez_xxxevdc                 C   s,   t  t jt jt jt  |¡t j¡}t  d|¡S )NÚnumba_xxpotrfrB   rC   r"   r"   r#   rQ   ¿   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 )Nr5   Únumba_ez_gesddr7   )r?   r   Ústyper@   r"   r"   r#   rR   É   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_geqrfrB   rC   r"   r"   r#   rT   Ü   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_xxgqrrB   rC   r"   r"   r#   rU   è   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 )Nr5   Únumba_ez_gelsd)r8   r   r9   r:   r;   r<   Úfloat64r=   r>   r"   r"   r#   rV   õ   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_xgesvrK   rC   r"   r"   r#   rX     s    ø
z_LAPACK.numba_xgesvN)rD   rE   rF   rG   r4   rH   rJ   rM   rN   rO   rP   rQ   rR   rT   rU   rV   rX   r"   r"   r"   r#   rI   s   s0   


	



	



rI   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 |||¡ qªd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   ÚArrayr\   Ú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    

re   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#   Úimpl5  s    zcheck_c_int.<locals>.implN)Úcompile_internalr   r   Únoner;   )r+   r,   rg   ri   r"   rh   r#   Úcheck_c_int/  s     ÿrl   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    
rq   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.
    Frm   z%LAPACK wrapper returned with an errorNrn   ro   r"   r"   r#   Úcheck_lapack_returnI  s    
rr   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Úbitcastrq   )r+   r,   Ú	conjugater   rg   Za_dataZb_dataÚout_dataÚfntyÚfnr!   Úkind_valrp   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rt|\}}|d }n|\}}|d }t|
ƒ}t  tt|ƒ¡}t  t|r®t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   Útrg   N)r   rs   rt   ru   rv   rw   r   rx   ry   r   r0   r\   r$   rz   r{   r}   r~   rq   )r+   r,   Údo_transZm_typeÚm_shapesÚm_dataÚv_datar€   r�   r‚   r   ÚalphaÚbetaÚmrg   Úldar!   rƒ   Útransrp   r"   r"   r#   Úcall_xxgemvk  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   rA   r…   r†   rˆ   rg   c                    s8   | j ˆj krˆnˆ| j dkr$|d n|d ˆ  |t¡fS )NrZ   r   r   )r\   r~   rw   )r-   ZshapesÚdata©r,   ZnotransÚout_typer‘   r"   r#   Úget_array_paramª  s    
úz$call_xxgemm.<locals>.get_array_paramN)r   rs   rt   ru   rv   rw   r   rx   ry   r   r0   rz   r{   r$   r}   r~   rq   )!r+   r,   Zx_typeÚx_shapesÚx_dataZy_typeÚy_shapesÚy_datar•   Ú
out_shapesr€   r�   r‚   r�   ÚkÚ_krg   r   r�   rŽ   r–   Ztransar�   Zdata_aZtransbZldbZdata_bÚ_ZldcZdata_cr!   rƒ   rp   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�   rg   Úoutr"   r"   r#   Údot_implÆ  s    

zdot_2_mm.<locals>.dot_impl©rj   r   rc   ©r+   r,   r@   r^   rª   rp   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�   Ú_mrg   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�   rg   Ú_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�   rg   r"   r"   r#   Ú
check_argsý  s    zdot_2_vv.<locals>.check_args)r^   rc   r   r   Úunpack_tupler¢   rj   r   r   rk   rl   Zalloca_onceZget_value_typer„   r“   Úload)r+   r,   r@   r^   r   ZatyZbtyr   r§   r¨   rg   r´   r©   r"   r"   r#   Údot_2_vvò  s    
 ÿr·   c                 C   s   t d| |ƒS )z
    np.dot(a, b)
    znp.dot()©Ú
dot_2_impl©ÚleftÚrightr"   r"   r#   Údot_2  s    r½   c                 C   s   t d| |ƒS )z
    a @ b
    z'@'r¸   rº   r"   r"   r#   Úmatmul_2  s    r¾   c                    sd   t |tjƒr`t |tjƒr`t‡fdd„ƒ‰ |jdks<|jdkrTt dˆ||ff t¡ ‡ fdd„S d S )Nc                    s˜   |j |j f‰ ‡ fdd„}|j|jkr0tdˆ ƒ‚ˆ dkrJt |jdd¡}n>ˆ dksZˆ dkrlt |jd	d¡}nˆ d
kr||j}ntdˆ ƒ‚t|||ƒ|fS )Nc              
      s¸   t ƒ  t| |||ƒ�š\}}ˆ dkr<t| |||ƒW  5 Q R £ S ˆ dkr^t| |||ƒW  5 Q R £ S ˆ dkr€t| |||ƒW  5 Q R £ S ˆ dkr¢t| |||ƒW  5 Q R £ S tdƒ‚W 5 Q R X d S )N©é   rÀ   ©rÀ   r   ©r   rÀ   ©r   r   Úunreachable)r(   re   r­   r±   r¯   r·   ÚAssertionError©r+   r,   r@   r^   ©Úndimsr"   r#   Ú_dot2_codegen#  s    z0dot_2_impl.<locals>._impl.<locals>._dot2_codegenz)%s arguments must all have the same dtyper¿   rÀ   rZ   rÁ   rÂ   r   rÃ   z*%s: inputs must have compatible dimensions)Úndimr   r   r   r`   r   )Útypingcontextr»   r¼   rÉ   rc   )ÚnamerÇ   r#   Ú_impl  s     ÿÿzdot_2_impl.<locals>._implrY   z/%s is faster on contiguous arrays, called on %sc                    s
   ˆ | |ƒS r*   r"   rº   ©rÍ   r"   r#   Ú<lambda>F  ó    zdot_2_impl.<locals>.<lambda>©r_   r   r`   r   r\   ÚwarningsÚwarnr   )rÌ   r»   r¼   r"   )rÍ   rÌ   r#   r¹     s    ! ÿþr¹   c                    s^   t | tjƒrZt |tjƒrZtdd„ ƒ‰ | jdks8|jdkrNt d| |ff t¡ ‡ fd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r8tdƒ‚t|j||ƒ|fS )Nc              
   S   sB   t ƒ  t| |||ƒ�$\}}t| |||dd�W  5 Q R £ S Q R X d S )NT)r   )r(   re   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>._implrY   ú6np.vdot() is faster on contiguous arrays, called on %sc                    s
   ˆ | |ƒS 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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®   rg   r"   r"   r#   Údot_3_vm_check_argsh  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°   rg   r"   r"   r#   Údot_3_mv_check_argss  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‡   rZ   ú==Frm   )r^   rc   rÅ   r   r   r   rµ   r¢   rÊ   r\   r“   r×   rØ   rj   r   r   rk   rl   Úget_constantr;   Úicmp_signedÚor_Úif_elseÚmemsetÚmulÚitemsizeÚnitemsr’   r   Ú	_getvalue)r+   r,   r@   r^   ÚxtyÚytyÚouttyr   ÚxÚ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_vm~  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s¤t‚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À   rZ   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�   rg   r"   r"   r#   r´   Ë  s    

zdot_3_mm.<locals>.check_argsrÙ   Frm   )r^   rc   rÅ   r   r   r   rµ   r¢   r\   rj   r   r   rk   rl   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�   rg   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                    st   t | tjƒrpt |tjƒrpt |tjƒrptdd„ ƒ‰ | jdksN|jdksN|jdkrdt d| |ff t¡ ‡ fd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| |||ƒ�x\}}tdd„ |jd d… D ƒƒ}|dhkrZt| |||ƒW  5 Q R £ S |ddhkr€t| |||ƒW  5 Q R £ S tdƒ‚W 5 Q R X 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(   re   Úsetr^   rî   rì   rÅ   )r+   r,   r@   r^   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>._implrY   rÕ   c                    s   ˆ | ||ƒS r*   r"   ©r»   r¼   r©   rÎ   r"   r#   rÏ   1  rÐ   zdot_3.<locals>.<lambda>NrÑ   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_matrix7  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ƒsŒd| }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_typesT  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£   ra   ÚflagsÚf_contiguousÚTZasfortranarray)r§   ÚacpyZflag_f©ZA_layoutZF_layoutr"   r#   ri   f  s    
z&ol_copy_to_fortran_order.<locals>.implr[   )r§   ri   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_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    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§   rg   r  r  Úipivr  ©r!   rJ   Znumba_xxgetrir"   r#   Úinv_impl˜  s    
zinv_impl.<locals>.inv_impl)r)   r  rI   rJ   r   rM   r{   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_problem´  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_matrix¾  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r€tj d¡‚t|ƒD ]}d|d |…|f< qˆ|S )Nr  r  r  r   z Matrix is not positive definite.)	r¢   r£   r÷   rø   ra   r  r  rÅ   Úrange)r§   rg   r  r©   r  Úcol©ZUPr!   rQ   r"   r#   Úcho_implÜ  s&    
ÿzcho_impl.<locals>.cho_impl)r)   r  rI   rQ   r   r{   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 |¡rÜt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§   rg   r  r  ÚldvlÚldvrÚwrZwiÚvlÚvrr  ©ÚJOBVLÚJOBVRr!   rN   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§   rg   r  r  r2  r3  Úwr5  r6  r  ©r8  r9  r!   rO   r"   r#   Úcmplx_eig_implB  s8    

öz eig_impl.<locals>.cmplx_eig_impl©r)   r  rI   rN   r   rO   r{   r$   r_   r   Zscalarsr  )r§   r:  r>  r"   ©r8  r9  r!   rO   rN   r#   Úeig_implü  s    
8(rA  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 
|¡rÎt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"  r0  r³   r  r  r1  r7  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.
        r  r  r  r   r  r   )r¢   r£   r÷   rø   rú   r	  r¥   r   r  r"  r  r  r;  r=  r"   r#   Úcmplx_eigvals_impl¸  s8    
öz(eigvals_impl.<locals>.cmplx_eigvals_implr?  )r§   rC  rD  r"   r@  r#   Úeigvals_implo  s    
;)rE  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Úeighr5   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§   rg   r  r  r<  r  ©ÚJOBZZUPLOr!   rP   Zw_dtyper"   r#   Ú	eigh_impl÷  s(    
úzeigh_impl.<locals>.eigh_impl©
r)   r  r8   r   Ú
np_supportÚas_dtyperI   rP   r{   r$   )r§   Úw_typerL  r"   rJ  r#   rL  æ  s    

rL  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Úeigvalshr5   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 rG  rH  rI  rJ  r"   r#   Úeigvalsh_impl(  s(    
úz$eigvalsh_impl.<locals>.eigvalsh_implrM  )r§   rP  rR  r"   rJ  r#   rR    s    

rR  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Úsvdr5   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_matricesrg   r�   r  ÚlduÚminmnrK  ÚucolÚldvtÚur   Úvtr  ©ZJOBZ_AZJOBZ_Sr!   rR   Ús_dtyper"   r#   Úsvd_implY  sD    


õzsvd_impl.<locals>.svd_impl)r   )
r)   r  r8   r   rN  rO  rI   rR   r{   r$   )r§   rW  Ús_typer`  r"   r^  r#   r`  H  s    

.r`  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 rŠt
ƒ  dsŠt‚tj||f| jd�j}t|ƒD ]*}	t|	d ƒD ]}
||
|	f ||
|	f< q¸q¨t||ƒD ]&}	t|ƒD ]}
||
|	f ||
|	f< qêqÞˆˆ ||||j	||j	ƒ}t|ƒ t|j|jgƒ |d d …d |…f |fS )Nr  r  r   rU  r  r   )r¢   r£   r÷   rø   rú   r	  rV  r¥   r   r  r  rÅ   r¤   r  r)  r"  r  r  )r§   rg   r�   Úqr�   rY  ÚtauÚretr  ÚiÚj©r!   rT   rU   r"   r#   Úqr_impl›  sN    


úù	zqr_impl.<locals>.qr_impl)r)   r  rI   rT   r   rU   r{   r$   )r§   ri  r"   rh  r#   ri  Š  s    
9ri  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    ro  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¢   rl  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  rp  rl  r"   r"   r#   Ú	twoD_implé  s    z)_system_copy_in_b_impl.<locals>.twoD_implrï   )rm  r¨   rn  rq  rr  r"   r"   r#   Ú_system_copy_in_b_implâ  s
    
rs  c                 C   s   t ‚dS )zK
    Compute the number of right hand sides in the system of equations
    Nrj  ©r¨   r"   r"   r#   Ú_system_compute_nrhsî  s    ru  c                 C   s&   | j dkrdd„ }|S dd„ }|S d S )Nr   c                 S   s   dS ©Nr   r"   rt  r"   r"   r#   rq  ø  s    z,_system_compute_nrhs_impl.<locals>.oneD_implc                 S   s
   | j d S )Nr  rp  rt  r"   r"   r#   rr  ü  s    z,_system_compute_nrhs_impl.<locals>.twoD_implrï   )r¨   rq  rr  r"   r"   r#   Ú_system_compute_nrhs_implõ  s
    
rw  c                 C   s   t ‚dS )zD
    Check that AX=B style system input is dimensionally valid.
    Nrj  ©r§   r¨   r"   r"   r#   Ú!_system_check_dimensionally_valid  s    ry  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#   rq    s    

ÿz9_system_check_dimensionally_valid_impl.<locals>.oneD_implc                 S   s,   | j d }|j d }||kr(tj d¡‚d S )Nr  rz  r{  r|  r"   r"   r#   rr    s    

ÿz9_system_check_dimensionally_valid_impl.<locals>.twoD_implrï   ©r§   r¨   rÊ   rq  rr  r"   r"   r#   Ú&_system_check_dimensionally_valid_impl  s    r€  c                 C   s   t ‚dS )z:
    Check that AX=B style system input is not empty.
    Nrj  rx  r"   r"   r#   Ú_system_check_non_empty  s    r�  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   rU  r{  )r§   r¨   r}  Úanr~  r"   r"   r#   rq  (  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 r‚  r{  )r§   r¨   r}  rƒ  r~  Úbnr"   r"   r#   rr  0  s    



 z/_system_check_non_empty_impl.<locals>.twoD_implrï   r  r"   r"   r#   Ú_system_check_non_empty_impl$  s    r…  c                 C   s   t ‚dS )z:
    Compute the residual from the 'b' scratch space.
    Nrj  )r¨   rg   rn  r"   r"   r#   Ú_lstsq_residual:  s    r†  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 )
Nr5   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¨   rg   rn  rp   ©Ú
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 ©Nr  rÀ   )r£   r¥   r)  r‰  rŠ  ©r¨   rg   rn  rp   rœ   rŒ  r"   r#   rŽ  W  s    &c                    s>   t j|ˆ d�}t|ƒD ]"}t  | |d …|f d ¡||< q|S r�  )r£   r¥   r)  r‰  r‘  rŒ  r"   r#   r�  ^  s     )	rÊ   r   rN  rO  r8   r_   r   r  rÅ   )r¨   rg   rn  rÊ   r   rŽ  r�  r"   rŒ  r#   Ú_lstsq_residual_implA  s    r’  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...
    Nrj  ©r¨   rm  rg   r"   r"   r#   Ú_lstsq_solutionf  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  Úravelr“  r"   r"   r#   rq  q  s    z'_lstsq_solution_impl.<locals>.oneD_implc                 S   s   |d |…d d …f   ¡ S r*   ©ra   r“  r"   r"   r#   rr  u  s    z'_lstsq_solution_impl.<locals>.twoD_implrï   )r¨   rm  rg   rq  rr  r"   r"   r#   Ú_lstsq_solution_impln  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Úlstsqr5   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rîtj	dˆd�}nt|	||ƒ}t||	|ƒ}t|j|	j|
j|jgƒ ||||
d |… fS )Nr  r  r  r   r   )r¢   ru  rú   r�  ry  rV  Úmaxr	  r£   r¥   r  ro  Úint32r  r"  r†  r”  r  r  )r§   r¨   Úrcondrg   r�   rn  rY  Zmaxmnr  rm  r   Zrank_ptrr  Úrankrp   ræ   ©r!   Únp_dtrV   r�  r"   r#   Ú
lstsq_impl—  sF    





õzlstsq_impl.<locals>.lstsq_impl)r™  )r)   r  r%  r  rN  rO  r   r8   rI   rV   r{   r$   )r§   r¨   r�  Únb_dtZr_typer¡  r"   rŸ  r#   r¡  z  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...
    Nrj  ©r¨   rm  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#   rq  ä  s    z-_solve_compute_return_impl.<locals>.oneD_implc                 S   s   |S r*   r"   r£  r"   r"   r#   rr  è  s    z-_solve_compute_return_impl.<locals>.twoD_implrï   )r¨   rm  rq  rr  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¢   ru  rú   ry  r	  r£   r¥   r  r¤  ro  r  r  r  r  r  )r§   r¨   rg   rn  r  rm  r  r  ©r!   r   rX   r"   r#   Ú
solve_implþ  s0    


ø
zsolve_impl.<locals>.solve_impl)r)   r  r%  r  rN  rO  r   rI   rX   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Úpinvr5   rT  rZ   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rÌd||  ||< |}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–  ÚreshaperV  r£   r¥   r   r  r"  r)  r  r  )r§   r�  rg   r�   r  rY  r\  r   r]  r  Zcut_atZcut_idxrœ   rf  rg  Zs_local©	ZJOBZTRANSAZTRANSBr!   rR   rA   rí   r_  rè   r"   r#   Ú	pinv_implD  sv    '


õ
& 	òÿzpinv_impl.<locals>.pinv_impl)r©  )r)   r  r8   r   rN  rO  rI   rR   r1   rA   r{   r$   r£   Úarray)r§   r�  ra  Ú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£   rŠ  Úlog)rg   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°  )rg   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   r5   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r€dtj	 fS t
|ƒ d}t|ƒD ]}||| |d k }q”|d@ }|dkrÂd}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§   rg   r  r  r  r  r±  rœ   ©ZONEZZEROZdiag_walkerr!   rJ   r"   r#   Úslogdet_impl  s*    
	z"slogdet_impl.<locals>.slogdet_impl)	r)   r  rI   rJ   r   r{   r$   rµ  r8   )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)   r  )r§   r¼  r"   r"   r#   r¼  -  s    
r¼  c                 C   s   t ‚dS )z)
    Compute singular values of *a*.
    Nrj  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`
    rS  r.  r5   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   rU  r   r  )r¢   r£   r÷   rø   rú   rV  r	  r¥   r  r"  r  r  )
r§   rg   r�   rX  rY  rZ  r[  r  r   r  ©ZJOBZ_Nr!   Únp_ret_typerR   r\  r]  r"   r#   Úsv_functionW  s6    


õz2_compute_singular_values_impl.<locals>.sv_function)
rI   rR   r   r{   r$   r8   rN  rO  r£   r¥   )r§   Únb_ret_typeÚnp_dtyperÁ  r"   r¿  r#   Ú_compute_singular_values_implB  s    
/rÄ  c                 C   s   t ‚dS )z.
    Compute the L2-norm of 1D-array *a*.
    Nrj  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 )Nr5   Únormc                    sl   t | ƒ}tjdˆd�}t| jd | j ƒ}ˆˆ || j||jƒ}|dk rTtƒ  dsTt‚t	|j
| j
gƒ |d S )Nrˆ  r  r   )Úlenr£   r¥   r|   Ústridesrà   r  r  rÅ   r  r  )r§   rg   re  Zjmpr  ©r!   rÀ  Úxxnrm2r"   r#   ri   ™  s    ûz_oneD_norm_2_impl.<locals>.impl)r8   r   rN  rO  r1   r6   r{   r$   )r§   rÂ  ri   r"   rÉ  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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r¨td	d
„ ƒ‰ n$| jdkrÀtdd
„ ƒ‰ ntdd
„ ƒ‰ d‡ fdd„	}nt |j¡j‰d‡fdd„	}|S d�st‚d S )Nr5   rÆ  r   c                 S   s   t | ƒS r*   )rÅ  ©r§   r{   r"   r"   r#   rq  Ñ  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rªt| d ƒ}td|ƒD ]}t| | ƒ}||k rˆ|}qˆ|S |dkrÜd}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·  rŠ  r)  )r§   r{   rg   re  rœ   r.   r"   r"   r#   rq  Ô  sD    


rÀ   rZ   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§   r{   rg   Za_c)rÍ  r"   r#   rr  &	  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�rˆt| ƒd S |dk�ržt| ƒd S tdƒ‚d S )Nr  r  r   r†   r   rÀ   z Invalid norm order for matrices.)r¢   r  r£   r·  r)  rŠ  r¾  r³   )	r§   r{   rg   r�   Z
global_maxÚiiÚtmpZjjZ
global_min)Úmax_valr"   r#   rr  1	  sZ    








r   )N)N)N)N)r8   r   rN  rO  r1   r6   r{   r$   rÊ   r   rk   r\   r
   r£   Úfinforÿ   r›  rÅ   )	r§   Zord_flagrÂ  rÀ  rÃ  rÊ  r!   rq  rr  r"   )rÍ  rÐ  r#   Ú_get_norm_impl´  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 ¡}qˆt |d |d ¡}n,tj | |¡}tj tj | ¡|¡}|| }t |¡r˜t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#   ri   Š	  s    
zcond_impl.<locals>.impl)Nr½  )r§   r×  ri   r"   r"   r#   Ú	cond_impl„	  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_values±	  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 )Nr5   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   rk   r8   r   rN  rO  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_impl¿	  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 ržt j | ¡ ¡ }|dkr–|S | }n|dkr®|  ¡ S | }|dk rì|d	krÎt  ||¡S |d
krêt  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³   ra   r÷   r  r¦   )
r§   rg   r
  rœ   r}  rƒ  r²  r»  re  Úflag©rÃ  r"   r#   Úmatrix_power_impl
  sH    


z,matrix_power_impl.<locals>.matrix_power_impl)	r  rN  rO  r   r8   r_   r   ÚIntegerr   )r§   rg   Ú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›  rV  r)  )r§   ÚoffsetÚrowsÚcolsrœ   rg   re  rf  r"   r"   r#   Úmatrix_trace_impl]
  s    
z,matrix_trace_impl.<locals>.matrix_trace_impl)r   )r  r_   r|   r   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_matq
  s    
ÿÿrõ  c                 C   s@   t  | ¡}t  |¡}t  | ¡  |jdf¡| ¡  d|jf¡¡S rv  ©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 rv  rö  rø  r"   r"   r#   Úouter_impl_arrƒ
  s    

þrü  c                 C   s   |d t jfkrtS tS d S r*   )r   rk   rû  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ÚouterFrð  c                    s   ˆ | ||ƒS r*   r"   rý  ©ri   r"   r#   Ú
outer_implœ
  s    zouter_impl.<locals>.outer_impl)N)rõ  rþ  )r§   r¨   r©   r  r"   r   r#   r  ”
  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)rZ   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  ±
  s    
c                 S   s   t  dt| ƒ¡}| |d< |S )NrÃ   r   )r£   r¥   rÿ   )ræ   r§   r"   r"   r#   r  ·
  s    )r_   r   r`   r\   r   ÚformatrÊ   r
   )ræ   r  r"   r"   r#   Ú_kron_normaliser_impl¢
  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#   re  Æ
  s    z_kron_return.<locals>.retc                 S   s   |  |j¡S r*   )r«  r  r  r"   r"   r#   re  Ë
  s    c                 S   s   |  | j¡S r*   ©r«  r¢   r  r"   r"   r#   re  Ñ
  s    c                 S   s   |  |j¡S r*   r  r  r"   r"   r#   re  Ö
  s    c                 S   s   |d S r    r"   r  r"   r"   r#   re  Û
  s    )r_   r   r`   rÊ   r
   )r§   r¨   Za_is_arrZb_is_arrre  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Ú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< qšqvqbˆ| ||
ƒS )Nr  r  r  )r¢   r£   r¥   r)  )r§   r¨   rù  rú  r}  rƒ  r~  r„  ÚcmZcnrZ   rf  Zrjmprœ   ZirjmpZslcrg  Zcjmp©r¯  Zfix_aZfix_bZret_cr"   r#   Ú	kron_implï
  s$    



&zkron_impl.<locals>.kron_impl)rõ  r  r	  r8   )r§   r¨   r  r"   r  r#   r  á
  s    
(r  )r   )F)T)T)r   )r™  )r©  )N)N)N)r   )T)N)ŸrG   Ú
contextlibrÒ   Zllvmliter   Únumpyr£   ÚoperatorZnumba.core.imputilsr   r   r   r   Znumba.core.typingr   Znumba.core.extendingr   r	   r
   Z
numba.corer   r   Znumba.core.errorsr   r   r   Zarrayobjr   r   r   Znumba.npr   rN  rt   ru   Z
as_pointerZ	ll_char_prw   Zll_intcZ	ll_intc_prv   Z	ll_intp_prœ  r  rL   Zfloat32rW   Z	complex64Z
complex128r   r$   r(   r)   r0   r1   rI   Úcontextmanagerre   rl   rq   rr   r„   r’   rŸ   r­   r¯   r±   r·   r¦   r½   Úmatmulr¾   r¹   rÖ   r×   rØ   rì   rî   rô   r=   r9   r  rú   r  r  r	  r  r  r  r÷   r  r!  r"  r%  r&  r,  r-  rA  rB  rE  rF  rL  rQ  rR  rS  r`  rb  ri  ro  rs  ru  rw  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
  r  r"   r"   r"   r#   Ú<module>   s<  

    ü
) $
%2


,
9Y
#



	


'
	


+

r

v

0

0
A

P




$

^


<
 $$

:


F
# H

,

A

P

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