Advanced Distributions

/**
 * Returns a function for generating gamma distribution random numbers
 * @param k - Shape parameter (must be positive)
 * @param theta - Scale parameter, defaults to 1
 * @returns Generator function producing gamma distributed numbers
 * @throws RangeError if k < 0
 */
function randomGamma(k: number, theta?: number): () => number;

import { randomGamma } from "d3-random";

// Service time distribution (shape=2, scale=3)
const serviceTime = randomGamma(2, 3);
console.log(serviceTime().toFixed(2)); // e.g., 4.23

// Exponential distribution (special case: k=1)
const exponential = randomGamma(1, 2);
console.log(exponential().toFixed(2)); // e.g., 1.87

try {
  const invalid = randomGamma(-1); // Throws RangeError
} catch (error) {
  console.error("Invalid gamma parameter");
}

/**
 * Returns a function for generating beta distribution random numbers
 * @param alpha - First shape parameter (must be positive)
 * @param beta - Second shape parameter (must be positive)
 * @returns Generator function producing numbers in range [0, 1]
 */
function randomBeta(alpha: number, beta: number): () => number;

import { randomBeta } from "d3-random";

// Uniform distribution (special case: alpha=1, beta=1)
const uniform = randomBeta(1, 1);
console.log(uniform().toFixed(3)); // e.g., 0.743

// Biased toward 0 (alpha=0.5, beta=2)
const leftSkewed = randomBeta(0.5, 2);
console.log(leftSkewed().toFixed(3)); // e.g., 0.123

// Bell-shaped distribution (alpha=5, beta=5)
const bellShaped = randomBeta(5, 5);
console.log(bellShaped().toFixed(3)); // e.g., 0.567

/**
 * Returns a function for generating generalized extreme value distribution random numbers
 * @param k - Shape parameter (positive=Weibull, zero=Gumbel, negative=Fréchet)
 * @param a - Location parameter, defaults to 0
 * @param b - Scale parameter, defaults to 1
 * @returns Generator function producing distributed numbers
 */
function randomWeibull(k: number, a?: number, b?: number): () => number;

import { randomWeibull } from "d3-random";

// Weibull distribution (k > 0) - reliability analysis
const reliability = randomWeibull(2, 0, 1000);
console.log(Math.round(reliability())); // e.g., 823 hours

// Gumbel distribution (k = 0) - extreme values
const extremeValue = randomWeibull(0, 10, 2);
console.log(extremeValue().toFixed(2)); // e.g., 12.34

// Fréchet distribution (k < 0) - heavy-tailed
const heavyTailed = randomWeibull(-0.5, 0, 1);
console.log(heavyTailed().toFixed(2)); // e.g., 3.45

/**
 * Returns a function for generating Cauchy distribution random numbers
 * @param a - Location parameter, defaults to 0
 * @param b - Scale parameter, defaults to 1
 * @returns Generator function producing Cauchy distributed numbers
 */
function randomCauchy(a?: number, b?: number): () => number;

import { randomCauchy } from "d3-random";

// Standard Cauchy distribution
const standard = randomCauchy();
console.log(standard().toFixed(2)); // e.g., -2.34 (can be very large)

// Shifted and scaled Cauchy
const shifted = randomCauchy(100, 10);
console.log(shifted().toFixed(2)); // e.g., 87.65

/**
 * Returns a function for generating logistic distribution random numbers
 * @param a - Location parameter, defaults to 0
 * @param b - Scale parameter, defaults to 1
 * @returns Generator function producing logistically distributed numbers
 */
function randomLogistic(a?: number, b?: number): () => number;

import { randomLogistic } from "d3-random";

// Standard logistic distribution
const standard = randomLogistic();
console.log(standard().toFixed(3)); // e.g., 1.234

// Logistic regression-style parameters
const logReg = randomLogistic(0, 0.5);
console.log(logReg().toFixed(3)); // e.g., -0.876

/**
 * Returns a function for generating Poisson distribution random numbers
 * @param lambda - Mean parameter (average number of events)
 * @returns Generator function producing non-negative integers
 */
function randomPoisson(lambda: number): () => number;

import { randomPoisson } from "d3-random";

// Number of customers per hour (average 5)
const customers = randomPoisson(5);
console.log(customers()); // e.g., 7

// Network packet arrivals (average 100 per second)
const packets = randomPoisson(100);
console.log(packets()); // e.g., 103

// Rare events (average 0.1 per day)
const rareEvents = randomPoisson(0.1);
console.log(rareEvents()); // Usually 0, occasionally 1 or more

/**
 * Returns a function for generating Pareto distribution random numbers
 * @param alpha - Shape parameter (must be positive)
 * @returns Generator function producing numbers ≥ 1
 */
function randomPareto(alpha: number): () => number;

import { randomPareto } from "d3-random";

// Income distribution (80/20 rule with alpha=1.16)
const income = randomPareto(1.16);
console.log(income().toFixed(2)); // e.g., 2.34

// City size distribution
const citySize = randomPareto(2);
console.log(citySize().toFixed(2)); // e.g., 1.87

/**
 * Returns a function for generating Bernoulli distribution random numbers
 * @param p - Success probability, must be in range [0, 1]
 * @returns Generator function producing 0 or 1
 */
function randomBernoulli(p: number): () => number;

import { randomBernoulli } from "d3-random";

// Fair coin flip (50% probability)
const coinFlip = randomBernoulli(0.5);
console.log(coinFlip()); // 0 or 1

// Biased coin (70% chance of success)
const biasedCoin = randomBernoulli(0.7);
console.log(biasedCoin()); // 1 more often than 0

// Rare event (1% probability)
const rareEvent = randomBernoulli(0.01);
console.log(rareEvent()); // Usually 0, rarely 1

/**
 * Returns a function for generating geometric distribution random numbers
 * @param p - Success probability per trial, must be in range [0, 1]
 * @returns Generator function producing positive integers
 */
function randomGeometric(p: number): () => number;

import { randomGeometric } from "d3-random";

// Number of attempts until success (20% success rate)
const attempts = randomGeometric(0.2);
console.log(attempts()); // e.g., 7 attempts

// Time until first customer (10% probability per minute)
const waitTime = randomGeometric(0.1);
console.log(waitTime()); // e.g., 12 minutes

/**
 * Returns a function for generating binomial distribution random numbers
 * @param n - Number of trials (must be ≥ 0)
 * @param p - Success probability per trial, must be in range [0, 1]
 * @returns Generator function producing integers from 0 to n
 */
function randomBinomial(n: number, p: number): () => number;

import { randomBinomial } from "d3-random";

// Number of heads in 10 coin flips
const heads = randomBinomial(10, 0.5);
console.log(heads()); // e.g., 6

// Number of defective items in batch of 100 (2% defect rate)
const defects = randomBinomial(100, 0.02);
console.log(defects()); // e.g., 1

// Survey responses (50 people, 30% response rate)
const responses = randomBinomial(50, 0.3);
console.log(responses()); // e.g., 14