add debug impls for all node headers

different platforms show varying numbers of digits in f32 debug impl =>
failing tests on linux vs macos runners. to fix this we ensure only 4
digits are printed

Author: nnethercott

src/distance/binary_quantized_cosine.rs

@@ -1,3 +1,5 @@
+use std::fmt;
+
 use bytemuck::{Pod, Zeroable};
 use rand::Rng;
 
@@ -18,10 +20,17 @@ pub enum BinaryQuantizedCosine {}
 
 /// The header of `BinaryQuantizedCosine` leaf nodes.
 #[repr(C)]
-#[derive(Pod, Zeroable, Debug, Clone, Copy)]
+#[derive(Pod, Zeroable, Clone, Copy)]
 pub struct NodeHeaderBinaryQuantizedCosine {
     norm: f32,
 }
+impl fmt::Debug for NodeHeaderBinaryQuantizedCosine {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("NodeHeaderBinaryQuantizedCosine")
+            .field("norm", &format!("{:.4}", self.norm))
+            .finish()
+    }
+}
 
 impl Distance for BinaryQuantizedCosine {
     const DEFAULT_OVERSAMPLING: usize = 3;

src/distance/binary_quantized_euclidean.rs

@@ -1,3 +1,5 @@
+use std::fmt;
+
 use bytemuck::{Pod, Zeroable};
 use rand::Rng;
 
@@ -19,11 +21,18 @@ pub enum BinaryQuantizedEuclidean {}
 
 /// The header of `BinaryQuantizedEuclidean` leaf nodes.
 #[repr(C)]
-#[derive(Pod, Zeroable, Debug, Clone, Copy)]
+#[derive(Pod, Zeroable, Clone, Copy)]
 pub struct NodeHeaderBinaryQuantizedEuclidean {
     /// An extra constant term to determine the offset of the plane
     bias: f32,
 }
+impl fmt::Debug for NodeHeaderBinaryQuantizedEuclidean {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("NodeHeaderBinaryQuantizedEuclidean")
+            .field("bias", &format!("{:.4}", self.bias))
+            .finish()
+    }
+}
 
 impl Distance for BinaryQuantizedEuclidean {
     const DEFAULT_OVERSAMPLING: usize = 3;

src/distance/binary_quantized_manhattan.rs

@@ -1,3 +1,5 @@
+use std::fmt;
+
 use bytemuck::{Pod, Zeroable};
 use rand::Rng;
 
@@ -18,11 +20,18 @@ pub enum BinaryQuantizedManhattan {}
 
 /// The header of BinaryQuantizedEuclidean leaf nodes.
 #[repr(C)]
-#[derive(Pod, Zeroable, Debug, Clone, Copy)]
+#[derive(Pod, Zeroable, Clone, Copy)]
 pub struct NodeHeaderBinaryQuantizedManhattan {
     /// An extra constant term to determine the offset of the plane
     bias: f32,
 }
+impl fmt::Debug for NodeHeaderBinaryQuantizedManhattan {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("NodeHeaderBinaryQuantizedManhattan")
+            .field("bias", &format!("{:.4}", self.bias))
+            .finish()
+    }
+}
 
 impl Distance for BinaryQuantizedManhattan {
     const DEFAULT_OVERSAMPLING: usize = 3;

src/distance/cosine.rs

@@ -1,3 +1,5 @@
+use std::fmt;
+
 use bytemuck::{Pod, Zeroable};
 use rand::Rng;
 
@@ -16,10 +18,15 @@ pub enum Cosine {}
 
 /// The header of Cosine leaf nodes.
 #[repr(C)]
-#[derive(Pod, Zeroable, Debug, Clone, Copy)]
+#[derive(Pod, Zeroable, Clone, Copy)]
 pub struct NodeHeaderCosine {
     norm: f32,
 }
+impl fmt::Debug for NodeHeaderCosine {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("NodeHeaderCosine").field("norm", &format!("{:.4}", self.norm)).finish()
+    }
+}
 
 impl Distance for Cosine {
     type Header = NodeHeaderCosine;

src/distance/dot_product.rs

@@ -1,3 +1,5 @@
+use std::fmt;
+
 use bytemuck::{Pod, Zeroable};
 use heed::{RwPrefix, RwTxn};
 use rand::Rng;
@@ -19,12 +21,20 @@ pub enum DotProduct {}
 
 /// The header of DotProduct leaf nodes.
 #[repr(C)]
-#[derive(Pod, Zeroable, Debug, Clone, Copy)]
+#[derive(Pod, Zeroable, Clone, Copy)]
 pub struct NodeHeaderDotProduct {
     extra_dim: f32,
     /// An extra constant term to determine the offset of the plane
     norm: f32,
 }
+impl fmt::Debug for NodeHeaderDotProduct {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("NodeHeaderDotProduct")
+            .field("extra_dim", &format!("{:.4}", self.extra_dim))
+            .field("norm", &format!("{:.4}", self.norm))
+            .finish()
+    }
+}
 
 impl Distance for DotProduct {
     type Header = NodeHeaderDotProduct;

src/distance/euclidean.rs

@@ -1,3 +1,5 @@
+use std::fmt;
+
 use bytemuck::{Pod, Zeroable};
 use rand::Rng;
 
@@ -17,11 +19,16 @@ pub enum Euclidean {}
 
 /// The header of Euclidean leaf nodes.
 #[repr(C)]
-#[derive(Pod, Zeroable, Debug, Clone, Copy)]
+#[derive(Pod, Zeroable, Clone, Copy)]
 pub struct NodeHeaderEuclidean {
     /// An extra constant term to determine the offset of the plane
     bias: f32,
 }
+impl fmt::Debug for NodeHeaderEuclidean {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("NodeHeaderEuclidean").field("bias", &format!("{:.4}", self.bias)).finish()
+    }
+}
 
 impl Distance for Euclidean {
     type Header = NodeHeaderEuclidean;

src/distance/manhattan.rs

@@ -1,3 +1,5 @@
+use std::fmt;
+
 use bytemuck::{Pod, Zeroable};
 use rand::Rng;
 
@@ -16,11 +18,16 @@ pub enum Manhattan {}
 
 /// The header of Manhattan leaf nodes.
 #[repr(C)]
-#[derive(Pod, Zeroable, Debug, Clone, Copy)]
+#[derive(Pod, Zeroable, Clone, Copy)]
 pub struct NodeHeaderManhattan {
     /// An extra constant term to determine the offset of the plane
     bias: f32,
 }
+impl fmt::Debug for NodeHeaderManhattan {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("NodeHeaderManhattan").field("bias", &format!("{:.4}", self.bias)).finish()
+    }
+}
 
 impl Distance for Manhattan {
     type Header = NodeHeaderManhattan;

src/reader.rs

@@ -347,7 +347,7 @@ impl<'t, D: Distance> Reader<'t, D> {
             let key = Key::new(self.index, item);
             match self.database_get(rtxn, &key)?.ok_or(Error::missing_key(key))? {
                 GenericReadNode::Leaf(_) => {
-                    if opt.candidates.map_or(true, |c| c.contains(item.item)) {
+                    if opt.candidates.is_none_or(|c| c.contains(item.item)) {
                         nns.push(item.unwrap_item());
                     }
                 }
@@ -364,7 +364,7 @@ impl<'t, D: Distance> Reader<'t, D> {
                     right,
                 }) => {
                     let margin = match normal {
-                        Some(normal) => D::margin(&normal, &query_leaf),
+                        Some(normal) => D::margin(&normal, query_leaf),
                         None => 0.0,
                     };
                     queue.push((OrderedFloat(D::pq_distance(dist, margin, Side::Left)), left));