usearch 2.9.2 → 2.10.0

package/simsimd/include/simsimd/binary.h

@@ -1,245 +0,0 @@
-/**
- *  @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/
- */
-#ifndef SIMSIMD_BINARY_H
-#define SIMSIMD_BINARY_H
-
-#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,bmi2"))) //
-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();
-    __m512i a_vec, b_vec;
-
-simsimd_avx512_b8_hamming_cycle:
-    if (n_words < 64) {
-        __mmask64 mask = _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_avx512_b8_hamming_cycle;
-
-    simsimd_size_t differences = _mm512_reduce_add_epi64(differences_vec);
-    return (simsimd_f32_t)differences;
-}
-
-__attribute__((target("avx512vpopcntdq,avx512vl,avx512bw,avx512f,bmi2"))) //
-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();
-    __m512i a_vec, b_vec;
-
-simsimd_avx512_b8_jaccard_cycle:
-    if (n_words < 64) {
-        __mmask64 mask = _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_avx512_b8_jaccard_cycle;
-
-    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
-
-/*
- *  @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
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

package/simsimd/include/simsimd/complex.h

@@ -1,174 +0,0 @@
-/**
- *  @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