transform-tree 0.0.6__tar.gz → 0.0.7__tar.gz

{transform_tree-0.0.6 → transform_tree-0.0.7}/Cargo.toml

@@ -20,7 +20,7 @@ exclude = [
 
 [workspace.package]
 # 0.0.x: every release may break every other (`SUPPORT.md`).
-version = "0.0.6"
+version = "0.0.7"
 edition = "2021"
 # 1.87 is forced by `ruzstd 0.9.0` (`tf_tree_ingest`). The `msrv` job reads this
 # field; policy in `SUPPORT.md`.
@@ -57,16 +57,16 @@ unexpected_cfgs = { level = "warn", check-cfg = ['cfg(loom)'] }
 
 [workspace.dependencies]
 # Intra-workspace crates.
-tf_tree_math = { path = "crates/tf_tree_math", version = "0.0.6" }
-tf_tree_arena = { path = "crates/tf_tree_arena", version = "0.0.6" }
+tf_tree_math = { path = "crates/tf_tree_math", version = "0.0.7" }
+tf_tree_arena = { path = "crates/tf_tree_arena", version = "0.0.7" }
 # `shm` (`docs/PHASE2.md` §2): `linux_raw` backend, no C build; used only by `tf_tree_ipc`.
 libc = "0.2"
 rustix = { version = "1.1", default-features = false, features = ["mm", "fs", "std"] }
 # `default-features = false` is load-bearing: without it `--no-default-features`
 # downstream still enables `counters` (`docs/PHASE5.md` §5.5).
-tf_tree_core = { path = "crates/tf_tree_core", version = "0.0.6", default-features = false }
-tf_tree_ipc = { path = "crates/tf_tree_ipc", version = "0.0.6" }
-tf_tree = { path = "crates/tf_tree", version = "0.0.6", default-features = false }
+tf_tree_core = { path = "crates/tf_tree_core", version = "0.0.7", default-features = false }
+tf_tree_ipc = { path = "crates/tf_tree_ipc", version = "0.0.7" }
+tf_tree = { path = "crates/tf_tree", version = "0.0.7", default-features = false }
 # publish = false crates; `default-features = false` as above.
 tf_tree_bench = { path = "crates/tf_tree_bench", default-features = false }
 tf_tree_bridge = { path = "crates/tf_tree_bridge" }
@@ -76,6 +76,9 @@ tf_tree_ingest = { path = "crates/tf_tree_ingest", default-features = false }
 libm = "0.2"
 bytemuck = { version = "1", features = ["derive"] }
 blake3 = { version = "1", default-features = false }
+# `tf_tree_math`'s optional `helicoid` feature (`docs/decisions/0063`): off by default, so D14's budget holds for everyone who does not opt in.
+helicoid = "=0.0.4"
+helicoid-linalg = "=0.0.4"
 # std-side facade / tooling only.
 thiserror = "2"
 anyhow = "1"

{transform_tree-0.0.6 → transform_tree-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: transform_tree
-Version: 0.0.6
+Version: 0.0.7
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.13

{transform_tree-0.0.6 → transform_tree-0.0.7}/crates/tf_tree_math/Cargo.toml

@@ -42,9 +42,16 @@ rustdoc-args = ["--cfg", "docsrs"]
 # `sqrt`/`sin`/`cos` on the hot path — with soft floats.
 miri-soft-float = ["libm/force-soft-floats"]
 
+# Delegate the SO(3) bodies to `helicoid` (`docs/decisions/0063`), on by default (`0064`);
+# `--no-default-features` runs the old bodies, which stay compiled either way as the adapter twins.
+default = ["helicoid"]
+helicoid = ["dep:helicoid", "dep:helicoid-linalg"]
+
 [dependencies]
 libm.workspace = true
 bytemuck.workspace = true
+helicoid = { workspace = true, optional = true }
+helicoid-linalg = { workspace = true, optional = true }
 
 [dev-dependencies]
 proptest.workspace = true

transform_tree-0.0.7/crates/tf_tree_math/src/helicoid_backend.rs

@@ -0,0 +1,284 @@
+//! The SO(3) bodies delegated to `helicoid` under the `helicoid` feature (`docs/decisions/0063`).
+//!
+//! Each function converts at the boundary and calls one `helicoid` routine; the arithmetic is
+//! `helicoid`'s. `Quat` and `Vec3` keep their layouts, so nothing here crosses a storage contract.
+//!
+//! A quaternion enters on `helicoid`'s *carried* path, a struct literal moved into
+//! `SO3::from_quat_unchecked`, never through the vouching `Quat::from_wxyz_unchecked`. `Iso3`
+//! composition never normalizes, so this crate's quaternions drift by design. The carried path
+//! asserts nothing, propagates NaN, and states each operation's error up to
+//! `|‖q‖² − 1| ≤ 2^-26.29` (`helicoid`'s `NUMERICS.md` §12).
+
+use crate::iso3::Vec3;
+use crate::quat::Quat;
+use helicoid::{LieGroup, Quat as HQuat, SO3Tangent, SO3};
+use helicoid_linalg::{Matrix, Vector};
+
+#[inline]
+fn so3(q: Quat) -> SO3<f64> {
+    SO3::from_quat_unchecked(HQuat {
+        w: q.w,
+        x: q.x,
+        y: q.y,
+        z: q.z,
+    })
+}
+
+#[inline]
+fn quat(r: SO3<f64>) -> Quat {
+    let q = r.quat();
+    Quat::new(q.w, q.x, q.y, q.z)
+}
+
+#[inline]
+pub(crate) fn exp_so3(w: Vec3) -> Quat {
+    quat(SO3::exp(&SO3Tangent {
+        phi: Vector([w.x, w.y, w.z]),
+    }))
+}
+
+#[inline]
+pub(crate) fn log_so3(q: Quat) -> Vec3 {
+    let [x, y, z] = so3(q).log().phi.0;
+    Vec3::new(x, y, z)
+}
+
+/// Shepperd's quotients in the native body's arithmetic on a rotation, normalized off the sphere,
+/// as `SO3::from_matrix` returns them (`docs/decisions/0063` decision 3).
+#[inline]
+pub(crate) fn quat_from_rot3(r: &[f64; 9]) -> Quat {
+    let row = |i: usize| Vector([r[3 * i], r[3 * i + 1], r[3 * i + 2]]);
+    quat(SO3::from_matrix(&Matrix::from_rows([
+        row(0),
+        row(1),
+        row(2),
+    ])))
+}
+
+#[inline]
+pub(crate) fn slerp(qa: Quat, qb: Quat, s: f64) -> Quat {
+    quat(SO3::geodesic(&so3(qa), &so3(qb), s))
+}
+
+/// Bit-identical to the native sandwich, drifted or not: the same products, in the same order.
+#[inline]
+pub(crate) fn rotate(q: Quat, v: Vec3) -> Vec3 {
+    let [x, y, z] = so3(q).act(Vector([v.x, v.y, v.z])).0;
+    Vec3::new(x, y, z)
+}
+
+/// The adapter twins (`docs/decisions/0063` decision 5): each delegated function against the body
+/// that ran before delegation, on a deterministic sweep. Tolerances are measured, not derived: the
+/// worst observed distance is asserted as a band, so an unrelated change does not fail them.
+#[cfg(test)]
+mod twin_tests {
+    use super::*;
+    use crate::interp::slerp_native;
+    use crate::quat::{exp_so3_native, log_so3_native, quat_from_rot3_native};
+
+    /// Rotation-vector magnitudes: both sides of `EXP_SO3_SMALL`, the series switches, and `π`.
+    const THETAS: [f64; 14] = [
+        0.0,
+        1e-12,
+        1e-9,
+        1e-8,
+        1e-6,
+        1e-3,
+        0.05,
+        0.15,
+        0.5,
+        1.0,
+        2.0,
+        3.0,
+        3.1,
+        core::f64::consts::PI - 1e-9,
+    ];
+
+    /// A unit direction, varied across `k` (golden-ratio steps; no `rand`).
+    fn axis(k: usize) -> Vec3 {
+        let a = 0.618_033_988_749_894_9 * (k as f64 + 1.0);
+        let (u, v) = (
+            a.fract() * 2.0 - 1.0,
+            (a * 7.0).fract() * core::f64::consts::TAU,
+        );
+        let r = (1.0 - u * u).sqrt();
+        Vec3::new(r * v.cos(), r * v.sin(), u)
+    }
+
+    fn rotation_vectors() -> impl Iterator<Item = Vec3> {
+        THETAS
+            .iter()
+            .enumerate()
+            .flat_map(|(i, &t)| (0..8).map(move |k| axis(7 * i + k).scale(t)))
+    }
+
+    fn dist(a: Quat, b: Quat) -> f64 {
+        a.sub(b).norm().min(a.add(b).norm())
+    }
+
+    /// `q` as the row-major `[f64; 9]` `quat_from_rot3` consumes.
+    fn rot3(q: Quat) -> [f64; 9] {
+        let (w, x, y, z) = (q.w, q.x, q.y, q.z);
+        [
+            1.0 - 2.0 * (y * y + z * z),
+            2.0 * (x * y - w * z),
+            2.0 * (x * z + w * y),
+            2.0 * (x * y + w * z),
+            1.0 - 2.0 * (x * x + z * z),
+            2.0 * (y * z - w * x),
+            2.0 * (x * z - w * y),
+            2.0 * (y * z + w * x),
+            1.0 - 2.0 * (x * x + y * y),
+        ]
+    }
+
+    #[test]
+    fn exp_so3_agrees_with_the_native_twin() {
+        let worst = rotation_vectors()
+            .map(|w| exp_so3(w).sub(exp_so3_native(w)).norm())
+            .fold(0.0, f64::max);
+        assert!(worst < 1e-15, "exp_so3 differs by {worst:e}");
+    }
+
+    #[test]
+    fn log_so3_agrees_with_the_native_twin() {
+        let worst = rotation_vectors()
+            .map(|w| {
+                let q = exp_so3_native(w);
+                log_so3(q).sub(log_so3_native(q)).norm()
+            })
+            .fold(0.0, f64::max);
+        assert!(worst < 1e-14, "log_so3 differs by {worst:e}");
+    }
+
+    /// The recorded behaviour change (`0063` decision 3): the native result is not normalized, so
+    /// the twin is compared after `normalize`, and up to the sign of the quaternion.
+    #[test]
+    fn quat_from_rot3_agrees_with_the_normalized_native_twin() {
+        let worst = rotation_vectors()
+            .map(|w| {
+                let r = rot3(exp_so3_native(w));
+                dist(quat_from_rot3(&r), quat_from_rot3_native(&r).normalize())
+            })
+            .fold(0.0, f64::max);
+        assert!(worst < 1e-14, "quat_from_rot3 differs by {worst:e}");
+    }
+
+    #[test]
+    fn slerp_agrees_with_the_native_twin() {
+        let qs: [Quat; 4] =
+            core::array::from_fn(|i| exp_so3_native(axis(i).scale(0.7 * i as f64 + 0.01)));
+        let mut worst = 0.0f64;
+        for (i, &qa) in qs.iter().enumerate() {
+            for &qb in &qs[i + 1..] {
+                for s in [0.0, 0.1, 0.25, 0.5, 0.9, 1.0] {
+                    worst = worst.max(dist(slerp(qa, qb, s), slerp_native(qa, qb, s)));
+                }
+            }
+        }
+        assert!(worst < 1e-14, "slerp differs by {worst:e}");
+    }
+
+    #[test]
+    fn slerp_endpoints_agree_with_the_native_twin() {
+        let qa = exp_so3_native(axis(3).scale(0.4));
+        for theta in [1e-8, 1e-3, 0.9] {
+            let qb = qa * exp_so3_native(axis(5).scale(theta));
+            assert!(
+                dist(slerp(qa, qb, 0.0), qa) < 4e-16,
+                "s = 0, theta {theta:e}"
+            );
+            assert!(
+                dist(slerp(qa, qb, 1.0), qb) < 4e-16,
+                "s = 1, theta {theta:e}"
+            );
+        }
+    }
+
+    #[test]
+    fn slerp_of_identical_inputs_is_qa_to_a_few_ulp() {
+        for k in 0..16 {
+            let qa = exp_so3_native(axis(k).scale(0.3 * k as f64 + 0.05));
+            for j in 0..=10 {
+                let d = dist(slerp(qa, qa, j as f64 / 10.0), qa);
+                assert!(d < 1e-15, "k={k} j={j}: {d:e}");
+            }
+        }
+    }
+
+    /// The native series collapses outside `[0, 1]`; `helicoid`'s geodesic is `x0 ⊕ s d`, so it holds.
+    #[test]
+    fn slerp_extrapolates_off_the_segment() {
+        let mut worst = 0.0f64;
+        for k in 0..16 {
+            let qa = exp_so3_native(axis(k).scale(0.3 * k as f64 + 0.05));
+            let ax = axis(k + 40);
+            for theta in [0.02, 0.1, 0.5] {
+                let qb = qa * exp_so3_native(ax.scale(theta));
+                for s in [-20.0, -5.0, 2.0, 5.0, 20.0] {
+                    let want = qa * exp_so3_native(ax.scale(s * theta));
+                    worst = worst.max(dist(slerp(qa, qb, s), want));
+                }
+            }
+        }
+        assert!(worst < 1e-13, "extrapolation differs by {worst:e}");
+    }
+
+    /// `q` scaled so that `‖q‖² − 1 = eta`: the drift `Iso3` composition carries.
+    fn drifted(q: Quat, eta: f64) -> Quat {
+        q.scale((1.0 + eta).sqrt())
+    }
+
+    /// Unit, at `helicoid`'s vouched bound `2^-40`, and out to the edge of its drift band.
+    const DRIFTS: [f64; 5] = [0.0, 9.1e-13, -9.1e-13, 1.2e-8, -1.2e-8];
+
+    #[test]
+    fn rotate_is_the_native_twin_to_the_bit_drifted_or_not() {
+        let v = [
+            Vec3::new(1.0, -2.0, 0.5),
+            Vec3::new(-3e-9, 7.0, 1e6),
+            Vec3::new(0.0, 0.0, 1.0),
+        ];
+        let bits = |a: Vec3| [a.x, a.y, a.z].map(f64::to_bits);
+        for w in rotation_vectors() {
+            for eta in DRIFTS {
+                let q = drifted(exp_so3_native(w), eta);
+                for &v in &v {
+                    assert_eq!(
+                        bits(rotate(q, v)),
+                        bits(q.rotate_native(v)),
+                        "{w:?} {eta:e}"
+                    );
+                }
+            }
+        }
+    }
+
+    /// A drifted quaternion reaches every delegated function without a debug panic, and `log_so3`
+    /// stays the native twin's: both are scale-invariant.
+    #[test]
+    fn a_drifted_quaternion_is_carried_through_every_delegated_function() {
+        let mut worst = 0.0f64;
+        for w in rotation_vectors() {
+            for eta in DRIFTS {
+                let q = drifted(exp_so3_native(w), eta);
+                worst = worst.max(log_so3(q).sub(log_so3_native(q)).norm());
+                let other = drifted(exp_so3_native(w.scale(0.5)), -eta);
+                let _ = slerp(q, other, 0.3);
+            }
+        }
+        assert!(worst < 1e-14, "log_so3 of a drifted q differs by {worst:e}");
+    }
+
+    #[test]
+    fn nan_propagates_through_every_delegated_function() {
+        let q = Quat::new(f64::NAN, 0.1, 0.2, 0.3);
+        let one = exp_so3_native(Vec3::new(0.3, -0.2, 0.1));
+        let log = log_so3(q);
+        assert!(log.x.is_nan() && log.y.is_nan() && log.z.is_nan());
+        assert!(rotate(q, Vec3::new(1.0, 2.0, 3.0)).x.is_nan());
+        assert!(slerp(q, one, 0.5).w.is_nan());
+        assert!(slerp(one, q, 0.5).w.is_nan());
+        assert!(slerp(one, one, f64::NAN).w.is_nan());
+    }
+}

{transform_tree-0.0.6 → transform_tree-0.0.7}/crates/tf_tree_math/src/interp.rs

@@ -159,6 +159,21 @@ impl Iso3 {
 #[inline]
 #[must_use]
 pub fn slerp(qa: Quat, qb: Quat, s: f64) -> Quat {
+    #[cfg(feature = "helicoid")]
+    {
+        crate::helicoid_backend::slerp(qa, qb, s)
+    }
+    #[cfg(not(feature = "helicoid"))]
+    {
+        slerp_native(qa, qb, s)
+    }
+}
+
+/// The body that ran before delegation, kept as [`slerp`]'s adapter twin (`docs/decisions/0063`).
+#[inline]
+#[must_use]
+#[cfg_attr(all(feature = "helicoid", not(test)), allow(dead_code))]
+pub(crate) fn slerp_native(qa: Quat, qb: Quat, s: f64) -> Quat {
     let dot = qa.dot(qb);
     let qb = if dot < 0.0 { qb.neg() } else { qb };
 

{transform_tree-0.0.6 → transform_tree-0.0.7}/crates/tf_tree_math/src/lib.rs

@@ -33,6 +33,8 @@
 mod readme {}
 
 pub mod dualquat;
+#[cfg(feature = "helicoid")]
+mod helicoid_backend;
 pub mod interp;
 pub mod iso3;
 pub mod quat;

{transform_tree-0.0.6 → transform_tree-0.0.7}/crates/tf_tree_math/src/quat.rs

@@ -174,6 +174,22 @@ impl Quat {
     #[inline]
     #[must_use]
     pub fn rotate(self, v: Vec3) -> Vec3 {
+        #[cfg(feature = "helicoid")]
+        {
+            crate::helicoid_backend::rotate(self, v)
+        }
+        #[cfg(not(feature = "helicoid"))]
+        {
+            self.rotate_native(v)
+        }
+    }
+
+    /// The body that ran before delegation, kept as [`Quat::rotate`]'s adapter twin
+    /// (`docs/decisions/0063`).
+    #[inline]
+    #[must_use]
+    #[cfg_attr(all(feature = "helicoid", not(test)), allow(dead_code))]
+    pub(crate) fn rotate_native(self, v: Vec3) -> Vec3 {
         let u = self.vector();
         let t = u.cross(v).scale(2.0);
         v.add(t.scale(self.w)).add(u.cross(t))
@@ -205,6 +221,21 @@ impl Mul for Quat {
 #[inline]
 #[must_use]
 pub fn exp_so3(w: Vec3) -> Quat {
+    #[cfg(feature = "helicoid")]
+    {
+        crate::helicoid_backend::exp_so3(w)
+    }
+    #[cfg(not(feature = "helicoid"))]
+    {
+        exp_so3_native(w)
+    }
+}
+
+/// The body that ran before delegation, kept as [`exp_so3`]'s adapter twin (`docs/decisions/0063`).
+#[inline]
+#[must_use]
+#[cfg_attr(all(feature = "helicoid", not(test)), allow(dead_code))]
+pub(crate) fn exp_so3_native(w: Vec3) -> Quat {
     exp_so3_theta(w, w.norm())
 }
 
@@ -238,6 +269,21 @@ pub(crate) fn exp_so3_theta(w: Vec3, theta: f64) -> Quat {
 #[inline]
 #[must_use]
 pub fn log_so3(q: Quat) -> Vec3 {
+    #[cfg(feature = "helicoid")]
+    {
+        crate::helicoid_backend::log_so3(q)
+    }
+    #[cfg(not(feature = "helicoid"))]
+    {
+        log_so3_native(q)
+    }
+}
+
+/// The body that ran before delegation, kept as [`log_so3`]'s adapter twin (`docs/decisions/0063`).
+#[inline]
+#[must_use]
+#[cfg_attr(all(feature = "helicoid", not(test)), allow(dead_code))]
+pub(crate) fn log_so3_native(q: Quat) -> Vec3 {
     // w ≥ 0 puts the result in the principal branch.
     let (w, x, y, z) = if q.w < 0.0 {
         (-q.w, -q.x, -q.y, -q.z)
@@ -269,6 +315,21 @@ pub fn log_so3(q: Quat) -> Vec3 {
 #[inline]
 #[must_use]
 pub fn quat_from_rot3(r: &[f64; 9]) -> Quat {
+    #[cfg(feature = "helicoid")]
+    {
+        crate::helicoid_backend::quat_from_rot3(r)
+    }
+    #[cfg(not(feature = "helicoid"))]
+    {
+        quat_from_rot3_native(r)
+    }
+}
+
+/// The body that ran before delegation, kept as [`quat_from_rot3`]'s adapter twin (`docs/decisions/0063`).
+#[inline]
+#[must_use]
+#[cfg_attr(all(feature = "helicoid", not(test)), allow(dead_code))]
+pub(crate) fn quat_from_rot3_native(r: &[f64; 9]) -> Quat {
     let (r00, r11, r22) = (r[0], r[4], r[8]);
     let trace = r00 + r11 + r22;
     if trace > 0.0 {

{transform_tree-0.0.6 → transform_tree-0.0.7}/crates/tf_tree_math/tests/slerp_public.rs

@@ -111,7 +111,11 @@ fn endpoints_are_bit_exact_above_the_lerp_fallback() {
 /// `s = 0` differs from `qa` by a couple of ulp unless `qa` is already unit to
 /// the bit. That ulp is the observable: it appears below the threshold and
 /// disappears above it with the same `qa`.
+///
+/// Native arm only: `helicoid`'s geodesic has no LERP fallback to pin, and its endpoints are
+/// held by `helicoid_backend`'s `slerp_endpoints_agree_with_the_native_twin`.
 #[test]
+#[cfg(not(feature = "helicoid"))]
 fn endpoints_lose_bit_exactness_only_in_the_lerp_fallback() {
     let mut discriminating = 0usize;
     let mut worst = 0.0f64;
@@ -262,7 +266,10 @@ fn the_arc_is_the_short_one_and_the_sign_of_qb_is_irrelevant() {
 }
 
 /// Identical inputs short-circuit, and `s` cannot perturb the answer.
+///
+/// Native arm only: `helicoid`'s geodesic returns `qa` to a few ulp, not the bit; `slerp_of_identical_inputs_is_qa_to_a_few_ulp` pins that arm.
 #[test]
+#[cfg(not(feature = "helicoid"))]
 fn numerically_identical_inputs_return_qa_at_every_s() {
     for k in 0..16 {
         let qa = sample_rotation(k);
@@ -274,11 +281,13 @@ fn numerically_identical_inputs_return_qa_at_every_s() {
 }
 
 /// The exact great-circle point at parameter `s`, valid off the segment too.
+#[cfg(not(feature = "helicoid"))]
 fn geodesic(qa: Quat, theta: f64, s: f64) -> Quat {
     step(qa, s * theta)
 }
 
 /// The double cover: the distance that counts is the smaller of the two.
+#[cfg(not(feature = "helicoid"))]
 fn rot_dist(a: Quat, b: Quat) -> f64 {
     a.sub(b).norm().min(a.add(b).norm())
 }
@@ -287,7 +296,10 @@ fn rot_dist(a: Quat, b: Quat) -> f64 {
 /// branches degrade differently (closed form holds, series collapses, the
 /// fallback's chord is fine until the arc grows), so the bands are wide and pin
 /// the shape, not a libm revision.
+///
+/// Native arm only: `helicoid` does not collapse out of range; `slerp_extrapolates_off_the_segment` pins that arm.
 #[test]
+#[cfg(not(feature = "helicoid"))]
 fn out_of_range_s_extrapolates_and_only_the_closed_form_holds() {
     // Closed form: as true off the segment as on it.
     let mut worst_closed = 0.0f64;
@@ -364,15 +376,14 @@ fn out_of_range_s_extrapolates_and_only_the_closed_form_holds() {
     );
 }
 
-/// `NaN` propagates through every branch except the early return that answers
-/// before `s` is read: `slerp(qa, qa, NaN)` returns `qa`.
+/// `NaN` propagates through every branch, on both arms.
 ///
 /// Do not "harden" the closed form. A `NaN` component reaches the closed form,
 /// where `acos(NaN.min(1.0)) = 0` makes `sin_angle` zero and the output `NaN` only
 /// via `0.0/0.0`; a `sin_angle == 0.0` guard would turn a `NaN` input into a
 /// plausible pose. `dot.clamp(-1.0, 1.0)` would be safe; see `slerp`'s docs.
 #[test]
-fn nan_propagates_except_through_the_identical_input_return() {
+fn nan_propagates_through_every_branch() {
     let all_nan = |q: Quat| q.w.is_nan() && q.x.is_nan() && q.y.is_nan() && q.z.is_nan();
     for k in 0..16 {
         let qa = sample_rotation(k);
@@ -397,18 +408,29 @@ fn nan_propagates_except_through_the_identical_input_return() {
                  before relaxing this."
             );
         }
-        // `h` is `0`, so nothing downstream reads `s`.
-        assert_eq!(bits(slerp(qa, qa, f64::NAN)), bits(qa), "k={k}");
-        assert_eq!(bits(slerp(qa, qa, f64::INFINITY)), bits(qa), "k={k}");
-        // A NaN component cannot reach it: `h` is NaN, not `<= 0.0`.
         let qnan = Quat::new(f64::NAN, qa.x, qa.y, qa.z);
         assert!(
             all_nan(slerp(qnan, qnan, 0.5)),
-            "the early return ate a NaN component: k={k}"
+            "a NaN component was eaten: k={k}"
         );
     }
 }
 
+/// The native early return answers before `s` is read: `slerp(qa, qa, NaN)` returns `qa`. A NaN
+/// component cannot reach it, which `nan_propagates_through_every_branch` checks: `h` is NaN, not
+/// `<= 0.0`.
+///
+/// Native arm only: `helicoid`'s geodesic has no early return, so a NaN `s` gives NaN there.
+#[test]
+#[cfg(not(feature = "helicoid"))]
+fn the_identical_input_return_answers_before_s_is_read() {
+    for k in 0..16 {
+        let qa = sample_rotation(k);
+        assert_eq!(bits(slerp(qa, qa, f64::NAN)), bits(qa), "k={k}");
+        assert_eq!(bits(slerp(qa, qa, f64::INFINITY)), bits(qa), "k={k}");
+    }
+}
+
 /// What dropping the `Iso3` round trip costs: as rotations `slerp` and
 /// `LerpSlerp::eval` never disagree (worst ~2.7e-16, the renormalization); the
 /// bits differ only at `s = 0` or `s = 1`, where `eval` answers from a shortcut:

{transform_tree-0.0.6 → transform_tree-0.0.7}/crates/tf_tree_py/Cargo.lock

@@ -231,6 +231,25 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
+[[package]]
+name = "helicoid"
+version = "0.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d8d5abfd68550c667ec6721da48a1d1fb852b435db673a8fda7093195411a7d"
+dependencies = [
+ "helicoid-linalg",
+ "libm",
+]
+
+[[package]]
+name = "helicoid-linalg"
+version = "0.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "994bdd3e24ef9a226b96904499395071be521cf75a4a4234198bc71a627794d2"
+dependencies = [
+ "libm",
+]
+
 [[package]]
 name = "hermit-abi"
 version = "0.5.2"
@@ -553,7 +572,7 @@ checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
 [[package]]
 name = "tf_tree"
-version = "0.0.6"
+version = "0.0.7"
 dependencies = [
  "tf_tree_arena",
  "tf_tree_core",
@@ -564,7 +583,7 @@ dependencies = [
 
 [[package]]
 name = "tf_tree_arena"
-version = "0.0.6"
+version = "0.0.7"
 dependencies = [
  "bytemuck",
  "rustix",
@@ -572,14 +591,14 @@ dependencies = [
 
 [[package]]
 name = "tf_tree_bridge"
-version = "0.0.6"
+version = "0.0.7"
 dependencies = [
  "tf_tree",
 ]
 
 [[package]]
 name = "tf_tree_core"
-version = "0.0.6"
+version = "0.0.7"
 dependencies = [
  "blake3",
  "bytemuck",
@@ -590,7 +609,7 @@ dependencies = [
 
 [[package]]
 name = "tf_tree_ingest"
-version = "0.0.6"
+version = "0.0.7"
 dependencies = [
  "blake3",
  "crc32fast",
@@ -604,7 +623,7 @@ dependencies = [
 
 [[package]]
 name = "tf_tree_ipc"
-version = "0.0.6"
+version = "0.0.7"
 dependencies = [
  "libc",
  "rustix",
@@ -612,15 +631,17 @@ dependencies = [
 
 [[package]]
 name = "tf_tree_math"
-version = "0.0.6"
+version = "0.0.7"
 dependencies = [
  "bytemuck",
+ "helicoid",
+ "helicoid-linalg",
  "libm",
 ]
 
 [[package]]
 name = "tf_tree_py"
-version = "0.0.6"
+version = "0.0.7"
 dependencies = [
  "numpy",
  "pyo3",