tessl/pypi-cupy-cuda111

CuPy: NumPy & SciPy for GPU - A NumPy/SciPy-compatible array library for GPU-accelerated computing with Python, specifically built for CUDA 11.1

—

Pending

Overview

Eval results

Files

Random Number Generation

Name: tessl/pypi-cupy-cuda111
Author: tessl

GPU-accelerated random number generation with comprehensive distribution support and modern generator APIs. CuPy provides both legacy and modern random number generation interfaces optimized for GPU execution, supporting all major statistical distributions and advanced generator management.

Capabilities

Generator Management

Modern generator API with pluggable bit generators and comprehensive state management for reproducible random number generation.

def default_rng(seed=None):
    """
    Construct new Generator with default BitGenerator (XORWOW).
    
    Parameters:
    - seed: None, int, array_like, SeedSequence, BitGenerator, or Generator
           Seed for initializing the BitGenerator
    
    Returns:
    - Generator: Initialized generator object
    """

class Generator:
    """Modern random number generator with pluggable bit generators"""
    def __init__(self, bit_generator): ...
    def random(self, size=None, dtype=float32, out=None): ...
    def integers(self, low, high=None, size=None, dtype=int64, endpoint=False): ...
    def choice(self, a, size=None, replace=True, p=None, axis=0, shuffle=True): ...

class BitGenerator:
    """Base class for bit generators"""
    def random_raw(self, size=None, output=True): ...
    
class XORWOW(BitGenerator):
    """XORWOW bit generator (CuPy default)"""
    def __init__(self, seed=None): ...

class MRG32k3a(BitGenerator):
    """MRG32k3a bit generator for high-quality random numbers"""
    def __init__(self, seed=None): ...

class Philox4x3210(BitGenerator):
    """Philox4x32-10 bit generator for parallel applications"""
    def __init__(self, seed=None): ...

Legacy Random State API

Compatible with NumPy's legacy random API for existing code migration.

class RandomState:
    """Legacy random number generator compatible with NumPy"""
    def __init__(self, seed=None): ...
    def seed(self, seed=None): ...
    def get_state(self): ...
    def set_state(self, state): ...

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

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

def seed(seed=None):
    """Seed the global random number generator"""

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

Simple Random Data

Basic random data generation functions for common use cases.

def rand(*args):
    """
    Random values in a given shape from uniform distribution [0, 1).
    
    Parameters:
    - *args: int, shape dimensions
    
    Returns:
    - ndarray: Random samples from uniform distribution
    """

def randn(*args):
    """
    Random samples from standard normal distribution.
    
    Parameters:
    - *args: int, shape dimensions
    
    Returns:
    - ndarray: Random samples from N(0, 1)
    """

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

def random_sample(size=None):
    """Random floats in [0.0, 1.0)"""

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

Continuous Distributions

Comprehensive support for continuous probability distributions commonly used in statistics and machine learning.

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

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

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

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

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

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

def f(dfnum, dfden, size=None):
    """Draw samples from F 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 lognormal(mean=0.0, sigma=1.0, size=None):
    """Draw samples from log-normal distribution"""

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

def power(a, size=None):
    """Draw samples from power 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 standard Student's t distribution"""

def triangular(left, mode, right, size=None):
    """Draw 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 distribution"""

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

Discrete Distributions

Support for discrete probability distributions for counting and categorical data.

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

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

def geometric(p, size=None):
    """Draw samples from geometric distribution"""

def hypergeometric(ngood, nbad, nsample, size=None):
    """Draw samples from hypergeometric distribution"""

def negative_binomial(n, p, size=None):
    """Draw samples from negative binomial 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 of each outcome
    - size: int or tuple, output shape
    
    Returns:
    - ndarray: Drawn samples
    """

Multivariate Distributions

Support for multivariate probability distributions for correlated random variables.

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

def dirichlet(alpha, size=None):
    """
    Draw samples from Dirichlet distribution.
    
    Parameters:
    - alpha: sequence of floats, concentration parameters
    - size: int or tuple, output shape
    
    Returns:
    - ndarray: Drawn samples
    """

Advanced Statistical Distributions

Specialized distributions for advanced statistical modeling and scientific applications.

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 gumbel(loc=0.0, scale=1.0, size=None):
    """Draw samples from Gumbel distribution"""

Permutations and Shuffling

Functions for generating permutations and shuffling arrays for randomization tasks.

def shuffle(x):
    """
    Modify sequence in-place by shuffling its contents.
    
    Parameters:
    - x: array_like, sequence to shuffle
    
    Notes:
    - Modifies input array in-place
    - Multi-dimensional arrays shuffled along first axis only
    """

def permutation(x):
    """
    Randomly permute sequence or generate permuted range.
    
    Parameters:
    - x: int or array_like, if int, generates permutation of range(x)
    
    Returns:
    - ndarray: Permuted sequence
    """

Usage Examples

Basic Random Data Generation

import cupy as cp

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

# Generate random arrays
random_uniform = cp.random.rand(1000, 1000)
random_normal = cp.random.randn(500, 500) 
random_integers = cp.random.randint(0, 100, size=(100,))

# Generate from specific distributions
normal_data = cp.random.normal(loc=5.0, scale=2.0, size=(1000,))
exponential_data = cp.random.exponential(scale=2.0, size=(1000,))

Modern Generator API

import cupy as cp

# Create generator with specific bit generator
rng = cp.random.default_rng(seed=42)

# Generate random data
data = rng.random((1000, 1000))
integers = rng.integers(0, 100, size=(100,))
choice_data = rng.choice([1, 2, 3, 4, 5], size=50, replace=True)

# Use different bit generators for different quality/performance trade-offs
fast_rng = cp.random.Generator(cp.random.XORWOW(42))
quality_rng = cp.random.Generator(cp.random.MRG32k3a(42))
parallel_rng = cp.random.Generator(cp.random.Philox4x3210(42))

Statistical Sampling

import cupy as cp

# Sample from various distributions for statistical modeling
normal_samples = cp.random.normal(0, 1, 10000)
gamma_samples = cp.random.gamma(2.0, 2.0, 10000)
beta_samples = cp.random.beta(2, 5, 10000)

# Multivariate sampling
mean = cp.array([0, 0])
cov = cp.array([[1, 0.5], [0.5, 1]])
mvn_samples = cp.random.multivariate_normal(mean, cov, 1000)

# Discrete distributions for count data
poisson_samples = cp.random.poisson(3.0, 10000)
binomial_samples = cp.random.binomial(10, 0.3, 10000)

Notes

All random number generation occurs on GPU, providing significant performance improvements for large-scale random data generation
CuPy's random number generators are independent of NumPy's generators, allowing separate reproducible streams
For ROCm platforms, Generator API requires ROCm ≥ 4.3
Bit generators provide different trade-offs between speed, quality, and parallel generation capabilities
Legacy RandomState API provided for NumPy compatibility, but modern Generator API recommended for new code

Install with Tessl CLI