
    J/Ph<                     <   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
 ddlmZmZmZ ddlmZ ddlmZ ddlmZ  ej         ej        d	                    Zej        Zej        Z ej         ej        d
                    Zej        Zej        ZdZdZ dZ!dZ"d Z#d Z$d Z%d Z&d Z'd Z(d Z)d Z*d Z+d Z,d Z-d Z.dcdZ/ e.ej0        d            e.ej1        d          Z2 e.ej3        d          Z4 e.ej5        d           Z6 e.ej7        d!          Z8 e.ej9        d"          Z: e/ej;        d#d$          Z< e/ej=        d%d&          Z> e/ej?        d'd(          Z@ e/ejA        d)d*          ZB e/ejC        d+d,          ZD e/ejE        d-d.          ZF e/ejG        d/d0          ZH e/ejI        d1d2          ZJ e/ejK        d3d4          ZL e/ejM        d5d6          ZN e/ejO        d7d8          ZP e/ejQ        d9d:          ZR e/ejS        d;d<          ZT e/ejU        d=d>          ZV e/ejW        d?d@          ZX e/ejY        dAdBdC          ZZ e/ej[        dDdEdC          Z\ e/ej]        dFdG          Z^ e/ej_        dHdI          Z` e/eja        dJdKdC          Zb e/ejc        dLdM          ZddN ZedO ZfdP ZgdQ ZhdR ZidS ZjdT ZkdU ZldV ZmdW ZndX ZodY ZpdZ Zqd[ Zrd\ Zsd] Zt e-eju        et           d^ Zv e-ejw        ev           d_ Zxd` Zy eey          da             Zzdb Z{dS )dzA
Provide math calls that uses intrinsics or libc math functions.
    N)Constant)impl_ret_untracked)typesconfigcgutils)overload)	signature)trailing_zerosfloat32float64il        l    l            c                 0    |                      d||          S )z<
    Return a condition testing whether *val* is a NaN.
    uno)fcmp_unorderedbuildervals     V/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/numba/np/math/mathimpl.pyis_nanr   '   s     !!%c222    c                    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   pos_infneg_infisposinfisneginfs         r   is_infr   -   st     sxv//Gsxv//G##D#w77H##D#w77H;;x***r   c                 \    |                      ||          }|                     d||          S )z?
    Return a condition testing whether *val* is a finite.
    ord)fsubr   )r   r   val_minus_vals      r   	is_finiter$   7   s/    
 LLc**M}mDDDr   c                     |j         t          j                                        k    sJ |                     |t          j                            d                    S )z1
    Bitcast a double into a 64-bit integer.
    @   )r   llvmliteir
DoubleTypebitcastIntTyper   s     r   f64_as_int64r,   ?   sI     8x{--//////??3 3 3B 7 7888r   c                     |j         t          j                            d          k    sJ |                     |t          j                                                  S )z1
    Bitcast a 64-bit integer into a double.
    r&   )r   r'   r(   r+   r*   r)   r   s     r   int64_as_f64r.   F   sI     8x{**2......??3 6 6 8 8999r   c                     |j         t          j                                        k    sJ |                     |t          j                            d                    S )z0
    Bitcast a float into a 32-bit integer.
        )r   r'   r(   	FloatTyper*   r+   r   s     r   f32_as_int32r2   M   sI     8x{,,......??3 3 3B 7 7888r   c                     |j         t          j                            d          k    sJ |                     |t          j                                                  S )z0
    Bitcast a 32-bit integer into a float.
    r0   )r   r'   r(   r+   r*   r1   r   s     r   int32_as_f32r4   T   sI     8x{**2......??3 5 5 7 7888r   c                 T    |                      t          |j        d          |          S )zB
    Negate real number *val*, with proper handling of zeros.
    g       )r"   r   r   r   s     r   negate_realr6   [   s$    
 <<400#666r   c                 |    | j         }|                    |d |D                       }|                     ||          S )z9
    Call a LLVM intrinsic floating-point operation.
    c                     g | ]	}|j         
S  )r   ).0as     r   
<listcomp>z%call_fp_intrinsic.<locals>.<listcomp>g   s    '='='=1'='='=r   )moduledeclare_intrinsiccall)r   nameargsmodintrs        r   call_fp_intrinsicrD   b   sC     .C  '='='='='=>>D<<d###r   c                       fd}|S )z
    Return an implementation factory to convert the single integral input
    argument to a float64, then defer to the *wrapped_impl*.
    c                    |\  }|j         d         }|                     |||t          j                  }t	          t          j        t          j                  } 	| |||f          }|                     ||t          j        |j                  S )Nr   )rA   castr   r   r	   return_type)
contextr   sigrA   r   
input_typefpval	inner_sigreswrapped_impls
            r   implementerz2_unary_int_input_wrapper_impl.<locals>.implementerp   st    Xa[
Wc:u}EEemU];;	l7GYAA||GS%-IIIr   r9   )rO   rP   s   ` r   _unary_int_input_wrapper_implrQ   k   s)    
J J J J J r   c                 $    t          |          }d S N)rQ   )fn
float_implimpls      r   unary_math_int_implrW   z   s    (44DDDr   c                 2    fd}t          | |           |S )zO
    Implement the math function *fn* using the LLVM intrinsic *intrcode*.
    c                 T    t          ||          }t          | ||j        |          S rS   )rD   r   rH   )rI   r   rJ   rA   rN   intrcodes        r   rU   z#unary_math_intr.<locals>.float_impl   s*    488!'7COSIIIr   )rW   )rT   rZ   rU   s    ` r   unary_math_intrr[   ~   s9    
J J J J J J'''r   Fc                     t           j        r|rt          j        nd}n|rt          j        nd}fd}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                    |\  }|j         }|j        d         }|                     |          }t          j        t          j        i|         }t          j                            ||g          }	t          j
        |j         |	|          }
|                    |
|f          }|                     ||||j                  }t          | ||j        |          S )z9
        Implement *fn* for a types.Float input.
        r   r@   )r=   rA   get_value_typer   r   r   r'   r(   FunctionTyper   insert_pure_functionr?   rG   rH   r   )rI   r   rJ   rA   r   rB   rK   lty	func_namefntyrT   rN   	f32extern	f64externs               r   rU   z%unary_math_extern.<locals>.float_impl   s     nXa[
$$Z00M9M9 	 {''cU33)'.$YOOOll2v&&ll7CS_EE!'7COSIIIr   )r   USE_LEGACY_TYPE_SYSTEMr   int64np_int64rW   )rT   re   rf   int_restype	f_restyperU   s    ``   r   unary_math_externrl      so     $ <#.8EKKD		&1;ENNt	J J J J J J* J'''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floornumba_gammafnumba_gammasqrtfsqrttruncftrunclgammaflgammac                 X    |\  }t          ||          }t          | ||j        |          S rS   )r   r   rH   rI   r   rJ   rA   r   rN   s         r   isnan_float_implr      .    ES
#

CgwEEEr   c                 H    t           j        }t          | ||j        |          S rS   r   	false_bitr   rH   rI   r   rJ   rA   rN   s        r   isnan_int_implr           

CgwEEEr   c                 X    |\  }t          ||          }t          | ||j        |          S rS   )r   r   rH   r   s         r   isinf_float_implr      r   r   c                 H    t           j        }t          | ||j        |          S rS   r   r   s        r   isinf_int_implr      r   r   c                 X    |\  }t          ||          }t          | ||j        |          S rS   )r$   r   rH   r   s         r   isfinite_float_implr      s.    ES
GS
!
!CgwEEEr   c                 H    t           j        }t          | ||j        |          S rS   )r   true_bitr   rH   r   s        r   isfinite_int_implr      s     

CgwEEEr   c                     |d         j         }|j        }t          j        |t          j                            |||f          d|j        z            }|                    ||          }t          | ||j
        |          S )Nr   zllvm.copysign.%s)r   r=   r   get_or_insert_functionr'   r(   r`   intrinsic_namer?   r   rH   )rI   r   rJ   rA   rb   rB   rT   rN   s           r   copysign_float_implr      sw    
q',C
.C		'X[-E-EcCQT:-V-V(:S=O(O
Q 
QB
,,r4
 
 CgwEEEr   c                 N   |\  }|                      |j        d                   }|                      |j        d                   }t          j        ||d          }t
          j                            ||t
          j                            |          f          }dddt          |                   }	t          j
        |j        ||	          }
|                    |
||f          }t          j        |||                    |          f          }t          | ||j        |          S )Nr      expr^   numba_frexpfnumba_frexpr   double)get_data_typerA   rH   r   alloca_oncer'   r(   r`   PointerTypestrr   r=   r?   make_anonymous_structloadr   )rI   r   rJ   rA   r   flttyinttyexpptrrd   fnamerT   rN   s               r   
frexp_implr     s	   DC!!#(1+..E!!#/!"455E %e<<<F;##EE8;3J3J53Q3Q+RSSD
 
 e**E 
	'e	D	DB
,,rC=
)
)C

'#w||F7K7K1L
M
MCgwEEEr   c                 P   |\  }}t          | j        |j                  \  }}t          j                            |||f          }dddt          |                   }	t          j        |j	        ||	          }
|
                    |
||f          }t          | ||j        |          S )Nnumba_ldexpfnumba_ldexpr   r^   )mapr   rA   r'   r(   r`   r   r   ra   r=   r?   r   rH   )rI   r   rJ   rA   r   r   r   r   rd   r   rT   rN   s               r   
ldexp_implr     s    HCw,ch77LE5;##EE5>::D
 
 e**E 
	%gnd	G	G	GB
,,rC:
&
&CgwEEEr   c                 Z   |\  }}|                     |t          j                                                  }|                     |t          j                                                  }t	          t
          j        t
          j        t
          j                  }t          | ||||f          S rS   )sitofpr'   r(   r)   r	   r   r   atan2_float_implrI   r   rJ   rA   yxfsigs          r   atan2_s64_implr   (  |    FQq(+002233Aq(+002233AU]EM5=AADGWdQF;;;r   c                 Z   |\  }}|                     |t          j                                                  }|                     |t          j                                                  }t	          t
          j        t
          j        t
          j                  }t          | ||||f          S rS   )uitofpr'   r(   r)   r	   r   r   r   r   s          r   atan2_u64_implr   0  r   r   c                    t          |          dk    sJ |j        }|j        d         }|                     |          }t          j        dt          j        di|         }t          j        	                    |||f          }t          j        |j        ||          }	|                    |	|          }
t          | ||j        |
          S )N   r   atan2fatan2r^   )lenr=   rA   r_   r   r   r   r'   r(   r`   r   ra   r?   r   rH   )rI   r   rJ   rA   rB   tyrb   rc   rd   rT   rN   s              r   r   r   8  s    t99>>>>
.C	!B

 
 
$
$Cxw
 I ;##C#s44D		%gnd	K	K	KB
,,r4
 
 CgwEEEr   c                    |\  }}|                     |t          j                                                  }|                     |t          j                                                  }t	          t
          j        t
          j        t
          j                  }t          | ||||f          }t          | ||j	        |          S rS   
r   r'   r(   r)   r	   r   r   hypot_float_implr   rH   rI   r   rJ   rA   r   r   r   rN   s           r   hypot_s64_implr   K      FQq(+002233Aq(+002233AU]EM5=AAD
7GTAq6
:
:CgwEEEr   c                    |\  }}|                     |t          j                                                  }|                     |t          j                                                  }t	          t
          j        t
          j        t
          j                  }t          | ||||f          }t          | ||j	        |          S rS   r   r   s           r   hypot_u64_implr   U  r   r   c                    |j         \  }}||cxk    r|j        k    sn J |\  }}t          j        t          j        dk    rdndt          j        t          j        dk    rdndi|         }t          j        ||          t          j        dk    r/t          j	        dk    r |t          d                    fd}	nfd	}	|                     ||	||          }
t          | ||j        |
          S )
Nwin32_hypotfhypotf_hypothypotr0   infc                 p    t          j        |           st          j        |          rS  | |          S rS   )mathisinf)r   r   r   
plat_hypots     r   
hypot_implz$hypot_float_impl.<locals>.hypot_implo  s9    z!}} 
1 
:a###r   c                      | |          S rS   r9   )r   r   r   s     r   r   z$hypot_float_impl.<locals>.hypot_implt  s    :a###r   )rA   rH   r   r   sysplatformr   ExternalFunctionr   MACHINE_BITSr   compile_internalr   )rI   r   rJ   rA   xtyytyr   r   r   r   rN   r   r   s              @@r   r   r   _  s0   xHC#((((((((((DAq
 	CLG$;$;yy3<7#:#:xx 
E 's33J
|w6#6"#<#<c%,,	$ 	$ 	$ 	$ 	$ 	$ 	$
	$ 	$ 	$ 	$ 	$ 
"
"7JT
B
BCgwEEEr   c                     |\  }|                      |j        t          j        dz            }|                    ||          }t          | ||j        |          S N   get_constantrH   r   pifmulr   rI   r   rJ   rA   r   coefrN   s          r   radians_float_implr   ~  sO    
CQ3??D
,,q$

CgwEEEr   c                     |\  }|                      |j        dt          j        z            }|                    ||          }t          | ||j        |          S r   r   r   s          r   degrees_float_implr     sO    
CQtw??D
,,q$

CgwEEEr   c                 Z    |                      t          j        |          } |||          S rS   )get_functionoperatorpow)rI   r   rJ   rA   rV   s        r   pow_implr    s+    c22D4r   c                     dS )z8Convert integer to unsigned integer of equivalent width.Nr9   Ts    r   	_unsignedr    s    Dr   c                     | t           j        v rd S | t           j        v r2t          t           d                    | j                            fdS d S )Nc                     | S rS   r9   r  s    r   <lambda>z _unsigned_impl.<locals>.<lambda>  s     r   zuint{}c                      |           S rS   r9   r  newTs    r   r
  z _unsigned_impl.<locals>.<lambda>  s    a r   )r   unsigned_domainsigned_domaingetattrformatbitwidthr  s    @r   _unsigned_implr    s[    E!!!{	
e!	!	!uhooaj99::      
"	!r   c                     |j         \  }}||cxk    r|j        k    sn J |\  }}d }|                     ||||          }	t          | ||j        |	          S )Nc                 F   t          |           }| dk    rt          |          S |dk    rt          |           S t          |           }t          |          }t          ||          }t	          t          t          j        | |                              }t	          t          t          j        ||                              }||k    r7||k    r||}}||z  }t          j        |t          |                    }||k    7t          j         ||          |          }|S )zO
        Stein's algorithm, heavily cribbed from Julia implementation.
        r   )r   absr
   minr  npright_shift
left_shift)	r;   br  zazbkuvrs	            r   gcdzgcd_impl.<locals>.gcd  s    GG66#a&&=66#a&&=AABKKc".B//0011c".B//00111ff1uu!1FAq."3"344A	 1ff
 M!!A$$""r   )rA   rH   r   r   )
rI   r   rJ   rA   r   r   r   r   r"  rN   s
             r   gcd_implr#    s}    xHC#((((((((((DAq  * 
"
"7Cd
;
;CgwEEEr   )F)|__doc__r   r  r   numpyr  llvmlite.irr'   r   numba.core.imputilsr   
numba.corer   r   r   numba.core.extendingr   numba.core.typingr	   numba.cpython.unsafe.numbersr
   finfodtype_NP_FLT_FINFOmaxFLT_MAXtinyFLT_MIN_NP_DBL_FINFODBL_MAXDBL_MINFLOAT_ABS_MASKFLOAT_SIGN_MASKDOUBLE_ABS_MASKDOUBLE_SIGN_MASKr   r   r$   r,   r.   r2   r4   r6   rD   rQ   rW   r[   rl   fabsr   exp_implloglog_impllog10
log10_implsinsin_implcoscos_implrn   
log1p_implrp   
expm1_implrr   erf_implrt   	erfc_implrv   tan_implrx   	asin_implrz   	acos_implr|   	atan_implr~   
asinh_implr   
acosh_implr   
atanh_implr   	sinh_implr   	cosh_implr   	tanh_implr   	log2_implr   	ceil_implr   
floor_implgamma
gamma_implr   	sqrt_implr   
trunc_implr   lgamma_implr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   radiansr   degreesr  r  r  r#  r9   r   r   <module>r\     s       



                     2 2 2 2 2 2 - - - - - - - - - - ) ) ) ) ) ) ' ' ' ' ' ' 7 7 7 7 7 7 ),,--



),,--



$% 3 3 3+ + +E E E9 9 9: : :9 9 99 9 97 7 7$ $ $  5 5 5
 
 
$ $ $ $N 	; ' ' '?48Z00?48Z00_TZ66
?48Z00?48Z00tz8W==
tz8W==
TXvu55di&99	TXvu55di&99	di&99	di&99	tz8W==
tz8W==
tz8W==
di&99	di&99	di&99	di&99	di&$??	tz8WdCC
tz>=II
di&99	tz8WdCC
YAAF F FF F FF F FF F FF F FF F FF F FF F F"
F 
F 
F"< < << < <F F F&F F FF F FF F F>F F F  DL"4 5 5 5
F F F  DL"4 5 5 5  	 	 	 
)! ! !F F F F Fr   