fix(zenpredict): argmin_masked_top_k skips NaN scores per documented contract

The consider() closure only rejected a NaN score once the top-K array was
full (the count == K branch's score < top[K-1].0 comparison, where NaN < x
is always false). While count < K, it inserted UNCONDITIONALLY — the
shift-loop's top[i - 1].0 > score never fires for a NaN score (every
comparison with NaN is false), so the NaN just landed in the next empty
slot instead of being skipped. This violated the function's own documented
'same NaN ... contract as argmin_masked' (NaN cells silently skipped, never
picked).

Fixed: skip immediately when score.is_nan(), before either branch.

Added argmin_top_k_skips_nan_scores: 5 predictions with 2 NaNs (both in the
count<K window) must never appear in the top-3 result; an all-NaN input
must yield [None, None, None]. Verified the test fails without the fix
(reproduced: NaN landed at index 0 instead of being skipped) and passes
with it. cargo test -p zenpredict --lib --features advanced: 141 passed.

Author: lilith

zenpredict/src/argmin.rs

@@ -239,6 +239,13 @@ pub fn argmin_masked_top_k<const K: usize>(
     let mut count: usize = 0;
 
     let mut consider = |score: f32, idx: usize| {
+        // Same NaN contract as `argmin_masked`: a NaN-scoring cell is silently skipped, never
+        // occupying a top-K slot. Without this, `score.is_nan()` cells (for which every `<`
+        // comparison is false) would slide into an empty slot below simply because the
+        // shift-loop's `top[i - 1].0 > score` never fires to displace it.
+        if score.is_nan() {
+            return;
+        }
         if count < K {
             let mut i = count;
             while i > 0 && top[i - 1].0 > score {

zenpredict/src/tests.rs

@@ -56,6 +56,28 @@ fn argmin_top_k_returns_sorted_indices() {
     assert_eq!(top, [Some(1), Some(3), Some(0)]);
 }
 
+#[test]
+#[cfg(feature = "advanced")]
+fn argmin_top_k_skips_nan_scores() {
+    // Same documented NaN contract as `argmin_masked`: a NaN-scoring cell must never occupy a
+    // top-K slot, even while the array still has room (count < K) — that's exactly the case
+    // the prior bug missed, since the shift-loop's `top[i - 1].0 > score` never fires to
+    // displace a NaN sitting in an empty slot.
+    let pred = [f32::NAN, 3.0f32, 1.0, f32::NAN, 1.5];
+    let mask = [true; 5];
+    let m = AllowedMask::new(&mask);
+    let top = argmin::argmin_masked_top_k::<3>(&pred, &m, ScoreTransform::Identity, None);
+    assert_eq!(top, [Some(2), Some(4), Some(1)]); // 1.0, 1.5, 3.0 — NaNs never appear
+
+    // All-NaN allowed set: every slot stays None (matches argmin_all_nan_returns_none).
+    let all_nan = [f32::NAN; 4];
+    let mask4 = [true; 4];
+    let m4 = AllowedMask::new(&mask4);
+    let top_all_nan =
+        argmin::argmin_masked_top_k::<3>(&all_nan, &m4, ScoreTransform::Identity, None);
+    assert_eq!(top_all_nan, [None, None, None]);
+}
+
 #[test]
 #[cfg(feature = "advanced")]
 fn pick_with_confidence_reports_gap() {