From 8665746eab54c96be6b2f1a028461b12542b5da7 Mon Sep 17 00:00:00 2001 From: jyviko <2501648+jyviko@users.noreply.github.com> Date: Wed, 21 Oct 2026 05:14:20 -0400 Subject: [PATCH] kernel: boolean runner measures SMLib's results again on truck When SMLib's volume of a boolean result differs from truck's, the report could not tell a wrong body from a wrong SMLib measure. The runner now measures the result it exports back to truck as well, keeps that volume in the JSON, and shows it in the export column wherever it leaves SMLib's own measure or SMLib could not measure the body at all. Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01QWhMwdqJYQKQq8RCLSL1LT --- crates/kernel/examples/smlib_booleans.rs | 59 ++++++++++++++++++------ 1 file changed, 46 insertions(+), 13 deletions(-) diff --git a/crates/kernel/examples/smlib_booleans.rs b/crates/kernel/examples/smlib_booleans.rs index d1cb4f962..d5da10987 100644 --- a/crates/kernel/examples/smlib_booleans.rs +++ b/crates/kernel/examples/smlib_booleans.rs @@ -67,7 +67,7 @@ mod run { /// What one kernel made of one case: its volume, face, edge and solid counts, history shape /// and times, or why it made nothing. - #[derive(Clone, Debug, Default)] + #[derive(Clone, Debug)] struct Outcome { error: Option, empty: bool, @@ -83,6 +83,28 @@ mod run { /// SMLib only: the result's SMLib→truck export, and why it failed. export_ms: f64, export_error: Option, + /// SMLib only: truck's measure of the exported result (NaN when there is none), which + /// tells a wrong body from a wrong SMLib measure. + export_volume: f64, + } + + impl Default for Outcome { + fn default() -> Outcome { + Outcome { + error: None, + empty: false, + volume: 0.0, + faces: 0, + edges: 0, + solids: 0, + history: None, + ms: 0.0, + import_ms: 0.0, + export_ms: 0.0, + export_error: None, + export_volume: f64::NAN, + } + } } /// A history's shape: faces Kept, Modified, Split, Merged, Generated; edges from an operand @@ -208,7 +230,10 @@ mod run { let t0 = Instant::now(); let back = solidcraft_kernel::body_from_smlib(&r); o.export_ms = ms_since(t0); - o.export_error = back.err().map(|e| e.to_string()); + match back.map_err(|e| e.to_string()).and_then(|b| measure(&b).map_err(|e| format!("measure: {e}"))) { + Ok(m) => o.export_volume = m.volume, + Err(e) => o.export_error = Some(e), + } return (o, Some(r)); } } @@ -552,6 +577,7 @@ mod run { import_ms: f("import_ms"), export_ms: f("export_ms"), export_error: s("export_error"), + export_volume: f("export_volume"), } } @@ -600,6 +626,7 @@ mod run { "import_ms": o.import_ms, "export_ms": o.export_ms, "export_error": o.export_error, + "export_volume": o.export_volume, }) } @@ -650,6 +677,19 @@ mod run { } } + /// The export's time, and what went wrong with it or where truck's measure of the exported + /// body leaves SMLib's own; a dash where SMLib made no body. + fn exported(o: &Outcome) -> String { + match &o.export_error { + Some(e) => format!("{:.1} (failed: {})", o.export_ms, e.replace('|', "/")), + None if !o.export_volume.is_finite() => "–".into(), + None if o.error.is_some() || (o.export_volume - o.volume).abs() > VOLUME_REL * o.volume.abs().max(1e-9) => { + format!("{:.1} (truck measures {:.3})", o.export_ms, o.export_volume) + } + None => format!("{:.1}", o.export_ms), + } + } + /// How far a measured volume lies from the analytic one, relative; `None` when it made none. fn off(o: &Outcome, analytic: f64) -> Option { if o.error.is_some() { @@ -740,11 +780,7 @@ mod run { } } let want_text = want.map_or("–".into(), |w| if w == 0.0 { "empty".into() } else { format!("{w:.3}") }); - let back = match (&s.export_error, s.error.is_some() || s.empty) { - (_, true) => "–".into(), - (Some(e), false) => format!("{:.1} (failed: {})", s.export_ms, e.replace('|', "/")), - (None, false) => format!("{:.1}", s.export_ms), - }; + let back = exported(&s); let _ = writeln!( md, "| {name} | {} | {want_text} | {} | {} | {what} | {:.1} | {:.1} | {:.1} | {back} |", @@ -777,10 +813,7 @@ mod run { None => format!("{:.3} ({}f {}e {}s)", o.volume, o.faces, o.edges, o.solids), }, }; - let export = m.filter(|o| s.op.is_some() && o.error.is_none()).map_or("–".into(), |o| match &o.export_error { - Some(e) => format!("{:.1} (failed: {})", o.export_ms, e.replace('|', "/")), - None => format!("{:.1}", o.export_ms), - }); + let export = m.filter(|_| s.op.is_some()).map_or("–".into(), exported); let _ = writeln!( seq_md, "| {} | {:.3} ({}s) | {} | {} | {} | {} | {} | {export} |", @@ -806,8 +839,8 @@ mod run { let _ = writeln!(report, "{} cases × 3 operations: {}.\n", cases.len(), summary.join(", ")); let _ = writeln!( report, - "Failed: truck {truck_fail}/{ops}, SMLib {smlib_fail}/{ops}; SMLib results that don't export back to truck: \ - {export_fail}. Against the {analytic_ops} analytic volumes: truck within {VOLUME_REL:e} on {truck_exact}, \ + "Failed: truck {truck_fail}/{ops}, SMLib {smlib_fail}/{ops}; SMLib results that don't export back to truck \ + (or that truck can't measure): {export_fail}. Against the {analytic_ops} analytic volumes: truck within {VOLUME_REL:e} on {truck_exact}, \ SMLib within 1e-6 on {smlib_exact}.\n" ); let _ = writeln!(report, "## Times (ms, operations that didn't fail)\n");