usearch 2.10.2 → 2.10.5

package/simsimd/binding.gyp

@@ -0,0 +1,36 @@
+{
+    "variables": {
+        "openssl_fips": ""
+    },
+    "targets": [
+        {
+            "target_name": "simsimd",
+            "sources": ["javascript/lib.c"],
+            "include_dirs": ["include"],
+            "defines": ["SIMSIMD_NATIVE_F16=0"],
+            "cflags": [
+                "-std=c11",
+                "-ffast-math",
+                "-Wno-unknown-pragmas",
+                "-Wno-maybe-uninitialized",
+                "-Wno-cast-function-type",
+                "-Wno-switch",
+            ],
+            "conditions": [
+                ["OS=='mac'", {
+                    "xcode_settings": {
+                        "MACOSX_DEPLOYMENT_TARGET": "11.0",
+                        "OTHER_CFLAGS": [
+                            "-arch arm64",
+                            "-arch x86_64"
+                        ],
+                        "OTHER_LDFLAGS": [
+                            "-arch arm64",
+                            "-arch x86_64"
+                        ]
+                    }
+                }]
+            ]
+        }
+    ]
+}

package/simsimd/build.rs

@@ -0,0 +1,51 @@
+fn main() {
+    let mut build = cc::Build::new();
+
+    build
+        .file("c/lib.c")
+        .include("include")
+        .define("SIMSIMD_NATIVE_F16", "0")
+        .define("SIMSIMD_DYNAMIC_DISPATCH", "1")
+        .flag("-O3")
+        .flag("-std=c99") // Enforce C99 standard
+        .flag("-pedantic") // Ensure strict compliance with the C standard
+        .warnings(false);
+
+    if build.try_compile("simsimd").is_err() {
+        print!("cargo:warning=Failed to compile with all SIMD backends...");
+
+        let target_arch = std::env::var("CARGO_CFG_TARGET_ARCH").unwrap_or_default();
+        let flags_to_try = match target_arch.as_str() {
+            "arm" | "aarch64" => vec!["SIMSIMD_TARGET_NEON", "SIMSIMD_TARGET_SVE"],
+            _ => vec![
+                "SIMSIMD_TARGET_SAPPHIRE",
+                "SIMSIMD_TARGET_ICE",
+                "SIMSIMD_TARGET_SKYLAKE",
+                "SIMSIMD_TARGET_HASWELL",
+            ],
+        };
+
+        for flag in flags_to_try.iter() {
+            build.define(flag, "0");
+            if build.try_compile("simsimd").is_ok() {
+                break;
+            }
+
+            // Print the failed configuration
+            println!(
+                "cargo:warning=Failed to compile after disabling {}, trying next configuration...",
+                flag
+            );
+        }
+    }
+
+    println!("cargo:rerun-if-changed=c/lib.c");
+    println!("cargo:rerun-if-changed=rust/lib.rs");
+    println!("cargo:rerun-if-changed=include/simsimd/simsimd.h");
+
+    println!("cargo:rerun-if-changed=include/simsimd/dot.h");
+    println!("cargo:rerun-if-changed=include/simsimd/spatial.h");
+    println!("cargo:rerun-if-changed=include/simsimd/probability.h");
+    println!("cargo:rerun-if-changed=include/simsimd/binary.h");
+    println!("cargo:rerun-if-changed=include/simsimd/types.h");
+}

package/simsimd/c/lib.c

@@ -0,0 +1,110 @@
+/**
+ *  @brief  Dynamic dispatch library for SimSIMD.
+ *  @note   Compile with the most recent compiler available.
+ *  @file   lib.c
+ */
+#define SIMSIMD_DYNAMIC_DISPATCH 1
+#define SIMSIMD_NATIVE_F16 0
+
+/*  Depending on the Operating System, the following intrinsics are available
+ *  on recent compiler toolchains:
+ *
+ *  - Linux: everything is available in GCC 12+ and Clang 16+.
+ *  - Windows - MSVC: everything except Sapphire Rapids and ARM SVE.
+ *  - MacOS - Apple Clang: only Arm NEON and x86 AVX2 Haswell extensions are available.
+ */
+#if !defined(SIMSIMD_TARGET_NEON) && (defined(__APPLE__) || defined(__linux__))
+#define SIMSIMD_TARGET_NEON 1
+#endif
+#if !defined(SIMSIMD_TARGET_SVE) && (defined(__linux__))
+#define SIMSIMD_TARGET_SVE 1
+#endif
+#if !defined(SIMSIMD_TARGET_HASWELL) && (defined(_MSC_VER) || defined(__APPLE__) || defined(__linux__))
+#define SIMSIMD_TARGET_HASWELL 1
+#endif
+#if !defined(SIMSIMD_TARGET_SKYLAKE) && (defined(_MSC_VER) || defined(__linux__))
+#define SIMSIMD_TARGET_SKYLAKE 1
+#endif
+#if !defined(SIMSIMD_TARGET_ICE) && (defined(_MSC_VER) || defined(__linux__))
+#define SIMSIMD_TARGET_ICE 1
+#endif
+#if !defined(SIMSIMD_TARGET_SAPPHIRE) && (defined(__linux__))
+#define SIMSIMD_TARGET_SAPPHIRE 1
+#endif
+
+#include <simsimd/simsimd.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+simsimd_capability_t simsimd_capabilities(void) {
+    static simsimd_capability_t static_capabilities = simsimd_cap_any_k;
+    if (static_capabilities == simsimd_cap_any_k)
+        static_capabilities = simsimd_capabilities_implementation();
+    return static_capabilities;
+}
+
+// Every time a function is called, it checks if the metric is already loaded. If not, it fetches it.
+// If no metric is found, it returns NaN. We can obtain NaN by dividing 0.0 by 0.0, but that annoys
+// the MSVC compiler. Instead we can directly write-in the signaling NaN (0x7FF0000000000001)
+// or the qNaN (0x7FF8000000000000).
+#define SIMSIMD_METRIC_DECLARATION(name, extension, type)                                                              \
+    SIMSIMD_DYNAMIC void simsimd_##name##_##extension(simsimd_##type##_t const* a, simsimd_##type##_t const* b,        \
+                                                      simsimd_size_t n, simsimd_distance_t* results) {                 \
+        static simsimd_metric_punned_t metric = 0;                                                                     \
+        if (metric == 0) {                                                                                             \
+            simsimd_capability_t used_capability;                                                                      \
+            simsimd_find_metric_punned(simsimd_metric_##name##_k, simsimd_datatype_##extension##_k,                    \
+                                       simsimd_capabilities(), simsimd_cap_any_k, &metric, &used_capability);          \
+            if (!metric) {                                                                                             \
+                *(simsimd_u64_t*)results = 0x7FF0000000000001ull;                                                      \
+                return;                                                                                                \
+            }                                                                                                          \
+        }                                                                                                              \
+        metric(a, b, n, results);                                                                                      \
+    }
+
+// Dot products
+SIMSIMD_METRIC_DECLARATION(dot, f16, f16)
+SIMSIMD_METRIC_DECLARATION(dot, f32, f32)
+SIMSIMD_METRIC_DECLARATION(dot, f64, f64)
+SIMSIMD_METRIC_DECLARATION(dot, f16c, f16)
+SIMSIMD_METRIC_DECLARATION(dot, f32c, f32)
+SIMSIMD_METRIC_DECLARATION(dot, f64c, f64)
+SIMSIMD_METRIC_DECLARATION(vdot, f16c, f16)
+SIMSIMD_METRIC_DECLARATION(vdot, f32c, f32)
+SIMSIMD_METRIC_DECLARATION(vdot, f64c, f64)
+
+// Spatial distances
+SIMSIMD_METRIC_DECLARATION(cos, i8, i8)
+SIMSIMD_METRIC_DECLARATION(cos, f16, f16)
+SIMSIMD_METRIC_DECLARATION(cos, f32, f32)
+SIMSIMD_METRIC_DECLARATION(cos, f64, f64)
+SIMSIMD_METRIC_DECLARATION(l2sq, i8, i8)
+SIMSIMD_METRIC_DECLARATION(l2sq, f16, f16)
+SIMSIMD_METRIC_DECLARATION(l2sq, f32, f32)
+SIMSIMD_METRIC_DECLARATION(l2sq, f64, f64)
+
+// Binary distances
+SIMSIMD_METRIC_DECLARATION(hamming, b8, b8)
+SIMSIMD_METRIC_DECLARATION(jaccard, b8, b8)
+
+// Probability distributions
+SIMSIMD_METRIC_DECLARATION(kl, f16, f16)
+SIMSIMD_METRIC_DECLARATION(kl, f32, f32)
+SIMSIMD_METRIC_DECLARATION(kl, f64, f64)
+SIMSIMD_METRIC_DECLARATION(js, f16, f16)
+SIMSIMD_METRIC_DECLARATION(js, f32, f32)
+SIMSIMD_METRIC_DECLARATION(js, f64, f64)
+
+SIMSIMD_DYNAMIC int simsimd_uses_neon(void) { return (simsimd_capabilities() & simsimd_cap_neon_k) != 0; }
+SIMSIMD_DYNAMIC int simsimd_uses_sve(void) { return (simsimd_capabilities() & simsimd_cap_sve_k) != 0; }
+SIMSIMD_DYNAMIC int simsimd_uses_haswell(void) { return (simsimd_capabilities() & simsimd_cap_haswell_k) != 0; }
+SIMSIMD_DYNAMIC int simsimd_uses_skylake(void) { return (simsimd_capabilities() & simsimd_cap_skylake_k) != 0; }
+SIMSIMD_DYNAMIC int simsimd_uses_ice(void) { return (simsimd_capabilities() & simsimd_cap_ice_k) != 0; }
+SIMSIMD_DYNAMIC int simsimd_uses_sapphire(void) { return (simsimd_capabilities() & simsimd_cap_sapphire_k) != 0; }
+
+#ifdef __cplusplus
+}
+#endif

package/simsimd/include/simsimd/binary.h

@@ -0,0 +1,258 @@
+/**
+ *  @file       binary.h
+ *  @brief      SIMD-accelerated Binary Similarity Measures.
+ *  @author     Ash Vardanian
+ *  @date       July 1, 2023
+ *
+ *  Contains:
+ *  - Hamming distance
+ *  - Jaccard similarity (Tanimoto coefficient)
+ *
+ *  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_BINARY_H
+#define SIMSIMD_BINARY_H
+
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// clang-format off
+
+/*  Serial backends for bitsets. */
+SIMSIMD_PUBLIC void simsimd_hamming_b8_serial(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words, simsimd_distance_t* distance);
+SIMSIMD_PUBLIC void simsimd_jaccard_b8_serial(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words, simsimd_distance_t* distance);
+
+/*  Arm NEON backend for bitsets. */
+SIMSIMD_PUBLIC void simsimd_hamming_b8_neon(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words, simsimd_distance_t* distance);
+SIMSIMD_PUBLIC void simsimd_jaccard_b8_neon(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words, simsimd_distance_t* distance);
+
+/*  Arm SVE backend for bitsets. */
+SIMSIMD_PUBLIC void simsimd_hamming_b8_sve(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words, simsimd_distance_t* distance);
+SIMSIMD_PUBLIC void simsimd_jaccard_b8_sve(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words, simsimd_distance_t* distance);
+
+/*  x86 AVX2 backend for bitsets for Intel Haswell CPUs and newer, needs only POPCNT extensions. */
+SIMSIMD_PUBLIC void simsimd_hamming_b8_haswell(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words, simsimd_distance_t* distance);
+SIMSIMD_PUBLIC void simsimd_jaccard_b8_haswell(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words, simsimd_distance_t* distance);
+
+/*  x86 AVX512 backend for bitsets for Intel Ice Lake CPUs and newer, using VPOPCNTDQ extensions. */
+SIMSIMD_PUBLIC void simsimd_hamming_b8_ice(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words, simsimd_distance_t* distance);
+SIMSIMD_PUBLIC void simsimd_jaccard_b8_ice(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words, simsimd_distance_t* distance);
+// clang-format on
+
+SIMSIMD_PUBLIC unsigned char simsimd_popcount_b8(simsimd_b8_t x) {
+    static unsigned char lookup_table[] = {
+        0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, //
+        1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+        1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+        1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+        2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+        3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8};
+    return lookup_table[x];
+}
+
+SIMSIMD_PUBLIC void simsimd_hamming_b8_serial(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words,
+                                              simsimd_distance_t* result) {
+    simsimd_i32_t differences = 0;
+    for (simsimd_size_t i = 0; i != n_words; ++i)
+        differences += simsimd_popcount_b8(a[i] ^ b[i]);
+    *result = differences;
+}
+
+SIMSIMD_PUBLIC void simsimd_jaccard_b8_serial(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words,
+                                              simsimd_distance_t* result) {
+    simsimd_i32_t intersection = 0, union_ = 0;
+    for (simsimd_size_t i = 0; i != n_words; ++i)
+        intersection += simsimd_popcount_b8(a[i] & b[i]), union_ += simsimd_popcount_b8(a[i] | b[i]);
+    *result = (union_ != 0) ? 1 - (simsimd_f32_t)intersection / (simsimd_f32_t)union_ : 0;
+}
+
+#if SIMSIMD_TARGET_ARM
+#if SIMSIMD_TARGET_NEON
+#pragma GCC target("+simd")
+#pragma clang attribute push(__attribute__((target("+simd"))), apply_to = function)
+
+SIMSIMD_PUBLIC void simsimd_hamming_b8_neon(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words,
+                                            simsimd_distance_t* result) {
+    simsimd_i32_t differences = 0;
+    simsimd_size_t i = 0;
+    for (; i + 16 <= n_words; i += 16) {
+        uint8x16_t a_first = vld1q_u8(a + i);
+        uint8x16_t b_first = vld1q_u8(b + i);
+        differences += vaddvq_u8(vcntq_u8(veorq_u8(a_first, b_first)));
+    }
+    // Handle the tail
+    for (; i != n_words; ++i)
+        differences += simsimd_popcount_b8(a[i] ^ b[i]);
+    *result = differences;
+}
+
+SIMSIMD_PUBLIC void simsimd_jaccard_b8_neon(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words,
+                                            simsimd_distance_t* result) {
+    simsimd_i32_t intersection = 0, union_ = 0;
+    simsimd_size_t i = 0;
+    for (; i + 16 <= n_words; i += 16) {
+        uint8x16_t a_first = vld1q_u8(a + i);
+        uint8x16_t b_first = vld1q_u8(b + i);
+        intersection += vaddvq_u8(vcntq_u8(vandq_u8(a_first, b_first)));
+        union_ += vaddvq_u8(vcntq_u8(vorrq_u8(a_first, b_first)));
+    }
+    // Handle the tail
+    for (; i != n_words; ++i)
+        intersection += simsimd_popcount_b8(a[i] & b[i]), union_ += simsimd_popcount_b8(a[i] | b[i]);
+    *result = (union_ != 0) ? 1 - (simsimd_f32_t)intersection / (simsimd_f32_t)union_ : 0;
+}
+
+#pragma clang attribute pop
+#pragma GCC pop_options
+#endif // SIMSIMD_TARGET_NEON
+
+#if SIMSIMD_TARGET_SVE
+#pragma GCC target("+sve")
+#pragma clang attribute push(__attribute__((target("+sve"))), apply_to = function)
+
+SIMSIMD_PUBLIC void simsimd_hamming_b8_sve(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words,
+                                           simsimd_distance_t* result) {
+    simsimd_size_t i = 0;
+    simsimd_i32_t differences = 0;
+    do {
+        svbool_t pg_vec = svwhilelt_b8((unsigned int)i, (unsigned int)n_words);
+        svuint8_t a_vec = svld1_u8(pg_vec, a + i);
+        svuint8_t b_vec = svld1_u8(pg_vec, b + i);
+        differences += svaddv_u8(svptrue_b8(), svcnt_u8_x(svptrue_b8(), sveor_u8_m(svptrue_b8(), a_vec, b_vec)));
+        i += svcntb();
+    } while (i < n_words);
+    *result = differences;
+}
+
+SIMSIMD_PUBLIC void simsimd_jaccard_b8_sve(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words,
+                                           simsimd_distance_t* result) {
+    simsimd_size_t i = 0;
+    simsimd_i32_t intersection = 0, union_ = 0;
+    do {
+        svbool_t pg_vec = svwhilelt_b8((unsigned int)i, (unsigned int)n_words);
+        svuint8_t a_vec = svld1_u8(pg_vec, a + i);
+        svuint8_t b_vec = svld1_u8(pg_vec, b + i);
+        intersection += svaddv_u8(svptrue_b8(), svcnt_u8_x(svptrue_b8(), svand_u8_m(svptrue_b8(), a_vec, b_vec)));
+        union_ += svaddv_u8(svptrue_b8(), svcnt_u8_x(svptrue_b8(), svorr_u8_m(svptrue_b8(), a_vec, b_vec)));
+        i += svcntb();
+    } while (i < n_words);
+    *result = (union_ != 0) ? 1 - (simsimd_f32_t)intersection / (simsimd_f32_t)union_ : 0;
+}
+
+#pragma clang attribute pop
+#pragma GCC pop_options
+#endif // SIMSIMD_TARGET_SVE
+#endif // SIMSIMD_TARGET_ARM
+
+#if SIMSIMD_TARGET_X86
+#if SIMSIMD_TARGET_ICE
+#pragma GCC push_options
+#pragma GCC target("avx512f", "avx512vl", "bmi2", "avx512bw", "avx512vpopcntdq")
+#pragma clang attribute push(__attribute__((target("avx512f,avx512vl,bmi2,avx512bw,avx512vpopcntdq"))),                \
+                             apply_to = function)
+
+SIMSIMD_PUBLIC void simsimd_hamming_b8_ice(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words,
+                                           simsimd_distance_t* result) {
+    __m512i differences_vec = _mm512_setzero_si512();
+    __m512i a_vec, b_vec;
+
+simsimd_hamming_b8_ice_cycle:
+    if (n_words < 64) {
+        __mmask64 mask = (__mmask64)_bzhi_u64(0xFFFFFFFFFFFFFFFF, n_words);
+        a_vec = _mm512_maskz_loadu_epi8(mask, a);
+        b_vec = _mm512_maskz_loadu_epi8(mask, b);
+        n_words = 0;
+    } else {
+        a_vec = _mm512_loadu_epi8(a);
+        b_vec = _mm512_loadu_epi8(b);
+        a += 64, b += 64, n_words -= 64;
+    }
+    __m512i xor_vec = _mm512_xor_si512(a_vec, b_vec);
+    differences_vec = _mm512_add_epi64(differences_vec, _mm512_popcnt_epi64(xor_vec));
+    if (n_words)
+        goto simsimd_hamming_b8_ice_cycle;
+
+    simsimd_size_t differences = _mm512_reduce_add_epi64(differences_vec);
+    *result = differences;
+}
+
+SIMSIMD_PUBLIC void simsimd_jaccard_b8_ice(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words,
+                                           simsimd_distance_t* result) {
+    __m512i intersection_vec = _mm512_setzero_si512(), union_vec = _mm512_setzero_si512();
+    __m512i a_vec, b_vec;
+
+simsimd_jaccard_b8_ice_cycle:
+    if (n_words < 64) {
+        __mmask64 mask = (__mmask64)_bzhi_u64(0xFFFFFFFFFFFFFFFF, n_words);
+        a_vec = _mm512_maskz_loadu_epi8(mask, a);
+        b_vec = _mm512_maskz_loadu_epi8(mask, b);
+        n_words = 0;
+    } else {
+        a_vec = _mm512_loadu_epi8(a);
+        b_vec = _mm512_loadu_epi8(b);
+        a += 64, b += 64, n_words -= 64;
+    }
+    __m512i and_vec = _mm512_and_si512(a_vec, b_vec);
+    __m512i or_vec = _mm512_or_si512(a_vec, b_vec);
+    intersection_vec = _mm512_add_epi64(intersection_vec, _mm512_popcnt_epi64(and_vec));
+    union_vec = _mm512_add_epi64(union_vec, _mm512_popcnt_epi64(or_vec));
+    if (n_words)
+        goto simsimd_jaccard_b8_ice_cycle;
+
+    simsimd_size_t intersection = _mm512_reduce_add_epi64(intersection_vec),
+                   union_ = _mm512_reduce_add_epi64(union_vec);
+    *result = (union_ != 0) ? 1 - (simsimd_f32_t)intersection / (simsimd_f32_t)union_ : 0;
+}
+
+#pragma clang attribute pop
+#pragma GCC pop_options
+#endif // SIMSIMD_TARGET_ICE
+
+#if SIMSIMD_TARGET_HASWELL
+#pragma GCC push_options
+#pragma GCC target("popcnt")
+#pragma clang attribute push(__attribute__((target("popcnt"))), apply_to = function)
+
+SIMSIMD_PUBLIC void simsimd_hamming_b8_haswell(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words,
+                                               simsimd_distance_t* result) {
+    // 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);
+    *result = differences;
+}
+
+SIMSIMD_PUBLIC void simsimd_jaccard_b8_haswell(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words,
+                                               simsimd_distance_t* result) {
+    // 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);
+    *result = (union_ != 0) ? 1 - (simsimd_f32_t)intersection / (simsimd_f32_t)union_ : 0;
+}
+
+#pragma clang attribute pop
+#pragma GCC pop_options
+#endif // SIMSIMD_TARGET_HASWELL
+#endif // SIMSIMD_TARGET_X86
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif