fix the normalized distance for the binary quantized euclidean distance

src/distance/angular.rs

@@ -52,7 +52,7 @@ impl Distance for Angular {
         }
     }
 
-    fn normalized_distance(d: f32) -> f32 {
+    fn normalized_distance(d: f32, _dimensions: usize) -> f32 {
         d
     }
 

src/distance/binary_quantized_euclidean.rs

@@ -37,11 +37,17 @@ impl Distance for BinaryQuantizedEuclidean {
     }
 
     fn built_distance(p: &Leaf<Self>, q: &Leaf<Self>) -> f32 {
-        dot_product(&p.vector, &q.vector)
+        squared_euclidean_distance(&p.vector, &q.vector)
+    }
+
+    /// Normalizes the distance returned by the distance method.
+    fn normalized_distance(d: f32, dimensions: usize) -> f32 {
+        d / dimensions as f32
     }
 
     fn norm_no_header(v: &UnalignedVector<Self::VectorCodec>) -> f32 {
-        dot_product(v, v).sqrt()
+        let ones = v.as_bytes().iter().map(|b| b.count_ones()).sum::<u32>() as f32;
+        ones.sqrt()
     }
 
     fn init(_node: &mut Leaf<Self>) {}
@@ -75,6 +81,15 @@ impl Distance for BinaryQuantizedEuclidean {
 }
 
 fn dot_product(u: &UnalignedVector<BinaryQuantized>, v: &UnalignedVector<BinaryQuantized>) -> f32 {
+    // /!\ If the number of dimensions is not a multiple of the `Word` size, we'll xor 0 bits at the end, which will generate a lot of 1s.
+    //     This may or may not impact relevancy since the 1s will be added to every vector.
+    u.as_bytes().iter().zip(v.as_bytes()).map(|(u, v)| (u | v).count_ones()).sum::<u32>() as f32
+}
+
+fn squared_euclidean_distance(
+    u: &UnalignedVector<BinaryQuantized>,
+    v: &UnalignedVector<BinaryQuantized>,
+) -> f32 {
     // /!\ If the number of dimensions is not a multiple of the `Word` size, we'll xor 0 bits at the end, which will generate a lot of 1s.
     //     This may or may not impact relevancy since the 1s will be added to every vector.
     u.as_bytes().iter().zip(v.as_bytes()).map(|(u, v)| (u ^ v).count_ones()).sum::<u32>() as f32

src/distance/dot_product.rs

@@ -70,7 +70,7 @@ impl Distance for DotProduct {
         dot_product(v, v).sqrt()
     }
 
-    fn normalized_distance(d: f32) -> f32 {
+    fn normalized_distance(d: f32, _dimension: usize) -> f32 {
         -d
     }
 

src/distance/manhattan.rs

@@ -40,7 +40,7 @@ impl Distance for Manhattan {
         p.vector.iter().zip(q.vector.iter()).map(|(p, q)| (p - q).abs()).sum()
     }
 
-    fn normalized_distance(d: f32) -> f32 {
+    fn normalized_distance(d: f32, _dimension: usize) -> f32 {
         d.max(0.0)
     }
 

src/distance/mod.rs

@@ -44,7 +44,7 @@ pub trait Distance: Send + Sync + Sized + Clone + fmt::Debug + 'static {
     }
 
     /// Normalizes the distance returned by the distance method.
-    fn normalized_distance(d: f32) -> f32 {
+    fn normalized_distance(d: f32, _dimensions: usize) -> f32 {
         d.sqrt()
     }
 

src/reader.rs

@@ -276,7 +276,7 @@ impl<'t, D: Distance> Reader<'t, D> {
             if output.len() == capacity {
                 break;
             }
-            output.push((item, D::normalized_distance(dist)));
+            output.push((item, D::normalized_distance(dist, self.dimensions)));
         }
 
         Ok(output)