tessl/pypi-cupy-cuda114

NumPy & SciPy compatible GPU-accelerated array library for CUDA computing

—

Pending

Overview

Eval results

Files

Random Number Generation

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

Comprehensive random number generation capabilities with support for multiple algorithms, distributions, and GPU-accelerated sampling for scientific computing and simulation. CuPy provides GPU-optimized random number generation with compatibility to NumPy's random module.

Capabilities

Basic Random Functions

Core random number generation functions for common use cases.

def random(size=None):
    """Random values in [0.0, 1.0) from uniform distribution.
    
    Args:
        size: Output shape
        
    Returns:
        cupy.ndarray: Random values
    """

def randn(*args):
    """Random values from standard normal distribution.
    
    Args:
        *args: Output shape dimensions
        
    Returns:
        cupy.ndarray: Standard normal random values
    """

def randint(low, high=None, size=None, dtype=int):
    """Random integers from uniform distribution.
    
    Args:
        low: Lowest integer (inclusive)
        high: Highest integer (exclusive), if None then [0, low)
        size: Output shape
        dtype: Output data type
        
    Returns:
        cupy.ndarray: Random integers
    """

def rand(*args):
    """Random values in [0.0, 1.0) from uniform distribution.
    
    Args:
        *args: Output shape dimensions
        
    Returns:
        cupy.ndarray: Random values
    """

def seed(seed=None):
    """Seed the random number generator.
    
    Args:
        seed: Random seed value
    """

Probability Distributions

Generate samples from various probability distributions.

def normal(loc=0.0, scale=1.0, size=None):
    """Normal (Gaussian) distribution samples.
    
    Args:
        loc: Mean of distribution
        scale: Standard deviation
        size: Output shape
        
    Returns:
        cupy.ndarray: Normal distribution samples
    """

def uniform(low=0.0, high=1.0, size=None):
    """Uniform distribution samples.
    
    Args:
        low: Lower boundary (inclusive)
        high: Upper boundary (exclusive)
        size: Output shape
        
    Returns:
        cupy.ndarray: Uniform distribution samples
    """

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

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

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

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

def poisson(lam=1.0, size=None):
    """Poisson distribution samples."""

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Sampling and Permutation

Functions for sampling and permutation operations.

def choice(a, size=None, replace=True, p=None):
    """Generate random sample from given array.
    
    Args:
        a: Array to sample from or integer for range
        size: Output shape
        replace: Whether to sample with replacement
        p: Probabilities for each element
        
    Returns:
        cupy.ndarray: Random samples
    """

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

def permutation(x):
    """Randomly permute array or return permuted range.
    
    Args:
        x: Array to permute or integer for range
        
    Returns:
        cupy.ndarray: Permuted array
    """

Generator Interface

Modern random number generator interface with multiple algorithms.

class Generator:
    """Random number generator with multiple algorithms.
    
    Provides access to various bit generators and distribution methods.
    """
    def __init__(self, bit_generator):
        """Initialize generator with bit generator.
        
        Args:
            bit_generator: Bit generator instance
        """
        
    def random(self, size=None, dtype=cp.float64, out=None):
        """Random floats in [0.0, 1.0)."""
        
    def integers(self, low, high=None, size=None, dtype=cp.int64, endpoint=False):
        """Random integers from discrete uniform distribution."""
        
    def standard_normal(self, size=None, dtype=cp.float64, out=None):
        """Standard normal distribution samples."""
        
    def normal(self, loc=0.0, scale=1.0, size=None):
        """Normal distribution samples."""
        
    def uniform(self, low=0.0, high=1.0, size=None):
        """Uniform distribution samples."""
        
    def exponential(self, scale=1.0, size=None):
        """Exponential distribution samples."""
        
    def gamma(self, shape, scale=1.0, size=None):
        """Gamma distribution samples."""
        
    def beta(self, a, b, size=None):
        """Beta distribution samples."""
        
    def binomial(self, n, p, size=None):
        """Binomial distribution samples."""
        
    def poisson(self, lam=1.0, size=None):
        """Poisson distribution samples."""
        
    def choice(self, a, size=None, replace=True, p=None, axis=0, shuffle=True):
        """Generate random sample from array."""
        
    def shuffle(self, x, axis=0):
        """Shuffle array in-place along axis."""
        
    def permutation(self, x, axis=0):
        """Return permuted array."""

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

class XORWOW(BitGenerator):
    """XORWOW bit generator."""
    def __init__(self, seed=None):
        pass

class MRG32k3a(BitGenerator):
    """MRG32k3a bit generator."""  
    def __init__(self, seed=None):
        pass

class Philox(BitGenerator):
    """Philox bit generator."""
    def __init__(self, seed=None, counter=None, key=None):
        pass

def default_rng(seed=None):
    """Create default random generator.
    
    Args:
        seed: Random seed
        
    Returns:
        Generator: Random number generator
    """

Random State Management

Control and manage random number generator state.

class RandomState:
    """Random number generator state container.
    
    Provides NumPy-compatible random state management.
    """
    def __init__(self, seed=None):
        """Initialize random state.
        
        Args:
            seed: Random seed
        """
        
    def seed(self, seed=None):
        """Seed the generator."""
        
    def get_state(self):
        """Get current state."""
        
    def set_state(self, state):
        """Set generator state."""
        
    def random_sample(self, size=None):
        """Random floats in [0.0, 1.0)."""
        
    def randint(self, low, high=None, size=None, dtype=int):
        """Random integers."""
        
    def randn(self, *args):
        """Standard normal samples."""
        
    def normal(self, loc=0.0, scale=1.0, size=None):
        """Normal distribution samples."""
        
    def uniform(self, low=0.0, high=1.0, size=None):
        """Uniform distribution samples."""
        
    def choice(self, a, size=None, replace=True, p=None):
        """Random sample from array."""
        
    def shuffle(self, x):
        """Shuffle array in-place."""
        
    def permutation(self, x):
        """Return permuted array."""

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

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

Usage Examples

Basic Random Number Generation

import cupy as cp

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

# Generate random arrays
uniform_vals = cp.random.random((3, 4))      # Uniform [0, 1)
normal_vals = cp.random.randn(5, 5)          # Standard normal
integers = cp.random.randint(0, 10, (2, 3))  # Random integers

print("Uniform values:\n", uniform_vals)
print("Normal values:\n", normal_vals)
print("Random integers:\n", integers)

Probability Distributions

# Normal distribution with custom parameters
normal_custom = cp.random.normal(loc=5.0, scale=2.0, size=(1000,))

# Exponential distribution
exponential_vals = cp.random.exponential(scale=2.0, size=500)

# Gamma distribution
gamma_vals = cp.random.gamma(shape=2.0, scale=1.0, size=1000)

# Binomial distribution
binomial_vals = cp.random.binomial(n=10, p=0.3, size=1000)

# Poisson distribution
poisson_vals = cp.random.poisson(lam=3.0, size=1000)

# Verify distribution properties
print(f"Normal mean: {normal_custom.mean():.2f} (expected: 5.0)")
print(f"Normal std: {normal_custom.std():.2f} (expected: 2.0)")

Sampling and Choice Operations

# Sample from existing array
data = cp.arange(100)
samples = cp.random.choice(data, size=10, replace=False)

# Weighted sampling
weights = cp.array([0.1, 0.2, 0.3, 0.4])
choices = cp.array(['A', 'B', 'C', 'D'])
weighted_samples = cp.random.choice(choices, size=1000, p=weights)

# Shuffling arrays
deck = cp.arange(52)  # Deck of cards
cp.random.shuffle(deck)
print("Shuffled deck:", deck[:10])

# Permutation (returns copy)
original = cp.array([1, 2, 3, 4, 5])
permuted = cp.random.permutation(original)
print("Original:", original)
print("Permuted:", permuted)

Advanced Generator Interface

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

# Generate samples using modern interface
samples = rng.random(size=(5, 5))
integers = rng.integers(low=0, high=100, size=10)
normal_samples = rng.normal(loc=0, scale=1, size=1000)

# Use different bit generators for different properties
philox_gen = cp.random.Generator(cp.random.Philox(seed=42))
xorwow_gen = cp.random.Generator(cp.random.XORWOW(seed=42))

# Philox is good for parallel generation
parallel_samples = philox_gen.normal(size=(10000,))

# XORWOW is fast for sequential generation
sequential_samples = xorwow_gen.uniform(size=(10000,))

Random State Management

# Save and restore random state
state = cp.random.get_state()

# Generate some numbers
first_batch = cp.random.random(5)

# Restore state and generate again
cp.random.set_state(state)
second_batch = cp.random.random(5)

# Should be identical
print("First batch: ", first_batch)
print("Second batch:", second_batch)
print("Identical:", cp.allclose(first_batch, second_batch))

# Use RandomState class for multiple generators
rs1 = cp.random.RandomState(seed=1)
rs2 = cp.random.RandomState(seed=2)

batch1 = rs1.random(3)
batch2 = rs2.random(3)
print("Generator 1:", batch1)
print("Generator 2:", batch2)

Monte Carlo Simulations

# Estimate π using Monte Carlo method
n_samples = 1000000
x = cp.random.uniform(-1, 1, n_samples)
y = cp.random.uniform(-1, 1, n_samples)

# Points inside unit circle
inside_circle = (x**2 + y**2) <= 1
pi_estimate = 4 * cp.mean(inside_circle)

print(f"π estimate: {pi_estimate:.4f}")
print(f"Error: {abs(pi_estimate - cp.pi):.4f}")

# Option pricing with geometric Brownian motion
S0 = 100      # Initial stock price
T = 1.0       # Time to maturity
r = 0.05      # Risk-free rate
sigma = 0.2   # Volatility
n_paths = 10000

# Generate random walks
dt = T / 252  # Daily steps
random_increments = cp.random.normal(0, 1, (n_paths, 252))
price_paths = S0 * cp.exp(cp.cumsum((r - 0.5*sigma**2)*dt + 
                                   sigma*cp.sqrt(dt)*random_increments, axis=1))

final_prices = price_paths[:, -1]
print(f"Expected final price: {cp.mean(final_prices):.2f}")

Statistical Testing and Validation

# Generate large sample and test properties
n = 100000
normal_samples = cp.random.normal(2.0, 1.5, n)

# Calculate sample statistics
sample_mean = cp.mean(normal_samples)
sample_std = cp.std(normal_samples, ddof=1)

print(f"Sample mean: {sample_mean:.4f} (expected: 2.0)")
print(f"Sample std: {sample_std:.4f} (expected: 1.5)")

# Test uniform distribution
uniform_samples = cp.random.uniform(0, 1, n)
print(f"Uniform min: {cp.min(uniform_samples):.4f}")
print(f"Uniform max: {cp.max(uniform_samples):.4f}")
print(f"Uniform mean: {cp.mean(uniform_samples):.4f} (expected: 0.5)")

Performance Considerations

# Large array generation
large_size = (10000, 10000)

# Time different operations
import time

start = time.time()
large_uniform = cp.random.random(large_size)
end = time.time()
print(f"Large uniform generation: {end - start:.3f} seconds")

start = time.time()
large_normal = cp.random.randn(*large_size)
end = time.time()
print(f"Large normal generation: {end - start:.3f} seconds")

# Memory usage
print(f"Array size: {large_uniform.nbytes / 1024**3:.2f} GB")

Install with Tessl CLI