usearch 2.21.4 → 2.25.1

package/numkong/include/numkong/set/serial.h

@@ -0,0 +1,174 @@
+/**
+ *  @brief SWAR-accelerated Set Similarity Measures for SIMD-free CPUs.
+ *  @file include/numkong/set/serial.h
+ *  @author Ash Vardanian
+ *  @date December 27, 2025
+ *
+ *  @sa include/numkong/set.h
+ *
+ *  @section set_serial_instructions Key SWAR Set Instructions
+ *
+ *  Serial backend uses lookup-table-based popcount for bit operations.
+ *  No SIMD instructions required - works on any architecture.
+ *
+ *  @section set_serial_stateful Stateful Streaming Logic
+ *
+ *  To build memory-optimal tiled algorithms, this file defines:
+ *
+ *  - nk_hamming_u1x128_state_serial_t for streaming Hamming distance
+ *  - nk_jaccard_u1x128_state_serial_t for streaming Jaccard similarity
+ *
+ *  @code{c}
+ *  nk_jaccard_u1x128_state_serial_t state_first, state_second, state_third, state_fourth;
+ *  nk_jaccard_u1x128_init_serial(&state_first);
+ *  // ... stream through packed binary vectors ...
+ *  nk_jaccard_u1x128_finalize_serial(&state_first, &state_second, &state_third, &state_fourth,
+ *      query_popcount, target_popcount_a, target_popcount_b, target_popcount_c, target_popcount_d,
+ *      total_dimensions, &results);
+ *  @endcode
+ */
+#ifndef NK_SET_SERIAL_H
+#define NK_SET_SERIAL_H
+#include "numkong/types.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#pragma region Binary Sets
+
+NK_PUBLIC void nk_hamming_u1_serial(nk_u1x8_t const *a, nk_u1x8_t const *b, nk_size_t n, nk_u32_t *result) {
+    nk_size_t n_bytes = nk_size_divide_round_up_(n, NK_BITS_PER_BYTE);
+    nk_u32_t differences = 0;
+    for (nk_size_t i = 0; i != n_bytes; ++i) differences += nk_u1x8_popcount_(a[i] ^ b[i]);
+    *result = differences;
+}
+
+NK_PUBLIC void nk_jaccard_u1_serial(nk_u1x8_t const *a, nk_u1x8_t const *b, nk_size_t n, nk_f32_t *result) {
+    nk_size_t n_bytes = nk_size_divide_round_up_(n, NK_BITS_PER_BYTE);
+    nk_u32_t intersection_count = 0, union_count = 0;
+    for (nk_size_t i = 0; i != n_bytes; ++i)
+        intersection_count += nk_u1x8_popcount_(a[i] & b[i]), union_count += nk_u1x8_popcount_(a[i] | b[i]);
+    *result = (union_count != 0) ? 1.0f - (nk_f32_t)intersection_count / (nk_f32_t)union_count : 0.0f;
+}
+
+#pragma endregion Binary Sets
+
+#pragma region Integer Sets
+
+NK_PUBLIC void nk_jaccard_u32_serial(nk_u32_t const *a, nk_u32_t const *b, nk_size_t n, nk_f32_t *result) {
+    nk_u32_t intersection_count = 0;
+    for (nk_size_t i = 0; i != n; ++i) intersection_count += (a[i] == b[i]);
+    *result = (n != 0) ? 1.0f - (nk_f32_t)intersection_count / (nk_f32_t)n : 0.0f;
+}
+
+NK_PUBLIC void nk_hamming_u8_serial(nk_u8_t const *a, nk_u8_t const *b, nk_size_t n, nk_u32_t *result) {
+    nk_u32_t differences = 0;
+    for (nk_size_t i = 0; i != n; ++i) differences += (a[i] != b[i]);
+    *result = differences;
+}
+
+NK_PUBLIC void nk_jaccard_u16_serial(nk_u16_t const *a, nk_u16_t const *b, nk_size_t n, nk_f32_t *result) {
+    nk_u32_t matches = 0;
+    for (nk_size_t i = 0; i != n; ++i) matches += (a[i] == b[i]);
+    *result = (n != 0) ? 1.0f - (nk_f32_t)matches / (nk_f32_t)n : 0.0f;
+}
+
+#pragma endregion Integer Sets
+
+#pragma region Stateful Streaming
+
+typedef struct nk_jaccard_u1x128_state_serial_t {
+    nk_u64_t intersection_count;
+} nk_jaccard_u1x128_state_serial_t;
+
+NK_INTERNAL void nk_jaccard_u1x128_init_serial(nk_jaccard_u1x128_state_serial_t *state) {
+    state->intersection_count = 0;
+}
+
+NK_INTERNAL void nk_jaccard_u1x128_update_serial(nk_jaccard_u1x128_state_serial_t *state, nk_b128_vec_t a,
+                                                 nk_b128_vec_t b, nk_size_t depth_offset, nk_size_t active_dimensions) {
+    nk_unused_(depth_offset);
+    nk_unused_(active_dimensions);
+    nk_u64_t intersection_low = a.u64s[0] & b.u64s[0];
+    nk_u64_t intersection_high = a.u64s[1] & b.u64s[1];
+    state->intersection_count += nk_u64_popcount_(intersection_low);
+    state->intersection_count += nk_u64_popcount_(intersection_high);
+}
+
+NK_INTERNAL void nk_jaccard_u1x128_finalize_serial( //
+    nk_jaccard_u1x128_state_serial_t const *state_a, nk_jaccard_u1x128_state_serial_t const *state_b,
+    nk_jaccard_u1x128_state_serial_t const *state_c, nk_jaccard_u1x128_state_serial_t const *state_d,
+    nk_f32_t query_popcount, nk_f32_t target_popcount_a, nk_f32_t target_popcount_b, nk_f32_t target_popcount_c,
+    nk_f32_t target_popcount_d, nk_size_t total_dimensions, nk_b128_vec_t *result) {
+    nk_unused_(total_dimensions);
+
+    nk_f32_t intersection_a = (nk_f32_t)state_a->intersection_count;
+    nk_f32_t intersection_b = (nk_f32_t)state_b->intersection_count;
+    nk_f32_t intersection_c = (nk_f32_t)state_c->intersection_count;
+    nk_f32_t intersection_d = (nk_f32_t)state_d->intersection_count;
+
+    nk_f32_t union_a = query_popcount + target_popcount_a - intersection_a;
+    nk_f32_t union_b = query_popcount + target_popcount_b - intersection_b;
+    nk_f32_t union_c = query_popcount + target_popcount_c - intersection_c;
+    nk_f32_t union_d = query_popcount + target_popcount_d - intersection_d;
+
+    result->f32s[0] = (union_a != 0) ? 1.0f - intersection_a / union_a : 0.0f;
+    result->f32s[1] = (union_b != 0) ? 1.0f - intersection_b / union_b : 0.0f;
+    result->f32s[2] = (union_c != 0) ? 1.0f - intersection_c / union_c : 0.0f;
+    result->f32s[3] = (union_d != 0) ? 1.0f - intersection_d / union_d : 0.0f;
+}
+
+typedef struct nk_hamming_u1x128_state_serial_t {
+    nk_u64_t intersection_count;
+} nk_hamming_u1x128_state_serial_t;
+
+NK_INTERNAL void nk_hamming_u1x128_init_serial(nk_hamming_u1x128_state_serial_t *state) {
+    state->intersection_count = 0;
+}
+
+NK_INTERNAL void nk_hamming_u1x128_update_serial(nk_hamming_u1x128_state_serial_t *state, nk_b128_vec_t a,
+                                                 nk_b128_vec_t b, nk_size_t depth_offset, nk_size_t active_dimensions) {
+    nk_unused_(depth_offset);
+    nk_unused_(active_dimensions);
+    nk_u64_t intersection_low = a.u64s[0] ^ b.u64s[0];
+    nk_u64_t intersection_high = a.u64s[1] ^ b.u64s[1];
+    state->intersection_count += nk_u64_popcount_(intersection_low);
+    state->intersection_count += nk_u64_popcount_(intersection_high);
+}
+
+NK_INTERNAL void nk_hamming_u1x128_finalize_serial( //
+    nk_hamming_u1x128_state_serial_t const *state_a, nk_hamming_u1x128_state_serial_t const *state_b,
+    nk_hamming_u1x128_state_serial_t const *state_c, nk_hamming_u1x128_state_serial_t const *state_d,
+    nk_size_t total_dimensions, nk_b128_vec_t *result) {
+    nk_unused_(total_dimensions);
+
+    result->u32s[0] = (nk_u32_t)state_a->intersection_count;
+    result->u32s[1] = (nk_u32_t)state_b->intersection_count;
+    result->u32s[2] = (nk_u32_t)state_c->intersection_count;
+    result->u32s[3] = (nk_u32_t)state_d->intersection_count;
+}
+
+/** @brief Hamming from_dot: computes pop_a + pop_b - 2*dot for 4 pairs (serial). */
+NK_INTERNAL void nk_hamming_u32x4_from_dot_serial_(nk_b128_vec_t dots, nk_u32_t query_pop, nk_b128_vec_t target_pops,
+                                                   nk_b128_vec_t *results) {
+    for (int i = 0; i < 4; ++i) results->u32s[i] = query_pop + target_pops.u32s[i] - 2 * dots.u32s[i];
+}
+
+/** @brief Jaccard from_dot: computes 1 - dot / (pop_a + pop_b - dot) for 4 pairs (serial). */
+NK_INTERNAL void nk_jaccard_f32x4_from_dot_serial_(nk_b128_vec_t dots, nk_u32_t query_pop, nk_b128_vec_t target_pops,
+                                                   nk_b128_vec_t *results) {
+    for (int i = 0; i < 4; ++i) {
+        nk_f32_t dot = (nk_f32_t)dots.u32s[i];
+        nk_f32_t union_val = (nk_f32_t)query_pop + (nk_f32_t)target_pops.u32s[i] - dot;
+        results->f32s[i] = (union_val != 0) ? 1.0f - dot / union_val : 0.0f;
+    }
+}
+
+#pragma endregion Stateful Streaming
+
+#if defined(__cplusplus)
+} // extern "C"
+#endif
+
+#endif // NK_SET_SERIAL_H

package/numkong/include/numkong/set/sve.h

@@ -0,0 +1,187 @@
+/**
+ *  @brief SIMD-accelerated Set Similarity Measures for SVE.
+ *  @file include/numkong/set/sve.h
+ *  @author Ash Vardanian
+ *  @date December 27, 2025
+ *
+ *  @sa include/numkong/set.h
+ *
+ *  @section set_sve_instructions ARM SVE Instructions
+ *
+ *      Intrinsic      Instruction                 V1
+ *      svld1_u8       LD1B (Z.B, P/Z, [Xn])       4-6cy @ 2p
+ *      svld1_u32      LD1W (Z.S, P/Z, [Xn])       4-6cy @ 2p
+ *      sveor_u8_m     EOR (Z.B, P/M, Z.B, Z.B)    1cy @ 2p
+ *      svand_u8_m     AND (Z.B, P/M, Z.B, Z.B)    1cy @ 2p
+ *      svorr_u8_m     ORR (Z.B, P/M, Z.B, Z.B)    1cy @ 2p
+ *      svcnt_u8_x     CNT (Z.B, P/M, Z.B)         2cy @ 2p
+ *      svadd_u8_z     ADD (Z.B, P/M, Z.B, Z.B)    1cy @ 2p
+ *      svaddv_u8      UADDV (D, P, Z.B)           6cy @ 1p
+ *      svcmpeq_u32    CMPEQ (P.S, P/Z, Z.S, Z.S)  2cy @ 1p
+ *      svcntp_b32     CNTP (Xd, P, P.S)           2cy @ 1p
+ *      svdup_n_u8     DUP (Z.B, #imm)             1cy @ 2p
+ *      svwhilelt_b8   WHILELT (P.B, Xn, Xm)       2cy @ 1p
+ *      svwhilelt_b32  WHILELT (P.S, Xn, Xm)       2cy @ 1p
+ *      svptrue_b8     PTRUE (P.B, pattern)        1cy @ 2p
+ *      svcntb         CNTB (Xd)                   1cy @ 2p
+ *      svcntw         CNTW (Xd)                   1cy @ 2p
+ */
+#ifndef NK_SET_SVE_H
+#define NK_SET_SVE_H
+
+#if NK_TARGET_ARM64_
+#if NK_TARGET_SVE
+
+#include "numkong/types.h"      // `nk_u1x8_t`
+#include "numkong/reduce/sve.h" // `nk_svaddv_f64_`
+#include "numkong/set/neon.h"   // `nk_hamming_u1_neon`
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#if defined(__clang__)
+#pragma clang attribute push(__attribute__((target("arch=armv8.2-a+sve"))), apply_to = function)
+#elif defined(__GNUC__)
+#pragma GCC push_options
+#pragma GCC target("arch=armv8.2-a+sve")
+#endif
+
+#pragma region Binary Sets
+
+NK_PUBLIC void nk_hamming_u1_sve(nk_u1x8_t const *a, nk_u1x8_t const *b, nk_size_t n, nk_u32_t *result) {
+    nk_size_t n_bytes = nk_size_divide_round_up_(n, NK_BITS_PER_BYTE);
+
+    // On very small register sizes, NEON is at least as fast as SVE.
+    nk_size_t const words_per_register = svcntb();
+    if (words_per_register <= 32) {
+        nk_hamming_u1_neon(a, b, n, result);
+        return;
+    }
+
+    // On larger register sizes, SVE is faster.
+    nk_size_t i = 0, cycle = 0;
+    nk_u32_t differences = 0;
+    svuint8_t popcount_u8x = svdup_n_u8(0);
+    svbool_t const all_predicate_b8x = svptrue_b8();
+    while (i < n_bytes) {
+        do {
+            svbool_t active_predicate_b8x = svwhilelt_b8_u64(i, n_bytes);
+            svuint8_t a_u8x = svld1_u8(active_predicate_b8x, a + i);
+            svuint8_t b_u8x = svld1_u8(active_predicate_b8x, b + i);
+            popcount_u8x = svadd_u8_z(all_predicate_b8x, popcount_u8x,
+                                      svcnt_u8_x(all_predicate_b8x, sveor_u8_m(all_predicate_b8x, a_u8x, b_u8x)));
+            i += words_per_register;
+            ++cycle;
+        } while (i < n_bytes && cycle < 31);
+        differences += nk_svaddv_u8_(all_predicate_b8x, popcount_u8x);
+        popcount_u8x = svdup_n_u8(0);
+        cycle = 0; // Reset the cycle counter.
+    }
+
+    *result = differences;
+}
+
+NK_PUBLIC void nk_jaccard_u1_sve(nk_u1x8_t const *a, nk_u1x8_t const *b, nk_size_t n, nk_f32_t *result) {
+    nk_size_t n_bytes = nk_size_divide_round_up_(n, NK_BITS_PER_BYTE);
+
+    // On very small register sizes, NEON is at least as fast as SVE.
+    nk_size_t const words_per_register = svcntb();
+    if (words_per_register <= 32) {
+        nk_jaccard_u1_neon(a, b, n, result);
+        return;
+    }
+
+    // On larger register sizes, SVE is faster.
+    nk_size_t i = 0, cycle = 0;
+    nk_u32_t intersection_count = 0, union_count = 0;
+    svuint8_t intersection_popcount_u8x = svdup_n_u8(0);
+    svuint8_t union_popcount_u8x = svdup_n_u8(0);
+    svbool_t const all_predicate_b8x = svptrue_b8();
+    while (i < n_bytes) {
+        do {
+            svbool_t active_predicate_b8x = svwhilelt_b8_u64(i, n_bytes);
+            svuint8_t a_u8x = svld1_u8(active_predicate_b8x, a + i);
+            svuint8_t b_u8x = svld1_u8(active_predicate_b8x, b + i);
+            intersection_popcount_u8x = svadd_u8_z(
+                all_predicate_b8x, intersection_popcount_u8x,
+                svcnt_u8_x(all_predicate_b8x, svand_u8_m(all_predicate_b8x, a_u8x, b_u8x)));
+            union_popcount_u8x = svadd_u8_z(all_predicate_b8x, union_popcount_u8x,
+                                            svcnt_u8_x(all_predicate_b8x, svorr_u8_m(all_predicate_b8x, a_u8x, b_u8x)));
+            i += words_per_register;
+            ++cycle;
+        } while (i < n_bytes && cycle < 31);
+        intersection_count += nk_svaddv_u8_(all_predicate_b8x, intersection_popcount_u8x);
+        intersection_popcount_u8x = svdup_n_u8(0);
+        union_count += nk_svaddv_u8_(all_predicate_b8x, union_popcount_u8x);
+        union_popcount_u8x = svdup_n_u8(0);
+        cycle = 0; // Reset the cycle counter.
+    }
+
+    *result = (union_count != 0) ? 1.0f - (nk_f32_t)intersection_count / (nk_f32_t)union_count : 0.0f;
+}
+
+#pragma endregion Binary Sets
+
+#pragma region Integer Sets
+
+NK_PUBLIC void nk_jaccard_u32_sve(nk_u32_t const *a, nk_u32_t const *b, nk_size_t n, nk_f32_t *result) {
+    nk_size_t const words_per_register = svcntw();
+    nk_size_t i = 0;
+    nk_u32_t intersection_count = 0;
+    while (i < n) {
+        svbool_t active_predicate_b32x = svwhilelt_b32_u64(i, n);
+        svuint32_t a_u32x = svld1_u32(active_predicate_b32x, a + i);
+        svuint32_t b_u32x = svld1_u32(active_predicate_b32x, b + i);
+        svbool_t equality_predicate_b32x = svcmpeq_u32(active_predicate_b32x, a_u32x, b_u32x);
+        intersection_count += svcntp_b32(active_predicate_b32x, equality_predicate_b32x);
+        i += words_per_register;
+    }
+    *result = (n != 0) ? 1.0f - (nk_f32_t)intersection_count / (nk_f32_t)n : 0.0f;
+}
+
+NK_PUBLIC void nk_hamming_u8_sve(nk_u8_t const *a, nk_u8_t const *b, nk_size_t n, nk_u32_t *result) {
+    nk_size_t const bytes_per_register = svcntb();
+    nk_size_t i = 0;
+    nk_u32_t differences = 0;
+    while (i < n) {
+        svbool_t active_predicate_b8x = svwhilelt_b8_u64(i, n);
+        svuint8_t a_u8x = svld1_u8(active_predicate_b8x, a + i);
+        svuint8_t b_u8x = svld1_u8(active_predicate_b8x, b + i);
+        svbool_t neq_predicate_b8x = svcmpne_u8(active_predicate_b8x, a_u8x, b_u8x);
+        differences += svcntp_b8(active_predicate_b8x, neq_predicate_b8x);
+        i += bytes_per_register;
+    }
+    *result = differences;
+}
+
+NK_PUBLIC void nk_jaccard_u16_sve(nk_u16_t const *a, nk_u16_t const *b, nk_size_t n, nk_f32_t *result) {
+    nk_size_t const halfwords_per_register = svcnth();
+    nk_size_t i = 0;
+    nk_u32_t intersection_count = 0;
+    while (i < n) {
+        svbool_t active_predicate_b16x = svwhilelt_b16_u64(i, n);
+        svuint16_t a_u16x = svld1_u16(active_predicate_b16x, a + i);
+        svuint16_t b_u16x = svld1_u16(active_predicate_b16x, b + i);
+        svbool_t equality_predicate_b16x = svcmpeq_u16(active_predicate_b16x, a_u16x, b_u16x);
+        intersection_count += svcntp_b16(active_predicate_b16x, equality_predicate_b16x);
+        i += halfwords_per_register;
+    }
+    *result = (n != 0) ? 1.0f - (nk_f32_t)intersection_count / (nk_f32_t)n : 0.0f;
+}
+
+#pragma endregion Integer Sets
+
+#if defined(__clang__)
+#pragma clang attribute pop
+#elif defined(__GNUC__)
+#pragma GCC pop_options
+#endif
+
+#if defined(__cplusplus)
+} // extern "C"
+#endif
+
+#endif // NK_TARGET_SVE
+#endif // NK_TARGET_ARM64_
+#endif // NK_SET_SVE_H

package/numkong/include/numkong/set/v128relaxed.h

@@ -0,0 +1,240 @@
+/**
+ *  @brief SIMD-accelerated Set Similarity Measures for WASM.
+ *  @file include/numkong/set/v128relaxed.h
+ *  @author Ash Vardanian
+ *  @date February 1, 2026
+ *
+ *  This file contains windowed implementations of Hamming and Jaccard distance
+ *  for bit-level operations (u1 packed bits). The windowing optimization reduces
+ *  widening overhead by 96.7%, providing 5-10× speedup over naive implementations.
+ *
+ *  Algorithm: Accumulate popcount results in u8 for 31 iterations, then widen
+ *  to u16 → u32 once. Since max(popcount(u8)) = 8, we can safely accumulate
+ *  31 × 8 = 248 < 255 (u8 max) without overflow.
+ */
+
+#ifndef NK_SET_V128RELAXED_H
+#define NK_SET_V128RELAXED_H
+
+#if NK_TARGET_V128RELAXED
+
+#include "numkong/types.h"
+#include "numkong/reduce/v128relaxed.h"
+#include "numkong/set/serial.h"
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#if defined(__clang__)
+#pragma clang attribute push(__attribute__((target("relaxed-simd"))), apply_to = function)
+#endif
+
+#pragma region Binary Sets
+
+NK_PUBLIC void nk_hamming_u1_v128relaxed(nk_u1x8_t const *a, nk_u1x8_t const *b, nk_size_t n, nk_u32_t *result) {
+    nk_u8_t const *a_bytes = (nk_u8_t const *)a;
+    nk_u8_t const *b_bytes = (nk_u8_t const *)b;
+    nk_size_t n_bytes = nk_size_divide_round_up_(n, NK_BITS_PER_BYTE);
+
+    nk_u32_t differences = 0;
+    nk_size_t i = 0;
+
+    // Windowed accumulation loop
+    while (i + 16 <= n_bytes) {
+        v128_t popcount_u8x16 = wasm_i8x16_splat(0);
+
+        // Inner loop: accumulate 31 iterations in u8 before widening
+        nk_size_t cycle = 0;
+        for (; cycle < 31 && i + 16 <= n_bytes; ++cycle, i += 16) {
+            v128_t a_u8x16 = wasm_v128_load(a_bytes + i);
+            v128_t b_u8x16 = wasm_v128_load(b_bytes + i);
+
+            // XOR to find differing bits
+            v128_t xor_u8x16 = wasm_v128_xor(a_u8x16, b_u8x16);
+
+            // Popcount each byte
+            v128_t popcnt_u8x16 = wasm_i8x16_popcnt(xor_u8x16);
+
+            // Accumulate in u8 (safe: 31 × 8 = 248 < 255)
+            popcount_u8x16 = wasm_i8x16_add(popcount_u8x16, popcnt_u8x16);
+        }
+
+        // Widen once per window: u8 → u16 → u32
+        differences += nk_reduce_add_u8x16_v128relaxed_(popcount_u8x16);
+    }
+
+    // Handle tail bytes
+    for (; i < n_bytes; i++) {
+        nk_u8_t xor_byte = a_bytes[i] ^ b_bytes[i];
+        differences += nk_u1x8_popcount_(xor_byte);
+    }
+
+    *result = differences;
+}
+
+NK_PUBLIC void nk_jaccard_u1_v128relaxed(nk_u1x8_t const *a, nk_u1x8_t const *b, nk_size_t n, nk_f32_t *result) {
+    nk_u8_t const *a_bytes = (nk_u8_t const *)a;
+    nk_u8_t const *b_bytes = (nk_u8_t const *)b;
+    nk_size_t n_bytes = nk_size_divide_round_up_(n, NK_BITS_PER_BYTE);
+
+    nk_u32_t intersection = 0;
+    nk_u32_t union_count = 0;
+    nk_size_t i = 0;
+
+    // Windowed accumulation loop
+    while (i + 16 <= n_bytes) {
+        v128_t popcount_and_u8x16 = wasm_i8x16_splat(0);
+        v128_t popcount_or_u8x16 = wasm_i8x16_splat(0);
+
+        // Inner loop: accumulate 31 iterations in u8 before widening
+        nk_size_t cycle = 0;
+        for (; cycle < 31 && i + 16 <= n_bytes; ++cycle, i += 16) {
+            v128_t a_u8x16 = wasm_v128_load(a_bytes + i);
+            v128_t b_u8x16 = wasm_v128_load(b_bytes + i);
+
+            // Intersection: a AND b
+            v128_t and_u8x16 = wasm_v128_and(a_u8x16, b_u8x16);
+            v128_t popcnt_and_u8x16 = wasm_i8x16_popcnt(and_u8x16);
+            popcount_and_u8x16 = wasm_i8x16_add(popcount_and_u8x16, popcnt_and_u8x16);
+
+            // Union: a OR b
+            v128_t or_u8x16 = wasm_v128_or(a_u8x16, b_u8x16);
+            v128_t popcnt_or_u8x16 = wasm_i8x16_popcnt(or_u8x16);
+            popcount_or_u8x16 = wasm_i8x16_add(popcount_or_u8x16, popcnt_or_u8x16);
+        }
+
+        // Widen once per window
+        intersection += nk_reduce_add_u8x16_v128relaxed_(popcount_and_u8x16);
+        union_count += nk_reduce_add_u8x16_v128relaxed_(popcount_or_u8x16);
+    }
+
+    // Handle tail bytes
+    for (; i < n_bytes; i++) {
+        nk_u8_t a_byte = a_bytes[i];
+        nk_u8_t b_byte = b_bytes[i];
+        intersection += nk_u1x8_popcount_(a_byte & b_byte);
+        union_count += nk_u1x8_popcount_(a_byte | b_byte);
+    }
+
+    // Jaccard distance = 1 - (intersection / union)
+    *result = union_count > 0 ? 1.0f - ((nk_f32_t)intersection / (nk_f32_t)union_count) : 0.0f;
+}
+
+#pragma endregion Binary Sets
+
+#pragma region Integer Sets
+
+NK_PUBLIC void nk_hamming_u8_v128relaxed(nk_u8_t const *a, nk_u8_t const *b, nk_size_t n, nk_u32_t *result) {
+    nk_u32_t sum_total = 0;
+    nk_size_t i = 0;
+
+    // Windowed accumulation: outer loop for windows, inner loop for iterations within window
+    while (i + 16 <= n) {
+        v128_t sum_u8x16 = wasm_i8x16_splat(0);
+
+        // Inner loop: accumulate up to 31 iterations in u8 (safe: 31 × 1 = 31 < 255)
+        nk_size_t cycle = 0;
+        for (; cycle < 31 && i + 16 <= n; ++cycle, i += 16) {
+            v128_t a_u8x16 = wasm_v128_load(a + i);
+            v128_t b_u8x16 = wasm_v128_load(b + i);
+
+            // Compare for inequality: 0xFF where different, 0x00 where same
+            v128_t neq_mask_u8x16 = wasm_i8x16_ne(a_u8x16, b_u8x16);
+
+            // Convert mask to count: 0xFF → 1, 0x00 → 0
+            v128_t neq_count_u8x16 = wasm_v128_and(neq_mask_u8x16, wasm_i8x16_splat(1));
+
+            // Accumulate counts
+            sum_u8x16 = wasm_i8x16_add(sum_u8x16, neq_count_u8x16);
+        }
+
+        // Widen and reduce once per window
+        sum_total += nk_reduce_add_u8x16_v128relaxed_(sum_u8x16);
+    }
+
+    // Traditional tail loop: handle remaining bytes (0-15) scalar-style
+    for (; i < n; i++) { sum_total += (a[i] != b[i]); }
+
+    *result = sum_total;
+}
+
+NK_PUBLIC void nk_jaccard_u32_v128relaxed(nk_u32_t const *a, nk_u32_t const *b, nk_size_t n, nk_f32_t *result) {
+    nk_u32_t matches = 0;
+    nk_size_t i = 0;
+    v128_t matches_u32x4 = wasm_i32x4_splat(0);
+
+    for (; i + 4 <= n; i += 4) {
+        v128_t a_u32x4 = wasm_v128_load(a + i);
+        v128_t b_u32x4 = wasm_v128_load(b + i);
+        v128_t eq_mask_u32x4 = wasm_i32x4_eq(a_u32x4, b_u32x4);
+        v128_t match_bits_u32x4 = wasm_u32x4_shr(eq_mask_u32x4, 31);
+        matches_u32x4 = wasm_i32x4_add(matches_u32x4, match_bits_u32x4);
+    }
+
+    matches += nk_reduce_add_u32x4_v128relaxed_(matches_u32x4);
+    for (; i < n; ++i) matches += (a[i] == b[i]);
+
+    *result = (n != 0) ? 1.0f - (nk_f32_t)matches / (nk_f32_t)n : 0.0f;
+}
+
+NK_PUBLIC void nk_jaccard_u16_v128relaxed(nk_u16_t const *a, nk_u16_t const *b, nk_size_t n, nk_f32_t *result) {
+    nk_u32_t matches = 0;
+    nk_size_t i = 0;
+    v128_t matches_u32x4 = wasm_i32x4_splat(0);
+
+    for (; i + 8 <= n; i += 8) {
+        v128_t a_u16x8 = wasm_v128_load(a + i);
+        v128_t b_u16x8 = wasm_v128_load(b + i);
+        v128_t eq_mask_u16x8 = wasm_i16x8_eq(a_u16x8, b_u16x8);
+        v128_t match_bits_u16x8 = wasm_u16x8_shr(eq_mask_u16x8, 15);
+        matches_u32x4 = wasm_i32x4_add(matches_u32x4, wasm_u32x4_extadd_pairwise_u16x8(match_bits_u16x8));
+    }
+
+    matches += nk_reduce_add_u32x4_v128relaxed_(matches_u32x4);
+    for (; i < n; ++i) matches += (a[i] == b[i]);
+
+    *result = (n != 0) ? 1.0f - (nk_f32_t)matches / (nk_f32_t)n : 0.0f;
+}
+
+#pragma endregion Integer Sets
+
+#pragma region Binary Sets from Dot
+
+NK_INTERNAL void nk_hamming_u32x4_from_dot_v128relaxed_( //
+    nk_b128_vec_t dots, nk_u32_t query_pop, nk_b128_vec_t target_pops, nk_b128_vec_t *results) {
+    v128_t dots_u32x4 = dots.v128;
+    v128_t query_u32x4 = wasm_u32x4_splat(query_pop);
+    v128_t target_u32x4 = target_pops.v128;
+    results->v128 = wasm_i32x4_sub(wasm_i32x4_add(query_u32x4, target_u32x4), wasm_i32x4_shl(dots_u32x4, 1));
+}
+
+NK_INTERNAL void nk_jaccard_f32x4_from_dot_v128relaxed_( //
+    nk_b128_vec_t dots, nk_u32_t query_pop, nk_b128_vec_t target_pops, nk_b128_vec_t *results) {
+    v128_t dot_f32x4 = wasm_f32x4_convert_u32x4(dots.v128);
+    v128_t query_f32x4 = wasm_f32x4_splat((nk_f32_t)query_pop);
+    v128_t target_f32x4 = wasm_f32x4_convert_u32x4(target_pops.v128);
+    v128_t union_f32x4 = wasm_f32x4_sub(wasm_f32x4_add(query_f32x4, target_f32x4), dot_f32x4);
+
+    v128_t zero_f32x4 = wasm_f32x4_splat(0.0f);
+    v128_t one_f32x4 = wasm_f32x4_splat(1.0f);
+    v128_t zero_mask_u32x4 = wasm_f32x4_eq(union_f32x4, zero_f32x4);
+    v128_t safe_union_f32x4 = wasm_i32x4_relaxed_laneselect(one_f32x4, union_f32x4, zero_mask_u32x4);
+
+    v128_t ratio_f32x4 = wasm_f32x4_div(dot_f32x4, safe_union_f32x4);
+    v128_t jaccard_f32x4 = wasm_f32x4_sub(one_f32x4, ratio_f32x4);
+    results->v128 = wasm_i32x4_relaxed_laneselect(zero_f32x4, jaccard_f32x4, zero_mask_u32x4);
+}
+
+#pragma endregion Binary Sets from Dot
+
+#if defined(__clang__)
+#pragma clang attribute pop
+#endif
+
+#if defined(__cplusplus)
+} // extern "C"
+#endif
+
+#endif // NK_TARGET_V128RELAXED
+#endif // NK_SET_V128RELAXED_H