fix(lints+docs): clippy clean on graduated modules + rustdoc examples

Two CI / review-feedback fixes on PR #194:

1) Clippy (`-D warnings`, --features rayon / approx,serde,rayon):
   10 errors surfaced because the graduated modules are no longer
   under hpc/mod.rs's `#![allow(clippy::all, ...)]` umbrella.
   Fixed each at the canonical Rust idiom rather than re-applying
   the umbrella — graduated modules hold to the higher standard:

   - `bitwise.rs:110,155` — `acc = acc + (x + y);` →
     `acc += x + y;` (assign_op_pattern; bare without parens).
   - `distance.rs:99` — `for j in i..n { points[j] }` →
     `for p in &points[i..n] { p[0]..p[2] }` (needless_range_loop).
   - `byte_scan.rs:38,71` — `for j in i..n { if haystack[j] == needle
     { result.push(j); }}` → `for (offset, &byte) in haystack[i..n]
     .iter().enumerate() { if byte == needle { result.push(i + offset);
     }}` (needless_range_loop with index preservation).
   - `byte_scan.rs:101,129` — same pattern but counting via
     `total += 1`; switched to `for &byte in &haystack[i..n]`
     (no index needed at all).
   - `spatial_hash.rs:334` — `for lane in 0..8 { d2_arr[lane] }` →
     `for (lane, &d2_lane) in d2_arr.iter().enumerate()`.
   - `spatial_hash.rs:342` — `for i in (chunks*8)..candidates.len()
     { candidates[i] }` → `let tail_start = chunks * 8;
     for (offset, &cand) in candidates[tail_start..].iter()
     .enumerate() { result.push((tail_start + offset, d2)) }`.

2) CodeRabbit + CLAUDE.md hard rule ("All public APIs need ///
   doc comments with examples"):
   Added `# Example` rustdoc blocks to each of the five new
   `pub mod` declarations in `src/lib.rs`. Each example uses
   only the actual public API of the target module (verified by
   running the doctests):

   - `bitwise` — popcount + hamming over [0xFF; 16]/[0x00; 16]
   - `heel_f64x8` — cosine_f64_simd + dot_f64_simd over [1.0; 32]
   - `distance` — l1/l2/linf_f64_simd over pythagorean (3,0)/(0,4)
   - `byte_scan` — byte_find_all over a 23-char fixture
   - `spatial_hash` — SpatialHash::new + insert + len

All five doctests pass under `cargo test --doc`. `cargo clippy
--features rayon --lib -- -D warnings` and `cargo clippy
--features approx,serde,rayon -- -D warnings` both green.

Author: claude

src/bitwise.rs

@@ -107,7 +107,7 @@ unsafe fn hamming_avx512bw(a: &[u8], b: &[u8]) -> u64 {
         let hi = xor.shr_epi16(4) & low_mask;
         let popcnt_lo = lookup.shuffle_bytes(lo);
         let popcnt_hi = lookup.shuffle_bytes(hi);
-        acc = acc + (popcnt_lo + popcnt_hi);
+        acc += popcnt_lo + popcnt_hi;
 
         i += 64;
         inner_count += 1;
@@ -152,7 +152,7 @@ unsafe fn popcount_avx512bw(a: &[u8]) -> u64 {
         let hi = va.shr_epi16(4) & low_mask;
         let popcnt_lo = lookup.shuffle_bytes(lo);
         let popcnt_hi = lookup.shuffle_bytes(hi);
-        acc = acc + (popcnt_lo + popcnt_hi);
+        acc += popcnt_lo + popcnt_hi;
 
         i += 64;
         inner_count += 1;

src/byte_scan.rs

@@ -35,9 +35,9 @@ pub(crate) mod simd_impl {
             i += 32;
         }
         // Scalar tail
-        for j in i..n {
-            if haystack[j] == needle {
-                result.push(j);
+        for (offset, &byte) in haystack[i..n].iter().enumerate() {
+            if byte == needle {
+                result.push(i + offset);
             }
         }
         result
@@ -68,9 +68,9 @@ pub(crate) mod simd_impl {
             i += 64;
         }
         // Scalar tail
-        for j in i..n {
-            if haystack[j] == needle {
-                result.push(j);
+        for (offset, &byte) in haystack[i..n].iter().enumerate() {
+            if byte == needle {
+                result.push(i + offset);
             }
         }
         result
@@ -98,8 +98,8 @@ pub(crate) mod simd_impl {
             }
             i += 32;
         }
-        for j in i..n {
-            if haystack[j] == needle {
+        for &byte in &haystack[i..n] {
+            if byte == needle {
                 total += 1;
             }
         }
@@ -126,8 +126,8 @@ pub(crate) mod simd_impl {
             total += mask.count_ones() as usize;
             i += 64;
         }
-        for j in i..n {
-            if haystack[j] == needle {
+        for &byte in &haystack[i..n] {
+            if byte == needle {
                 total += 1;
             }
         }

src/distance.rs

@@ -96,10 +96,10 @@ pub(crate) mod simd_impl {
         }
 
         // Scalar tail
-        for j in i..n {
-            let dx = query[0] - points[j][0];
-            let dy = query[1] - points[j][1];
-            let dz = query[2] - points[j][2];
+        for p in &points[i..n] {
+            let dx = query[0] - p[0];
+            let dy = query[1] - p[1];
+            let dz = query[2] - p[2];
             out.push(dx * dx + dy * dy + dz * dz);
         }
     }
@@ -211,7 +211,7 @@ pub fn l1_f64_simd(a: &[f64], b: &[f64]) -> f64 {
     for i in 0..chunks {
         let va = F64x8::from_slice(&a[i * 8..]);
         let vb = F64x8::from_slice(&b[i * 8..]);
-        acc = acc + (va - vb).abs();
+        acc += (va - vb).abs();
     }
     let mut sum = acc.reduce_sum();
     let offset = chunks * 8;

src/lib.rs

@@ -276,28 +276,78 @@ pub mod simd_caps;
 /// Graduated from `crate::hpc::bitwise::*` (substrate-tier; uses
 /// `crate::simd::U64x8` polyfill internally). Back-compat re-export in
 /// `crate::hpc::*` preserves existing import paths.
+///
+/// # Example
+///
+/// ```
+/// use ndarray::bitwise::{hamming_distance_raw, popcount_raw};
+/// let a = [0xFFu8; 16];
+/// let b = [0x00u8; 16];
+/// assert_eq!(hamming_distance_raw(&a, &b), 128);
+/// assert_eq!(popcount_raw(&a), 128);
+/// ```
 #[cfg(feature = "std")]
 pub mod bitwise;
 
 /// F64x8 HEEL distance kernels — 8-plane weighted Hamming, f64 SIMD
 /// dot / cosine / sum-of-squares. Graduated from `crate::hpc::heel_f64x8::*`.
+///
+/// # Example
+///
+/// ```
+/// use ndarray::heel_f64x8::{cosine_f64_simd, dot_f64_simd};
+/// let a = vec![1.0_f64; 32];
+/// let b = vec![1.0_f64; 32];
+/// assert!((cosine_f64_simd(&a, &b) - 1.0).abs() < 1e-10);
+/// assert!((dot_f64_simd(&a, &b) - 32.0).abs() < 1e-10);
+/// ```
 #[cfg(feature = "std")]
 pub mod heel_f64x8;
 
 /// Batch distance computations — spatial 3D-point queries +
 /// slice-shape L1 / L2 / L∞ (PR-X10 A6). Graduated from
 /// `crate::hpc::distance::*`.
+///
+/// # Example
+///
+/// ```
+/// use ndarray::distance::{l1_f64_simd, l2_f64_simd, linf_f64_simd};
+/// let a = vec![3.0_f64, 0.0];
+/// let b = vec![0.0_f64, 4.0];
+/// assert!((l1_f64_simd(&a, &b) - 7.0).abs() < 1e-12);
+/// assert!((l2_f64_simd(&a, &b) - 5.0).abs() < 1e-12);
+/// assert!((linf_f64_simd(&a, &b) - 4.0).abs() < 1e-12);
+/// ```
 #[cfg(feature = "std")]
 pub mod distance;
 
 /// SIMD-accelerated byte-scan utilities — needle search, delimiter
 /// finding, parallel byte comparison. Graduated from
 /// `crate::hpc::byte_scan::*`.
+///
+/// # Example
+///
+/// ```
+/// use ndarray::byte_scan::byte_find_all;
+/// let haystack = b"hello world, hello rust";
+/// let hits = byte_find_all(haystack, b'l');
+/// assert_eq!(hits, vec![2, 3, 9, 15, 16]);
+/// ```
 #[cfg(feature = "std")]
 pub mod byte_scan;
 
 /// SIMD-accelerated spatial hash — bucketing, candidate gather, hash
 /// collision detection. Graduated from `crate::hpc::spatial_hash::*`.
+///
+/// # Example
+///
+/// ```
+/// use ndarray::spatial_hash::SpatialHash;
+/// let mut grid = SpatialHash::new(1.0);
+/// grid.insert(0, 0.0, 0.0, 0.0);
+/// grid.insert(1, 10.0, 10.0, 10.0);
+/// assert_eq!(grid.len(), 2);
+/// ```
 #[cfg(feature = "std")]
 pub mod spatial_hash;
 

src/spatial_hash.rs

@@ -331,18 +331,19 @@ pub(crate) unsafe fn batch_sq_dist_avx2(query: [f32; 3], candidates: &[[f32; 3]]
 
         // Compare: d2 <= radius_sq (scalar array comparison — no F32x8 cmp polyfill)
         let d2_arr = d2.to_array();
-        for lane in 0..8 {
-            if d2_arr[lane] <= radius_sq {
-                result.push((base + lane, d2_arr[lane]));
+        for (lane, &d2_lane) in d2_arr.iter().enumerate() {
+            if d2_lane <= radius_sq {
+                result.push((base + lane, d2_lane));
             }
         }
     }
 
     // Scalar tail
-    for i in (chunks * 8)..candidates.len() {
-        let d2 = sq_dist_f32(query, candidates[i]);
+    let tail_start = chunks * 8;
+    for (offset, &cand) in candidates[tail_start..].iter().enumerate() {
+        let d2 = sq_dist_f32(query, cand);
         if d2 <= radius_sq {
-            result.push((i, d2));
+            result.push((tail_start + offset, d2));
         }
     }