numkong 7.0.0 → 7.4.2

package/include/numkong/set/loongsonasx.h

@@ -0,0 +1,181 @@
+/**
+ *  @brief SIMD-accelerated Set Similarity Measures for LoongArch LASX (256-bit).
+ *  @file include/numkong/set/loongsonasx.h
+ *  @author Ash Vardanian
+ *  @date March 23, 2026
+ *
+ *  @sa include/numkong/set.h
+ *
+ *  @section set_loongsonasx_instructions Key LASX Set Instructions
+ *
+ *      Intrinsic                    Instruction
+ *      __lasx_xvld                  XVLD (256-bit unaligned load)
+ *      __lasx_xvxor_v               XVXOR.V (bitwise XOR)
+ *      __lasx_xvor_v                XVOR.V (bitwise OR)
+ *      __lasx_xvand_v               XVAND.V (bitwise AND)
+ *      __lasx_xvpcnt_d              XVPCNT.D (popcount per u64 element)
+ *      __lasx_xvseq_b               XVSEQ.B (byte-wise equality, 0xFF/0x00)
+ *      __lasx_xvmin_bu              XVMIN.BU (unsigned byte minimum)
+ *      __lasx_xvhaddw_hu_bu         XVHADDW.HU.BU (horizontal pairwise add u8->u16)
+ *      __lasx_xvhaddw_wu_hu         XVHADDW.WU.HU (horizontal pairwise add u16->u32)
+ *      __lasx_xvhaddw_du_wu         XVHADDW.DU.WU (horizontal pairwise add u32->u64)
+ *      __lasx_xvadd_d               XVADD.D (i64 addition)
+ *      __lasx_xvpermi_q             XVPERMI.Q (extract/permute 128-bit lanes)
+ *
+ *  LASX provides per-element popcount at multiple widths (`xvpcnt_b/h/w/d`).
+ *  For binary set operations we use `xvpcnt_d` which gives 4 x u64 popcount values
+ *  directly, eliminating the need for horizontal byte-sum reduction chains.
+ *
+ *  For sorted integer set operations (jaccard_u16, jaccard_u32), SIMD provides limited
+ *  benefit due to the inherently serial merge-based algorithm, so we delegate to the
+ *  serial implementations.
+ */
+#ifndef NK_SET_LOONGSONASX_H
+#define NK_SET_LOONGSONASX_H
+
+#if NK_TARGET_LOONGARCH_
+#if NK_TARGET_LOONGSONASX
+
+#include "numkong/types.h"
+#include "numkong/set/serial.h"      // `nk_u1x8_popcount_`, serial fallbacks
+#include "numkong/dot/loongsonasx.h" // `nk_reduce_add_i32x8_loongsonasx_`
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#pragma region Reduction Helpers
+
+/** @brief Horizontal sum of 4 u64 lanes in a 256-bit LASX register. */
+NK_INTERNAL nk_u64_t nk_reduce_add_u64x4_loongsonasx_(__m256i sum_u64x4) {
+    __m256i high_u64x4 = __lasx_xvpermi_q(sum_u64x4, sum_u64x4, 0x11);
+    __m256i sum_u64x2 = __lasx_xvadd_d(sum_u64x4, high_u64x4);
+    __m256i swapped_u64x2 = __lasx_xvshuf4i_d(sum_u64x2, sum_u64x2, 0b0001);
+    __m256i reduced_u64x2 = __lasx_xvadd_d(sum_u64x2, swapped_u64x2);
+    return (nk_u64_t)__lasx_xvpickve2gr_du(reduced_u64x2, 0);
+}
+
+/** @brief Horizontally sum all bytes in a 256-bit register as unsigned values.
+ *
+ *  Chains pairwise widening additions: u8→u16→u32→u64, then reduces 4 u64 lanes.
+ */
+NK_INTERNAL nk_u64_t nk_reduce_add_u8x32_loongsonasx_(__m256i v_u8x32) {
+    __m256i sum_u16x16 = __lasx_xvhaddw_hu_bu(v_u8x32, v_u8x32);
+    __m256i sum_u32x8 = __lasx_xvhaddw_wu_hu(sum_u16x16, sum_u16x16);
+    __m256i sum_u64x4 = __lasx_xvhaddw_du_wu(sum_u32x8, sum_u32x8);
+    return nk_reduce_add_u64x4_loongsonasx_(sum_u64x4);
+}
+
+#pragma endregion Reduction Helpers
+
+#pragma region Binary Sets
+
+NK_PUBLIC void nk_hamming_u1_loongsonasx(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);
+    __m256i count_u64x4 = __lasx_xvreplgr2vr_d(0);
+    nk_size_t i = 0;
+
+    for (; i + 32 <= n_bytes; i += 32) {
+        __m256i a_u8x32 = __lasx_xvld(a + i, 0);
+        __m256i b_u8x32 = __lasx_xvld(b + i, 0);
+        __m256i xor_u8x32 = __lasx_xvxor_v(a_u8x32, b_u8x32);
+        count_u64x4 = __lasx_xvadd_d(count_u64x4, __lasx_xvpcnt_d(xor_u8x32));
+    }
+
+    nk_u64_t count = nk_reduce_add_u64x4_loongsonasx_(count_u64x4);
+
+    for (; i < n_bytes; ++i) count += nk_u1x8_popcount_(a[i] ^ b[i]);
+    *result = (nk_u32_t)count;
+}
+
+NK_PUBLIC void nk_jaccard_u1_loongsonasx(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);
+    __m256i xor_count_u64x4 = __lasx_xvreplgr2vr_d(0);
+    __m256i or_count_u64x4 = __lasx_xvreplgr2vr_d(0);
+    nk_size_t i = 0;
+
+    for (; i + 32 <= n_bytes; i += 32) {
+        __m256i a_u8x32 = __lasx_xvld(a + i, 0);
+        __m256i b_u8x32 = __lasx_xvld(b + i, 0);
+        __m256i xor_u8x32 = __lasx_xvxor_v(a_u8x32, b_u8x32);
+        __m256i or_u8x32 = __lasx_xvor_v(a_u8x32, b_u8x32);
+        xor_count_u64x4 = __lasx_xvadd_d(xor_count_u64x4, __lasx_xvpcnt_d(xor_u8x32));
+        or_count_u64x4 = __lasx_xvadd_d(or_count_u64x4, __lasx_xvpcnt_d(or_u8x32));
+    }
+
+    nk_u64_t xor_count = nk_reduce_add_u64x4_loongsonasx_(xor_count_u64x4);
+    nk_u64_t or_count = nk_reduce_add_u64x4_loongsonasx_(or_count_u64x4);
+
+    for (; i < n_bytes; ++i) {
+        xor_count += nk_u1x8_popcount_(a[i] ^ b[i]);
+        or_count += nk_u1x8_popcount_(a[i] | b[i]);
+    }
+    *result = (or_count != 0) ? (nk_f32_t)xor_count / (nk_f32_t)or_count : 0.0f;
+}
+
+#pragma endregion Binary Sets
+
+#pragma region Integer Sets
+
+NK_PUBLIC void nk_hamming_u8_loongsonasx(nk_u8_t const *a, nk_u8_t const *b, nk_size_t n, nk_u32_t *result) {
+    __m256i count_u64x4 = __lasx_xvreplgr2vr_d(0);
+    __m256i ones_u8x32 = __lasx_xvreplgr2vr_b(1);
+    nk_size_t i = 0;
+
+    for (; i + 32 <= n; i += 32) {
+        __m256i a_u8x32 = __lasx_xvld(a + i, 0);
+        __m256i b_u8x32 = __lasx_xvld(b + i, 0);
+        __m256i xor_u8x32 = __lasx_xvxor_v(a_u8x32, b_u8x32);
+        __m256i min_u8x32 = __lasx_xvmin_bu(xor_u8x32, ones_u8x32);
+        __m256i sum_u16x16 = __lasx_xvhaddw_hu_bu(min_u8x32, min_u8x32);
+        __m256i sum_u32x8 = __lasx_xvhaddw_wu_hu(sum_u16x16, sum_u16x16);
+        __m256i sum_u64x4 = __lasx_xvhaddw_du_wu(sum_u32x8, sum_u32x8);
+        count_u64x4 = __lasx_xvadd_d(count_u64x4, sum_u64x4);
+    }
+
+    nk_u64_t count = nk_reduce_add_u64x4_loongsonasx_(count_u64x4);
+
+    for (; i < n; ++i) count += (a[i] != b[i]);
+    *result = (nk_u32_t)count;
+}
+
+#pragma endregion Integer Sets
+
+#pragma region Batched Finalizers
+
+/** @brief Hamming from_dot: computes pop_a + pop_b − 2 × dot for 4 pairs (LSX). */
+NK_INTERNAL void nk_hamming_u32x4_from_dot_loongsonasx_(nk_b128_vec_t dots, nk_u32_t query_pop,
+                                                        nk_b128_vec_t target_pops, nk_b128_vec_t *results) {
+    __m128i dots_u32x4 = dots.xmm;
+    __m128i query_u32x4 = __lsx_vreplgr2vr_w((int)query_pop);
+    __m128i target_u32x4 = target_pops.xmm;
+    results->xmm = __lsx_vsub_w(__lsx_vadd_w(query_u32x4, target_u32x4), __lsx_vslli_w(dots_u32x4, 1));
+}
+
+/** @brief Jaccard from_dot: computes 1 − dot / (pop_a + pop_b − dot) for 4 pairs (LSX). */
+NK_INTERNAL void nk_jaccard_f32x4_from_dot_loongsonasx_(nk_b128_vec_t dots, nk_u32_t query_pop,
+                                                        nk_b128_vec_t target_pops, nk_b128_vec_t *results) {
+    __m128 dot_f32x4 = __lsx_vffint_s_wu(dots.xmm);
+    __m128 query_f32x4 = nk_xvreplgr2vr_s_128_((nk_f32_t)query_pop);
+    __m128 target_f32x4 = __lsx_vffint_s_wu(target_pops.xmm);
+    __m128 union_f32x4 = __lsx_vfsub_s(__lsx_vfadd_s(query_f32x4, target_f32x4), dot_f32x4);
+
+    __m128 zero_f32x4 = (__m128)__lsx_vreplgr2vr_w(0);
+    __m128 one_f32x4 = nk_xvreplgr2vr_s_128_(1.0f);
+    __m128i zero_union_mask_u32x4 = __lsx_vfcmp_ceq_s(union_f32x4, zero_f32x4);
+    __m128 safe_union_f32x4 = (__m128)__lsx_vbitsel_v((__m128i)union_f32x4, (__m128i)one_f32x4, zero_union_mask_u32x4);
+
+    __m128 ratio_f32x4 = __lsx_vfdiv_s(dot_f32x4, safe_union_f32x4);
+    __m128 jaccard_f32x4 = __lsx_vfsub_s(one_f32x4, ratio_f32x4);
+    results->xmm_ps = (__m128)__lsx_vbitsel_v((__m128i)jaccard_f32x4, (__m128i)zero_f32x4, zero_union_mask_u32x4);
+}
+
+#pragma endregion Batched Finalizers
+
+#if defined(__cplusplus)
+} // extern "C"
+#endif
+
+#endif // NK_TARGET_LOONGSONASX
+#endif // NK_TARGET_LOONGARCH_
+#endif // NK_SET_LOONGSONASX_H

package/include/numkong/set/neon.h

@@ -10,13 +10,13 @@
  *
  *  Key NEON instructions for binary/bitwise operations (Cortex-A76 class):
  *
- *      Intrinsic                   Instruction                     Latency     Throughput
- *      vcntq_u8                    CNT (V.16B, V.16B)              2cy         2/cy
- *      veorq_u8                    EOR (V.16B, V.16B, V.16B)       1cy         4/cy
- *      vandq_u8                    AND (V.16B, V.16B, V.16B)       1cy         4/cy
- *      vorrq_u8                    ORR (V.16B, V.16B, V.16B)       1cy         4/cy
- *      vpaddlq_u8                  UADDLP (V.8H, V.16B)            2cy         2/cy
- *      vaddvq_u32                  ADDV (S, V.4S)                  3cy         1/cy
+ *      Intrinsic   Instruction                A76       M5
+ *      vcntq_u8    CNT (V.16B, V.16B)         2cy @ 2p  2cy @ 4p
+ *      veorq_u8    EOR (V.16B, V.16B, V.16B)  1cy @ 2p  2cy @ 4p
+ *      vandq_u8    AND (V.16B, V.16B, V.16B)  1cy @ 2p  2cy @ 4p
+ *      vorrq_u8    ORR (V.16B, V.16B, V.16B)  1cy @ 2p  2cy @ 4p
+ *      vpaddlq_u8  UADDLP (V.8H, V.16B)       2cy @ 2p  2cy @ 4p
+ *      vaddvq_u32  ADDV (S, V.4S)             4cy @ 1p  5cy @ 1p
  *
  *  According to the available literature, the throughput for those basic integer ops is
  *  identical across most Apple, Qualcomm, and AWS Graviton chips. As long as we avoid widening
@@ -58,7 +58,7 @@ extern "C" {
 #pragma GCC target("arch=armv8-a+simd")
 #endif
 
-#pragma region - Binary Sets
+#pragma region Binary Sets
 
 NK_PUBLIC void nk_hamming_u1_neon(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);
@@ -109,9 +109,9 @@ NK_PUBLIC void nk_jaccard_u1_neon(nk_u1x8_t const *a, nk_u1x8_t const *b, nk_siz
     *result = (union_count != 0) ? 1.0f - (nk_f32_t)intersection_count / (nk_f32_t)union_count : 0.0f;
 }
 
-#pragma endregion - Binary Sets
+#pragma endregion Binary Sets
 
-#pragma region - Integer Sets
+#pragma region Integer Sets
 
 NK_PUBLIC void nk_jaccard_u32_neon(nk_u32_t const *a, nk_u32_t const *b, nk_size_t n, nk_f32_t *result) {
     nk_u32_t intersection_count = 0;
@@ -174,9 +174,9 @@ NK_PUBLIC void nk_jaccard_u16_neon(nk_u16_t const *a, nk_u16_t const *b, nk_size
     *result = (n != 0) ? 1.0f - (nk_f32_t)matches / (nk_f32_t)n : 0.0f;
 }
 
-#pragma endregion - Integer Sets
+#pragma endregion Integer Sets
 
-#pragma region - Stateful Streaming
+#pragma region Stateful Streaming
 
 typedef struct nk_hamming_u1x128_state_neon_t {
     uint32x4_t intersection_count_u32x4;
@@ -290,12 +290,11 @@ NK_INTERNAL void nk_jaccard_u1x128_finalize_neon( //
     float32x4_t intersection_f32x4 = vcvtq_f32_u32(intersection_u32x4);
 
     // Compute union using |A ∪ B| = |A| + |B| - |A ∩ B|
-    // Build target popcounts vector using lane insertion (avoids union store/load round-trip).
+    // Build target popcounts vector from two independent halves (avoids serial lane insertion chain).
     float32x4_t query_f32x4 = vdupq_n_f32(query_popcount);
-    float32x4_t targets_f32x4 = vdupq_n_f32(target_popcount_a);
-    targets_f32x4 = vsetq_lane_f32(target_popcount_b, targets_f32x4, 1);
-    targets_f32x4 = vsetq_lane_f32(target_popcount_c, targets_f32x4, 2);
-    targets_f32x4 = vsetq_lane_f32(target_popcount_d, targets_f32x4, 3);
+    float32x2_t targets_ab_f32x2 = vset_lane_f32(target_popcount_b, vdup_n_f32(target_popcount_a), 1);
+    float32x2_t targets_cd_f32x2 = vset_lane_f32(target_popcount_d, vdup_n_f32(target_popcount_c), 1);
+    float32x4_t targets_f32x4 = vcombine_f32(targets_ab_f32x2, targets_cd_f32x2);
     float32x4_t union_f32x4 = vsubq_f32(vaddq_f32(query_f32x4, targets_f32x4), intersection_f32x4);
 
     // Handle zero-union edge case (empty vectors → distance = 0.0, matching scipy convention)
@@ -347,7 +346,7 @@ NK_INTERNAL void nk_jaccard_f32x4_from_dot_neon_(nk_b128_vec_t dots, nk_u32_t qu
     results->f32x4 = vbslq_f32(zero_union_mask, vdupq_n_f32(0.0f), jaccard_f32x4);
 }
 
-#pragma endregion - Stateful Streaming
+#pragma endregion Stateful Streaming
 
 #if defined(__clang__)
 #pragma clang attribute pop

package/include/numkong/set/powervsx.h

@@ -0,0 +1,326 @@
+/**
+ *  @brief SIMD-accelerated Set Similarity Measures for Power ISA VSX.
+ *  @file include/numkong/set/powervsx.h
+ *  @author Ash Vardanian
+ *  @date March 23, 2026
+ *
+ *  @sa include/numkong/set.h
+ *
+ *  @section set_powervsx_instructions Power9 VSX Set Instructions
+ *
+ *  Key Power9 VSX instructions for binary/bitwise operations:
+ *
+ *      Intrinsic      Instruction          P9
+ *      vec_popcnt     vpopcntb/h/w/d       2cy @ 2p    element-wise popcount
+ *      vec_xor        xxlxor               1cy @ 4p
+ *      vec_and        xxland               1cy @ 4p
+ *      vec_or         xxlor                1cy @ 4p
+ *      vec_cmpne      vcmpneb/h/w          2cy @ 2p    byte/half/word not-equal
+ *      vec_xl_len     lxvll                6cy @ 1p    partial vector load
+ *
+ *  Power9 has native doubleword `vpopcntd` instruction, providing efficient SIMD popcount
+ *  with minimal data flow complexity. `vec_xl_len` enables branchless tail handling.
+ *
+ *  @section set_powervsx_stateful Stateful Streaming Logic
+ *
+ *  To build memory-optimal tiled algorithms, this file defines:
+ *
+ *  - nk_hamming_u1x128_state_powervsx_t for streaming Hamming distance
+ *  - nk_jaccard_u1x128_state_powervsx_t for streaming Jaccard similarity
+ *
+ *  @code{c}
+ *  nk_jaccard_u1x128_state_powervsx_t state_first, state_second, state_third, state_fourth;
+ *  nk_jaccard_u1x128_init_powervsx(&state_first);
+ *  // ... stream through packed binary vectors ...
+ *  nk_jaccard_u1x128_finalize_powervsx(&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_POWERVSX_H
+#define NK_SET_POWERVSX_H
+
+#if NK_TARGET_POWER_
+#if NK_TARGET_POWERVSX
+
+#include "numkong/types.h"
+#include "numkong/set/serial.h"   // `nk_u1x8_popcount_`
+#include "numkong/dot/powervsx.h" // `nk_hsum_u32x4_powervsx_`, `nk_hsum_u64x2_powervsx_`
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#if defined(__clang__)
+#pragma clang attribute push(__attribute__((target("power9-vector"))), apply_to = function)
+#elif defined(__GNUC__)
+#pragma GCC push_options
+#pragma GCC target("power9-vector")
+#endif
+
+NK_PUBLIC void nk_hamming_u1_powervsx(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_vu64x2_t differences_u64x2 = vec_splats((nk_u64_t)0);
+    nk_size_t i = 0;
+    // Process 16 bytes at a time using doubleword popcount (vpopcntd)
+    for (; i + 16 <= n_bytes; i += 16) {
+        nk_vu8x16_t a_u8x16 = vec_xl(0, (nk_u8_t const *)(a + i));
+        nk_vu8x16_t b_u8x16 = vec_xl(0, (nk_u8_t const *)(b + i));
+        nk_vu8x16_t xor_u8x16 = vec_xor(a_u8x16, b_u8x16);
+        nk_vu64x2_t popcnt_u64x2 = vec_popcnt((nk_vu64x2_t)xor_u8x16);
+        differences_u64x2 = vec_add(differences_u64x2, popcnt_u64x2);
+    }
+    // Branchless tail: vec_xl_len zero-fills beyond remaining_bytes
+    nk_size_t remaining_bytes = n_bytes - i;
+    nk_vu8x16_t a_u8x16 = vec_xl_len((nk_u8_t *)(a + i), remaining_bytes);
+    nk_vu8x16_t b_u8x16 = vec_xl_len((nk_u8_t *)(b + i), remaining_bytes);
+    nk_vu8x16_t xor_u8x16 = vec_xor(a_u8x16, b_u8x16);
+    nk_vu64x2_t popcnt_u64x2 = vec_popcnt((nk_vu64x2_t)xor_u8x16);
+    differences_u64x2 = vec_add(differences_u64x2, popcnt_u64x2);
+    *result = (nk_u32_t)nk_hsum_u64x2_powervsx_(differences_u64x2);
+}
+
+NK_PUBLIC void nk_jaccard_u1_powervsx(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_vu64x2_t intersection_u64x2 = vec_splats((nk_u64_t)0);
+    nk_vu64x2_t union_u64x2 = vec_splats((nk_u64_t)0);
+    nk_size_t i = 0;
+    for (; i + 16 <= n_bytes; i += 16) {
+        nk_vu8x16_t a_u8x16 = vec_xl(0, (nk_u8_t const *)(a + i));
+        nk_vu8x16_t b_u8x16 = vec_xl(0, (nk_u8_t const *)(b + i));
+        nk_vu64x2_t and_popcnt_u64x2 = vec_popcnt((nk_vu64x2_t)vec_and(a_u8x16, b_u8x16));
+        nk_vu64x2_t or_popcnt_u64x2 = vec_popcnt((nk_vu64x2_t)vec_or(a_u8x16, b_u8x16));
+        intersection_u64x2 = vec_add(intersection_u64x2, and_popcnt_u64x2);
+        union_u64x2 = vec_add(union_u64x2, or_popcnt_u64x2);
+    }
+    // Branchless tail
+    nk_size_t remaining_bytes = n_bytes - i;
+    nk_vu8x16_t a_u8x16 = vec_xl_len((nk_u8_t *)(a + i), remaining_bytes);
+    nk_vu8x16_t b_u8x16 = vec_xl_len((nk_u8_t *)(b + i), remaining_bytes);
+    nk_vu64x2_t and_popcnt_u64x2 = vec_popcnt((nk_vu64x2_t)vec_and(a_u8x16, b_u8x16));
+    nk_vu64x2_t or_popcnt_u64x2 = vec_popcnt((nk_vu64x2_t)vec_or(a_u8x16, b_u8x16));
+    intersection_u64x2 = vec_add(intersection_u64x2, and_popcnt_u64x2);
+    union_u64x2 = vec_add(union_u64x2, or_popcnt_u64x2);
+    nk_u32_t intersection_count = (nk_u32_t)nk_hsum_u64x2_powervsx_(intersection_u64x2);
+    nk_u32_t union_count = (nk_u32_t)nk_hsum_u64x2_powervsx_(union_u64x2);
+    *result = (union_count != 0) ? 1.0f - (nk_f32_t)intersection_count / (nk_f32_t)union_count : 0.0f;
+}
+
+NK_PUBLIC void nk_hamming_u8_powervsx(nk_u8_t const *a, nk_u8_t const *b, nk_size_t n, nk_u32_t *result) {
+    nk_vu32x4_t differences_u32x4 = vec_splats((nk_u32_t)0);
+    nk_vu8x16_t ones_u8x16 = vec_splats((nk_u8_t)1);
+    nk_size_t i = 0;
+    // Process 16 bytes at a time using vec_cmpne
+    for (; i + 16 <= n; i += 16) {
+        nk_vu8x16_t a_u8x16 = vec_xl(0, (nk_u8_t const *)(a + i));
+        nk_vu8x16_t b_u8x16 = vec_xl(0, (nk_u8_t const *)(b + i));
+        // vec_cmpne returns 0xFF for not-equal, 0x00 for equal
+        // AND with 1 to get 0x01 for not-equal, then sum groups of 4 bytes → u32
+        nk_vu8x16_t not_equal_u8x16 = vec_and((nk_vu8x16_t)vec_cmpne(a_u8x16, b_u8x16), ones_u8x16);
+        differences_u32x4 = vec_sum4s(not_equal_u8x16, differences_u32x4);
+    }
+    // Branchless tail
+    nk_size_t remaining_bytes = n - i;
+    nk_vu8x16_t a_u8x16 = vec_xl_len((nk_u8_t *)(a + i), remaining_bytes);
+    nk_vu8x16_t b_u8x16 = vec_xl_len((nk_u8_t *)(b + i), remaining_bytes);
+    nk_vu8x16_t not_equal_u8x16 = vec_and((nk_vu8x16_t)vec_cmpne(a_u8x16, b_u8x16), ones_u8x16);
+    differences_u32x4 = vec_sum4s(not_equal_u8x16, differences_u32x4);
+    *result = nk_hsum_u32x4_powervsx_(differences_u32x4);
+}
+
+typedef struct nk_hamming_u1x128_state_powervsx_t {
+    nk_vu32x4_t intersection_count_u32x4;
+} nk_hamming_u1x128_state_powervsx_t;
+
+NK_INTERNAL void nk_hamming_u1x128_init_powervsx(nk_hamming_u1x128_state_powervsx_t *state) {
+    state->intersection_count_u32x4 = vec_splats((nk_u32_t)0);
+}
+
+NK_INTERNAL void nk_hamming_u1x128_update_powervsx(nk_hamming_u1x128_state_powervsx_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);
+
+    // Process one 128-bit chunk (native VSX register size).
+    // Uses vector accumulation → horizontal sum deferred to finalize.
+    //
+    // Power9 VSX instruction characteristics:
+    // - `vec_xor`:     xxlxor (V, V, V)             1cy, bitwise XOR
+    // - `vec_popcnt`:  vpopcntw (V.4S, V.4S)        3cy, word popcount
+    // - `vec_add`:     vadduwm (V.4S, V.4S, V.4S)   2cy, u32 add
+    // Total: ~6cy per 128-bit chunk (horizontal sum deferred to finalize)
+
+    // Step 1: Compute difference bits (A XOR B)
+    nk_vu8x16_t a_u8x16 = *(nk_vu8x16_t *)&a;
+    nk_vu8x16_t b_u8x16 = *(nk_vu8x16_t *)&b;
+    nk_vu8x16_t xor_u8x16 = vec_xor(a_u8x16, b_u8x16);
+
+    // Step 2: Word popcount → each u32 lane contains set bits for 4 bytes
+    nk_vu32x4_t popcnt_u32x4 = vec_popcnt((nk_vu32x4_t)xor_u8x16);
+
+    // Step 3: Vector accumulation (defers horizontal sum to finalize)
+    state->intersection_count_u32x4 = vec_add(state->intersection_count_u32x4, popcnt_u32x4);
+}
+
+NK_INTERNAL void nk_hamming_u1x128_finalize_powervsx( //
+    nk_hamming_u1x128_state_powervsx_t const *state_a, nk_hamming_u1x128_state_powervsx_t const *state_b,
+    nk_hamming_u1x128_state_powervsx_t const *state_c, nk_hamming_u1x128_state_powervsx_t const *state_d,
+    nk_size_t total_dimensions, nk_b128_vec_t *result) {
+    nk_unused_(total_dimensions);
+
+    nk_vu32x4_t a_u32x4 = state_a->intersection_count_u32x4, b_u32x4 = state_b->intersection_count_u32x4,
+                c_u32x4 = state_c->intersection_count_u32x4, d_u32x4 = state_d->intersection_count_u32x4;
+    nk_vu32x4_t transpose_ab_low_u32x4 = vec_mergeh(a_u32x4, b_u32x4);
+    nk_vu32x4_t transpose_cd_low_u32x4 = vec_mergeh(c_u32x4, d_u32x4);
+    nk_vu32x4_t transpose_ab_high_u32x4 = vec_mergel(a_u32x4, b_u32x4);
+    nk_vu32x4_t transpose_cd_high_u32x4 = vec_mergel(c_u32x4, d_u32x4);
+    nk_vu32x4_t sum_lane0_u32x4 = (nk_vu32x4_t)vec_xxpermdi((nk_vu64x2_t)transpose_ab_low_u32x4,
+                                                            (nk_vu64x2_t)transpose_cd_low_u32x4, 0);
+    nk_vu32x4_t sum_lane1_u32x4 = (nk_vu32x4_t)vec_xxpermdi((nk_vu64x2_t)transpose_ab_low_u32x4,
+                                                            (nk_vu64x2_t)transpose_cd_low_u32x4, 3);
+    nk_vu32x4_t sum_lane2_u32x4 = (nk_vu32x4_t)vec_xxpermdi((nk_vu64x2_t)transpose_ab_high_u32x4,
+                                                            (nk_vu64x2_t)transpose_cd_high_u32x4, 0);
+    nk_vu32x4_t sum_lane3_u32x4 = (nk_vu32x4_t)vec_xxpermdi((nk_vu64x2_t)transpose_ab_high_u32x4,
+                                                            (nk_vu64x2_t)transpose_cd_high_u32x4, 3);
+    result->vu32x4 = vec_add(vec_add(sum_lane0_u32x4, sum_lane1_u32x4), vec_add(sum_lane2_u32x4, sum_lane3_u32x4));
+}
+
+typedef struct nk_jaccard_u1x128_state_powervsx_t {
+    nk_vu32x4_t intersection_count_u32x4;
+} nk_jaccard_u1x128_state_powervsx_t;
+
+NK_INTERNAL void nk_jaccard_u1x128_init_powervsx(nk_jaccard_u1x128_state_powervsx_t *state) {
+    state->intersection_count_u32x4 = vec_splats((nk_u32_t)0);
+}
+
+NK_INTERNAL void nk_jaccard_u1x128_update_powervsx(nk_jaccard_u1x128_state_powervsx_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);
+
+    // Process one 128-bit chunk (native VSX register size).
+    // Uses vector accumulation → horizontal sum deferred to finalize.
+    //
+    // Power9 VSX instruction characteristics:
+    // - `vec_and`:     xxland (V, V, V)              1cy, bitwise AND
+    // - `vec_popcnt`:  vpopcntw (V.4S, V.4S)         3cy, word popcount
+    // - `vec_add`:     vadduwm (V.4S, V.4S, V.4S)    2cy, u32 add
+    // Total: ~6cy per 128-bit chunk (horizontal sum deferred to finalize)
+
+    // Step 1: Compute intersection bits (A AND B)
+    nk_vu8x16_t a_u8x16 = *(nk_vu8x16_t *)&a;
+    nk_vu8x16_t b_u8x16 = *(nk_vu8x16_t *)&b;
+    nk_vu8x16_t intersection_u8x16 = vec_and(a_u8x16, b_u8x16);
+
+    // Step 2: Word popcount → each u32 lane contains set bits for 4 bytes
+    nk_vu32x4_t popcnt_u32x4 = vec_popcnt((nk_vu32x4_t)intersection_u8x16);
+
+    // Step 3: Vector accumulation (defers horizontal sum to finalize)
+    state->intersection_count_u32x4 = vec_add(state->intersection_count_u32x4, popcnt_u32x4);
+}
+
+NK_INTERNAL void nk_jaccard_u1x128_finalize_powervsx( //
+    nk_jaccard_u1x128_state_powervsx_t const *state_a, nk_jaccard_u1x128_state_powervsx_t const *state_b,
+    nk_jaccard_u1x128_state_powervsx_t const *state_c, nk_jaccard_u1x128_state_powervsx_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);
+
+    // Transpose-based 4-way horizontal sum of u32x4 intersection counts
+    nk_vu32x4_t a_u32x4 = state_a->intersection_count_u32x4, b_u32x4 = state_b->intersection_count_u32x4,
+                c_u32x4 = state_c->intersection_count_u32x4, d_u32x4 = state_d->intersection_count_u32x4;
+    nk_vu32x4_t transpose_ab_low_u32x4 = vec_mergeh(a_u32x4, b_u32x4);
+    nk_vu32x4_t transpose_cd_low_u32x4 = vec_mergeh(c_u32x4, d_u32x4);
+    nk_vu32x4_t transpose_ab_high_u32x4 = vec_mergel(a_u32x4, b_u32x4);
+    nk_vu32x4_t transpose_cd_high_u32x4 = vec_mergel(c_u32x4, d_u32x4);
+    nk_vu32x4_t sum_lane0_u32x4 = (nk_vu32x4_t)vec_xxpermdi((nk_vu64x2_t)transpose_ab_low_u32x4,
+                                                            (nk_vu64x2_t)transpose_cd_low_u32x4, 0);
+    nk_vu32x4_t sum_lane1_u32x4 = (nk_vu32x4_t)vec_xxpermdi((nk_vu64x2_t)transpose_ab_low_u32x4,
+                                                            (nk_vu64x2_t)transpose_cd_low_u32x4, 3);
+    nk_vu32x4_t sum_lane2_u32x4 = (nk_vu32x4_t)vec_xxpermdi((nk_vu64x2_t)transpose_ab_high_u32x4,
+                                                            (nk_vu64x2_t)transpose_cd_high_u32x4, 0);
+    nk_vu32x4_t sum_lane3_u32x4 = (nk_vu32x4_t)vec_xxpermdi((nk_vu64x2_t)transpose_ab_high_u32x4,
+                                                            (nk_vu64x2_t)transpose_cd_high_u32x4, 3);
+    nk_vu32x4_t intersection_u32x4 = vec_add(vec_add(sum_lane0_u32x4, sum_lane1_u32x4),
+                                             vec_add(sum_lane2_u32x4, sum_lane3_u32x4));
+    nk_vf32x4_t intersection_f32x4 = vec_ctf(intersection_u32x4, 0);
+
+    // Build target popcounts vector via vec_insert
+    nk_vf32x4_t targets_f32x4 = vec_splats(0.0f);
+    targets_f32x4 = vec_insert(target_popcount_a, targets_f32x4, 0);
+    targets_f32x4 = vec_insert(target_popcount_b, targets_f32x4, 1);
+    targets_f32x4 = vec_insert(target_popcount_c, targets_f32x4, 2);
+    targets_f32x4 = vec_insert(target_popcount_d, targets_f32x4, 3);
+    nk_vf32x4_t query_f32x4 = vec_splats(query_popcount);
+
+    // Compute union using |A union B| = |A| + |B| - |A intersection B|
+    nk_vf32x4_t union_f32x4 = vec_sub(vec_add(query_f32x4, targets_f32x4), intersection_f32x4);
+
+    // Handle zero-union edge case (empty vectors → distance = 0.0)
+    nk_vf32x4_t one_f32x4 = vec_splats(1.0f);
+    nk_vf32x4_t zero_f32x4 = vec_splats(0.0f);
+    nk_vu32x4_t zero_union_mask_u32x4 = (nk_vu32x4_t)vec_cmpeq(union_f32x4, zero_f32x4);
+    nk_vf32x4_t safe_union_f32x4 = vec_sel(union_f32x4, one_f32x4, zero_union_mask_u32x4);
+
+    // Fast reciprocal with Newton-Raphson refinement
+    nk_vf32x4_t union_reciprocal_f32x4 = vec_re(safe_union_f32x4);
+    // One Newton-Raphson step: reciprocal = reciprocal × (2 - value * reciprocal)
+    nk_vf32x4_t two_f32x4 = vec_splats(2.0f);
+    union_reciprocal_f32x4 = vec_mul(union_reciprocal_f32x4,
+                                     vec_sub(two_f32x4, vec_mul(safe_union_f32x4, union_reciprocal_f32x4)));
+
+    // Compute Jaccard distance = 1 - intersection / union
+    nk_vf32x4_t ratio_f32x4 = vec_mul(intersection_f32x4, union_reciprocal_f32x4);
+    nk_vf32x4_t jaccard_f32x4 = vec_sub(one_f32x4, ratio_f32x4);
+    result->vf32x4 = vec_sel(jaccard_f32x4, zero_f32x4, zero_union_mask_u32x4);
+}
+
+/** @brief Hamming from_dot: computes pop_a + pop_b - 2 × dot for 4 pairs (Power VSX). */
+NK_INTERNAL void nk_hamming_u32x4_from_dot_powervsx_(nk_b128_vec_t dots, nk_u32_t query_pop, nk_b128_vec_t target_pops,
+                                                     nk_b128_vec_t *results) {
+    nk_vu32x4_t dots_u32x4 = dots.vu32x4;
+    nk_vu32x4_t query_u32x4 = vec_splats(query_pop);
+    nk_vu32x4_t target_u32x4 = target_pops.vu32x4;
+    nk_vu32x4_t two_dots_u32x4 = vec_add(dots_u32x4, dots_u32x4);
+    results->vu32x4 = vec_sub(vec_add(query_u32x4, target_u32x4), two_dots_u32x4);
+}
+
+/** @brief Jaccard from_dot: computes 1 - dot / (pop_a + pop_b - dot) for 4 pairs (Power VSX). */
+NK_INTERNAL void nk_jaccard_f32x4_from_dot_powervsx_(nk_b128_vec_t dots, nk_u32_t query_pop, nk_b128_vec_t target_pops,
+                                                     nk_b128_vec_t *results) {
+    nk_vf32x4_t dot_f32x4 = vec_ctf(dots.vu32x4, 0);
+    nk_vf32x4_t query_f32x4 = vec_splats((nk_f32_t)query_pop);
+    nk_vf32x4_t target_f32x4 = vec_ctf(target_pops.vu32x4, 0);
+    nk_vf32x4_t union_f32x4 = vec_sub(vec_add(query_f32x4, target_f32x4), dot_f32x4);
+
+    nk_vf32x4_t one_f32x4 = vec_splats(1.0f);
+    nk_vf32x4_t zero_f32x4 = vec_splats(0.0f);
+    nk_vu32x4_t zero_union_mask_u32x4 = (nk_vu32x4_t)vec_cmpeq(union_f32x4, zero_f32x4);
+    nk_vf32x4_t safe_union_f32x4 = vec_sel(union_f32x4, one_f32x4, zero_union_mask_u32x4);
+
+    // Fast reciprocal with Newton-Raphson
+    nk_vf32x4_t union_reciprocal_f32x4 = vec_re(safe_union_f32x4);
+    nk_vf32x4_t two_f32x4 = vec_splats(2.0f);
+    union_reciprocal_f32x4 = vec_mul(union_reciprocal_f32x4,
+                                     vec_sub(two_f32x4, vec_mul(safe_union_f32x4, union_reciprocal_f32x4)));
+
+    nk_vf32x4_t ratio_f32x4 = vec_mul(dot_f32x4, union_reciprocal_f32x4);
+    nk_vf32x4_t jaccard_f32x4 = vec_sub(one_f32x4, ratio_f32x4);
+    results->vf32x4 = vec_sel(jaccard_f32x4, zero_f32x4, zero_union_mask_u32x4);
+}
+
+#if defined(__clang__)
+#pragma clang attribute pop
+#elif defined(__GNUC__)
+#pragma GCC pop_options
+#endif
+
+#if defined(__cplusplus)
+} // extern "C"
+#endif
+
+#endif // NK_TARGET_POWERVSX
+#endif // NK_TARGET_POWER_
+#endif // NK_SET_POWERVSX_H

package/include/numkong/set/rvv.h

@@ -50,7 +50,7 @@
 extern "C" {
 #endif
 
-#pragma region - Binary Sets
+#pragma region Binary Sets
 
 /**
  *  @brief  Compute byte-level popcount using arithmetic SWAR.
@@ -142,9 +142,9 @@ NK_PUBLIC void nk_jaccard_u1_rvv(nk_u1x8_t const *a, nk_u1x8_t const *b, nk_size
     *result = (union_count_u32 != 0) ? 1.0f - (nk_f32_t)intersection_count_u32 / (nk_f32_t)union_count_u32 : 0.0f;
 }
 
-#pragma endregion - Binary Sets
+#pragma endregion Binary Sets
 
-#pragma region - Integer Sets
+#pragma region Integer Sets
 
 NK_PUBLIC void nk_hamming_u8_rvv(nk_u8_t const *a, nk_u8_t const *b, nk_size_t n, nk_u32_t *result) {
     vuint32m1_t difference_count_u32m1 = __riscv_vmv_v_x_u32m1(0, 1);
@@ -209,7 +209,7 @@ NK_PUBLIC void nk_jaccard_u16_rvv(nk_u16_t const *a, nk_u16_t const *b, nk_size_
     *result = (n != 0) ? 1.0f - (nk_f32_t)match_count_u32 / (nk_f32_t)n : 0.0f;
 }
 
-#pragma endregion - Integer Sets
+#pragma endregion Integer Sets
 
 #if defined(__cplusplus)
 } // extern "C"

package/include/numkong/set/serial.h

@@ -35,7 +35,7 @@
 extern "C" {
 #endif
 
-#pragma region - Binary Sets
+#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);
@@ -52,9 +52,9 @@ NK_PUBLIC void nk_jaccard_u1_serial(nk_u1x8_t const *a, nk_u1x8_t const *b, nk_s
     *result = (union_count != 0) ? 1.0f - (nk_f32_t)intersection_count / (nk_f32_t)union_count : 0.0f;
 }
 
-#pragma endregion - Binary Sets
+#pragma endregion Binary Sets
 
-#pragma region - Integer 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;
@@ -74,9 +74,9 @@ NK_PUBLIC void nk_jaccard_u16_serial(nk_u16_t const *a, nk_u16_t const *b, nk_si
     *result = (n != 0) ? 1.0f - (nk_f32_t)matches / (nk_f32_t)n : 0.0f;
 }
 
-#pragma endregion - Integer Sets
+#pragma endregion Integer Sets
 
-#pragma region - Stateful Streaming
+#pragma region Stateful Streaming
 
 typedef struct nk_jaccard_u1x128_state_serial_t {
     nk_u64_t intersection_count;
@@ -165,7 +165,7 @@ NK_INTERNAL void nk_jaccard_f32x4_from_dot_serial_(nk_b128_vec_t dots, nk_u32_t
     }
 }
 
-#pragma endregion - Stateful Streaming
+#pragma endregion Stateful Streaming
 
 #if defined(__cplusplus)
 } // extern "C"