o
    –ôj^} ã                   @   s¤  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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! ddl"m#Z# e $d¡Z%e% &¡ Z'e'Z(e $d¡Z)e) &¡ Z*ej+Z+e+ &¡ Z,dd„ Z-e.e/e#ddƒƒZ0e0Z1dZ2dd„ Z3e1r’ej4nej5Z6e1ršej4nej5Z7ej8dej9dej:dej;diZ<dÃdd„Z=dd„ Z>dd „ Z?d!d"„ Z@G d#d$„ d$ƒZAG d%d&„ d&ƒZBejCd'd(„ ƒZDd)d*„ ZEd+d,„ ZFd-d.„ ZGd/d0„ ZHd1d2„ ZId3d4„ ZJd5d6„ ZKd7d8„ ZLd9d:„ ZMdÄd;d<„ZNeejOƒd=d>„ ƒZPeejQƒd?d@„ ƒZRdAdB„ ZSeejTƒdCdD„ ƒZTdEdF„ ZUdGdH„ ZVdIdJ„ ZWdKdL„ ZXeejOƒdMdN„ ƒZYe ZdOe [¡ ¡Z\edPdQ„ ƒZ]dÅdSdT„Z^dUdV„ Z_dWdX„ Z`ee`ƒdYdZ„ ƒZaed[d\„ ƒZbed]d^„ ƒZceejdjeƒd_d`„ ƒZfedadb„ ƒZgdÅdcdd„Zheejdjiƒdedf„ ƒZjeejdjkƒdgdh„ ƒZleejdjmƒdidj„ ƒZneejdjoƒdkdl„ ƒZpeejdjqƒdmdn„ ƒZreejdjsƒdÆdodp„ƒZteejdjuƒdqdr„ ƒZvdsdt„ Zweewƒdudv„ ƒZxdwdx„ Zyeeyƒdydz„ ƒZzd{d|„ Z{ee{ƒd}d~„ ƒZ|dd€„ Z}ee}ƒd�d‚„ ƒZ~dƒd„„ Zeeƒd…d†„ ƒZ€d‡dˆ„ Z�ee�ƒd‰dŠ„ ƒZ‚eejdjƒƒdÇdŒd�„ƒZ„dŽd�„ Z…ee…ƒd�d‘„ ƒZ†eejdj‡ƒd’d“„ ƒZˆeejdj‰ƒdÈd•d–„ƒZŠd—d˜„ Z‹eejdjŒƒd™dš„ ƒZ�eejdjŽƒd›dœ„ ƒZ�d�dž„ Z�ee�ƒdŸd „ ƒZ‘d¡d¢„ Z’ee’ƒd£d¤„ ƒZ“d¥d¦„ Z”eejdj•ƒdÉd§d¨„ƒZ–eejdj—ƒdÉd©dª„ƒZ˜ed«d¬„ ƒZ™eejdjšƒdÉd­d®„ƒZ›eejdjœƒ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Úconfig)ÚTypingErrorÚNumbaTypeErrorÚNumbaPerformanceWarningé   )Ú
make_arrayÚ_empty_nd_implÚ
array_copy)Únumpy_support)Ú
_helperlibé   é    c               
   C   s>   zddl m}  t| d d d ƒW S  tttfy   Y dS w )a  
    Whether the scipy actually installed *right now* provides ILP64 (64-bit
    Fortran integer) scipy.linalg.cython_blas / cython_lapack, as opposed to
    the usual 32-bit ("LP64") ones. This may differ from what numba's own
    _lapack.c wrappers were *built* for (see _LAPACK_BUILD_ILP64 below and
    _check_lapack_int_width()) -- scipy can be upgraded/downgraded/swapped
    independently of numba. SciPy records which ABI it built for in
    scipy.__config__ (see scipy.linalg.blas.HAS_LP64, which reads the same
    flag).
    r   ©ÚCONFIGzBuild DependenciesÚblaszcython blas ilp64F)Úscipy.__config__r   ÚboolÚImportErrorÚKeyErrorÚ	TypeErrorr   © r!   ú`/var/www/html/academy/tools/voices/clone/sv-venv/lib/python3.10/site-packages/numba/np/linalg.pyÚ_lapack_runtime_is_ilp64"   s   ýr#   ÚLAPACK_BUILD_ILP64FzYhttps://numba.readthedocs.io/en/stable/user/installing.html#numba-source-install-env_varsc                  C   sF   t ƒ } | tkr!trdnd}| rdnd}td|› d|› dt› d�ƒ‚dS )a‹  
    Guard against a numba built for one Fortran integer width being used
    against a scipy providing the other one: the compiled numba_* wrappers
    assume a fixed width, so calling through the wrong one is silent memory
    corruption or wrong answers, not a clean error -- refuse outright
    instead. Called from ensure_blas()/ensure_lapack(), once scipy is
    confirmed importable.
    ZILP64ZLP64z!This copy of Numba was built for z3 BLAS/LAPACK, but the scipy installed now provides zí scipy.linalg.cython_blas/cython_lapack. Numba's compiled BLAS/LAPACK wrappers assume a fixed integer width and will produce wrong results or crash if called against the wrong one. Either install a matching SciPy or rebuild Numba -- see z for details.N)r#   Ú_LAPACK_BUILD_ILP64ÚRuntimeErrorÚ_LAPACK_INSTALL_DOCS_URL)Zruntime_ilp64Zbuilt_asZfound_asr!   r!   r"   Ú_check_lapack_int_widthE   s   	ÿúÿýr(   ÚsÚdÚcÚzú<BLAS function>c                 C   s$   t  | ¡}|d u rtd|f ƒ‚|S )Nzunsupported dtype for %s())Ú_blas_kindsÚgetr   )ÚdtypeÚ	func_nameÚkindr!   r!   r"   Úget_blas_kindj   s   
r3   c                  C   ó.   zdd l } W n ty   tdƒ‚w tƒ  d S ©Nr   z*scipy 0.16+ is required for linear algebra)Úscipy.linalg.cython_blasr   r(   ©Úscipyr!   r!   r"   Úensure_blasq   ó   ÿ
r9   c                  C   r4   r5   )Úscipy.linalg.cython_lapackr   r(   r7   r!   r!   r"   Úensure_lapacky   r:   r<   c                 C   s   |   |||¡}t ||¡S ©N)Úget_constant_genericr   Úalloca_once_value)ÚcontextÚbuilderÚtyÚvalÚconstr!   r!   r"   Úmake_constant_slot�   s   rE   c                   @   s0   e Zd ZdZdd„ Zedd„ ƒZedd„ ƒZdS )	Ú_BLASzM
    Functions to return type signatures for wrapped
    BLAS functions.
    c                 C   ó
   t ƒ  d S r=   )r9   ©Úselfr!   r!   r"   Ú__init__Œ   ó   
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©Úclsr0   ÚrtypeÚsigr!   r!   r"   rM   �   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   rP   rQ   rR   rS   rT   ©rV   r0   rX   r!   r!   r"   rY   š   s"   òz_BLAS.numba_xxgemmN)Ú__name__Ú
__module__Ú__qualname__Ú__doc__rJ   ÚclassmethodrM   rY   r!   r!   r!   r"   rF   †   s    

rF   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   rG   r=   )r<   rH   r!   r!   r"   rJ   µ   rK   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   rP   rQ   rR   rS   ÚF_INT_nbtyperT   r[   r!   r!   r"   rb   ¸   s   ûz_LAPACK.numba_xxgetrfc              	   C   s0   t  t jt jt  |¡t jt  t¡¡}t  d|¡S )NÚnumba_ez_xxgetrirc   r[   r!   r!   r"   re   Ã   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_rgeevrZ   r[   r!   r!   r"   rf   Í   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_cgeevrZ   r[   r!   r!   r"   rg   Þ   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 )NrL   Únumba_ez_xxxevdrN   )rV   r0   ZwtyperX   r!   r!   r"   rh   î   s   úz_LAPACK.numba_ez_xxxevdc                 C   s,   t  t jt jt jt  |¡t j¡}t  d|¡S )NÚnumba_xxpotrfrZ   r[   r!   r!   r"   ri   û   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 )NrL   Únumba_ez_gesddrN   )rV   r0   ÚstyperX   r!   r!   r"   rj     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_geqrfrZ   r[   r!   r!   r"   rl     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_xxgqrrZ   r[   r!   r!   r"   rm   $  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¡¡}t d|¡S )NrL   Únumba_ez_gelsd)	rO   r   rP   rQ   rR   rS   Úfloat64rd   rT   rU   r!   r!   r"   rn   1  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_xgesvrc   r[   r!   r!   r"   rp   C  s   ø
z_LAPACK.numba_xgesvN)r\   r]   r^   r_   rJ   r`   rb   re   rf   rg   rh   ri   rj   rl   rm   rn   rp   r!   r!   r!   r"   ra   ¯   s2    


	



	



ra   c                 c   sÌ   � g }g }g }t |j|ƒD ]9\}}t|tjƒr|jdv r"||}	}
n|jdd�}	t|	|ƒ}t| |||fƒ}
| 	|	|
f¡ | 	|	¡ | 	|
¡ qt|j
g|¢R Ž t|ƒfV  |D ]\}}| j |||¡ qWdS )zƒ
    Ensure that all array arguments are contiguous, if necessary by
    copying them.
    A new (sig, args) tuple is yielded.
    ÚCFÚC©ÚlayoutN)ÚzipÚargsÚ
isinstancer   ÚArrayrt   Úcopyr   r   ÚappendÚreturn_typeÚtupleÚnrtÚdecref)r@   rA   rX   rv   ZnewtysÚnewargsZcopiesrB   rC   ÚnewtyÚnewvalZcopysigr!   r!   r"   Úmake_contiguousR  s"   €

ÿr‚   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"   Úimplq  s   ÿzcheck_c_int.<locals>.implN)Úcompile_internalr   r   ÚnonerR   )r@   rA   r„   r†   r!   r…   r"   Úcheck_c_intk  s
   ÿr‰   c                 C   óX   |j t ||¡dd�� |  |¡}| ¡  | d¡ W d  ƒ dS 1 s%w   Y  dS )z[
    Check the integer error return from one of the BLAS wrappers in
    _helperlib.c.
    F©Úlikelyz#BLAS wrapper returned with an errorN©Úif_thenr   Úis_not_nullÚget_python_apiÚ
gil_ensureÚfatal_error©r@   rA   ÚresÚpyapir!   r!   r"   Úcheck_blas_returny  ó
   
"ür–   c                 C   rŠ   )z]
    Check the integer error return from one of the LAPACK wrappers in
    _helperlib.c.
    Fr‹   z%LAPACK wrapper returned with an errorNr�   r“   r!   r!   r"   Úcheck_lapack_return…  r—   r˜   c                 C   s–   t  t  d¡ttttttg¡}t |j|d¡}	t	|ƒ}
t  
tt|
ƒ¡}t  
tt|ƒ¡}| |	|||| |t¡| |t¡| |t¡f¡}t| ||ƒ dS )zQ
    Call the BLAS vector * vector product function for the given arguments.
    r   Znumba_xxdotN)r   ÚFunctionTypeÚIntTypeÚll_charÚintp_tÚ	ll_void_pr   Úget_or_insert_functionÚmoduler3   ÚConstantÚordÚintÚcallÚbitcastr–   )r@   rA   Ú	conjugater0   r„   Úa_dataÚb_dataÚout_dataÚfntyÚfnr2   Úkind_valr”   r!   r!   r"   Ú
call_xxdot‘  s   ÿÿ


ýr¬   c                 C   s  t  t  d¡ttttttttttg
¡}t |j|d¡}	|j	}
t
| ||
dƒ}t
| ||
dƒ}|jdkr:|\}}|d }n|\}}|d }t|
ƒ}t  tt|ƒ¡}t  t|rWtdƒntd	ƒ¡}| |	||||| |t¡| |t¡|| |t¡| |t¡| |t¡f
¡}t| ||ƒ d
S )zQ
    Call the BLAS matrix * vector product function for the given arguments.
    r   Znumba_xxgemvç      ð?ç        ÚFr   r   Útr„   N)r   r™   rš   r›   rœ   r�   r   rž   rŸ   r0   rE   rt   r3   r    r¡   r£   r¤   r–   )r@   rA   Údo_transZm_typeÚm_shapesÚm_dataÚv_datar¨   r©   rª   r0   ÚalphaÚbetaÚmr„   Úldar2   r«   Útransr”   r!   r!   r"   Úcall_xxgemv§  s6   ýÿ





ûrº   c           !         s8  t  t  d¡ttttttttttttttg¡}t ˆ j|d¡}|\}}|\}}|j	}t
| ˆ |dƒ}t
| ˆ |dƒ}t  ttdƒ¡‰t  ttdƒ¡‰‡ ‡‡‡fdd„}||||ƒ\}}}||||ƒ\}}}|ˆ|	|
ƒ\}}}t|ƒ}t  tt|ƒ¡}ˆ  |||||||ˆ  |t¡||||ˆ  |t¡||f¡} t| ˆ | ƒ d	S )
zQ
    Call the BLAS matrix * matrix product function for the given arguments.
    r   rY   r­   r®   r°   r„   c                    s8   | j ˆj krˆnˆ| j dkr|d n|d ˆ  |t¡fS )Nrr   r   r   )rt   r¤   r�   )rB   ÚshapesÚdata©rA   ZnotransÚout_typer¹   r!   r"   Úget_array_paramæ  s   
úz$call_xxgemm.<locals>.get_array_paramN)r   r™   rš   r›   rœ   r�   r   rž   rŸ   r0   rE   r    r¡   r3   r£   r¤   r–   )!r@   rA   Zx_typeÚx_shapesÚx_dataZy_typeÚy_shapesÚy_datar¾   Ú
out_shapesr¨   r©   rª   r·   ÚkÚ_kr„   r0   rµ   r¶   r¿   Útransar¸   Zdata_aZtransbZldbZdata_bÚ_ZldcZdata_cr2   r«   r”   r!   r½   r"   Úcall_xxgemmÌ  s:   ûÿ
ýrÉ   c                 C   ó(   dd„ }|   ||||¡}t| ||j|ƒS )z 
    np.dot(matrix, matrix)
    c                 S   sN   | j \}}|j \}}|dkrt ||f| j¡S t ||f| j¡}t | ||¡S ©Nr   ©ÚshapeÚnpÚzerosr0   ÚemptyÚdot)ÚaÚbr·   rÅ   rÆ   r„   Úoutr!   r!   r"   Údot_impl  s   

zdot_2_mm.<locals>.dot_impl©r‡   r   r{   ©r@   rA   rX   rv   rÕ   r”   r!   r!   r"   Údot_2_mmþ  ó   rØ   c                 C   rÊ   )z 
    np.dot(vector, matrix)
    c                 S   sH   | j \}|j \}}|dkrt |f| j¡S t |f| j¡}t | ||¡S rË   rÌ   )rÒ   rÓ   r·   Ú_mr„   rÔ   r!   r!   r"   rÕ     s   
zdot_2_vm.<locals>.dot_implrÖ   r×   r!   r!   r"   Údot_2_vm  rÙ   rÛ   c                 C   rÊ   )z 
    np.dot(matrix, vector)
    c                 S   sH   | j \}}|j \}|dkrt |f| j¡S t |f| j¡}t | ||¡S rË   rÌ   )rÒ   rÓ   r·   r„   Ú_nrÔ   r!   r!   r"   rÕ   "  s   
zdot_2_mv.<locals>.dot_implrÖ   r×   r!   r!   r"   Údot_2_mv  rÙ   rÝ   c              	   C   s²   |j \}}|j}t|ƒ| ||d ƒ}t|ƒ| ||d ƒ}	t ||j¡\}
dd„ }|  ||ttj	g|j ¢R Ž |¡ t
| ||
ƒ t ||  |¡¡}t| ||||
|j|	j|ƒ | |¡S )z<
    np.dot(vector, vector)
    np.vdot(vector, vector)
    r   r   c                 S   s$   | j \}|j \}||krtdƒ‚d S )Nz;incompatible array sizes for np.dot(a, b) (vector * vector)©rÍ   Ú
ValueError)rÒ   rÓ   r·   r„   r!   r!   r"   Ú
check_args9  s
   ÿzdot_2_vv.<locals>.check_args)rv   r{   r   r   Úunpack_tuplerÍ   r‡   r   r   rˆ   r‰   Úalloca_onceÚget_value_typer¬   r¼   Úload)r@   rA   rX   rv   r¥   ÚatyÚbtyr0   rÒ   rÓ   r„   rà   rÔ   r!   r!   r"   Údot_2_vv.  s   
ÿ
rç   c                 C   ó   t d| |ƒS )z
    np.dot(a, b)
    znp.dot()©Ú
dot_2_impl©rÒ   rÓ   r!   r!   r"   Údot_2I  ó   rì   c                 C   rè   )z
    a @ b
    z'@'ré   rë   r!   r!   r"   Úmatmul_2Q  rí   rî   c                    sn   t |tjƒr3t |tjƒr5t‡fdd„ƒ‰ |jdvs|jdvr-tjs-t dˆ||ff t	¡ ‡ fdd„S d S d S )Nc                    s˜   |j |j f‰ ‡ fdd„}|j|jkrtdˆ ƒ‚ˆ dkr%t |jdd¡}nˆ dks-ˆ dkr6t |jd	d¡}nˆ d
kr>|j}ntdˆ ƒ‚t|||ƒ|fS )Nc                    sÆ   t ƒ  t| |||ƒ�O\}}ˆ dkrt| |||ƒW  d   ƒ S ˆ dkr1t| |||ƒW  d   ƒ S ˆ dkrCt| |||ƒW  d   ƒ S ˆ dkrUt| |||ƒW  d   ƒ S tdƒ‚1 s\w   Y  d S )N©é   rð   ©rð   r   ©r   rð   ©r   r   Úunreachable)r9   r‚   rØ   rÝ   rÛ   rç   ÚAssertionError©r@   rA   rX   rv   ©Úndimsr!   r"   Ú_dot2_codegen_  s    þüúø
öz0dot_2_impl.<locals>._impl.<locals>._dot2_codegenz)%s arguments must all have the same dtyperï   rð   rr   rñ   rò   r   ró   z*%s: inputs must have compatible dimensions)Úndimr0   r   r   rx   r   )ÚtypingcontextrÒ   rÓ   rù   r{   )Únamer÷   r"   Ú_impl[  s    ÿÿzdot_2_impl.<locals>._implrq   z/%s is faster on contiguous arrays, called on %sc                    ó
   ˆ | |ƒS r=   r!   rë   ©rý   r!   r"   Ú<lambda>„  ó   
 zdot_2_impl.<locals>.<lambda>©
rw   r   rx   r   rt   r   ÚDISABLE_PERFORMANCE_WARNINGSÚwarningsÚwarnr   )rü   rÒ   rÓ   r!   )rý   rü   r"   rê   Y  s   "ÿÿþÖrê   c                    sh   t | tjƒr0t |tjƒr2tdd„ ƒ‰ | jdvs|jdvr*tjs*t d| |ff t	¡ ‡ fdd„S dS dS )z
    np.vdot(a, b)
    c                 S   sJ   dd„ }|j dks|j dkrtdƒ‚|j|jkrtdƒ‚t|j||ƒ|fS )Nc                 S   sN   t ƒ  t| |||ƒ�\}}t| |||dd�W  d   ƒ S 1 s w   Y  d S )NT)r¥   )r9   r‚   rç   rö   r!   r!   r"   Úcodegen�  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   r0   r   )rû   ÚleftÚrightr  r!   r!   r"   rý   �  s   ÿzvdot.<locals>._implrq   ú6np.vdot() is faster on contiguous arrays, called on %sc                    rþ   r=   r!   ©r  r  rÿ   r!   r"   r   ¥  r  zvdot.<locals>.<lambda>Nr  r
  r!   rÿ   r"   Úvdot‡  s   
ÿÿþçr  c                 C   s:   | j \}|j \}}||krtdƒ‚|j |fkrtdƒ‚d S )Nz;incompatible array sizes for np.dot(a, b) (vector * matrix)zFincompatible output array size for np.dot(a, b, out) (vector * matrix)rÞ   )rÒ   rÓ   rÔ   r·   rÚ   r„   r!   r!   r"   Údot_3_vm_check_args¨  s   
ÿr  c                 C   s:   | j \}}|j \}||krtdƒ‚|j |fkrtdƒ‚d S )Nz;incompatible array sizes for np.dot(a, b) (matrix * vector)zFincompatible output array size for np.dot(a, b, out) (matrix * vector)rÞ   )rÒ   rÓ   rÔ   r·   rÜ   r„   r!   r!   r"   Údot_3_mv_check_args³  s   
ÿr  c                 C   s.  |j \}}}||jksJ ‚|j}t|ƒ| ||d ƒ}t|ƒ| ||d ƒ}	t|ƒ| ||d ƒ}
t ||j¡}t ||	j¡}t ||
j¡}|j|jk rd|}|}|d }|d }|jdk}|	j	|j	}}t
}n|}|}|d }|d }|jdk}|j	|	j	}}t}|  ||ttjg|j ¢R Ž |¡ |D ]}t| ||ƒ q�|  tjd¡}| d||¡}| d||¡}| ||¡}|j|dd��I\}}|� t ||
j	| |
j|
j¡d¡ W d	  ƒ n1 sÚw   Y  |� t| |||||||
j	ƒ W d	  ƒ n1 søw   Y  W d	  ƒ n	1 �sw   Y  t| ||j|
 ¡ ƒS )
zE
    np.dot(vector, matrix, out)
    np.dot(matrix, vector, out)
    r   r   rð   r¯   rr   ú==Fr‹   N)rv   r{   r0   r   r   rá   rÍ   rú   rt   r¼   r  r  r‡   r   r   rˆ   r‰   Úget_constantrR   Úicmp_signedÚor_Úif_elseÚmemsetÚmulÚitemsizeÚnitemsrº   r   Ú	_getvalue)r@   rA   rX   rv   ÚxtyÚytyÚouttyr0   ÚxÚyrÔ   rÀ   rÂ   rÄ   Zmtyr²   Zv_shaper¸   r±   r³   r´   rà   rC   ÚzeroÚ
both_emptyZmatrix_emptyÚis_emptyrÐ   Únonemptyr!   r!   r"   Údot_3_vm¾  sb   

ÿ
ÿÿÿÿ€ü
ÿr!  c           '      C   s  |j \}}}||jksJ ‚|j}t|ƒ| ||d ƒ}t|ƒ| ||d ƒ}	t|ƒ| ||d ƒ}
t ||j¡}t ||	j¡}t ||
j¡}|\}}|\}}|jdksRJ ‚dd„ }|  ||t	t
jg|j ¢R Ž |¡ t| ||ƒ t| ||ƒ t| ||ƒ |j}|	j}|
j}|  t
jd¡}| d||¡}| d||¡}| d||¡}| || ||¡¡}|j|dd	���I\}}|� t ||
j| |
j|
j¡d¡ W d
  ƒ n1 sÎw   Y  |�� |  t
jd¡}| d||¡}| d||¡}| |¡�ç\} }!| �b | |¡�L\}"}#|"� t| |d|||||ƒ W d
  ƒ n	1 �sw   Y  |#� |j|jk}$t| ||$|||||ƒ W d
  ƒ n	1 �s<w   Y  W d
  ƒ n	1 �sLw   Y  W d
  ƒ n	1 �s\w   Y  |!�e | |¡�O\}%}&|%� |j|jk}$t| ||$|||||ƒ W d
  ƒ n	1 �s‹w   Y  |&� t| ||||||||||ƒ W d
  ƒ n	1 �s¬w   Y  W d
  ƒ n	1 �s¼w   Y  W d
  ƒ n	1 �sÌw   Y  W d
  ƒ n	1 �sÜw   Y  W d
  ƒ n	1 �sìw   Y  W d
  ƒ n	1 �süw   Y  t| ||j|
 ¡ ƒS )z%
    np.dot(matrix, matrix, out)
    r   r   rð   rr   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Æ   r„   r!   r!   r"   rà     s   

ÿzdot_3_mm.<locals>.check_argsr  Fr‹   N)rv   r{   r0   r   r   rá   rÍ   rt   r‡   r   r   rˆ   r‰   r¼   r  rR   r  r  r  r  r  r  r  r¬   rº   rÉ   r   r  )'r@   rA   rX   rv   r  r  r  r0   r  r  rÔ   rÀ   rÂ   rÄ   r·   rÅ   rÆ   r„   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                    s‚   t | tjƒr;t |tjƒr=t |tjƒr?tdd„ ƒ‰ | jdvs'|jdvs'|jdvr5tjs5t d| |ff t	¡ ‡ fdd„S dS dS dS )z
    np.dot(a, b, out)
    c                 S   s:   dd„ }|j |j ks|j |j krtdƒ‚t||||ƒ|fS )Nc                 S   s    t ƒ  t| |||ƒ�<\}}tdd„ |jd d… D ƒƒ}|dhkr.t| |||ƒW  d   ƒ S |ddhkrBt| |||ƒW  d   ƒ S tdƒ‚1 sIw   Y  d S )Nc                 s   s   � | ]}|j V  qd S r=   ©rú   )Ú.0r  r!   r!   r"   Ú	<genexpr>^  s   € z8dot_3.<locals>._impl.<locals>.codegen.<locals>.<genexpr>rð   r   rô   )r9   r‚   Úsetrv   r#  r!  rõ   )r@   rA   rX   rv   rø   r!   r!   r"   r  Y  s   
üúøz%dot_3.<locals>._impl.<locals>.codegenz/np.dot() arguments must all have the same dtype)r0   r   r   )rû   rÒ   rÓ   rÔ   r  r!   r!   r"   rý   W  s   ÿzdot_3.<locals>._implrq   r	  c                    ó   ˆ | ||ƒS r=   r!   ©rÒ   rÓ   rÔ   rÿ   r!   r"   r   t  s    zdot_3.<locals>.<lambda>Nr  r)  r!   rÿ   r"   Údot_3P  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Î   ÚnditerÚisfiniteÚitemÚlinalgÚLinAlgError)rÒ   Úvr!   r!   r"   Ú_check_finite_matrixz  s   ÿÿÿr1  Tc                 C   s�   |rdnd}||f}t | tjƒr| j} t | tjƒs#d| }t|dd�‚| jdks2d| }t|dd�‚t | jtjtj	fƒsFd| }t|dd�‚d S )	Nú	np.linalgrÎ   z&%s.%s() only supported for array typesF©Úhighlightingrð   z%%s.%s() only supported on 2-D arrays.ú3%s.%s() only supported on float and complex arrays.)
rw   r   ÚOptionalÚtyperx   r   rú   r0   ÚFloatÚComplex)rÒ   r1   Ú	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.Fr3  )r0   r   )r1   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Ÿ  ó   rA  c                    s&   | j dk‰| j dk‰ ‡ ‡fdd„}|S )Nr¯   ÚAc                    sP   ˆr	t  | ¡}|S ˆ r!| jj}|rt  | j¡j}|S t  | ¡}|S t  | ¡}|S r=   )rÎ   ry   ÚflagsÚf_contiguousÚTÚasfortranarray)rÒ   ÚacpyZflag_f©ZA_layoutZF_layoutr!   r"   r†   ©  s   
ò
ü
ÿz&ol_copy_to_fortran_order.<locals>.implrs   )rÒ   r†   r!   rI  r"   Úol_copy_to_fortran_order£  s   

rJ  c                 C   s6   | dkr| dk rt ƒ  J ‚| dkrtj d¡‚d S d S )Nr   z(Matrix is singular to machine precision.)Úfatal_error_funcrÎ   r.  r/  ©Úrr!   r!   r"   Ú_inv_err_handler¿  s   ÿûrN  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   rP  c                    óP   t ƒ  t| dƒ tƒ  | j¡‰tƒ  | j¡‰tt| jdƒƒ‰ ‡ ‡‡fdd„}|S )NÚinvc                    s    | j d }| j d |krd}tj |¡‚t| ƒ t| ƒ}|dkr"|S tj|td�}ˆˆ |||j||jƒ}t	|ƒ ˆˆ ||j||jƒ}t	|ƒ t
|j|jgƒ |S )Néÿÿÿÿéþÿÿÿú.Last 2 dimensions of the array must be square.r   ©r0   )rÍ   rÎ   r.  r/  r1  rA  rÐ   ÚF_INT_nptypeÚctypesrN  rP  Úsize)rÒ   r„   r=  rH  ÚipivrM  ©r2   rb   Znumba_xxgetrir!   r"   Úinv_implÛ  s   
zinv_impl.<locals>.inv_impl)r<   r>  ra   rb   r0   re   r¡   r3   )rÒ   r\  r!   r[  r"   r\  Ï  s   
r\  c                 C   s2   | dkr| dk rt ƒ  J ‚| dkrtdƒ‚d S d S )Nr   z&Internal algorithm failed to converge.)rK  rß   rL  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s!td| ƒ‚t | jtjtjfƒs1td| ƒ‚d S )Nr2  rÎ   z'%s.%s() only supported for array types rð   ú+%s.%s() only supported on 1 and 2-D arrays r5  )rw   r   rx   r   rú   r0   r8  r9  ©rÒ   r1   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 r4tƒ  J ‚|dkr>tj d¡‚t|ƒD ]
}d|d |…|f< qB|S )NrS  rT  rU  r   z Matrix is not positive definite.)rÍ   rÎ   r.  r/  ry   rX  rK  Úrange)rÒ   r„   r=  rÔ   rM  Úcol©ZUPr2   ri   r!   r"   Úcho_impl  s&   
ÿzcho_impl.<locals>.cho_impl)r<   r>  ra   ri   r0   r¡   r3   )rÒ   ZLOrg  r!   rf  r"   rg    s   
rg  c                    sÂ   t ƒ  t| dƒ tƒ  | j¡‰tƒ  | j¡‰tt| jdƒƒ‰tdƒ‰ tdƒ‰tj	dk‰t
| jd| jƒ}t t
tdd|j › �ƒ¡‰‡ ‡‡‡‡‡fdd	„}‡ ‡‡‡fd
d„}t| jtjjƒr_|S |S )NÚeigÚNÚV©rð   é   rL   Úcomplexrð   c                    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rdˆr_tj|ˆd�}
tj||fˆd�}|
|jfS ||	jfS ˆˆˆ ˆ||j	||j	|j	|j	||	j	|ƒ}t
|ƒ ˆ�r1tj|ˆd�}
tj||fˆd�}d}||k �r|| dkrÀt|| || ƒ|
|< t|ƒD ]}t|	||f dƒ|||f< q«|d7 }nVt|| || ƒ|
|< t||d  ||d  ƒ|
|d < t|ƒD ]1}|	||f }|	|d |f }||j||f< ||j||f< ||j|d |f< | |j|d |f< qà|d7 }||k s–t|j|j|	j|j|j|
j|jgƒ |
|jfS t |¡�r;td	ƒ‚t|j|j|	j|j|jgƒ ||	jfS )
z7
        eig() implementation for real arrays.
        rS  rT  rU  r   rV  r   r®   rð   z.eig() argument must not cause a domain change.)rÍ   rÎ   r.  r/  r1  rA  rÐ   r0   rF  rX  r]  rm  rd  ÚrealÚimagrP  rY  Úanyrß   )rÒ   r„   r=  rH  ÚldvlÚldvrÚwrÚwiÚvlÚvrÚwr0  rM  ÚiÚjÚreÚim)ÚJOBVLÚJOBVRÚ_eig_always_complexÚ_eig_cmplx_dtyper2   rf   r!   r"   Úreal_eig_implS  s~   


õ

"ðÿ
ÿ
zeig_impl.<locals>.real_eig_implc           
         sØ   | j d }| j d |krd}tj |¡‚t| ƒ t| ƒ}d}|}tj|| jd�}tj||f| jd�}tj||f| jd�}|dkrE||jfS ˆˆˆ ˆ||j	||j	|j	||j	|ƒ}	t
|	ƒ t|j|j|j|jgƒ ||jfS )z:
        eig() implementation for complex arrays.
        rS  rT  rU  r   rV  r   )rÍ   rÎ   r.  r/  r1  rA  rÐ   r0   rF  rX  r]  rP  rY  ©
rÒ   r„   r=  rH  rq  rr  rw  ru  rv  rM  ©r|  r}  r2   rg   r!   r"   Úcmplx_eig_impl±  s8   

ö
z eig_impl.<locals>.cmplx_eig_impl©r<   r>  ra   rf   r0   rg   r¡   r3   Ú
np_supportÚnumpy_versionrO   Úas_dtyper   Úbitwidthrw   Úscalarsr9  )rÒ   Z_eig_real_tyr€  rƒ  r!   )r|  r}  r~  r  r2   rg   rf   r"   Úeig_impl?  s"   

ÿ^(rŠ  c                    sÂ   t ƒ  t| dƒ tƒ  | j¡‰tƒ  | j¡‰tt| jdƒƒ‰tdƒ‰ tdƒ‰tj	dk‰t
| jd| jƒ}t t
tdd|j › �ƒ¡‰‡ ‡‡‡‡‡fdd„}‡ ‡‡‡fd	d
„}t| jtjjƒr_|S |S )NÚeigvalsri  rk  rL   rm  rð   c                    sZ  | j d }| j d |krd}tj |¡‚t| ƒ t| ƒ}d}d}tj|| jd�}|dkr7ˆr5tj|ˆd�S |S tj|| jd�}tjd| jd�}tjd| jd�}	ˆˆˆ ˆ||j||j|j|j||	j|ƒ}
t	|
ƒ ˆr”tj|ˆd�}t
|ƒD ]}t|| || ƒ||< qtt|j|j|	j|j|j|jgƒ |S t |¡r�tdƒ‚t|j|j|	j|j|jgƒ |S )z;
        eigvals() implementation for real arrays.
        rS  rT  rU  r   rV  r   z2eigvals() argument must not cause a domain change.)rÍ   rÎ   r.  r/  r1  rA  rÐ   r0   rX  r]  rd  rm  rP  rY  rp  rß   )rÒ   r„   r=  rH  rq  rr  rs  rt  ru  rv  rM  rw  rx  )r|  r}  Ú_eigvals_always_complexÚ_eigvals_cmplx_dtyper2   rf   r!   r"   Úreal_eigvals_implò  sX   
õÿ
ÿ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.
        rS  rT  rU  r   rV  r   )rÍ   rÎ   r.  r/  r1  rA  rÐ   r0   rX  r]  rP  rY  r�  r‚  r!   r"   Úcmplx_eigvals_impl;  s8   
öz(eigvals_impl.<locals>.cmplx_eigvals_implr„  )rÒ   Z_eigvals_real_tyrŽ  r�  r!   )r|  r}  rŒ  r�  r2   rg   rf   r"   Úeigvals_implÞ  s"   

ÿI)r�  c                    óp   t ƒ  t| dƒ t| jd| jƒ}t |¡‰tƒ  | j¡‰tt	| jdƒƒ‰tdƒ‰ tdƒ‰‡ ‡‡‡‡fdd„}|S )NÚeighrL   rj  rc  c                    sŽ   | j d }| j d |krd}tj |¡‚t| ƒ t| ƒ}tj|ˆd�}|dkr+||fS ˆˆˆ ˆ||j||jƒ}t|ƒ t	|j
|j
gƒ ||fS ©NrS  rT  rU  rV  r   ©rÍ   rÎ   r.  r/  r1  rA  rÐ   rX  r]  rP  rY  ©rÒ   r„   r=  rH  rw  rM  ©ÚJOBZÚUPLOr2   rh   Zw_dtyper!   r"   Ú	eigh_implz  s(   
úzeigh_impl.<locals>.eigh_impl©
r<   r>  rO   r0   r…  r‡  ra   rh   r¡   r3   )rÒ   Úw_typer™  r!   r–  r"   r™  i  ó   

r™  c                    r‘  )NÚeigvalshrL   ri  rc  c                    s†   | j d }| j d |krd}tj |¡‚t| ƒ t| ƒ}tj|ˆd�}|dkr)|S ˆˆˆ ˆ||j||jƒ}t|ƒ t	|j
|j
gƒ |S r“  r”  r•  r–  r!   r"   Úeigvalsh_impl«  s(   
úz$eigvalsh_impl.<locals>.eigvalsh_implrš  )rÒ   r›  rž  r!   r–  r"   rž  š  rœ  rž  c                    sr   t ƒ  t| dƒ t| jd| jƒ}t |¡‰tƒ  | j¡‰tt	| jdƒƒ‰tdƒ‰ tdƒ‰d‡ ‡‡‡‡fdd„	}|S )	NÚsvdrL   rC  ÚSr   c                    sô   | j d }| j d }|dks|dkrtj d¡‚t| ƒ t| ƒ}|}t||ƒ}|r0ˆ }|}|}	nˆ}|}|}	tj||f| jd�}
tj|ˆd�}tj||	f| jd�}ˆˆ||||j	||j	|
j	||j	|	ƒ}t
|ƒ t|j|j|
j|jgƒ |
j||jfS )NrS  rT  r   úArrays cannot be emptyrV  )rÍ   rÎ   r.  r/  r1  rA  ÚminrÐ   r0   rX  r]  rP  rY  rF  )rÒ   Úfull_matricesr„   r·   rH  ÚlduÚminmnr—  ÚucolÚldvtÚur)   ÚvtrM  ©ZJOBZ_AZJOBZ_Sr2   rj   Ús_dtyper!   r"   Úsvd_implÜ  sD   


õzsvd_impl.<locals>.svd_impl©r   )
r<   r>  rO   r0   r…  r‡  ra   rj   r¡   r3   )rÒ   r£  Ús_typer¬  r!   rª  r"   r¬  Ë  s   

.r¬  c                    rQ  )NÚqrc                    sJ  | j d }| j d }|dks|dkrtj d¡‚t| ƒ t| ƒ}|}t||ƒ}tj|| jd�}ˆˆ |||j	||j	ƒ}|dk rCt
ƒ  J ‚tj||f| jd�j}t|ƒD ]}	t|	d ƒD ]}
||
|	f ||
|	f< qZqRt||ƒD ]}	t|ƒD ]}
||
|	f ||
|	f< qsqmˆˆ ||||j	||j	ƒ}t|ƒ t|j|jgƒ |d d …d |…f |fS )NrS  rT  r   r¡  rV  r   )rÍ   rÎ   r.  r/  r1  rA  r¢  rÐ   r0   rX  rK  rÏ   rF  rd  r]  rP  rY  )rÒ   r„   r·   Úqr¸   r¥  ÚtauÚretrM  rx  ry  ©r2   rl   rm   r!   r"   Úqr_impl  sR   


úÿÿù	zqr_impl.<locals>.qr_impl)r<   r>  ra   rl   r0   rm   r¡   r3   )rÒ   r´  r!   r³  r"   r´    s   
9r´  c                 C   ó   t ‚)z;
    Correctly copy 'b' into the 'bcpy' scratch space.
    ©ÚNotImplementedError©ÚbcpyrÓ   Únrhsr!   r!   r"   Ú_system_copy_in_b^  ó   r»  c                 C   s"   |j dkrdd„ }|S dd„ }|S )Nr   c                 S   s   || d |j d …df< d S )NrS  r   ©rÍ   r¸  r!   r!   r"   Ú	oneD_implh  s   z)_system_copy_in_b_impl.<locals>.oneD_implc                 S   s   || d |j d …d |…f< d S )NrT  r½  r¸  r!   r!   r"   Ú	twoD_impll  s   z)_system_copy_in_b_impl.<locals>.twoD_implr$  )r¹  rÓ   rº  r¾  r¿  r!   r!   r"   Ú_system_copy_in_b_imple  ó
   
rÀ  c                 C   rµ  )zK
    Compute the number of right hand sides in the system of equations
    r¶  ©rÓ   r!   r!   r"   Ú_system_compute_nrhsq  r¼  rÃ  c                 C   s"   | j dkrdd„ }|S dd„ }|S )Nr   c                 S   s   dS ©Nr   r!   rÂ  r!   r!   r"   r¾  {  rB  z,_system_compute_nrhs_impl.<locals>.oneD_implc                 S   s
   | j d S )NrS  r½  rÂ  r!   r!   r"   r¿    rK   z,_system_compute_nrhs_impl.<locals>.twoD_implr$  )rÓ   r¾  r¿  r!   r!   r"   Ú_system_compute_nrhs_implx  rÁ  rÅ  c                 C   rµ  )zD
    Check that AX=B style system input is dimensionally valid.
    r¶  rë   r!   r!   r"   Ú!_system_check_dimensionally_valid„  r¼  rÆ  c                 C   ó&   |j }|dkrdd„ }|S dd„ }|S )Nr   c                 S   s,   | j d }|j d }||krtj d¡‚d S )NrT  rS  ú<Incompatible array sizes, system is not dimensionally valid.©rÍ   rÎ   r.  r/  ©rÒ   rÓ   ÚamÚbmr!   r!   r"   r¾  �  ó   

ÿÿz9_system_check_dimensionally_valid_impl.<locals>.oneD_implc                 S   s,   | j d }|j d }||krtj d¡‚d S )NrT  rÈ  rÉ  rÊ  r!   r!   r"   r¿  —  rÍ  z9_system_check_dimensionally_valid_impl.<locals>.twoD_implr$  ©rÒ   rÓ   rú   r¾  r¿  r!   r!   r"   Ú&_system_check_dimensionally_valid_impl‹  s   rÏ  c                 C   rµ  )z:
    Check that AX=B style system input is not empty.
    r¶  rë   r!   r!   r"   Ú_system_check_non_empty   r¼  rÐ  c                 C   rÇ  )Nr   c                 S   sF   | j d }| j d }|j d }|dks|dks|dkr!tj d¡‚d S ©NrT  rS  r   r¡  rÉ  )rÒ   rÓ   rË  ÚanrÌ  r!   r!   r"   r¾  «  s   


ÿz/_system_check_non_empty_impl.<locals>.oneD_implc                 S   sX   | j d }| j d }|j d }|j d }|dks$|dks$|dks$|dkr*tj d¡‚d S rÑ  rÉ  )rÒ   rÓ   rË  rÒ  rÌ  Úbnr!   r!   r"   r¿  ³  s   



 ÿz/_system_check_non_empty_impl.<locals>.twoD_implr$  rÎ  r!   r!   r"   Ú_system_check_non_empty_impl§  s   rÔ  c                 C   rµ  )z:
    Compute the residual from the 'b' scratch space.
    r¶  )rÓ   r„   rº  r!   r!   r"   Ú_lstsq_residual½  r¼  rÕ  c                    sŠ   | j }| j}t t|d|ƒ¡‰ |dkr)t|tjƒr!‡ fdd„}|S ‡ fdd„}|S |dks/J ‚t|tjƒr=‡ fdd„}|S ‡ fd	d„}|S )
NrL   r   c                    s6   t jdˆ d�}t  t  | |d …df ¡d ¡|d< |S ©Nr­  rV  r   rð   )rÎ   rÐ   ÚsumÚabs©rÓ   r„   rº  r”   ©Ú
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 rÖ  )rÎ   rÐ   r×  rÙ  rÚ  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 ©NrV  rð   )rÎ   rÐ   rd  r×  rØ  ©rÓ   r„   rº  r”   rÅ   rÚ  r!   r"   rÜ  Ú  s   &c                    s>   t j|ˆ d�}t|ƒD ]}t  | |d …|f d ¡||< q|S rÞ  )rÎ   rÐ   rd  r×  rß  rÚ  r!   r"   rÝ  á  s    )rú   r0   r…  r‡  rO   rw   r   r9  )rÓ   r„   rº  rú   r0   rÜ  rÝ  r!   rÚ  r"   Ú_lstsq_residual_implÄ  s   rà  c                 C   rµ  )zŠ
    Extract 'x' (the lstsq solution) from the 'bcpy' scratch space.
    Note 'b' is only used to check the system input dimension...
    r¶  ©rÓ   r¹  r„   r!   r!   r"   Ú_lstsq_solutioné  ó   râ  c                 C   s"   | j dkrdd„ }|S dd„ }|S )Nr   c                 S   s   |j  ¡ d |… S r=   ©rF  Úravelrá  r!   r!   r"   r¾  ô  s   z'_lstsq_solution_impl.<locals>.oneD_implc                 S   s   |d |…d d …f   ¡ S r=   ©ry   rá  r!   r!   r"   r¿  ø  s   z'_lstsq_solution_impl.<locals>.twoD_implr$  )rÓ   r¹  r„   r¾  r¿  r!   r!   r"   Ú_lstsq_solution_implñ  rÁ  rç  ç      ð¿c                    s‚   t ƒ  t| dƒ t|dƒ td| |ƒ t | j¡‰| j}t|d|ƒ}t |¡‰tƒ  	| j¡‰t
t|dƒƒ‰ d‡ ‡‡‡fdd„	}|S )NÚlstsqrL   rè  c                    s0  | 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d�}ˆˆ ||||j||	j||
j||jƒ}t|ƒ |d }||k sn||krvtj	dˆd�}nt|	||ƒ}t||	|ƒ}t|j|	j|
j|jgƒ ||||
d |… fS )NrS  rT  rV  r   r   )rÍ   rÃ  r1  rÐ  rÆ  r¢  ÚmaxrA  rÎ   rÐ   rF  r»  rW  rX  r]  rÕ  râ  rP  rY  )rÒ   rÓ   Úrcondr„   r·   rº  r¥  ZmaxmnrH  r¹  r)   Zrank_ptrrM  Úrankr”   r  ©r2   Únp_dtrn   rÛ  r!   r"   Ú
lstsq_impl  sF   





õzlstsq_impl.<locals>.lstsq_impl©rè  )r<   r>  r`  r@  r…  r‡  r0   rO   ra   rn   r¡   r3   )rÒ   rÓ   rë  Únb_dtZr_typerï  r!   rí  r"   rï  ý  s   


?rï  c                 C   rµ  )z„
    Extract 'x' (the solution) from the 'bcpy' scratch space.
    Note 'b' is only used to check the system input dimension...
    r¶  ©rÓ   r¹  r!   r!   r"   Ú_solve_compute_return\  rã  ró  c                 C   s"   | j dkrdd„ }|S dd„ }|S )Nr   c                 S   s
   |j  ¡ S r=   rä  rò  r!   r!   r"   r¾  g  rK   z-_solve_compute_return_impl.<locals>.oneD_implc                 S   s   |S r=   r!   rò  r!   r!   r"   r¿  k  rB  z-_solve_compute_return_impl.<locals>.twoD_implr$  )rÓ   r¹  r¾  r¿  r!   r!   r"   Ú_solve_compute_return_impld  rÁ  rô  c                    sh   t ƒ  t| dƒ t|dƒ td| |ƒ t | j¡‰| j}tƒ  | j¡‰t	t
|dƒƒ‰ ‡ ‡‡fdd„}|S )NÚsolvec              	      s¶   | j d }t|ƒ}t| ƒ t|ƒ t| |ƒ t| ƒ}tj||fˆd�j}|dkr-t||ƒS t	|||ƒ tj|t
d�}ˆˆ |||j||j|j|ƒ}t|ƒ t|j|j|jgƒ t||ƒS )NrS  rV  r   )rÍ   rÃ  r1  rÆ  rA  rÎ   rÐ   rF  ró  r»  rW  rX  rN  rP  rY  )rÒ   rÓ   r„   rº  rH  r¹  rZ  rM  ©r2   rî  rp   r!   r"   Ú
solve_impl�  s0   


ø

zsolve_impl.<locals>.solve_impl)r<   r>  r`  r@  r…  r‡  r0   ra   rp   r¡   r3   )rÒ   rÓ   rñ  r÷  r!   rö  r"   r÷  p  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ÚpinvrL   r   rr   r®   rV  r­   rø  c                    sØ  | j d }| j d }t| ƒ t| ƒ}|dks|dkr$|j ¡  | j ¡jS t||ƒ}tj||f| j	d�}tj|ˆd�}tj||f| j	d�}ˆˆˆ |||j
||j
|j
||j
|ƒ}	t|	ƒ |d | }
d}t|ƒD ]}|| |
krxd||  ||< |}qf|d7 }||kržt|ƒD ]}t|ƒD ]}|||f ||  |||f< q‹q…nt|ƒD ]}|| }t|ƒD ]}|||f | |||f< q¬q¢ˆˆˆˆ|||ˆj
|j
||j
|ˆj
|j
|ƒ}	t|j|j|j|jˆjˆjgƒ |j ¡  | j ¡jS )NrS  rT  r   rV  r­   r   )rÍ   r1  rA  rF  rå  Úreshaper¢  rÎ   rÐ   r0   rX  r]  rd  rP  rY  )rÒ   rë  r„   r·   rH  r¥  r¨  r)   r©  rM  Zcut_atZcut_idxrÅ   rx  ry  Zs_local©	ZJOBZTRANSAZTRANSBr2   rj   rY   r"  r«  r  r!   r"   Ú	pinv_implÇ  s~   
'

õ€ÿÿÿ
òÿzpinv_impl.<locals>.pinv_impl©rø  )r<   r>  rO   r0   r…  r‡  ra   rj   rF   rY   r¡   r3   rÎ   Úarray)rÒ   rë  r®  Údtrü  r!   rû  r"   rü  ­  s    

 rü  c                 C   s.   t | jtjƒrtdd„ ƒ}|S tdd„ ƒ}|S )zù
    Walks the diag of a LUP decomposed matrix
    uses that det(A) = prod(diag(lup(A)))
    and also that log(a)+log(b) = log(a*b)
    The return sign is adjusted based on the values found
    such that the log(value) stays in the real domain.
    c                 S   sV   |d }d}t | ƒD ]}t |||f ¡}||||f |  }|t |¡ }q
||fS )Ny                r®   )rd  rÎ   rØ  Úlog)r„   rÒ   ÚsgnZcsgnÚaccrÅ   Zabselr!   r!   r"   Úcmplx_diag_walkerZ  s   z3_get_slogdet_diag_walker.<locals>.cmplx_diag_walkerc                 S   sL   d}t | ƒD ]}|||f }|dk r| }| }|t |¡ }q|d |fS )Nr®   )rd  rÎ   r   )r„   rÒ   r  r  rÅ   r0  r!   r!   r"   Úreal_diag_walkerf  s   z2_get_slogdet_diag_walker.<locals>.real_diag_walker)rw   r0   r   r9  r
   )rÒ   r  r  r!   r!   r"   Ú_get_slogdet_diag_walkerQ  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   rL   r   c                    sÚ   | j d }| j d |krd}tj |¡‚|dkrˆ ˆfS t| ƒ t| ƒ}tj|td�}ˆˆ|||j||jƒ}|dkr@dtj	 fS t
|ƒ d}t|ƒD ]}||| |d k }qJ|d@ }|dkrad}t|jgƒ ˆ|||ƒS )NrS  rT  rU  r   rV  r®   r   )rÍ   rÎ   r.  r/  r1  rA  rÐ   rW  rX  ÚinfrN  rd  rP  rY  )rÒ   r„   r=  rH  rZ  rM  r  rÅ   ©ÚONEÚZEROZdiag_walkerr2   rb   r!   r"   Úslogdet_impl„  s*   
	z"slogdet_impl.<locals>.slogdet_impl)	r<   r>  ra   rb   r0   r¡   r3   r  rO   )rÒ   r  r!   r  r"   r  u  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   rµ  )z)
    Compute singular values of *a*.
    r¶  rO  r!   r!   r"   Ú_compute_singular_values¾  r¼  r  c                    s‚   t ƒ  | j¡‰tt| jdƒƒ‰tdƒ‰ t| jd| jƒ}t |¡‰t | j¡}tj	d|d�‰tj	d|d�‰‡ ‡‡‡‡‡fdd„}|S )z>
    Returns a function to compute singular values of `a`
    rŸ  ri  rL   ró   rV  c           
         s¬   | j d }| j d }|dks|dkrtj d¡‚t| ƒ |}t||ƒ}d}d}t| ƒ}tj|ˆd�}ˆˆˆ |||j||jˆj|ˆj|ƒ}	t	|	ƒ t
|jˆjˆj|jgƒ |S )z+
        Computes singular values.
        rS  rT  r   r¡  r   rV  )rÍ   rÎ   r.  r/  r1  r¢  rA  rÐ   rX  r]  rP  rY  )
rÒ   r„   r·   r¤  r¥  r¦  r§  rH  r)   rM  ©ZJOBZ_Nr2   Únp_ret_typerj   r¨  r©  r!   r"   Úsv_functionÚ  s6   


õz2_compute_singular_values_impl.<locals>.sv_function)
ra   rj   r0   r¡   r3   rO   r…  r‡  rÎ   rÐ   )rÒ   Únb_ret_typeÚnp_dtyper  r!   r  r"   Ú_compute_singular_values_implÅ  s   
/r  c                 C   rµ  )z.
    Compute the L2-norm of 1D-array *a*.
    r¶  rO  r!   r!   r"   Ú_oneD_norm_2	  r¼  r  c                    sL   t | jd| jƒ}t |¡‰tƒ  | j¡‰tt| jdƒƒ‰ ‡ ‡‡fdd„}|S )NrL   Únormc                    sh   t | ƒ}tjdˆd�}t| jd | j ƒ}ˆˆ || j||jƒ}|dk r(tƒ  J ‚t|j	| j	gƒ |d S )Nr­  rV  r   )
ÚlenrÎ   rÐ   r¢   Ústridesr  rX  rK  rP  rY  )rÒ   r„   r²  ÚjmprM  ©r2   r  Úxxnrm2r!   r"   r†   	  s   ûz_oneD_norm_2_impl.<locals>.impl)rO   r0   r…  r‡  rF   rM   r¡   r3   )rÒ   r  r†   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r<|d t	j
fv r5ddd„}|S ddd„}|S | jdkr|d t	j
fv ro| jdkrTtd	d
„ ƒ‰ n| jdkr`tdd
„ ƒ‰ ntdd
„ ƒ‰ d‡ fdd„	}|S t |j¡j‰d‡fdd„	}|S J ‚)NrL   r  r   c                 S   s   t | ƒS r=   )r  ©r  r¡   r!   r!   r"   r¾  T	  s   z!_get_norm_impl.<locals>.oneD_implc                 S   s<  t | ƒ}|dkr
dS |dkrt| ƒS |tjkr3t| d ƒ}td|ƒD ]}t| | ƒ}||kr0|}q"|S |tj krUt| d ƒ}td|ƒD ]}t| | ƒ}||k rR|}qD|S |dkrnd}t|ƒD ]}| | dkrk|d7 }q_|S |dkr…d}t|ƒD ]
}|t| | ƒ7 }qx|S d}t|ƒD ]}|t| | ƒ| 7 }q‹|d|  S )Nr   r®   rð   r   r­   )r  r  rÎ   r  rØ  rd  )r  r¡   r„   r²  rÅ   rC   r!   r!   r"   r¾  W	  sJ   
€€€rð   rr   c                 S   s   | S r=   r!   ©r  r!   r!   r"   Úarray_prepareš	  ó   z%_get_norm_impl.<locals>.array_preparer¯   c                 S   s   | j S r=   )rF  r   r!   r!   r"   r!  ž	  s   c                 S   s   |   ¡ S r=   ræ  r   r!   r!   r"   r!  £	  ó   c                    s(   | j }|dkr	dS ˆ | ƒ}t| |¡ƒS )Nr   r®   )rY  r  rú  )r  r¡   r„   Úx_c)r!  r!   r"   r¿  ©	  s
   z!_get_norm_impl.<locals>.twoD_implc           	         s˜  | j d }| j d }| jdkrdS |tjkr:d}t|ƒD ]}d}t|ƒD ]}|t| ||f ƒ7 }q$||kr7|}q|S |tj krdˆ }t|ƒD ]}d}t|ƒD ]}|t| ||f ƒ7 }qN||k ra|}qF|S |dkrŒd}t|ƒD ]}d}t|ƒD ]}|t| ||f ƒ7 }qv||kr‰|}qn|S |dkr´ˆ }t|ƒD ]}d}t|ƒD ]}|t| ||f ƒ7 }qž||k r±|}q–|S |dkr¾t| ƒd S |dkrÈt| ƒd S tdƒ‚)NrS  rT  r   r®   r   rð   z Invalid norm order for matrices.)rÍ   rY  rÎ   r  rd  rØ  r  rß   )	r  r¡   r„   r·   Z
global_maxÚiiÚtmpÚjjZ
global_min)Úmax_valr!   r"   r¿  ´	  sb   



€€€€r   r=   )rO   r0   r…  r‡  rF   rM   r¡   r3   rú   r   rˆ   rt   r
   rÎ   Úfinfor7  rê  )	r  Zord_flagr  r  r  r  r2   r¾  r¿  r!   )r!  r(  r"   Ú_get_norm_impl7	  s6   


<
Ç9



P¹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 u r.t | ƒ}|dks|d u r#t |d |d ¡}n!t |d |d ¡}ntj | |¡}tj tj | ¡|¡}|| }t |¡rLtjS |S )Nrð   rT  r   rS  )r  rÎ   Údivider.  r  rR  Úisnanr  )r  Úpr)   rM  Únorm_xZ
norm_inv_xr!   r!   r"   r†   
  s   
zcond_impl.<locals>.implr=   r  )r  r/  r†   r!   r!   r"   Ú	cond_impl
  s   

$r1  c                 C   s4   d}t t| ƒƒD ]}| | |kr|d }q |S |S )zJ
    Gets rank from singular values with cut-off at a given tolerance
    r   r   ©rd  r  )Úsvr°   rì  rÅ   r!   r!   r"   Ú_get_rank_from_singular_values4
  s   
r4  c                    s.   t ƒ  t| dƒ dd„ ‰ ‡ fdd„}|| |ƒS )ah  
    Computes rank for matrices and vectors.
    The only issue that may arise is that because numpy uses double
    precision lapack calls whereas numba uses type specific lapack
    calls, some singular values may differ and therefore counting the
    number of them above a tolerance may lead to different counts,
    and therefore rank, in some cases.
    Úmatrix_rankc                    sT   |d t jfv r#t| jd| jƒ}t |¡}t |¡j‰ d‡ fdd„	}|S ddd„}|S )NrL   c                    s@   t | ƒ}| jd }| jd }t||ƒ}|d | ˆ  }t||ƒS )Nr   r   )r  rÍ   rê  r4  )rC  Útolr)   rM  r+   Úlr°   ©Zeps_valr!   r"   Ú_2d_tol_none_implX
  s   



zImatrix_rank_impl.<locals>._2d_matrix_rank_impl.<locals>._2d_tol_none_implc                 S   s   t | ƒ}t||ƒS r=   )r  r4  )rC  r6  r)   r!   r!   r"   Ú_2d_tol_not_none_implb
  s   
zMmatrix_rank_impl.<locals>._2d_matrix_rank_impl.<locals>._2d_tol_not_none_implr=   )	r   rˆ   rO   r0   r…  r‡  rÎ   r)  Úeps)rC  r6  Únb_typeÚnp_typer9  r:  r!   r8  r"   Ú_2d_matrix_rank_implP
  s   

z.matrix_rank_impl.<locals>._2d_matrix_rank_implc                    s2   | j }|dkrddd„}|S |dkrˆ | |ƒS J ‚)Nr   c                 S   s(   t t| ƒƒD ]}| | dkr dS qdS )Nr®   r   r   r2  )rC  r6  rÅ   r!   r!   r"   Ú_1d_matrix_rank_implv
  s
   ÿzMmatrix_rank_impl.<locals>._get_matrix_rank_impl.<locals>._1d_matrix_rank_implrð   r   r=   r$  )rC  r6  rú   r?  ©r>  r!   r"   Ú_get_matrix_rank_implg
  s   

z/matrix_rank_impl.<locals>._get_matrix_rank_impl)r<   r`  )rC  r6  rA  r!   r@  r"   Úmatrix_rank_implB
  s
   


rB  c                    sF   t | dƒ t | j¡‰ t|d|ƒ}t|tjƒstdƒ‚‡ fdd„}|S )zL
    Computes matrix power. Only integer powers are supported in numpy.
    Úmatrix_powerr0   zExponent must be an integer.c           
         sH  |dkrt j| jˆ d�}t| jd ƒD ]}d|||f< q|S | jd | jd }}||kr1tdƒ‚|dkr9|  ¡ S |dk rOt j | ¡ ¡ }|dkrK|S | }n
|dkrW|  ¡ S | }|dk rw|d	krgt  ||¡S |d
krut  t  ||¡|¡S d S |}|}|}d}	|dkr¢|d@ r”|	rŽ|}d}	nt  ||¡}t  ||¡}|d? }|dksƒ|S )Nr   rV  r­   rS  rT  zinput must be a square arrayr   é   rð   é   TF)	rÎ   rÏ   rÍ   rd  rß   ry   r.  rR  rÑ   )
rÒ   r„   rC  rÅ   rË  rÒ  r  r  r²  Úflag©r  r!   r"   Úmatrix_power_impl‘
  sL   ÿø
z,matrix_power_impl.<locals>.matrix_power_impl)	r>  r…  r‡  r0   rO   rw   r   ÚIntegerr   )rÒ   r„   ÚntrH  r!   rG  r"   rH  „
  s   
?rH  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r8t|ƒD ]}|| ||| f 7 }q)|S t|ƒD ]}|| || |f 7 }q<|S rË   )rÍ   rê  r¢  rd  )rÒ   ÚoffsetÚrowsÚcolsrÅ   r„   r²  rx  r!   r!   r"   Úmatrix_trace_implà
  s   
þz,matrix_trace_impl.<locals>.matrix_trace_implN©r   )r>  rw   r¢   r   rI  r   )rÒ   rM  rP  r!   r!   r"   rP  Õ
  s
   
rP  c                 C   sB   |rdnd}||f}t | tjƒr| jdkstd| dd�‚d S d S )Nr2  rÎ   rð   r^  Fr3  )rw   r   rx   rú   r   r_  r!   r!   r"   Ú_check_scalar_or_lt_2d_matô
  s   
ÿÿþrR  c                 C   s@   t  | ¡}t  |¡}t  | ¡  |jdf¡| ¡  d|jf¡¡S rÄ  ©rÎ   ÚasarrayÚmultiplyrå  rú  rY  ©rÒ   rÓ   rÔ   ÚaaÚbbr!   r!   r"   Úouter_impl_noneþ
  s
   

ÿrY  c                 C   sF   t  | ¡}t  |¡}t  | ¡  |jdf¡| ¡  d|jf¡|¡ |S rÄ  rS  rV  r!   r!   r"   Úouter_impl_arr  s   

þrZ  c                 C   s   |d t jfv r	tS tS r=   )r   rˆ   rY  rZ  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ÚouterFrL  c                    r(  r=   r!   r)  ©r†   r!   r"   Ú
outer_impl  s   zouter_impl.<locals>.outer_implr=   )rR  r[  )rÒ   rÓ   rÔ   r^  r!   r]  r"   r^    s
   r^  c                 C   s`   t | tjƒr(| jdvrtd | j¡ƒ‚| jdkr tdd„ ƒ}|S tdd„ ƒ}|S tdd„ ƒ}|S )N)rr   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 )NrS  rT  ©rÍ   rú  )r  ÚxnÚxmr!   r!   r"   Ú	nrm_shape-  s   

z(_kron_normaliser_impl.<locals>.nrm_shapec                 S   s   | j d }|  d|¡S )NrS  r   r_  )r  r`  r!   r!   r"   rb  4  s   
c                 S   s   t  dt| ƒ¡}| |d< |S )Nró   r   )rÎ   rÐ   r7  )r  rÒ   r!   r!   r"   rb  :  s   )rw   r   rx   rt   r   Úformatrú   r
   )r  rb  r!   r!   r"   Ú_kron_normaliser_impl%  s   
þ



rd  c                 C   sŒ   t | tjƒ}t |tjƒ}|r*|r*| jdks|jdkr"tdd„ ƒ}|S tdd„ ƒ}|S |r4tdd„ ƒ}|S |r>tdd„ ƒ}|S tdd„ ƒ}|S )Nrð   c                 S   s   |S r=   r!   ©rÒ   rÓ   r+   r!   r!   r"   r²  I  r"  z_kron_return.<locals>.retc                 S   s   |  |j¡S r=   )rú  rY  re  r!   r!   r"   r²  N  ó   c                 S   s   |  | j¡S r=   ©rú  rÍ   re  r!   r!   r"   r²  T  rf  c                 S   s   |  |j¡S r=   rg  re  r!   r!   r"   r²  Y  rf  c                 S   s   |d S rË   r!   re  r!   r!   r"   r²  ^  r#  )rw   r   rx   rú   r
   )rÒ   rÓ   Za_is_arrZb_is_arrr²  r!   r!   r"   Ú_kron_returnB  s*   




rh  c                    sX   t | ddd� t |ddd� t| ƒ‰t|ƒ‰t| |ƒ‰t| d| ƒ‰ ‡ ‡‡‡fdd„}|S )NÚkronFrL  r0   c              	      sØ   ˆ| ƒ}ˆ|ƒ}|j d }|j d }|j d }|j d }|| }|| }	tj||	fˆ d�}
t|ƒD ]4}|| }t|ƒD ])}|| }||d d …f }t|ƒD ]}|| }|||f | |
|||| …f< qMq;q1ˆ| ||
ƒS )NrT  rS  rV  )rÍ   rÎ   rÐ   rd  )rÒ   rÓ   rW  rX  rË  rÒ  rÌ  rÓ  ÚcmÚcnrr   rx  ZrjmprÅ   ZirjmpÚslcry  Zcjmp©rÿ  Zfix_aZfix_bZret_cr!   r"   Ú	kron_implr  s(   



"ûúzkron_impl.<locals>.kron_impl)rR  rd  rh  rO   )rÒ   rÓ   rn  r!   rm  r"   rn  d  s   
(rn  )r-   )F)Tr­  rð  rý  r=   rQ  )ªr_   Ú
contextlibr  Úllvmliter   ÚnumpyrÎ   ÚoperatorÚnumba.core.imputilsr   r   r   r   Únumba.core.typingr   Únumba.core.extendingr   r	   r
   Ú
numba.corer   r   r   Únumba.core.errorsr   r   r   Úarrayobjr   r   r   Únumba.npr   r…  Únumbar   rš   r›   Ú
as_pointerZ	ll_char_pr�   Úll_intcZ	ll_intc_prœ   Z	ll_intp_pr#   r   rO   r%   Z_LAPACK_ILP64r'   r(   Úint64Úint32rW  rd   Úfloat32ro   Ú	complex64Ú
complex128r.   r3   r9   r<   rE   rF   ra   Úcontextmanagerr‚   r‰   r–   r˜   r¬   rº   rÉ   rØ   rÛ   rÝ   rç   rÑ   rì   Úmatmulrî   rê   r  r  r  r!  r#  r*  rT   rP   rK  r1  r>  r@  rA  rJ  rN  rP  r.  rR  r\  r]  r`  ra  rg  rh  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,  r1  r4  r5  rB  rC  rH  rK  rP  rR  rY  rZ  r[  r\  r^  rd  rh  ri  rn  r!   r!   r!   r"   Ú<module>   sH   

ÿü
) $
%2


.
 9Y
&



	


'

	


+
 

 


0

0
A
P




$

^



< $
$

:

F
# 
H
,


A
P


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