usearch 2.9.1 → 2.9.2

package/simsimd/README.md

@@ -1,20 +1,41 @@
 # SimSIMD 📏
 
 <div>
-<a href="https://pepy.tech/project/simsimd"> <img alt="PyPI" src="https://static.pepy.tech/personalized-badge/simsimd?period=total&units=abbreviation&left_color=black&right_color=blue&left_text=SimSIMD%20Python%20installs"> </a>
-<a href="https://www.npmjs.com/package/simsimd"> <img alt="npm" src="https://img.shields.io/npm/dy/simsimd?label=npm%20dowloads"> </a>
-<a href="https://crates.io/crates/simsimd"> <img alt="rust" src="https://img.shields.io/crates/d/simsimd?logo=rust" /> </a>
+<a href="https://pepy.tech/project/simsimd">
+    <img alt="PyPI" src="https://static.pepy.tech/personalized-badge/simsimd?period=total&units=abbreviation&left_color=black&right_color=blue&left_text=SimSIMD%20Python%20installs">
+</a>
+<a href="https://www.npmjs.com/package/simsimd">
+    <img alt="npm" src="https://img.shields.io/npm/dy/simsimd?label=npm%20dowloads">
+</a>
+<a href="https://crates.io/crates/simsimd">
+    <img alt="rust" src="https://img.shields.io/crates/d/simsimd?logo=rust" />
+</a>
 <img alt="GitHub code size in bytes" src="https://img.shields.io/github/languages/code-size/ashvardanian/simsimd">
+<a href="https://github.com/ashvardanian/SimSIMD/actions/workflows/release.yml">
+    <img alt="GitHub Actions Ubuntu" src="https://img.shields.io/github/actions/workflow/status/ashvardanian/SimSIMD/release.yml?branch=main&label=Ubuntu&logo=github&color=blue">
+</a>
+<a href="https://github.com/ashvardanian/SimSIMD/actions/workflows/release.yml">
+    <img alt="GitHub Actions Windows" src="https://img.shields.io/github/actions/workflow/status/ashvardanian/SimSIMD/release.yml?branch=main&label=Windows&logo=windows&color=blue">
+</a>
+<a href="https://github.com/ashvardanian/SimSIMD/actions/workflows/release.yml">
+    <img alt="GitHub Actions MacOS" src="https://img.shields.io/github/actions/workflow/status/ashvardanian/SimSIMD/release.yml?branch=main&label=MacOS&logo=apple&color=blue">
+</a>
+<a href="https://github.com/ashvardanian/SimSIMD/actions/workflows/release.yml">
+    <img alt="GitHub Actions CentOS Linux" src="https://img.shields.io/github/actions/workflow/status/ashvardanian/SimSIMD/release.yml?branch=main&label=CentOS&logo=centos&color=blue">
+</a>
+
 </div>
 
+
 ## Hardware-Accelerated Similarity Metrics and Distance Functions
 
 - Zero-dependency [header-only C 99](#using-simsimd-in-c) library.
-- Bindings for [Python](#using-simsimd-in-python), [Rust](#using-simsimd-in-rust) and [JavaScript](#using-simsimd-in-javascript).
-- Targets ARM NEON, SVE, x86 AVX2, AVX-512 (VNNI, FP16) hardware backends.
-- Zero-copy compatible with NumPy, PyTorch, TensorFlow, and other tensors.
 - Handles `f64` double-, `f32` single-, and `f16` half-precision, `i8` integral, and binary vectors.
+- Targets ARM NEON, SVE, x86 AVX2, AVX-512 (VNNI, FP16) hardware backends.
+- Bindings for [Python](#using-simsimd-in-python), [Rust](#using-simsimd-in-rust) and [JavaScript](#using-simsimd-in-javascript).
 - __Up to 200x faster__ than [`scipy.spatial.distance`][scipy] and [`numpy.inner`][numpy].
+- [Supports more Python versions][compatibility] than SciPy and NumPy.
+- Zero-copy compatible with NumPy, PyTorch, TensorFlow, and other tensors.
 - Used in [USearch](https://github.com/unum-cloud/usearch) and several DBMS products.
 
 __Implemented distance functions__ include:
@@ -25,6 +46,7 @@ __Implemented distance functions__ include:
 
 [scipy]: https://docs.scipy.org/doc/scipy/reference/spatial.distance.html#module-scipy.spatial.distance
 [numpy]: https://numpy.org/doc/stable/reference/generated/numpy.inner.html
+[compatibility]: https://pypi.org/project/simsimd/#files
 
 __Technical Insights__ and related articles:
 
@@ -67,6 +89,11 @@ __Broader Benchmarking Results__:
 
 ## Using SimSIMD in Python
 
+The package is intended to replace the usage of `numpy.inner`, `numpy.dot`, and `scipy.spatial.distance`.
+Aside from drastic performance improvements, SimSIMD significantly improves accuracy in mixed precision setups.
+NumPy and SciPy, processing `i8` or `f16` vectors, will use the same types for accumulators, while SimSIMD can combine `i8` enumeration, `i16` multiplication, and `i32` accumulation to entirely avoid overflows.
+The same applies to processing `f16` values with `f32` precision.
+
 ### Installation
 
 ```sh
@@ -85,6 +112,14 @@ dist = simsimd.cosine(vec1, vec2)
 ```
 
 Supported functions include `cosine`, `inner`, `sqeuclidean`, `hamming`, and `jaccard`.
+Unlike SciPy, SimSIMD allows explicitly stating the precision of the input vectors, which is especially useful for mixed-precision setups.
+
+```py
+dist = simsimd.cosine(vec1, vec2, "i8")
+dist = simsimd.cosine(vec1, vec2, "f16")
+dist = simsimd.cosine(vec1, vec2, "f32")
+dist = simsimd.cosine(vec1, vec2, "f64")
+```
 
 ### Distance Between 2 Batches
 
@@ -150,20 +185,73 @@ To install, add the following to your `Cargo.toml`:
 simsimd = "..."
 ```
 
-To use it:
+Before using the SimSIMD library, ensure you have imported the necessary traits and types into your Rust source file.
+The library provides several traits for different distance/similarity kinds - `SpatialSimilarity`, `BinarySimilarity`, and `ProbabilitySimilarity`.
 
 ```rust
-use simsimd::{cosine, sqeuclidean};
+use simsimd::SpatialSimilarity;
 
 fn main() {
-    let vector_a = vec![1.0, 2.0, 3.0];
-    let vector_b = vec![4.0, 5.0, 6.0];
+    let vector_a: Vec<f32> = vec![1.0, 2.0, 3.0];
+    let vector_b: Vec<f32> = vec![4.0, 5.0, 6.0];
 
-    let distance = cosine(&vector_a, &vector_b);
-    println!("Cosine Distance: {}", distance);
+    // Compute the cosine similarity between vector_a and vector_b
+    let cosine_similarity = f32::cosine(&vector_a, &vector_b)
+        .expect("Vectors must be of the same length");
 
-    let distance = sqeuclidean(&vector_a, &vector_b);
-    println!("Squared Euclidean Distance: {}", distance);
+    println!("Cosine Similarity: {}", cosine_similarity);
+
+    // Compute the squared Euclidean distance between vector_a and vector_b
+    let sq_euclidean_distance = f32::sqeuclidean(&vector_a, &vector_b)
+        .expect("Vectors must be of the same length");
+
+    println!("Squared Euclidean Distance: {}", sq_euclidean_distance);
+}
+```
+
+Similarly, one can compute bit-level distance functions between slices of unsigned integers:
+
+```rust
+use simsimd::BinarySimilarity;
+
+fn main() {
+    let vector_a = &[0b11110000, 0b00001111, 0b10101010];
+    let vector_b = &[0b11110000, 0b00001111, 0b01010101];
+
+    // Compute the Hamming distance between vector_a and vector_b
+    let hamming_distance = u8::hamming(&vector_a, &vector_b)
+        .expect("Vectors must be of the same length");
+
+    println!("Hamming Distance: {}", hamming_distance);
+
+    // Compute the Jaccard distance between vector_a and vector_b
+    let jaccard_distance = u8::jaccard(&vector_a, &vector_b)
+        .expect("Vectors must be of the same length");
+
+    println!("Jaccard Distance: {}", jaccard_distance);
+}
+```
+
+Rust has no native support for half-precision floating-point numbers, but SimSIMD provides a `f16` type for this purpose.
+It doesn't have any functionality and is a `transparent` wrapper around `u16`, so it can be used with `half`, or any other half-precision library.
+
+```rust
+use simsimd::SpatialSimilarity;
+use simsimd::f16 as SimF16;
+use half::f16 as HalfF16;
+
+fn main() {
+    let vector_a: Vec<HalfF16> = ...
+    let vector_b: Vec<HalfF16> = ...
+
+    let buffer_a: &[SimF16] = unsafe { std::slice::from_raw_parts(a_half.as_ptr() as *const SimF16, a_half.len()) };
+    let buffer_b: &[SimF16] = unsafe { std::slice::from_raw_parts(b_half.as_ptr() as *const SimF16, b_half.len()) };
+
+    // Compute the cosine similarity between vector_a and vector_b
+    let cosine_similarity = SimF16::cosine(&vector_a, &vector_b)
+        .expect("Vectors must be of the same length");
+
+    println!("Cosine Similarity: {}", cosine_similarity);
 }
 ```
 
@@ -227,49 +315,3 @@ All of the functions names follow the same pattern: `simsimd_{backend}_{type}_{m
 - The metric can be `cos`, `ip`, `l2sq`, `hamming`, `jaccard`, `kl`, or `js`.
 
 In case you want to avoid hard-coding the backend, you can use the `simsimd_metric_punned_t` to pun the function pointer, and `simsimd_capabilities` function to get the available backends at runtime.
-
-## Benchmarking and Contributing
-
-__To rerun experiments__ utilize the following command:
-
-```sh
-cmake -DCMAKE_BUILD_TYPE=Release -DSIMSIMD_BUILD_BENCHMARKS=1 -B ./build_release
-cmake --build build_release --config Release
-./build_release/simsimd_bench
-./build_release/simsimd_bench --benchmark_filter=js
-```
-
-__To test and benchmark with Python bindings__:
-
-```sh
-pip install -e .
-pytest python/test.py -s -x 
-
-pip install numpy scipy scikit-learn # for comparison baselines
-python python/bench.py # to run default benchmarks
-python python/bench.py --n 1000 --ndim 1000000 # batch size and dimensions
-```
-
-__To test and benchmark JavaScript bindings__:
-
-```sh
-npm install --dev
-npm test
-npm run bench
-```
-
-__To test and benchmark GoLang bindings__:
-
-```sh
-cd golang
-go test # To test
-go test -run=^$ -bench=. -benchmem # To benchmark
-```
-
-__To test and benchmark Rust bindings__:
-
-```sh
-cargo test 
-cargo bench 
-open ./target/criterion/report/index.html
-```

package/simsimd/include/simsimd/binary.h

@@ -190,6 +190,50 @@ simsimd_avx512_b8_jaccard_cycle:
 }
 
 #endif // SIMSIMD_TARGET_X86_AVX512
+
+/*
+ *  @file   x86_avx2_b8.h
+ *  @brief  x86 AVX2 implementation of the most common similarity metrics for bitsets.
+ *  @author Ash Vardanian
+ *
+ *  - Implements: Hamming and Jaccard similarity.
+ *  - Requires compiler capabilities: avx2.
+ *
+ *  AVX2 provides no built-in functionality for popcount, so we use the BMI2 instruction set.
+ *  Wojciech Mu la, Nathan Kurz and Daniel Lemire propose an alternative solution based on Harley-Seal
+ *  transforms and lookup tables. Those are very fast on large vectors, but on short vectors they lose
+ *  to built-in scalar population counts. https://arxiv.org/pdf/1611.07612.pdf
+ */
+
+#if SIMSIMD_TARGET_X86_AVX2
+
+__attribute__((target("popcnt"))) //
+inline static simsimd_f32_t
+simsimd_avx2_b8_hamming(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words) {
+    // x86 supports unaligned loads and works just fine with the scalar version for small vectors.
+    simsimd_size_t differences = 0;
+    for (; n_words >= 8; n_words -= 8, a += 8, b += 8)
+        differences += _mm_popcnt_u64(*(simsimd_u64_t const*)a ^ *(simsimd_u64_t const*)b);
+    for (; n_words; --n_words, ++a, ++b)
+        differences += _mm_popcnt_u32(*a ^ *b);
+    return (simsimd_f32_t)differences;
+}
+
+__attribute__((target("popcnt"))) //
+inline static simsimd_f32_t
+simsimd_avx2_b8_jaccard(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words) {
+    // x86 supports unaligned loads and works just fine with the scalar version for small vectors.
+    simsimd_size_t intersection = 0, union_ = 0;
+    for (; n_words >= 8; n_words -= 8, a += 8, b += 8)
+        intersection += _mm_popcnt_u64(*(simsimd_u64_t const*)a & *(simsimd_u64_t const*)b),
+            union_ += _mm_popcnt_u64(*(simsimd_u64_t const*)a | *(simsimd_u64_t const*)b);
+    for (; n_words; --n_words, ++a, ++b)
+        intersection += _mm_popcnt_u32(*a & *b), union_ += _mm_popcnt_u32(*a | *b);
+    return (union_ != 0) ? 1 - (simsimd_f32_t)intersection / (simsimd_f32_t)union_ : 0;
+}
+
+#endif // SIMSIMD_TARGET_X86_AVX2
+
 #endif // SIMSIMD_TARGET_X86
 
 #undef popcount64

package/simsimd/include/simsimd/complex.h

@@ -0,0 +1,174 @@
+/**
+ *  @brief      SIMD-accelerated Similarity Measures for Complex Vectors.
+ *  @author     Ash Vardanian
+ *  @date       February 24, 2024
+ *
+ *  Contains:
+ *  - Inner Product
+ *  - Cosine Distance
+ *
+ *  For datatypes:
+ *  - 32-bit floating point numbers
+ *  - 16-bit floating point numbers
+ *
+ *  For hardware architectures:
+ *  - Arm (NEON, SVE?)
+ *  - x86 (AVX2?, AVX512?)
+ *
+ *  x86 intrinsics: https://www.intel.com/content/www/us/en/docs/intrinsics-guide/
+ *  Arm intrinsics: https://developer.arm.com/architectures/instruction-sets/intrinsics/
+ */
+#ifndef SIMSIMD_COMPLEX_H
+#define SIMSIMD_COMPLEX_H
+
+#include "types.h"
+
+#define SIMSIMD_MAKE_COMPLEX_IP(name, input_type, accumulator_type, converter, epsilon)                                \
+    inline static simsimd_f32_t simsimd_##name##_##input_type##_complex_ip(                                            \
+        simsimd_##input_type##_t const* a, simsimd_##input_type##_t const* b, simsimd_size_t n,                        \
+        simsimd_f32_t* real_out, simsimd_f32_t* imag_out) {                                                            \
+        simsimd_##accumulator_type##_t ab_real, ab_imag;                                                               \
+        for (simsimd_size_t i = 0; i + 2 <= n; i += 2) {                                                               \
+            simsimd_##accumulator_type##_t ar = converter(a[i]);                                                       \
+            simsimd_##accumulator_type##_t br = converter(b[i]);                                                       \
+            simsimd_##accumulator_type##_t ai = converter(a[i + 1]);                                                   \
+            simsimd_##accumulator_type##_t bi = converter(b[i + 1]);                                                   \
+            ab_real += ar * br + ai * bi;                                                                              \
+            ab_imag += ai * br - ar * bi;                                                                              \
+        }                                                                                                              \
+        *real_out = ab_real;                                                                                           \
+        *imag_out = ab_imag;                                                                                           \
+        return 1 - ab_real;                                                                                            \
+    }
+
+#define SIMSIMD_MAKE_COMPLEX_COS(name, input_type, accumulator_type, converter, epsilon)                               \
+    inline static simsimd_f32_t simsimd_##name##_##input_type##_complex_cos(                                           \
+        simsimd_##input_type##_t const* a, simsimd_##input_type##_t const* b, simsimd_size_t n,                        \
+        simsimd_f32_t* real_out, simsimd_f32_t* imag_out) {                                                            \
+        simsimd_##accumulator_type##_t ab_real, ab_imag, a2_sum, b2_sum;                                               \
+        for (simsimd_size_t i = 0; i + 2 <= n; i += 2) {                                                               \
+            simsimd_##accumulator_type##_t ar = converter(a[i]);                                                       \
+            simsimd_##accumulator_type##_t br = converter(b[i]);                                                       \
+            simsimd_##accumulator_type##_t ai = converter(a[i + 1]);                                                   \
+            simsimd_##accumulator_type##_t bi = converter(b[i + 1]);                                                   \
+            ab_real += ar * br + ai * bi;                                                                              \
+            ab_imag += ai * br - ar * bi;                                                                              \
+            a2_sum += ar * ar + ai * ai;                                                                               \
+            b2_sum += br * br + bi * bi;                                                                               \
+        }                                                                                                              \
+        *real_out = ab_real;                                                                                           \
+        *imag_out = ab_imag;                                                                                           \
+        simsimd_##accumulator_type##_t ab_angle = ab_real * SIMSIMD_RSQRT(a2_sum) * SIMSIMD_RSQRT(b2_sum);             \
+        return 1 - ab_angle;                                                                                           \
+    }
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SIMSIMD_MAKE_COMPLEX_IP(serial, f64, f64, SIMSIMD_IDENTIFY,
+                        SIMSIMD_F32_DIVISION_EPSILON) // simsimd_serial_f64_complex_ip
+SIMSIMD_MAKE_COMPLEX_COS(serial, f64, f64, SIMSIMD_IDENTIFY,
+                         SIMSIMD_F32_DIVISION_EPSILON) // simsimd_serial_f64_complex_cos
+
+SIMSIMD_MAKE_COMPLEX_IP(serial, f32, f32, SIMSIMD_IDENTIFY,
+                        SIMSIMD_F32_DIVISION_EPSILON) // simsimd_serial_f32_complex_ip
+SIMSIMD_MAKE_COMPLEX_COS(serial, f32, f32, SIMSIMD_IDENTIFY,
+                         SIMSIMD_F32_DIVISION_EPSILON) // simsimd_serial_f32_complex_cos
+
+SIMSIMD_MAKE_COMPLEX_IP(serial, f16, f32, SIMSIMD_UNCOMPRESS_F16,
+                        SIMSIMD_F32_DIVISION_EPSILON) // simsimd_serial_f16_complex_ip
+SIMSIMD_MAKE_COMPLEX_COS(serial, f16, f32, SIMSIMD_UNCOMPRESS_F16,
+                         SIMSIMD_F32_DIVISION_EPSILON) // simsimd_serial_f16_complex_cos
+
+SIMSIMD_MAKE_COMPLEX_IP(accurate, f32, f64, SIMSIMD_IDENTIFY,
+                        SIMSIMD_F32_DIVISION_EPSILON) // simsimd_accurate_f32_complex_ip
+SIMSIMD_MAKE_COMPLEX_COS(accurate, f32, f64, SIMSIMD_IDENTIFY,
+                         SIMSIMD_F32_DIVISION_EPSILON) // simsimd_accurate_f32_complex_cos
+
+SIMSIMD_MAKE_COMPLEX_IP(accurate, f16, f64, SIMSIMD_UNCOMPRESS_F16,
+                        SIMSIMD_F32_DIVISION_EPSILON) // simsimd_accurate_f16_complex_ip
+SIMSIMD_MAKE_COMPLEX_COS(accurate, f16, f64, SIMSIMD_UNCOMPRESS_F16,
+                         SIMSIMD_F32_DIVISION_EPSILON) // simsimd_accurate_f16_complex_cos
+
+#if SIMSIMD_TARGET_ARM
+#if SIMSIMD_TARGET_ARM_NEON
+
+/*
+ *  @file   arm_neon_f32.h
+ *  @brief  Arm NEON implementation of the most common similarity metrics for 32-bit floating point numbers.
+ *  @author Ash Vardanian
+ *
+ *  - Implements: Kullback-Leibler and Jensen–Shannon divergence.
+ *  - Uses `f32` for storage and `f32` for accumulation.
+ *  - Requires compiler capabilities: +simd.
+ */
+
+__attribute__((target("+simd"))) //
+inline static simsimd_f32_t
+simsimd_neon_f32_complex_cos(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n, //
+                             simsimd_f32_t* real_out, simsimd_f32_t* imag_out) {
+    float32x4_t ab_real_vec = vdupq_n_f32(0);
+    float32x4_t ab_imag_vec = vdupq_n_f32(0);
+    float32x4_t a2_vec = vdupq_n_f32(0);
+    float32x4_t b2_vec = vdupq_n_f32(0);
+    simsimd_size_t i = 0;
+    for (; i + 8 <= n; i += 8) {
+        // Unpack the input arrays into real and imaginary parts:
+        // a_real = a[::2]
+        // a_imag = a[1::2]
+        // b_real = b[::2]
+        // b_imag = b[1::2]
+        float32x4x2_t a_vec = vld2q_f32(a + i);
+        float32x4x2_t b_vec = vld2q_f32(b + i);
+        float32x4_t a_real_vec = a_vec.val[0];
+        float32x4_t a_imag_vec = a_vec.val[1];
+        float32x4_t b_real_vec = b_vec.val[0];
+        float32x4_t b_imag_vec = b_vec.val[1];
+
+        // Compute the dot product:
+        // ab_real = sum(ar * br + ai * bi for ar, ai, br, bi in zip(a_real, a_imag, b_real, b_imag))
+        // ab_imag = sum(ai * br - ar * bi for ar, ai, br, bi in zip(a_real, a_imag, b_real, b_imag))
+        ab_real_vec = vfmaq_f32(ab_real_vec, a_real_vec, b_real_vec);
+        ab_real_vec = vfmaq_f32(ab_real_vec, a_imag_vec, b_imag_vec);
+        ab_imag_vec = vfmaq_f32(ab_imag_vec, a_imag_vec, b_real_vec);
+        ab_imag_vec = vfmsq_f32(ab_imag_vec, a_real_vec, b_imag_vec);
+
+        // Compute the vector norms:
+        // a2 = sum(ar * ar + ai * ai for ar, ai in zip(a_real, a_imag))
+        // b2 = sum(br * br + bi * bi for br, bi in zip(b_real, b_imag))
+        a2_vec = vfmaq_f32(a2_vec, a_real_vec, a_real_vec);
+        a2_vec = vfmaq_f32(a2_vec, a_imag_vec, a_imag_vec);
+        b2_vec = vfmaq_f32(b2_vec, b_real_vec, b_real_vec);
+        b2_vec = vfmaq_f32(b2_vec, b_imag_vec, b_imag_vec);
+    }
+
+    // Reduce horizontal sums:
+    simsimd_f32_t ab_real = vaddvq_f32(ab_real_vec);
+    simsimd_f32_t ab_imag = vaddvq_f32(ab_imag_vec);
+    simsimd_f32_t a2 = vaddvq_f32(a2_vec);
+    simsimd_f32_t b2 = vaddvq_f32(b2_vec);
+
+    // Handle the tail:
+    for (; i < n; i += 2) {
+        simsimd_f32_t ar = a[i], ai = a[i + 1], br = b[i], bi = b[i + 1];
+        ab_real += ar * br + ai * bi, ab_imag += ai * br - ar * bi;
+        a2 += ar * ar + ai * ai, b2 += br * br + bi * bi;
+    }
+    *real_out = ab_real;
+    *imag_out = ab_imag;
+
+    // Avoid `simsimd_approximate_inverse_square_root` on Arm NEON
+    simsimd_f32_t a2_b2_arr[2] = {a2, b2};
+    vst1_f32(a2_b2_arr, vrsqrte_f32(vld1_f32(a2_b2_arr)));
+    return ab_real != 0 ? 1 - ab_real * a2_b2_arr[0] * a2_b2_arr[1] : 1;
+}
+
+#endif // SIMSIMD_TARGET_ARM_NEON
+#endif // SIMSIMD_TARGET_ARM
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

package/simsimd/include/simsimd/simsimd.h

@@ -15,10 +15,11 @@
 #define SIMSIMD_H
 
 #define SIMSIMD_VERSION_MAJOR 3
-#define SIMSIMD_VERSION_MINOR 8
+#define SIMSIMD_VERSION_MINOR 9
 #define SIMSIMD_VERSION_PATCH 0
 
 #include "binary.h"      // Hamming, Jaccard
+#include "complex.h"     // Complex numbers
 #include "probability.h" // Kullback-Leibler, Jensen–Shannon
 #include "spatial.h"     // L2, Inner Product, Cosine
 
@@ -388,14 +389,6 @@ inline static void simsimd_find_metric_punned( //
     // Binary vectors
     case simsimd_datatype_b8_k:
 
-    #if SIMSIMD_TARGET_ARM_NEON
-        if (viable & simsimd_cap_arm_neon_k)
-            switch (kind) {
-            case simsimd_metric_hamming_k: *m = (simsimd_metric_punned_t)&simsimd_neon_b8_hamming, *c = simsimd_cap_arm_neon_k; return;
-            case simsimd_metric_jaccard_k: *m = (simsimd_metric_punned_t)&simsimd_neon_b8_jaccard, *c = simsimd_cap_arm_neon_k; return;
-            default: break;
-            }
-    #endif
     #if SIMSIMD_TARGET_ARM_SVE
         if (viable & simsimd_cap_arm_sve_k)
             switch (kind) {
@@ -404,6 +397,14 @@ inline static void simsimd_find_metric_punned( //
             default: break;
             }
     #endif
+    #if SIMSIMD_TARGET_ARM_NEON
+        if (viable & simsimd_cap_arm_neon_k)
+            switch (kind) {
+            case simsimd_metric_hamming_k: *m = (simsimd_metric_punned_t)&simsimd_neon_b8_hamming, *c = simsimd_cap_arm_neon_k; return;
+            case simsimd_metric_jaccard_k: *m = (simsimd_metric_punned_t)&simsimd_neon_b8_jaccard, *c = simsimd_cap_arm_neon_k; return;
+            default: break;
+            }
+    #endif
     #if SIMSIMD_TARGET_X86_AVX512
         if (viable & simsimd_cap_x86_avx512vpopcntdq_k)
             switch (kind) {
@@ -412,6 +413,14 @@ inline static void simsimd_find_metric_punned( //
             default: break;
             }
     #endif
+    #if SIMSIMD_TARGET_X86_AVX2
+        if (viable & simsimd_cap_x86_avx2_k)
+            switch (kind) {
+            case simsimd_metric_hamming_k: *m = (simsimd_metric_punned_t)&simsimd_avx2_b8_hamming, *c = simsimd_cap_x86_avx2_k; return;
+            case simsimd_metric_jaccard_k: *m = (simsimd_metric_punned_t)&simsimd_avx2_b8_jaccard, *c = simsimd_cap_x86_avx2_k; return;
+            default: break;
+            }
+    #endif
 
         if (viable & simsimd_cap_serial_k)
             switch (kind) {