usearch 2.7.3 → 2.7.7

package/simsimd/python/test.py

@@ -1,38 +1,170 @@
-import platform
-
+import pytest
+import numpy as np
 import simsimd as simd
+import scipy.spatial.distance as spd
+
+SIMSIMD_RTOL = 2
+SIMSIMD_ATOL = 3e-1
+
+
+def test_pointers_availability():
+    """Tests the availability of pre-compiled functions for compatibility with USearch."""
+    assert simd.pointer_to_sqeuclidean("f32") != 0
+    assert simd.pointer_to_cosine("f32") != 0
+    assert simd.pointer_to_inner("f32") != 0
+
+    assert simd.pointer_to_sqeuclidean("f16") != 0
+    assert simd.pointer_to_cosine("f16") != 0
+    assert simd.pointer_to_inner("f16") != 0
+
+    assert simd.pointer_to_sqeuclidean("i8") != 0
+    assert simd.pointer_to_cosine("i8") != 0
+    assert simd.pointer_to_inner("i8") != 0
+
+
+@pytest.mark.repeat(50)
+@pytest.mark.parametrize("ndim", [3, 97, 1536])
+@pytest.mark.parametrize("dtype", [np.float32, np.float16])
+def test_dot(ndim, dtype):
+    """Compares the simd.dot() function with numpy.dot(), measuring the accuracy error for f16, and f32 types."""
+    a = np.random.randn(ndim).astype(dtype)
+    b = np.random.randn(ndim).astype(dtype)
+    a /= np.linalg.norm(a)
+    b /= np.linalg.norm(b)
+
+    expected = 1 - np.inner(a, b)
+    result = simd.inner(a, b)
+
+    np.testing.assert_allclose(expected, result, atol=SIMSIMD_ATOL, rtol=SIMSIMD_RTOL)
+
+
+@pytest.mark.repeat(50)
+@pytest.mark.parametrize("ndim", [3, 97, 1536])
+@pytest.mark.parametrize("dtype", [np.float32, np.float16])
+def test_sqeuclidean(ndim, dtype):
+    """Compares the simd.sqeuclidean() function with scipy.spatial.distance.sqeuclidean(), measuring the accuracy error for f16, and f32 types."""
+    a = np.random.randn(ndim).astype(dtype)
+    b = np.random.randn(ndim).astype(dtype)
+
+    expected = spd.sqeuclidean(a, b)
+    result = simd.sqeuclidean(a, b)
+
+    np.testing.assert_allclose(expected, result, atol=SIMSIMD_ATOL, rtol=SIMSIMD_RTOL)
+
+
+@pytest.mark.repeat(50)
+@pytest.mark.parametrize("ndim", [3, 97, 1536])
+@pytest.mark.parametrize("dtype", [np.float32, np.float16])
+def test_cosine(ndim, dtype):
+    """Compares the simd.cosine() function with scipy.spatial.distance.cosine(), measuring the accuracy error for f16, and f32 types."""
+    a = np.random.randn(ndim).astype(dtype)
+    b = np.random.randn(ndim).astype(dtype)
+
+    expected = spd.cosine(a, b)
+    result = simd.cosine(a, b)
+
+    np.testing.assert_allclose(expected, result, atol=SIMSIMD_ATOL, rtol=SIMSIMD_RTOL)
+
+
+@pytest.mark.parametrize("ndim", [3, 97, 1536])
+@pytest.mark.parametrize("dtype", [np.float32, np.float16])
+def test_cosine_zero_vector(ndim, dtype):
+    """Tests the simd.cosine() function with zero vectors, to catch division by zero errors."""
+    a = np.zeros(ndim, dtype=dtype)
+    b = np.random.randn(ndim).astype(dtype)
+
+    # SciPy raises: "RuntimeWarning: invalid value encountered in scalar divide"
+    with pytest.raises(RuntimeWarning):
+        expected = spd.cosine(a, b)
+
+    expected = 1
+    result = simd.cosine(a, b)
+
+    assert result == expected, f"Expected {expected}, but got {result}"
+
+
+@pytest.mark.repeat(50)
+@pytest.mark.parametrize("ndim", [3, 97, 1536])
+def test_hamming(ndim):
+    """Compares the simd.hamming() function with scipy.spatial.distance.hamming."""
+    a = np.packbits(np.random.randint(0, 2, ndim).astype(np.uint8))
+    b = np.packbits(np.random.randint(0, 2, ndim).astype(np.uint8))
+
+    expected = spd.hamming(a, b)
+    result = simd.hamming(a, b)
+
+    np.testing.assert_allclose(expected, result, atol=SIMSIMD_ATOL, rtol=SIMSIMD_RTOL)
+
+
+@pytest.mark.repeat(50)
+@pytest.mark.parametrize("ndim", [3, 97, 1536])
+def test_jaccard(ndim):
+    """Compares the simd.jaccard() function with scipy.spatial.distance.jaccard."""
+    a = np.packbits(np.random.randint(0, 2, ndim).astype(np.uint8))
+    b = np.packbits(np.random.randint(0, 2, ndim).astype(np.uint8))
+
+    expected = spd.jaccard(a, b)
+    result = simd.jaccard(a, b)
+
+    np.testing.assert_allclose(expected, result, atol=SIMSIMD_ATOL, rtol=SIMSIMD_RTOL)
+
+
+@pytest.mark.parametrize("ndim", [3, 97, 1536])
+@pytest.mark.parametrize("dtype", [np.float32, np.float16])
+def test_batch(ndim, dtype):
+    """Compares the simd.simd.sqeuclidean() function with scipy.spatial.distance.sqeuclidean() for a batch of vectors, measuring the accuracy error for f16, and f32 types."""
+
+    # Distance between matrixes A (N x D scalars) and B (N x D scalars) is an array with N floats.
+    A = np.random.randn(10, ndim).astype(dtype)
+    B = np.random.randn(10, ndim).astype(dtype)
+    result_np = [spd.sqeuclidean(A[i], B[i]) for i in range(10)]
+    result_simd = simd.sqeuclidean(A, B)
+    assert np.allclose(result_simd, result_np, atol=SIMSIMD_ATOL, rtol=SIMSIMD_RTOL)
+
+    # Distance between matrixes A (N x D scalars) and B (1 x D scalars) is an array with N floats.
+    B = np.random.randn(1, ndim).astype(dtype)
+    result_np = [spd.sqeuclidean(A[i], B[0]) for i in range(10)]
+    result_simd = simd.sqeuclidean(A, B)
+    assert np.allclose(result_simd, result_np, atol=SIMSIMD_ATOL, rtol=SIMSIMD_RTOL)
+
+    # Distance between matrixes A (1 x D scalars) and B (N x D scalars) is an array with N floats.
+    A = np.random.randn(1, ndim).astype(dtype)
+    B = np.random.randn(10, ndim).astype(dtype)
+    result_np = [spd.sqeuclidean(A[0], B[i]) for i in range(10)]
+    result_simd = simd.sqeuclidean(A, B)
+    assert np.allclose(result_simd, result_np, atol=SIMSIMD_ATOL, rtol=SIMSIMD_RTOL)
+
+    # Distance between matrix A (N x D scalars) and array B (D scalars) is an array with N floats.
+    A = np.random.randn(10, ndim).astype(dtype)
+    B = np.random.randn(ndim).astype(dtype)
+    result_np = [spd.sqeuclidean(A[i], B) for i in range(10)]
+    result_simd = simd.sqeuclidean(A, B)
+    assert np.allclose(result_simd, result_np, atol=SIMSIMD_ATOL, rtol=SIMSIMD_RTOL)
+
+    # Distance between matrix B (N x D scalars) and array A (D scalars) is an array with N floats.
+    B = np.random.randn(10, ndim).astype(dtype)
+    A = np.random.randn(ndim).astype(dtype)
+    result_np = [spd.sqeuclidean(B[i], A) for i in range(10)]
+    result_simd = simd.sqeuclidean(B, A)
+    assert np.allclose(result_simd, result_np, atol=SIMSIMD_ATOL, rtol=SIMSIMD_RTOL)
+
+
+@pytest.mark.parametrize("ndim", [3, 97, 1536])
+@pytest.mark.parametrize("dtype", [np.float32, np.float16])
+@pytest.mark.parametrize("metric", ["sqeuclidean", "cosine"])
+def test_cdist(ndim, dtype, metric):
+    """Compares the simd.cdist() function with scipy.spatial.distance.cdist(), measuring the accuracy error for f16, and f32 types using sqeuclidean and cosine metrics."""
+
+    # Create random matrices A (M x D) and B (N x D).
+    M, N = 10, 15  # or any other sizes you deem appropriate
+    A = np.random.randn(M, ndim).astype(dtype)
+    B = np.random.randn(N, ndim).astype(dtype)
+
+    # Compute cdist using scipy.
+    expected = spd.cdist(A, B, metric)
 
+    # Compute cdist using simd.
+    result = simd.cdist(A, B, metric=metric)
 
-def test_non_null():
-    # Some distance functions are provided for every platform
-    assert simd.to_int(simd.tanimoto_b1x8_naive) != 0
-    assert simd.to_int(simd.tanimoto_maccs_naive) != 0
-
-    # Arm Neon variants should be precompiled for any 64-bit Arm machine:
-    if platform.machine() == "arm64":
-        assert simd.to_int(simd.cos_f16x4_neon) != 0
-        assert simd.to_int(simd.cos_i8x16_neon) != 0
-        assert simd.to_int(simd.cos_f32x4_neon) != 0
-        assert simd.to_int(simd.dot_f32x4_neon) != 0
-        assert simd.to_int(simd.tanimoto_maccs_neon) != 0
-
-    # Arm SVE variants should be precompiled for 64-bit Arm machines running Linux:
-    if platform.machine() == "arm64" and platform.system().lower() == "linux":
-        assert simd.to_int(simd.dot_f32_sve) != 0
-        assert simd.to_int(simd.cos_f32_sve) != 0
-        assert simd.to_int(simd.cos_f16_sve) != 0
-        assert simd.to_int(simd.l2sq_f32_sve) != 0
-        assert simd.to_int(simd.l2sq_f16_sve) != 0
-        assert simd.to_int(simd.hamming_b1x8_sve) != 0
-        assert simd.to_int(simd.hamming_b1x128_sve) != 0
-        assert simd.to_int(simd.tanimoto_maccs_sve) != 0
-
-    # x86 AVX2 variants are precompiled for every 64-bit x86 platform:
-    if platform.machine() == "x86_64":
-        assert simd.to_int(simd.cos_f32x4_avx2) != 0
-
-    # x86 AVX-512 variants are precompiled for 64-bit x86 machines running Linux:
-    if platform.machine() == "x86_64" and platform.system().lower() == "linux":
-        assert simd.to_int(simd.cos_f16x16_avx512) != 0
-        assert simd.to_int(simd.hamming_b1x128_avx512) != 0
-        assert simd.to_int(simd.tanimoto_maccs_avx512) != 0
+    # Assert they're close.
+    np.testing.assert_allclose(expected, result, atol=SIMSIMD_ATOL, rtol=SIMSIMD_RTOL)

package/simsimd/setup.py

@@ -1,10 +1,59 @@
 import os
+import sys
+import platform
 from os.path import dirname
 from setuptools import setup, Extension
 
+import glob
+import numpy
+
 __version__ = open("VERSION", "r").read().strip()
 __lib_name__ = "simsimd"
 
+compile_args = []
+link_args = []
+macros_args = []
+
+if sys.platform == "linux":
+    compile_args.append("-std=c11")
+    compile_args.append("-O3")
+    compile_args.append("-ffast-math")
+    compile_args.append("-fdiagnostics-color=always")
+
+    # Disable warnings
+    compile_args.append("-w")
+
+    # Enable OpenMP for Linux
+    compile_args.append("-fopenmp")
+    link_args.append("-lgomp")
+
+if sys.platform == "darwin":
+    compile_args.append("-std=c11")
+    compile_args.append("-O3")
+    compile_args.append("-ffast-math")
+
+    # Disable warnings
+    compile_args.append("-w")
+
+if sys.platform == "win32":
+    compile_args.append("/std:c11")
+    compile_args.append("/O2")
+    compile_args.append("/fp:fast")
+
+    # Dealing with MinGW linking errors
+    # https://cibuildwheel.readthedocs.io/en/stable/faq/#windows-importerror-dll-load-failed-the-specific-module-could-not-be-found
+    compile_args.append("/d2FH4-")
+
+ext_modules = [
+    Extension(
+        "simsimd",
+        sources=["python/lib.c"],
+        include_dirs=["include", numpy.get_include()],
+        extra_compile_args=compile_args,
+        extra_link_args=link_args,
+        define_macros=macros_args,
+    ),
+]
 
 this_directory = os.path.abspath(dirname(__file__))
 with open(os.path.join(this_directory, "README.md"), "r", encoding="utf8") as f:
@@ -16,7 +65,7 @@ setup(
     author="Ash Vardanian",
     author_email="1983160+ashvardanian@users.noreply.github.com",
     url="https://github.com/ashvardanian/simsimd",
-    description="SIMD-accelerated similarity measures for x86 and Arm",
+    description="Vector Similarity Functions 3x-200x Faster than SciPy and NumPy",
     long_description=long_description,
     long_description_content_type="text/markdown",
     license="Apache-2.0",
@@ -29,12 +78,6 @@ setup(
         "Programming Language :: C",
         "Programming Language :: Python :: Implementation :: CPython",
     ],
-    ext_modules=[
-        Extension(
-            "simsimd",
-            sources=["python/lib.c"],
-            include_dirs=["include"],
-        )
-    ],
+    ext_modules=ext_modules,
     zip_safe=False,
 )

package/wasmer.toml

@@ -1,6 +1,6 @@
 [package]
 name="unum/usearch"
-version="2.7.3"
+version="2.7.7"
 description="Smaller & Faster Single-File Vector Search Engine from Unum"
 license="Apache-2.0"
 readme="README.md"

package/simsimd/bench.cxx

@@ -1,137 +0,0 @@
-#include <thread>
-
-#include <benchmark/benchmark.h>
-
-#include <simsimd/simsimd.h>
-#include <simsimd/simsimd_chem.h>
-
-namespace bm = benchmark;
-
-static const std::size_t threads_k = std::thread::hardware_concurrency();
-static constexpr std::size_t time_k = 10;
-static constexpr std::size_t bytes_k = 1024;
-
-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 bytes_per_vector_ak = bytes_k,
-          typename metric_at = void> //
-static void measure(bm::State& state, metric_at metric) {
-
-    constexpr ::size_t dimensions_ak = bytes_per_vector_ak / sizeof(scalar_at);
-    alignas(64) scalar_at a[dimensions_ak]{};
-    alignas(64) scalar_at b[dimensions_ak]{};
-    float c{};
-
-    std::fill_n(a, dimensions_ak, static_cast<scalar_at>(1));
-    std::fill_n(b, dimensions_ak, static_cast<scalar_at>(2));
-
-    std::size_t iterations = 0;
-    for (auto _ : state)
-        if constexpr (number_of_arguments(metric_at{}) == 3)
-            bm::DoNotOptimize((c = metric(a, b, dimensions_ak))), iterations++;
-        else
-            bm::DoNotOptimize((c = metric(a, b))), iterations++;
-
-    state.counters["bytes"] = bm::Counter(iterations * bytes_per_vector_ak * 2u, bm::Counter::kIsRate);
-    state.counters["pairs"] = bm::Counter(iterations, bm::Counter::kIsRate);
-}
-
-template <typename scalar_at, std::size_t bytes_per_vector_ak = bytes_k, typename metric_at = void>
-void register_(char const* name, metric_at distance_func) {
-    bm::RegisterBenchmark(name, measure<scalar_at, bytes_per_vector_ak, metric_at>, distance_func)
-        ->Threads(1)
-        ->MinTime(time_k);
-    bm::RegisterBenchmark(name, measure<scalar_at, bytes_per_vector_ak, metric_at>, distance_func)
-        ->Threads(threads_k)
-        ->MinTime(time_k);
-}
-
-simsimd_f32_t cos_f32_naive(simsimd_f32_t* v1, simsimd_f32_t* v2, std::size_t n) {
-    simsimd_f32_t inner_product = 0;
-    simsimd_f32_t magnitude1 = 0;
-    simsimd_f32_t magnitude2 = 0;
-    for (std::size_t i = 0; i != n; ++i) {
-        inner_product += v1[i] * v2[i];
-        magnitude1 += v1[i] * v1[i];
-        magnitude2 += v2[i] * v2[i];
-    }
-    return 1 - inner_product / (std::sqrt(magnitude1) * std::sqrt(magnitude2));
-}
-
-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("Default vector length: %zu bytes\n", bytes_k);
-    std::printf("\n");
-
-    // Run the benchmarks
-    bm::Initialize(&argc, argv);
-    if (bm::ReportUnrecognizedArguments(argc, argv))
-        return 1;
-
-    register_<std::uint8_t, 21>("tanimoto_maccs_naive", simsimd_tanimoto_maccs_naive);
-    register_<simsimd_f32_t>("cos_f32_naive", cos_f32_naive);
-
-#if SIMSIMD_TARGET_ARM_SVE
-    register_<simsimd_f32_t>("dot_f32_sve", simsimd_dot_f32_sve);
-    register_<simsimd_f32_t>("cos_f32_sve", simsimd_cos_f32_sve);
-    register_<std::int16_t>("cos_f16_sve", simsimd_cos_f16_sve);
-    register_<simsimd_f32_t>("l2sq_f32_sve", simsimd_l2sq_f32_sve);
-    register_<std::int16_t>("l2sq_f16_sve", simsimd_l2sq_f16_sve);
-    register_<std::uint8_t>("hamming_b1x8_sve", simsimd_hamming_b1x8_sve);
-    register_<std::uint8_t>("hamming_b1x128_sve", simsimd_hamming_b1x128_sve);
-    register_<std::uint8_t, 21>("tanimoto_maccs_sve", simsimd_tanimoto_maccs_sve);
-#endif
-
-#if SIMSIMD_TARGET_ARM_NEON
-    register_<simsimd_f32_t>("dot_f32x4_neon", simsimd_dot_f32x4_neon);
-    register_<std::int16_t>("cos_f16x4_neon", simsimd_cos_f16x4_neon);
-    register_<std::int8_t>("cos_i8x16_neon", simsimd_cos_i8x16_neon);
-    register_<std::int8_t>("l2sq_i8x16_neon", simsimd_l2sq_i8x16_neon);
-    register_<simsimd_f32_t>("cos_f32x4_neon", simsimd_cos_f32x4_neon);
-    register_<std::uint8_t, 21>("tanimoto_maccs_neon", simsimd_tanimoto_maccs_neon);
-#endif
-
-#if SIMSIMD_TARGET_X86_AVX2
-    register_<simsimd_f32_t>("dot_f32x4_avx2", simsimd_dot_f32x4_avx2);
-    register_<simsimd_f32_t>("cos_f32x4_avx2", simsimd_cos_f32x4_avx2);
-#endif
-
-#if SIMSIMD_TARGET_X86_AVX512
-    register_<std::int16_t>("cos_f16x16_avx512", simsimd_cos_f16x16_avx512);
-    register_<std::uint8_t>("hamming_b1x128_avx512", simsimd_hamming_b1x128_avx512);
-    register_<std::uint8_t, 21>("tanimoto_maccs_avx512", simsimd_tanimoto_maccs_avx512);
-#endif
-
-    bm::RunSpecifiedBenchmarks();
-    bm::Shutdown();
-    return 0;
-}

package/simsimd/include/simsimd/simsimd_bio.h

@@ -1,54 +0,0 @@
-/**
- *  @brief Collection of Biology-oriented Similarity Measures, SIMD-accelerated with SSE, AVX, NEON, SVE.
- *
- *  @author Ash Vardanian
- *  @date August 8, 2023
- */
-
-#pragma once
-
-#include <simsimd/simsimd_chem.h>
-
-#ifdef _MSC_VER
-#define hash32
-#define hash64
-#else
-#define hash32
-#define hash64
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- *  @brief  Used to compute the similarity of two DNA or RNA sequences in "TwoBit" form.
- *
- *  By design uses a separate bit-set for every string, expanding the compressed
- *  representation into bitsets, and then computes the tanimoto distance on those.
- *
- *  Optimal `length_hash` should be derived from `max(a_length, b_length)`, as
- */
-inline static simsimd_f32_t simsimd_tanimoto_twobit( //
-    uint8_t const* a_chars, uint8_t const* b_chars,  //
-    size_t a_length, size_t b_length,                //
-    uint8_t* a_hash, uint8_t* b_hash, size_t length_hash) {
-
-    // uint64 -> 32-gram
-    // uint32 -> 16-gram
-    uint64_t last_word = 0;
-    for (size_t i = 0; i + 8 <= a_length; i += 8) {
-        uint64_t a_word;
-        memcpy(&a_word, a_chars, 8);
-    }
-
-    size_t b_words = (b_length + 7) / 8;
-
-    return simsimd_tanimoto_b1x8_naive(a_hash, b_hash, length_hash);
-}
-
-#undef popcount64
-
-#ifdef __cplusplus
-}
-#endif

package/simsimd/include/simsimd/simsimd_chem.h

@@ -1,167 +0,0 @@
-/**
- *  @brief Collection of Chemistry-oriented Similarity Measures, SIMD-accelerated with SSE, AVX, NEON, SVE.
- *
- *  @author Ashot Vardanian
- *  @date July 1, 2023
- */
-
-#pragma once
-#include <string.h> // `memcpy`
-
-#include <simsimd/simsimd.h>
-
-#ifdef _MSC_VER
-#include <intrin.h>
-#define popcount64 __popcnt64
-#else
-#define popcount64 __builtin_popcountll
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- *  @brief  Optimized version for Tanimoto distance on @b exactly 166 bits,
- *          forming 21 incomplete bytes for the MACCS fingerprints used in
- *          computation chemistry.
- */
-inline static simsimd_f32_t //
-simsimd_tanimoto_maccs_naive(uint8_t const* a_chars, uint8_t const* b_chars) {
-    unsigned long a[3] = {0};
-    unsigned long b[3] = {0};
-    memcpy(&a[0], a_chars, 21);
-    memcpy(&b[0], b_chars, 21);
-    float and_count = popcount64(a[0] & b[0]) + popcount64(a[1] & b[1]) + popcount64(a[2] & b[2]);
-    float or_count = popcount64(a[0] | b[0]) + popcount64(a[1] | b[1]) + popcount64(a[2] | b[2]);
-    return 1 - and_count / or_count;
-}
-
-/**
- *  @brief  Weird Tanimoto distance implementation for concatenated MACCS and ECFP4
- *          representations, forming a grand-total of 56 bytes. The last chunk is evaluated
- *          if only the first one matches well.
- *
- *              - First 166 bits in 21 bytes is a MACCS vector.
- *              - After that 3 empty bytes of a padding are expected.
- *              - After which, 256 bytes (32 words) of ECFP4 follow.
- */
-inline static simsimd_f32_t //
-simsimd_tanimoto_conditional_naive(uint8_t const* a_chars, uint8_t const* b_chars) {
-    float const threshold = 0.2;
-    unsigned long const* a = (unsigned long const*)(a_chars);
-    unsigned long const* b = (unsigned long const*)(b_chars);
-    float and_count = popcount64(a[0] & b[0]) + popcount64(a[1] & b[1]) + popcount64(a[2] & b[2]);
-    float or_count = popcount64(a[0] | b[0]) + popcount64(a[1] | b[1]) + popcount64(a[2] | b[2]);
-    float result = 1 - and_count / or_count;
-    if (result > threshold)
-        return result;
-
-    // Start comparing ECFP4
-    and_count = 0, or_count = 0;
-    for (int i = 0; i != 32; ++i)
-        and_count += popcount64(a[3 + i] & b[3 + i]), or_count += popcount64(a[3 + i] | b[3 + i]);
-    result = 1 - and_count / or_count;
-    return result * threshold;
-}
-
-#if SIMSIMD_TARGET_ARM
-#if SIMSIMD_TARGET_ARM_NEON
-
-/**
- *  @brief  Optimized version for Tanimoto distance on @b exactly 166 bits,
- *          forming 21 incomplete bytes for the MACCS fingerprints used in
- *          computation chemistry, accelerated for Arm NEON ISA.
- */
-inline static simsimd_f32_t //
-simsimd_tanimoto_maccs_neon(uint8_t const* a_chars, uint8_t const* b_chars) {
-    unsigned char a[32] = {0};
-    unsigned char b[32] = {0};
-    memcpy(&a[0], a_chars, 21);
-    memcpy(&b[0], b_chars, 21);
-    uint8x16_t a_first = vld1q_u8(&a[0]);
-    uint8x16_t a_second = vld1q_u8(&a[16]);
-    uint8x16_t b_first = vld1q_u8(&b[0]);
-    uint8x16_t b_second = vld1q_u8(&b[16]);
-    uint8x16_t a_and_b_first = vandq_u8(a_first, b_first);
-    uint8x16_t a_and_b_second = vandq_u8(a_second, b_second);
-    uint8x16_t a_or_b_first = vorrq_u8(a_first, b_first);
-    uint8x16_t a_or_b_second = vorrq_u8(a_second, b_second);
-    float and_populations = vaddvq_u8(vaddq_u8(vcntq_u8(a_and_b_first), vcntq_u8(a_and_b_second)));
-    float or_populations = vaddvq_u8(vaddq_u8(vcntq_u8(a_or_b_first), vcntq_u8(a_or_b_second)));
-    return 1 - and_populations / or_populations;
-}
-
-#endif // SIMSIMD_TARGET_ARM_NEON
-
-#if SIMSIMD_TARGET_ARM_SVE
-
-/**
- *  @brief  Optimized version for Tanimoto distance on @b exactly 166 bits,
- *          forming 21 incomplete bytes for the MACCS fingerprints used in
- *          computation chemistry, accelerated for Arm NEON ISA.
- */
-__attribute__((target("+sve"))) inline static simsimd_f32_t //
-simsimd_tanimoto_maccs_sve(uint8_t const* a_chars, uint8_t const* b_chars) {
-    svbool_t pg_vec = svwhilelt_b8(0ul, 21ul);
-    svuint8_t a_vec = svld1_u8(pg_vec, (uint8_t const*)a_chars);
-    svuint8_t b_vec = svld1_u8(pg_vec, (uint8_t const*)b_chars);
-    svuint8_t a_and_b_vec = svand_u8_m(pg_vec, a_vec, b_vec);
-    svuint8_t a_or_b_vec = svorr_u8_m(pg_vec, a_vec, b_vec);
-    svuint8_t and_populations_vec = svcnt_u8_x(pg_vec, a_and_b_vec);
-    svuint8_t or_populations_vec = svcnt_u8_x(pg_vec, a_or_b_vec);
-
-    // We are gonna need at most two cycles like this, regardless of the architecture,
-    // assuming the SVE registers are at least 128 bits (16 bytes), and we onlu need 21 bytes.
-    pg_vec = svwhilelt_b8(svcntb(), 21ul);
-    a_vec = svld1_u8(pg_vec, (uint8_t const*)a_chars + svcntb());
-    b_vec = svld1_u8(pg_vec, (uint8_t const*)b_chars + svcntb());
-    a_and_b_vec = svand_u8_m(pg_vec, a_vec, b_vec);
-    a_or_b_vec = svorr_u8_m(pg_vec, a_vec, b_vec);
-    and_populations_vec = svadd_u8_m(pg_vec, svcnt_u8_x(pg_vec, a_and_b_vec), and_populations_vec);
-    or_populations_vec = svadd_u8_m(pg_vec, svcnt_u8_x(pg_vec, a_or_b_vec), or_populations_vec);
-
-    float and_populations = svaddv_u8(svptrue_b8(), and_populations_vec);
-    float or_populations = svaddv_u8(svptrue_b8(), or_populations_vec);
-    return 1 - and_populations / or_populations;
-}
-#endif
-#endif // SIMSIMD_TARGET_ARM
-
-#if SIMSIMD_TARGET_X86
-#if SIMSIMD_TARGET_X86_AVX512
-
-/**
- *  @brief  Optimized version for Tanimoto distance on @b exactly 166 bits,
- *          forming 21 incomplete bytes for the MACCS fingerprints used in
- *          computation chemistry, accelerated with AVX-512 population count
- *          instructions.
- */
-__attribute__((target("avx512vpopcntdq")))                     //
-__attribute__((target("avx512vl")))                            //
-__attribute__((target("avx512bw")))                            //
-__attribute__((target("avx512f"))) inline static simsimd_f32_t //
-simsimd_tanimoto_maccs_avx512(uint8_t const* a, uint8_t const* b) {
-    __m256i a_vec = _mm256_maskz_loadu_epi8(0b11111111111111111111100000000000, a);
-    __m256i b_vec = _mm256_maskz_loadu_epi8(0b11111111111111111111100000000000, b);
-    __m256i and_vec = _mm256_and_si256(a_vec, b_vec);
-    __m256i or_vec = _mm256_or_si256(a_vec, b_vec);
-    __m256i and_counts_vec = _mm256_popcnt_epi64(and_vec);
-    __m256i or_counts_vec = _mm256_popcnt_epi64(or_vec);
-
-    float and_counts = _mm256_extract_epi64(and_counts_vec, 0) + _mm256_extract_epi64(and_counts_vec, 1) +
-                       _mm256_extract_epi64(and_counts_vec, 2) + _mm256_extract_epi64(and_counts_vec, 3);
-    float or_counts = _mm256_extract_epi64(or_counts_vec, 0) + _mm256_extract_epi64(or_counts_vec, 1) +
-                      _mm256_extract_epi64(or_counts_vec, 2) + _mm256_extract_epi64(or_counts_vec, 3);
-
-    return 1 - and_counts / or_counts;
-}
-
-#endif // SIMSIMD_TARGET_X86_AVX512
-#endif // SIMSIMD_TARGET_X86
-
-#undef popcount64
-
-#ifdef __cplusplus
-}
-#endif