usearch 2.16.8 → 2.16.9

package/simsimd/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "simsimd",
-  "version": "5.9.2",
+  "version": "6.0.5",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "simsimd",
-      "version": "5.9.2",
+      "version": "6.0.5",
       "hasInstallScript": true,
       "license": "Apache 2.0",
       "dependencies": {
@@ -16,7 +16,7 @@
       },
       "devDependencies": {
         "@types/bindings": "^1.5.5",
-        "@types/node": "^20.17.1",
+        "@types/node": "^20.17.6",
         "node-gyp": "^10.0.1",
         "prebuildify": "^6.0.0",
         "typescript": "^5.3.3"
@@ -107,9 +107,9 @@
       }
     },
     "node_modules/@types/node": {
-      "version": "20.17.1",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.17.1.tgz",
-      "integrity": "sha512-j2VlPv1NnwPJbaCNv69FO/1z4lId0QmGvpT41YxitRtWlg96g/j8qcv2RKsLKe2F6OJgyXhupN1Xo17b2m139Q==",
+      "version": "20.17.6",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.17.6.tgz",
+      "integrity": "sha512-VEI7OdvK2wP7XHnsuXbAJnEpEkF6NjSN45QJlL4VGqZSXsnicpesdTWsg9RISeSdYd3yeRj/y3k5KGjUXYnFwQ==",
       "devOptional": true,
       "license": "MIT",
       "dependencies": {
@@ -335,10 +335,11 @@
       }
     },
     "node_modules/cross-spawn": {
-      "version": "7.0.3",
-      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz",
-      "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==",
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
         "path-key": "^3.1.0",
         "shebang-command": "^2.0.0",

package/simsimd/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simsimd",
-  "version": "6.0.5",
+  "version": "6.2.3",
   "description": "Portable mixed-precision BLAS-like vector math library for x86 and ARM",
   "homepage": "https://github.com/ashvardanian/simsimd",
   "author": "Ash Vardanian",
@@ -48,7 +48,7 @@
   },
   "devDependencies": {
     "@types/bindings": "^1.5.5",
-    "@types/node": "^20.17.1",
+    "@types/node": "^20.17.6",
     "node-gyp": "^10.0.1",
     "prebuildify": "^6.0.0",
     "typescript": "^5.3.3"

package/simsimd/rust/lib.rs

@@ -80,6 +80,12 @@ extern "C" {
     fn simsimd_l2sq_f32(a: *const f32, b: *const f32, c: usize, d: *mut Distance);
     fn simsimd_l2sq_f64(a: *const f64, b: *const f64, c: usize, d: *mut Distance);
 
+    fn simsimd_l2_i8(a: *const i8, b: *const i8, c: usize, d: *mut Distance);
+    fn simsimd_l2_f16(a: *const u16, b: *const u16, c: usize, d: *mut Distance);
+    fn simsimd_l2_bf16(a: *const u16, b: *const u16, c: usize, d: *mut Distance);
+    fn simsimd_l2_f32(a: *const f32, b: *const f32, c: usize, d: *mut Distance);
+    fn simsimd_l2_f64(a: *const f64, b: *const f64, c: usize, d: *mut Distance);
+
     fn simsimd_hamming_b8(a: *const u8, b: *const u8, c: usize, d: *mut Distance);
     fn simsimd_jaccard_b8(a: *const u8, b: *const u8, c: usize, d: *mut Distance);
 
@@ -93,6 +99,9 @@ extern "C" {
     fn simsimd_kl_f32(a: *const f32, b: *const f32, c: usize, d: *mut Distance);
     fn simsimd_kl_f64(a: *const f64, b: *const f64, c: usize, d: *mut Distance);
 
+    fn simsimd_intersect_u16(a: *const u16, b: *const u16, a_length: usize, b_length: usize, d: *mut Distance);
+    fn simsimd_intersect_u32(a: *const u32, b: *const u32, a_length: usize, b_length: usize, d: *mut Distance);
+
     fn simsimd_uses_neon() -> i32;
     fn simsimd_uses_neon_f16() -> i32;
     fn simsimd_uses_neon_bf16() -> i32;
@@ -215,6 +224,12 @@ where
     /// between corresponding elements of the two slices.
     fn l2sq(a: &[Self], b: &[Self]) -> Option<Distance>;
 
+    /// Computes the Euclidean distance between two slices.
+    /// The Euclidean distance is the square root of 
+    //  sum of the squared differences between corresponding 
+    /// elements of the two slices.
+    fn l2(a: &[Self], b: &[Self]) -> Option<Distance>;
+
     /// Computes the squared Euclidean distance between two slices.
     /// The squared Euclidean distance is the sum of the squared differences
     /// between corresponding elements of the two slices.
@@ -222,6 +237,14 @@ where
         SpatialSimilarity::l2sq(a, b)
     }
 
+    /// Computes the Euclidean distance between two slices.
+    /// The Euclidean distance is the square root of the 
+    /// sum of the squared differences between corresponding 
+    /// elements of the two slices.
+    fn euclidean(a: &[Self], b: &[Self]) -> Option<Distance> {
+        SpatialSimilarity::l2(a, b)
+    }
+
     /// Computes the squared Euclidean distance between two slices.
     /// The squared Euclidean distance is the sum of the squared differences
     /// between corresponding elements of the two slices.
@@ -295,6 +318,16 @@ where
     fn vdot(a: &[Self], b: &[Self]) -> Option<ComplexProduct>;
 }
 
+/// `Sparse` provides trait methods for sparse vectors.
+pub trait Sparse
+where
+    Self: Sized,
+{
+    /// Computes the number of common elements between two sparse vectors.
+    /// both vectors must be sorted in ascending order.
+    fn intersect(a: &[Self], b: &[Self]) -> Option<Distance>;
+}
+
 impl BinarySimilarity for u8 {
     fn hamming(a: &[Self], b: &[Self]) -> Option<Distance> {
         if a.len() != b.len() {
@@ -347,6 +380,38 @@ impl SpatialSimilarity for i8 {
         unsafe { simsimd_l2sq_i8(a.as_ptr(), b.as_ptr(), a.len(), distance_ptr) };
         Some(distance_value)
     }
+
+    fn l2(a: &[Self], b: &[Self]) -> Option<Distance> {
+        if a.len() != b.len() {
+            return None;
+        }
+        let mut distance_value: Distance = 0.0;
+        let distance_ptr: *mut Distance = &mut distance_value as *mut Distance;
+        unsafe { simsimd_l2_i8(a.as_ptr(), b.as_ptr(), a.len(), distance_ptr) };
+        Some(distance_value)
+    }
+}
+
+impl Sparse for u16 {
+      
+    fn intersect(a: &[Self], b: &[Self]) -> Option<Distance> {
+        let mut distance_value: Distance = 0.0;
+        let distance_ptr: *mut Distance = &mut distance_value as *mut Distance;
+        unsafe { simsimd_intersect_u16(a.as_ptr(), b.as_ptr(), a.len(), b.len(), distance_ptr) };
+        Some(distance_value)
+    }
+
+}
+
+impl Sparse for u32 {
+      
+    fn intersect(a: &[Self], b: &[Self]) -> Option<Distance> {
+        let mut distance_value: Distance = 0.0;
+        let distance_ptr: *mut Distance = &mut distance_value as *mut Distance;
+        unsafe { simsimd_intersect_u32(a.as_ptr(), b.as_ptr(), a.len(), b.len(), distance_ptr) };
+        Some(distance_value)
+    }
+
 }
 
 impl SpatialSimilarity for f16 {
@@ -391,6 +456,20 @@ impl SpatialSimilarity for f16 {
         unsafe { simsimd_l2sq_f16(a_ptr, b_ptr, a.len(), distance_ptr) };
         Some(distance_value)
     }
+
+    fn l2(a: &[Self], b: &[Self]) -> Option<Distance> {
+        
+        if a.len() != b.len() {
+            return None;
+        }
+        // Explicitly cast `*const f16` to `*const u16`
+        let a_ptr = a.as_ptr() as *const u16;
+        let b_ptr = b.as_ptr() as *const u16;
+        let mut distance_value: Distance = 0.0;
+        let distance_ptr: *mut Distance = &mut distance_value as *mut Distance;
+        unsafe { simsimd_l2_f16(a_ptr, b_ptr, a.len(), distance_ptr) };
+        Some(distance_value)
+    }
 }
 
 impl SpatialSimilarity for bf16 {
@@ -435,6 +514,19 @@ impl SpatialSimilarity for bf16 {
         unsafe { simsimd_l2sq_bf16(a_ptr, b_ptr, a.len(), distance_ptr) };
         Some(distance_value)
     }
+
+    fn l2(a: &[Self], b: &[Self]) -> Option<Distance> {
+        if a.len() != b.len() {
+            return None;
+        }
+        // Explicitly cast `*const bf16` to `*const u16`
+        let a_ptr = a.as_ptr() as *const u16;
+        let b_ptr = b.as_ptr() as *const u16;
+        let mut distance_value: Distance = 0.0;
+        let distance_ptr: *mut Distance = &mut distance_value as *mut Distance;
+        unsafe { simsimd_l2sq_bf16(a_ptr, b_ptr, a.len(), distance_ptr) };
+        Some(distance_value)
+    }
 }
 
 impl SpatialSimilarity for f32 {
@@ -467,6 +559,16 @@ impl SpatialSimilarity for f32 {
         unsafe { simsimd_l2sq_f32(a.as_ptr(), b.as_ptr(), a.len(), distance_ptr) };
         Some(distance_value)
     }
+
+    fn l2(a: &[Self], b: &[Self]) -> Option<Distance> {
+        if a.len() != b.len() {
+            return None;
+        }
+        let mut distance_value: Distance = 0.0;
+        let distance_ptr: *mut Distance = &mut distance_value as *mut Distance;
+        unsafe { simsimd_l2_f32(a.as_ptr(), b.as_ptr(), a.len(), distance_ptr) };
+        Some(distance_value)
+    }
 }
 
 impl SpatialSimilarity for f64 {
@@ -499,6 +601,16 @@ impl SpatialSimilarity for f64 {
         unsafe { simsimd_l2sq_f64(a.as_ptr(), b.as_ptr(), a.len(), distance_ptr) };
         Some(distance_value)
     }
+
+    fn l2(a: &[Self], b: &[Self]) -> Option<Distance> {
+        if a.len() != b.len() {
+            return None;
+        }
+        let mut distance_value: Distance = 0.0;
+        let distance_ptr: *mut Distance = &mut distance_value as *mut Distance;
+        unsafe { simsimd_l2_f64(a.as_ptr(), b.as_ptr(), a.len(), distance_ptr) };
+        Some(distance_value)
+    }
 }
 
 impl ProbabilitySimilarity for f16 {
@@ -850,6 +962,60 @@ mod tests {
         }
     }
 
+    #[test]
+    fn test_l2_f32() {
+        let a: &[f32; 3] = &[1.0, 2.0, 3.0];
+        let b: &[f32; 3] = &[4.0, 5.0, 6.0];
+        if let Some(result) = SpatialSimilarity::euclidean(a, b) {
+            println!("The result of l2_f32 is {:.8}", result);
+            assert_almost_equal(5.2, result, 0.01);
+        }
+    }
+
+    #[test]
+    fn test_l2_f64() {
+        let a: &[f64; 3] = &[1.0, 2.0, 3.0];
+        let b: &[f64; 3] = &[4.0, 5.0, 6.0];
+        if let Some(result) = SpatialSimilarity::euclidean(a, b) {
+            println!("The result of l2_f64 is {:.8}", result);
+            assert_almost_equal(5.2, result, 0.01);
+        }
+    }
+
+    #[test]
+    fn test_l2_f16() {
+        let a_half: Vec<HalfF16> = vec![1.0, 2.0, 3.0]
+            .iter()
+            .map(|&x| HalfF16::from_f32(x))
+            .collect();
+        let b_half: Vec<HalfF16> = vec![4.0, 5.0, 6.0]
+            .iter()
+            .map(|&x| HalfF16::from_f32(x))
+            .collect();
+
+        
+        let a_simsimd: &[f16] =
+            unsafe { std::slice::from_raw_parts(a_half.as_ptr() as *const f16, a_half.len()) };
+        let b_simsimd: &[f16] =
+            unsafe { std::slice::from_raw_parts(b_half.as_ptr() as *const f16, b_half.len()) };
+
+        if let Some(result) = SpatialSimilarity::euclidean(&a_simsimd, &b_simsimd) {
+            println!("The result of l2_f16 is {:.8}", result);
+            assert_almost_equal(5.2, result, 0.01);
+        }
+        
+    }
+
+    #[test]
+    fn test_l2_i8() {
+        let a = &[1, 2, 3];
+        let b = &[4, 5, 6];
+
+        if let Some(result) = SpatialSimilarity::euclidean(a, b) {
+            println!("The result of l2_i8 is {:.8}", result);
+            assert_almost_equal(5.2, result, 0.01);
+        }
+    }
     // Adding new tests for bit-level distances
     #[test]
     fn test_hamming_u8() {
@@ -877,19 +1043,19 @@ mod tests {
     // Adding new tests for probability similarities
     #[test]
     fn test_js_f32() {
-        let a = &[0.1, 0.9, 0.0];
-        let b = &[0.2, 0.8, 0.0];
+        let a: &[f32; 3] = &[0.1, 0.9, 0.0];
+        let b: &[f32; 3] = &[0.2, 0.8, 0.0];
 
         if let Some(result) = ProbabilitySimilarity::jensenshannon(a, b) {
             println!("The result of js_f32 is {:.8}", result);
-            assert_almost_equal(0.01, result, 0.01); // Example value
+            assert_almost_equal(0.099, result, 0.01); // Example value
         }
     }
 
     #[test]
     fn test_kl_f32() {
-        let a = &[0.1, 0.9, 0.0];
-        let b = &[0.2, 0.8, 0.0];
+        let a: &[f32; 3] = &[0.1, 0.9, 0.0];
+        let b: &[f32; 3] = &[0.2, 0.8, 0.0];
 
         if let Some(result) = ProbabilitySimilarity::kullbackleibler(a, b) {
             println!("The result of kl_f32 is {:.8}", result);
@@ -990,4 +1156,51 @@ mod tests {
             assert_almost_equal(0.025, result, 0.01);
         }
     }
+
+    #[test]
+    fn test_intersect_u16() {
+        {
+            let a_u16: &[u16] = &[153, 16384, 17408]; 
+            let b_u16: &[u16] = &[15360, 16384, 7408]; 
+
+            if let Some(result) = Sparse::intersect(a_u16, b_u16) {
+                println!("The result of intersect_u16 is {:.8}", result);
+                assert_almost_equal(1.0, result, 0.0001);
+            }
+        }
+
+        {
+            let a_u16: &[u16] = &[153, 11638, 08]; 
+            let b_u16: &[u16] = &[15360, 16384, 7408]; 
+
+            if let Some(result) = Sparse::intersect(a_u16, b_u16) {
+                println!("The result of intersect_u16 is {:.8}", result);
+                assert_almost_equal(0.0, result, 0.0001);
+            }   
+        }
+    }
+
+    #[test]
+    fn test_intersect_u32() {
+        {
+            let a_u32: &[u32] = &[11, 153]; 
+            let b_u32: &[u32] = &[11, 153, 7408, 16384]; 
+
+            if let Some(result) = Sparse::intersect(a_u32, b_u32) {
+                println!("The result of intersect_u32 is {:.8}", result);
+                assert_almost_equal(2.0, result, 0.0001);
+            }
+        }
+        
+        {
+            let a_u32: &[u32] = &[153, 7408, 11638]; 
+            let b_u32: &[u32] = &[153, 7408, 11638]; 
+
+            if let Some(result) = Sparse::intersect(a_u32, b_u32) {
+                println!("The result of intersect_u32 is {:.8}", result);
+                assert_almost_equal(3.0, result, 0.0001);
+            }   
+        }
+        
+    }
 }