tsdynamics 5.2.0__tar.gz → 5.2.2__tar.gz

{tsdynamics-5.2.0 → tsdynamics-5.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tsdynamics
-Version: 5.2.0
+Version: 5.2.2
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Science/Research
 Classifier: Operating System :: OS Independent

{tsdynamics-5.2.0 → tsdynamics-5.2.2}/crates/Cargo.toml

@@ -49,6 +49,22 @@ repository = "https://github.com/El3ssar/TSDynamics"
 # path here; external engine/binding deps (pyo3, numpy, rayon) are pre-pinned to
 # the versions already proven in `tsdynamics-core`. Solver-/JIT-specific deps
 # (e.g. cranelift for tsdyn-jit) are declared by their owning crate, not here.
+# Release-profile tuning for the workspace members (`tsdyn-ir`/`-vm`/`-jit`/
+# `-solvers`/`-engine`). Profiles are resolved from the root manifest of the
+# build, so this block governs any `cargo build --release` / benchmark over the
+# workspace (e.g. `rust-workspace.yml`); the wheel build does NOT pass through
+# here — it roots at the excluded `tsdyn-core` manifest, which carries its own
+# matching `[profile.release]`. `lto = "thin"` enables cross-crate inlining of
+# the hot RK / interpreter loops; `codegen-units = 1` hands each crate to the
+# optimizer as a single unit. Conventional release tuning for a numerical
+# engine, and **answer-preserving** — it changes only code generation, never the
+# IEEE-754 results, so `interp == jit`, the golden fixtures and parallel==serial
+# ensembles are bit-for-bit unchanged. Affects the release build only; `cargo
+# test` (debug) is untouched.
+[profile.release]
+lto = "thin"
+codegen-units = 1
+
 [workspace.dependencies]
 tsdyn-ir = { path = "tsdyn-ir" }
 tsdyn-vm = { path = "tsdyn-vm" }

{tsdynamics-5.2.0 → tsdynamics-5.2.2}/crates/tsdyn-core/Cargo.toml

@@ -48,3 +48,27 @@ tsdyn-engine = { path = "../tsdyn-engine" }
 # building the shipped extension; left OFF for `cargo test` so the unit-test
 # harness links libpython and runs. Kept off the default set on purpose.
 extension-module = ["pyo3/extension-module"]
+
+# Release-profile tuning for the shipped wheel.
+#
+# This crate is the maturin build root (the project's `pyproject.toml` points
+# `manifest-path` here) and is **excluded** from `crates/Cargo.toml`'s workspace,
+# so it does NOT inherit any workspace `[profile.release]` — Cargo resolves the
+# profile from the root manifest of whatever is being built, and for the wheel
+# that root is *this* manifest. Without these keys the wheel built with cargo's
+# defaults (`lto = false`, `codegen-units = 16`), which leaves the hot RK /
+# interpreter loops in `tsdyn-vm` / `tsdyn-solvers` un-inlined across crate
+# boundaries.
+#
+# `lto = "thin"` enables cross-crate inlining of the tape-evaluation and
+# solver-step hot paths (thin LTO keeps build times reasonable vs. `"fat"`);
+# `codegen-units = 1` gives the optimizer the whole crate as one unit. Both are
+# the conventional release tuning for a tight numerical kernel. They affect ONLY
+# the release build — `cargo test` (debug) is untouched — and are
+# **answer-preserving**: LTO/codegen-unit changes alter only how the same
+# floating-point operations are scheduled into machine code, never the IEEE-754
+# result, so `interp == jit`, the golden fixtures, and the parallel==serial
+# ensembles are unchanged.
+[profile.release]
+lto = "thin"
+codegen-units = 1

{tsdynamics-5.2.0 → tsdynamics-5.2.2}/crates/tsdyn-core/src/bridge/marshal.rs

@@ -9,7 +9,7 @@
 //! unchanged.
 
 use tsdyn_engine::{EventDirection, IntegrateError, MapError, SdeError};
-use tsdyn_ir::{Evaluator, Tape};
+use tsdyn_ir::{Evaluator, Op, Tape};
 use tsdyn_jit::JitEvaluator;
 use tsdyn_solvers::explicit::{Bs3, CashKarp, Dop853, HeunEuler, Rk45, Rkf45, Tsit5};
 use tsdyn_solvers::implicit::{
@@ -162,6 +162,7 @@ pub(super) fn build_evaluator_send(
 /// Mirrors the argument order of the Python `Tape.to_arrays()`:
 /// `(ops, a, b, imm, outputs, jac_outputs, n_state, n_param)`. A malformed tape
 /// is rejected here, at the boundary, as [`EngineError::BadTape`].
+#[cfg(test)] // production uses the no-copy `build_tape_owned`; kept for the cross-check test.
 #[allow(clippy::too_many_arguments)] // the eight arrays are the tape contract.
 pub fn build_tape(
     ops: &[i32],
@@ -177,6 +178,39 @@ pub fn build_tape(
         .map_err(|e| EngineError::BadTape(e.to_string()))
 }
 
+/// Build a validated [`Tape`] from **owned** wire arrays — the move (no-copy)
+/// FFI ingestion path.
+///
+/// Identical in result to `build_tape`, but takes its arrays by value: it
+/// decodes `ops` (the raw wire opcodes) into [`Op`]s **in place** (rejecting an
+/// unknown opcode as [`EngineError::BadTape`], exactly as the slice path does),
+/// then moves the already-owned `a`/`b`/`imm`/`outputs`/`jac_outputs` `Vec`s
+/// straight into [`Tape::from_parts`]. Because the caller (`crate::OwnedTape`)
+/// already owns these `Vec`s (it copied the NumPy views once so they could
+/// cross [`Python::detach`]), this avoids the second
+/// allocation `Tape::from_arrays` makes when it `to_vec`s every slice. The tape
+/// is byte-identical — `from_parts` runs the same structural validation
+/// `from_arrays` runs after its copy.
+///
+/// [`Python::detach`]: pyo3::Python::detach
+#[allow(clippy::too_many_arguments)] // the eight arrays are the tape contract.
+pub fn build_tape_owned(
+    ops: Vec<i32>,
+    a: Vec<i32>,
+    b: Vec<i32>,
+    imm: Vec<f64>,
+    outputs: Vec<i32>,
+    jac_outputs: Vec<i32>,
+    n_state: usize,
+    n_param: usize,
+) -> Result<Tape, EngineError> {
+    // Decode the wire opcodes to `Op`s; an unknown opcode is a malformed tape.
+    let decoded: Result<Vec<Op>, _> = ops.into_iter().map(Op::from_i32).collect();
+    let decoded = decoded.map_err(|e| EngineError::BadTape(e.to_string()))?;
+    Tape::from_parts(decoded, a, b, imm, outputs, jac_outputs, n_state, n_param)
+        .map_err(|e| EngineError::BadTape(e.to_string()))
+}
+
 // ---------------------------------------------------------------------------
 // Solver resolution
 // ---------------------------------------------------------------------------
@@ -379,3 +413,76 @@ pub(super) fn map_diverge_msg(e: &MapError) -> String {
 pub(super) fn sde_diverge_msg(e: &SdeError) -> String {
     format!("SDE integration diverged before reaching the final time: {e}")
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // A minimal valid wire tape: f(u) = u0 * p0 (dim 1, n_state 1, n_param 1).
+    // Wire opcodes: State=1, Param=2, Mul=12 (the v2 contract values pinned in
+    // `tsdyn_ir`'s tape tests).
+    #[allow(clippy::type_complexity)]
+    fn ok_wire() -> (Vec<i32>, Vec<i32>, Vec<i32>, Vec<f64>, Vec<i32>) {
+        let ops = vec![1, 2, 12];
+        let a = vec![0, 0, 0];
+        let b = vec![0, 0, 1];
+        let imm = vec![0.0, 0.0, 0.0];
+        let outputs = vec![2];
+        (ops, a, b, imm, outputs)
+    }
+
+    /// The move path ([`build_tape_owned`]) and the slice/copy path
+    /// ([`build_tape`]) must produce a byte-identical [`Tape`] — the no-copy
+    /// optimisation is answer-preserving.
+    #[test]
+    fn owned_path_equals_slice_path() {
+        let (ops, a, b, imm, outputs) = ok_wire();
+        let jac: Vec<i32> = vec![];
+
+        let by_slice =
+            build_tape(&ops, &a, &b, &imm, &outputs, &jac, 1, 1).expect("slice path builds");
+        let by_move = build_tape_owned(
+            ops.clone(),
+            a.clone(),
+            b.clone(),
+            imm.clone(),
+            outputs.clone(),
+            jac.clone(),
+            1,
+            1,
+        )
+        .expect("move path builds");
+
+        // `Tape` derives `PartialEq`, so this is a full structural equality.
+        assert_eq!(by_slice, by_move);
+        assert_eq!(by_move.n_reg(), 3);
+        assert_eq!(by_move.dim(), 1);
+        assert!(!by_move.has_jacobian());
+    }
+
+    /// The move path decodes opcodes in place and must reject an unknown one as
+    /// [`EngineError::BadTape`], exactly as the slice path does.
+    #[test]
+    fn owned_path_rejects_unknown_opcode() {
+        let (mut ops, a, b, imm, outputs) = ok_wire();
+        ops[2] = 99; // not a known opcode
+        let err = build_tape_owned(ops, a, b, imm, outputs, vec![], 1, 1).expect_err("must reject");
+        assert!(matches!(err, EngineError::BadTape(_)));
+    }
+
+    /// A malformed (out-of-range output) wire tape is rejected identically on the
+    /// move path and the slice path.
+    #[test]
+    fn owned_path_rejects_bad_shape_like_slice_path() {
+        let (ops, a, b, imm, _outputs) = ok_wire();
+        let bad_outputs = vec![9]; // output register 9 with only 3 instructions
+
+        let slice_err = build_tape(&ops, &a, &b, &imm, &bad_outputs, &[], 1, 1)
+            .expect_err("slice path rejects");
+        let move_err = build_tape_owned(ops, a, b, imm, bad_outputs, vec![], 1, 1)
+            .expect_err("move path rejects");
+
+        assert!(matches!(slice_err, EngineError::BadTape(_)));
+        assert_eq!(slice_err, move_err);
+    }
+}

{tsdynamics-5.2.0 → tsdynamics-5.2.2}/crates/tsdyn-core/src/bridge/mod.rs

@@ -15,7 +15,7 @@
 //! the test suite) see exactly the same `bridge::*` surface as before:
 //!
 //! - [`marshal`] — the shared FFI plumbing: the [`EngineError`] enum, the
-//!   [`VmEvaluator`] adapter + evaluator builders, [`build_tape`] ingestion,
+//!   [`VmEvaluator`] adapter + evaluator builders, `build_tape` ingestion,
 //!   [`resolve_solver`] / [`build_solver`], the input/grid/shape guards and the
 //!   divergence-message helpers. Every family entry point is built on it.
 //! - [`ode`] — [`eval_rhs`] / [`eval_jac`] / [`integrate_dense`] /
@@ -45,7 +45,9 @@ pub mod stepper;
 pub use dde::integrate_dde_dense;
 pub use events::integrate_events_dense;
 pub use map::{iterate_map, map_ensemble_final};
-pub use marshal::{build_tape, EngineError};
+#[cfg(test)]
+pub use marshal::build_tape;
+pub use marshal::EngineError;
 pub use ode::{ensemble_final, eval_jac, eval_rhs, integrate_dense};
 pub use sde::{sde_ensemble_final, sde_integrate_dense};
 pub use stepper::OdeStepper;

{tsdynamics-5.2.0 → tsdynamics-5.2.2}/crates/tsdyn-core/src/lib.rs

@@ -125,15 +125,28 @@ impl OwnedTape {
         self.outputs.len()
     }
 
-    /// Build the validated [`tsdyn_ir::Tape`] (inside the GIL release).
-    fn build(&self) -> Result<tsdyn_ir::Tape, EngineError> {
-        bridge::build_tape(
-            &self.ops,
-            &self.a,
-            &self.b,
-            &self.imm,
-            &self.outputs,
-            &self.jac_outputs,
+    /// Build the validated [`tsdyn_ir::Tape`] (inside the GIL release),
+    /// **consuming** the owned wire arrays.
+    ///
+    /// `OwnedTape` already holds owned `Vec`s (copied once, in
+    /// [`copy_in`](OwnedTape::copy_in), so they could cross the
+    /// [`Python::detach`] GIL release). Handing those `Vec`s **by value** to the
+    /// engine — decoding `ops` to [`tsdyn_ir::Op`]s in place and moving every
+    /// array into [`tsdyn_ir::Tape::from_parts`] — avoids the second allocation
+    /// the slice path ([`tsdyn_ir::Tape::from_arrays`], which re-`to_vec`s each
+    /// array) would make. The resulting `Tape` is byte-identical: `from_parts`
+    /// runs the same validation `from_arrays` does after its copy. `build` takes
+    /// `self` because each caller uses the `OwnedTape` exactly once (the system
+    /// dimension is read via [`dim`](OwnedTape::dim) *before* the GIL release, and
+    /// `build` is the tape's last use, inside the detached closure).
+    fn build(self) -> Result<tsdyn_ir::Tape, EngineError> {
+        bridge::marshal::build_tape_owned(
+            self.ops,
+            self.a,
+            self.b,
+            self.imm,
+            self.outputs,
+            self.jac_outputs,
             self.n_state,
             self.n_param,
         )

{tsdynamics-5.2.0 → tsdynamics-5.2.2}/crates/tsdyn-engine/src/ensemble.rs

@@ -120,26 +120,33 @@ where
     );
     let n_ic = u0_batch.len() / dim;
 
-    // map → collect preserves index order, so the output never depends on the
-    // order rayon happens to finish workers in.
-    let per_traj: Vec<(Vec<f64>, TrajStatus)> = (0..n_ic)
-        .into_par_iter()
-        .map(|i| {
+    // Preallocate the contiguous output and write each trajectory DIRECTLY into
+    // its own row slice in parallel. Zipping `states.par_chunks_mut(dim)` with
+    // `status.par_iter_mut()` partitions the buffers into disjoint, index-aligned
+    // pieces, so worker `i` only ever touches row `i` — no per-trajectory heap
+    // `Vec` and no second copy. The partition is positional, so the output is
+    // still in input order regardless of how rayon schedules the workers
+    // (parallel == serial bit-for-bit, the determinism contract above).
+    let mut states = vec![0.0; n_ic * dim];
+    let mut status = vec![TrajStatus::Ok; n_ic];
+    states
+        .par_chunks_mut(dim)
+        .zip(status.par_iter_mut())
+        .enumerate()
+        .for_each(|(i, (row, st))| {
             let u0 = &u0_batch[i * dim..(i + 1) * dim];
             let mut solver = make_solver(i);
             match integrate_final(ev, &mut *solver, u0, p, t0, t1, cfg) {
-                Ok(uf) => (uf, TrajStatus::Ok),
-                Err(e) => (vec![f64::NAN; dim], TrajStatus::Failed(e)),
+                Ok(uf) => {
+                    row.copy_from_slice(&uf);
+                    *st = TrajStatus::Ok;
+                }
+                Err(e) => {
+                    row.fill(f64::NAN);
+                    *st = TrajStatus::Failed(e);
+                }
             }
-        })
-        .collect();
-
-    let mut states = Vec::with_capacity(n_ic * dim);
-    let mut status = Vec::with_capacity(n_ic);
-    for (uf, s) in per_traj {
-        states.extend_from_slice(&uf);
-        status.push(s);
-    }
+        });
     EnsembleFinal {
         dim,
         states,
@@ -300,4 +307,51 @@ mod tests {
         assert_eq!(ens.n_ic(), 0);
         assert!(ens.states.is_empty());
     }
+
+    #[test]
+    fn direct_row_write_preserves_index_order_with_interleaved_failures() {
+        // Regression for the direct-into-row-slice ensemble write (no per-traj
+        // Vec + second copy): an interleaved ok/fail/ok/fail pattern must land
+        // each trajectory in its OWN row in input order, with NaN confined to the
+        // failed rows — even under a forced multi-thread pool where workers finish
+        // out of order. blowup() diverges for x0 > 0 and decays for x0 < 0.
+        let ev = VmEval::new(blowup());
+        let cfg = IntegrateConfig::new(0.01);
+        let n_ic = 64;
+        // Even index → +1 (blows up before t=2), odd index → -1 (stays finite).
+        let u0: Vec<f64> = (0..n_ic)
+            .map(|i| if i % 2 == 0 { 1.0 } else { -1.0 })
+            .collect();
+
+        let pool = rayon::ThreadPoolBuilder::new()
+            .num_threads(8)
+            .build()
+            .unwrap();
+        let ens = pool
+            .install(|| ensemble_final(&ev, |_| Box::new(Rk4::new()), &u0, &[], 0.0, 2.0, &cfg));
+
+        assert_eq!(ens.n_ic(), n_ic);
+        assert_eq!(ens.n_failed(), n_ic / 2);
+        for i in 0..n_ic {
+            if i % 2 == 0 {
+                assert!(
+                    matches!(ens.status[i], TrajStatus::Failed(_)),
+                    "row {i} should have diverged"
+                );
+                assert!(ens.row(i)[0].is_nan(), "diverged row {i} must be NaN");
+            } else {
+                assert!(ens.status[i].is_ok(), "row {i} should be finite");
+                assert!(
+                    ens.row(i)[0].is_finite(),
+                    "finite row {i} must not be NaN-smeared by a neighbour"
+                );
+                // -1 decaying under dx/dt = x²: x(t) = -1/(1+t), so x(2) = -1/3.
+                assert!(
+                    (ens.row(i)[0] - (-1.0 / 3.0)).abs() < 1e-6,
+                    "row {i}: {} vs -1/3",
+                    ens.row(i)[0]
+                );
+            }
+        }
+    }
 }

{tsdynamics-5.2.0 → tsdynamics-5.2.2}/crates/tsdyn-engine/src/map.rs

@@ -230,23 +230,31 @@ pub fn iterate_ensemble_final(
     );
     let n_ic = u0_batch.len() / dim;
 
-    let per_traj: Vec<(Vec<f64>, MapTrajStatus)> = (0..n_ic)
-        .into_par_iter()
-        .map(|i| {
+    // Preallocate the contiguous output and write each trajectory DIRECTLY into
+    // its own row slice in parallel: `states.par_chunks_mut(dim)` zipped with
+    // `status.par_iter_mut()` gives worker `i` exclusive access to row `i`, so
+    // there is no per-trajectory heap `Vec` and no second copy. The partition is
+    // positional, so the result stays in input order regardless of thread count
+    // (maps carry no per-step randomness, so this is identical run to run).
+    let mut states = vec![0.0; n_ic * dim];
+    let mut status = vec![MapTrajStatus::Ok; n_ic];
+    states
+        .par_chunks_mut(dim)
+        .zip(status.par_iter_mut())
+        .enumerate()
+        .for_each(|(i, (row, st))| {
             let u0 = &u0_batch[i * dim..(i + 1) * dim];
             match iterate_final(ev, u0, p, n_steps) {
-                Ok(uf) => (uf, MapTrajStatus::Ok),
-                Err(e) => (vec![f64::NAN; dim], MapTrajStatus::Failed(e)),
+                Ok(uf) => {
+                    row.copy_from_slice(&uf);
+                    *st = MapTrajStatus::Ok;
+                }
+                Err(e) => {
+                    row.fill(f64::NAN);
+                    *st = MapTrajStatus::Failed(e);
+                }
             }
-        })
-        .collect();
-
-    let mut states = Vec::with_capacity(n_ic * dim);
-    let mut status = Vec::with_capacity(n_ic);
-    for (uf, s) in per_traj {
-        states.extend_from_slice(&uf);
-        status.push(s);
-    }
+        });
     MapEnsembleFinal {
         dim,
         states,
@@ -521,4 +529,40 @@ mod tests {
         assert_eq!(ens.n_ic(), 0);
         assert!(ens.states.is_empty());
     }
+
+    #[test]
+    fn direct_row_write_preserves_index_order_with_interleaved_failures() {
+        // Regression for the direct-into-row-slice ensemble write (no per-traj
+        // Vec + second copy): an interleaved finite/diverging pattern must land
+        // each trajectory in its OWN row in input order with NaN confined to the
+        // diverged rows, even under a forced multi-thread pool. doubling() x←2x
+        // keeps x0=0 fixed and overflows any nonzero x0 over this horizon.
+        let ev = VmEval::new(doubling());
+        let n_ic = 64;
+        // Even index → 0 (stays at the fixed point), odd index → 1 (overflows).
+        let u0: Vec<f64> = (0..n_ic)
+            .map(|i| if i % 2 == 0 { 0.0 } else { 1.0 })
+            .collect();
+
+        let pool = rayon::ThreadPoolBuilder::new()
+            .num_threads(8)
+            .build()
+            .unwrap();
+        let ens = pool.install(|| iterate_ensemble_final(&ev, &u0, &[], 100_000));
+
+        assert_eq!(ens.n_ic(), n_ic);
+        assert_eq!(ens.n_failed(), n_ic / 2);
+        for i in 0..n_ic {
+            if i % 2 == 0 {
+                assert!(ens.status[i].is_ok(), "fixed-point row {i} should survive");
+                assert_eq!(ens.row(i), &[0.0], "fixed-point row {i} must stay 0");
+            } else {
+                assert!(
+                    matches!(ens.status[i], MapTrajStatus::Failed(_)),
+                    "row {i} should have diverged"
+                );
+                assert!(ens.row(i)[0].is_nan(), "diverged row {i} must be NaN");
+            }
+        }
+    }
 }

{tsdynamics-5.2.0 → tsdynamics-5.2.2}/crates/tsdyn-engine/src/sde.rs

@@ -368,29 +368,36 @@ where
     );
     let n_ic = u0_batch.len() / dim;
 
-    // map → collect preserves index order, so the output never depends on the
-    // order rayon finishes workers in.
-    let per_traj: Vec<(Vec<f64>, SdeTrajStatus)> = (0..n_ic)
-        .into_par_iter()
-        .map(|i| {
+    // Preallocate the contiguous output and write each trajectory DIRECTLY into
+    // its own row slice in parallel: `states.par_chunks_mut(dim)` zipped with
+    // `status.par_iter_mut()` gives worker `i` exclusive access to row `i`, so
+    // there is no per-trajectory heap `Vec` and no second copy. The partition is
+    // positional and each worker's RNG is seeded only from its index `i`
+    // (`seed_for(base_seed, i)`), so the result depends only on the index, never
+    // on thread count — parallel == serial bit-for-bit (the determinism contract).
+    let mut states = vec![0.0; n_ic * dim];
+    let mut status = vec![SdeTrajStatus::Ok; n_ic];
+    states
+        .par_chunks_mut(dim)
+        .zip(status.par_iter_mut())
+        .enumerate()
+        .for_each(|(i, (row, st))| {
             let u0 = &u0_batch[i * dim..(i + 1) * dim];
             let mut kernel = make_kernel();
             // Randomness keyed by trajectory index — the determinism contract.
             let mut rng = SplitMix64::new(seed_for(base_seed, i as u64));
             match sde_integrate_final(drift, diffusion, &mut *kernel, &mut rng, u0, p, t0, t1, cfg)
             {
-                Ok(uf) => (uf, SdeTrajStatus::Ok),
-                Err(e) => (vec![f64::NAN; dim], SdeTrajStatus::Failed(e)),
+                Ok(uf) => {
+                    row.copy_from_slice(&uf);
+                    *st = SdeTrajStatus::Ok;
+                }
+                Err(e) => {
+                    row.fill(f64::NAN);
+                    *st = SdeTrajStatus::Failed(e);
+                }
             }
-        })
-        .collect();
-
-    let mut states = Vec::with_capacity(n_ic * dim);
-    let mut status = Vec::with_capacity(n_ic);
-    for (uf, s) in per_traj {
-        states.extend_from_slice(&uf);
-        status.push(s);
-    }
+        });
     SdeEnsembleFinal {
         dim,
         states,
@@ -1105,4 +1112,109 @@ mod tests {
         assert_eq!(ens.n_ic(), 0);
         assert!(ens.states.is_empty());
     }
+
+    #[test]
+    fn direct_row_write_is_index_keyed_and_parallel_equals_serial() {
+        // Regression for the direct-into-row-slice ensemble write (no per-traj
+        // Vec + second copy). Each worker writes its OWN row and seeds its RNG
+        // only from its index, so the multi-thread result must match a serial
+        // per-index loop bit-for-bit AND each row must equal the standalone
+        // single-trajectory integration of that index's seed.
+        let drift = gbm_drift(0.1);
+        let diffusion = gbm_diffusion(0.5);
+        let cfg = SdeConfig::new(0.01);
+        let base = 0xD15EA5E;
+        let n = 128;
+        let u0 = vec![1.0; n];
+
+        let pool = rayon::ThreadPoolBuilder::new()
+            .num_threads(8)
+            .build()
+            .unwrap();
+        let parallel = pool.install(|| {
+            sde_ensemble_final(
+                &drift,
+                &diffusion,
+                || Box::new(Milstein::new()),
+                base,
+                &u0,
+                &[],
+                0.0,
+                1.0,
+                &cfg,
+            )
+        });
+
+        for i in 0..n {
+            let mut kernel = Milstein::new();
+            let mut rng = SplitMix64::new(seed_for(base, i as u64));
+            let serial = sde_integrate_final(
+                &drift,
+                &diffusion,
+                &mut kernel,
+                &mut rng,
+                &[1.0],
+                &[],
+                0.0,
+                1.0,
+                &cfg,
+            )
+            .unwrap();
+            assert!(parallel.status[i].is_ok());
+            assert_eq!(
+                parallel.row(i)[0].to_bits(),
+                serial[0].to_bits(),
+                "row {i}: direct-write ensemble != serial single-trajectory",
+            );
+        }
+    }
+
+    #[test]
+    fn direct_row_write_isolates_interleaved_failures_in_order() {
+        // f(x) = x², g = 0 ⇒ deterministic finite-time blow-up for x0 = 1 and a
+        // finite decay for x0 = -1. An interleaved pattern must confine NaN to the
+        // diverged rows in input order under a forced multi-thread pool.
+        let mut b = TapeBuilder::new();
+        let x = b.state(0);
+        let f = b.mul(x, x);
+        let drift = VmEval::new(Interpreter::new(b.finish(&[f], &[], 1, 0).unwrap()));
+        let diffusion = const_diffusion(0.0);
+        let cfg = SdeConfig::new(0.01);
+        let n = 32;
+        let u0: Vec<f64> = (0..n)
+            .map(|i| if i % 2 == 0 { 1.0 } else { -1.0 })
+            .collect();
+
+        let pool = rayon::ThreadPoolBuilder::new()
+            .num_threads(8)
+            .build()
+            .unwrap();
+        let ens = pool.install(|| {
+            sde_ensemble_final(
+                &drift,
+                &diffusion,
+                || Box::new(EulerMaruyama::new()),
+                0,
+                &u0,
+                &[],
+                0.0,
+                2.0,
+                &cfg,
+            )
+        });
+
+        assert_eq!(ens.n_failed(), n / 2);
+        for i in 0..n {
+            if i % 2 == 0 {
+                assert!(
+                    matches!(ens.status[i], SdeTrajStatus::Failed(_)),
+                    "row {i} should have diverged"
+                );
+                assert!(ens.row(i)[0].is_nan(), "diverged row {i} must be NaN");
+            } else {
+                assert!(ens.status[i].is_ok(), "row {i} should stay finite");
+                assert!(ens.row(i)[0].is_finite());
+            }
+        }
+    }
 }