usearch 2.7.2 → 2.7.6

package/simsimd/cpp/bench.cxx

@@ -0,0 +1,187 @@
+#include <cmath>  // `std::sqrt`
+#include <thread> // `std::thread`
+
+#include <benchmark/benchmark.h>
+
+#define SIMSIMD_RSQRT simsimd_approximate_inverse_square_root
+#define SIMSIMD_LOG simsimd_approximate_log
+#include <simsimd/simsimd.h>
+
+namespace bm = benchmark;
+
+template <typename return_at, typename... args_at>
+constexpr std::size_t number_of_arguments(return_at (*f)(args_at...)) {
+    return sizeof...(args_at);
+}
+
+template <typename scalar_at, std::size_t dimensions_ak> struct vectors_pair_gt {
+    scalar_at a[dimensions_ak]{};
+    scalar_at b[dimensions_ak]{};
+
+    std::size_t dimensions() const noexcept { return dimensions_ak; }
+    std::size_t size_bytes() const noexcept { return dimensions_ak * sizeof(scalar_at); }
+
+    void set(scalar_at v) noexcept {
+        for (std::size_t i = 0; i != dimensions_ak; ++i)
+            a[i] = b[i] = v;
+    }
+
+    void randomize() noexcept {
+
+        double a2_sum = 0, b2_sum = 0;
+        for (std::size_t i = 0; i != dimensions_ak; ++i) {
+            if constexpr (std::is_integral_v<scalar_at>)
+                a[i] = static_cast<scalar_at>(rand()), b[i] = static_cast<scalar_at>(rand());
+            else {
+                double ai = double(rand()) / double(RAND_MAX), bi = double(rand()) / double(RAND_MAX);
+                a2_sum += ai * ai, b2_sum += bi * bi;
+                a[i] = static_cast<scalar_at>(ai), b[i] = static_cast<scalar_at>(bi);
+            }
+        }
+
+        // Normalize the vectors:
+        if constexpr (!std::is_integral_v<scalar_at>) {
+            a2_sum = std::sqrt(a2_sum);
+            b2_sum = std::sqrt(b2_sum);
+            for (std::size_t i = 0; i != dimensions_ak; ++i)
+                a[i] /= a2_sum, b[i] /= b2_sum;
+        }
+    }
+};
+
+template <typename pair_at, typename metric_at = void>
+static void measure(bm::State& state, metric_at metric, metric_at baseline) {
+
+    pair_at pair;
+    pair.randomize();
+    // pair.set(1);
+
+    double c_baseline = baseline(pair.a, pair.b, pair.dimensions());
+    double c = 0;
+    std::size_t iterations = 0;
+    for (auto _ : state)
+        bm::DoNotOptimize((c = metric(pair.a, pair.b, pair.dimensions()))), iterations++;
+
+    state.counters["bytes"] = bm::Counter(iterations * pair.size_bytes() * 2, bm::Counter::kIsRate);
+    state.counters["pairs"] = bm::Counter(iterations, bm::Counter::kIsRate);
+
+    double delta = std::abs(c - c_baseline) > 0.0001 ? std::abs(c - c_baseline) : 0;
+    double error = delta != 0 && c_baseline != 0 ? delta / c_baseline : 0;
+    state.counters["abs_delta"] = delta;
+    state.counters["relative_error"] = error;
+}
+
+template <typename scalar_at, typename metric_at = void>
+void register_(std::string name, metric_at* distance_func, metric_at* baseline_func) {
+
+    using pair_dims_t = vectors_pair_gt<scalar_at, 1536>;
+    using pair_bytes_t = vectors_pair_gt<scalar_at, 1536 / sizeof(scalar_at)>;
+
+    std::size_t seconds = 10;
+    std::size_t threads = std::thread::hardware_concurrency(); // 1;
+    std::string name_dims = name + "_" + std::to_string(pair_dims_t{}.dimensions()) + "d";
+    std::string name_bytes = name + "_" + std::to_string(pair_bytes_t{}.size_bytes()) + "b";
+
+    bm::RegisterBenchmark(name_dims.c_str(), measure<pair_dims_t, metric_at*>, distance_func, baseline_func)
+        ->MinTime(seconds)
+        ->Threads(threads);
+    bm::RegisterBenchmark(name_bytes.c_str(), measure<pair_bytes_t, metric_at*>, distance_func, baseline_func)
+        ->MinTime(seconds)
+        ->Threads(threads);
+}
+
+int main(int argc, char** argv) {
+
+    bool compiled_with_sve = false;
+    bool compiled_with_neon = false;
+    bool compiled_with_avx2 = false;
+    bool compiled_with_avx512popcnt = false;
+
+#if defined(__ARM_FEATURE_SVE)
+    compiled_with_sve = true;
+#endif
+#if defined(__ARM_NEON)
+    compiled_with_neon = true;
+#endif
+#if defined(__AVX2__)
+    compiled_with_avx2 = true;
+#endif
+#if defined(__AVX512VPOPCNTDQ__)
+    compiled_with_avx512popcnt = true;
+#endif
+
+    // Log supported functionality
+    char const* flags[2] = {"false", "true"};
+    std::printf("Benchmarking Similarity Measures\n");
+    std::printf("\n");
+    std::printf("- Arm NEON support enabled: %s\n", flags[compiled_with_neon]);
+    std::printf("- Arm SVE support enabled: %s\n", flags[compiled_with_sve]);
+    std::printf("- x86 AVX2 support enabled: %s\n", flags[compiled_with_avx2]);
+    std::printf("- x86 AVX512VPOPCNTDQ support enabled: %s\n", flags[compiled_with_avx512popcnt]);
+    std::printf("\n");
+
+    // Run the benchmarks
+    bm::Initialize(&argc, argv);
+    if (bm::ReportUnrecognizedArguments(argc, argv))
+        return 1;
+
+#if SIMSIMD_TARGET_ARM_NEON
+    register_<simsimd_f16_t>("neon_f16_ip", simsimd_neon_f16_ip, simsimd_accurate_f16_ip);
+    register_<simsimd_f16_t>("neon_f16_cos", simsimd_neon_f16_cos, simsimd_accurate_f16_cos);
+    register_<simsimd_f16_t>("neon_f16_l2sq", simsimd_neon_f16_l2sq, simsimd_accurate_f16_l2sq);
+
+    register_<simsimd_f32_t>("neon_f32_ip", simsimd_neon_f32_ip, simsimd_accurate_f32_ip);
+    register_<simsimd_f32_t>("neon_f32_cos", simsimd_neon_f32_cos, simsimd_accurate_f32_cos);
+    register_<simsimd_f32_t>("neon_f32_l2sq", simsimd_neon_f32_l2sq, simsimd_accurate_f32_l2sq);
+
+    register_<simsimd_i8_t>("neon_i8_cos", simsimd_neon_i8_cos, simsimd_accurate_i8_cos);
+    register_<simsimd_i8_t>("neon_i8_l2sq", simsimd_neon_i8_l2sq, simsimd_accurate_i8_l2sq);
+#endif
+
+#if SIMSIMD_TARGET_ARM_SVE
+    register_<simsimd_f16_t>("sve_f16_ip", simsimd_sve_f16_ip, simsimd_accurate_f16_ip);
+    register_<simsimd_f16_t>("sve_f16_cos", simsimd_sve_f16_cos, simsimd_accurate_f16_cos);
+    register_<simsimd_f16_t>("sve_f16_l2sq", simsimd_sve_f16_l2sq, simsimd_accurate_f16_l2sq);
+
+    register_<simsimd_f32_t>("sve_f32_ip", simsimd_sve_f32_ip, simsimd_accurate_f32_ip);
+    register_<simsimd_f32_t>("sve_f32_cos", simsimd_sve_f32_cos, simsimd_accurate_f32_cos);
+    register_<simsimd_f32_t>("sve_f32_l2sq", simsimd_sve_f32_l2sq, simsimd_accurate_f32_l2sq);
+#endif
+
+#if SIMSIMD_TARGET_X86_AVX2
+    register_<simsimd_f16_t>("avx2_f16_ip", simsimd_avx2_f16_ip, simsimd_accurate_f16_ip);
+    register_<simsimd_f16_t>("avx2_f16_cos", simsimd_avx2_f16_cos, simsimd_accurate_f16_cos);
+    register_<simsimd_f16_t>("avx2_f16_l2sq", simsimd_avx2_f16_l2sq, simsimd_accurate_f16_l2sq);
+
+    register_<simsimd_i8_t>("avx2_i8_cos", simsimd_avx2_i8_cos, simsimd_accurate_i8_cos);
+    register_<simsimd_i8_t>("avx2_i8_l2sq", simsimd_avx2_i8_l2sq, simsimd_accurate_i8_l2sq);
+#endif
+
+#if SIMSIMD_TARGET_X86_AVX512
+    register_<simsimd_f16_t>("avx512_f16_ip", simsimd_avx512_f16_ip, simsimd_accurate_f16_ip);
+    register_<simsimd_f16_t>("avx512_f16_cos", simsimd_avx512_f16_cos, simsimd_accurate_f16_cos);
+    register_<simsimd_f16_t>("avx512_f16_l2sq", simsimd_avx512_f16_l2sq, simsimd_accurate_f16_l2sq);
+
+    register_<simsimd_i8_t>("avx512_i8_cos", simsimd_avx512_i8_cos, simsimd_accurate_i8_cos);
+    register_<simsimd_i8_t>("avx512_i8_l2sq", simsimd_avx512_i8_l2sq, simsimd_accurate_i8_l2sq);
+
+    register_<simsimd_f32_t>("avx512_f32_ip", simsimd_avx512_f32_ip, simsimd_accurate_f32_ip);
+    register_<simsimd_f32_t>("avx512_f32_cos", simsimd_avx512_f32_cos, simsimd_accurate_f32_cos);
+    register_<simsimd_f32_t>("avx512_f32_l2sq", simsimd_avx512_f32_l2sq, simsimd_accurate_f32_l2sq);
+#endif
+
+    register_<simsimd_f16_t>("serial_f16_ip", simsimd_serial_f16_ip, simsimd_accurate_f16_ip);
+    register_<simsimd_f16_t>("serial_f16_cos", simsimd_serial_f16_cos, simsimd_accurate_f16_cos);
+    register_<simsimd_f16_t>("serial_f16_l2sq", simsimd_serial_f16_l2sq, simsimd_accurate_f16_l2sq);
+
+    register_<simsimd_f32_t>("serial_f32_ip", simsimd_serial_f32_ip, simsimd_accurate_f32_ip);
+    register_<simsimd_f32_t>("serial_f32_cos", simsimd_serial_f32_cos, simsimd_accurate_f32_cos);
+    register_<simsimd_f32_t>("serial_f32_l2sq", simsimd_serial_f32_l2sq, simsimd_accurate_f32_l2sq);
+
+    register_<simsimd_i8_t>("serial_i8_cos", simsimd_serial_i8_cos, simsimd_accurate_i8_cos);
+    register_<simsimd_i8_t>("serial_i8_l2sq", simsimd_serial_i8_l2sq, simsimd_accurate_i8_l2sq);
+
+    bm::RunSpecifiedBenchmarks();
+    bm::Shutdown();
+    return 0;
+}

package/simsimd/go.mod

@@ -0,0 +1,3 @@
+module github.com/ashvardanian/simsimd
+
+go 1.19

package/simsimd/golang/bench_test.go

@@ -0,0 +1,40 @@
+package simsimd
+
+import (
+	"math"
+	"math/rand"
+	"testing"
+)
+
+func cosineSimilarity(a, b []float32) float32 {
+	var dotProduct float32
+	var normA, normB float32
+	for i := range a {
+		dotProduct += a[i] * b[i]
+		normA += a[i] * a[i]
+		normB += b[i] * b[i]
+	}
+	return dotProduct / (float32(math.Sqrt(float64(normA))) * float32(math.Sqrt(float64(normB))))
+}
+
+func generateRandomVector(dim int) []float32 {
+	vec := make([]float32, dim)
+	for i := range vec {
+		vec[i] = rand.Float32()
+	}
+	return vec
+}
+
+func BenchmarkCosineSimilarityNative(b *testing.B) {
+    first, second := generateRandomVector(1536), generateRandomVector(1536)
+    for i := 0; i < b.N; i++ {
+        cosineSimilarity(first, second)
+    }
+}
+
+func BenchmarkCosineSimilaritySIMD(b *testing.B) {
+    first, second := generateRandomVector(1536), generateRandomVector(1536)
+    for i := 0; i < b.N; i++ {
+        CosineF32(first, second)
+    }
+}

package/simsimd/golang/simsimd.go

@@ -0,0 +1,47 @@
+package simsimd
+
+/*
+#cgo CFLAGS: -O3
+#cgo LDFLAGS: -O3 -L.
+#include "../simsimd/simsimd.h"
+#include <stdlib.h>
+
+inline static simsimd_f32_t cosine_i8(simsimd_i8_t const* a, simsimd_i8_t const* b, simsimd_size_t d) { return simsimd_metric_punned(simsimd_metric_cosine_k, simsimd_datatype_i8_k, simsimd_cap_any_k)(a, b, d, d); }
+inline static simsimd_f32_t cosine_f32(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t d) { return simsimd_neon_f32_cos(a, b, d); }
+inline static simsimd_f32_t inner_i8(simsimd_i8_t const* a, simsimd_i8_t const* b, simsimd_size_t d) { return simsimd_metric_punned(simsimd_metric_inner_k, simsimd_datatype_i8_k, simsimd_cap_any_k)(a, b, d, d); }
+inline static simsimd_f32_t inner_f32(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t d) { return simsimd_metric_punned(simsimd_metric_inner_k, simsimd_datatype_f32_k, simsimd_cap_any_k)(a, b, d, d); }
+inline static simsimd_f32_t sqeuclidean_i8(simsimd_i8_t const* a, simsimd_i8_t const* b, simsimd_size_t d) { return simsimd_metric_punned(simsimd_metric_sqeuclidean_k, simsimd_datatype_i8_k, simsimd_cap_any_k)(a, b, d, d); }
+inline static simsimd_f32_t sqeuclidean_f32(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t d) { return simsimd_metric_punned(simsimd_metric_sqeuclidean_k, simsimd_datatype_f32_k, simsimd_cap_any_k)(a, b, d, d); }
+*/
+import "C"
+
+
+// CosineI8 computes the cosine similarity between two i8 vectors using the most suitable SIMD instruction set available.
+func CosineI8(a, b []int8) float32 {
+	return float32(C.cosine_i8((*C.simsimd_i8_t)(&a[0]), (*C.simsimd_i8_t)(&b[0]), C.simsimd_size_t(len(a))))
+}
+
+// CosineF32 computes the cosine similarity between two i8 vectors using the most suitable SIMD instruction set available.
+func CosineF32(a, b []float32) float32 {
+	return float32(C.cosine_f32((*C.simsimd_f32_t)(&a[0]), (*C.simsimd_f32_t)(&b[0]), C.simsimd_size_t(len(a))))
+}
+
+// InnerI8 computes the inner-product similarity between two i8 vectors using the most suitable SIMD instruction set available.
+func InnerI8(a, b []int8) float32 {
+	return float32(C.inner_i8((*C.simsimd_i8_t)(&a[0]), (*C.simsimd_i8_t)(&b[0]), C.simsimd_size_t(len(a))))
+}
+
+// InnerF32 computes the inner-product similarity between two i8 vectors using the most suitable SIMD instruction set available.
+func InnerF32(a, b []float32) float32 {
+	return float32(C.inner_f32((*C.simsimd_f32_t)(&a[0]), (*C.simsimd_f32_t)(&b[0]), C.simsimd_size_t(len(a))))
+}
+
+// SqEuclideanI8 computes the squared euclidean similarity between two i8 vectors using the most suitable SIMD instruction set available.
+func SqEuclideanI8(a, b []int8) float32 {
+	return float32(C.sqeuclidean_i8((*C.simsimd_i8_t)(&a[0]), (*C.simsimd_i8_t)(&b[0]), C.simsimd_size_t(len(a))))
+}
+
+// SqEuclideanF32 computes the squared euclidean similarity between two i8 vectors using the most suitable SIMD instruction set available.
+func SqEuclideanF32(a, b []float32) float32 {
+	return float32(C.sqeuclidean_f32((*C.simsimd_f32_t)(&a[0]), (*C.simsimd_f32_t)(&b[0]), C.simsimd_size_t(len(a))))
+}

package/simsimd/golang/unit_test.go

@@ -0,0 +1,40 @@
+package simsimd
+
+import (
+	"math"
+	"testing"
+)
+
+func TestCosineI8(t *testing.T) {
+	a := []int8{1, 0}
+	b := []int8{0, 1}
+
+	result := CosineI8(a, b)
+	expected := float32(1.0) // Cosine similarity of orthogonal vectors is 0
+	if math.Abs(float64(result-expected)) > 1e-3 {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+}
+
+func TestCosineF32(t *testing.T) {
+	a := []float32{1, 0}
+	b := []float32{0, 1}
+
+	result := CosineF32(a, b)
+	expected := float32(1.0) // Cosine similarity of orthogonal vectors is 0
+	if math.Abs(float64(result-expected)) > 1e-3 {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+}
+
+func TestVectorLengthMismatch(t *testing.T) {
+	defer func() {
+		if r := recover(); r == nil {
+			t.Errorf("The code did not panic")
+		}
+	}()
+
+	a := []int8{1, 0}
+	b := []int8{0}
+	_ = CosineI8(a, b) // This should panic
+}

package/simsimd/include/simsimd/binary.h

@@ -0,0 +1,186 @@
+/**
+ *  @brief      SIMD-accelerated Binary Similarity Measures.
+ *  @author     Ash Vardanian
+ *  @date       July 1, 2023
+ *
+ *  Contains:
+ *  - Hamming distance
+ *  - Jaccard similarity (Tanimoto coefficient)
+ *
+ *  For datatypes:
+ *  - 8-bit bitsets
+ *
+ *  For hardware architectures:
+ *  - Arm (NEON, SVE)
+ *  - x86 (AVX512)
+ *
+ *  x86 intrinsics: https://www.intel.com/content/www/us/en/docs/intrinsics-guide/
+ *  Arm intrinsics: https://developer.arm.com/architectures/instruction-sets/intrinsics/
+ */
+
+#pragma once
+#include "types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+inline static 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];
+}
+
+inline static simsimd_f32_t simsimd_serial_b8_hamming( //
+    simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words) {
+    simsimd_i32_t differences = 0;
+    for (simsimd_size_t i = 0; i != n_words; ++i)
+        differences += simsimd_popcount_b8(a[i] ^ b[i]);
+    return (simsimd_f32_t)differences;
+}
+
+inline static simsimd_f32_t simsimd_serial_b8_jaccard( //
+    simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words) {
+    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]);
+    return (union_ != 0) ? 1 - (simsimd_f32_t)intersection / (simsimd_f32_t)union_ : 0;
+}
+
+#if SIMSIMD_TARGET_ARM
+#if SIMSIMD_TARGET_ARM_NEON
+
+__attribute__((target("+simd"))) //
+inline static simsimd_f32_t
+simsimd_neon_b8_hamming(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words) {
+    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]);
+    return (simsimd_f32_t)differences;
+}
+
+__attribute__((target("+simd"))) //
+inline static simsimd_f32_t
+simsimd_neon_b8_jaccard(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words) {
+    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]);
+    return (union_ != 0) ? 1 - (simsimd_f32_t)intersection / (simsimd_f32_t)union_ : 0;
+}
+
+#endif // SIMSIMD_TARGET_ARM_NEON
+
+#if SIMSIMD_TARGET_ARM_SVE
+
+__attribute__((target("+sve"))) //
+inline static simsimd_f32_t
+simsimd_sve_b8_hamming(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words) {
+    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);
+    return (simsimd_f32_t)differences;
+}
+
+__attribute__((target("+sve"))) //
+inline static simsimd_f32_t
+simsimd_sve_b8_jaccard(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words) {
+    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);
+    return (union_ != 0) ? 1 - (simsimd_f32_t)intersection / (simsimd_f32_t)union_ : 0;
+}
+
+#endif // SIMSIMD_TARGET_ARM_SVE
+
+#endif // SIMSIMD_TARGET_ARM
+
+#if SIMSIMD_TARGET_X86
+
+#if SIMSIMD_TARGET_X86_AVX512
+
+__attribute__((target("avx512vpopcntdq,avx512vl,avx512bw,avx512f"))) //
+inline static simsimd_f32_t
+simsimd_avx512_b8_hamming(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words) {
+    __m512i differences_vec = _mm512_setzero_si512(), union_vec = _mm512_setzero_si512();
+    for (simsimd_size_t i = 0; i < n_words; i += 64) {
+
+        // Compute mask for tail elements
+        __mmask64 mask = (i + 64 <= n_words) ? 0xFFFFFFFFFFFFFFFF : (((1ull << (n_words - i)) - 1ull));
+
+        __m512i a_vec = _mm512_maskz_loadu_epi8(mask, a + i);
+        __m512i b_vec = _mm512_maskz_loadu_epi8(mask, b + i);
+        __m512i xor_vec = _mm512_xor_si512(a_vec, b_vec);
+
+        differences_vec = _mm512_add_epi64(differences_vec, _mm512_popcnt_epi64(xor_vec));
+    }
+
+    simsimd_size_t differences = _mm512_reduce_add_epi64(differences_vec);
+    return (simsimd_f32_t)differences;
+}
+
+__attribute__((target("avx512vpopcntdq,avx512vl,avx512bw,avx512f"))) //
+inline static simsimd_f32_t
+simsimd_avx512_b8_jaccard(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words) {
+    __m512i intersection_vec = _mm512_setzero_si512(), union_vec = _mm512_setzero_si512();
+    for (simsimd_size_t i = 0; i < n_words; i += 64) {
+
+        // Compute mask for tail elements
+        __mmask64 mask = (i + 64 <= n_words) ? 0xFFFFFFFFFFFFFFFF : (((1ull << (n_words - i)) - 1ull));
+
+        __m512i a_vec = _mm512_maskz_loadu_epi8(mask, a + i);
+        __m512i b_vec = _mm512_maskz_loadu_epi8(mask, b + i);
+        __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));
+    }
+
+    simsimd_size_t intersection = _mm512_reduce_add_epi64(intersection_vec),
+                   union_ = _mm512_reduce_add_epi64(union_vec);
+    return (union_ != 0) ? 1 - (simsimd_f32_t)intersection / (simsimd_f32_t)union_ : 0;
+}
+
+#endif // SIMSIMD_TARGET_X86_AVX512
+#endif // SIMSIMD_TARGET_X86
+
+#undef popcount64
+
+#ifdef __cplusplus
+}
+#endif