Sampling & Randomized Designs

Space-filling and randomized experimental designs for computer experiments, Monte Carlo simulation, and uncertainty quantification. These designs provide uniform coverage of the experimental space and are particularly suitable for deterministic simulations and high-dimensional problems.

Capabilities

Latin Hypercube Sampling

Stratified sampling method that ensures each factor is uniformly sampled across its range while maintaining randomness.

def lhs(n, samples=None, criterion=None, iterations=None, random_state=None, correlation_matrix=None):
    """
    Generate a Latin Hypercube Sampling design
    
    Parameters:
    - n: int, number of factors to generate samples for
    - samples: int, optional, number of samples to generate (default: n)
    - criterion: str, optional, optimization criterion for sample placement
    - iterations: int, optional, number of iterations for optimization (default: 5)
    - random_state: int or RandomState, optional, random seed for reproducibility
    - correlation_matrix: ndarray, optional, enforce correlation between factors
    
    Returns:
    - H: 2d-array, design matrix normalized to [0,1] with uniform factor spacing
    """

Criterion Options:

• None (default): Simple randomized Latin hypercube
• "center" or "c": Centered Latin hypercube (samples at stratum centers)
• "maximin" or "m": Maximizes minimum distance between sample points
• "centermaximin" or "cm": Combines center and maximin criteria
• "correlation" or "corr": Minimizes correlations between factors

Key Features:

• Ensures each factor is sampled across its full range
• Maintains stratification properties for any number of samples
• Excellent space-filling properties for computer experiments
• Supports correlation control and distance optimization

Usage Examples:

import pyDOE3
import numpy as np

# Basic 4-factor LHS with 10 samples
design = pyDOE3.lhs(4, samples=10, random_state=42)
print(f"Design shape: {design.shape}")  # (10, 4)

# Centered LHS for more uniform coverage
centered_design = pyDOE3.lhs(3, samples=8, criterion='center', random_state=42)

# Maximin LHS for maximum space-filling
maximin_design = pyDOE3.lhs(5, samples=20, criterion='maximin', iterations=100)

# LHS with enforced correlation structure
correlation_matrix = np.array([[1.0, 0.5], [0.5, 1.0]])
correlated_design = pyDOE3.lhs(2, samples=15, correlation_matrix=correlation_matrix)

Grid Designs

Deterministic space-filling designs with regular structure for systematic exploration of experimental space.

Sukharev Grid

Low-discrepancy grid design with optimal covering radius properties based on max-norm distance.

def sukharev_grid(num_points, dimension):
    """
    Create Sukharev grid in unit hypercube
    
    Parameters:
    - num_points: int, number of points to generate
                 num_points^(1/dimension) must be integer
    - dimension: int, dimensionality of the space
    
    Returns:
    - points: 2d-array, (num_points, dimension) grid coordinates in [0,1]
    """

Key Features:

• Points placed at centroids of subcells (not on boundaries)
• Optimal covering radius for max-norm distances
• Deterministic and reproducible point placement
• Uniform space-filling with regular structure

Usage Example:

import pyDOE3

# 3D Sukharev grid with 27 points (3^3)
grid = pyDOE3.sukharev_grid(27, 3)
print(f"Grid shape: {grid.shape}")  # (27, 3)

# 2D grid with 16 points (4^2)
grid_2d = pyDOE3.sukharev_grid(16, 2)
print(f"Grid shape: {grid_2d.shape}")  # (16, 2)

# Note: num_points must be a perfect power of dimension
# For 3D: valid values are 1, 8, 27, 64, 125, ... (1^3, 2^3, 3^3, 4^3, 5^3, ...)

Design Manipulation

Tools for modifying and augmenting existing experimental designs.

Design Folding

Augments 2-level designs by adding their geometric reflection to reduce confounding effects.

def fold(H, columns=None):
    """
    Fold a design to reduce confounding effects
    
    Parameters:
    - H: 2d-array, design matrix to be folded (must be 2-level)
    - columns: array-like, optional, indices of columns to fold (default: all)
    
    Returns:
    - Hf: 2d-array, folded design matrix with doubled number of runs
    """

Key Features:

• Doubles the number of experimental runs
• Reduces confounding by creating geometric reflections
• Can fold specific columns or entire design
• Only works with 2-level factors

Usage Example:

import pyDOE3

# Create a fractional factorial design
original_design = pyDOE3.fracfact("a b ab")
print(f"Original shape: {original_design.shape}")  # (4, 3)

# Fold the entire design
folded_design = pyDOE3.fold(original_design)
print(f"Folded shape: {folded_design.shape}")  # (8, 3)

# Fold only specific columns (first two factors)
partial_fold = pyDOE3.fold(original_design, columns=[0, 1])
print(f"Partial fold shape: {partial_fold.shape}")  # (8, 3)

Design Selection Guidelines

When to Use Each Design Type:

Latin Hypercube Sampling:

• Best for: Computer experiments, Monte Carlo simulation, uncertainty quantification
• Use when: Need good space-filling properties with random sampling
• Factors: Any number (scales well to high dimensions)
• Advantages: Excellent coverage, flexible sample sizes, optimization criteria

Sukharev Grid:

• Best for: Deterministic simulations, systematic space exploration
• Use when: Need reproducible, regular point placement
• Factors: Low to moderate dimensions (constraint: num_points^(1/dimension) = integer)
• Advantages: Optimal covering radius, deterministic placement

Design Folding:

• Best for: Augmenting existing 2-level designs, resolution enhancement
• Use when: Initial design shows confounding, need to separate main effects from interactions
• Factors: Any number of 2-level factors
• Advantages: Doubles information, reduces confounding, cost-effective augmentation

LHS Criterion Selection:

Sample Size Recommendations:

• Computer experiments: 10-20 samples per factor
• Monte Carlo simulation: Based on convergence requirements
• Screening studies: 5-10 samples per factor minimum
• Response surface: Combine with RSM designs for modeling

Types

import numpy as np
from typing import Optional, Union, Tuple
from numpy.random import RandomState

# Type aliases
DesignMatrix = np.ndarray
RandomSeed = Union[int, RandomState, None]
OptimizationCriterion = Optional[str]
ColumnIndices = Optional[Union[list, np.ndarray]]
CorrelationMatrix = Optional[np.ndarray]

Integration with Other Design Types

Sampling and randomized designs complement other experimental design approaches:

• With Factorial Designs: Use LHS for initial exploration, then factorial for detailed study
• With RSM: Combine LHS screening with Box-Behnken/CCD for optimization
• With Optimal Designs: Use LHS to generate candidate sets for optimal design algorithms
• Sequential Approach: Start with LHS screening → Fold promising regions → Apply RSM