
    i'                     H   S SK rS SKJrJrJrJr  S SKJr  S SK	J
r
JrJrJr  S SKJrJr  \S 5       r\S 5       r\S 5       r\S	 5       r\S
 5       r\S 5       r\S 5       r\S 5       r\S 5       r\S 5       r\S 5       r\S 5       r\S 5       r\S 5       r\S 5       rg)    N)uint64uint32uint16uint8)register_jitable)
UINT32_MAX
UINT64_MAX
UINT16_MAX	UINT8_MAX)next_uint32next_uint64c                 p    [        U 5      nXS-	  -  nXS-	  -  nXS-	  -  nXS-	  -  nXS-	  -  nXS-	  -  nU$ )N                   )r   )maxmasks     ]/var/www/html/trading/venv/lib/python3.13/site-packages/numba/np/random/old_random_methods.pygen_maskr      sX    #;DAIDAIDAIDAIDBJDBJDK    c                 h    US:X  a  XU4$ U(       d  [        U 5      nSnO
US-  nUS-  nUS-  S:g  X44$ )Nr      r   )r   )bitgenoffrngbcntbufs        r   buffered_bounded_boolr!      sJ    q#~&!		1WNT&&r   c                 Z    U(       d  [        U 5      nSnO
US-  nUS-  n[        U5      X4$ )N   r   r   )r   r   r   r   r    s      r   buffered_uint8r%   (   s5    &!		:t  r   c                 Z    U(       d  [        U 5      nSnO
US-  nUS-  n[        U5      X4$ )Nr   r   )r   r   r$   s      r   buffered_uint16r'   4   s5    &!
	#;!!r   c                    [        U5      [        S5      -   nUS:w  d   e[        XU5      u  pRn[        XT-  5      nUS-  nXt:  aB  [        [        5      U-
  U-  nXx:  a(  [        XU5      u  pRn[        XT-  5      nUS-  nXx:  a  M(  US-	  X#4$ )a#  
Generates a random unsigned 8 bit integer bounded
within a given interval using Lemire's rejection.

The buffer acts as storage for a 32 bit integer
drawn from the associated BitGenerator so that
multiple integers of smaller bitsize can be generated
from a single draw of the BitGenerator.
r      r   )r   r%   r   r   	r   r   r   r    rng_exclnmleftover	thresholds	            r   buffered_bounded_lemire_uint8r0   B   s     SzE!H$H4KK "&4LASq|A 4xHI&,8	#)&<LASq|$A4xH #
 64r   c                    [        U5      [        S5      -   nUS:w  d   e[        XU5      u  pRn[        XT-  5      nUS-  nXt:  aB  [        [        5      U-
  U-  nXx:  a(  [        XU5      u  pRn[        XT-  5      nUS-  nXx:  a  M(  US-	  X#4$ )a$  
Generates a random unsigned 16 bit integer bounded
within a given interval using Lemire's rejection.

The buffer acts as storage for a 32 bit integer
drawn from the associated BitGenerator so that
multiple integers of smaller bitsize can be generated
from a single draw of the BitGenerator.
r     r   )r   r'   r   r
   r*   s	            r   buffered_bounded_lemire_uint16r3   f   s     c{VAY&H6MM #65LASq|A 6zHZ(3.(:	#*6=LASq|$A6zH #
 7Dr   c                    [        U5      [        S5      -   nUS:w  d   e[        [        U 5      5      [        U5      -  nUS-  nXB:  a=  [        U-
  U-  nXE:  a,  [        [        U 5      5      [        U5      -  nUS-  nXE:  a  M,  US-	  $ )zf
Generates a random unsigned 32 bit integer bounded
within a given interval using Lemire's rejection.
r       r   )r   r   r   r   )r   r   r+   r-   r.   r/   s         r   buffered_bounded_lemire_uint32r6      s     c{VAY&H: 	{6"#fX&66A :~H#%1	#{6*+fX.>>A:~H # Gr   c                    [        U5      [        S5      -   nUS:w  d   e[        U 5      n[        U5      [        U5      -  nXB:  a:  [        U-
  U-  nXE:  a)  [        U 5      n[        U5      [        U5      -  nXE:  a  M)  U[        S5      -  nUS-	  nU[        S5      -  nUS-	  n	Xh-  n
Xx-  U
S-	  -   nU[        S5      -  nUS-	  nXU	-  -  nXy-  U-   US-	  -   nU$ )zf
Generates a random unsigned 64 bit integer bounded
within a given interval using Lemire's rejection.
r       r5   r   )r   r   r	   )r   r   r+   xr.   r/   x0x1	rng_excl0	rng_excl1w0tw1w2m1s                  r   bounded_lemire_uint64rC      s	    c{VAY&H%%&%FAay6(++H#%1	#F#Aay6(#33H # 
VJ	B	
bB6*--IBI	B
"(#A	
VJ	B	
bBy.B	"	b	)BIr   c                    [         R                  " X4S9nUS:X  a#  [         R                  " U5       H  nXU'   M	     U$ US::  ae  US:X  a/  [         R                  " U5       H  nU[        U 5      -   XV'   M     U$ [         R                  " U5       H  nU[	        X5      -   XV'   M      U$ US:X  a/  [         R                  " U5       H  nU[        U 5      -   XV'   M     U$ [         R                  " U5       H  nU[        X5      -   XV'   M     U$ )zS
Returns a new array of given size with 64 bit integers
bounded by given interval.
dtyper   r5   r8   )npemptyndindexr   r6   r   rC   r   lowr   sizerF   outis          r   random_bounded_uint64_fillrO      s	    ((4
%C
axD!AF "" J 

	:ZZ%{622 & J ZZ%=fJJ & J #
#D!A;v..CF " J D!A0==CF " Jr   c                 D   [         R                  " X4S9nUS:X  a#  [         R                  " U5       H  nXU'   M	     U$ US:X  a/  [         R                  " U5       H  nU[        U 5      -   XV'   M     U$ [         R                  " U5       H  nU[	        X5      -   XV'   M     U$ )zS
Returns a new array of given size with 32 bit integers
bounded by given interval.
rE   r   r5   )rG   rH   rI   r   r6   rJ   s          r   random_bounded_uint32_fillrQ      s     ((4
%C
axD!AF " J 

	D!A;v..CF "
 J D!A9&FFCF "Jr   c                 `   SnSn[         R                  " X4S9nUS:X  a#  [         R                  " U5       H  nXU'   M	     U$ US:X  a4  [         R                  " U5       H  n[        XU5      u  pnX-   Xx'   M     U$ [         R                  " U5       H  n[	        XXe5      u  pnX-   Xx'   M     U$ )zS
Returns a new array of given size with 16 bit integers
bounded by given interval.
r   rE   r2   )rG   rH   rI   r'   r3   
r   rK   r   rL   rF   r    r   rM   rN   vals
             r   random_bounded_uint16_fillrU      s     CD
((4
%C
axD!AF " J 
D!A,V3?NCsYCF " J D!A.v/3: Cs YCF	 "
 Jr   c                 `   SnSn[         R                  " X4S9nUS:X  a#  [         R                  " U5       H  nXU'   M	     U$ US:X  a4  [         R                  " U5       H  n[        XU5      u  pnX-   Xx'   M     U$ [         R                  " U5       H  n[	        XXe5      u  pnX-   Xx'   M     U$ )zR
Returns a new array of given size with 8 bit integers
bounded by given interval.
r   rE   r)   )rG   rH   rI   r%   r0   rS   s
             r   random_bounded_uint8_fillrW     s     CD
((4
%C
axD!AF " J 
D!A+F#>NCsYCF " J D!A-f.29 Cs YCF	 "
 Jr   c                     SnSn[         R                  " X4S9n[         R                  " U5       H  n[        XX&U5      u  pnX-   Xx'   M     U$ )z8
Returns a new array of given size with boolean values.
r   rE   )rG   rH   rI   r!   rS   s
             r   random_bounded_bool_fillrY   /  sQ    
 CD
((4
%CZZ.vCsK3  Jr   c                 *   X:  a  [        S5      eUS:  a]  [        U5      nU(       d  U[        S5      -  n[        U5      nU S:  a  [        U 5      n X:  a  [        S5      eX:  a  [        S5      egX:  a  [        S5      eX:  a  [        S5      eg)zG
Check that low and high are within the bounds
for the given datatype.
zlow is out of boundsr   r   zhigh is out of boundsz*low is greater than high in given intervalN)
ValueErrorr   )rK   highendpointlower_boundupper_bounds        r   _randint_arg_checkr`   =  s     /00
 axd|F1ID[)7+C455:IJJ  455:IJJ r   c                 6   US:X  a  g[        U5      n[        [        U5      5      nUS::  a;  [        [        U 5      5      U-  nX1:  a  [        [        U 5      5      U-  nX1:  a  M  O([        U 5      U-  nX1:  a  [        U 5      U-  nX1:  a  M  [        U5      $ )Nr   r5   )r   r   r   r   )r   max_valr   values       r   random_intervalrd   \  s    1WoG(7#$D:{6*+d2o;v./$6E o F#d*o'$.E o %=r   ) numpyrG   numbar   r   r   r   numba.core.extendingr   numba.np.random._constantsr   r	   r
   r   numba.np.random.generator_corer   r   r   r!   r%   r'   r0   r3   r6   rC   rO   rQ   rU   rW   rY   r`   rd    r   r   <module>rk      sO    / / 1? ? C   
' 
' ! ! " "    F    F  4  D  6  &  6  4 
 
 K K<  r   