usearch 0.22.3 → 1.0.0

package/simsimd/include/simsimd/simsimd.h

@@ -12,6 +12,7 @@
 #pragma once
 #include <math.h>   // `sqrt`
 #include <stddef.h> // `size_t`
+#include <stdint.h>
 
 #if defined(__AVX2__)
 #include <immintrin.h>
@@ -25,6 +26,13 @@
 #include <arm_sve.h>
 #endif
 
+#ifdef _MSC_VER
+#include <intrin.h>
+#define popcount32 __popcnt
+#else
+#define popcount32 __builtin_popcount
+#endif
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -38,7 +46,7 @@ union simsimd_f32i32_t {
     float f;
 };
 
-inline static simsimd_f32_t simsimd_dot_f32sve(simsimd_f32_t const* a, simsimd_f32_t const* b, size_t d) {
+inline static simsimd_f32_t simsimd_dot_f32_sve(simsimd_f32_t const* a, simsimd_f32_t const* b, size_t d) {
 #if defined(__ARM_FEATURE_SVE)
     size_t i = 0;
     svfloat32_t ab_vec = svdupq_n_f32(0.f, 0.f, 0.f, 0.f);
@@ -50,14 +58,14 @@ inline static simsimd_f32_t simsimd_dot_f32sve(simsimd_f32_t const* a, simsimd_f
         i += svcntw();
         pg_vec = svwhilelt_b32(i, d);
     } while (svptest_any(svptrue_b32(), pg_vec));
-    return svaddv_f32(svptrue_b32(), ab_vec);
+    return 1 - svaddv_f32(svptrue_b32(), ab_vec);
 #else
     (void)a, (void)b, (void)d;
-    return 0;
+    return -1;
 #endif
 }
 
-inline static simsimd_f32_t simsimd_cos_f32sve(simsimd_f32_t const* a, simsimd_f32_t const* b, size_t d) {
+inline static simsimd_f32_t simsimd_cos_f32_sve(simsimd_f32_t const* a, simsimd_f32_t const* b, size_t d) {
 #if defined(__ARM_FEATURE_SVE)
     size_t i = 0;
     svfloat32_t ab_vec = svdupq_n_f32(0.f, 0.f, 0.f, 0.f);
@@ -76,14 +84,14 @@ inline static simsimd_f32_t simsimd_cos_f32sve(simsimd_f32_t const* a, simsimd_f
     simsimd_f32_t ab = svaddv_f32(svptrue_b32(), ab_vec);
     simsimd_f32_t a2 = svaddv_f32(svptrue_b32(), a2_vec);
     simsimd_f32_t b2 = svaddv_f32(svptrue_b32(), b2_vec);
-    return ab / (sqrt(a2) * sqrt(b2));
+    return 1 - ab / (sqrt(a2) * sqrt(b2));
 #else
     (void)a, (void)b, (void)d;
-    return 0;
+    return -1;
 #endif
 }
 
-inline static simsimd_f32_t simsimd_l2sq_f32sve(simsimd_f32_t const* a, simsimd_f32_t const* b, size_t d) {
+inline static simsimd_f32_t simsimd_l2sq_f32_sve(simsimd_f32_t const* a, simsimd_f32_t const* b, size_t d) {
 #if defined(__ARM_FEATURE_SVE)
     size_t i = 0;
     svfloat32_t d2_vec = svdupq_n_f32(0.f, 0.f, 0.f, 0.f);
@@ -100,11 +108,39 @@ inline static simsimd_f32_t simsimd_l2sq_f32sve(simsimd_f32_t const* a, simsimd_
     return sqrt(d2);
 #else
     (void)a, (void)b, (void)d;
-    return 0;
+    return -1;
 #endif
 }
 
-inline static simsimd_f16_t simsimd_l2sq_f16sve(simsimd_f16_t const* a_enum, simsimd_f16_t const* b_enum, size_t d) {
+inline static simsimd_f32_t simsimd_cos_f16_sve(simsimd_f16_t const* a_enum, simsimd_f16_t const* b_enum, size_t d) {
+#if defined(__ARM_FEATURE_SVE)
+    size_t i = 0;
+    svfloat16_t ab_vec = svdupq_n_f16(0, 0, 0, 0, 0, 0, 0, 0);
+    svfloat16_t a2_vec = svdupq_n_f16(0, 0, 0, 0, 0, 0, 0, 0);
+    svfloat16_t b2_vec = svdupq_n_f16(0, 0, 0, 0, 0, 0, 0, 0);
+    svbool_t pg_vec = svwhilelt_b16(i, d);
+    simsimd_f16_t const* a = (simsimd_f16_t const*)(a_enum);
+    simsimd_f16_t const* b = (simsimd_f16_t const*)(b_enum);
+    do {
+        svfloat16_t a_vec = svld1_f16(pg_vec, (float16_t const*)a + i);
+        svfloat16_t b_vec = svld1_f16(pg_vec, (float16_t const*)b + i);
+        ab_vec = svmla_f16_x(pg_vec, ab_vec, a_vec, b_vec);
+        a2_vec = svmla_f16_x(pg_vec, a2_vec, a_vec, a_vec);
+        b2_vec = svmla_f16_x(pg_vec, b2_vec, b_vec, b_vec);
+        i += svcnth();
+        pg_vec = svwhilelt_b16(i, d);
+    } while (svptest_any(svptrue_b16(), pg_vec));
+    simsimd_f16_t ab = svaddv_f16(svptrue_b16(), ab_vec);
+    simsimd_f16_t a2 = svaddv_f16(svptrue_b16(), a2_vec);
+    simsimd_f16_t b2 = svaddv_f16(svptrue_b16(), b2_vec);
+    return 1 - ab / (sqrt(a2) * sqrt(b2));
+#else
+    (void)a_enum, (void)b_enum, (void)d;
+    return -1;
+#endif
+}
+
+inline static simsimd_f32_t simsimd_l2sq_f16_sve(simsimd_f16_t const* a_enum, simsimd_f16_t const* b_enum, size_t d) {
 #if defined(__ARM_FEATURE_SVE)
     size_t i = 0;
     svfloat16_t d2_vec = svdupq_n_f16(0, 0, 0, 0, 0, 0, 0, 0);
@@ -120,16 +156,14 @@ inline static simsimd_f16_t simsimd_l2sq_f16sve(simsimd_f16_t const* a_enum, sim
         pg_vec = svwhilelt_b16(i, d);
     } while (svptest_any(svptrue_b16(), pg_vec));
     float16_t f16 = svaddv_f16(svptrue_b16(), d2_vec);
-    simsimd_f16_t i16;
-    memcpy(&i16, &f16, sizeof(i16));
-    return i16;
+    return 1 - simsimd_f32_t(f16);
 #else
     (void)a_enum, (void)b_enum, (void)d;
-    return 0;
+    return -1;
 #endif
 }
 
-inline static size_t simsimd_hamming_b1x8sve(uint8_t const* a, uint8_t const* b, size_t d) {
+inline static simsimd_f32_t simsimd_hamming_b1x8_sve(uint8_t const* a, uint8_t const* b, size_t d) {
 #if defined(__ARM_FEATURE_SVE)
     size_t i = 0;
     svuint8_t d_vec = svdupq_n_u8(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
@@ -142,26 +176,26 @@ inline static size_t simsimd_hamming_b1x8sve(uint8_t const* a, uint8_t const* b,
         i += svcntb() * __CHAR_BIT__;
         pg_vec = svwhilelt_b32(i, d);
     } while (svptest_any(svptrue_b32(), pg_vec));
-    return svaddv_u8(svptrue_b32(), d_vec);
+    return 1 - svaddv_u8(svptrue_b32(), d_vec);
 #else
     (void)a, (void)b, (void)d;
-    return 0;
+    return -1;
 #endif
 }
 
-inline static simsimd_f32_t simsimd_dot_f32x4neon(simsimd_f32_t const* a, simsimd_f32_t const* b, size_t d) {
+inline static simsimd_f32_t simsimd_dot_f32x4_neon(simsimd_f32_t const* a, simsimd_f32_t const* b, size_t d) {
 #if defined(__ARM_NEON)
     float32x4_t ab_vec = vdupq_n_f32(0);
     for (size_t i = 0; i != d; i += 4)
         ab_vec = vfmaq_f32(ab_vec, vld1q_f32(a + i), vld1q_f32(b + i));
-    return vaddvq_f32(ab_vec);
+    return 1 - vaddvq_f32(ab_vec);
 #else
     (void)a, (void)b, (void)d;
-    return 0;
+    return -1;
 #endif
 }
 
-inline static simsimd_f32_t simsimd_cos_f16x4neon(simsimd_f16_t const* a, simsimd_f16_t const* b, size_t d) {
+inline static simsimd_f32_t simsimd_cos_f16x4_neon(simsimd_f16_t const* a, simsimd_f16_t const* b, size_t d) {
 #if defined(__ARM_NEON)
     float32x4_t ab_vec = vdupq_n_f32(0);
     float32x4_t a2_vec = vdupq_n_f32(0);
@@ -177,14 +211,14 @@ inline static simsimd_f32_t simsimd_cos_f16x4neon(simsimd_f16_t const* a, simsim
     simsimd_f32_t ab = vaddvq_f32(ab_vec);
     simsimd_f32_t a2 = vaddvq_f32(a2_vec);
     simsimd_f32_t b2 = vaddvq_f32(b2_vec);
-    return ab / (sqrt(a2) * sqrt(b2));
+    return 1 - ab / (sqrt(a2) * sqrt(b2));
 #else
     (void)a, (void)b, (void)d;
-    return 0;
+    return -1;
 #endif
 }
 
-inline static simsimd_f32_t simsimd_cos_i8x16neon(int8_t const* a, int8_t const* b, size_t d) {
+inline static simsimd_f32_t simsimd_cos_i8x16_neon(int8_t const* a, int8_t const* b, size_t d) {
 #if defined(__ARM_NEON)
     int32x4_t ab_vec = vdupq_n_s32(0);
     int32x4_t a2_vec = vdupq_n_s32(0);
@@ -205,11 +239,11 @@ inline static simsimd_f32_t simsimd_cos_i8x16neon(int8_t const* a, int8_t const*
         int16x8_t ab_part_vec = vmulq_s16(a_vec, b_vec);
         int16x8_t a2_part_vec = vmulq_s16(a_vec, a_vec);
         int16x8_t b2_part_vec = vmulq_s16(b_vec, b_vec);
-        ab_vec =
+        ab_vec = //
             vaddq_s32(ab_vec, vaddq_s32(vmovl_s16(vget_high_s16(ab_part_vec)), vmovl_s16(vget_low_s16(ab_part_vec))));
-        a2_vec =
+        a2_vec = //
             vaddq_s32(a2_vec, vaddq_s32(vmovl_s16(vget_high_s16(a2_part_vec)), vmovl_s16(vget_low_s16(a2_part_vec))));
-        b2_vec =
+        b2_vec = //
             vaddq_s32(b2_vec, vaddq_s32(vmovl_s16(vget_high_s16(b2_part_vec)), vmovl_s16(vget_low_s16(b2_part_vec))));
     }
 #endif
@@ -220,14 +254,14 @@ inline static simsimd_f32_t simsimd_cos_i8x16neon(int8_t const* a, int8_t const*
     int32_t a2 = vget_lane_s32(vpadd_s32(a2_part, a2_part), 0);
     int32x2_t b2_part = vadd_s32(vget_high_s32(b2_vec), vget_low_s32(b2_vec));
     int32_t b2 = vget_lane_s32(vpadd_s32(b2_part, b2_part), 0);
-    return ab / (sqrt(a2) * sqrt(b2));
+    return 1 - ab / (sqrt(a2) * sqrt(b2));
 #else
     (void)a, (void)b, (void)d;
-    return 0;
+    return -1;
 #endif
 }
 
-inline static simsimd_f32_t simsimd_cos_f32x4neon(simsimd_f32_t const* a, simsimd_f32_t const* b, size_t d) {
+inline static simsimd_f32_t simsimd_cos_f32x4_neon(simsimd_f32_t const* a, simsimd_f32_t const* b, size_t d) {
 #if defined(__ARM_NEON)
     float32x4_t ab_vec = vdupq_n_f32(0);
     float32x4_t a2_vec = vdupq_n_f32(0);
@@ -242,14 +276,14 @@ inline static simsimd_f32_t simsimd_cos_f32x4neon(simsimd_f32_t const* a, simsim
     simsimd_f32_t ab = vaddvq_f32(ab_vec);
     simsimd_f32_t a2 = vaddvq_f32(a2_vec);
     simsimd_f32_t b2 = vaddvq_f32(b2_vec);
-    return ab / (sqrt(a2) * sqrt(b2));
+    return 1 - ab / (sqrt(a2) * sqrt(b2));
 #else
     (void)a, (void)b, (void)d;
-    return 0;
+    return -1;
 #endif
 }
 
-inline static size_t simsimd_hamming_b1x128sve(uint8_t const* a, uint8_t const* b, size_t d) {
+inline static simsimd_f32_t simsimd_hamming_b1x128_sve(uint8_t const* a, uint8_t const* b, size_t d) {
 #if defined(__ARM_NEON)
     /// Contains 16x 8-bit integers with running population count sums.
     uint8x16_t d_vec = vdupq_n_u8(0);
@@ -259,14 +293,14 @@ inline static size_t simsimd_hamming_b1x128sve(uint8_t const* a, uint8_t const*
         uint8x16_t a_xor_b_vec = veorq_u8(a_vec, b_vec);
         d_vec = vaddq_u8(d_vec, vcntq_u8(a_xor_b_vec));
     }
-    return vaddvq_u8(d_vec);
+    return 1 - vaddvq_u8(d_vec);
 #else
     (void)a, (void)b, (void)d;
-    return 0;
+    return -1;
 #endif
 }
 
-inline static simsimd_f32_t simsimd_dot_f32x4avx2(simsimd_f32_t const* a, simsimd_f32_t const* b, size_t d) {
+inline static simsimd_f32_t simsimd_dot_f32x4_avx2(simsimd_f32_t const* a, simsimd_f32_t const* b, size_t d) {
 #if defined(__AVX2__)
     __m128 ab_vec = _mm_set1_ps(0);
     for (size_t i = 0; i != d; i += 4)
@@ -275,14 +309,14 @@ inline static simsimd_f32_t simsimd_dot_f32x4avx2(simsimd_f32_t const* a, simsim
     ab_vec = _mm_hadd_ps(ab_vec, ab_vec);
     simsimd_f32i32_t ab_union;
     ab_union.i = _mm_cvtsi128_si32(_mm_castps_si128(ab_vec));
-    return ab_union.f;
+    return 1 - ab_union.f;
 #else
     (void)a, (void)b, (void)d;
-    return 0;
+    return -1;
 #endif
 }
 
-inline static simsimd_f32_t simsimd_cos_f16x16avx512(simsimd_f16_t const* a, simsimd_f16_t const* b, size_t d) {
+inline static simsimd_f32_t simsimd_cos_f16x16_avx512(simsimd_f16_t const* a, simsimd_f16_t const* b, size_t d) {
 #if defined(__AVX512F__)
     __m512 ab_vec = _mm512_set1_ps(0);
     __m512 a2_vec = _mm512_set1_ps(0);
@@ -297,35 +331,14 @@ inline static simsimd_f32_t simsimd_cos_f16x16avx512(simsimd_f16_t const* a, sim
     simsimd_f32_t ab = _mm512_reduce_add_ps(ab_vec);
     simsimd_f32_t a2 = _mm512_reduce_add_ps(a2_vec);
     simsimd_f32_t b2 = _mm512_reduce_add_ps(b2_vec);
-    return ab / (sqrt(a2) * sqrt(b2));
+    return 1 - ab / (sqrt(a2) * sqrt(b2));
 #else
     (void)a, (void)b, (void)d;
-    return 0;
+    return -1;
 #endif
 }
 
-inline static int32_t simsimd_dot_i8x16avx2(int8_t const* a, int8_t const* b, size_t d) {
-#if defined(__AVX2__)
-    __m256i ab_vec = _mm256_set1_epi32(0);
-    for (size_t i = 0; i != d; i += 8) {
-        ab_vec = _mm256_add_epi32(     //
-            ab_vec, _mm256_madd_epi16( //
-                        _mm256_cvtepi8_epi16(_mm_loadu_si128((__m128i const*)(a + i))),
-                        _mm256_cvtepi8_epi16(_mm_loadu_si128((__m128i const*)(b + i)))));
-    }
-    ab_vec = _mm256_hadd_epi32(ab_vec, ab_vec);
-    ab_vec = _mm256_hadd_epi32(ab_vec, ab_vec);
-    ab_vec = _mm256_hadd_epi32(ab_vec, ab_vec);
-    simsimd_f32i32_t ab_union;
-    ab_union.f = _mm256_cvtss_f32(_mm256_castsi256_ps(ab_vec));
-    return ab_union.i;
-#else
-    (void)a, (void)b, (void)d;
-    return 0;
-#endif
-}
-
-inline static simsimd_f32_t simsimd_cos_f32x4avx2(simsimd_f32_t const* a, simsimd_f32_t const* b, size_t d) {
+inline static simsimd_f32_t simsimd_cos_f32x4_avx2(simsimd_f32_t const* a, simsimd_f32_t const* b, size_t d) {
 #if defined(__AVX2__)
     __m128 ab_vec = _mm_set1_ps(0);
     __m128 a2_vec = _mm_set1_ps(0);
@@ -346,14 +359,14 @@ inline static simsimd_f32_t simsimd_cos_f32x4avx2(simsimd_f32_t const* a, simsim
     simsimd_f32i32_t ab_union = {_mm_cvtsi128_si32(_mm_castps_si128(ab_vec))};
     simsimd_f32i32_t a2_union = {_mm_cvtsi128_si32(_mm_castps_si128(a2_vec))};
     simsimd_f32i32_t b2_union = {_mm_cvtsi128_si32(_mm_castps_si128(b2_vec))};
-    return ab_union.f / (sqrt(a2_union.f) * sqrt(b2_union.f));
+    return 1 - ab_union.f / (sqrt(a2_union.f) * sqrt(b2_union.f));
 #else
     (void)a, (void)b, (void)d;
-    return 0;
+    return -1;
 #endif
 }
 
-inline static size_t simsimd_hamming_b1x128avx512(uint8_t const* a, uint8_t const* b, size_t d) {
+inline static simsimd_f32_t simsimd_hamming_b1x128_avx512(uint8_t const* a, uint8_t const* b, size_t d) {
 #if defined(__AVX512VPOPCNTDQ__)
     size_t words = d / 128;
     uint64_t const* a64 = (uint64_t const*)(a);
@@ -369,10 +382,19 @@ inline static size_t simsimd_hamming_b1x128avx512(uint8_t const* a, uint8_t cons
     return _mm_cvtm64_si64(_mm_movepi64_pi64(d_vec)) + _mm_extract_epi64(d_vec, 1);
 #else
     (void)a, (void)b, (void)d;
-    return 0;
+    return -1;
 #endif
 }
 
+inline static simsimd_f32_t simsimd_tanimoto_b1x8_naive(uint8_t const* a, uint8_t const* b, size_t d) {
+    size_t and_count = 0, or_count = 0;
+    for (size_t i = 0; i != d; ++i)
+        and_count += popcount32(a[i] & b[i]), or_count += popcount32(a[i] | b[i]);
+    return 1 - (simsimd_f32_t)(and_count) / or_count;
+}
+
+#undef popcount32
+
 #ifdef __cplusplus
 }
 #endif

package/simsimd/include/simsimd/simsimd_chem.h

@@ -0,0 +1,126 @@
+/**
+ *  @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  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) {
+#if defined(__ARM_NEON)
+    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;
+#else
+    (void)a_chars, (void)b_chars;
+    return 0;
+#endif
+}
+
+/**
+ *  @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_sve(uint8_t const* a_chars, uint8_t const* b_chars) {
+#if defined(__ARM_FEATURE_SVE)
+    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;
+#else
+    (void)a_chars, (void)b_chars;
+    return 0;
+#endif
+}
+
+/**
+ *  @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.
+ */
+inline static simsimd_f32_t simsimd_tanimoto_maccs_avx512(uint8_t const* a, uint8_t const* b) {
+#if defined(__AVX512VPOPCNTDQ__)
+    __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 = _mm256_popcnt_epi8(and_vec);
+    __m256i or_counts = _mm256_popcnt_epi8(or_vec);
+    return 1 - float(_mm256_reduce_add_epi8(and_counts)) / _mm256_reduce_add_epi8(or_counts);
+#else
+    (void)a, (void)b;
+    return 0;
+#endif
+}
+
+#undef popcount64
+
+#ifdef __cplusplus
+}
+#endif

package/simsimd/package.json

@@ -0,0 +1,8 @@
+{
+  "devDependencies": {
+    "@semantic-release/exec": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "conventional-changelog-eslint": "^4.0.0",
+    "semantic-release": "^21.0.7"
+  }
+}

package/simsimd/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=42", "wheel", "cmake>=3.22", "pybind11"]
+build-backend = "setuptools.build_meta"
+
+[tool.pytest.ini_options]
+minversion = "6.0"
+addopts = ["-ra", "--showlocals", "--strict-markers", "--strict-config"]
+xfail_strict = true
+filterwarnings = ["error"]
+
+[tool.cibuildwheel]
+test-requires = ["pytest"]
+test-command = "pytest {project}/python/test.py -x"
+build-verbosity = 0
+skip = ["*musllinux*", "*i686*", "pp*"]
+
+[tool.cibuildwheel.linux]
+before-build = [
+    "rm -rf {project}/build",
+]
+manylinux-x86_64-image = "manylinux_2_28"
+manylinux-aarch64-image = "manylinux_2_28"
+
+archs = ["x86_64", "aarch64"]
+before-all = [
+    "yum install -y glibc-devel wget python3-devel"
+]
+repair-wheel-command = "auditwheel repair --lib-sdir . -w {dest_dir} {wheel}"
+
+[tool.cibuildwheel.macos]
+before-build = [
+    "rm -rf {project}/build",
+]
+archs = ["x86_64", "universal2", "arm64"]
+repair-wheel-command = "delocate-wheel --require-archs {delocate_archs} -w {dest_dir} -v {wheel}"
+
+[tool.cibuildwheel.windows]
+before-build = [
+   "rd /s /q {project}\\build || echo Done",
+]
+archs = ["x86", "AMD64"]
+skip = ["*win32*", "pp*"]

package/simsimd/python/python.c

@@ -0,0 +1,81 @@
+/**
+ *  @file python.c
+ *  @author Ashot Vardanian
+ *  @date 2023-01-30
+ *  @copyright Copyright (c) 2023
+ *
+ *  @brief Pure CPython bindings for simsimd.
+ */
+
+#include "simsimd/simsimd.h"
+#include "simsimd/simsimd_chem.h"
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+static void pseudo_destroy(PyObject* obj) { (void)obj; }
+
+PyObject* distance(void* func) { return PyCapsule_New(func, NULL, pseudo_destroy); }
+
+static PyObject* to_int(PyObject* self, PyObject* args) {
+    PyObject* capsule;
+    if (!PyArg_ParseTuple(args, "O", &capsule)) {
+        return NULL;
+    }
+
+    if (!PyCapsule_IsValid(capsule, NULL)) {
+        PyErr_SetString(PyExc_ValueError, "Object is not a valid capsule");
+        return NULL;
+    }
+
+    void* pointer = PyCapsule_GetPointer(capsule, NULL);
+
+    return PyLong_FromVoidPtr(pointer);
+}
+
+static PyMethodDef simsimd_methods[] = {
+    {"to_int", (PyCFunction)to_int, METH_VARARGS, "Converts CPython capsule to `int`"},
+    {NULL, NULL, 0, NULL} /* Sentinel */
+};
+
+static PyModuleDef simsimd_module = {
+    PyModuleDef_HEAD_INIT,
+    .m_name = "SimSIMD",
+    .m_doc = "SIMD-accelerated similarity measures for x86 and Arm: AVX2, AVX512, NEON, SVE",
+    .m_size = -1,
+    .m_methods = simsimd_methods,
+};
+
+PyMODINIT_FUNC PyInit_simsimd(void) {
+    PyObject* m = PyModule_Create(&simsimd_module);
+    if (m == NULL)
+        return NULL;
+
+    PyModule_AddObject(m, "dot_f32_sve", distance(&simsimd_dot_f32_sve));
+    PyModule_AddObject(m, "dot_f32x4_neon", distance(&simsimd_dot_f32x4_neon));
+
+    PyModule_AddObject(m, "cos_f32_sve", distance(&simsimd_cos_f32_sve));
+    PyModule_AddObject(m, "cos_f16_sve", distance(&simsimd_cos_f16_sve));
+    PyModule_AddObject(m, "cos_f16x4_neon", distance(&simsimd_cos_f16x4_neon));
+    PyModule_AddObject(m, "cos_i8x16_neon", distance(&simsimd_cos_i8x16_neon));
+    PyModule_AddObject(m, "cos_f32x4_neon", distance(&simsimd_cos_f32x4_neon));
+    PyModule_AddObject(m, "cos_f16x16_avx512", distance(&simsimd_cos_f16x16_avx512));
+    PyModule_AddObject(m, "cos_f32x4_avx2", distance(&simsimd_cos_f32x4_avx2));
+
+    PyModule_AddObject(m, "l2sq_f32_sve", distance(&simsimd_l2sq_f32_sve));
+    PyModule_AddObject(m, "l2sq_f16_sve", distance(&simsimd_l2sq_f16_sve));
+
+    PyModule_AddObject(m, "hamming_b1x8_sve", distance(&simsimd_hamming_b1x8_sve));
+    PyModule_AddObject(m, "hamming_b1x128_sve", distance(&simsimd_hamming_b1x128_sve));
+    PyModule_AddObject(m, "hamming_b1x128_avx512", distance(&simsimd_hamming_b1x128_avx512));
+
+    PyModule_AddObject(m, "tanimoto_b1x8_naive", distance(&simsimd_tanimoto_b1x8_naive));
+
+    // Specific vector sizes for chemistry
+    PyModule_AddObject(m, "tanimoto_maccs_naive", distance(&simsimd_tanimoto_maccs_naive));
+    PyModule_AddObject(m, "tanimoto_maccs_neon", distance(&simsimd_tanimoto_maccs_neon));
+    PyModule_AddObject(m, "tanimoto_maccs_sve", distance(&simsimd_tanimoto_maccs_sve));
+    PyModule_AddObject(m, "tanimoto_maccs_avx512", distance(&simsimd_tanimoto_maccs_avx512));
+
+    return m;
+}

package/simsimd/python/run.sh

@@ -0,0 +1 @@
+pip install --upgrade --force-reinstall . && pytest --capture=no python/tests/