smolpy-engine-rs 1.8.0__tar.gz

smolpy_engine_rs-1.8.0/Cargo.lock

@@ -0,0 +1,277 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "block-buffer"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d2f6c7dbe95a6ed67ad9f18e57daf93a2f034c524b99fd2b76d18fdfeb6660aa"
+dependencies = [
+ "hybrid-array",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e7648175b45a9a48536d676f68d918270699102aa8dab5496df06904c914600"
+
+[[package]]
+name = "const-oid"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be95d4a884358a21a199689323c29e9256b4a1b315e22f183d155422041d3a9a"
+
+[[package]]
+name = "cpufeatures"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ca28b0ae3115b884660db4118d803791fd6756b6e88f39c0f3f7859060d7566"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ce6e4c961d6cd6c9a86db418387425e8bdeaf05b3c8bc1411e6dca4c252f1453"
+dependencies = [
+ "hybrid-array",
+]
+
+[[package]]
+name = "digest"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1dd6dbb5841937940781866fa1281a1ff7bd3bf827091440879f9994983d5c2"
+dependencies = [
+ "block-buffer",
+ "const-oid",
+ "crypto-common",
+]
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hybrid-array"
+version = "0.4.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "27f864f10dfb56725ce5ce5472bc52252c8f93a4ab86327122cebf62c5f59a17"
+dependencies = [
+ "typenum",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3bd1574e617a9a6c1f8f8181bd7e841e1f20e4277607ef28945765188d6284d4"
+
+[[package]]
+name = "libc"
+version = "0.2.191"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "65cd87c9a6d60536580b316ad985726104730a5151c99845f2490428ef91240a"
+
+[[package]]
+name = "memchr"
+version = "2.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98"
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "portable-atomic"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05c8b63e8d9609db387f0324918f81d68fe27748f084ef092fb35954d0539a85"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.107"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.30.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "229ca13b8a15bb0d1487b81ab975bfcd97513416499a8312011b6036e42e0de4"
+dependencies = [
+ "libc",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.30.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "70130e2b6dd1ee589a8788026a429561ca5c40fa7a2fa7914c2282eddae24700"
+dependencies = [
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.30.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e7ff73c555c286d212d4ce7e5fbda845a973c4f61bd5f160f5f2c3c2a04d1c4"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.30.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c46d2e5862c7bb8207e3b639f713dda3c499933444784154c11d013c5a691b60"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.30.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "38b89f066f2ae72a2aef52d1537ca2fcd104440ebfadee06e97aa90738a25b9b"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "serde"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4148590afebada386688f18773da617792bf2ef03ffc1e4cbd2b1d45b023e0ba"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67dca2c9c51e58a4791a4b1ed58308b39c64224d349a935ab5039aa360942a48"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.229"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7a5d71263a5a7d47b41f6b3f06ba276f10cc18b0931f1799f710578e2309348"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.154"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7e9cc8b1b85264074fbcc02a88680c4096b1e47df8f739dceb03bf482f04bd6"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "sha2"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47d7069beb7d6ac7b9acd1039986e73443f24234f41074da099d6f994ac9ad19"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "smol-engine"
+version = "1.8.0"
+dependencies = [
+ "serde_json",
+ "sha2",
+]
+
+[[package]]
+name = "smolpy-engine-rs"
+version = "1.8.0"
+dependencies = [
+ "pyo3",
+ "smol-engine",
+]
+
+[[package]]
+name = "syn"
+version = "3.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ae9ccbea3a7b0b09443036490c8f34a8b1b760fd345e5c0dae0aac718faea79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.13.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c447be3a2abfa84b2d91680c56600bd6b2873866de27b36ec911be705e291da"
+
+[[package]]
+name = "typenum"
+version = "1.20.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2c754d6c33795a1c324727428e5a7dedb5b06195f9890bdbcba760d3e246563"
+
+[[package]]
+name = "zmij"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b"

smolpy_engine_rs-1.8.0/Cargo.toml

@@ -0,0 +1,13 @@
+[workspace]
+members = ["smol-engine", "smolpy-engine-rs"]
+resolver = "2"
+
+[workspace.package]
+version = "1.8.0"
+edition = "2021"
+license = "MIT"
+repository = "https://github.com/jwszolek/SMOLPy"
+
+[profile.release]
+lto = "fat"
+codegen-units = 1

smolpy_engine_rs-1.8.0/PKG-INFO

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: smolpy-engine-rs
+Version: 1.8.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Rust
+Classifier: Topic :: System :: Networking
+Classifier: Topic :: Scientific/Engineering
+Summary: Native Rust simulation engine for SMOLPy: SimPy's results bit for bit, about 40x faster
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Documentation, https://jwszolek.github.io/SMOLPy/
+Project-URL: Homepage, https://github.com/jwszolek/SMOLPy
+Project-URL: Source, https://github.com/jwszolek/SMOLPy/tree/main/rust
+
+# smolpy-engine-rs
+
+The native simulation engine of [SMOLPy](https://github.com/jwszolek/SMOLPy), a network description language and discrete-event simulator for industrial networks. It is written in Rust and exposed to Python with PyO3 ([ADR-0008](https://jwszolek.github.io/SMOLPy/adr/0008-rust-des-engine-mvp/)).
+
+```bash
+pip install smolpy smolpy-engine-rs
+```
+
+```python
+result = net.simulate(duration=60_000, backend="rust")
+```
+
+- **The same model as SimPy.** SimPy, SMOLPy's reference engine, and this engine implement the same written contract, [Model Semantics](https://jwszolek.github.io/SMOLPy/model-semantics/). On deterministic scenarios they give the same results bit for bit, down to the event count. On random traffic, which uses each engine's own generator, they agree statistically.
+- **About 40x faster.**
+    - B1 at 10 M frames runs in 4.9 s, against 200.8 s on SimPy.
+    - A 10 201-node plant (B4) at 100 M frames runs in 5.2 min, against 106 min.
+- **Scope so far.**
+    - Adapters, switches (both QoS modes, learning and converged MAC tables), links, and flows with every pattern and IMIX sizes.
+    - The metrics `throughput`, `latency`, `bytes_sent`, `bytes_received`, `queue_depth` and `utilization`.
+    - MQTT, Modbus TCP and PROFINET follow. A scenario that uses them is rejected before the run, with a message naming the element.
+- **Versions.** The package is released together with `smolpy`, with the same version. It checks that it reads the Scenario IR version that `smolpy` writes.
+
+One abi3 wheel per platform serves every Python from 3.10: Linux x86_64 and aarch64, macOS arm64 and x86_64, and Windows x86_64.
+

smolpy_engine_rs-1.8.0/README.md

@@ -0,0 +1,23 @@
+# smolpy-engine-rs
+
+The native simulation engine of [SMOLPy](https://github.com/jwszolek/SMOLPy), a network description language and discrete-event simulator for industrial networks. It is written in Rust and exposed to Python with PyO3 ([ADR-0008](https://jwszolek.github.io/SMOLPy/adr/0008-rust-des-engine-mvp/)).
+
+```bash
+pip install smolpy smolpy-engine-rs
+```
+
+```python
+result = net.simulate(duration=60_000, backend="rust")
+```
+
+- **The same model as SimPy.** SimPy, SMOLPy's reference engine, and this engine implement the same written contract, [Model Semantics](https://jwszolek.github.io/SMOLPy/model-semantics/). On deterministic scenarios they give the same results bit for bit, down to the event count. On random traffic, which uses each engine's own generator, they agree statistically.
+- **About 40x faster.**
+    - B1 at 10 M frames runs in 4.9 s, against 200.8 s on SimPy.
+    - A 10 201-node plant (B4) at 100 M frames runs in 5.2 min, against 106 min.
+- **Scope so far.**
+    - Adapters, switches (both QoS modes, learning and converged MAC tables), links, and flows with every pattern and IMIX sizes.
+    - The metrics `throughput`, `latency`, `bytes_sent`, `bytes_received`, `queue_depth` and `utilization`.
+    - MQTT, Modbus TCP and PROFINET follow. A scenario that uses them is rejected before the run, with a message naming the element.
+- **Versions.** The package is released together with `smolpy`, with the same version. It checks that it reads the Scenario IR version that `smolpy` writes.
+
+One abi3 wheel per platform serves every Python from 3.10: Linux x86_64 and aarch64, macOS arm64 and x86_64, and Windows x86_64.

smolpy_engine_rs-1.8.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["maturin>=1.7,<2"]
+build-backend = "maturin"
+
+[project]
+name = "smolpy-engine-rs"
+description = "Native Rust simulation engine for SMOLPy: SimPy's results bit for bit, about 40x faster"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+version = "1.8.0"
+classifiers = [
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Rust",
+    "Topic :: System :: Networking",
+    "Topic :: Scientific/Engineering",
+]
+
+[project.urls]
+Homepage = "https://github.com/jwszolek/SMOLPy"
+Documentation = "https://jwszolek.github.io/SMOLPy/"
+Source = "https://github.com/jwszolek/SMOLPy/tree/main/rust"
+
+[tool.maturin]
+features = ["pyo3/extension-module"]
+module-name = "smolpy_engine_rs"
+manifest-path = "smolpy-engine-rs/Cargo.toml"

smolpy_engine_rs-1.8.0/smol-engine/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "smol-engine"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+description = "SMOLPy's native discrete-event network simulation engine (ADR-0008)"
+publish = false  # shipped as the Python package smolpy-engine-rs, not on crates.io
+
+[dependencies]
+serde_json = { version = "1.0.154", features = ["arbitrary_precision"] }
+sha2 = "0.11.1"

smolpy_engine_rs-1.8.0/smol-engine/src/frames.rs

@@ -0,0 +1,29 @@
+//! Ethernet frames on the wire (ADR-0010), as `smolpy.model.frames`.
+//!
+//! A frame runs from the destination MAC to the FCS, is at least 64 B and
+//! carries an 802.1Q tag with a priority above 0. On the wire every frame is
+//! preceded by a preamble and SFD (8 B) and followed by an inter-frame gap
+//! (12 B).
+
+pub const VLAN_TAG_BYTES: u64 = 4;
+pub const PREAMBLE_SFD_BYTES: u64 = 8;
+pub const IFG_BYTES: u64 = 12;
+pub const WIRE_OVERHEAD_BYTES: u64 = PREAMBLE_SFD_BYTES + IFG_BYTES;
+
+/// A flow frame of `size` bytes (untagged, FCS included), with the tag a
+/// priority above 0 needs.
+pub fn flow_frame_size(size: u64, priority: u8) -> u64 {
+    size + if priority > 0 { VLAN_TAG_BYTES } else { 0 }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn flow_frames() {
+        assert_eq!(flow_frame_size(100, 0), 100);
+        assert_eq!(flow_frame_size(100, 3), 104);
+        assert_eq!(WIRE_OVERHEAD_BYTES, 20);
+    }
+}

smolpy_engine_rs-1.8.0/smol-engine/src/lib.rs

@@ -0,0 +1,18 @@
+//! SMOLPy's native discrete-event engine (ADR-0008): a second implementation
+//! of the semantics contract (docs/model-semantics.md), with no Python
+//! dependency. `smolpy-engine-rs` exposes it to Python.
+
+pub mod frames;
+pub mod rng;
+pub mod scenario;
+pub mod sim;
+pub mod timebase;
+
+pub use scenario::CAPABILITIES;
+pub use sim::Outcome;
+
+/// Read a Scenario IR JSON document and run it.
+pub fn run_json(text: &str) -> Result<Outcome, String> {
+    let scenario = scenario::parse(text)?;
+    sim::run(&scenario)
+}

smolpy_engine_rs-1.8.0/smol-engine/src/rng.rs

@@ -0,0 +1,174 @@
+//! Random streams (Model Semantics §6) and the distributions of the traffic
+//! patterns.
+//!
+//! - **Streams.** Every traffic statement has a stable source id,
+//!   `"<kind>:<from>-><to>#<k>"`, and its generator is seeded from the first
+//!   8 bytes, big-endian, of SHA-256 of `"<run seed>:<source id>"`, exactly
+//!   as `smolpy.model.streams`.
+//! - **Generator.** The engine's own: xoshiro256** seeded through SplitMix64.
+//!   Its draws differ from SimPy's `random.Random`, so stochastic scenarios
+//!   are compared statistically (ADR-0009).
+//! - **Distributions** use the formulas of Python's `random` module, so the
+//!   two engines draw from the same distributions.
+
+use sha2::{Digest, Sha256};
+
+/// The stream seed of a traffic statement.
+pub fn stream_seed(run_seed: u64, source_id: &str) -> u64 {
+    let digest = Sha256::digest(format!("{run_seed}:{source_id}").as_bytes());
+    u64::from_be_bytes(digest[..8].try_into().unwrap())
+}
+
+/// xoshiro256** (Blackman and Vigna), seeded through SplitMix64.
+pub struct Rng {
+    s: [u64; 4],
+}
+
+impl Rng {
+    pub fn new(seed: u64) -> Rng {
+        let mut x = seed;
+        let mut next = || {
+            x = x.wrapping_add(0x9E37_79B9_7F4A_7C15);
+            let mut z = x;
+            z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
+            z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
+            z ^ (z >> 31)
+        };
+        Rng {
+            s: [next(), next(), next(), next()],
+        }
+    }
+
+    fn next_u64(&mut self) -> u64 {
+        let s = &mut self.s;
+        let result = s[1].wrapping_mul(5).rotate_left(7).wrapping_mul(9);
+        let t = s[1] << 17;
+        s[2] ^= s[0];
+        s[3] ^= s[1];
+        s[1] ^= s[2];
+        s[0] ^= s[3];
+        s[2] ^= t;
+        s[3] = s[3].rotate_left(45);
+        result
+    }
+
+    /// Uniform on [0, 1), with 53 random bits as `random.random()`.
+    pub fn random(&mut self) -> f64 {
+        (self.next_u64() >> 11) as f64 * (1.0 / (1u64 << 53) as f64)
+    }
+
+    /// `random.expovariate(lambd)`: `-log(1 - random()) / lambd`.
+    pub fn expovariate(&mut self, lambd: f64) -> f64 {
+        -(1.0 - self.random()).ln() / lambd
+    }
+
+    /// `random.paretovariate(alpha)`: `(1 - random()) ** (-1 / alpha)`.
+    pub fn paretovariate(&mut self, alpha: f64) -> f64 {
+        (1.0 - self.random()).powf(-1.0 / alpha)
+    }
+
+    /// `random.uniform(a, b)`: `a + (b - a) * random()`.
+    pub fn uniform(&mut self, a: f64, b: f64) -> f64 {
+        a + (b - a) * self.random()
+    }
+}
+
+/// Group sizes of the `batch` pattern, as `smolpy.core.batch.BatchSpec`.
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Batch {
+    Fixed(u64),
+    Geom(f64),
+    Pareto(f64),
+}
+
+impl Batch {
+    /// E[X], with the same zeta approximation as the reference engine.
+    pub fn mean(self) -> f64 {
+        match self {
+            Batch::Fixed(k) => k as f64,
+            Batch::Geom(m) => m,
+            Batch::Pareto(a) => zeta(a),
+        }
+    }
+
+    pub fn draw(self, rng: &mut Rng) -> u64 {
+        match self {
+            Batch::Fixed(k) => k,
+            Batch::Geom(m) => {
+                let p = 1.0 / m;
+                if p >= 1.0 {
+                    return 1;
+                }
+                // inverse transform for the geometric distribution on {1, 2, ...}
+                let u = 1.0 - rng.random(); // in (0, 1]
+                1 + (u.ln() / (1.0 - p).ln()) as u64
+            }
+            Batch::Pareto(a) => (rng.paretovariate(a) as u64).max(1),
+        }
+    }
+}
+
+/// Riemann zeta(s) for s > 1: direct sum plus an Euler-Maclaurin tail, as
+/// `smolpy.core.batch._zeta` (whose sum is exact; this one is compensated).
+pub fn zeta(s: f64) -> f64 {
+    let terms = 10_000;
+    let n = terms as f64;
+    let (mut sum, mut c) = (0.0f64, 0.0f64);
+    for k in 1..terms {
+        let y = (k as f64).powf(-s) - c;
+        let t = sum + y;
+        c = (t - sum) - y;
+        sum = t;
+    }
+    let tail = n.powf(1.0 - s) / (s - 1.0) + 0.5 * n.powf(-s) + s * n.powf(-s - 1.0) / 12.0;
+    sum + tail
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn stream_seed_is_a_sha256_prefix() {
+        // the value of Model Semantics §6 and tests/test_semantics.py
+        assert_eq!(stream_seed(42, "flow:a->b#0"), 5_297_917_812_165_586_412);
+    }
+
+    #[test]
+    fn a_seed_gives_the_same_draws() {
+        let (mut a, mut b) = (Rng::new(7), Rng::new(7));
+        for _ in 0..1000 {
+            assert_eq!(a.random().to_bits(), b.random().to_bits());
+        }
+        assert_ne!(Rng::new(7).random(), Rng::new(8).random());
+    }
+
+    fn mean(n: usize, mut f: impl FnMut() -> f64) -> f64 {
+        (0..n).map(|_| f()).sum::<f64>() / n as f64
+    }
+
+    #[test]
+    fn distributions_have_their_means() {
+        let mut r = Rng::new(1);
+        let n = 400_000;
+        let u = mean(n, || r.random());
+        assert!((u - 0.5).abs() < 0.003, "{u}");
+        assert!((0..n).all(|_| (0.0..1.0).contains(&r.random())));
+        let e = mean(n, || r.expovariate(1.0 / 20.0));
+        assert!((e / 20.0 - 1.0).abs() < 0.01, "{e}");
+        let p = mean(n, || r.paretovariate(3.0)); // mean a / (a - 1) = 1.5
+        assert!((p / 1.5 - 1.0).abs() < 0.01, "{p}");
+        let un = mean(n, || r.uniform(0.3, 1.2));
+        assert!((un / 0.75 - 1.0).abs() < 0.005, "{un}");
+        for batch in [Batch::Fixed(8), Batch::Geom(4.0), Batch::Pareto(2.5)] {
+            let m = mean(n, || batch.draw(&mut r) as f64);
+            assert!((m / batch.mean() - 1.0).abs() < 0.02, "{batch:?}: {m}");
+        }
+    }
+
+    #[test]
+    fn zeta_values() {
+        assert!((zeta(2.0) - std::f64::consts::PI.powi(2) / 6.0).abs() < 1e-12);
+        assert!((zeta(2.5) - 1.341_487_257_250_917).abs() < 1e-12);
+    }
+}