usearch 2.17.0 → 2.19.4

package/simsimd/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simsimd",
-  "version": "6.2.3",
+  "version": "6.4.10",
   "description": "Portable mixed-precision BLAS-like vector math library for x86 and ARM",
   "homepage": "https://github.com/ashvardanian/simsimd",
   "author": "Ash Vardanian",
@@ -43,19 +43,19 @@
   },
   "dependencies": {
     "bindings": "^1.5.0",
-    "node-addon-api": "^3.2.1",
-    "node-gyp-build": "^4.8.0"
+    "node-addon-api": "^8.4.0",
+    "node-gyp-build": "^4.8.4"
   },
   "devDependencies": {
     "@types/bindings": "^1.5.5",
-    "@types/node": "^20.17.6",
-    "node-gyp": "^10.0.1",
-    "prebuildify": "^6.0.0",
-    "typescript": "^5.3.3"
+    "@types/node": "^24.0.10",
+    "node-gyp": "^11.2.0",
+    "prebuildify": "^6.0.1",
+    "typescript": "^5.8.3"
   },
   "optionalDependencies": {
     "benchmark": "^2.1.4",
-    "mathjs": "^11.11.2",
-    "usearch": "^2.8.15"
+    "mathjs": "^14.5.3",
+    "usearch": "^2.17.1"
   }
 }

package/simsimd/rust/lib.rs

@@ -2,7 +2,7 @@
 //!
 //! * Targets ARM NEON, SVE, x86 AVX2, AVX-512 (VNNI, FP16) hardware backends.
 //! * Handles `f64` double-, `f32` single-, and `f16` half-precision, `i8` integral, and binary vectors.
-//! * Zero-dependency header-only C 99 library with bindings for Rust and other langauges.
+//! * Zero-dependency header-only C 99 library with bindings for Rust and other languages.
 //!
 //! ## Implemented distance functions include:
 //!
@@ -26,6 +26,9 @@
 //!
 //! // Compute squared Euclidean distance
 //! let l2sq_dist = i8::l2sq(a, b);
+//! 
+//! // Optimize performance by flushing denormals
+//! simsimd::capabilities::flush_denormals();
 //! ```
 //!
 //! ## Traits
@@ -53,6 +56,7 @@ type ComplexProduct = (f64, f64);
 
 extern "C" {
 
+    fn simsimd_dot_i8(a: *const i8, b: *const i8, c: usize, d: *mut Distance);
     fn simsimd_dot_f16(a: *const u16, b: *const u16, c: usize, d: *mut Distance);
     fn simsimd_dot_bf16(a: *const u16, b: *const u16, c: usize, d: *mut Distance);
     fn simsimd_dot_f32(a: *const f32, b: *const f32, c: usize, d: *mut Distance);
@@ -99,8 +103,20 @@ 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_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;
@@ -117,6 +133,9 @@ extern "C" {
     fn simsimd_uses_sapphire() -> i32;
     fn simsimd_uses_turin() -> i32;
     fn simsimd_uses_sierra() -> i32;
+
+    fn simsimd_flush_denormals() -> i32;
+    fn simsimd_uses_dynamic_dispatch() -> i32;
 }
 
 /// A half-precision floating point number.
@@ -194,6 +213,29 @@ pub mod capabilities {
     pub fn uses_sierra() -> bool {
         unsafe { crate::simsimd_uses_sierra() != 0 }
     }
+
+    /// Flushes denormalized numbers to zero on the current CPU architecture.
+    /// 
+    /// This function should be called on each thread before any SIMD operations
+    /// to avoid performance penalties. When facing denormalized values, 
+    /// Fused-Multiply-Add (FMA) operations can be up to 30x slower.
+    /// 
+    /// # Returns
+    /// 
+    /// Returns `true` if the operation was successful, `false` otherwise.
+    pub fn flush_denormals() -> bool {
+        unsafe { crate::simsimd_flush_denormals() != 0 }
+    }
+
+    /// Checks if the library is using dynamic dispatch for function selection.
+    /// 
+    /// # Returns
+    /// 
+    /// Returns `true` if dynamic dispatch is enabled, `false` otherwise.
+    /// Currently always returns `false` as dynamic dispatch is not implemented.
+    pub fn uses_dynamic_dispatch() -> bool {
+        unsafe { crate::simsimd_uses_dynamic_dispatch() != 0 }
+    }
 }
 
 /// `SpatialSimilarity` provides a set of trait methods for computing similarity
@@ -225,8 +267,8 @@ where
     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 
+    /// 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>;
 
@@ -238,8 +280,8 @@ where
     }
 
     /// Computes the Euclidean distance between two slices.
-    /// The Euclidean distance is the square root of the 
-    /// sum of the squared differences between corresponding 
+    /// 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)
@@ -367,7 +409,7 @@ impl SpatialSimilarity for i8 {
         }
         let mut distance_value: Distance = 0.0;
         let distance_ptr: *mut Distance = &mut distance_value as *mut Distance;
-        unsafe { simsimd_cos_i8(a.as_ptr(), b.as_ptr(), a.len(), distance_ptr) };
+        unsafe { simsimd_dot_i8(a.as_ptr(), b.as_ptr(), a.len(), distance_ptr) };
         Some(distance_value)
     }
 
@@ -393,25 +435,21 @@ impl SpatialSimilarity for i8 {
 }
 
 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 {
@@ -458,7 +496,6 @@ impl SpatialSimilarity for f16 {
     }
 
     fn l2(a: &[Self], b: &[Self]) -> Option<Distance> {
-        
         if a.len() != b.len() {
             return None;
         }
@@ -524,7 +561,7 @@ impl SpatialSimilarity for bf16 {
         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) };
+        unsafe { simsimd_l2_bf16(a_ptr, b_ptr, a.len(), distance_ptr) };
         Some(distance_value)
     }
 }
@@ -891,7 +928,7 @@ mod tests {
 
         if let Some(result) = SpatialSimilarity::dot(a, b) {
             println!("The result of dot_i8 is {:.8}", result);
-            assert_almost_equal(0.029403687, result, 0.01);
+            assert_almost_equal(32.0, result, 0.01);
         }
     }
 
@@ -993,7 +1030,6 @@ mod tests {
             .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] =
@@ -1003,7 +1039,6 @@ mod tests {
             println!("The result of l2_f16 is {:.8}", result);
             assert_almost_equal(5.2, result, 0.01);
         }
-        
     }
 
     #[test]
@@ -1160,8 +1195,8 @@ mod tests {
     #[test]
     fn test_intersect_u16() {
         {
-            let a_u16: &[u16] = &[153, 16384, 17408]; 
-            let b_u16: &[u16] = &[15360, 16384, 7408]; 
+            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);
@@ -1170,37 +1205,36 @@ mod tests {
         }
 
         {
-            let a_u16: &[u16] = &[153, 11638, 08]; 
-            let b_u16: &[u16] = &[15360, 16384, 7408]; 
+            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]; 
+            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]; 
+            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);
-            }   
+            }
         }
-        
     }
 }

package/simsimd/scripts/bench.cxx

@@ -1,3 +1,16 @@
+/**
+ *  SimSIMD C++ Benchmark Suite
+ *
+ *  Comprehensive benchmarks comparing SimSIMD SIMD-optimized functions against
+ *  baseline implementations using Google Benchmark framework. Run with:
+ *
+ *  ```bash
+ *  cmake -B build_release -D SIMSIMD_BUILD_BENCHMARKS=1
+ *  cmake --build build_release
+ *  build_release/simsimd_bench
+ *  ```
+ */
+
 #include <array>         // `std::array`
 #include <cmath>         // `std::sqrt`
 #include <cstdlib>       // `std::aligned_alloc`

package/simsimd/scripts/bench_cosine.rs

@@ -1,3 +1,11 @@
+//! Cosine Similarity Benchmark
+//!
+//! Compares SimSIMD vs native Rust implementations using Criterion.
+//! Run with:
+//!
+//! ```bash
+//! cargo bench --bench bench_cosine
+//! ```
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
 use simsimd::SpatialSimilarity as SimSIMD;
 

package/simsimd/scripts/bench_native.rs

@@ -1,3 +1,7 @@
+//! Native Rust Baseline Implementations
+//!
+//! Provides baseline implementations of distance functions for benchmarking
+//! against SimSIMD's SIMD-optimized versions.
 #![allow(unused)]
 use rand::Rng;
 

package/simsimd/scripts/bench_sqeuclidean.rs

@@ -1,3 +1,11 @@
+//! Squared Euclidean Distance Benchmark
+//!
+//! Compares SimSIMD vs native Rust implementations using Criterion.
+//! Run with:
+//!
+//! ```bash
+//! cargo bench --bench bench_sqeuclidean
+//! ```
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
 use simsimd::SpatialSimilarity as SimSIMD;
 

package/simsimd/scripts/test.c

@@ -156,10 +156,32 @@ void test_distance_from_itself(void) {
     simsimd_kl_f64(f64s, f64s, 1536, &distance[0]);
 }
 
+/**
+ *  @brief Test whether denormals are being flushed to zero or not.
+ *
+ *  We create subnormal float values, do a small computation (multiplication),
+ *  and classify the result. If flush-to-zero @b (FTZ) is enabled, the result is
+ *  likely zero. Otherwise, you may see another subnormal or normal number.
+ */
+static void test_denormals(void) {
+
+    // Create two subnormal floats:
+    // 1e-40 ~ 1.0 * 10^-40 is typically a subnormal in IEEE-754 single precision
+    float subnorm1 = 1e-40f;
+    float subnorm2 = 2e-40f;
+    float result = subnorm1 * subnorm2; // This might be subnormal, zero, or normal
+    int classification = fpclassify(result);
+    if (classification == FP_SUBNORMAL) { printf("Denormal test: result is subnormal: %.8g\n", result); }
+    else if (result == 0.0f) { printf("Denormal test: result is zero (denormals likely flushed).\n"); }
+    else if (classification == FP_NORMAL) { printf("Denormal test: result is normal: %.8g\n", result); }
+    else { printf("Denormal test: result has unexpected classification.\n"); }
+}
+
 int main(int argc, char **argv) {
 
     print_capabilities();
     test_utilities();
     test_distance_from_itself();
+    test_denormals();
     return 0;
 }

package/simsimd/scripts/test.py

@@ -4,8 +4,8 @@
 Module: test.py
 
 This module contains a suite of tests for the `simsimd` package.
-It compares various SIMD kernels (like Dot-products, squared Euclidean, and Cosine distances) 
-with their NumPy or baseline counterparts, testing accuracy for different data types including 
+It compares various SIMD kernels (like Dot-products, squared Euclidean, and Cosine distances)
+with their NumPy or baseline counterparts, testing accuracy for different data types including
 floating-point, integer, and complex numbers.
 
 The tests cover:
@@ -1245,7 +1245,7 @@ def test_batch(ndim, dtype, capability):
     result_simd = np.array(simd.sqeuclidean(A, B)).astype(np.float64)
     assert np.allclose(result_simd, result_np, atol=SIMSIMD_ATOL, rtol=SIMSIMD_RTOL)
 
-    # Distance between matrixes A (N x D scalars) and B (N x D scalars) with a differnt output type.
+    # Distance between matrixes A (N x D scalars) and B (N x D scalars) with a different output type.
     A = np.random.randn(10, ndim).astype(dtype)
     B = np.random.randn(10, ndim).astype(dtype)
     result_np = np.array([spd.sqeuclidean(A[i], B[i]) for i in range(10)]).astype(np.float32)
@@ -1365,7 +1365,7 @@ def test_cdist_complex(ndim, input_dtype, out_dtype, metric, capability):
     C = C_extended[:, :N]
 
     #! Unlike the `np.dot`, the `np.vdot` flattens multi-dimensional inputs into 1D arrays.
-    #! So to compreare the results we need to manually compute all the dot-products.
+    #! So to compare the results we need to manually compute all the dot-products.
     expected = np.zeros((M, N), dtype=out_dtype if out_dtype else np.complex128)
     baseline_kernel = np.dot if metric == "dot" else np.vdot
     for i in range(M):
@@ -1418,6 +1418,82 @@ def test_cdist_hamming(ndim, out_dtype, capability):
     np.testing.assert_allclose(result, expected, atol=SIMSIMD_ATOL, rtol=SIMSIMD_RTOL)
 
 
+@pytest.mark.skipif(not numpy_available, reason="NumPy is not installed")
+def test_gil_free_threading():
+    """Test SimSIMD in Python 3.13t free-threaded mode if available."""
+    import sys
+    import sysconfig
+
+    # Check if we're in a GIL-free environment
+    # https://py-free-threading.github.io/running-gil-disabled/
+    version = sys.version_info
+    if version.major == 3 and version.minor >= 13:
+        is_free_threaded = bool(sysconfig.get_config_var("Py_GIL_DISABLED"))
+        if not is_free_threaded:
+            pytest.skip("Uses non-free-threaded Python, skipping GIL-related tests")
+        if sys._is_gil_enabled():
+            pytest.skip("GIL is enabled, skipping GIL-related tests")
+    else:
+        pytest.skip("Python < 3.13t, skipping GIL-related tests")
+
+    import multiprocessing
+    import concurrent.futures
+
+    num_threads = multiprocessing.cpu_count()
+    vectors_a = np.random.rand(32 * 1024 * num_threads, 1024).astype(np.float32)
+    vectors_b = np.random.rand(32 * 1024 * num_threads, 1024).astype(np.float32)
+    distances = np.zeros(vectors_a.shape[0], dtype=np.float32)
+
+    def compute_batch(start_idx, end_idx) -> float:
+        """Compute cosine distances for a batch."""
+        slice_a = vectors_a[start_idx:end_idx]
+        slice_b = vectors_b[start_idx:end_idx]
+        slice_distances = distances[start_idx:end_idx]
+        simd.cosine(slice_a, slice_b, out=slice_distances)
+        return sum(slice_distances)
+
+    def compute_with_threads(threads: int) -> float:
+        """Compute cosine distances using multiple threads."""
+        chunk_size = len(vectors_a) // threads
+        futures = []
+        with concurrent.futures.ThreadPoolExecutor(max_workers=threads) as executor:
+            for i in range(threads):
+                start_idx = i * chunk_size
+                end_idx = (i + 1) * chunk_size if i < threads - 1 else len(vectors_a)
+                futures.append(executor.submit(compute_batch, start_idx, end_idx))
+
+        total_sum = 0.0
+        for future in concurrent.futures.as_completed(futures):
+            total_sum += future.result()
+
+        return total_sum
+
+    # Dual-threaded baseline is better than single-threaded,
+    # as it will include the overhead of thread management.
+    start_time = time.time()
+    baseline_sum = compute_with_threads(2)
+    end_time = time.time()
+    baseline_duration = end_time - start_time
+
+    # Multi-threaded execution, using all available threads
+    start_time = time.time()
+    multi_sum = compute_with_threads(num_threads)
+    end_time = time.time()
+    multi_duration = end_time - start_time
+
+    # Verify results are the same length and reasonable
+    assert np.allclose(
+        baseline_sum, multi_sum, atol=SIMSIMD_ATOL, rtol=SIMSIMD_RTOL
+    ), f"Results differ: baseline {baseline_sum} vs multi-threaded {multi_sum}"
+
+    # Warn if multi-threaded execution is slower than the baseline
+    if baseline_duration < multi_duration:
+        pytest.warns(
+            UserWarning,
+            f"{num_threads}-threaded execution took longer than 2-threaded baseline: {multi_duration:.2f}s vs {baseline_duration:.2f}s",
+        )
+
+
 if __name__ == "__main__":
     pytest.main(
         [

package/simsimd/swift/SimSIMD.swift

@@ -4,6 +4,7 @@ public protocol SimSIMD {
     static var dataType: simsimd_datatype_t { get }
     static var cosine: simsimd_metric_dense_punned_t { get }
     static var dotProduct: simsimd_metric_dense_punned_t { get }
+    static var euclidean: simsimd_metric_dense_punned_t { get }
     static var squaredEuclidean: simsimd_metric_dense_punned_t { get }
 }
 
@@ -11,21 +12,26 @@ extension Int8: SimSIMD {
     public static let dataType = simsimd_datatype_i8_k
     public static let cosine = find(kind: simsimd_metric_cosine_k, dataType: dataType)
     public static let dotProduct = find(kind: simsimd_metric_dot_k, dataType: dataType)
+    public static let euclidean = find(kind: simsimd_metric_euclidean_k, dataType: dataType)
     public static let squaredEuclidean = find(kind: simsimd_metric_sqeuclidean_k, dataType: dataType)
 }
 
+#if !arch(x86_64)
 @available(macOS 11.0, iOS 14.0, tvOS 14.0, watchOS 7.0, *)
 extension Float16: SimSIMD {
     public static let dataType = simsimd_datatype_f16_k
     public static let cosine = find(kind: simsimd_metric_cosine_k, dataType: dataType)
     public static let dotProduct = find(kind: simsimd_metric_dot_k, dataType: dataType)
+    public static let euclidean = find(kind: simsimd_metric_euclidean_k, dataType: dataType)
     public static let squaredEuclidean = find(kind: simsimd_metric_sqeuclidean_k, dataType: dataType)
 }
+#endif
 
 extension Float32: SimSIMD {
     public static let dataType = simsimd_datatype_f32_k
     public static let cosine = find(kind: simsimd_metric_cosine_k, dataType: dataType)
     public static let dotProduct = find(kind: simsimd_metric_inner_k, dataType: dataType)
+    public static let euclidean = find(kind: simsimd_metric_euclidean_k, dataType: dataType)
     public static let squaredEuclidean = find(kind: simsimd_metric_sqeuclidean_k, dataType: dataType)
 }
 
@@ -33,6 +39,7 @@ extension Float64: SimSIMD {
     public static let dataType = simsimd_datatype_f64_k
     public static let cosine = find(kind: simsimd_metric_cosine_k, dataType: dataType)
     public static let dotProduct = find(kind: simsimd_metric_dot_k, dataType: dataType)
+    public static let euclidean = find(kind: simsimd_metric_euclidean_k, dataType: dataType)
     public static let squaredEuclidean = find(kind: simsimd_metric_sqeuclidean_k, dataType: dataType)
 }
 
@@ -47,6 +54,11 @@ extension SimSIMD {
         perform(dotProduct, a: a, b: b)
     }
 
+    @inlinable @inline(__always)
+    public static func euclidean<A, B>(_ a: A, _ b: B) -> Double? where A: Sequence, B: Sequence, A.Element == Self, B.Element == Self {
+        perform(euclidean, a: a, b: b)
+    }
+
     @inlinable @inline(__always)
     public static func sqeuclidean<A, B>(_ a: A, _ b: B) -> Double? where A: Sequence, B: Sequence, A.Element == Self, B.Element == Self {
         perform(squaredEuclidean, a: a, b: b)
@@ -64,6 +76,11 @@ extension RandomAccessCollection where Element: SimSIMD {
         Element.dot(self, b)
     }
 
+    @inlinable @inline(__always)
+    public func euclidean<B>(_ b: B) -> Double? where B: Sequence, B.Element == Element {
+        Element.euclidean(self, b)
+    }
+
     @inlinable @inline(__always)
     public func sqeuclidean<B>(_ b: B) -> Double? where B: Sequence, B.Element == Element {
         Element.sqeuclidean(self, b)

package/simsimd/swift/Test.swift

@@ -13,12 +13,14 @@ class SimSIMDTests: XCTestCase {
         XCTAssertEqual(result, 0.00012027938, accuracy: 0.01)
     }
 
+    #if !arch(x86_64)
     func testCosineFloat16() throws {
         let a: [Float16] = [1.0, 2.0, 3.0]
         let b: [Float16] = [1.0, 2.0, 3.0]
         let result = try XCTUnwrap(a.cosine(b))
         XCTAssertEqual(result, 0.004930496, accuracy: 0.01)
     }
+    #endif
 
     func testCosineFloat32() throws {
         let a: [Float32] = [1.0, 2.0, 3.0]
@@ -41,12 +43,14 @@ class SimSIMDTests: XCTestCase {
         XCTAssertEqual(result, 32.0, accuracy: 0.01)
     }
 
+    #if !arch(x86_64)
     func testDotFloat16() throws {
         let a: [Float16] = [1.0, 2.0, 3.0]
         let b: [Float16] = [4.0, 5.0, 6.0]
         let result = try XCTUnwrap(a.dot(b))
         XCTAssertEqual(result, 32.0, accuracy: 0.01)
     }
+    #endif
 
     func testDotFloat32() throws {
         let a: [Float32] = [1.0, 2.0, 3.0]
@@ -62,6 +66,36 @@ class SimSIMDTests: XCTestCase {
         XCTAssertEqual(result, 32.0, accuracy: 0.01)
     }
 
+    func testEuclideanInt8() throws {
+        let a: [Int8] = [1, 2, 3]
+        let b: [Int8] = [4, 5, 6]
+        let result = try XCTUnwrap(a.euclidean(b))
+        XCTAssertEqual(result, 5.196152422706632, accuracy: 0.01)
+    }
+
+    #if !arch(x86_64)
+    func testEuclideanFloat16() throws {
+        let a: [Float16] = [1.0, 2.0, 3.0]
+        let b: [Float16] = [4.0, 5.0, 6.0]
+        let result = try XCTUnwrap(a.euclidean(b))
+        XCTAssertEqual(result, 5.196152422706632, accuracy: 0.01)
+    }
+    #endif
+
+    func testEuclideanFloat32() throws {
+        let a: [Float32] = [1.0, 2.0, 3.0]
+        let b: [Float32] = [4.0, 5.0, 6.0]
+        let result = try XCTUnwrap(a.euclidean(b))
+        XCTAssertEqual(result, 5.196152422706632, accuracy: 0.01)
+    }
+
+    func testEuclideanFloat64() throws {
+        let a: [Float64] = [1.0, 2.0, 3.0]
+        let b: [Float64] = [4.0, 5.0, 6.0]
+        let result = try XCTUnwrap(a.euclidean(b))
+        XCTAssertEqual(result, 5.196152422706632, accuracy: 0.01)
+    }
+
     func testSqeuclideanInt8() throws {
         let a: [Int8] = [1, 2, 3]
         let b: [Int8] = [4, 5, 6]
@@ -69,12 +103,14 @@ class SimSIMDTests: XCTestCase {
         XCTAssertEqual(result, 27.0, accuracy: 0.01)
     }
 
+    #if !arch(x86_64)
     func testSqeuclideanFloat16() throws {
         let a: [Float16] = [1.0, 2.0, 3.0]
         let b: [Float16] = [4.0, 5.0, 6.0]
         let result = try XCTUnwrap(a.sqeuclidean(b))
         XCTAssertEqual(result, 27.0, accuracy: 0.01)
     }
+    #endif
 
     func testSqeuclideanFloat32() throws {
         let a: [Float32] = [1.0, 2.0, 3.0]