Numerics/Random Numbers - Revision history

Admin: replace all emdashes with regular dashes (via update-page on MediaWiki MCP Server)

2026-06-24T10:58:43Z

replace all emdashes with regular dashes (via update-page on MediaWiki MCP Server)

Admin: Add NumericsFlag template (via update-page on MediaWiki MCP Server)

2026-06-24T10:52:49Z

Add NumericsFlag template (via update-page on MediaWiki MCP Server)

← Older revision		Revision as of 10:52, 24 June 2026
Line 215:		Line 215:
	[[Category:Python]]		[[Category:Python]]
	[[Category:Random]]		[[Category:Random]]
			{{NumericsFlag}}

Admin: Replace emdashes with regular dashes, remove "(Seriously)" from section headers, remove "honestly" references, add border="1" to tables (via update-page on MediaWiki MCP Server)

2026-06-24T10:46:39Z

Replace emdashes with regular dashes, remove "(Seriously)" from section headers, remove "honestly" references, add border="1" to tables (via update-page on MediaWiki MCP Server)

← Older revision		Revision as of 10:46, 24 June 2026
Line 1:		Line 1:
	'''Random numbers''' are one of those things that sound dead simple — "just give me a number I can't predict, right?" — but then the rabbit hole opens up and suddenly you're comparing Mersenne Twister state spaces and wondering if your Monte Carlo simulation is actually converged.		'''Random numbers''' are one of those things that sound dead simple — "just give me a number I can't predict, right?" - but then the rabbit hole opens up and suddenly you're comparing Mersenne Twister state spaces and wondering if your Monte Carlo simulation is actually converged.

	This page is the Python-centric tour through random number generation: what actually works, what's secretly broken, and how to wield these tools without accidentally turning your simulation into a deterministic paperweight. If you stumbled here looking for C++ <code>rand()</code> quirks, check out the sister page '''[[Random Numbers]]''' — but ~~honestly,~~ for numerical work, you want to be here.		This page is the Python-centric tour through random number generation: what actually works, what's secretly broken, and how to wield these tools without accidentally turning your simulation into a deterministic paperweight. If you stumbled here looking for C++ <code>rand()</code> quirks, check out the sister page '''[[Random Numbers]]''' — but for numerical work, you want to be here.

	== The Two Kinds of Random ==		== The Two Kinds of Random ==
Line 7:		Line 7:
	There are really only two flavors of random numbers in the universe, and knowing which one you're dealing with changes everything:		There are really only two flavors of random numbers in the universe, and knowing which one you're dealing with changes everything:

	{\| class="wikitable"		{\| class="wikitable" border="1"
	\|-		\|-
	! Type !! Where it comes from !! Use it for...		! Type !! Where it comes from !! Use it for...
Line 26:		Line 26:
	<math>X_{n+1} = (aX_n + c) \bmod m</math>		<math>X_{n+1} = (aX_n + c) \bmod m</math>

	This is the LCG — the Honda Civic of random number generators. It's everywhere (including C's <code>rand()</code>), it's fast, and it's... fine, for very loose definitions of "fine." LCGs have lousy statistical properties in low dimensions — if you plot consecutive pairs <math>(X_n, X_{n+1})</math> as points in 2D, they fall on a small number of parallel planes. This is the Marsaglia effect and it's ~~honestly~~ kind of horrifying once you see it.		This is the LCG — the Honda Civic of random number generators. It's everywhere (including C's <code>rand()</code>), it's fast, and it's... fine, for very loose definitions of "fine." LCGs have lousy statistical properties in low dimensions — if you plot consecutive pairs <math>(X_n, X_{n+1})</math> as points in 2D, they fall on a small number of parallel planes. This is the Marsaglia effect and it's kind of horrifying once you see it.

	=== The Workhorse: Mersenne Twister (MT19937) ===		=== The Workhorse: Mersenne Twister (MT19937) ===
Line 40:		Line 40:
	=== The Core Functions You'll Actually Use ===		=== The Core Functions You'll Actually Use ===

	{\| class="wikitable"		{\| class="wikitable" border="1"
	\|-		\|-
	! Function !! What it gives you		! Function !! What it gives you
Line 52:		Line 52:
	\| <code>random.choice(seq)</code> \|\| Grab a random element from a sequence. O(1) for lists.		\| <code>random.choice(seq)</code> \|\| Grab a random element from a sequence. O(1) for lists.
	\|-		\|-
	\| <code>random.shuffle(seq)</code> \|\| Fisher-Yates in-place shuffle. ~~Honestly kind~~ of elegant.		\| <code>random.shuffle(seq)</code> \|\| Fisher-Yates in-place shuffle. Kind of elegant.
	\|-		\|-
	\| <code>random.sample(population, k)</code> \|\| <code>k</code> unique random elements without replacement. Reservoir sampling when needed.		\| <code>random.sample(population, k)</code> \|\| <code>k</code> unique random elements without replacement. Reservoir sampling when needed.
Line 69:		Line 69:
	</syntaxhighlight>		</syntaxhighlight>

	Call <code>seed()</code> once at the start of your program if you want reproducible runs. If you don't seed, Python seeds from <code>os.urandom()</code> on modern versions, which is fine — but your results won't be reproducible between runs.		Call <code>seed()</code> once at the start of your program if you want reproducible runs. If you don't seed, Python seeds from <code>os.urandom()</code> on modern versions, which is fine - but your results won't be reproducible between runs.

	'''One seed to rule them all:''' if you import other modules that also use <code>random</code>, seeding the global instance affects them too. This is either a feature or a deeply confusing bug depending on your perspective.		'''One seed to rule them all:''' if you import other modules that also use <code>random</code>, seeding the global instance affects them too. This is either a feature or a deeply confusing bug depending on your perspective.
Line 81:		Line 81:
	NumPy has been through a random-number glow-up. Here's the deal:		NumPy has been through a random-number glow-up. Here's the deal:

	{\| class="wikitable"		{\| class="wikitable" border="1"
	\|-		\|-
	! Approach !! API !! Verdict		! Approach !! API !! Verdict
Line 90:		Line 90:
	\|}		\|}

	The new way is the recommended path and it's ~~honestly~~ just cleaner:		The new way is the recommended path and it's just cleaner:

	<syntaxhighlight lang="python">		<syntaxhighlight lang="python">
Line 108:		Line 108:
	== A Tour Through the Distributions ==		== A Tour Through the Distributions ==

	~~Honestly, half~~ the power of random numbers is in the transformations. You start with uniform [0,1) and then shape it into whatever distribution your model needs. Here are the greatest hits:		Half the power of random numbers is in the transformations. You start with uniform [0,1) and then shape it into whatever distribution your model needs. Here are the greatest hits:

	=== The Inverse Transform Method ===		=== The Inverse Transform Method ===
Line 114:		Line 114:
	This is one of those ideas that's so elegant it hurts. If you have a CDF <math>F(x)</math> with inverse <math>F^{-1}</math>, and you generate <math>U \sim \text{Uniform}(0,1)</math>, then <math>X = F^{-1}(U)</math> follows the distribution with CDF <math>F</math>.		This is one of those ideas that's so elegant it hurts. If you have a CDF <math>F(x)</math> with inverse <math>F^{-1}</math>, and you generate <math>U \sim \text{Uniform}(0,1)</math>, then <math>X = F^{-1}(U)</math> follows the distribution with CDF <math>F</math>.

	That's it. That's the whole trick. It's why the exponential distribution is <math>-\lambda \ln(U)</math> — the CDF inversion just works out that way. Some distributions (normal) don't have a closed-form inverse CDF, so fancier methods like Box-Muller or Ziggurat step in. But the inverse transform is the conceptual backbone.		That's it. That's the whole trick. It's why the exponential distribution is <math>-\lambda \ln(U)</math> - the CDF inversion just works out that way. Some distributions (normal) don't have a closed-form inverse CDF, so fancier methods like Box-Muller or Ziggurat step in. But the inverse transform is the conceptual backbone.

	=== NumPy's Distribution Buffet ===		=== NumPy's Distribution Buffet ===
Line 135:		Line 135:
	== Seeds and Reproducibility: Control Your Chaos ==		== Seeds and Reproducibility: Control Your Chaos ==

	Reproducibility is the quiet superpower of PRNGs. Set the same seed, get the same sequence — every single time, on any machine, any OS. This makes debugging stochastic code actually possible and lets other people replicate your results exactly.		Reproducibility is the quiet superpower of PRNGs. Set the same seed, get the same sequence - every single time, on any machine, any OS. This makes debugging stochastic code actually possible and lets other people replicate your results exactly.

	=== The Golden Rules ===		=== The Golden Rules ===
Line 151:		Line 151:
	</syntaxhighlight>		</syntaxhighlight>

	=== Don't Seed in a Loop ~~(Seriously)~~ ===		=== Don't Seed in a Loop ===

	<syntaxhighlight lang="python">		<syntaxhighlight lang="python">
Line 164:		Line 164:
	== When Random Isn't Random Enough: Cryptography ==		== When Random Isn't Random Enough: Cryptography ==

	Sometimes "statistically random" isn't good enough — you need "your adversary, armed with a supercomputer and a copy of your algorithm, cannot predict the next bit." That's the crypto-grade bar.		Sometimes "statistically random" isn't good enough - you need "your adversary, armed with a supercomputer and a copy of your algorithm, cannot predict the next bit." That's the crypto-grade bar.

	=== <code>secrets</code> and <code>os.urandom()</code> ===		=== <code>secrets</code> and <code>os.urandom()</code> ===

	Python 3.6+ ships the <code>secrets</code> module, which wraps <code>os.urandom()</code> (the OS's cryptographically secure RNG — on Linux this comes from <code>/dev/urandom</code> and the kernel's entropy pool):		Python 3.6+ ships the <code>secrets</code> module, which wraps <code>os.urandom()</code> (the OS's cryptographically secure RNG - on Linux this comes from <code>/dev/urandom</code> and the kernel's entropy pool):

	<syntaxhighlight lang="python">		<syntaxhighlight lang="python">

Admin: finally wrote this up — the page was just sitting here empty, now it's got the good stuff (via update-page on MediaWiki MCP Server)

2026-06-24T01:16:02Z

finally wrote this up — the page was just sitting here empty, now it's got the good stuff (via update-page on MediaWiki MCP Server)

Show changes

Admin: Clear page contents per request (via update-page on MediaWiki MCP Server)

2026-06-24T01:13:24Z

Clear page contents per request (via update-page on MediaWiki MCP Server)

Show changes

Admin: BALLMER MODE ACTIVATED! DEVELOPERS! DEVELOPERS! DEVELOPERS! RANDOM! RANDOM! RANDOM! (via update-page on MediaWiki MCP Server)

2026-06-24T01:09:27Z

BALLMER MODE ACTIVATED! DEVELOPERS! DEVELOPERS! DEVELOPERS! RANDOM! RANDOM! RANDOM! (via update-page on MediaWiki MCP Server)

Show changes

Admin: Create opinionated, Python-centric random numbers page (via create-page on MediaWiki MCP Server)

2026-06-24T01:05:18Z

Create opinionated, Python-centric random numbers page (via create-page on MediaWiki MCP Server)

New page

'''DEVELOPERS! DEVELOPERS! DEVELOPERS!''' — and the random numbers they need.

If you are reaching for C++ to generate random numbers, '''STOP.''' Put down that `<random>` header. Step away from the Mersenne Twister boilerplate. You are about to write 15 lines of ceremonial incantation just to get a number between 1 and 6. Python gives you that in '''one line'''. And it will be correct. And it will be readable. And you will not have to explain to your cryptographer friend why you seeded with `time(NULL)` (spoiler: that is how you get owned).

Python's random-number story is the best in the business for numerical work. It ships with three battle-tested modules — `random`, `secrets`, and `numpy.random` — and each one knows its job. This page covers all three, calls out the footguns, and shows you the one obvious way to do it.

== The Holy Trinity of Python Randomness ==

{| class="wikitable" style="width:100%"
|-
! Module !! Use Case !! Speed !! Cryptographic?
|-
| `random` || Simulations, games, shuffling, sampling || Fast (Mersenne Twister) || '''NO — never for security'''
|-
| `secrets` || Passwords, tokens, session keys, auth || Slower (OS entropy) || '''YES — designed for it'''
|-
| `numpy.random` || Massive arrays, Monte Carlo, stats || Vectorized, GPU-ready || '''NO — never for security'''
|}

Memorize this table. Getting it wrong is how you ship a broken cryptosystem or a simulation that takes 100× too long.

== `random` — Your Daily Driver ==

The `random` module uses the Mersenne Twister (MT19937): period of <math>2^{19937} - 1</math>, passes Diehard and TestU01 (mostly), and ships with CPython. It is not cryptographically secure. Do not use it for secrets. '''Are we clear? Good.'''

=== The One-Liners You Will Use Every Day ===

<syntaxhighlight lang="python">
import random

# Integer in [a, b] — inclusive on BOTH ends
die_roll = random.randint(1, 6)

# Integer in [a, b) — exclusive upper, like range()
idx = random.randrange(0, len(my_list))

# Float in [0.0, 1.0)
u = random.random()

# Float in [a, b]
f = random.uniform(2.5, 7.5)

# Pick one
winner = random.choice(["Alice", "Bob", "Charlie", "Dana"])

# Pick k WITHOUT replacement (no duplicates)
sample = random.sample(population, k=10)

# Shuffle IN PLACE — Fisher-Yates under the hood
random.shuffle(deck)
</syntaxhighlight>

=== Seeds: Control Your Chaos ===

<syntaxhighlight lang="python">
random.seed(42) # Deterministic run — great for tests
random.seed() # System time + os.urandom fallback
random.seed("hello world", version=2) # Hash a string into a seed
</syntaxhighlight>

'''OPINION: Always seed explicitly in scientific code.''' Reproducibility is not optional. If your results cannot be regenerated from a known seed, you do not have results — you have an anecdote. Save the seed alongside your output. Future you will weep with gratitude.

=== Distributions: Beyond Uniform ===

<syntaxhighlight lang="python">
# Gaussian (mu=0, sigma=1)
random.gauss(0, 1) # Slightly faster
random.normalvariate(0, 1) # Thread-safe

# Exponentially distributed, lambda=1.5
random.expovariate(1.5)

# Gamma, Beta, von Mises, Pareto, Weibull...
random.gammavariate(alpha=2.0, beta=3.0)
random.betavariate(alpha=0.5, beta=0.5)
random.paretovariate(alpha=1.5)
random.weibullvariate(alpha=1.5, beta=2.0)
</syntaxhighlight>

=== The Trap: `SystemRandom` (Just Use `secrets` Instead) ===

<syntaxhighlight lang="python">
# Exists, works, but WHY ARE YOU DOING THIS?
sr = random.SystemRandom()
token = sr.randrange(2**256)
</syntaxhighlight>

`SystemRandom` wraps `/dev/urandom` through the `random.Random` API. Fine, it works. But Python 3.6 gave us `secrets`, which has a purpose-built API for exactly this. Use the right tool.

== `secrets` — When Random Isn't Just Random ==

If the outcome affects '''money, privacy, authentication, or user safety''', you are in `secrets` territory. This module pulls entropy directly from the operating system's CSPRNG (`/dev/urandom` on Linux, `CryptGenRandom` on Windows) and the API is deliberately narrow — you cannot accidentally use it for Monte Carlo.

<syntaxhighlight lang="python">
import secrets

# Cryptographically random integer in [0, n)
secrets.randbelow(2**256)

# Random integer with k random bits
secrets.randbits(256)

# Token — URL-safe Base64, nbytes → ceil(nbytes * 4/3) characters
secrets.token_hex(32) # 64 hex chars
secrets.token_urlsafe(32) # ~43 URL-safe chars

# Pick one — constant-time-ish choice
secrets.choice(["primary", "secondary", "fallback"])
</syntaxhighlight>

'''OPINION: If you type `random` when you should have typed `secrets`, you have introduced a vulnerability.''' Full stop. The Mersenne Twister is predictable after 624 consecutive outputs. That is not a theoretical attack — it is a Saturday-afternoon script. Use `secrets` for anything adversarial.

== `numpy.random` — The Heavy Artillery ==

When you need '''millions''' of random numbers, Python's `random` module becomes a bottleneck. Each call crosses the Python/C boundary. NumPy's `numpy.random` generates entire arrays in C, vectorized, and the new API (1.17+) uses the superior PCG-64 generator by default.

=== The New API (Use This, Not the Old One) ===

<syntaxhighlight lang="python">
import numpy as np

# Create a generator — PCG64 is the new default
rng = np.random.default_rng(seed=2024)

# Uniform [0, 1) — 10 million floats in < 100 ms
u = rng.random(10_000_000)

# Integers
dice = rng.integers(1, 7, size=1000, endpoint=True) # d6 × 1000

# Normal, vectorized
z = rng.standard_normal((1000, 1000)) # 1M standard normals

# Shuffle along axis
rng.shuffle(arr, axis=0)

# Choice with replacement and probabilities
rng.choice(["H", "T"], size=1000, p=[0.5, 0.5])
</syntaxhighlight>

=== The Old API (Detect It, Then Kill It) ===

<syntaxhighlight lang="python">
# LEGACY: Global state, unpredictable seeding, slower PCG
np.random.seed(42)
np.random.rand(100) # Uniform
np.random.randn(100) # Normal
np.random.randint(0, 10, 100)

# EVERY call after np.random.seed() is a footgun in threaded code.
# Use np.random.default_rng() instead.
</syntaxhighlight>

'''OPINION: `np.random.seed()` is a code smell in 2024.''' The global RandomState is shared across all threads, libraries, and modules that import NumPy. If any of them call `np.random.seed()` or draw from the global state, your "deterministic" run is silently corrupted. The `Generator` API (`default_rng`) gives each component its own isolated stream. Use it.

=== Generators: Pick Your Poison ===

<syntaxhighlight lang="python">
from numpy.random import PCG64, Philox, SFC64, MT19937

# PCG64 — default, excellent all-rounder, tiny state (128 bits)
rng = np.random.Generator(PCG64(seed=42))

# Philox — counter-based, parallel- and GPU-friendly
rng = np.random.Generator(Philox(seed=42))

# SFC64 — fastest, small state, good statistical quality
rng = np.random.Generator(SFC64(seed=42))

# MT19937 — the old warhorse. For compatibility only.
rng = np.random.Generator(MT19937(seed=42))
</syntaxhighlight>

== The Laws of Random Number Hygiene ==

=== Law 1: Seeds Are Sacred ===

Log your seed. Better yet, log the entire RNG state if you checkpoint. If you cannot replay your simulation bit-for-bit, your paper is a PDF full of hopes and feelings.

=== Law 2: `random` ≠ `secrets` ===

Print this on a sticky note and attach it to your monitor:

'''`random` is for dice. `secrets` is for keys.'''

If your code generates a session ID, password reset token, or API key with `random`, delete it and start over.

=== Law 3: Vectorize or Die ===

Generating 10 million random numbers in a Python `for` loop calling `random.random()` is the computational equivalent of eating soup with a fork. Use `numpy.random.Generator.random(10_000_000)`. It will be 50–200× faster and your CPU will not file a grievance.

=== Law 4: Never Seed With System Time in a Loop ===

Seeding with `time.time()` inside a tight loop (we see this in the wild) produces identical "random" sequences every iteration because the clock hasn't ticked. This is not a subtle bug — it is a disaster with a straight face. If you must reseed quickly, use `secrets.randbits(128)` as the seed.

=== Law 5: Beware the Birthday Paradox ===

You need only <math>\sqrt{n}</math> samples before collisions appear. For 32-bit random IDs, that is ~77,000. If you are generating IDs with `random.getrandbits(32)`, expect a duplicate by row 65,536. Use 128-bit tokens (`secrets.token_hex(16)`) and the collision probability becomes cosmically negligible.

== Common Patterns, Done Right ==

=== Pattern: Monte Carlo Integration ===

<syntaxhighlight lang="python">
import numpy as np

def estimate_pi(n: int, rng=None) -> float:
"""Estimate π by throwing darts at a unit square."""
if rng is None:
rng = np.random.default_rng()
x = rng.random(n)
y = rng.random(n)
inside = np.sum(x**2 + y**2 <= 1.0)
return 4.0 * inside / n

rng = np.random.default_rng(seed=42)
print(estimate_pi(10_000_000, rng=rng)) # 3.1415...
</syntaxhighlight>

=== Pattern: Reservoir Sampling (Streaming Data) ===

<syntaxhighlight lang="python">
import random

def reservoir_sample(stream, k: int, rng=None):
"""Reservoir-sample k items from a streaming iterable."""
if rng is None:
rng = random.Random()
reservoir = []
for i, item in enumerate(stream):
if i < k:
reservoir.append(item)
else:
j = rng.randrange(i + 1)
if j < k:
reservoir[j] = item
return reservoir
</syntaxhighlight>

=== Pattern: Cryptographic Salt / Token ===

<syntaxhighlight lang="python">
import secrets

def make_session_id() -> str:
"""256-bit session ID, URL-safe. ~43 characters."""
return secrets.token_urlsafe(32)

def make_api_key() -> str:
"""Hex-encoded 256-bit API key. 64 characters."""
return secrets.token_hex(32)
</syntaxhighlight>

=== Pattern: Train/Test Split (Reproducible) ===

<syntaxhighlight lang="python">
import numpy as np

rng = np.random.default_rng(seed=8675309)
indices = rng.permutation(len(data))
split = int(0.8 * len(data))
train_idx, test_idx = indices[:split], indices[split:]
</syntaxhighlight>

== What About `os.urandom`? ==

`os.urandom(n)` is the bedrock — it returns ''n'' bytes from the OS CSPRNG. `secrets` is a thin, opinionated wrapper around it. Use `secrets` for structured randomness (tokens, integers, choices). Use `os.urandom` directly only when you need raw bytes or are building your own crypto primitives (and if you are doing that, you already know why you are here).

== What About C++'s `<random>`? ==

Look, I have written C++. I have loved C++. But generating a random integer in modern C++ looks like this:

<syntaxhighlight lang="cpp">
#include <random>
#include <iostream>

int main() {
std::random_device rd;
std::mt19937 gen(rd());
std::uniform_int_distribution<> dist(1, 6);
std::cout << dist(gen) << '\n';
}
</syntaxhighlight>

Python:

<syntaxhighlight lang="python">
import random
print(random.randint(1, 6))
</syntaxhighlight>

The C++ version is five lines. It pulls in three headers. It instantiates three objects from three different classes. '''For a die roll.''' And every single one of those lines has a sharp edge: `std::random_device` can be deterministic on MinGW. `std::mt19937` produces biased results if you use modulo instead of `uniform_int_distribution`. The boilerplate-to-value ratio is off the charts.

'''Use Python. Your numerical code will be shorter, correcter, and you will finish before lunch.'''

== See Also ==

* [[Numerics]] — the full numerical recipes catalog
* [[Numerics/Monte Carlo]] — Monte Carlo methods done right
* [[Numerics/Statistical Descriptions of Data]] — descriptive statistics
* [[Numerics/Classification and Inference]] — Bayesian and frequentist inference
* [https://docs.python.org/3/library/random.html Python `random` documentation]
* [https://docs.python.org/3/library/secrets.html Python `secrets` documentation]
* [https://numpy.org/doc/stable/reference/random/index.html NumPy random documentation]
* [https://www.pcg-random.org/ PCG Random — the PCG family explained]

[[Category:Numerics]]
[[Category:Python]]
[[Category:Random]]

← Older revision		Revision as of 10:58, 24 June 2026
Line 1:		Line 1:
	'''Random numbers''' are one of those things that sound dead simple — "just give me a number I can't predict, right?" - but then the rabbit hole opens up and suddenly you're comparing Mersenne Twister state spaces and wondering if your Monte Carlo simulation is actually converged.		'''Random numbers''' are one of those things that sound dead simple - "just give me a number I can't predict, right?" - but then the rabbit hole opens up and suddenly you're comparing Mersenne Twister state spaces and wondering if your Monte Carlo simulation is actually converged.

	This page is the Python-centric tour through random number generation: what actually works, what's secretly broken, and how to wield these tools without accidentally turning your simulation into a deterministic paperweight. If you stumbled here looking for C++ <code>rand()</code> quirks, check out the sister page '''[[Random Numbers]]''' — but for numerical work, you want to be here.		This page is the Python-centric tour through random number generation: what actually works, what's secretly broken, and how to wield these tools without accidentally turning your simulation into a deterministic paperweight. If you stumbled here looking for C++ <code>rand()</code> quirks, check out the sister page '''[[Random Numbers]]''' - but for numerical work, you want to be here.

	== The Two Kinds of Random ==		== The Two Kinds of Random ==
Line 11:		Line 11:
	! Type !! Where it comes from !! Use it for...		! Type !! Where it comes from !! Use it for...
	\|-		\|-
	\| '''True random''' \|\| Physical entropy — radioactive decay, thermal noise, keyboard mash-timing, hardware RNGs, <code>/dev/random</code> \|\| Cryptography, key generation, anything where predictability = disaster		\| '''True random''' \|\| Physical entropy - radioactive decay, thermal noise, keyboard mash-timing, hardware RNGs, <code>/dev/random</code> \|\| Cryptography, key generation, anything where predictability = disaster
	\|-		\|-
	\| '''Pseudorandom (PRNG)''' \|\| A deterministic algorithm starting from a seed \|\| Simulations, Monte Carlo, randomized algorithms, games, reproducible science		\| '''Pseudorandom (PRNG)''' \|\| A deterministic algorithm starting from a seed \|\| Simulations, Monte Carlo, randomized algorithms, games, reproducible science
	\|}		\|}

	True random is beautiful but slow and you can't replay it. Pseudorandom is fast, reproducible, and — if the algorithm is good — statistically indistinguishable from the real thing for most purposes. The rest of this page is about PRNGs, because that's what 99% of numerical work needs.		True random is beautiful but slow and you can't replay it. Pseudorandom is fast, reproducible, and - if the algorithm is good - statistically indistinguishable from the real thing for most purposes. The rest of this page is about PRNGs, because that's what 99% of numerical work needs.

	== Pseudorandom Number Generators: Controlled Chaos ==		== Pseudorandom Number Generators: Controlled Chaos ==
Line 26:		Line 26:
	<math>X_{n+1} = (aX_n + c) \bmod m</math>		<math>X_{n+1} = (aX_n + c) \bmod m</math>

	This is the LCG — the Honda Civic of random number generators. It's everywhere (including C's <code>rand()</code>), it's fast, and it's... fine, for very loose definitions of "fine." LCGs have lousy statistical properties in low dimensions — if you plot consecutive pairs <math>(X_n, X_{n+1})</math> as points in 2D, they fall on a small number of parallel planes. This is the Marsaglia effect and it's kind of horrifying once you see it.		This is the LCG - the Honda Civic of random number generators. It's everywhere (including C's <code>rand()</code>), it's fast, and it's... fine, for very loose definitions of "fine." LCGs have lousy statistical properties in low dimensions - if you plot consecutive pairs <math>(X_n, X_{n+1})</math> as points in 2D, they fall on a small number of parallel planes. This is the Marsaglia effect and it's kind of horrifying once you see it.

	=== The Workhorse: Mersenne Twister (MT19937) ===		=== The Workhorse: Mersenne Twister (MT19937) ===

	Python's <code>random</code> module uses the Mersenne Twister under the hood — specifically MT19937, with a period of <math>2^{19937} - 1</math> (yes, that's a Mersenne prime, hence the name). The period is so absurdly long that you will never, ever exhaust it. The state is 624 32-bit integers, or about 2.5 KB. It passes most statistical test suites with flying colors.		Python's <code>random</code> module uses the Mersenne Twister under the hood - specifically MT19937, with a period of <math>2^{19937} - 1</math> (yes, that's a Mersenne prime, hence the name). The period is so absurdly long that you will never, ever exhaust it. The state is 624 32-bit integers, or about 2.5 KB. It passes most statistical test suites with flying colors.

	It is ''not'' cryptographically secure. If an attacker can observe 624 consecutive outputs, they can reconstruct the entire internal state and predict every future number. For science and simulation this is irrelevant — for crypto it's a dealbreaker. Keep reading.		It is ''not'' cryptographically secure. If an attacker can observe 624 consecutive outputs, they can reconstruct the entire internal state and predict every future number. For science and simulation this is irrelevant - for crypto it's a dealbreaker. Keep reading.

	== Python's <code>random</code> Module: Batteries Included ==		== Python's <code>random</code> Module: Batteries Included ==
Line 46:		Line 46:
	\| <code>random.random()</code> \|\| Float in [0.0, 1.0). This is the one you'll call 90% of the time.		\| <code>random.random()</code> \|\| Float in [0.0, 1.0). This is the one you'll call 90% of the time.
	\|-		\|-
	\| <code>random.randint(a, b)</code> \|\| Random integer in [a, b] — inclusive on both ends. Yes, <code>randint(0, 10)</code> can give you 10.		\| <code>random.randint(a, b)</code> \|\| Random integer in [a, b] - inclusive on both ends. Yes, <code>randint(0, 10)</code> can give you 10.
	\|-		\|-
	\| <code>random.randrange(start, stop, step)</code> \|\| Like <code>range()</code> but returns one random element. <code>randrange(0, 10)</code> gives ~~0–9~~.		\| <code>random.randrange(start, stop, step)</code> \|\| Like <code>range()</code> but returns one random element. <code>randrange(0, 10)</code> gives 0-9.
	\|-		\|-
	\| <code>random.choice(seq)</code> \|\| Grab a random element from a sequence. O(1) for lists.		\| <code>random.choice(seq)</code> \|\| Grab a random element from a sequence. O(1) for lists.
Line 75:		Line 75:
	== NumPy's Random: When the Stakes Get Higher ==		== NumPy's Random: When the Stakes Get Higher ==

	The <code>random</code> module is fine for one-at-a-time random numbers, but numerical work often needs ''millions'' of them, fast. NumPy's random subsystem does exactly that — vectorized, tight C loops, and way more distributions than the stdlib.		The <code>random</code> module is fine for one-at-a-time random numbers, but numerical work often needs ''millions'' of them, fast. NumPy's random subsystem does exactly that - vectorized, tight C loops, and way more distributions than the stdlib.

	=== The API Schism: Old Way vs. New Way ===		=== The API Schism: Old Way vs. New Way ===
Line 100:		Line 100:
	</syntaxhighlight>		</syntaxhighlight>

	The <code>Generator</code> API gives you basically every distribution known to statistics — uniform, normal, exponential, gamma, beta, binomial, Poisson, chi-square, F, t, Laplace, logistic, lognormal, multinomial, multivariate normal, Dirichlet, Wishart... the list goes on. It's a statistical candy store.		The <code>Generator</code> API gives you basically every distribution known to statistics - uniform, normal, exponential, gamma, beta, binomial, Poisson, chi-square, F, t, Laplace, logistic, lognormal, multinomial, multivariate normal, Dirichlet, Wishart... the list goes on. It's a statistical candy store.

	=== Why PCG64 Over MT19937? ===		=== Why PCG64 Over MT19937? ===

	PCG64 is a permuted congruential generator. It has better statistical properties than MT19937, a smaller state (128 bits — just two integers), and supports ''multiple independent streams'' via <code>SeedSequence</code>. It's also faster. The only real win MT19937 has is that the period is absurdly large, but PCG64's period of <math>2^{128}</math> is still "you'll never exhaust it in a billion lifetimes" territory.		PCG64 is a permuted congruential generator. It has better statistical properties than MT19937, a smaller state (128 bits - just two integers), and supports ''multiple independent streams'' via <code>SeedSequence</code>. It's also faster. The only real win MT19937 has is that the period is absurdly large, but PCG64's period of <math>2^{128}</math> is still "you'll never exhaust it in a billion lifetimes" territory.

	== A Tour Through the Distributions ==		== A Tour Through the Distributions ==
Line 140:		Line 140:

	# '''Seed once, at the top.''' Never inside a loop. You already knew this, but everyone does it at least once.		# '''Seed once, at the top.''' Never inside a loop. You already knew this, but everyone does it at least once.
	# '''Use <code>SeedSequence</code> for parallel work.''' If you're running 8 MPI processes or 32 <code>joblib</code> workers, you don't want them all using the same stream. <code>SeedSequence</code> derives independent seeds from one parent seed — it's basically entropy-aware seed spawning and it's kind of genius.		# '''Use <code>SeedSequence</code> for parallel work.''' If you're running 8 MPI processes or 32 <code>joblib</code> workers, you don't want them all using the same stream. <code>SeedSequence</code> derives independent seeds from one parent seed - it's basically entropy-aware seed spawning and it's kind of genius.
	# '''Record your seed.''' Stick it in a config file, a log line, or a comment. Future you will thank present you.		# '''Record your seed.''' Stick it in a config file, a log line, or a comment. Future you will thank present you.

Line 179:		Line 179:
	=== Why MT19937 Is NOT Crypto-Safe ===		=== Why MT19937 Is NOT Crypto-Safe ===

	The Mersenne Twister is a linear recurrence. Observe 624 consecutive 32-bit outputs and you can solve for the entire internal state with linear algebra. After that you can predict every future output and reconstruct every past output. The <code>random</code> module even warns about this in its docs — it's not suitable for security purposes. Use <code>secrets</code> or <code>os.urandom()</code> directly.		The Mersenne Twister is a linear recurrence. Observe 624 consecutive 32-bit outputs and you can solve for the entire internal state with linear algebra. After that you can predict every future output and reconstruct every past output. The <code>random</code> module even warns about this in its docs - it's not suitable for security purposes. Use <code>secrets</code> or <code>os.urandom()</code> directly.

	== Practical Gotchas: Stuff That Will Bite You ==		== Practical Gotchas: Stuff That Will Bite You ==
Line 201:		Line 201:
	=== Parallel RNG: Independent Streams or Bust ===		=== Parallel RNG: Independent Streams or Bust ===

	If you spawn 8 parallel processes and each seeds with the current time, you might get collisions. Worse, if you seed them all with the same seed (or with seeds 0,1,2,...7), the streams might be correlated. <code>SeedSequence</code> + PCG64 makes this basically foolproof — use it.		If you spawn 8 parallel processes and each seeds with the current time, you might get collisions. Worse, if you seed them all with the same seed (or with seeds 0,1,2,...7), the streams might be correlated. <code>SeedSequence</code> + PCG64 makes this basically foolproof - use it.

	=== The <code>random.random() * N</code> Subtle Bias ===		=== The <code>random.random() * N</code> Subtle Bias ===

	Multiplying a uniform float by N and flooring to get an integer index can introduce tiny biases due to floating-point representation. For casual use it's fine, but if you're doing something like lottery draw simulations where every bit of uniformity counts, use <code>randint</code> or <code>randrange</code> — they use rejection sampling internally to guarantee uniformity.		Multiplying a uniform float by N and flooring to get an integer index can introduce tiny biases due to floating-point representation. For casual use it's fine, but if you're doing something like lottery draw simulations where every bit of uniformity counts, use <code>randint</code> or <code>randrange</code> - they use rejection sampling internally to guarantee uniformity.

	== See Also ==		== See Also ==

	* '''[[Random Numbers]]''' — The C++ page exploring <code>rand()</code> weirdness (the one that kicked all this off)		* '''[[Random Numbers]]''' - The C++ page exploring <code>rand()</code> weirdness (the one that kicked all this off)
	* '''[[Numerics/Statistical Descriptions of Data]]''' — Making sense of the numbers once you've generated them		* '''[[Numerics/Statistical Descriptions of Data]]''' - Making sense of the numbers once you've generated them

	[[Category:Numerics]]		[[Category:Numerics]]