Closures and Higher-Order Functions

import numpy as np

def make_noise_generator(
    noise_type: str = "gaussian",
    power_dbw: float = 0.0,
    seed: int | None = None,
):
    """Create a noise generator closure.

    Parameters
    ----------
    noise_type : str
        'gaussian', 'uniform', or 'laplacian'.
    power_dbw : float
        Noise power in dBW.
    seed : int or None
        Random seed for reproducibility.

    Returns
    -------
    callable
        Function that takes shape tuple and returns noise array.
    """
    rng = np.random.default_rng(seed)
    variance = 10 ** (power_dbw / 10)
    std = np.sqrt(variance)

    if noise_type == "gaussian":
        def generate(shape):
            return rng.normal(0, std, shape)
    elif noise_type == "uniform":
        def generate(shape):
            half = std * np.sqrt(3)
            return rng.uniform(-half, half, shape)
    elif noise_type == "laplacian":
        def generate(shape):
            scale = std / np.sqrt(2)
            return rng.laplace(0, scale, shape)
    else:
        raise ValueError(f"Unknown noise type: {noise_type}")

    return generate

# Create specialized generators
thermal_noise = make_noise_generator("gaussian", power_dbw=-10, seed=42)
impulse_noise = make_noise_generator("laplacian", power_dbw=-5, seed=42)

# Use them
signal = np.ones(1000)
noisy_thermal = signal + thermal_noise((1000,))
noisy_impulse = signal + impulse_noise((1000,))

# The RNG state is encapsulated — each generator has its own
print(thermal_noise((3,)))   # reproducible sequence

def make_regularizer(
    reg_type: str = "l2",
    alpha: float = 1.0,
    l1_ratio: float = 0.5,
):
    """Create a regularization penalty function.

    Parameters
    ----------
    reg_type : str
        'l1', 'l2', or 'elasticnet'.
    alpha : float
        Regularization strength.
    l1_ratio : float
        Mixing parameter for ElasticNet (0 = pure L2, 1 = pure L1).
    """
    if reg_type == "l1":
        def penalty(w: np.ndarray) -> float:
            return alpha * np.sum(np.abs(w))
    elif reg_type == "l2":
        def penalty(w: np.ndarray) -> float:
            return alpha * np.sum(w ** 2)
    elif reg_type == "elasticnet":
        def penalty(w: np.ndarray) -> float:
            l1 = np.sum(np.abs(w))
            l2 = np.sum(w ** 2)
            return alpha * (l1_ratio * l1 + (1 - l1_ratio) * l2)
    else:
        raise ValueError(f"Unknown type: {reg_type}")

    # Attach metadata for introspection
    penalty.reg_type = reg_type
    penalty.alpha = alpha
    return penalty

# Sweep over regularization strengths
alphas = np.logspace(-4, 2, 20)
results = {}

for alpha in alphas:
    reg = make_regularizer("l2", alpha=alpha)
    loss = train_model(X, y, regularizer=reg)
    results[alpha] = loss

# The factory made it trivial to parameterize the sweep

from functools import partial

def simulate_channel(
    signal: np.ndarray,
    snr_db: float,
    channel_type: str = "awgn",
    num_taps: int = 1,
    seed: int = 42,
) -> np.ndarray:
    """General channel simulation function."""
    rng = np.random.default_rng(seed)
    noise_power = 10 ** (-snr_db / 10)
    noise = rng.normal(0, np.sqrt(noise_power), signal.shape)
    if channel_type == "rayleigh":
        h = (rng.normal(0, 1, num_taps) +
             1j * rng.normal(0, 1, num_taps)) / np.sqrt(2)
        signal = np.convolve(signal, h, mode='same')
    return signal + noise

# Create specialized versions
awgn_10db = partial(simulate_channel, snr_db=10.0, channel_type="awgn")
rayleigh_fading = partial(simulate_channel, channel_type="rayleigh", num_taps=4)

# Use them — cleaner than lambda, preserves introspection
result = awgn_10db(my_signal)
print(awgn_10db.func.__name__)  # 'simulate_channel'
print(awgn_10db.keywords)       # {'snr_db': 10.0, 'channel_type': 'awgn'}

# All three create a specialized function:

# 1. partial — preserves metadata, picklable
f1 = partial(simulate_channel, snr_db=10.0)

# 2. lambda — concise but no metadata
f2 = lambda sig: simulate_channel(sig, snr_db=10.0)

# 3. closure — most flexible, can add logic
def make_sim(snr):
    def sim(sig):
        return simulate_channel(sig, snr_db=snr)
    return sim
f3 = make_sim(10.0)