usearch 2.21.2 → 2.21.4

package/simsimd/rust/lib.rs

@@ -7,7 +7,7 @@
 //!
 //! ## Implemented distance functions include:
 //!
-//! * Euclidean (L2), Inner Distance, and Cosine (Angular) spatial distances.
+//! * Euclidean (L2), inner product, and cosine (angular) spatial distances.
 //! * Hamming (~ Manhattan) and Jaccard (~ Tanimoto) binary distances.
 //! * Kullback-Leibler and Jensen-Shannon divergences for probability distributions.
 //!
@@ -19,8 +19,8 @@
 //! let a = &[1, 2, 3];
 //! let b = &[4, 5, 6];
 //!
-//! // Compute cosine similarity
-//! let cos_sim = i8::cos(a, b);
+//! // Compute cosine distance
+//! let cos_dist = i8::cos(a, b);
 //!
 //! // Compute dot product distance
 //! let dot_product = i8::dot(a, b);
@@ -40,12 +40,12 @@
 //! // Work with half-precision floats
 //! let half_a: Vec<f16> = vec![1.0, 2.0, 3.0].iter().map(|&x| f16::from_f32(x)).collect();
 //! let half_b: Vec<f16> = vec![4.0, 5.0, 6.0].iter().map(|&x| f16::from_f32(x)).collect();
-//! let half_cos = f16::cos(&half_a, &half_b);
+//! let half_cos_dist = f16::cos(&half_a, &half_b);
 //!
 //! // Work with brain floats
 //! let brain_a: Vec<bf16> = vec![1.0, 2.0, 3.0].iter().map(|&x| bf16::from_f32(x)).collect();
 //! let brain_b: Vec<bf16> = vec![4.0, 5.0, 6.0].iter().map(|&x| bf16::from_f32(x)).collect();
-//! let brain_cos = bf16::cos(&brain_a, &brain_b);
+//! let brain_cos_dist = bf16::cos(&brain_a, &brain_b);
 //!
 //! // Direct bit manipulation
 //! let half = f16::from_f32(3.14);
@@ -57,14 +57,14 @@
 //!
 //! The `SpatialSimilarity` trait covers following methods:
 //!
-//! - `cosine(a: &[Self], b: &[Self]) -> Option<Distance>`: Computes cosine similarity between two slices.
+//! - `cosine(a: &[Self], b: &[Self]) -> Option<Distance>`: Computes cosine distance (1 - similarity) between two slices.
 //! - `dot(a: &[Self], b: &[Self]) -> Option<Distance>`: Computes dot product distance between two slices.
 //! - `sqeuclidean(a: &[Self], b: &[Self]) -> Option<Distance>`: Computes squared Euclidean distance between two slices.
 //!
 //! The `BinarySimilarity` trait covers following methods:
 //!
 //! - `hamming(a: &[Self], b: &[Self]) -> Option<Distance>`: Computes Hamming distance between two slices.
-//! - `jaccard(a: &[Self], b: &[Self]) -> Option<Distance>`: Computes Jaccard index between two slices.
+//! - `jaccard(a: &[Self], b: &[Self]) -> Option<Distance>`: Computes Jaccard distance between two slices.
 //!
 //! The `ProbabilitySimilarity` trait covers following methods:
 //!
@@ -77,6 +77,12 @@
 pub type Distance = f64;
 pub type ComplexProduct = (f64, f64);
 
+/// Compatibility function for pre 1.85 Rust versions lacking `f32::abs`.
+#[inline(always)]
+fn f32_abs_compat(x: f32) -> f32 {
+    f32::from_bits(x.to_bits() & 0x7FFF_FFFF)
+}
+
 #[link(name = "simsimd")]
 extern "C" {
 
@@ -194,10 +200,10 @@ pub struct f16(pub u16);
 impl f16 {
     /// Positive zero.
     pub const ZERO: Self = f16(0);
-    
+
     /// Positive one.
     pub const ONE: Self = f16(0x3C00);
-    
+
     /// Negative one.
     pub const NEG_ONE: Self = f16(0xBC00);
 
@@ -251,11 +257,11 @@ impl f16 {
     /// Returns the absolute value of self.
     #[inline(always)]
     pub fn abs(self) -> Self {
-        Self::from_f32(self.to_f32().abs())
+        Self::from_f32(f32_abs_compat(self.to_f32()))
     }
 
     /// Returns the largest integer less than or equal to a number.
-    /// 
+    ///
     /// This method is only available when the `std` feature is enabled.
     #[cfg(feature = "std")]
     #[inline(always)]
@@ -264,7 +270,7 @@ impl f16 {
     }
 
     /// Returns the smallest integer greater than or equal to a number.
-    /// 
+    ///
     /// This method is only available when the `std` feature is enabled.
     #[cfg(feature = "std")]
     #[inline(always)]
@@ -273,7 +279,7 @@ impl f16 {
     }
 
     /// Returns the nearest integer to a number. Round half-way cases away from 0.0.
-    /// 
+    ///
     /// This method is only available when the `std` feature is enabled.
     #[cfg(feature = "std")]
     #[inline(always)]
@@ -368,10 +374,10 @@ pub struct bf16(pub u16);
 impl bf16 {
     /// Positive zero.
     pub const ZERO: Self = bf16(0);
-    
+
     /// Positive one.
     pub const ONE: Self = bf16(0x3F80);
-    
+
     /// Negative one.
     pub const NEG_ONE: Self = bf16(0xBF80);
 
@@ -425,11 +431,11 @@ impl bf16 {
     /// Returns the absolute value of self.
     #[inline(always)]
     pub fn abs(self) -> Self {
-        Self::from_f32(self.to_f32().abs())
+        Self::from_f32(f32_abs_compat(self.to_f32()))
     }
 
     /// Returns the largest integer less than or equal to a number.
-    /// 
+    ///
     /// This method is only available when the `std` feature is enabled.
     #[cfg(feature = "std")]
     #[inline(always)]
@@ -438,7 +444,7 @@ impl bf16 {
     }
 
     /// Returns the smallest integer greater than or equal to a number.
-    /// 
+    ///
     /// This method is only available when the `std` feature is enabled.
     #[cfg(feature = "std")]
     #[inline(always)]
@@ -447,7 +453,7 @@ impl bf16 {
     }
 
     /// Returns the nearest integer to a number. Round half-way cases away from 0.0.
-    /// 
+    ///
     /// This method is only available when the `std` feature is enabled.
     #[cfg(feature = "std")]
     #[inline(always)]
@@ -596,8 +602,8 @@ pub mod capabilities {
     ///
     /// # Returns
     ///
-    /// Returns `true` if dynamic dispatch is enabled, `false` otherwise.
-    /// Currently always returns `false` as dynamic dispatch is not implemented.
+    /// Returns `true` when the C backend is compiled with dynamic dispatch
+    /// (default for this crate via `build.rs`), otherwise `false`.
     pub fn uses_dynamic_dispatch() -> bool {
         unsafe { crate::simsimd_uses_dynamic_dispatch() != 0 }
     }
@@ -605,19 +611,21 @@ pub mod capabilities {
 
 /// `SpatialSimilarity` provides a set of trait methods for computing similarity
 /// or distance between spatial data vectors in SIMD (Single Instruction, Multiple Data) context.
-/// These methods can be used to calculate metrics like cosine similarity, dot product,
+/// These methods can be used to calculate metrics like cosine distance, dot product,
 /// and squared Euclidean distance between two slices of data.
 ///
 /// Each method takes two slices of data (a and b) and returns an Option<Distance>.
 /// The result is `None` if the slices are not of the same length, as these operations
 /// require one-to-one correspondence between the elements of the slices.
-/// Otherwise, it returns the computed similarity or distance as `Some(f32)`.
+/// Otherwise, it returns the computed similarity or distance as `Some(f64)`.
+/// Convenience methods like `cosine`/`sqeuclidean` delegate to the core methods
+/// `cos`/`l2sq` implemented by this trait.
 pub trait SpatialSimilarity
 where
     Self: Sized,
 {
-    /// Computes the cosine similarity between two slices.
-    /// The cosine similarity is a measure of similarity between two non-zero vectors
+    /// Computes the cosine distance between two slices.
+    /// The cosine distance is 1 minus the cosine similarity between two non-zero vectors
     /// of an dot product space that measures the cosine of the angle between them.
     fn cos(a: &[Self], b: &[Self]) -> Option<Distance>;
 
@@ -659,8 +667,8 @@ where
         SpatialSimilarity::dot(a, b)
     }
 
-    /// Computes the cosine similarity between two slices.
-    /// The cosine similarity is a measure of similarity between two non-zero vectors
+    /// Computes the cosine distance between two slices.
+    /// The cosine distance is 1 minus the cosine similarity between two non-zero vectors
     /// of an dot product space that measures the cosine of the angle between them.
     fn cosine(a: &[Self], b: &[Self]) -> Option<Distance> {
         SpatialSimilarity::cos(a, b)
@@ -1121,7 +1129,7 @@ impl ProbabilitySimilarity for f64 {
 
 impl ComplexProducts for f16 {
     fn dot(a: &[Self], b: &[Self]) -> Option<ComplexProduct> {
-        if a.len() != b.len() {
+        if a.len() != b.len() || a.len() % 2 != 0 {
             return None;
         }
         // Prepare the output array where the real and imaginary parts will be stored
@@ -1130,26 +1138,28 @@ impl ComplexProducts for f16 {
         // 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;
-        unsafe { simsimd_dot_f16c(a_ptr, b_ptr, a.len(), product_ptr) };
+        // The C function expects the number of complex pairs, not the total number of f16 elements
+        unsafe { simsimd_dot_f16c(a_ptr, b_ptr, a.len() / 2, product_ptr) };
         Some((product[0], product[1]))
     }
 
     fn vdot(a: &[Self], b: &[Self]) -> Option<ComplexProduct> {
-        if a.len() != b.len() {
+        if a.len() != b.len() || a.len() % 2 != 0 {
             return None;
         }
         let mut product: [Distance; 2] = [0.0, 0.0];
         let product_ptr: *mut Distance = &mut product[0] as *mut _;
         let a_ptr = a.as_ptr() as *const u16;
         let b_ptr = b.as_ptr() as *const u16;
-        unsafe { simsimd_vdot_f16c(a_ptr, b_ptr, a.len(), product_ptr) };
+        // The C function expects the number of complex pairs, not the total number of f16 elements
+        unsafe { simsimd_vdot_f16c(a_ptr, b_ptr, a.len() / 2, product_ptr) };
         Some((product[0], product[1]))
     }
 }
 
 impl ComplexProducts for bf16 {
     fn dot(a: &[Self], b: &[Self]) -> Option<ComplexProduct> {
-        if a.len() != b.len() {
+        if a.len() != b.len() || a.len() % 2 != 0 {
             return None;
         }
         // Prepare the output array where the real and imaginary parts will be stored
@@ -1158,12 +1168,13 @@ impl ComplexProducts for bf16 {
         // 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;
-        unsafe { simsimd_dot_bf16c(a_ptr, b_ptr, a.len(), product_ptr) };
+        // The C function expects the number of complex pairs, not the total number of bf16 elements
+        unsafe { simsimd_dot_bf16c(a_ptr, b_ptr, a.len() / 2, product_ptr) };
         Some((product[0], product[1]))
     }
 
     fn vdot(a: &[Self], b: &[Self]) -> Option<ComplexProduct> {
-        if a.len() != b.len() {
+        if a.len() != b.len() || a.len() % 2 != 0 {
             return None;
         }
         // Prepare the output array where the real and imaginary parts will be stored
@@ -1172,51 +1183,56 @@ impl ComplexProducts for bf16 {
         // 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;
-        unsafe { simsimd_vdot_bf16c(a_ptr, b_ptr, a.len(), product_ptr) };
+        // The C function expects the number of complex pairs, not the total number of bf16 elements
+        unsafe { simsimd_vdot_bf16c(a_ptr, b_ptr, a.len() / 2, product_ptr) };
         Some((product[0], product[1]))
     }
 }
 
 impl ComplexProducts for f32 {
     fn dot(a: &[Self], b: &[Self]) -> Option<ComplexProduct> {
-        if a.len() != b.len() {
+        if a.len() != b.len() || a.len() % 2 != 0 {
             return None;
         }
         let mut product: [Distance; 2] = [0.0, 0.0];
         let product_ptr: *mut Distance = &mut product[0] as *mut _;
-        unsafe { simsimd_dot_f32c(a.as_ptr(), b.as_ptr(), a.len(), product_ptr) };
+        // The C function expects the number of complex pairs, not the total number of floats
+        unsafe { simsimd_dot_f32c(a.as_ptr(), b.as_ptr(), a.len() / 2, product_ptr) };
         Some((product[0], product[1]))
     }
 
     fn vdot(a: &[Self], b: &[Self]) -> Option<ComplexProduct> {
-        if a.len() != b.len() {
+        if a.len() != b.len() || a.len() % 2 != 0 {
             return None;
         }
         let mut product: [Distance; 2] = [0.0, 0.0];
         let product_ptr: *mut Distance = &mut product[0] as *mut _;
-        unsafe { simsimd_vdot_f32c(a.as_ptr(), b.as_ptr(), a.len(), product_ptr) };
+        // The C function expects the number of complex pairs, not the total number of floats
+        unsafe { simsimd_vdot_f32c(a.as_ptr(), b.as_ptr(), a.len() / 2, product_ptr) };
         Some((product[0], product[1]))
     }
 }
 
 impl ComplexProducts for f64 {
     fn dot(a: &[Self], b: &[Self]) -> Option<ComplexProduct> {
-        if a.len() != b.len() {
+        if a.len() != b.len() || a.len() % 2 != 0 {
             return None;
         }
         let mut product: [Distance; 2] = [0.0, 0.0];
         let product_ptr: *mut Distance = &mut product[0] as *mut _;
-        unsafe { simsimd_dot_f64c(a.as_ptr(), b.as_ptr(), a.len(), product_ptr) };
+        // The C function expects the number of complex pairs, not the total number of floats
+        unsafe { simsimd_dot_f64c(a.as_ptr(), b.as_ptr(), a.len() / 2, product_ptr) };
         Some((product[0], product[1]))
     }
 
     fn vdot(a: &[Self], b: &[Self]) -> Option<ComplexProduct> {
-        if a.len() != b.len() {
+        if a.len() != b.len() || a.len() % 2 != 0 {
             return None;
         }
         let mut product: [Distance; 2] = [0.0, 0.0];
         let product_ptr: *mut Distance = &mut product[0] as *mut _;
-        unsafe { simsimd_vdot_f64c(a.as_ptr(), b.as_ptr(), a.len(), product_ptr) };
+        // The C function expects the number of complex pairs, not the total number of floats
+        unsafe { simsimd_vdot_f64c(a.as_ptr(), b.as_ptr(), a.len() / 2, product_ptr) };
         Some((product[0], product[1]))
     }
 }
@@ -1228,7 +1244,7 @@ mod tests {
     use half::f16 as HalfF16;
 
     #[test]
-    fn test_hardware_features_detection() {
+    fn hardware_features_detection() {
         let uses_arm = capabilities::uses_neon() || capabilities::uses_sve();
         let uses_x86 = capabilities::uses_haswell()
             || capabilities::uses_skylake()
@@ -1246,7 +1262,13 @@ mod tests {
         }
 
         println!("- uses_neon: {}", capabilities::uses_neon());
+        println!("- uses_neon_f16: {}", capabilities::uses_neon_f16());
+        println!("- uses_neon_bf16: {}", capabilities::uses_neon_bf16());
+        println!("- uses_neon_i8: {}", capabilities::uses_neon_i8());
         println!("- uses_sve: {}", capabilities::uses_sve());
+        println!("- uses_sve_f16: {}", capabilities::uses_sve_f16());
+        println!("- uses_sve_bf16: {}", capabilities::uses_sve_bf16());
+        println!("- uses_sve_i8: {}", capabilities::uses_sve_i8());
         println!("- uses_haswell: {}", capabilities::uses_haswell());
         println!("- uses_skylake: {}", capabilities::uses_skylake());
         println!("- uses_ice: {}", capabilities::uses_ice());
@@ -1265,127 +1287,109 @@ mod tests {
     }
 
     #[test]
-    fn test_cos_i8() {
+    fn cos_i8() {
         let a = &[3, 97, 127];
         let b = &[3, 97, 127];
 
         if let Some(result) = SpatialSimilarity::cosine(a, b) {
-            println!("The result of cos_i8 is {:.8}", result);
             assert_almost_equal(0.00012027938, result, 0.01);
         }
     }
 
     #[test]
-    fn test_cos_f32() {
+    fn cos_f32() {
         let a = &[1.0, 2.0, 3.0];
         let b = &[4.0, 5.0, 6.0];
 
         if let Some(result) = SpatialSimilarity::cosine(a, b) {
-            println!("The result of cos_f32 is {:.8}", result);
             assert_almost_equal(0.025, result, 0.01);
         }
     }
 
     #[test]
-    fn test_dot_i8() {
+    fn dot_i8() {
         let a = &[1, 2, 3];
         let b = &[4, 5, 6];
 
         if let Some(result) = SpatialSimilarity::dot(a, b) {
-            println!("The result of dot_i8 is {:.8}", result);
             assert_almost_equal(32.0, result, 0.01);
         }
     }
 
     #[test]
-    fn test_dot_f32() {
+    fn dot_f32() {
         let a = &[1.0, 2.0, 3.0];
         let b = &[4.0, 5.0, 6.0];
 
         if let Some(result) = SpatialSimilarity::dot(a, b) {
-            println!("The result of dot_f32 is {:.8}", result);
             assert_almost_equal(32.0, result, 0.01);
         }
     }
 
     #[test]
-    fn test_dot_f32_complex() {
+    fn dot_f32_complex() {
         // Let's consider these as complex numbers where every pair is (real, imaginary)
         let a: &[f32; 4] = &[1.0, 2.0, 3.0, 4.0]; // Represents two complex numbers: 1+2i, 3+4i
         let b: &[f32; 4] = &[5.0, 6.0, 7.0, 8.0]; // Represents two complex numbers: 5+6i, 7+8i
 
         if let Some((real, imag)) = ComplexProducts::dot(a, b) {
-            println!(
-                "The result of dot_f32_complex is real: {:.8}, imag: {:.8}",
-                real, imag
-            );
-            // These values should be replaced with the expected real and imaginary parts of the result
-            assert_almost_equal(-18.0, real, 0.01); // Corrected expected real part
-            assert_almost_equal(68.0, imag, 0.01); // Corrected expected imaginary part
+            assert_almost_equal(-18.0, real, 0.01);
+            assert_almost_equal(68.0, imag, 0.01);
         }
     }
 
     #[test]
-    fn test_vdot_f32_complex() {
+    fn vdot_f32_complex() {
         // Here we're assuming a similar setup to the previous test, but for the Hermitian (conjugate) dot product
         let a: &[f32; 4] = &[1.0, 2.0, 3.0, 4.0]; // Represents two complex numbers: 1+2i, 3+4i
         let b: &[f32; 4] = &[5.0, 6.0, 7.0, 8.0]; // Represents two complex numbers: 5+6i, 7+8i
 
         if let Some((real, imag)) = ComplexProducts::vdot(a, b) {
-            println!(
-                "The result of vdot_f32_complex is real: {:.8}, imag: {:.8}",
-                real, imag
-            );
-            // Replace these with the actual expected values
-            assert_almost_equal(70.0, real, 0.01); // Example expected real part
-            assert_almost_equal(-8.0, imag, 0.01); // Example expected imaginary part
+            assert_almost_equal(70.0, real, 0.01);
+            assert_almost_equal(-8.0, imag, 0.01);
         }
     }
 
     #[test]
-    fn test_l2sq_i8() {
+    fn l2sq_i8() {
         let a = &[1, 2, 3];
         let b = &[4, 5, 6];
 
         if let Some(result) = SpatialSimilarity::sqeuclidean(a, b) {
-            println!("The result of l2sq_i8 is {:.8}", result);
             assert_almost_equal(27.0, result, 0.01);
         }
     }
 
     #[test]
-    fn test_l2sq_f32() {
+    fn l2sq_f32() {
         let a = &[1.0, 2.0, 3.0];
         let b = &[4.0, 5.0, 6.0];
 
         if let Some(result) = SpatialSimilarity::sqeuclidean(a, b) {
-            println!("The result of l2sq_f32 is {:.8}", result);
             assert_almost_equal(27.0, result, 0.01);
         }
     }
 
     #[test]
-    fn test_l2_f32() {
+    fn 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() {
+    fn 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() {
+    fn l2_f16() {
         let a_half: Vec<HalfF16> = vec![1.0, 2.0, 3.0]
             .iter()
             .map(|&x| HalfF16::from_f32(x))
@@ -1401,110 +1405,98 @@ mod tests {
             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() {
+    fn 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() {
-        let a = &[0b01010101, 0b11110000, 0b10101010]; // Binary representations for clarity
+    fn hamming_u8() {
+        let a = &[0b01010101, 0b11110000, 0b10101010];
         let b = &[0b01010101, 0b11110000, 0b10101010];
 
         if let Some(result) = BinarySimilarity::hamming(a, b) {
-            println!("The result of hamming_u8 is {:.8}", result);
-            assert_almost_equal(0.0, result, 0.01); // Perfect match
+            assert_almost_equal(0.0, result, 0.01);
         }
     }
 
     #[test]
-    fn test_jaccard_u8() {
+    fn jaccard_u8() {
         // For binary data, treat each byte as a set of bits
         let a = &[0b11110000, 0b00001111, 0b10101010];
         let b = &[0b11110000, 0b00001111, 0b01010101];
 
         if let Some(result) = BinarySimilarity::jaccard(a, b) {
-            println!("The result of jaccard_u8 is {:.8}", result);
-            assert_almost_equal(0.5, result, 0.01); // Example value
+            assert_almost_equal(0.5, result, 0.01);
         }
     }
 
     // Adding new tests for probability similarities
     #[test]
-    fn test_js_f32() {
+    fn js_f32() {
         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.099, result, 0.01); // Example value
+            assert_almost_equal(0.099, result, 0.01);
         }
     }
 
     #[test]
-    fn test_kl_f32() {
+    fn kl_f32() {
         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);
-            assert_almost_equal(0.036, result, 0.01); // Example value
+            assert_almost_equal(0.036, result, 0.01);
         }
     }
 
     #[test]
-    fn test_cos_f16_same() {
+    fn cos_f16_same() {
         // Assuming these u16 values represent f16 bit patterns, and they are identical
         let a_u16: &[u16] = &[15360, 16384, 17408]; // Corresponding to some f16 values
         let b_u16: &[u16] = &[15360, 16384, 17408]; // Same as above for simplicity
 
         // Reinterpret cast from &[u16] to &[f16]
-        // SAFETY: This is safe as long as the representations are guaranteed to be identical,
-        // which they are for transparent structs wrapping the same type.
         let a_f16: &[f16] =
             unsafe { std::slice::from_raw_parts(a_u16.as_ptr() as *const f16, a_u16.len()) };
         let b_f16: &[f16] =
             unsafe { std::slice::from_raw_parts(b_u16.as_ptr() as *const f16, b_u16.len()) };
 
         if let Some(result) = SpatialSimilarity::cosine(a_f16, b_f16) {
-            println!("The result of cos_f16 is {:.8}", result);
-            assert_almost_equal(0.0, result, 0.01); // Example value, adjust according to actual expected value
+            assert_almost_equal(0.0, result, 0.01);
         }
     }
 
     #[test]
-    fn test_cos_bf16_same() {
+    fn cos_bf16_same() {
         // Assuming these u16 values represent bf16 bit patterns, and they are identical
         let a_u16: &[u16] = &[15360, 16384, 17408]; // Corresponding to some bf16 values
         let b_u16: &[u16] = &[15360, 16384, 17408]; // Same as above for simplicity
 
         // Reinterpret cast from &[u16] to &[bf16]
-        // SAFETY: This is safe as long as the representations are guaranteed to be identical,
-        // which they are for transparent structs wrapping the same type.
         let a_bf16: &[bf16] =
             unsafe { std::slice::from_raw_parts(a_u16.as_ptr() as *const bf16, a_u16.len()) };
         let b_bf16: &[bf16] =
             unsafe { std::slice::from_raw_parts(b_u16.as_ptr() as *const bf16, b_u16.len()) };
 
         if let Some(result) = SpatialSimilarity::cosine(a_bf16, b_bf16) {
-            println!("The result of cos_bf16 is {:.8}", result);
-            assert_almost_equal(0.0, result, 0.01); // Example value, adjust according to actual expected value
+            assert_almost_equal(0.0, result, 0.01);
         }
     }
 
     #[test]
-    fn test_cos_f16_interop() {
+    fn cos_f16_interop() {
         let a_half: Vec<HalfF16> = vec![1.0, 2.0, 3.0]
             .iter()
             .map(|&x| HalfF16::from_f32(x))
@@ -1523,15 +1515,12 @@ mod tests {
 
         // Use the reinterpret-casted slices with your SpatialSimilarity implementation
         if let Some(result) = SpatialSimilarity::cosine(a_simsimd, b_simsimd) {
-            // Expected value might need adjustment depending on actual cosine functionality
-            // Assuming identical vectors yield cosine similarity of 1.0
-            println!("The result of cos_f16 (interop) is {:.8}", result);
             assert_almost_equal(0.025, result, 0.01);
         }
     }
 
     #[test]
-    fn test_cos_bf16_interop() {
+    fn cos_bf16_interop() {
         let a_half: Vec<HalfBF16> = vec![1.0, 2.0, 3.0]
             .iter()
             .map(|&x| HalfBF16::from_f32(x))
@@ -1550,44 +1539,38 @@ mod tests {
 
         // Use the reinterpret-casted slices with your SpatialSimilarity implementation
         if let Some(result) = SpatialSimilarity::cosine(a_simsimd, b_simsimd) {
-            // Expected value might need adjustment depending on actual cosine functionality
-            // Assuming identical vectors yield cosine similarity of 1.0
-            println!("The result of cos_bf16 (interop) is {:.8}", result);
             assert_almost_equal(0.025, result, 0.01);
         }
     }
 
     #[test]
-    fn test_intersect_u16() {
+    fn intersect_u16() {
         {
             let a_u16: &[u16] = &[153, 16384, 17408];
-            let b_u16: &[u16] = &[15360, 16384, 7408];
+            let b_u16: &[u16] = &[7408, 15360, 16384];
 
             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];
+            let a_u16: &[u16] = &[8, 153, 11638];
+            let b_u16: &[u16] = &[7408, 15360, 16384];
 
             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() {
+    fn 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);
             }
         }
@@ -1597,34 +1580,194 @@ mod tests {
             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);
             }
         }
     }
 
+    /// Reference implementation of set intersection using Rust's standard library
+    fn reference_intersect<T: Ord>(a: &[T], b: &[T]) -> usize {
+        let mut a_iter = a.iter();
+        let mut b_iter = b.iter();
+        let mut a_current = a_iter.next();
+        let mut b_current = b_iter.next();
+        let mut count = 0;
+
+        while let (Some(a_val), Some(b_val)) = (a_current, b_current) {
+            match a_val.cmp(b_val) {
+                core::cmp::Ordering::Less => a_current = a_iter.next(),
+                core::cmp::Ordering::Greater => b_current = b_iter.next(),
+                core::cmp::Ordering::Equal => {
+                    count += 1;
+                    a_current = a_iter.next();
+                    b_current = b_iter.next();
+                }
+            }
+        }
+        count
+    }
+
+    /// Generate test arrays with various sizes and patterns for intersection testing
+    /// Includes empty, small, medium, large arrays with different overlap characteristics
+    fn generate_intersection_test_arrays<T>() -> Vec<Vec<T>>
+    where
+        T: core::convert::TryFrom<u32> + Copy,
+        <T as core::convert::TryFrom<u32>>::Error: core::fmt::Debug,
+    {
+        vec![
+            // Empty array
+            vec![],
+            // Single element
+            vec![T::try_from(42).unwrap()],
+            // Very small arrays (< 16 elements) - tests serial fallback
+            vec![
+                T::try_from(1).unwrap(),
+                T::try_from(5).unwrap(),
+                T::try_from(10).unwrap(),
+            ],
+            vec![
+                T::try_from(2).unwrap(),
+                T::try_from(4).unwrap(),
+                T::try_from(6).unwrap(),
+                T::try_from(8).unwrap(),
+                T::try_from(10).unwrap(),
+                T::try_from(12).unwrap(),
+                T::try_from(14).unwrap(),
+            ],
+            // Small arrays (< 32 elements) - boundary case for Turin
+            (0..14).map(|x| T::try_from(x * 10).unwrap()).collect(),
+            (5..20).map(|x| T::try_from(x * 10).unwrap()).collect(),
+            // Medium arrays (32-64 elements) - tests one or two SIMD iterations
+            (0..40).map(|x| T::try_from(x * 2).unwrap()).collect(),
+            (10..50).map(|x| T::try_from(x * 2).unwrap()).collect(), // 50% overlap with previous
+            (0..45).map(|x| T::try_from(x * 3).unwrap()).collect(),  // Different stride
+            // Large arrays (> 64 elements) - tests main SIMD loop
+            (0..100).map(|x| T::try_from(x * 2).unwrap()).collect(),
+            (50..150).map(|x| T::try_from(x * 2).unwrap()).collect(), // 50% overlap
+            (0..100).map(|x| T::try_from(x * 5).unwrap()).collect(),  // Sparse overlap
+            (0..150)
+                .filter(|x| x % 7 == 0)
+                .map(|x| T::try_from(x).unwrap())
+                .collect(),
+            // Very large arrays (> 256 elements) - stress test
+            (0..500).map(|x| T::try_from(x * 3).unwrap()).collect(),
+            (100..600).map(|x| T::try_from(x * 3).unwrap()).collect(), // Large overlap
+            (0..600).map(|x| T::try_from(x * 7).unwrap()).collect(),   // Minimal overlap
+            // Edge cases: no overlap at all
+            (0..50).map(|x| T::try_from(x * 2).unwrap()).collect(),
+            (1000..1050).map(|x| T::try_from(x * 2).unwrap()).collect(), // Completely disjoint
+            // Dense arrays at boundaries
+            (0..16).map(|x| T::try_from(x).unwrap()).collect(), // Exactly 16 elements
+            (0..32).map(|x| T::try_from(x).unwrap()).collect(), // Exactly 32 elements
+            (0..64).map(|x| T::try_from(x).unwrap()).collect(), // Exactly 64 elements
+        ]
+    }
+
     #[test]
-    fn test_f16_arithmetic() {
+    fn intersect_u32_comprehensive() {
+        let test_arrays: Vec<Vec<u32>> = generate_intersection_test_arrays();
+
+        for (i, array_a) in test_arrays.iter().enumerate() {
+            for (j, array_b) in test_arrays.iter().enumerate() {
+                let expected = reference_intersect(array_a, array_b);
+                let result =
+                    Sparse::intersect(array_a.as_slice(), array_b.as_slice()).unwrap() as usize;
+
+                assert_eq!(
+                    expected,
+                    result,
+                    "Intersection mismatch for arrays[{}] (len={}) and arrays[{}] (len={})",
+                    i,
+                    array_a.len(),
+                    j,
+                    array_b.len()
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn intersect_u16_comprehensive() {
+        let test_arrays: Vec<Vec<u16>> = generate_intersection_test_arrays();
+
+        for (i, array_a) in test_arrays.iter().enumerate() {
+            for (j, array_b) in test_arrays.iter().enumerate() {
+                let expected = reference_intersect(array_a, array_b);
+                let result =
+                    Sparse::intersect(array_a.as_slice(), array_b.as_slice()).unwrap() as usize;
+
+                assert_eq!(
+                    expected,
+                    result,
+                    "Intersection mismatch for arrays[{}] (len={}) and arrays[{}] (len={})",
+                    i,
+                    array_a.len(),
+                    j,
+                    array_b.len()
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn intersect_edge_cases() {
+        // Test empty arrays
+        let empty: &[u32] = &[];
+        let non_empty: &[u32] = &[1, 2, 3];
+        assert_eq!(Sparse::intersect(empty, empty), Some(0.0));
+        assert_eq!(Sparse::intersect(empty, non_empty), Some(0.0));
+        assert_eq!(Sparse::intersect(non_empty, empty), Some(0.0));
+
+        // Test single element matches
+        assert_eq!(Sparse::intersect(&[42u32], &[42u32]), Some(1.0));
+        assert_eq!(Sparse::intersect(&[42u32], &[43u32]), Some(0.0));
+
+        // Test no overlap
+        let a: &[u32] = &[1, 2, 3, 4, 5];
+        let b: &[u32] = &[10, 20, 30, 40, 50];
+        assert_eq!(Sparse::intersect(a, b), Some(0.0));
+
+        // Test complete overlap
+        let c: &[u32] = &[10, 20, 30, 40, 50];
+        assert_eq!(Sparse::intersect(c, c), Some(5.0));
+
+        // Test one element at boundary (exactly at 16, 32, 64 element boundaries)
+        let boundary_16: Vec<u32> = (0..16).collect();
+        let boundary_32: Vec<u32> = (0..32).collect();
+        let boundary_64: Vec<u32> = (0..64).collect();
+
+        assert_eq!(Sparse::intersect(&boundary_16, &boundary_16), Some(16.0));
+        assert_eq!(Sparse::intersect(&boundary_32, &boundary_32), Some(32.0));
+        assert_eq!(Sparse::intersect(&boundary_64, &boundary_64), Some(64.0));
+
+        // Test partial overlap at boundaries
+        let first_half: Vec<u32> = (0..32).collect();
+        let second_half: Vec<u32> = (16..48).collect();
+        assert_eq!(Sparse::intersect(&first_half, &second_half), Some(16.0));
+    }
+
+    #[test]
+    fn f16_arithmetic() {
         let a = f16::from_f32(3.5);
         let b = f16::from_f32(2.0);
-        
+
         // Test basic arithmetic
         assert!((a + b).to_f32() - 5.5 < 0.01);
         assert!((a - b).to_f32() - 1.5 < 0.01);
         assert!((a * b).to_f32() - 7.0 < 0.01);
         assert!((a / b).to_f32() - 1.75 < 0.01);
         assert!((-a).to_f32() + 3.5 < 0.01);
-        
+
         // Test constants
         assert!(f16::ZERO.to_f32() == 0.0);
         assert!((f16::ONE.to_f32() - 1.0).abs() < 0.01);
         assert!((f16::NEG_ONE.to_f32() + 1.0).abs() < 0.01);
-        
+
         // Test comparisons
         assert!(a > b);
         assert!(!(a < b));
         assert!(a == a);
-        
+
         // Test utility methods
         assert!((-a).abs().to_f32() - 3.5 < 0.01);
         assert!(a.is_finite());
@@ -1633,31 +1776,46 @@ mod tests {
     }
 
     #[test]
-    fn test_bf16_arithmetic() {
+    fn bf16_arithmetic() {
         let a = bf16::from_f32(3.5);
         let b = bf16::from_f32(2.0);
-        
+
         // Test basic arithmetic
         assert!((a + b).to_f32() - 5.5 < 0.1);
         assert!((a - b).to_f32() - 1.5 < 0.1);
         assert!((a * b).to_f32() - 7.0 < 0.1);
         assert!((a / b).to_f32() - 1.75 < 0.1);
         assert!((-a).to_f32() + 3.5 < 0.1);
-        
+
         // Test constants
         assert!(bf16::ZERO.to_f32() == 0.0);
         assert!((bf16::ONE.to_f32() - 1.0).abs() < 0.01);
         assert!((bf16::NEG_ONE.to_f32() + 1.0).abs() < 0.01);
-        
+
         // Test comparisons
         assert!(a > b);
         assert!(!(a < b));
         assert!(a == a);
-        
+
         // Test utility methods
         assert!((-a).abs().to_f32() - 3.5 < 0.1);
         assert!(a.is_finite());
         assert!(!a.is_nan());
         assert!(!a.is_infinite());
     }
+
+    #[test]
+    fn bf16_dot() {
+        let brain_a: Vec<bf16> = vec![1.0, 2.0, 3.0, 1.0, 2.0]
+            .iter()
+            .map(|&x| bf16::from_f32(x))
+            .collect();
+        let brain_b: Vec<bf16> = vec![4.0, 5.0, 6.0, 4.0, 5.0]
+            .iter()
+            .map(|&x| bf16::from_f32(x))
+            .collect();
+        if let Some(result) = <bf16 as SpatialSimilarity>::dot(&brain_a, &brain_b) {
+            assert_eq!(46.0, result);
+        }
+    }
 }