U
    í¾|ed<  ã                   @   sØ  d Z ddlZddlZddlZddlZddlZddlmZ ddl	m
Z
mZ ddlmZ ddlmZmZmZmZ ddlmZ ddlmZ dd	lmZ e
d
ƒZejZe e d¡¡ZejZej Z!e e d¡¡Z"e"jZ#e"j Z$dZ%dZ&dZ'dZ(dd„ Z)dd„ Z*dd„ Z+dd„ Z,dd„ Z-dd„ Z.dd„ Z/dd „ Z0d!d"„ Z1d#d$„ Z2d%d&„ Z3d'd(„ Z4d‡d*d+„Z5e4ej6d,ƒ e4ej7d-ƒZ8e4ej9d.ƒZ:e4ej;d/ƒZ<e4ej=d0ƒZ>e4ej?d1ƒZ@e5ejAd2d3ƒZBe5ejCd4d5ƒZDe5ejEd6d7ƒZFe5ejGd8d9ƒZHe5ejId:d;ƒZJe5ejKd<d=ƒZLe5ejMd>d?ƒZNe5ejOd@dAƒZPe5ejQdBdCƒZRe5ejSdDdEƒZTe5ejUdFdGƒZVe5ejWdHdIƒZXe5ejYdJdKƒZZe5ej[dLdMƒZ\e5ej]dNdOƒZ^e5ej_dPdQdRƒZ`e5ejadSdTdRƒZbe5ejcdUdVƒZde5ejedWdXƒZfe5ejgdYdZdRƒZhe5ejid[d\ƒZjeejkejlƒd]d^„ ƒZmeejkejnƒd_d`„ ƒZoeejpejlƒdadb„ ƒZqeejpejnƒdcdd„ ƒZreejsejlƒdedf„ ƒZteejsejnƒdgdh„ ƒZueejvejlejlƒdidj„ ƒZweejxejlƒdkdl„ ƒZyeejzejlej{ƒdmdn„ ƒZ|eej}ej~ej~ƒdodp„ ƒZeej}ej€ej€ƒdqdr„ ƒZ�eej}ejlejlƒdsdt„ ƒZ‚eejƒej~ej~ƒdudv„ ƒZ„eejƒej€ej€ƒdwdx„ ƒZ…eejƒejlejlƒdydz„ ƒZ†eej‡ejlƒd{d|„ ƒZˆe3ej‡eˆƒ eej‰ejlƒd}d~„ ƒZŠe3ej‰eŠƒ eej‹ejlejlƒeej‹ejlejnƒdd€„ ƒƒZŒd�d‚„ Z�ee�ƒdƒd„„ ƒZŽd…d†„ Z�eej�ejnejnƒe�ƒ dS )ˆzA
Provide math calls that uses intrinsics or libc math functions.
é    N)ÚConstant)ÚRegistryÚimpl_ret_untracked)Útypeof)ÚtypesÚutilsÚconfigÚcgutils)Úoverload)Ú	signature)Útrailing_zerosÚmathimplÚfloat32Úfloat64iÿÿÿl        l   ÿÿÿÿ l            c                 C   s   |   d||¡S )z<
    Return a condition testing whether *val* is a NaN.
    Úuno)Úfcmp_unordered©ÚbuilderÚval© r   úS/var/www/website-v5/atlas_env/lib/python3.8/site-packages/numba/cpython/mathimpl.pyÚis_nan(   s    r   c                 C   sH   t |jtdƒƒ}t |jtdƒƒ}|  d||¡}|  d||¡}|  ||¡S )zB
    Return a condition testing whether *val* is an infinite.
    z+infz-infz==)r   ÚtypeÚfloatÚfcmp_orderedÚor_)r   r   Zpos_infZneg_infÚisposinfÚisneginfr   r   r   Úis_inf.   s
    r   c                 C   s   |   ||¡}|  d||¡S )z?
    Return a condition testing whether *val* is a finite.
    Úord)Úfsubr   )r   r   Zval_minus_valr   r   r   Ú	is_finite8   s    r!   c                 C   s(   |j tj ¡ kst‚|  |tj d¡¡S )z1
    Bitcast a double into a 64-bit integer.
    é@   )r   ÚllvmliteÚirÚ
DoubleTypeÚAssertionErrorÚbitcastÚIntTyper   r   r   r   Úf64_as_int64@   s    r)   c                 C   s(   |j tj d¡kst‚|  |tj ¡ ¡S )z1
    Bitcast a 64-bit integer into a double.
    r"   )r   r#   r$   r(   r&   r'   r%   r   r   r   r   Úint64_as_f64G   s    r*   c                 C   s(   |j tj ¡ kst‚|  |tj d¡¡S )z0
    Bitcast a float into a 32-bit integer.
    é    )r   r#   r$   Ú	FloatTyper&   r'   r(   r   r   r   r   Úf32_as_int32N   s    r-   c                 C   s(   |j tj d¡kst‚|  |tj ¡ ¡S )z0
    Bitcast a 32-bit integer into a float.
    r+   )r   r#   r$   r(   r&   r'   r,   r   r   r   r   Úint32_as_f32U   s    r.   c                 C   s   |   t|jdƒ|¡S )zB
    Negate real number *val*, with proper handling of zeros.
    g       €)r    r   r   r   r   r   r   Únegate_real\   s    r/   c                 C   s(   | j }| |dd„ |D ƒ¡}|  ||¡S )z9
    Call a LLVM intrinsic floating-point operation.
    c                 S   s   g | ]
}|j ‘qS r   )r   )Ú.0Úar   r   r   Ú
<listcomp>h   s     z%call_fp_intrinsic.<locals>.<listcomp>)ÚmoduleÚdeclare_intrinsicÚcall)r   ÚnameÚargsÚmodZintrr   r   r   Úcall_fp_intrinsicc   s    r9   c                    s   ‡ fdd„}|S )zŒ
    Return an implementation factory to convert the single integral input
    argument to a float64, then defer to the *wrapped_impl*.
    c           	         sT   |\}|j d }|  |||tj¡}ttjtjƒ}ˆ | |||fƒ}|  ||tj|j¡S )Nr   )r7   Úcastr   r   r   Úreturn_type)	Úcontextr   Úsigr7   r   Ú
input_typeZfpvalÚ	inner_sigÚres©Úwrapped_implr   r   Úimplementerq   s    
z2_unary_int_input_wrapper_impl.<locals>.implementerr   )rB   rC   r   rA   r   Ú_unary_int_input_wrapper_impll   s    rD   c                 C   s   t |ƒ}t| tjƒ|ƒ d S ©N)rD   Úlowerr   ÚInteger)ÚfnÚ
float_implÚimplr   r   r   Úunary_math_int_impl{   s    rK   c                    s&   t | tjƒ‡ fdd„ƒ}t| |ƒ |S )zO
    Implement the math function *fn* using the LLVM intrinsic *intrcode*.
    c                    s   t |ˆ |ƒ}t| ||j|ƒS rE   )r9   r   r;   ©r<   r   r=   r7   r@   ©Úintrcoder   r   rI   ƒ   s    z#unary_math_intr.<locals>.float_impl)rF   r   ÚFloatrK   )rH   rN   rI   r   rM   r   Úunary_math_intr   s    

rP   Fc                    s:   |r
t jnd}‡ ‡fdd„}t| t jƒ|ƒ t| |ƒ |S )a!  
    Register implementations of Python function *fn* using the
    external function named *f32extern* and *f64extern* (for float32
    and float64 inputs, respectively).
    If *int_restype* is true, then the function's return value should be
    integral, otherwise floating-point.
    Nc                    s†   |\}|j }|jd }|  |¡}tjˆ tjˆi| }tj ||g¡}	t	j
|j |	|d�}
| |
|f¡}|  ||||j¡}t| ||j|ƒS )z9
        Implement *fn* for a types.Float input.
        r   ©r6   )r3   r7   Úget_value_typer   r   r   r#   r$   ÚFunctionTyper	   Úinsert_pure_functionr5   r:   r;   r   )r<   r   r=   r7   r   r8   r>   ÚltyÚ	func_nameÚfntyrH   r@   ©Ú	f32externÚ	f64externr   r   rI   •   s     

  þýz%unary_math_extern.<locals>.float_impl)r   Úint64rF   rO   rK   )rH   rY   rZ   Zint_restypeZ	f_restyperI   r   rX   r   Úunary_math_extern‹   s
    
r\   z	llvm.fabszllvm.expzllvm.logz
llvm.log10zllvm.sinzllvm.cosÚlog1pfÚlog1pÚexpm1fÚexpm1ÚerffÚerfÚerfcfÚerfcÚtanfÚtanÚasinfÚasinÚacosfÚacosÚatanfÚatanÚasinhfÚasinhÚacoshfÚacoshÚatanhfÚatanhÚsinhfÚsinhÚcoshfÚcoshÚtanhfÚtanhÚlog2fÚlog2ÚceilfÚceilTÚfloorfÚfloorZnumba_gammafZnumba_gammaÚsqrtfÚsqrtÚtruncfÚtruncÚlgammafÚlgammac                 C   s    |\}t ||ƒ}t| ||j|ƒS rE   )r   r   r;   ©r<   r   r=   r7   r   r@   r   r   r   Úisnan_float_implÑ   s    
r†   c                 C   s   t j}t| ||j|ƒS rE   ©r	   Ú	false_bitr   r;   rL   r   r   r   Úisnan_int_impl×   s    r‰   c                 C   s    |\}t ||ƒ}t| ||j|ƒS rE   )r   r   r;   r…   r   r   r   Úisinf_float_implÝ   s    
rŠ   c                 C   s   t j}t| ||j|ƒS rE   r‡   rL   r   r   r   Úisinf_int_implã   s    r‹   c                 C   s    |\}t ||ƒ}t| ||j|ƒS rE   )r!   r   r;   r…   r   r   r   Úisfinite_float_implé   s    
rŒ   c                 C   s   t j}t| ||j|ƒS rE   )r	   Útrue_bitr   r;   rL   r   r   r   Úisfinite_int_implð   s    rŽ   c                 C   sN   |d j }|j}t |tj |||f¡d|j ¡}| ||¡}t	| ||j
|ƒS )Nr   zllvm.copysign.%s)r   r3   r	   Úget_or_insert_functionr#   r$   rS   Úintrinsic_namer5   r   r;   )r<   r   r=   r7   rU   r8   rH   r@   r   r   r   Úcopysign_float_implö   s    
ÿr‘   c                 C   s¨   |\}|   |jd ¡}|   |jd ¡}tj||dd�}tj ||tj |¡f¡}dddœt	|ƒ }	t 
|j||	¡}
| |
||f¡}t ||| |¡f¡}t| ||j|ƒS )Nr   é   ÚexprQ   Znumba_frexpfZnumba_frexp©r   Údouble)Úget_data_typer7   r;   r	   Úalloca_oncer#   r$   rS   ÚPointerTypeÚstrr�   r3   r5   Úmake_anonymous_structÚloadr   )r<   r   r=   r7   r   ÚflttyÚinttyZexpptrrW   ÚfnamerH   r@   r   r   r   Ú
frexp_impl  s    þýrŸ   c                 C   sp   |\}}t | j|jƒ\}}tj |||f¡}dddœt|ƒ }	tj|j	||	d�}
| 
|
||f¡}t| ||j|ƒS )NZnumba_ldexpfZnumba_ldexpr”   rQ   )Úmapr–   r7   r#   r$   rS   r™   r	   rT   r3   r5   r   r;   )r<   r   r=   r7   r   r“   rœ   r�   rW   rž   rH   r@   r   r   r   Ú
ldexp_impl  s    þýr¡   c                 C   sP   |\}}|  |tj ¡ ¡}|  |tj ¡ ¡}ttjtjtjƒ}t| ||||fƒS rE   )Úsitofpr#   r$   r%   r   r   r   Úatan2_float_impl©r<   r   r=   r7   ÚyÚxÚfsigr   r   r   Úatan2_s64_impl%  s
    r¨   c                 C   sP   |\}}|  |tj ¡ ¡}|  |tj ¡ ¡}ttjtjtjƒ}t| ||||fƒS rE   )Úuitofpr#   r$   r%   r   r   r   r£   r¤   r   r   r   Úatan2_u64_impl-  s
    rª   c                 C   s~   t |ƒdkst‚|j}|jd }|  |¡}tjdtjdi| }tj	 
|||f¡}tj|j||d�}	| |	|¡}
t| ||j|
ƒS )Né   r   Úatan2fÚatan2rQ   )Úlenr&   r3   r7   rR   r   r   r   r#   r$   rS   r	   rT   r5   r   r;   )r<   r   r=   r7   r8   ÚtyrU   rV   rW   rH   r@   r   r   r   r£   5  s    

  þýr£   c                 C   s`   |\}}|  |tj ¡ ¡}|  |tj ¡ ¡}ttjtjtjƒ}t| ||||fƒ}t| ||j	|ƒS rE   ©
r¢   r#   r$   r%   r   r   r   Úhypot_float_implr   r;   ©r<   r   r=   r7   r¦   r¥   r§   r@   r   r   r   Úhypot_s64_implH  s    r³   c                 C   s`   |\}}|  |tj ¡ ¡}|  |tj ¡ ¡}ttjtjtjƒ}t| ||||fƒ}t| ||j	|ƒS rE   r°   r²   r   r   r   Úhypot_u64_implR  s    r´   c                    sÆ   |j \}}||  kr |jks&n t‚|\}}tjtjdkr@dndtjtjdkrTdndi| }t ||¡‰tjdkršt	j
dkrš|tdƒƒ‰ ‡ ‡fdd	„}	n‡fd
d	„}	|  ||	||¡}
t| ||j|
ƒS )NÚwin32Z_hypotfZhypotfZ_hypotÚhypotr+   Úinfc                    s"   t  | ¡st  |¡rˆ S ˆ| |ƒS rE   )ÚmathÚisinf©r¦   r¥   ©r·   Ú
plat_hypotr   r   Ú
hypot_implm  s    z$hypot_float_impl.<locals>.hypot_implc                    s
   ˆ | |ƒS rE   r   rº   )r¼   r   r   r½   r  s    )r7   r;   r&   r   r   ÚsysÚplatformr   ÚExternalFunctionr   ÚMACHINE_BITSr   Úcompile_internalr   )r<   r   r=   r7   ÚxtyÚytyr¦   r¥   rž   r½   r@   r   r»   r   r±   \  s"    
  þýr±   c                 C   s6   |\}|   |jtjd ¡}| ||¡}t| ||j|ƒS ©Né´   ©Úget_constantr;   r¸   ÚpiÚfmulr   ©r<   r   r=   r7   r¦   Úcoefr@   r   r   r   Úradians_float_impl{  s    rÍ   c                 C   s6   |\}|   |jdtj ¡}| ||¡}t| ||j|ƒS rÅ   rÇ   rË   r   r   r   Údegrees_float_impl†  s    rÎ   c                 C   s   |   tj|¡}|||ƒS rE   )Úget_functionÚoperatorÚpow)r<   r   r=   r7   rJ   r   r   r   Úpow_impl‘  s    rÒ   c                 C   s   dS )z8Convert integer to unsigned integer of equivalent width.Nr   ©ÚTr   r   r   Ú	_unsignedš  s    rÕ   c                    s>   | t jkrdd„ S | t jkr:tt d | j¡ƒ‰ ‡ fdd„S d S )Nc                 S   s   | S rE   r   rÓ   r   r   r   Ú<lambda>¡  ó    z _unsigned_impl.<locals>.<lambda>zuint{}c                    s   ˆ | ƒS rE   r   rÓ   ©ZnewTr   r   rÖ   ¤  r×   )r   Úunsigned_domainÚsigned_domainÚgetattrÚformatÚbitwidthrÓ   r   rØ   r   Ú_unsigned_implž  s
    

rÞ   c           
      C   sV   |j \}}||  kr |jks&n t‚|\}}dd„ }|  ||||¡}	t| ||j|	ƒS )Nc           	      S   s²   t | ƒ}| dkrt|ƒS |dkr(t| ƒS t| ƒ}t|ƒ}t||ƒ}ttt | |¡ƒƒ}ttt ||¡ƒƒ}||krž||kr„|| }}||8 }t |t|ƒ¡}qjt ||ƒ|¡}|S )zO
        Stein's algorithm, heavily cribbed from Julia implementation.
        r   )r   Úabsr   ÚminrÕ   ÚnpÚright_shiftÚ
left_shift)	r1   ÚbrÔ   ZzaZzbÚkÚuÚvÚrr   r   r   Úgcd¬  s"      

zgcd_impl.<locals>.gcd)r7   r;   r&   rÂ   r   )
r<   r   r=   r7   rÃ   rÄ   r¦   r¥   ré   r@   r   r   r   Úgcd_impl§  s    
rê   )F)‘Ú__doc__r¸   rÐ   r¾   Únumpyrá   Úllvmlite.irr#   r   Únumba.core.imputilsr   r   Únumbar   Ú
numba.corer   r   r   r	   Únumba.core.extendingr
   Únumba.core.typingr   Únumba.cpython.unsafe.numbersr   ÚregistryrF   ÚfinfoÚdtypeZ_NP_FLT_FINFOÚmaxÚFLT_MAXÚtinyÚFLT_MINZ_NP_DBL_FINFOÚDBL_MAXZDBL_MINZFLOAT_ABS_MASKZFLOAT_SIGN_MASKZDOUBLE_ABS_MASKZDOUBLE_SIGN_MASKr   r   r!   r)   r*   r-   r.   r/   r9   rD   rK   rP   r\   Úfabsr“   Úexp_implÚlogÚlog_implÚlog10Ú
log10_implÚsinÚsin_implÚcosÚcos_implr^   Ú
log1p_implr`   Ú
expm1_implrb   Zerf_implrd   Z	erfc_implrf   Útan_implrh   Ú	asin_implrj   Ú	acos_implrl   Ú	atan_implrn   Ú
asinh_implrp   Ú
acosh_implrr   Ú
atanh_implrt   Ú	sinh_implrv   Ú	cosh_implrx   Ú	tanh_implrz   Z	log2_implr|   Z	ceil_implr~   Z
floor_implÚgammaÚ
gamma_implr€   Ú	sqrt_implr‚   Z
trunc_implr„   Zlgamma_implÚisnanrO   r†   rG   r‰   r¹   rŠ   r‹   ÚisfiniterŒ   rŽ   Úcopysignr‘   ÚfrexprŸ   ÚldexpÚintcr¡   r­   r[   r¨   Úuint64rª   r£   r¶   r³   r´   r±   ÚradiansrÍ   ÚdegreesrÎ   rÑ   rÒ   rÕ   rÞ   rê   ré   r   r   r   r   Ú<module>   sØ   
	
$












	
	



