crc-framework 0.2.1__tar.gz → 0.2.5__tar.gz

{crc_framework-0.2.1 → crc_framework-0.2.5}/.github/workflows/release.yaml

@@ -69,7 +69,6 @@ jobs:
             3.11
             3.12
             3.13
-            3.13t
             3.14
             3.14t
       - name: Build wheels
@@ -79,12 +78,11 @@ jobs:
         with:
           target: ${{ matrix.target }}
           args: >-
-            --release 
-            --out dist 
+            --release
+            --out dist
             --find-interpreter
           sccache: "true"
           container: "off"
-          rust-toolchain: nightly-2026-01-27
       - name: Upload wheels
         uses: actions/upload-artifact@v4
         with:
@@ -102,7 +100,6 @@ jobs:
         with:
           command: sdist
           args: --out dist
-          rust-toolchain: nightly-2026-01-27
       - name: Upload sdist
         uses: actions/upload-artifact@v4
         with:

crc_framework-0.2.5/.python-version

@@ -0,0 +1 @@
+3.14

{crc_framework-0.2.1 → crc_framework-0.2.5}/Cargo.lock

@@ -15,12 +15,6 @@ dependencies = [
  "zerocopy",
 ]
 
-[[package]]
-name = "autocfg"
-version = "1.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
-
 [[package]]
 name = "cfg-if"
 version = "1.0.4"
@@ -49,7 +43,7 @@ dependencies = [
 
 [[package]]
 name = "crc-framework-core"
-version = "0.2.1"
+version = "0.2.5"
 dependencies = [
  "h3o",
  "phf",
@@ -58,7 +52,7 @@ dependencies = [
 
 [[package]]
 name = "crc-framework-rs"
-version = "0.2.1"
+version = "0.2.5"
 dependencies = [
  "crc-framework-core",
  "h3o",
@@ -137,15 +131,6 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
-[[package]]
-name = "indoc"
-version = "2.0.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706"
-dependencies = [
- "rustversion",
-]
-
 [[package]]
 name = "libc"
 version = "0.2.188"
@@ -158,15 +143,6 @@ version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
 
-[[package]]
-name = "memoffset"
-version = "0.9.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
-dependencies = [
- "autocfg",
-]
-
 [[package]]
 name = "once_cell"
 version = "1.21.4"
@@ -242,35 +218,32 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.27.2"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab53c047fcd1a1d2a8820fe84f05d6be69e9526be40cb03b73f86b6b03e6d87d"
+checksum = "cd274650b21d4bfc26a0a47587962c1edb425f69287324355cd040c3ea66071c"
 dependencies = [
- "indoc",
  "libc",
- "memoffset",
  "once_cell",
  "portable-atomic",
  "pyo3-build-config",
  "pyo3-ffi",
  "pyo3-macros",
- "unindent",
 ]
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.27.2"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b455933107de8642b4487ed26d912c2d899dec6114884214a0b3bb3be9261ea6"
+checksum = "c5e2a7d2f0d013342f295c048ad19237add5154a55b1c5a254c0ec93d4109078"
 dependencies = [
  "target-lexicon",
 ]
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.27.2"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c85c9cbfaddf651b1221594209aed57e9e5cff63c4d11d1feead529b872a089"
+checksum = "ca85c467da1bbc8d866eea5deff9cf29ea5f7785054a17da36e65bda9c05845b"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -278,9 +251,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.27.2"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a5b10c9bf9888125d917fb4d2ca2d25c8df94c7ab5a52e13313a07e050a3b02"
+checksum = "9ac53762fd065daa3194dd09337a38bd793a188100fd1a9304c4ab312d901771"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -290,13 +263,12 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.27.2"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03b51720d314836e53327f5871d4c0cfb4fb37cc2c4a11cc71907a86342c40f9"
+checksum = "4ca3a1557399783172dc5bf39cfca835157732532cba56b71d2292161e53b362"
 dependencies = [
  "heck",
  "proc-macro2",
- "pyo3-build-config",
  "quote",
  "syn 2.0.119",
 ]
@@ -345,12 +317,6 @@ dependencies = [
  "getrandom 0.3.4",
 ]
 
-[[package]]
-name = "rustversion"
-version = "1.0.23"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
-
 [[package]]
 name = "serde"
 version = "1.0.229"
@@ -429,12 +395,6 @@ version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
 
-[[package]]
-name = "unindent"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"
-
 [[package]]
 name = "version_check"
 version = "0.9.5"

{crc_framework-0.2.1 → crc_framework-0.2.5}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "crc-framework-rs"
-version = "0.2.1"
+version = "0.2.5"
 edition = "2024"
 rust-version = "1.85"
 description = "Rust-powered Python bindings for the Climate Risk Commons Framework"
@@ -18,4 +18,4 @@ crate-type = ["cdylib"]
 [dependencies]
 crc-framework-core = { path = "crates/core" }
 h3o = "=0.9.3"
-pyo3 = { version = "0.27", features = ["extension-module"] }
+pyo3 = { version = "0.29", features = ["extension-module"] }

{crc_framework-0.2.1 → crc_framework-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crc-framework
-Version: 0.2.1
+Version: 0.2.5
 Classifier: Development Status :: 3 - Alpha
 Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)
 Classifier: Operating System :: OS Independent
@@ -20,6 +20,9 @@ Author: Riskthinking.AI
 License-Expression: AGPL-3.0-or-later
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/RiskThinking/crc-framework-rs
+Project-URL: Issues, https://github.com/RiskThinking/crc-framework-rs/issues
+Project-URL: Repository, https://github.com/RiskThinking/crc-framework-rs
 
 # Climate Risk Commons Framework
 

{crc_framework-0.2.1 → crc_framework-0.2.5}/crates/core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "crc-framework-core"
-version = "0.2.1"
+version = "0.2.5"
 edition = "2024"
 rust-version = "1.85"
 description = "Core distribution and climate-risk algorithms for CRC Framework"

{crc_framework-0.2.1 → crc_framework-0.2.5}/crates/core/src/reference/curve_fitting.rs

@@ -240,6 +240,9 @@ pub(crate) fn fit_quantile_points(
     };
     let value_range = values.iter().copied().fold(f64::NEG_INFINITY, f64::max)
         - values.iter().copied().fold(f64::INFINITY, f64::min);
+    // Loop-invariant across every start, iteration and objective evaluation of
+    // this fit; summed here in the same order the objective used to sum it.
+    let weight_sum = weights.iter().sum::<f64>();
     let mut best: Option<SimplexResult> = None;
 
     for start in starts {
@@ -268,6 +271,7 @@ pub(crate) fn fit_quantile_points(
                     probabilities,
                     values,
                     weights,
+                    weight_sum,
                     value_scale,
                     truncation_atom,
                 )
@@ -403,12 +407,16 @@ fn constrain_quantile_parameters(kind: DistributionKind, parameters: &mut [f64])
     }
 }
 
+/// `weight_sum` is `weights.iter().sum()`. It is a property of the fit, not of
+/// the trial parameters, so the caller computes it once instead of having every
+/// objective evaluation re-sum the weight vector.
 fn quantile_objective(
     kind: DistributionKind,
     parameters: &[f64],
     probabilities: &[f64],
     values: &[f64],
     weights: &[f64],
+    weight_sum: f64,
     value_scale: f64,
     truncation_atom: Option<f64>,
 ) -> f64 {
@@ -425,20 +433,36 @@ fn quantile_objective(
     if tail_start.is_some_and(|cdf| !cdf.is_finite() || 1.0 - cdf <= 1.0e-12) {
         return f64::INFINITY;
     }
-    let weight_sum = weights.iter().sum::<f64>();
+    // The truncation branch is loop-invariant, so it is resolved once here
+    // rather than per knot. Both arms compute exactly what the single combined
+    // loop computed, in the same order.
     let mut loss = 0.0;
-    for ((&probability, &value), &weight) in probabilities.iter().zip(values).zip(weights) {
-        if weight == 0.0 {
-            continue;
+    match tail_start {
+        None => {
+            for ((&probability, &value), &weight) in probabilities.iter().zip(values).zip(weights) {
+                if weight == 0.0 {
+                    continue;
+                }
+                let fitted = distribution.ppf(probability);
+                if !fitted.is_finite() {
+                    return f64::INFINITY;
+                }
+                loss += weight * ((fitted - value) / value_scale).powi(2);
+            }
         }
-        let base_probability = tail_start.map_or(probability, |cdf| {
-            (cdf + probability * (1.0 - cdf)).min(1.0 - 1.0e-15)
-        });
-        let fitted = distribution.ppf(base_probability);
-        if !fitted.is_finite() {
-            return f64::INFINITY;
+        Some(cdf) => {
+            for ((&probability, &value), &weight) in probabilities.iter().zip(values).zip(weights) {
+                if weight == 0.0 {
+                    continue;
+                }
+                let base_probability = (cdf + probability * (1.0 - cdf)).min(1.0 - 1.0e-15);
+                let fitted = distribution.ppf(base_probability);
+                if !fitted.is_finite() {
+                    return f64::INFINITY;
+                }
+                loss += weight * ((fitted - value) / value_scale).powi(2);
+            }
         }
-        loss += weight * ((fitted - value) / value_scale).powi(2);
     }
     loss / weight_sum
 }
@@ -469,6 +493,17 @@ where
     let mut values: Vec<f64> = simplex.iter().map(|point| objective(point)).collect();
     let mut evaluations = values.len();
 
+    // Multi-start callers (e.g. GenExtreme's 5 shape starts) run this to
+    // completion for every start even when a start is clearly not
+    // converging. Nelder-Mead's improvement curve is front-loaded, so a
+    // start that hasn't beaten its best objective in STALL_LIMIT iterations
+    // is treated the same as one that exhausted max_iterations: it returns
+    // early as not-converged, which the caller already ranks below any
+    // converged candidate.
+    const STALL_LIMIT: usize = 300;
+    let mut best_seen = f64::INFINITY;
+    let mut stall_count = 0usize;
+
     for iteration in 0..max_iterations {
         let mut order: Vec<usize> = (0..simplex.len()).collect();
         order.sort_by(|&left, &right| values[left].total_cmp(&values[right]));
@@ -498,6 +533,22 @@ where
             };
         }
 
+        if values[best] < best_seen - objective_tolerance {
+            best_seen = values[best];
+            stall_count = 0;
+        } else {
+            stall_count += 1;
+            if stall_count >= STALL_LIMIT {
+                return SimplexResult {
+                    parameters: simplex[best].clone(),
+                    objective: values[best],
+                    converged: false,
+                    iterations: iteration,
+                    evaluations,
+                };
+            }
+        }
+
         let mut centroid = vec![0.0; dimensions];
         for &index in &order[..dimensions] {
             for (dimension, value) in centroid.iter_mut().enumerate() {

crc_framework-0.2.5/crates/core/tests/quantile_fit_golden.rs

@@ -0,0 +1,320 @@
+//! Bit-exact golden tests for the quantile Nelder-Mead fitting path.
+//!
+//! `fit_quantiles` drives `quantile_nelder_mead`, the simplex optimizer used to
+//! produce production risk-model parameters. These tests pin the exact IEEE-754
+//! bit patterns of the fitted parameters together with the simplex iteration and
+//! evaluation counts, so any change to the optimizer that is meant to be purely
+//! mechanical (allocation strategy, code motion) can be verified as producing
+//! identical output rather than merely similar output.
+//!
+//! The objective calls `exp`, `ln` and `pow` from the platform's libm, so the
+//! table is pinned to the libm that produced it (it was generated on macOS
+//! 15 / aarch64 and verified identical in both debug and release builds). Treat
+//! a mismatch on a different platform as a portability finding to investigate,
+//! not as an automatic regression, and regenerate the table only for an
+//! intentional numerical change:
+//!
+//! ```text
+//! CRC_GOLDEN_REGEN=1 cargo test -p crc-framework-core --test quantile_fit_golden -- --nocapture
+//! ```
+
+use crc_framework_core::{DistributionFamily, fit_hurdle_quantiles, fit_quantiles};
+
+/// Deterministic value generator: SplitMix64, so the cases are identical on
+/// every platform and every run without pulling in an RNG dependency.
+struct SplitMix64(u64);
+
+impl SplitMix64 {
+    fn next_u64(&mut self) -> u64 {
+        self.0 = self.0.wrapping_add(0x9E37_79B9_7F4A_7C15);
+        let mut z = self.0;
+        z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
+        z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
+        z ^ (z >> 31)
+    }
+
+    /// Uniform in [0, 1) built from the top 53 bits, i.e. exactly representable.
+    fn next_unit(&mut self) -> f64 {
+        (self.next_u64() >> 11) as f64 * (1.0 / (1u64 << 53) as f64)
+    }
+}
+
+const PROBABILITIES_WIDE: [f64; 13] = [
+    0.01, 0.05, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 0.95, 0.99,
+];
+const PROBABILITIES_NARROW: [f64; 5] = [0.1, 0.25, 0.5, 0.75, 0.9];
+
+/// A single fit problem: strictly increasing probabilities and non-decreasing
+/// values, which is what `fit_quantiles` requires.
+struct Case {
+    label: &'static str,
+    probabilities: Vec<f64>,
+    values: Vec<f64>,
+    weights: Option<Vec<f64>>,
+}
+
+/// Builds a monotone value curve by accumulating positive jitter onto a base
+/// curve, so the resulting shapes are irregular enough to exercise multi-start
+/// selection, expansion, contraction and shrink branches of the simplex.
+fn monotone_values(seed: u64, count: usize, base: f64, slope: f64, jitter: f64) -> Vec<f64> {
+    let mut rng = SplitMix64(seed);
+    let mut value = base;
+    let mut out = Vec::with_capacity(count);
+    for step in 0..count {
+        value += slope * (1.0 + step as f64 * 0.1) + jitter * rng.next_unit();
+        out.push(value);
+    }
+    out
+}
+
+fn cases() -> Vec<Case> {
+    let wide = PROBABILITIES_WIDE.to_vec();
+    let narrow = PROBABILITIES_NARROW.to_vec();
+    vec![
+        Case {
+            label: "wide-gentle",
+            probabilities: wide.clone(),
+            values: monotone_values(0x1234_5678, wide.len(), 0.0, 1.0, 0.25),
+            weights: None,
+        },
+        Case {
+            label: "wide-steep-tail",
+            probabilities: wide.clone(),
+            values: monotone_values(0xDEAD_BEEF, wide.len(), 2.0, 4.0, 3.0),
+            weights: None,
+        },
+        Case {
+            label: "wide-large-scale",
+            probabilities: wide.clone(),
+            values: monotone_values(0x0BAD_C0DE, wide.len(), 1000.0, 250.0, 90.0),
+            weights: None,
+        },
+        Case {
+            label: "wide-tiny-scale",
+            probabilities: wide.clone(),
+            values: monotone_values(0x00C0_FFEE, wide.len(), 0.001, 0.0004, 0.0002),
+            weights: None,
+        },
+        Case {
+            label: "wide-weighted",
+            probabilities: wide.clone(),
+            values: monotone_values(0xFEED_FACE, wide.len(), 5.0, 2.0, 1.5),
+            weights: Some(vec![
+                3.0, 2.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 2.0, 2.5, 4.0,
+            ]),
+        },
+        Case {
+            label: "wide-flat-then-jump",
+            probabilities: wide.clone(),
+            values: vec![
+                0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 2.0, 3.0, 5.0, 9.0, 14.0, 30.0,
+            ],
+            weights: None,
+        },
+        Case {
+            label: "narrow-gentle",
+            probabilities: narrow.clone(),
+            values: monotone_values(0xA5A5_5A5A, narrow.len(), 10.0, 3.0, 1.0),
+            weights: None,
+        },
+        Case {
+            label: "narrow-negative-support",
+            probabilities: narrow.clone(),
+            values: monotone_values(0x5150_5150, narrow.len(), -40.0, 6.0, 2.0),
+            weights: None,
+        },
+    ]
+}
+
+/// One line per (family, case) with the exact bit patterns of everything the
+/// optimizer produces. Bits, not decimals: this is the whole point of the test.
+fn fingerprint() -> Vec<String> {
+    let mut lines = Vec::new();
+    for family in DistributionFamily::ALL {
+        for case in cases() {
+            let outcome = fit_quantiles(
+                &case.probabilities,
+                &case.values,
+                case.weights.as_deref(),
+                family,
+            );
+            let rendered = match outcome {
+                Err(error) => format!("err({error})"),
+                Ok(result) => {
+                    let shape = result.distribution.shape;
+                    let loc = result.distribution.location;
+                    let scale = result.distribution.scale;
+                    let diagnostics = result.diagnostics;
+                    format!(
+                        "shape={} loc={:016x} scale={:016x} converged={} iterations={} \
+                         evaluations={} points={} rmse={:016x} nrmse={:016x} r2={:016x} \
+                         maxres={:016x}",
+                        shape
+                            .map_or_else(|| "none".to_owned(), |v| format!("{:016x}", v.to_bits())),
+                        loc.to_bits(),
+                        scale.to_bits(),
+                        diagnostics.converged,
+                        diagnostics.iterations,
+                        diagnostics.evaluations,
+                        diagnostics.point_count,
+                        diagnostics.rmse.to_bits(),
+                        diagnostics.normalized_rmse.to_bits(),
+                        diagnostics.weighted_r_squared.to_bits(),
+                        diagnostics.maximum_absolute_residual.to_bits(),
+                    )
+                }
+            };
+            lines.push(format!("{}/{} {rendered}", family.name(), case.label));
+        }
+    }
+    lines
+}
+
+#[test]
+fn quantile_fits_are_bit_identical_to_golden() {
+    let actual = fingerprint();
+
+    if std::env::var_os("CRC_GOLDEN_REGEN").is_some() {
+        println!("---BEGIN GOLDEN---");
+        for line in &actual {
+            println!("{line}");
+        }
+        println!("---END GOLDEN---");
+        return;
+    }
+
+    let expected: Vec<&str> = GOLDEN.lines().filter(|line| !line.is_empty()).collect();
+    assert_eq!(
+        actual.len(),
+        expected.len(),
+        "golden table is stale: case count changed"
+    );
+    let mut mismatches = Vec::new();
+    for (actual_line, expected_line) in actual.iter().zip(&expected) {
+        if actual_line != expected_line {
+            mismatches.push(format!(
+                "  expected: {expected_line}\n  actual:   {actual_line}"
+            ));
+        }
+    }
+    assert!(
+        mismatches.is_empty(),
+        "{} of {} quantile fits changed:\n{}",
+        mismatches.len(),
+        expected.len(),
+        mismatches.join("\n")
+    );
+}
+
+const GOLDEN: &str = include_str!("quantile_fit_golden.txt");
+
+/// Wall-clock micro-benchmark for the fitting hot path, at the knot widths the
+/// curve_fit_cdf pipeline actually uses (999 knots per curve) plus a narrower
+/// width for contrast. Both objective paths are measured, because that pipeline
+/// overwhelmingly takes the truncated (hurdle) one.
+///
+/// Ignored by default because it is a timing measurement, not an assertion:
+///
+/// ```text
+/// cargo test --release -p crc-framework-core --test quantile_fit_golden -- \
+///     --ignored --nocapture bench_wide_quantile_fits
+/// ```
+#[test]
+#[ignore = "timing benchmark, run explicitly with --ignored"]
+fn bench_wide_quantile_fits() {
+    const WARMUP_ROUNDS: usize = 2;
+    const MEASURED_ROUNDS: usize = 7;
+    const PROBLEMS: usize = 4;
+
+    /// A curve with `plateau` leading knots pinned at zero (the hurdle atom)
+    /// and a strictly increasing tail, which is the shape the pipeline feeds in.
+    fn wide_problem(knots: usize, plateau: usize, seed: u64) -> (Vec<f64>, Vec<f64>) {
+        let mut rng = SplitMix64(seed);
+        let probabilities: Vec<f64> = (1..=knots)
+            .map(|index| index as f64 / (knots as f64 + 1.0))
+            .collect();
+        let mut value = 0.0;
+        let mut values = Vec::with_capacity(knots);
+        for step in 0..knots {
+            if step >= plateau {
+                value += 0.05 + rng.next_unit() * (1.0 + step as f64 * 0.01);
+            }
+            values.push(value);
+        }
+        (probabilities, values)
+    }
+
+    for knots in [999usize, 200] {
+        let plateau = knots / 4;
+        let problems: Vec<(Vec<f64>, Vec<f64>)> = (0..PROBLEMS)
+            .map(|seed| wide_problem(knots, plateau, 0x5EED + seed as u64))
+            .collect();
+        for family in [
+            DistributionFamily::GumbelRight,
+            DistributionFamily::GenExtreme,
+        ] {
+            for truncated in [false, true] {
+                let mut failures = 0usize;
+                let mut round = || {
+                    let start = std::time::Instant::now();
+                    let mut checksum = 0u64;
+                    for (probabilities, values) in &problems {
+                        let fitted = if truncated {
+                            fit_hurdle_quantiles(
+                                probabilities,
+                                values,
+                                None,
+                                family,
+                                values[0],
+                                probabilities[plateau - 1],
+                            )
+                            .map(|result| {
+                                (
+                                    result.distribution.base().location,
+                                    result.diagnostics.tail.iterations,
+                                )
+                            })
+                        } else {
+                            fit_quantiles(probabilities, values, None, family).map(|result| {
+                                (result.distribution.location, result.diagnostics.iterations)
+                            })
+                        };
+                        match fitted {
+                            // Consume the result so nothing is optimized away.
+                            Ok((location, iterations)) => {
+                                checksum = checksum
+                                    .wrapping_mul(0x0100_0000_01b3)
+                                    .wrapping_add(location.to_bits())
+                                    .wrapping_add(iterations as u64);
+                            }
+                            Err(_) => failures += 1,
+                        }
+                    }
+                    (start.elapsed().as_secs_f64(), checksum)
+                };
+
+                for _ in 0..WARMUP_ROUNDS {
+                    round();
+                }
+                let mut timings = Vec::with_capacity(MEASURED_ROUNDS);
+                let mut checksum = 0u64;
+                for _ in 0..MEASURED_ROUNDS {
+                    let (elapsed, round_checksum) = round();
+                    checksum = round_checksum;
+                    timings.push(elapsed);
+                }
+                timings.sort_by(f64::total_cmp);
+                // A benchmark that measured only error returns would be silently
+                // meaningless, so the fit failures are reported alongside.
+                assert_eq!(failures, 0, "benchmark inputs must produce real fits");
+                println!(
+                    "knots={knots:<4} {:<11} {:<7} best {:>10.2} us/fit  median {:>10.2} us/fit  checksum {checksum:016x}",
+                    family.name(),
+                    if truncated { "hurdle" } else { "plain" },
+                    timings[0] / PROBLEMS as f64 * 1.0e6,
+                    timings[timings.len() / 2] / PROBLEMS as f64 * 1.0e6,
+                );
+            }
+        }
+    }
+}