numkong 7.0.0

package/include/numkong/set/rvvbb.h

@@ -0,0 +1,117 @@
+/**
+ *  @brief SIMD-accelerated Set Similarity Measures for RISC-V with Zvbb.
+ *  @file include/numkong/set/rvvbb.h
+ *  @author Ash Vardanian
+ *  @date February 9, 2026
+ *
+ *  @sa include/numkong/set.h
+ *
+ *  Zvbb (Vector Basic Bit-manipulation) provides native per-element popcount via `vcpop.v`,
+ *  replacing the 11-instruction SWAR approach in set/rvv.h with a single instruction.
+ *
+ *  Only `nk_hamming_u1` and `nk_jaccard_u1` benefit from Zvbb (they need byte-level popcount).
+ *  Integer set operations (hamming_u8, jaccard_u16, jaccard_u32) use mask-level vcpop.m
+ *  which is already available in base RVV 1.0.
+ *
+ *  Requires: RVV 1.0 + Zvbb extension (GCC 14+ or Clang 18+)
+ */
+#ifndef NK_SET_RVVBB_H
+#define NK_SET_RVVBB_H
+
+#if NK_TARGET_RISCV_
+#if NK_TARGET_RVVBB
+
+#include "numkong/types.h"
+
+#if defined(__clang__)
+#pragma clang attribute push(__attribute__((target("arch=+v,+zvbb"))), apply_to = function)
+#elif defined(__GNUC__)
+#pragma GCC push_options
+#pragma GCC target("arch=+v,+zvbb")
+#endif
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+/**
+ *  @brief  Native per-element popcount using Zvbb vcpop.v (1 instruction).
+ *
+ *  Replaces the 11-instruction SWAR approach in nk_popcount_u8m4_rvv_.
+ */
+NK_INTERNAL vuint8m4_t nk_popcount_u8m4_rvvbb_(vuint8m4_t v_u8m4) {
+    vuint8m4_t result_u8m4;
+    __asm__ volatile("vcpop.v %0, %1" : "=vr"(result_u8m4) : "vr"(v_u8m4));
+    return result_u8m4;
+}
+
+NK_PUBLIC void nk_hamming_u1_rvvbb(nk_u1x8_t const *a, nk_u1x8_t const *b, nk_size_t n, nk_u32_t *result) {
+    nk_size_t count_bytes = nk_size_divide_round_up_(n, NK_BITS_PER_BYTE);
+
+    vuint32m1_t sum_u32m1 = __riscv_vmv_v_x_u32m1(0, 1);
+
+    nk_size_t i = 0;
+    for (nk_size_t vector_length; i + 1 <= count_bytes; i += vector_length) {
+        vector_length = __riscv_vsetvl_e8m4(count_bytes - i);
+
+        vuint8m4_t a_u8m4 = __riscv_vle8_v_u8m4(a + i, vector_length);
+        vuint8m4_t b_u8m4 = __riscv_vle8_v_u8m4(b + i, vector_length);
+        vuint8m4_t xor_u8m4 = __riscv_vxor_vv_u8m4(a_u8m4, b_u8m4, vector_length);
+
+        // Native per-element popcount via Zvbb (1 instruction vs 11 SWAR)
+        vuint8m4_t popcount_u8m4 = nk_popcount_u8m4_rvvbb_(xor_u8m4);
+
+        // Widen to u16 and accumulate via widening reduction sum
+        vuint16m8_t popcount_u16m8 = __riscv_vwaddu_vx_u16m8(popcount_u8m4, 0, vector_length);
+        sum_u32m1 = __riscv_vwredsumu_vs_u16m8_u32m1(popcount_u16m8, sum_u32m1, vector_length);
+    }
+
+    *result = __riscv_vmv_x_s_u32m1_u32(sum_u32m1);
+}
+
+NK_PUBLIC void nk_jaccard_u1_rvvbb(nk_u1x8_t const *a, nk_u1x8_t const *b, nk_size_t n, nk_f32_t *result) {
+    nk_size_t count_bytes = nk_size_divide_round_up_(n, NK_BITS_PER_BYTE);
+
+    vuint32m1_t intersection_sum_u32m1 = __riscv_vmv_v_x_u32m1(0, 1);
+    vuint32m1_t union_sum_u32m1 = __riscv_vmv_v_x_u32m1(0, 1);
+
+    nk_size_t i = 0;
+    for (nk_size_t vector_length; i + 1 <= count_bytes; i += vector_length) {
+        vector_length = __riscv_vsetvl_e8m4(count_bytes - i);
+
+        vuint8m4_t a_u8m4 = __riscv_vle8_v_u8m4(a + i, vector_length);
+        vuint8m4_t b_u8m4 = __riscv_vle8_v_u8m4(b + i, vector_length);
+
+        vuint8m4_t intersection_u8m4 = __riscv_vand_vv_u8m4(a_u8m4, b_u8m4, vector_length);
+        vuint8m4_t union_u8m4 = __riscv_vor_vv_u8m4(a_u8m4, b_u8m4, vector_length);
+
+        // Native per-element popcount via Zvbb
+        vuint8m4_t intersection_popcount_u8m4 = nk_popcount_u8m4_rvvbb_(intersection_u8m4);
+        vuint8m4_t union_popcount_u8m4 = nk_popcount_u8m4_rvvbb_(union_u8m4);
+
+        // Widen and accumulate
+        vuint16m8_t intersection_popcount_u16m8 = __riscv_vwaddu_vx_u16m8(intersection_popcount_u8m4, 0, vector_length);
+        vuint16m8_t union_popcount_u16m8 = __riscv_vwaddu_vx_u16m8(union_popcount_u8m4, 0, vector_length);
+        intersection_sum_u32m1 = __riscv_vwredsumu_vs_u16m8_u32m1(intersection_popcount_u16m8, intersection_sum_u32m1,
+                                                                  vector_length);
+        union_sum_u32m1 = __riscv_vwredsumu_vs_u16m8_u32m1(union_popcount_u16m8, union_sum_u32m1, vector_length);
+    }
+
+    nk_u32_t intersection_count_u32 = __riscv_vmv_x_s_u32m1_u32(intersection_sum_u32m1);
+    nk_u32_t union_count_u32 = __riscv_vmv_x_s_u32m1_u32(union_sum_u32m1);
+    *result = (union_count_u32 != 0) ? 1.0f - (nk_f32_t)intersection_count_u32 / (nk_f32_t)union_count_u32 : 0.0f;
+}
+
+#if defined(__cplusplus)
+} // extern "C"
+#endif
+
+#if defined(__clang__)
+#pragma clang attribute pop
+#elif defined(__GNUC__)
+#pragma GCC pop_options
+#endif
+
+#endif // NK_TARGET_RVVBB
+#endif // NK_TARGET_RISCV_
+#endif // NK_SET_RVVBB_H

package/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/include/numkong/set/sve.h

@@ -0,0 +1,185 @@
+/**
+ *  @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                     Latency     Throughput
+ *      svld1_u8                    LD1B (Z.B, P/Z, [Xn])           4-6cy       2/cy
+ *      svld1_u32                   LD1W (Z.S, P/Z, [Xn])           4-6cy       2/cy
+ *      sveor_u8_m                  EOR (Z.B, P/M, Z.B, Z.B)        1cy         2/cy
+ *      svand_u8_m                  AND (Z.B, P/M, Z.B, Z.B)        1cy         2/cy
+ *      svorr_u8_m                  ORR (Z.B, P/M, Z.B, Z.B)        1cy         2/cy
+ *      svcnt_u8_x                  CNT (Z.B, P/M, Z.B)             2cy         2/cy
+ *      svadd_u8_z                  ADD (Z.B, P/M, Z.B, Z.B)        1cy         2/cy
+ *      svaddv_u8                   UADDV (D, P, Z.B)               6cy         1/cy
+ *      svcmpeq_u32                 CMPEQ (P.S, P/Z, Z.S, Z.S)      2cy         1/cy
+ *      svcntp_b32                  CNTP (Xd, P, P.S)               2cy         1/cy
+ *      svdup_n_u8                  DUP (Z.B, #imm)                 1cy         2/cy
+ *      svwhilelt_b8                WHILELT (P.B, Xn, Xm)           2cy         1/cy
+ *      svwhilelt_b32               WHILELT (P.S, Xn, Xm)           2cy         1/cy
+ *      svptrue_b8                  PTRUE (P.B, pattern)            1cy         2/cy
+ *      svcntb                      CNTB (Xd)                       1cy         2/cy
+ *      svcntw                      CNTW (Xd)                       1cy         2/cy
+ */
+#ifndef NK_SET_SVE_H
+#define NK_SET_SVE_H
+
+#if NK_TARGET_ARM_
+#if NK_TARGET_SVE
+
+#include "numkong/types.h"    // `nk_u1x8_t`
+#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_u8 = svdup_n_u8(0);
+    svbool_t const all_predicate = svptrue_b8();
+    while (i < n_bytes) {
+        do {
+            svbool_t active_predicate = svwhilelt_b8_u64(i, n_bytes);
+            svuint8_t a_u8 = svld1_u8(active_predicate, a + i);
+            svuint8_t b_u8 = svld1_u8(active_predicate, b + i);
+            popcount_u8 = svadd_u8_z(all_predicate, popcount_u8,
+                                     svcnt_u8_x(all_predicate, sveor_u8_m(all_predicate, a_u8, b_u8)));
+            i += words_per_register;
+            ++cycle;
+        } while (i < n_bytes && cycle < 31);
+        differences += svaddv_u8(all_predicate, popcount_u8);
+        popcount_u8 = 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_u8 = svdup_n_u8(0);
+    svuint8_t union_popcount_u8 = svdup_n_u8(0);
+    svbool_t const all_predicate = svptrue_b8();
+    while (i < n_bytes) {
+        do {
+            svbool_t active_predicate = svwhilelt_b8_u64(i, n_bytes);
+            svuint8_t a_u8 = svld1_u8(active_predicate, a + i);
+            svuint8_t b_u8 = svld1_u8(active_predicate, b + i);
+            intersection_popcount_u8 = svadd_u8_z(all_predicate, intersection_popcount_u8,
+                                                  svcnt_u8_x(all_predicate, svand_u8_m(all_predicate, a_u8, b_u8)));
+            union_popcount_u8 = svadd_u8_z(all_predicate, union_popcount_u8,
+                                           svcnt_u8_x(all_predicate, svorr_u8_m(all_predicate, a_u8, b_u8)));
+            i += words_per_register;
+            ++cycle;
+        } while (i < n_bytes && cycle < 31);
+        intersection_count += svaddv_u8(all_predicate, intersection_popcount_u8);
+        intersection_popcount_u8 = svdup_n_u8(0);
+        union_count += svaddv_u8(all_predicate, union_popcount_u8);
+        union_popcount_u8 = 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 = svwhilelt_b32_u64(i, n);
+        svuint32_t a_u32 = svld1_u32(active_predicate, a + i);
+        svuint32_t b_u32 = svld1_u32(active_predicate, b + i);
+        svbool_t equality_predicate = svcmpeq_u32(active_predicate, a_u32, b_u32);
+        intersection_count += svcntp_b32(active_predicate, equality_predicate);
+        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 = svwhilelt_b8_u64(i, n);
+        svuint8_t a_u8 = svld1_u8(active_predicate, a + i);
+        svuint8_t b_u8 = svld1_u8(active_predicate, b + i);
+        svbool_t neq_predicate = svcmpne_u8(active_predicate, a_u8, b_u8);
+        differences += svcntp_b8(active_predicate, neq_predicate);
+        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 = svwhilelt_b16_u64(i, n);
+        svuint16_t a_u16 = svld1_u16(active_predicate, a + i);
+        svuint16_t b_u16 = svld1_u16(active_predicate, b + i);
+        svbool_t equality_predicate = svcmpeq_u16(active_predicate, a_u16, b_u16);
+        intersection_count += svcntp_b16(active_predicate, equality_predicate);
+        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_ARM_
+#endif // NK_SET_SVE_H