style(simd_nightly): apply cargo fmt --all (PR #146 fmt fix)

The round-3-portable-simd fleet wrote agent files without running
cargo fmt, so the format/stable CI job (now blocking per PR #145)
flagged 34 drift sites across 12 files in src/simd_nightly/.

`cargo fmt --all` normalizes. Zero semantic changes.

Verified: `cargo fmt --all --check` clean.

Author: claude

src/simd_nightly/bf16_types.rs

@@ -48,11 +48,7 @@ impl BF16x16 {
     /// Load 16 BF16 bit-patterns from a `u16` slice (must have `len >= 16`).
     #[inline]
     pub fn from_slice(s: &[u16]) -> Self {
-        assert!(
-            s.len() >= 16,
-            "BF16x16::from_slice: need >= 16 elements, got {}",
-            s.len()
-        );
+        assert!(s.len() >= 16, "BF16x16::from_slice: need >= 16 elements, got {}", s.len());
         let mut arr = [0u16; 16];
         arr.copy_from_slice(&s[..16]);
         Self(arr)
@@ -73,11 +69,7 @@ impl BF16x16 {
     /// Write the 16 BF16 bit-patterns into `dst` (must have `len >= 16`).
     #[inline]
     pub fn copy_to_slice(self, dst: &mut [u16]) {
-        assert!(
-            dst.len() >= 16,
-            "BF16x16::copy_to_slice: need >= 16 elements, got {}",
-            dst.len()
-        );
+        assert!(dst.len() >= 16, "BF16x16::copy_to_slice: need >= 16 elements, got {}", dst.len());
         dst[..16].copy_from_slice(&self.0);
     }
 
@@ -119,11 +111,7 @@ impl BF16x8 {
     /// Load 8 BF16 bit-patterns from a `u16` slice (must have `len >= 8`).
     #[inline]
     pub fn from_slice(s: &[u16]) -> Self {
-        assert!(
-            s.len() >= 8,
-            "BF16x8::from_slice: need >= 8 elements, got {}",
-            s.len()
-        );
+        assert!(s.len() >= 8, "BF16x8::from_slice: need >= 8 elements, got {}", s.len());
         let mut arr = [0u16; 8];
         arr.copy_from_slice(&s[..8]);
         Self(arr)
@@ -144,11 +132,7 @@ impl BF16x8 {
     /// Write the 8 BF16 bit-patterns into `dst` (must have `len >= 8`).
     #[inline]
     pub fn copy_to_slice(self, dst: &mut [u16]) {
-        assert!(
-            dst.len() >= 8,
-            "BF16x8::copy_to_slice: need >= 8 elements, got {}",
-            dst.len()
-        );
+        assert!(dst.len() >= 8, "BF16x8::copy_to_slice: need >= 8 elements, got {}", dst.len());
         dst[..8].copy_from_slice(&self.0);
     }
 

src/simd_nightly/exotic_methods.rs

@@ -138,7 +138,7 @@ impl U8x64 {
         for lane in 0..4 {
             let base = lane * 16;
             for i in 0..8 {
-                out[base + i * 2]     = a[base + i];
+                out[base + i * 2] = a[base + i];
                 out[base + i * 2 + 1] = b[base + i];
             }
         }
@@ -172,7 +172,7 @@ impl U8x64 {
         for lane in 0..4 {
             let base = lane * 16;
             for i in 0..8 {
-                out[base + i * 2]     = a[base + 8 + i];
+                out[base + i * 2] = a[base + 8 + i];
                 out[base + i * 2 + 1] = b[base + 8 + i];
             }
         }
@@ -310,7 +310,7 @@ impl U8x32 {
         for lane in 0..2 {
             let base = lane * 16;
             for i in 0..8 {
-                out[base + i * 2]     = a[base + i];
+                out[base + i * 2] = a[base + i];
                 out[base + i * 2 + 1] = b[base + i];
             }
         }
@@ -344,7 +344,7 @@ impl U8x32 {
         for lane in 0..2 {
             let base = lane * 16;
             for i in 0..8 {
-                out[base + i * 2]     = a[base + 8 + i];
+                out[base + i * 2] = a[base + 8 + i];
                 out[base + i * 2 + 1] = b[base + 8 + i];
             }
         }
@@ -436,7 +436,7 @@ mod tests {
         for lane in 0..4 {
             let base = lane * 16;
             for i in 0..8 {
-                assert_eq!(arr[base + i * 2],     0xAA, "lane {lane} pos {}", i * 2);
+                assert_eq!(arr[base + i * 2], 0xAA, "lane {lane} pos {}", i * 2);
                 assert_eq!(arr[base + i * 2 + 1], 0xBB, "lane {lane} pos {}", i * 2 + 1);
             }
         }
@@ -459,7 +459,7 @@ mod tests {
         for lane in 0..4 {
             let base = lane * 16;
             for i in 0..8 {
-                assert_eq!(arr[base + i * 2],     (8 + i) as u8, "lane {lane} a[{i}]");
+                assert_eq!(arr[base + i * 2], (8 + i) as u8, "lane {lane} a[{i}]");
                 assert_eq!(arr[base + i * 2 + 1], (108 + i) as u8, "lane {lane} b[{i}]");
             }
         }
@@ -533,7 +533,7 @@ mod tests {
         for lane in 0..2 {
             let base = lane * 16;
             for i in 0..8 {
-                assert_eq!(arr[base + i * 2],     0xAA);
+                assert_eq!(arr[base + i * 2], 0xAA);
                 assert_eq!(arr[base + i * 2 + 1], 0xBB);
             }
         }
@@ -556,7 +556,7 @@ mod tests {
         for lane in 0..2 {
             let base = lane * 16;
             for i in 0..8 {
-                assert_eq!(arr[base + i * 2],     (8 + i) as u8, "lane {lane} a[{i}]");
+                assert_eq!(arr[base + i * 2], (8 + i) as u8, "lane {lane} a[{i}]");
                 assert_eq!(arr[base + i * 2 + 1], (108 + i) as u8, "lane {lane} b[{i}]");
             }
         }

src/simd_nightly/f16_types.rs

@@ -228,10 +228,7 @@ mod tests {
         let v = F16x16::from_f32_array(inputs);
         let out = v.to_f32_array();
         for (i, (&orig, &back)) in inputs.iter().zip(out.iter()).enumerate() {
-            assert!(
-                (orig - back).abs() < 0.001,
-                "lane {i}: {orig} → f16 → {back}"
-            );
+            assert!((orig - back).abs() < 0.001, "lane {i}: {orig} → f16 → {back}");
         }
     }
 

src/simd_nightly/f32_types.rs

@@ -1,9 +1,9 @@
 //! F32x16 / F32x8 portable-simd wrappers — round-3-portable-simd agent #1.
 #![cfg(feature = "nightly-simd")]
 
-use core::simd::{f32x16 as core_f32x16, f32x8 as core_f32x8};
 use core::simd::cmp::{SimdPartialEq, SimdPartialOrd};
 use core::simd::num::SimdFloat;
+use core::simd::{f32x16 as core_f32x16, f32x8 as core_f32x8};
 // `mul_add`, `sqrt`, `round`, `floor`, `abs` live in `StdFloat` (std-only nightly trait).
 use std::simd::StdFloat;
 

src/simd_nightly/f64_types.rs

@@ -1,9 +1,9 @@
 //! F64x8 / F64x4 portable-simd wrappers — round-3-portable-simd agent #2.
 #![cfg(feature = "nightly-simd")]
 
-use core::simd::{f64x8 as core_f64x8, f64x4 as core_f64x4};
 use core::simd::cmp::{SimdPartialEq, SimdPartialOrd};
 use core::simd::num::SimdFloat;
+use core::simd::{f64x4 as core_f64x4, f64x8 as core_f64x8};
 use std::simd::StdFloat;
 
 // ════════════════════════════════════════════════════════════════════

src/simd_nightly/i8_types.rs

@@ -1,9 +1,9 @@
 //! I8x32 / I8x64 portable-simd wrappers — round-3-portable-simd agent #5.
 #![cfg(feature = "nightly-simd")]
 
-use core::simd::{i8x32, i8x64};
 use core::simd::cmp::{SimdOrd, SimdPartialEq, SimdPartialOrd};
 use core::simd::num::SimdInt;
+use core::simd::{i8x32, i8x64};
 
 // ════════════════════════════════════════════════════════════════════
 // I8x64 — 64-lane signed byte

src/simd_nightly/i_word_types.rs

@@ -1,9 +1,9 @@
 //! I16x16 / I16x32 / I32x16 / I64x8 portable-simd wrappers — round-3-portable-simd agent #6.
 #![cfg(feature = "nightly-simd")]
 
-use core::simd::{i16x16, i16x32, i32x16, i64x8};
 use core::simd::cmp::{SimdOrd, SimdPartialEq, SimdPartialOrd};
 use core::simd::num::SimdInt;
+use core::simd::{i16x16, i16x32, i32x16, i64x8};
 
 // ════════════════════════════════════════════════════════════════════
 // I16x16 — 16-lane signed 16-bit integer

src/simd_nightly/masks.rs

@@ -1,9 +1,9 @@
 //! Comparison-result mask wrappers — round-3-portable-simd agent #7.
 #![cfg(feature = "nightly-simd")]
 
-use core::simd::Mask;
+use super::{F32x16, F32x8, F64x4, F64x8};
 use core::simd::prelude::Select;
-use super::{F32x16, F32x8, F64x8, F64x4};
+use core::simd::Mask;
 
 // ============================================================================
 // F32Mask16 — 16-lane mask for F32x16 comparisons

src/simd_nightly/mod.rs

@@ -40,6 +40,6 @@ pub use f32_types::{F32x16, F32x8};
 pub use f64_types::{F64x4, F64x8};
 pub use i8_types::{I8x32, I8x64};
 pub use i_word_types::{I16x16, I16x32, I32x16, I64x8};
-pub use masks::{F32Mask16, F32Mask8, F64Mask8, F64Mask4};
+pub use masks::{F32Mask16, F32Mask8, F64Mask4, F64Mask8};
 pub use u8_types::{U8x32, U8x64};
-pub use u_word_types::{U16x32, U32x8, U32x16, U64x4, U64x8};
+pub use u_word_types::{U16x32, U32x16, U32x8, U64x4, U64x8};

src/simd_nightly/tests.rs

@@ -170,7 +170,9 @@ fn f64x4_reduce_sum_parity() {
 fn f32x16_cmpeq_mask_parity() {
     let a: [f32; 16] = core::array::from_fn(|i| (i % 4) as f32);
     let b: [f32; 16] = core::array::from_fn(|i| (i % 2) as f32);
-    let mask = F32x16::from_array(a).simd_eq(F32x16::from_array(b)).to_bitmask();
+    let mask = F32x16::from_array(a)
+        .simd_eq(F32x16::from_array(b))
+        .to_bitmask();
     let mut expected: u16 = 0;
     for i in 0..16 {
         if a[i] == b[i] {
@@ -198,7 +200,9 @@ fn f32x16_cmpgt_mask_parity() {
 fn f32x8_cmpeq_mask_parity() {
     let a: [f32; 8] = core::array::from_fn(|i| (i % 2) as f32);
     let b: [f32; 8] = [0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0];
-    let mask = F32x8::from_array(a).simd_eq(F32x8::from_array(b)).to_bitmask();
+    let mask = F32x8::from_array(a)
+        .simd_eq(F32x8::from_array(b))
+        .to_bitmask();
     let mut expected: u8 = 0;
     for i in 0..8 {
         if a[i] == b[i] {
@@ -212,7 +216,9 @@ fn f32x8_cmpeq_mask_parity() {
 fn f64x8_cmpeq_mask_parity() {
     let a: [f64; 8] = core::array::from_fn(|i| (i % 3) as f64);
     let b: [f64; 8] = core::array::from_fn(|i| (i % 2) as f64);
-    let mask = F64x8::from_array(a).simd_eq(F64x8::from_array(b)).to_bitmask();
+    let mask = F64x8::from_array(a)
+        .simd_eq(F64x8::from_array(b))
+        .to_bitmask();
     let mut expected: u8 = 0;
     for i in 0..8 {
         if a[i] == b[i] {
@@ -359,7 +365,9 @@ fn f32x16_fma_scalar_parity() {
     let b: [f32; 16] = core::array::from_fn(|i| (i as f32) * 0.3);
     let c: [f32; 16] = core::array::from_fn(|i| i as f32);
     let simd_result = F32x16::from_array(a).mul_add(F32x16::from_array(b), F32x16::from_array(c));
-    for (i, (&r, (&ai, (&bi, &ci)))) in simd_result.to_array().iter()
+    for (i, (&r, (&ai, (&bi, &ci)))) in simd_result
+        .to_array()
+        .iter()
         .zip(a.iter().zip(b.iter().zip(c.iter())))
         .enumerate()
     {
@@ -381,10 +389,7 @@ fn bf16x16_from_f32_to_f32_lossy_within_bounds() {
     for (i, (&orig, &back)) in inputs.iter().zip(out.iter()).enumerate() {
         // BF16 truncation error is at most |orig| * 2^-7
         let max_err = orig.abs() * (2.0_f32.powi(-7)) + f32::EPSILON;
-        assert!(
-            (orig - back).abs() <= max_err,
-            "lane {i}: orig={orig} back={back} err={}", (orig - back).abs()
-        );
+        assert!((orig - back).abs() <= max_err, "lane {i}: orig={orig} back={back} err={}", (orig - back).abs());
     }
 }
 
@@ -395,10 +400,7 @@ fn bf16x8_from_f32_to_f32_lossy_within_bounds() {
     let out = v.to_f32_lossy();
     for (i, (&orig, &back)) in inputs.iter().zip(out.iter()).enumerate() {
         let max_err = orig.abs() * (2.0_f32.powi(-7)) + f32::EPSILON;
-        assert!(
-            (orig - back).abs() <= max_err,
-            "lane {i}: orig={orig} back={back}"
-        );
+        assert!((orig - back).abs() <= max_err, "lane {i}: orig={orig} back={back}");
     }
 }
 
@@ -425,10 +427,7 @@ fn f16x16_from_f32_to_f32_roundtrip_within_1ulp() {
     let out = v.to_f32_array();
     for (i, (&orig, &back)) in inputs.iter().zip(out.iter()).enumerate() {
         // These integers are exactly representable in f16 (range 0..2048)
-        assert!(
-            (orig - back).abs() <= 0.5,
-            "lane {i}: orig={orig} back={back}"
-        );
+        assert!((orig - back).abs() <= 0.5, "lane {i}: orig={orig} back={back}");
     }
 }
 
@@ -483,7 +482,9 @@ fn f32mask16_select_scalar_parity() {
     let threshold = F32x16::splat(7.5);
     let va = F32x16::from_array(a);
     let mask = va.simd_lt(threshold);
-    let result = mask.select(F32x16::splat(100.0), F32x16::splat(200.0)).to_array();
+    let result = mask
+        .select(F32x16::splat(100.0), F32x16::splat(200.0))
+        .to_array();
     for i in 0..16 {
         let expected = if a[i] < 7.5 { 100.0_f32 } else { 200.0_f32 };
         assert_eq!(result[i], expected, "lane {i}");
@@ -496,7 +497,9 @@ fn f32mask8_select_scalar_parity() {
     let threshold = F32x8::splat(3.5);
     let va = F32x8::from_array(a);
     let mask = va.simd_gt(threshold);
-    let result = mask.select(F32x8::splat(10.0), F32x8::splat(20.0)).to_array();
+    let result = mask
+        .select(F32x8::splat(10.0), F32x8::splat(20.0))
+        .to_array();
     for i in 0..8 {
         let expected = if a[i] > 3.5 { 10.0_f32 } else { 20.0_f32 };
         assert_eq!(result[i], expected, "lane {i}");
@@ -522,7 +525,9 @@ fn f64mask4_select_scalar_parity() {
     let threshold = F64x4::splat(4.0);
     let va = F64x4::from_array(a);
     let mask = va.simd_gt(threshold);
-    let result = mask.select(F64x4::splat(99.0), F64x4::splat(0.0)).to_array();
+    let result = mask
+        .select(F64x4::splat(99.0), F64x4::splat(0.0))
+        .to_array();
     // Lanes 1 (5>4) and 3 (7>4) should be 99.0
     assert_eq!(result, [0.0, 99.0, 0.0, 99.0]);
 }
@@ -682,10 +687,7 @@ fn f32x16_floor_parity() {
 
 #[test]
 fn f32x16_round_parity() {
-    let src: [f32; 16] = [
-        0.5, 1.5, 2.5, 3.5, 4.5, 5.5, -0.5, -1.5,
-        0.4, 1.6, 2.3, 3.7, -0.4, -1.6, 100.0, -100.0,
-    ];
+    let src: [f32; 16] = [0.5, 1.5, 2.5, 3.5, 4.5, 5.5, -0.5, -1.5, 0.4, 1.6, 2.3, 3.7, -0.4, -1.6, 100.0, -100.0];
     let result = F32x16::from_array(src).round().to_array();
     for (i, (&r, &s)) in result.iter().zip(src.iter()).enumerate() {
         assert_eq!(r, s.round(), "lane {i}");