tessl/pypi-cupy-cuda12x

CuPy is a NumPy/SciPy-compatible array library for GPU-accelerated computing with Python

—

Pending

Overview

Eval results

Files

Random Numbers

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

GPU-accelerated random number generation compatible with numpy.random. CuPy provides both legacy RandomState interface and modern Generator API with multiple bit generators optimized for GPU architectures.

Capabilities

Random Generator Management

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

    Parameters:
    - seed: random seed value

    Returns:
    None
    """

def get_random_state():
    """Get current random state."""

def set_random_state(state):
    """Set random state."""

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

def default_rng(seed=None):
    """
    Construct new Generator with default BitGenerator (XORWOW).

    Parameters:
    - seed: seed for initialization

    Returns:
    Generator: initialized generator object
    """

class RandomState:
    """
    Random state container (legacy interface).

    Parameters:
    - seed: random seed value
    """
    def __init__(self, seed=None): ...

Modern Generator API

class Generator:
    """
    Modern random number generator.

    Parameters:
    - bit_generator: underlying bit generator
    """
    def __init__(self, bit_generator): ...

class BitGenerator:
    """Base class for bit generators."""

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

    Parameters:
    - seed: seed value
    """
    def __init__(self, seed=None): ...

class MRG32k3a:
    """
    MRG32k3a bit generator.

    Parameters:
    - seed: seed value
    """
    def __init__(self, seed=None): ...

class Philox4x3210:
    """
    Philox4x32 bit generator.

    Parameters:
    - seed: seed value
    """
    def __init__(self, seed=None): ...

Basic Random Sampling

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

    Parameters:
    - size: output shape

    Returns:
    cupy.ndarray: random samples
    """

def random(size=None):
    """Alias for random_sample."""

def ranf(size=None):
    """Alias for random_sample."""

def sample(size=None):
    """Alias for random_sample."""

def rand(*dn):
    """
    Random values from uniform distribution over [0, 1).

    Parameters:
    - dn: dimensions of returned array

    Returns:
    cupy.ndarray: random array
    """

def randn(*dn):
    """
    Random values from standard normal distribution.

    Parameters:
    - dn: dimensions of returned array

    Returns:
    cupy.ndarray: random array from N(0,1)
    """

def randint(low, high=None, size=None, dtype=int):
    """
    Return random integers from low (inclusive) to high (exclusive).

    Parameters:
    - low: lowest integer to draw
    - high: highest integer to draw
    - size: output shape
    - dtype: data type

    Returns:
    cupy.ndarray: random integers
    """

def random_integers(low, high=None, size=None):
    """Random integers (deprecated, use randint)."""

def choice(a, size=None, replace=True, p=None):
    """
    Generate random sample from given 1-D array.

    Parameters:
    - a: 1-D array-like or int
    - size: output shape
    - replace: whether sample with replacement
    - p: probabilities associated with each entry

    Returns:
    cupy.ndarray: generated random samples
    """

def bytes(length):
    """
    Return random bytes (CPU-based).

    Parameters:
    - length: number of random bytes

    Returns:
    bytes: random bytes
    """

Continuous Distributions

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

    Parameters:
    - loc: mean of distribution
    - scale: standard deviation
    - size: output shape

    Returns:
    cupy.ndarray: drawn samples
    """

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

def uniform(low=0.0, high=1.0, size=None):
    """Draw samples from uniform distribution."""

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

def gamma(shape, scale=1.0, size=None):
    """Draw samples from Gamma distribution."""

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

def beta(a, b, size=None):
    """Draw samples from Beta distribution."""

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

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

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

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

def standard_t(df, size=None):
    """Draw samples from standard Student's t 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 gumbel(loc=0.0, scale=1.0, size=None):
    """Draw samples from Gumbel distribution."""

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

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

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

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

def rayleigh(scale=1.0, size=None):
    """Draw samples from Rayleigh 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 (inverse Gaussian) distribution."""

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

Discrete Distributions

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

    Parameters:
    - n: number of trials
    - p: probability of success
    - size: output shape

    Returns:
    cupy.ndarray: drawn samples
    """

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."""

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

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

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

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

Multivariate Distributions

def multivariate_normal(mean, cov, size=None, check_valid='warn', tol=1e-8):
    """
    Draw samples from multivariate normal distribution.

    Parameters:
    - mean: mean of distribution
    - cov: covariance matrix
    - size: output shape
    - check_valid: behavior when covariance is not valid
    - tol: tolerance for checking covariance

    Returns:
    cupy.ndarray: drawn samples
    """

def multinomial(n, pvals, size=None):
    """
    Draw samples from multinomial distribution.

    Parameters:
    - n: number of experiments
    - pvals: probabilities of p different outcomes
    - size: output shape

    Returns:
    cupy.ndarray: drawn samples
    """

def dirichlet(alpha, size=None):
    """
    Draw samples from Dirichlet distribution.

    Parameters:
    - alpha: parameter of distribution
    - size: output shape

    Returns:
    cupy.ndarray: drawn samples
    """

Permutations

def shuffle(x):
    """
    Modify array in-place by shuffling its contents.

    Parameters:
    - x: array to shuffle

    Returns:
    None
    """

def permutation(x):
    """
    Randomly permute sequence or return permuted range.

    Parameters:
    - x: array-like or int

    Returns:
    cupy.ndarray: permuted sequence
    """

Usage Examples

Basic Random Generation

import cupy as cp

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

# Generate random numbers
uniform_samples = cp.random.random((5, 5))
normal_samples = cp.random.randn(100)
integers = cp.random.randint(0, 10, size=(3, 3))

# Using convenience functions
zeros_to_ones = cp.random.rand(1000)  # Uniform [0, 1)
standard_normal = cp.random.randn(1000)  # N(0, 1)

Modern Generator API

import cupy as cp

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

# Or with specific bit generator
bit_gen = cp.random.XORWOW(seed=42)
rng = cp.random.Generator(bit_gen)

# Generate random numbers
samples = rng.random((5, 5))
normal_samples = rng.normal(0, 1, size=100)
integers = rng.integers(0, 10, size=(3, 3))

Statistical Distributions

import cupy as cp

# Normal distribution
normal_data = cp.random.normal(loc=10, scale=2, size=1000)

# Exponential distribution  
exp_data = cp.random.exponential(scale=1.5, size=1000)

# Gamma distribution
gamma_data = cp.random.gamma(shape=2, scale=1, size=1000)

# Beta distribution
beta_data = cp.random.beta(a=2, b=5, size=1000)

# Discrete distributions
binomial_data = cp.random.binomial(n=10, p=0.3, size=1000)
poisson_data = cp.random.poisson(lam=3, size=1000)

Multivariate Distributions

import cupy as cp

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

# Multinomial
n_trials = 20
probabilities = cp.array([0.2, 0.3, 0.5])
multinomial_samples = cp.random.multinomial(n_trials, probabilities, size=50)

# Dirichlet
alpha = cp.array([1, 2, 3])
dirichlet_samples = cp.random.dirichlet(alpha, size=100)

Random Sampling and Choice

import cupy as cp

# Random choice from array
data = cp.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
random_choices = cp.random.choice(data, size=5, replace=False)

# Weighted choice
weights = cp.array([0.1, 0.1, 0.1, 0.2, 0.2, 0.1, 0.1, 0.05, 0.025, 0.025])
weighted_choices = cp.random.choice(data, size=100, p=weights)

# Random permutation
original = cp.arange(10)
permuted = cp.random.permutation(original)

# Shuffle in place
to_shuffle = cp.arange(10)
cp.random.shuffle(to_shuffle)

Random State Management

import cupy as cp

# Save and restore state
state = cp.random.get_random_state()
sample1 = cp.random.random(5)

# Generate more samples
sample2 = cp.random.random(5)

# Restore state and regenerate
cp.random.set_random_state(state)
sample1_again = cp.random.random(5)  # Same as sample1

# Using RandomState object
rs = cp.random.RandomState(42)
controlled_sample = rs.random(10)

Performance Considerations

import cupy as cp
import time

# Large random generation
size = (10000, 10000)

# Time different distributions
start = time.time()
uniform_large = cp.random.random(size)
uniform_time = time.time() - start

start = time.time()
normal_large = cp.random.normal(0, 1, size)
normal_time = time.time() - start

print(f"Uniform generation: {uniform_time:.4f}s")
print(f"Normal generation: {normal_time:.4f}s")

# Memory usage
memory_pool = cp.get_default_memory_pool()
print(f"GPU memory used: {memory_pool.used_bytes() / 1024**3:.2f} GB")

Install with Tessl CLI