
    bi                       U d dl mZ d dlZd dlZd dlZd dlmZmZ d dlmZ d dl	m
Z
 d dlmZ d dlZd dlmZmZmZ d dlmZ d d	lmZmZmZmZmZmZ d d
lmZ d dlmZ d dl m!Z! d dl"m#Z# d dl$m%Z%m&Z&m'Z'  G d d      Z(dJdZ) G d d      Z*d Z+dKdZ,d Z-d Z.d Z/d Z0d Z1d Z2dddddZ3	 i Z4d e5d!<    e       Z6d" Z7	  e7d#      Z8 e7d$      Z9 e7d%      Z: e7d&      Z; e7d'      Z< e7d(      Z= e7d)      Z> e7d*      Z? e7d+      Z@ e7d,      ZA e7d-      ZB e7d.      ZC e7d/      ZD e7d0      ZE e7d1      ZF e7d2      ZG e7d3      ZH e7d4      ZI e7d5      ZJ e7d6      ZK e7d7      ZL e7d8      ZM e7d9      ZN e7d:      ZO e7d;      ZP e7d;      ZQ e7d<      ZR e7d=      ZS e7d>      ZT e7d?      ZU e7d@      ZV e7dA      ZW e7dB      ZX e7dC      ZY e7dD      ZZ e7dE      Z[ e7dF      Z\ e7dG      Z] e7dH      Z^ e7dI      Z_y)L    )annotationsN)chainproduct)Integral)getitem)Lock)TaskTaskRefparse_input)array_creation_dispatch)Arrayasarraybroadcast_shapesbroadcast_tonormalize_chunksslices_from_chunks)arange)asarray_safe)tokenize)HighLevelGraph)derived_fromrandom_state_datatypenamec                  ~   e Zd ZdZd Zd Zed        Zed        Z e	e
j                  j                  d      d1d
       Z e	e
j                  j                  d      d1d       Z e	e
j                  j                  d      d1d       Z e	e
j                  j                  d      	 	 	 	 	 	 d2d       Z e	e
j                  j                  d      d3d       Z e	e
j                  j                  d      d1d       Z e	e
j                  j                  d      d3d       Z e	e
j                  j                  d      d1d       Z e	e
j                  j                  d      d4d       Z e	e
j                  j                  d      d1d       Z e	e
j                  j                  d      dde
j.                  dd	fd       Z e	e
j                  j                  d      d4d       Z e	e
j                  j                  d      d4d       Z e	e
j                  j                  d      d4d       Z e	e
j                  j                  d      d1d       Z e	e
j                  j                  d      d1d       Z e	e
j                  j                  d      	 d5d       Z e	e
j                  j                  d      d1d       Z e	e
j                  j                  d      d1d       Z  e	e
j                  j                  d      d1d       Z! e	e
j                  j                  d      d4d       Z" e	e
j                  j                  d      d1d        Z# e	e
j                  j                  d      d!        Z$ e	e
j                  j                  d      d3d"       Z% e	e
j                  j                  d      d1d#       Z& e	e
j                  j                  d      de
jN                  dd	fd$       Z e	e
j                  j                  d      d3d%       Z( e	e
j                  j                  d      d1d&       Z) e	e
j                  j                  d      d1d'       Z* e	e
j                  j                  d      d1d(       Z+ e	e
j                  j                  d      d1d)       Z, e	e
j                  j                  d      d1d*       Z- e	e
j                  j                  d      d1d+       Z. e	e
j                  j                  d      d4d,       Z/ e	e
j                  j                  d      d1d-       Z0 e	e
j                  j                  d      d1d.       Z1 e	e
j                  j                  d      d1d/       Z2 e	e
j                  j                  d      d1d0       Z3y)6	Generatora
  
    Container for the BitGenerators.

    ``Generator`` exposes a number of methods for generating random
    numbers drawn from a variety of probability distributions and serves
    as a replacement for ``RandomState``. The main difference between the
    two is that ``Generator`` relies on an additional ``BitGenerator`` to
    manage state and generate the random bits, which are then transformed
    into random values from useful distributions. The default ``BitGenerator``
    used by ``Generator`` is ``PCG64``. The ``BitGenerator`` can be changed
    by passing an instantiated ``BitGenerator`` to ``Generator``.

    The function :func:`dask.array.random.default_rng` is the recommended way
    to instantiate a ``Generator``.

    .. warning::

       No Compatibility Guarantee.

       ``Generator`` does not provide a version compatibility guarantee. In
       particular, as better algorithms evolve the bit stream may change.

    Parameters
    ----------
    bit_generator : BitGenerator
        BitGenerator to use as the core generator.

    Notes
    -----
    In addition to the distribution-specific arguments, each ``Generator``
    method takes a keyword argument `size` that defaults to ``None``. If
    `size` is ``None``, then a single value is generated and returned. If
    `size` is an integer, then a 1-D array filled with generated values is
    returned. If `size` is a tuple, then an array with that shape is
    filled and returned.

    The Python stdlib module `random` contains pseudo-random number generator
    with a number of methods that are similar to the ones available in
    ``Generator``. It uses Mersenne Twister, and this bit generator can
    be accessed using ``MT19937``. ``Generator``, besides being
    Dask-aware, has the advantage that it provides a much larger number
    of probability distributions to choose from.

    All ``Generator`` methods are identical to ``np.random.Generator`` except
    that they also take a `chunks=` keyword argument.

    ``Generator`` does not guarantee parity in the generated numbers
    with any third party library. In particular, numbers generated by
    `Dask` and `NumPy` will differ even if they use the same seed.

    Examples
    --------
    >>> from numpy.random import PCG64
    >>> from dask.array.random import Generator
    >>> rng = Generator(PCG64())
    >>> rng.standard_normal().compute() # doctest: +SKIP
    array(0.44595957)  # random

    See Also
    --------
    default_rng : Recommended constructor for `Generator`.
    np.random.Generator
    c                    || _         y N)_bit_generator)selfbit_generators     L/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/dask/array/random.py__init__zGenerator.__init___   s
    +    c                    | j                   j                  }|d| j                  j                   j                  z   dz   z  }|S )N())	__class____name__r   )r   _strs     r!   __str__zGenerator.__str__b   s<    ~~&&d))33<<<sBBr#   c                P    t        | j                        j                  d      d   S N.r   )r   r   splitr   s    r!   _backend_namezGenerator._backend_nameg   s%     ++,2237::r#   c                @    t        j                  | j                        S r   )	importlibimport_moduler0   r/   s    r!   _backendzGenerator._backendm   s     &&t'9'9::r#      
skipblocksNautoc                &    t        | d||f||d|S Nbetasizechunks
_wrap_funcr   abr=   r>   kwargss         r!   r;   zGenerator.betas       $1Q4Q&QQr#   c                &    t        | d||f||d|S Nbinomialr<   r?   r   npr=   r>   rD   s         r!   rH   zGenerator.binomialw       $
AqUtFUfUUr#   c                $    t        | d|f||d|S N	chisquarer<   r?   r   dfr=   r>   rD   s        r!   rO   zGenerator.chisquare{       $RTd6TVTTr#   c                   t        | ||||||      \  }}}}}}}}	t        t        |       }
t        | j                  t        |
            }dt        ||||||||      z  }t        |ggd |D         }t        |||
      D ci c]  \  }}}|t        |t        |||||||	        }}}}t        j                  |||	      }t        ||||      S c c}}}w )Nda.random.choice-%sc              3  D   K   | ]  }t        t        |              y wr   rangelen.0bds     r!   	<genexpr>z#Generator.choice.<locals>.<genexpr>   s      ABs2w A    dependenciesmeta)_choice_validate_paramslistr   _spawn_bitgensr   rX   r   zipr	   _choice_rngr   from_collectionsr   )r   rB   r=   replacerK   axisshuffler>   ra   r_   sizesbitgensnamekeyskbitgendskgraphs                     r!   choicezGenerator.choice   s   ( $D!T7AtVL		
 Wf%& !4!4c%jA$xT61gq$(
 
 vB A& AB $'tWe#<
 
64 tA{FAtWawOO
 

 //cUUD&t44
s   #Cc                $    t        | d|f||d|S Nexponentialr<   r?   r   scaler=   r>   rD   s        r!   rv   zGenerator.exponential   (    -
-1&
DJ
 	
r#   c                &    t        | d||f||d|S Nfr<   r?   r   dfnumdfdenr=   r>   rD   s         r!   r|   zGenerator.f       $UEVVVvVVr#   c                &    t        | d||f||d|S Ngammar<   r?   r   shaperx   r=   r>   rD   s         r!   r   zGenerator.gamma   *    '5%
.26
EK
 	
r#   c                $    t        | d|f||d|S N	geometricr<   r?   r   rK   r=   r>   rD   s        r!   r   zGenerator.geometric       $QST&SFSSr#   c                &    t        | d||f||d|S Ngumbelr<   r?   r   locrx   r=   r>   rD   s         r!   r   zGenerator.gumbel   *    (C
-1&
DJ
 	
r#   c                (    t        | d|||f||d|S Nhypergeometricr<   r?   r   ngoodnbadnsampler=   r>   rD   s          r!   r   zGenerator.hypergeometric   5    	
 	
 	
 		
r#   Fc           	     *    t        | d|f|||||d|S )Nintegers)highr=   dtypeendpointr>   r?   )r   lowr   r=   r   r   r>   rD   s           r!   r   zGenerator.integers   s:     

 

 

 
	
r#   c                &    t        | d||f||d|S Nlaplacer<   r?   r   s         r!   r   zGenerator.laplace   *    )S%
.26
EK
 	
r#   c                &    t        | d||f||d|S Nlogisticr<   r?   r   s         r!   r   zGenerator.logistic   *    *c5
/3F
FL
 	
r#   c                &    t        | d||f||d|S N	lognormalr<   r?   r   meansigmar=   r>   rD   s         r!   r   zGenerator.lognormal   *    +tU
15f
HN
 	
r#   c                $    t        | d|f||d|S N	logseriesr<   r?   r   s        r!   r   zGenerator.logseries   r   r#   c                >    t        | d||f||t        |      ffd|S Nmultinomialr=   r>   extra_chunksr@   rX   r   rJ   pvalsr=   r>   rD   s         r!   r   zGenerator.multinomial   >    		

 u:-)	
 	
 		
r#   c                (    t        | d||f|||d|S )Nmultivariate_hypergeometric)r=   methodr>   r?   )r   colorsr   r=   r   r>   rD   s          r!   r   z%Generator.multivariate_hypergeometric  s7     )		

 	
 	
 		
r#   c                &    t        | d||f||d|S Nnegative_binomialr<   r?   rI   s         r!   r   zGenerator.negative_binomial  +    %q!
26v
IO
 	
r#   c                &    t        | d||f||d|S Nnoncentral_chisquarer<   r?   r   rQ   noncr=   r>   rD   s         r!   r   zGenerator.noncentral_chisquare  +    ("d
9=f
PV
 	
r#   c                (    t        | d|||f||d|S Nnoncentral_fr<   r?   r   r~   r   r   r=   r>   rD   s          r!   r   zGenerator.noncentral_f   ,    .%
;?
RX
 	
r#   c                &    t        | d||f||d|S Nnormalr<   r?   r   s         r!   r   zGenerator.normal&  r   r#   c                $    t        | d|f||d|S Nparetor<   r?   r   rB   r=   r>   rD   s        r!   r   zGenerator.pareto,      $!P$vPPPr#   c                   ddl m} | j                  dk(  rt        d      t	        |t
        j                        rt        |d      }| j                  j                  t        |            }t        | j                  |        |||      S )Nr   shuffle_slicecupyz`Generator.permutation` not supported for cupy-backed Generator objects. Use the 'numpy' array backend to call `dask.array.random.default_rng`, or pass in  `numpy.random.PCG64()`.r8   r>   )dask.array.slicingr   r0   NotImplementedError
isinstancenumbersNumberr   r4   rX   _shuffler   r   xr   indexs       r!   permutationzGenerator.permutation0  sv    4'%+  a(q(A$$SV,$$e,Q&&r#   c                $    t        | d|f||d|S Npoissonr<   r?   r   lamr=   r>   rD   s        r!   r   zGenerator.poissonC      $	3ST&SFSSr#   c                $    t        | d|f||d|S Npowerr<   r?   r   s        r!   r   zGenerator.powerG      $OfOOOr#   c                &    t        | df||||d|S )Nrandom)r=   r   outr>   r?   )r   r=   r   r   r>   rD   s         r!   r   zGenerator.randomK  s*    (
!%UF
NT
 	
r#   c                $    t        | d|f||d|S Nrayleighr<   r?   rw   s        r!   r   zGenerator.rayleighQ      $
EVVVvVVr#   c                "    t        | df||d|S Nstandard_cauchyr<   r?   r   r=   r>   rD   s       r!   r   zGenerator.standard_cauchyU      $ 1VVVvVVr#   c                "    t        | df||d|S Nstandard_exponentialr<   r?   r   s       r!   r   zGenerator.standard_exponentialY  '    (
/3F
FL
 	
r#   c                $    t        | d|f||d|S Nstandard_gammar<   r?   r   r   r=   r>   rD   s        r!   r  zGenerator.standard_gamma_  )    "E
04V
GM
 	
r#   c                "    t        | df||d|S Nstandard_normalr<   r?   r   s       r!   r  zGenerator.standard_normale  r   r#   c                $    t        | d|f||d|S N
standard_tr<   r?   rP   s        r!   r	  zGenerator.standard_ti      $bUtFUfUUr#   c                (    t        | d|||f||d|S N
triangularr<   r?   r   leftmoderightr=   r>   rD   s          r!   r  zGenerator.triangularm  ,    ,dE
8<V
OU
 	
r#   c                &    t        | d||f||d|S Nuniformr<   r?   r   r   r   r=   r>   rD   s         r!   r  zGenerator.uniforms  *    )S$
-1&
DJ
 	
r#   c                &    t        | d||f||d|S Nvonmisesr<   r?   r   mukappar=   r>   rD   s         r!   r  zGenerator.vonmisesy  *    *b%
.26
EK
 	
r#   c                &    t        | d||f||d|S Nwaldr<   r?   r   r   rx   r=   r>   rD   s         r!   r!  zGenerator.wald       $eX$vXQWXXr#   c                $    t        | d|f||d|S Nweibullr<   r?   r   s        r!   r&  zGenerator.weibull      $	1Q4Q&QQr#   c                $    t        | d|f||d|S Nzipfr<   r?   r   s        r!   r*  zGenerator.zipf      $NVNvNNr#   Nr8   )NTNr   Tr8         ?Nr8   g        r.  Nr8   )N	marginalsr8   )4r(   
__module____qualname____doc__r"   r*   propertyr0   r4   r   npr   r   r;   rH   rO   rs   rv   r|   r   r   r   r   int64r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   float64r   r   r   r  r  r	  r  r  r  r!  r&  r*   r#   r!   r   r      s   >@,
 ; ;
 ; ;
 "))%%!4R 5R "))%%!4V 5V "))%%!4U 5U "))%%!4 
"5 5"5H "))%%!4
 5

 "))%%!4W 5W "))%%!4
 5

 "))%%!4T 5T "))%%!4
 5

 "))%%!4

 5

 "))%%!4 hh
 5
, "))%%!4
 5

 "))%%!4
 5

 "))%%!4
 5

 "))%%!4T 5T "))%%!4

 5

 "))%%!4EK
 5
 "))%%!4
 5

 "))%%!4
 5

 "))%%!4
 5

 "))%%!4
 5

 "))%%!4Q 5Q "))%%!4' 5'$ "))%%!4T 5T "))%%!4P 5P "))%%!4bjjd6 
 5

 "))%%!4W 5W "))%%!4W 5W "))%%!4
 5

 "))%%!4
 5

 "))%%!4W 5W "))%%!4V 5V "))%%!4
 5

 "))%%!4
 5

 "))%%!4
 5

 "))%%!4Y 5Y "))%%!4R 5R "))%%!4O 5Or#   r   c                    t        | d      rt        |       S t        | t              r| S t        | d      rt        | j                        S t        t	        j
                  |             S )af
  
    Construct a new Generator with the default BitGenerator (PCG64).

    Parameters
    ----------
    seed : {None, int, array_like[ints], SeedSequence, BitGenerator, Generator}, optional
        A seed to initialize the `BitGenerator`. If None, then fresh,
        unpredictable entropy will be pulled from the OS. If an ``int`` or
        ``array_like[ints]`` is passed, then it will be passed to
        `SeedSequence` to derive the initial `BitGenerator` state. One may
        also pass in a `SeedSequence` instance.
        Additionally, when passed a `BitGenerator`, it will be wrapped by
        `Generator`. If passed a `Generator`, it will be returned unaltered.

    Returns
    -------
    Generator
        The initialized generator object.

    Notes
    -----
    If ``seed`` is not a `BitGenerator` or a `Generator`, a new
    `BitGenerator` is instantiated. This function does not manage a default
    global instance.

    Examples
    --------
    ``default_rng`` is the recommended constructor for the random number
    class ``Generator``. Here are several ways we can construct a random
    number generator using ``default_rng`` and the ``Generator`` class.

    Here we use ``default_rng`` to generate a random float:

    >>> import dask.array as da
    >>> rng = da.random.default_rng(12345)
    >>> print(rng)
    Generator(PCG64)
    >>> rfloat = rng.random().compute()
    >>> rfloat
    array(0.86999885)
    >>> type(rfloat)
    <class 'numpy.ndarray'>

    Here we use ``default_rng`` to generate 3 random integers between 0
    (inclusive) and 10 (exclusive):

    >>> import dask.array as da
    >>> rng = da.random.default_rng(12345)
    >>> rints = rng.integers(low=0, high=10, size=3).compute()
    >>> rints
    array([2, 8, 7])
    >>> type(rints[0])
    <class 'numpy.int64'>

    Here we specify a seed so that we have reproducible results:

    >>> import dask.array as da
    >>> rng = da.random.default_rng(seed=42)
    >>> print(rng)
    Generator(PCG64)
    >>> arr1 = rng.random((3, 3)).compute()
    >>> arr1
    array([[0.91674416, 0.91098667, 0.8765925 ],
           [0.30931841, 0.95465607, 0.17509458],
           [0.99662814, 0.75203348, 0.15038118]])

    If we exit and restart our Python interpreter, we'll see that we
    generate the same random numbers again:

    >>> import dask.array as da
    >>> rng = da.random.default_rng(seed=42)
    >>> arr2 = rng.random((3, 3)).compute()
    >>> arr2
    array([[0.91674416, 0.91098667, 0.8765925 ],
           [0.30931841, 0.95465607, 0.17509458],
           [0.99662814, 0.75203348, 0.15038118]])

    See Also
    --------
    np.random.default_rng
    capsuler    )hasattrr   r   r    r   default_bit_generator)seeds    r!   default_rngr>    sZ    d tY	D)	$		'++,,,BB4HIIr#   c                     e Zd ZdZd/dZed        Zd0dZ ee	j                  j                  d      d1d       Z ee	j                  j                  d      d1d	       Z ee	j                  j                  d      d1d
       Z ej                   e      5   ee	j                  j                  d      d2d       Zddd        ee	j                  j                  d      d3d       Z ee	j                  j                  d      d1d       Z ee	j                  j                  d      d3d       Z ee	j                  j                  d      d1d       Z ee	j                  j                  d      d4d       Z ee	j                  j                  d      d1d       Z ee	j                  j                  d      d4d       Z ee	j                  j                  d      d4d       Z ee	j                  j                  d      d4d       Z ee	j                  j                  d      d1d       Z ee	j                  j                  d      d1d       Z ee	j                  j                  d      d1d       Z ee	j                  j                  d      d1d       Z ee	j                  j                  d      d1d       Z  ee	j                  j                  d      d4d       Z! ee	j                  j                  d      d1d       Z" ee	j                  j                  d      d        Z# ee	j                  j                  d      d3d       Z$ ee	j                  j                  d      d1d       Z% ee	j                  j                  d      d5d       Z& ee	j                  j                  d      d6d        Z' ee	j                  j                  d      d1d!       Z(e(Z
 ee	j                  j                  d      d3d"       Z) ee	j                  j                  d      d1d#       Z* ee	j                  j                  d      d1d$       Z+ ee	j                  j                  d      d1d%       Z, ee	j                  j                  d      d1d&       Z- ee	j                  j                  d      d1d'       Z. ee	j                  j                  d      d1d(       Z/ ee	j                  j                  d      d1d)       Z0 ee	j                  j                  d      d4d*       Z1 ee	j                  j                  d      d1d+       Z2 ee	j                  j                  d      d1d,       Z3 ee	j                  j                  d      d1d-       Z4 ee	j                  j                  d      d1d.       Z5y# 1 sw Y   xY w)7RandomStatea  
    Mersenne Twister pseudo-random number generator

    This object contains state to deterministically generate pseudo-random
    numbers from a variety of probability distributions.  It is identical to
    ``np.random.RandomState`` except that all functions also take a ``chunks=``
    keyword argument.

    Parameters
    ----------
    seed: Number
        Object to pass to RandomState to serve as deterministic seed
    RandomState: Callable[seed] -> RandomState
        A callable that, when provided with a ``seed`` keyword provides an
        object that operates identically to ``np.random.RandomState`` (the
        default).  This might also be a function that returns a
        ``mkl_random``, or ``cupy.random.RandomState`` object.

    Examples
    --------
    >>> import dask.array as da
    >>> state = da.random.RandomState(1234)  # a seed
    >>> x = state.normal(10, 0.1, size=3, chunks=(2,))
    >>> x.compute()
    array([10.01867852, 10.04812289,  9.89649746])

    See Also
    --------
    np.random.RandomState
    Nc                    t         j                  j                  |      | _        |t        j                  | _        y || _        y r   )r5  r   r@  _numpy_stater   _RandomState)r   r=  r@  s      r!   r"   zRandomState.__init__  s;    II11$73>3F#// 	LW 	r#   c                z    t        | j                        j                  d      d   }t        j                  |      S r,   )r   rC  r.   r2   r3   )r   r0   s     r!   r4   zRandomState._backend  s5     !!2!2399#>qA&&}55r#   c                :    | j                   j                  |       y r   )rB  r=  )r   r=  s     r!   r=  zRandomState.seed  s    t$r#   r5   r6   c                &    t        | d||f||d|S r:   r?   rA   s         r!   r;   zRandomState.beta  rE   r#   c                &    t        | d||f||d|S rG   r?   rI   s         r!   rH   zRandomState.binomial  rL   r#   c                $    t        | d|f||d|S rN   r?   rP   s        r!   rO   zRandomState.chisquare#  rR   r#   c                   t        | ||||d|      \  }}}}}}}}t        t        |       }	t        t	        |	      | j
                        }
dt        |
|||||      z  }t        |ggd |D         }t        ||
|	      D ci c]  \  }}}|t        |t        |||||       }}}}t        j                  |||      }t        ||||      S c c}}}w )Nr   rT   c              3  D   K   | ]  }t        t        |              y wr   rV   rY   s     r!   r\   z%RandomState.choice.<locals>.<genexpr><  s     $EU3r7^$Er]   r^   r`   )rb   rc   r   r   rX   rB  r   re   r	   
_choice_rsr   rg   r   )r   rB   r=   rh   rK   r>   ri   ra   r_   rk   
state_datarm   rn   ro   staterq   rr   s                    r!   rs   zRandomState.choice)  s    (aw1fM	 &)*E*3u:t7H7HIJ(8D&!Wa, D D6F$Ef$EFD '*$
E&B "Aud 4:uawBBC 
 #33cE f488s   !Cc                $    t        | d|f||d|S ru   r?   rw   s        r!   rv   zRandomState.exponentialG  ry   r#   c                &    t        | d||f||d|S r{   r?   r}   s         r!   r|   zRandomState.fM  r   r#   c                &    t        | d||f||d|S r   r?   r   s         r!   r   zRandomState.gammaQ  r   r#   c                $    t        | d|f||d|S r   r?   r   s        r!   r   zRandomState.geometricW  r   r#   c                &    t        | d||f||d|S r   r?   r   s         r!   r   zRandomState.gumbel[  r   r#   c                (    t        | d|||f||d|S r   r?   r   s          r!   r   zRandomState.hypergeometrica  r   r#   c                &    t        | d||f||d|S r   r?   r   s         r!   r   zRandomState.laplacen  r   r#   c                &    t        | d||f||d|S r   r?   r   s         r!   r   zRandomState.logistict  r   r#   c                &    t        | d||f||d|S r   r?   r   s         r!   r   zRandomState.lognormalz  r   r#   c                $    t        | d|f||d|S r   r?   r   s        r!   r   zRandomState.logseries  r   r#   c                >    t        | d||f||t        |      ffd|S r   r   r   s         r!   r   zRandomState.multinomial  r   r#   c                &    t        | d||f||d|S r   r?   rI   s         r!   r   zRandomState.negative_binomial  r   r#   c                &    t        | d||f||d|S r   r?   r   s         r!   r   z RandomState.noncentral_chisquare  r   r#   c                (    t        | d|||f||d|S r   r?   r   s          r!   r   zRandomState.noncentral_f  r   r#   c                &    t        | d||f||d|S r   r?   r   s         r!   r   zRandomState.normal  r   r#   c                $    t        | d|f||d|S r   r?   r   s        r!   r   zRandomState.pareto  r   r#   c                    ddl m} t        |t        j                        rt        |d      }t        j
                  t        |            }| j                  j                  |        |||      S )Nr   r   r8   r   )
r   r   r   r   r   r   r5  rX   rB  rj   r   s       r!   r   zRandomState.permutation  sR    4a(q(A		#a&!!!%(Q&&r#   c                $    t        | d|f||d|S r   r?   r   s        r!   r   zRandomState.poisson  r   r#   c                $    t        | d|f||d|S r   r?   r   s        r!   r   zRandomState.power  r   r#   c                (    t        | d||f|||d|S )Nrandint)r=   r>   r   r?   )r   r   r   r=   r>   r   rD   s          r!   rb  zRandomState.randint  s,    )S$
-1&
QW
 	
r#   c                &    t        | d||f||d|S )Nrandom_integersr<   r?   r  s         r!   rd  zRandomState.random_integers  s+    #S$
59&
LR
 	
r#   c                "    t        | df||d|S )Nrandom_sampler<   r?   r   s       r!   rf  zRandomState.random_sample  s    $Td6TVTTr#   c                $    t        | d|f||d|S r   r?   rw   s        r!   r   zRandomState.rayleigh  r   r#   c                "    t        | df||d|S r   r?   r   s       r!   r   zRandomState.standard_cauchy  r   r#   c                "    t        | df||d|S r   r?   r   s       r!   r   z RandomState.standard_exponential  r   r#   c                $    t        | d|f||d|S r   r?   r  s        r!   r  zRandomState.standard_gamma  r  r#   c                "    t        | df||d|S r  r?   r   s       r!   r  zRandomState.standard_normal  r   r#   c                $    t        | d|f||d|S r  r?   rP   s        r!   r	  zRandomState.standard_t  r
  r#   c                "    t        | df||d|S )Ntomaxintr<   r?   r   s       r!   rn  zRandomState.tomaxint  s    $
OfOOOr#   c                (    t        | d|||f||d|S r  r?   r  s          r!   r  zRandomState.triangular  r  r#   c                &    t        | d||f||d|S r  r?   r  s         r!   r  zRandomState.uniform  r  r#   c                &    t        | d||f||d|S r  r?   r  s         r!   r  zRandomState.vonmises  r  r#   c                &    t        | d||f||d|S r   r?   r"  s         r!   r!  zRandomState.wald  r#  r#   c                $    t        | d|f||d|S r%  r?   r   s        r!   r&  zRandomState.weibull  r'  r#   c                $    t        | d|f||d|S r)  r?   r   s        r!   r*  zRandomState.zipf  r+  r#   )NNr   r,  )NTNr8   r-  r/  )NNr8   l)NNr8   )6r(   r1  r2  r3  r"   r4  r4   r=  r   r5  r   r@  r;   rH   rO   
contextlibsuppressAttributeErrorrs   rv   r|   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   rb  rd  rf  r   r   r   r  r  r	  rn  r  r  r  r!  r&  r*  r8  r#   r!   r@  r@    s   >
 6 6% "))''A6R 7R "))''A6V 7V "))''A6U 7U 
		^	, 9	bii++	:	9 
;	99@ "))''A6
 7

 "))''A6W 7W "))''A6
 7

 "))''A6T 7T "))''A6
 7

 "))''A6

 7

 "))''A6
 7

 "))''A6
 7

 "))''A6
 7

 "))''A6T 7T "))''A6

 7

 "))''A6
 7

 "))''A6
 7

 "))''A6
 7

 "))''A6
 7

 "))''A6Q 7Q "))''A6' 7' "))''A6T 7T "))''A6P 7P "))''A6
 7

 "))''A6
 7

 "))''A6U 7U F"))''A6W 7W "))''A6W 7W "))''A6
 7

 "))''A6
 7

 "))''A6W 7W "))''A6V 7V "))''A6P 7P "))''A6
 7

 "))''A6
 7

 "))''A6
 7

 "))''A6Y 7Y "))''A6R 7R "))''A6O 7OM9 9s   &WW!r@  c                    t        |       j                  d      d   }t        j                  |      }|j                  j                  |       S r,   )r   r.   r2   r3   r   r>  )rp   backend_namebackend_libs      r!   _rng_from_bitgenr|    sE     F#))#.q1L)),7K))&11r#   c                >    t        |       }|j                  ||      S )N)ri   )r|  rj   )r    r   ri   rM  s       r!   r   r     s    ]+E===&&r#   c                    | j                   j                  |      }|D cg c]  } t        |       |       }}|S c c}w r   )	_seed_seqspawntype)rp   	n_bitgensseedsr=  rl   s        r!   rd   rd     s@    ""9-E.34d|tF|D!4G4N 5s   <c                    t        |t        j                  j                        r | |      }t	        |      } t        | |      } ||d|i|S )z$Apply random module method with seedr=   )r   r5  r   SeedSequencer|  getattr)rngfuncnamerp   r=   argsrD   funcs          r!   _apply_random_funcr  $  sJ    &"))001V
6
"C3!D+D+F++r#   c                b    | t         j                  }  | |      }t        ||      } ||d|i|S )z"Apply RandomState method with seedr=   )r   r@  r  )r@  r  rL  r=   r  rD   rM  r  s           r!   _apply_randomr  -  s>    -99
#E5(#D+D+F++r#   c                F    t        |       }|j                  ||||||      S )N)r=   rh   rK   ri   rj   )r|  rs   )rL  rB   r=   rh   rK   ri   rj   rM  s           r!   rf   rf   6  s'    Z(E<<gw<WWr#   c                V    t        j                  |       }|j                  ||||      S )N)r=   rh   rK   )r   r@  rs   )rL  rB   r=   rh   rK   rM  s         r!   rK  rK  ;  s)    #//
;E<<g<;;r#   c                   g }t        |t              rt        | t              rQ| j                  dk(  rt	        d      | j
                  j                  j                         j                  ddd       }nrt        | t              rW|| j
                  j                  dg      n|}	| j
                  j                  j                         j                  dd|	      }nt        d      |}
|dk  rt        d      t        |      }|j                  |j                        }|j                  }|j                   dk7  rt        d	      t#        |      }
|j%                  |       t'        |j)                         d         }|t        |t*              sKt-        ||
      }t/        j0                  |j3                         ddd      st        d      t        |      }n|j                  |j                        }|j                   dk7  rt        d      t#        |      |
k7  rt        d      |j%                  |       t'        |j)                         d         }|d}nt        |t4        t6        f      s|f}|dk7  rt        d      t9        ||t.        j:                        }|st#        |d         dkD  rd}t	        |      ||||||||fS )Nr   z3`choice` not supported for cupy-backed `Generator`.r5   r8  )r=   rK   zUnknown generator classr   za must be greater than 0za must be one dimensional)likegHz>)rtolatolzprobabilities do not sum to 1zp must be one dimensionalza and p must have the same sizez)axis must be 0 since a is one dimensionalr   z]replace=False is not currently supported for dask.array.choice with multi-chunk output arrays)r   r   r   r0   r   r4   r   r>  rs   r@  array
ValueErrorr   rechunkr   _metandimrX   appendr
   __dask_keys__r   r   r5  isclosesumtuplerc   r   r7  )rM  rB   r=   rh   rK   ri   r>   r_   ra   dummy_plen_aerr_msgs               r!   rb   rb   @  sw   L!XeY'""f,)I  >>((446==abD=QD{+ 45=enn**A3/aG>>((446==abG=TD677q5788AJIIaggww66Q;899AAAOO%a() 	}!U# QQ'A::aeegqt!< !@AA
A		!''"A66Q;899q6U?>??AAOO%a()|udm,wqyDEEfd"**=Fs6!9~) 	
 "'**dGQfdL@@r#   r8   r8  r   c               N   |t        |t        t        f      s|f}t        t        ||j	                               D ch c].  }t        |t
        t        j                  f      r|j                  0 c}      }||j                  |       t        | }t        |||j                  dt        j                              }t        |      }	d }
i }i }g }g }t        |      D ]  \  }}t        |t        j                  t
        f      r |
|||      }t        |t
              r!|j                  |       |j                   ||<   n2t        |t        j                        rdt#        |       }|||<   |||<   |j                  |t        d |j                  D                        |j                  |        i }|j%                         D ]  \  }}t        |t        j                  t
        f      r |
|||      }t        |t
              r!|j                  |       |j                   ||<   n2t        |t        j                        rdt#        |       }|||<   |||<   |t        d |j                  D                 ||<   |||<    t        t'        |       }t        | t(              r_t+        | j,                  t/        |            }t#        |      }|D cg c]  }|j0                   }}t2        }t5        | j,                        }nXt        | t6              r=t9        t/        |      | j:                        }t#        |      }t<        }| j>                  }ntA        d      t#        |||||      }| d| }t'        |gg|D cg c]  }tC        t/        |             c}d	ggt/        |      z  z    }t'        |D cg c]  }tC        t/        |             c} }tE        ||||	|      D ]f  \  }}}}} g }!t        |      D ]  \  }}||vr|!j                  |       t        |t
              r"|!j                  tG        ||   f| z                Nt        |t        j                        r@tI        d
t#        ||   |       tJ        tG        ||         |      }"|!j                  |"       tA        d       i }#|j%                         D ]`  \  }$}|$|vr||#|$<   t        |t
              r||$   f| z   |#|$<   -t        |t        j                        rtJ        ||$   |f|#|$<   WtA        d       tI        ||||||tM        |!      tM        |#            ||<   i  |||dt/        |      z  ||      }%tO        jP                  |||      }&t        |&|||z   |%      S c c}w c c}w c c}w c c}w )zWrap numpy random function to produce dask.array random function
    extra_chunks should be a chunks tuple to append to the end of chunks
    r   r  c                    t        | t              rt        | |      j                  |      S t        | t        j
                        r)t	        j                  t	        j                  | |            S t        d      )Nz!Unknown object type for broadcast)r   r   r   r  r5  ndarrayascontiguousarray	TypeError)arr   r>   s      r!   _broadcast_anyz"_wrap_func.<locals>._broadcast_any  sZ    b% E*226::BJJ'''E(BCC?@@r#   zarray-c              3      K   | ]  }d   ywr   Nr8  rZ   _s     r!   r\   z_wrap_func.<locals>.<genexpr>  s     &;Qq&;   c              3      K   | ]  }d   ywr  r8  r  s     r!   r\   z_wrap_func.<locals>.<genexpr>  s     (=q(=r  z:Unknown object type: Not a Generator and Not a RandomState-r   zgetitem-zUnknown object type in argszUnknown object type in kwargsr   r^   r`   ))r   r  rc   r   valuesr   r5  r  r   r  r   r   getr7  r   	enumeraterm   r   itemsr   r   rd   r   rX   r  r  r  r@  r   rB  r  rC  r  rW   re   r
   r	   r   r   r   rg   )'r  r  r=   r>   r   r  rD   r  shapesslicesr  rq   lookup
small_argsr_   iresrm   small_kwargskeyrk   rl   bitgen_token_bitgenfunc_appliergentokenr[   rn   blocksrp   slcblockargt_kwrgro   ra   rr   s'                                          r!   r@   r@     sb    
4% ?w D&--/2	
"ubjj12 HH	
F dV$Djj"**-F
  'FA CFJL4 "2b2::u-. T62C#u%##C(HHq	C,/ q	D	b&;"((&;!;<=b!" L<<> #Rb2::u-. T62C#u%##C(!hhsC,/"sD	 "5(=BHH(=#= >L "L# &!"E#y! !3!3SZ@(4;<7$$<<)3%%&	C	%#CJ0@0@A($TUU\4v>EZq D	,23b5R>3sec,>O6OOD 7"uSW~78F),T7E66)R &
%VT3t_ 	CEAr

2b%(JJwq	|e';<=BJJ/"8F1Is#;"<=q	*	B JJrN#$ABB	C  \\^ 		EEArQb%(%aylU2DGBJJ/&q	37DG#$CDD		E 	
C;&
P s4yD ++D#LQEf|3$??I	
@ = 47s   3VV=V
8V"zdict[str, RandomState]_cached_statesc                      fd}t        t               j                  |_        t        t               j                  |_        |S )Nc                     t         j                  }t        5  	 t        |   }d d d         t              | i |S # t        $ r t               xt        |<   }Y 8w xY w# 1 sw Y   =xY wr   )r   backend_cached_states_lockr  KeyErrorr@  r  )r  rD   r  rM  attrs       r!   wrapperz_make_api.<locals>.wrapper%  sr    %--  	<<&s+	<
 $wud#T4V44  <.9m;s#e<	< 	<s&   A	=AAAAA()r  r@  r(   r3  )r  r  s   ` r!   	_make_apir  $  s8    5 {D1::Gk4088GONr#   r=  r;   rH   rO   rs   rv   r|   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   rf  rb  rd  r   r   r   r  r  r	  r  r  r  r!  r&  r*  r   r  )`
__future__r   rv  r2   r   	itertoolsr   r   r   operatorr   	threadingr   numpyr5  dask._task_specr	   r
   r   dask.array.backendsr   dask.array.corer   r   r   r   r   r   dask.array.creationr   dask.array.utilsr   	dask.baser   dask.highlevelgraphr   
dask.utilsr   r   r   r   r>  r@  r|  r   rd   r  r  rf   rK  rb   r@   r  __annotations__r  r  r=  r;   rH   rO   rs   rv   r|   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   rf  r   rb  rd  r   r   r   r  r  r	  r  r  r  r!  r&  r*  r8  r#   r!   <module>r     sj   "    $     6 6 7  ' )  . @ @kO kO\\J~cO cOL	2'
,,X
<
CAN  $FN@b *,& +f  Z k"		8	&cN'k"		8	+,
I
Z k"	k"	&12  !78 (	8		8	&
I
'/*	?	#
I
-.Z -. !78 +,-.|$
|$

I
Z 
I
r#   