Random Number Generation

class RandomState:
    """
    Legacy random number generator for backward compatibility.
    
    Parameters:
    - seed: int or None, random seed
    """
    def __init__(self, seed=None): ...
    
    def seed(self, seed=None):
        """Initialize random number generator state."""
    
    def get_state(self):
        """Return current random number generator state."""
    
    def set_state(self, state):
        """Set random number generator state."""

class Generator:
    """
    Modern random number generator with improved algorithms.
    
    Parameters:
    - bit_generator: BitGenerator instance
    """
    def __init__(self, bit_generator): ...

class BitGenerator:
    """Base class for bit generators used by Generator."""

class XORWOW(BitGenerator):
    """XORWOW bit generator (CuPy default)."""

class MRG32k3a(BitGenerator):
    """MRG32k3a bit generator for high-quality randomness."""

class Philox4x3210(BitGenerator):  
    """Philox 4x32x10 counter-based bit generator."""

def default_rng(seed=None):
    """
    Create default random number generator.
    
    Parameters:
    - seed: int or None, random seed
    
    Returns:
    cupy.random.Generator: Random number generator instance
    """

def get_random_state():
    """Get global RandomState instance."""

def set_random_state(rs):
    """Set global RandomState instance."""

def seed(seed=None):
    """Set random seed for global RandomState."""

def reset_states():
    """Reset all random number generator states."""

def random(size=None):
    """
    Generate random floats in [0.0, 1.0).
    
    Parameters:
    - size: int or tuple, output shape
    
    Returns:
    cupy.ndarray: Random floats
    """

def rand(*args):
    """
    Generate random floats in [0.0, 1.0) with given shape.
    
    Parameters:
    - args: ints, dimensions of output array
    
    Returns:
    cupy.ndarray: Random floats with shape args
    """

def randn(*args):
    """
    Generate samples from standard normal distribution.
    
    Parameters:
    - args: ints, dimensions of output array
    
    Returns:
    cupy.ndarray: Standard normal random numbers
    """

def randint(low, high=None, size=None, dtype=int):
    """
    Generate random integers from low (inclusive) to high (exclusive).
    
    Parameters:
    - low: int, lowest (signed) integer to draw, or highest if high=None
    - high: int or None, highest (signed) integer to draw
    - size: int or tuple, output shape
    - dtype: data type, output data type
    
    Returns:
    cupy.ndarray: Random integers
    """

def random_sample(size=None):
    """Generate random floats in [0.0, 1.0) (alias for random)."""

def ranf(size=None):
    """Generate random floats in [0.0, 1.0) (alias for random)."""

def sample(size=None):
    """Generate random floats in [0.0, 1.0) (alias for random)."""

def choice(a, size=None, replace=True, p=None):
    """
    Generate random sample from array.
    
    Parameters:
    - a: array-like or int, if int, equivalent to arange(a)
    - size: int or tuple, output shape
    - replace: bool, whether sampling is with replacement
    - p: array-like, probabilities for each element (must sum to 1)
    
    Returns:
    cupy.ndarray: Random samples from a
    """

def bytes(length):
    """
    Generate random bytes (NumPy wrapper).
    
    Parameters:
    - length: int, number of bytes
    
    Returns:
    bytes: Random byte string
    """

def binomial(n, p, size=None):
    """
    Draw samples from binomial distribution.
    
    Parameters:
    - n: int or array-like, number of trials
    - p: float or array-like, probability of success in each trial
    - size: int or tuple, output shape
    
    Returns:
    cupy.ndarray: Samples from binomial distribution
    """

def geometric(p, size=None):
    """
    Draw samples from geometric distribution.
    
    Parameters:
    - p: float or array-like, probability of success
    - size: int or tuple, output shape
    
    Returns:
    cupy.ndarray: Samples from geometric distribution
    """

def hypergeometric(ngood, nbad, nsample, size=None):
    """
    Draw samples from hypergeometric distribution.
    
    Parameters:
    - ngood: int or array-like, number of good items
    - nbad: int or array-like, number of bad items  
    - nsample: int or array-like, number of items sampled
    - size: int or tuple, output shape
    
    Returns:
    cupy.ndarray: Samples from hypergeometric distribution
    """

def negative_binomial(n, p, size=None):
    """Draw samples from negative binomial distribution."""

def poisson(lam=1.0, size=None):
    """
    Draw samples from Poisson distribution.
    
    Parameters:
    - lam: float or array-like, expected number of events
    - size: int or tuple, output shape
    
    Returns:
    cupy.ndarray: Samples from Poisson distribution
    """

def power(a, size=None):
    """Draw samples from power distribution."""

def zipf(a, size=None):
    """Draw samples from Zipf distribution."""

def logseries(p, size=None):
    """Draw samples from logarithmic series distribution."""

def multinomial(n, pvals, size=None):
    """
    Draw samples from multinomial distribution.
    
    Parameters:
    - n: int, number of trials
    - pvals: sequence of floats, probabilities (must sum to 1)
    - size: int or tuple, output shape
    
    Returns:
    cupy.ndarray: Samples from multinomial distribution
    """

def normal(loc=0.0, scale=1.0, size=None):
    """
    Draw samples from normal (Gaussian) distribution.
    
    Parameters:
    - loc: float or array-like, mean of distribution
    - scale: float or array-like, standard deviation  
    - size: int or tuple, output shape
    
    Returns:
    cupy.ndarray: Samples from normal distribution
    """

def uniform(low=0.0, high=1.0, size=None):
    """
    Draw samples from uniform distribution.
    
    Parameters:
    - low: float or array-like, lower boundary
    - high: float or array-like, upper boundary
    - size: int or tuple, output shape
    
    Returns:
    cupy.ndarray: Samples from uniform distribution
    """

def exponential(scale=1.0, size=None):
    """
    Draw samples from exponential distribution.
    
    Parameters:
    - scale: float or array-like, scale parameter (1/rate)
    - size: int or tuple, output shape
    
    Returns:
    cupy.ndarray: Samples from exponential distribution
    """

def gamma(shape, scale=1.0, size=None):
    """
    Draw samples from gamma distribution.
    
    Parameters:
    - shape: float or array-like, shape parameter
    - scale: float or array-like, scale parameter
    - size: int or tuple, output shape
    
    Returns:
    cupy.ndarray: Samples from gamma distribution
    """

def beta(a, b, size=None):
    """
    Draw samples from beta distribution.
    
    Parameters:
    - a: float or array-like, alpha parameter
    - b: float or array-like, beta parameter
    - size: int or tuple, output shape
    
    Returns:
    cupy.ndarray: Samples from beta distribution
    """

def chisquare(df, size=None):
    """Draw samples from chi-square distribution."""

def f(dfnum, dfden, size=None):
    """Draw samples from F distribution."""

def lognormal(mean=0.0, sigma=1.0, size=None):
    """Draw samples from log-normal distribution."""

def laplace(loc=0.0, scale=1.0, size=None):
    """Draw samples from Laplace distribution."""

def logistic(loc=0.0, scale=1.0, size=None):
    """Draw samples from logistic distribution."""

def pareto(a, size=None):
    """Draw samples from Pareto distribution."""

def rayleigh(scale=1.0, size=None):
    """Draw samples from Rayleigh distribution."""

def standard_cauchy(size=None):
    """Draw samples from standard Cauchy distribution."""

def standard_exponential(size=None):
    """Draw samples from standard exponential distribution."""

def standard_gamma(shape, size=None):
    """Draw samples from standard gamma distribution."""

def standard_normal(size=None):
    """Draw samples from standard normal distribution."""

def standard_t(df, size=None):
    """Draw samples from Student's t distribution."""

def triangular(left, mode, right, size=None):
    """
    Draw samples from triangular distribution.
    
    Parameters:
    - left: float or array-like, lower limit
    - mode: float or array-like, mode value
    - right: float or array-like, upper limit
    - size: int or tuple, output shape
    
    Returns:
    cupy.ndarray: Samples from triangular distribution
    """

def vonmises(mu, kappa, size=None):
    """Draw samples from von Mises distribution."""

def wald(mean, scale, size=None):
    """Draw samples from Wald (inverse Gaussian) distribution."""

def weibull(a, size=None):
    """Draw samples from Weibull distribution."""

def gumbel(loc=0.0, scale=1.0, size=None):
    """Draw samples from Gumbel distribution."""

def noncentral_chisquare(df, nonc, size=None):
    """Draw samples from noncentral chi-square distribution."""

def noncentral_f(dfnum, dfden, nonc, size=None):
    """Draw samples from noncentral F distribution."""

def multivariate_normal(mean, cov, size=None, check_valid='warn', tol=1e-8):
    """
    Draw samples from multivariate normal distribution.
    
    Parameters:
    - mean: array-like, mean of distribution (N,)
    - cov: array-like, covariance matrix (N, N)
    - size: int or tuple, output shape
    - check_valid: {'warn', 'raise', 'ignore'}, behavior for invalid covariance
    - tol: float, tolerance for checking covariance matrix
    
    Returns:
    cupy.ndarray: Samples from multivariate normal (..., N)
    """

def dirichlet(alpha, size=None):
    """
    Draw samples from Dirichlet distribution.
    
    Parameters:
    - alpha: array-like, concentration parameters
    - size: int or tuple, output shape
    
    Returns:
    cupy.ndarray: Samples from Dirichlet distribution
    """

def shuffle(x):
    """
    Modify sequence by shuffling contents in-place.
    
    Parameters:
    - x: cupy.ndarray, array to shuffle along first axis
    
    Returns:
    None: Modifies x in-place
    """

def permutation(x):
    """
    Return random permutation of sequence or range.
    
    Parameters:
    - x: int or array-like, if int, permutation of arange(x)
    
    Returns:
    cupy.ndarray: Permuted sequence
    """

import cupy as cp

# Set random seed for reproducibility
cp.random.seed(42)

# Generate basic random arrays
random_floats = cp.random.random((1000, 1000))
random_ints = cp.random.randint(0, 100, size=(500, 500))
normal_data = cp.random.normal(0, 1, size=10000)

# Using the modern Generator interface
rng = cp.random.default_rng(seed=12345)
better_random = rng.random((100, 100))

import cupy as cp

# Sample from various distributions
uniform_samples = cp.random.uniform(-1, 1, size=1000)
exponential_samples = cp.random.exponential(2.0, size=1000)
gamma_samples = cp.random.gamma(2.0, 2.0, size=1000)

# Discrete distributions
binomial_trials = cp.random.binomial(10, 0.3, size=1000)
poisson_events = cp.random.poisson(5.0, size=1000)

# Multivariate normal
mean = cp.array([0, 0])
cov = cp.array([[1, 0.5], [0.5, 1]])
mvn_samples = cp.random.multivariate_normal(mean, cov, size=500)

import cupy as cp

# Multiple random number generators
rng1 = cp.random.default_rng(seed=1)
rng2 = cp.random.default_rng(seed=2)

# Independent random streams
stream1_data = rng1.normal(0, 1, size=1000)
stream2_data = rng2.normal(0, 1, size=1000)

# Random choice with probabilities  
categories = cp.array(['A', 'B', 'C', 'D'])
probabilities = cp.array([0.4, 0.3, 0.2, 0.1])
choices = cp.random.choice(4, size=1000, p=probabilities)

# Shuffling arrays
data = cp.arange(100)
cp.random.shuffle(data)  # In-place shuffle

# Permutations
permuted = cp.random.permutation(100)

import cupy as cp

# Generate large arrays efficiently
large_random = cp.random.random((10000, 10000))

# Memory pool management with random generation
mempool = cp.get_default_memory_pool()
with mempool:
    random_data = cp.random.normal(0, 1, size=(5000, 5000))
    processed = cp.sin(random_data) + cp.cos(random_data)