numkong 7.0.0 → 7.4.2

package/include/numkong/scalar/neon.h

@@ -8,13 +8,13 @@
  *
  *  @section scalars_neon_instructions Key NEON Scalar Instructions
  *
- *      Intrinsic           Instruction                     Latency     Throughput
- *      vsqrt_f32           FSQRT (S)                       9-12cy      0.25/cy
- *      vsqrt_f64           FSQRT (D)                       12-18cy     0.25/cy
- *      vfmas_f32           FMADD (S, S, S, S)              4cy         2/cy
- *      vfmad_f64           FMADD (D, D, D, D)              4cy         2/cy
- *      vqaddb_u8           UQADD (B)                       1cy         4/cy
- *      vqaddb_s8           SQADD (B)                       1cy         4/cy
+ *      Intrinsic  Instruction         A76        M5
+ *      vsqrt_f32  FSQRT (S)           12cy @ 1p  9cy @ 1p
+ *      vsqrt_f64  FSQRT (D)           12cy @ 1p  9cy @ 1p
+ *      vfmas_f32  FMADD (S, S, S, S)  4cy @ 2p   3cy @ 4p
+ *      vfmad_f64  FMADD (D, D, D, D)  4cy @ 2p   3cy @ 4p
+ *      vqaddb_u8  UQADD (B)           2cy @ 2p   3cy @ 2p
+ *      vqaddb_s8  SQADD (B)           2cy @ 2p   3cy @ 2p
  */
 #ifndef NK_SCALAR_NEON_H
 #define NK_SCALAR_NEON_H
@@ -98,8 +98,8 @@ NK_PUBLIC nk_u64_t nk_u64_saturating_mul_neon(nk_u64_t a, nk_u64_t b) {
 }
 NK_PUBLIC nk_i64_t nk_i64_saturating_mul_neon(nk_i64_t a, nk_i64_t b) {
     int sign = (a < 0) ^ (b < 0);
-    nk_u64_t abs_a = a < 0 ? -(nk_u64_t)a : (nk_u64_t)a;
-    nk_u64_t abs_b = b < 0 ? -(nk_u64_t)b : (nk_u64_t)b;
+    nk_u64_t abs_a = a < 0 ? (0u - (nk_u64_t)a) : (nk_u64_t)a;
+    nk_u64_t abs_b = b < 0 ? (0u - (nk_u64_t)b) : (nk_u64_t)b;
     nk_u64_t high = nk_u64_mulhigh_neon_(abs_a, abs_b);
     nk_u64_t low = abs_a * abs_b;
     if (high || (sign && low > 9223372036854775808ull) || (!sign && low > 9223372036854775807ull))

package/include/numkong/scalar/powervsx.h

@@ -0,0 +1,96 @@
+/**
+ *  @brief SIMD-accelerated Scalar Math Helpers for Power VSX.
+ *  @file include/numkong/scalar/powervsx.h
+ *  @author Ash Vardanian
+ *  @date March 24, 2026
+ *
+ *  @sa include/numkong/scalar.h
+ *
+ *  @section scalars_powervsx_instructions Key Power VSX Scalar Instructions
+ *
+ *      Instruction     Description                  Latency
+ *      xssqrtsp        Scalar √ (f32)               26cy
+ *      xssqrtdp        Scalar √ (f64)               33cy
+ *      xsrsqrtesp      Scalar 1/√ estimate (f32)    6cy
+ *      xsrsqrtedp      Scalar 1/√ estimate (f64)    6cy
+ *      xsmaddadp       Scalar FMA (f64)             5cy
+ *      xsmaddasp       Scalar FMA (f32)             5cy
+ */
+#ifndef NK_SCALAR_POWERVSX_H
+#define NK_SCALAR_POWERVSX_H
+
+#if NK_TARGET_POWER_
+#if NK_TARGET_POWERVSX
+
+#include "numkong/types.h"
+
+#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 nk_f32_t nk_f32_sqrt_powervsx(nk_f32_t x) {
+    nk_f32_t result;
+    __asm__("xssqrtsp %0, %1" : "=f"(result) : "f"(x));
+    return result;
+}
+NK_PUBLIC nk_f64_t nk_f64_sqrt_powervsx(nk_f64_t x) {
+    nk_f64_t result;
+    __asm__("xssqrtdp %0, %1" : "=d"(result) : "d"(x));
+    return result;
+}
+NK_PUBLIC nk_f32_t nk_f32_rsqrt_powervsx(nk_f32_t x) {
+    // xsrsqrtesp → ~12-bit estimate, then 2 Newton→Raphson iterations → ~24-bit precision
+    nk_f32_t r;
+    __asm__("xsrsqrtesp %0, %1" : "=f"(r) : "f"(x));
+    // Newton→Raphson: r = r * (3 - x * r * r) / 2
+    nk_f32_t half_x = x * 0.5f;
+    nk_f32_t three_half = 1.5f;
+    r = r * (three_half - half_x * r * r);
+    r = r * (three_half - half_x * r * r);
+    return r;
+}
+NK_PUBLIC nk_f64_t nk_f64_rsqrt_powervsx(nk_f64_t x) {
+    // xsrsqrtedp → ~14-bit estimate, then 3 Newton→Raphson iterations → ~48-bit precision
+    nk_f64_t r;
+    __asm__("xsrsqrtedp %0, %1" : "=d"(r) : "d"(x));
+    // Newton→Raphson: r = r * (3 - x * r * r) / 2
+    nk_f64_t half_x = x * 0.5;
+    nk_f64_t three_half = 1.5;
+    r = r * (three_half - half_x * r * r);
+    r = r * (three_half - half_x * r * r);
+    r = r * (three_half - half_x * r * r);
+    return r;
+}
+NK_PUBLIC nk_f32_t nk_f32_fma_powervsx(nk_f32_t a, nk_f32_t b, nk_f32_t c) {
+    // xsmaddasp: result = a * b + c (scalar f32 FMA)
+    nk_f32_t r = c;
+    __asm__("xsmaddasp %0, %1, %2" : "+f"(r) : "f"(a), "f"(b));
+    return r;
+}
+NK_PUBLIC nk_f64_t nk_f64_fma_powervsx(nk_f64_t a, nk_f64_t b, nk_f64_t c) {
+    // xsmaddadp: result = a * b + c (scalar f64 FMA)
+    nk_f64_t r = c;
+    __asm__("xsmaddadp %0, %1, %2" : "+d"(r) : "d"(a), "d"(b));
+    return r;
+}
+
+#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_SCALAR_POWERVSX_H

package/include/numkong/scalar/rvv.h

@@ -185,8 +185,8 @@ NK_PUBLIC nk_u64_t nk_u64_saturating_mul_rvv(nk_u64_t a, nk_u64_t b) {
 }
 NK_PUBLIC nk_i64_t nk_i64_saturating_mul_rvv(nk_i64_t a, nk_i64_t b) {
     int sign = (a < 0) ^ (b < 0);
-    nk_u64_t abs_a = a < 0 ? -(nk_u64_t)a : (nk_u64_t)a;
-    nk_u64_t abs_b = b < 0 ? -(nk_u64_t)b : (nk_u64_t)b;
+    nk_u64_t abs_a = a < 0 ? (0u - (nk_u64_t)a) : (nk_u64_t)a;
+    nk_u64_t abs_b = b < 0 ? (0u - (nk_u64_t)b) : (nk_u64_t)b;
     vuint64m1_t a_u64m1 = __riscv_vmv_v_x_u64m1(abs_a, 1);
     vuint64m1_t b_u64m1 = __riscv_vmv_v_x_u64m1(abs_b, 1);
     nk_u64_t high = __riscv_vmv_x_s_u64m1_u64(__riscv_vmulhu_vv_u64m1(a_u64m1, b_u64m1, 1));

package/include/numkong/scalar/sapphire.h

@@ -29,23 +29,34 @@ extern "C" {
 #endif
 
 NK_PUBLIC int nk_f16_order_sapphire(nk_f16_t a, nk_f16_t b) {
-    __m128h a_f16x8 = _mm_castsi128_ph(_mm_cvtsi32_si128(a));
-    __m128h b_f16x8 = _mm_castsi128_ph(_mm_cvtsi32_si128(b));
+    nk_fui16_t a_fui, b_fui;
+    a_fui.f = a, b_fui.f = b;
+    __m128h a_f16x8 = _mm_castsi128_ph(_mm_cvtsi32_si128(a_fui.u));
+    __m128h b_f16x8 = _mm_castsi128_ph(_mm_cvtsi32_si128(b_fui.u));
     return _mm_comigt_sh(a_f16x8, b_f16x8) - _mm_comilt_sh(a_f16x8, b_f16x8);
 }
 NK_PUBLIC nk_f16_t nk_f16_sqrt_sapphire(nk_f16_t x) {
-    __m128h x_f16x8 = _mm_castsi128_ph(_mm_cvtsi32_si128(x));
-    return (nk_f16_t)_mm_cvtsi128_si32(_mm_castph_si128(_mm_sqrt_sh(x_f16x8, x_f16x8)));
+    nk_fui16_t x_fui, out_fui;
+    x_fui.f = x;
+    __m128h x_f16x8 = _mm_castsi128_ph(_mm_cvtsi32_si128(x_fui.u));
+    out_fui.u = (nk_u16_t)_mm_cvtsi128_si32(_mm_castph_si128(_mm_sqrt_sh(x_f16x8, x_f16x8)));
+    return out_fui.f;
 }
 NK_PUBLIC nk_f16_t nk_f16_rsqrt_sapphire(nk_f16_t x) {
-    __m128h x_f16x8 = _mm_castsi128_ph(_mm_cvtsi32_si128(x));
-    return (nk_f16_t)_mm_cvtsi128_si32(_mm_castph_si128(_mm_rsqrt_sh(x_f16x8, x_f16x8)));
+    nk_fui16_t x_fui, out_fui;
+    x_fui.f = x;
+    __m128h x_f16x8 = _mm_castsi128_ph(_mm_cvtsi32_si128(x_fui.u));
+    out_fui.u = (nk_u16_t)_mm_cvtsi128_si32(_mm_castph_si128(_mm_rsqrt_sh(x_f16x8, x_f16x8)));
+    return out_fui.f;
 }
 NK_PUBLIC nk_f16_t nk_f16_fma_sapphire(nk_f16_t a, nk_f16_t b, nk_f16_t c) {
-    __m128h a_f16x8 = _mm_castsi128_ph(_mm_cvtsi32_si128(a));
-    __m128h b_f16x8 = _mm_castsi128_ph(_mm_cvtsi32_si128(b));
-    __m128h c_f16x8 = _mm_castsi128_ph(_mm_cvtsi32_si128(c));
-    return (nk_f16_t)_mm_cvtsi128_si32(_mm_castph_si128(_mm_fmadd_sh(a_f16x8, b_f16x8, c_f16x8)));
+    nk_fui16_t a_fui, b_fui, c_fui, out_fui;
+    a_fui.f = a, b_fui.f = b, c_fui.f = c;
+    __m128h a_f16x8 = _mm_castsi128_ph(_mm_cvtsi32_si128(a_fui.u));
+    __m128h b_f16x8 = _mm_castsi128_ph(_mm_cvtsi32_si128(b_fui.u));
+    __m128h c_f16x8 = _mm_castsi128_ph(_mm_cvtsi32_si128(c_fui.u));
+    out_fui.u = (nk_u16_t)_mm_cvtsi128_si32(_mm_castph_si128(_mm_fmadd_sh(a_f16x8, b_f16x8, c_f16x8)));
+    return out_fui.f;
 }
 
 #if defined(__clang__)

package/include/numkong/scalar/serial.h

@@ -74,16 +74,16 @@ NK_PUBLIC nk_f64_t nk_f64_fma_serial(nk_f64_t multiplicand, nk_f64_t multiplier,
     nk_f64_t product = multiplicand * multiplier;
     // Dekker splitting: break each operand into non-overlapping high and low halves
     nk_f64_t const dekker_split = 134217729.0; // 2^27 + 1 for double precision
-    nk_f64_t multiplicand_hi = dekker_split * multiplicand;
-    nk_f64_t multiplicand_lo = multiplicand - (multiplicand_hi - (multiplicand_hi - multiplicand));
-    multiplicand_hi = multiplicand_hi - (multiplicand_hi - multiplicand);
-    nk_f64_t multiplier_hi = dekker_split * multiplier;
-    nk_f64_t multiplier_lo = multiplier - (multiplier_hi - (multiplier_hi - multiplier));
-    multiplier_hi = multiplier_hi - (multiplier_hi - multiplier);
+    nk_f64_t multiplicand_high = dekker_split * multiplicand;
+    nk_f64_t multiplicand_low = multiplicand - (multiplicand_high - (multiplicand_high - multiplicand));
+    multiplicand_high = multiplicand_high - (multiplicand_high - multiplicand);
+    nk_f64_t multiplier_high = dekker_split * multiplier;
+    nk_f64_t multiplier_low = multiplier - (multiplier_high - (multiplier_high - multiplier));
+    multiplier_high = multiplier_high - (multiplier_high - multiplier);
     // Exact multiplication error from the four cross-products
-    nk_f64_t product_error = ((multiplicand_hi * multiplier_hi - product) + multiplicand_hi * multiplier_lo +
-                              multiplicand_lo * multiplier_hi) +
-                             multiplicand_lo * multiplier_lo;
+    nk_f64_t product_error = ((multiplicand_high * multiplier_high - product) + multiplicand_high * multiplier_low +
+                              multiplicand_low * multiplier_high) +
+                             multiplicand_low * multiplier_low;
     // Knuth TwoSum: add the addend with error tracking
     nk_f64_t result = product + addend;
     nk_f64_t addend_recovered = result - product;
@@ -102,16 +102,16 @@ NK_PUBLIC nk_f32_t nk_f32_fma_serial(nk_f32_t multiplicand, nk_f32_t multiplier,
     nk_f32_t product = multiplicand * multiplier;
     // Dekker splitting: break each operand into non-overlapping high and low halves
     nk_f32_t const dekker_split = 4097.0f; // 2^12 + 1 for single precision
-    nk_f32_t multiplicand_hi = dekker_split * multiplicand;
-    nk_f32_t multiplicand_lo = multiplicand - (multiplicand_hi - (multiplicand_hi - multiplicand));
-    multiplicand_hi = multiplicand_hi - (multiplicand_hi - multiplicand);
-    nk_f32_t multiplier_hi = dekker_split * multiplier;
-    nk_f32_t multiplier_lo = multiplier - (multiplier_hi - (multiplier_hi - multiplier));
-    multiplier_hi = multiplier_hi - (multiplier_hi - multiplier);
+    nk_f32_t multiplicand_high = dekker_split * multiplicand;
+    nk_f32_t multiplicand_low = multiplicand - (multiplicand_high - (multiplicand_high - multiplicand));
+    multiplicand_high = multiplicand_high - (multiplicand_high - multiplicand);
+    nk_f32_t multiplier_high = dekker_split * multiplier;
+    nk_f32_t multiplier_low = multiplier - (multiplier_high - (multiplier_high - multiplier));
+    multiplier_high = multiplier_high - (multiplier_high - multiplier);
     // Exact multiplication error from the four cross-products
-    nk_f32_t product_error = ((multiplicand_hi * multiplier_hi - product) + multiplicand_hi * multiplier_lo +
-                              multiplicand_lo * multiplier_hi) +
-                             multiplicand_lo * multiplier_lo;
+    nk_f32_t product_error = ((multiplicand_high * multiplier_high - product) + multiplicand_high * multiplier_low +
+                              multiplicand_low * multiplier_high) +
+                             multiplicand_low * multiplier_low;
     // Knuth TwoSum: add the addend with error tracking
     nk_f32_t result = product + addend;
     nk_f32_t addend_recovered = result - product;
@@ -125,7 +125,7 @@ NK_PUBLIC nk_f32_t nk_f32_fma_serial(nk_f32_t multiplicand, nk_f32_t multiplier,
  *  Uses TwoProd (via FMA) and TwoSum error-free transformations.
  *  @see Ogita, T., Rump, S.M., Oishi, S. (2005). "Accurate Sum and Dot Product"
  */
-NK_INTERNAL void nk_f64_dot2_(nk_f64_t *sum, nk_f64_t *compensation, nk_f64_t a, nk_f64_t b) {
+NK_INTERNAL void nk_f64_dot2_(nk_f64_t *sum, nk_f64_t *compensation, nk_f64_t a, nk_f64_t b) NK_STREAMING_COMPATIBLE_ {
     nk_f64_t product = a * b;
     nk_f64_t product_error = nk_f64_fma_serial(a, b, -product);
     nk_f64_t running_sum = *sum + product;
@@ -238,8 +238,8 @@ NK_PUBLIC nk_i64_t nk_i64_saturating_mul_serial(nk_i64_t a, nk_i64_t b) {
     int sign = ((a < 0) ^ (b < 0)) ? -1 : 1; // Track the sign of the result
 
     // Take absolute values for easy multiplication and overflow detection
-    nk_u64_t abs_a = (a < 0) ? -(nk_u64_t)a : (nk_u64_t)a;
-    nk_u64_t abs_b = (b < 0) ? -(nk_u64_t)b : (nk_u64_t)b;
+    nk_u64_t abs_a = (a < 0) ? (0u - (nk_u64_t)a) : (nk_u64_t)a;
+    nk_u64_t abs_b = (b < 0) ? (0u - (nk_u64_t)b) : (nk_u64_t)b;
 
     // Split the absolute values into high and low 32-bit parts
     nk_u64_t a_high = abs_a >> 32;

package/include/numkong/scalar.h

@@ -383,6 +383,7 @@ NK_PUBLIC nk_f64_t nk_f64_fma_v128relaxed(nk_f64_t a, nk_f64_t b, nk_f64_t c);
 #include "numkong/scalar/haswell.h"     // `nk_f32_sqrt_haswell`
 #include "numkong/scalar/sapphire.h"    // `nk_f16_order_sapphire`
 #include "numkong/scalar/rvv.h"         // `nk_f32_rsqrt_rvv`
+#include "numkong/scalar/powervsx.h"    // `nk_f32_sqrt_powervsx`
 #include "numkong/scalar/v128relaxed.h" // `nk_f32_sqrt_v128relaxed`
 
 #if defined(__cplusplus)
@@ -396,6 +397,8 @@ NK_PUBLIC nk_f32_t nk_f32_sqrt(nk_f32_t x) {
     return nk_f32_sqrt_haswell(x);
 #elif NK_TARGET_NEON
     return nk_f32_sqrt_neon(x);
+#elif NK_TARGET_POWERVSX
+    return nk_f32_sqrt_powervsx(x);
 #elif NK_TARGET_RVV
     return nk_f32_sqrt_rvv(x);
 #elif NK_TARGET_V128RELAXED
@@ -410,6 +413,8 @@ NK_PUBLIC nk_f64_t nk_f64_sqrt(nk_f64_t x) {
     return nk_f64_sqrt_haswell(x);
 #elif NK_TARGET_NEON
     return nk_f64_sqrt_neon(x);
+#elif NK_TARGET_POWERVSX
+    return nk_f64_sqrt_powervsx(x);
 #elif NK_TARGET_RVV
     return nk_f64_sqrt_rvv(x);
 #elif NK_TARGET_V128RELAXED
@@ -424,6 +429,8 @@ NK_PUBLIC nk_f32_t nk_f32_rsqrt(nk_f32_t x) {
     return nk_f32_rsqrt_haswell(x);
 #elif NK_TARGET_NEON
     return nk_f32_rsqrt_neon(x);
+#elif NK_TARGET_POWERVSX
+    return nk_f32_rsqrt_powervsx(x);
 #elif NK_TARGET_RVV
     return nk_f32_rsqrt_rvv(x);
 #elif NK_TARGET_V128RELAXED
@@ -438,6 +445,8 @@ NK_PUBLIC nk_f64_t nk_f64_rsqrt(nk_f64_t x) {
     return nk_f64_rsqrt_haswell(x);
 #elif NK_TARGET_NEON
     return nk_f64_rsqrt_neon(x);
+#elif NK_TARGET_POWERVSX
+    return nk_f64_rsqrt_powervsx(x);
 #elif NK_TARGET_RVV
     return nk_f64_rsqrt_rvv(x);
 #elif NK_TARGET_V128RELAXED
@@ -452,6 +461,8 @@ NK_PUBLIC nk_f32_t nk_f32_fma(nk_f32_t a, nk_f32_t b, nk_f32_t c) {
     return nk_f32_fma_haswell(a, b, c);
 #elif NK_TARGET_NEON
     return nk_f32_fma_neon(a, b, c);
+#elif NK_TARGET_POWERVSX
+    return nk_f32_fma_powervsx(a, b, c);
 #elif NK_TARGET_RVV
     return nk_f32_fma_rvv(a, b, c);
 #elif NK_TARGET_V128RELAXED
@@ -466,6 +477,8 @@ NK_PUBLIC nk_f64_t nk_f64_fma(nk_f64_t a, nk_f64_t b, nk_f64_t c) {
     return nk_f64_fma_haswell(a, b, c);
 #elif NK_TARGET_NEON
     return nk_f64_fma_neon(a, b, c);
+#elif NK_TARGET_POWERVSX
+    return nk_f64_fma_powervsx(a, b, c);
 #elif NK_TARGET_RVV
     return nk_f64_fma_rvv(a, b, c);
 #elif NK_TARGET_V128RELAXED

package/include/numkong/set/README.md

@@ -7,22 +7,22 @@ Hamming distance counts the number of positions where elements differ.
 For binary vectors packed as octets, this is the popcount of the XOR.
 For byte-level vectors, it counts the number of mismatched bytes:
 
-```math
+$$
 \text{hamming}(a, b) = \sum_{i=0}^{n-1} [a_i \neq b_i]
-```
+$$
 
 Jaccard distance measures the dissimilarity of two sets.
 For binary vectors, the intersection and union are computed via bitwise AND and OR with popcount:
 
-```math
+$$
 \text{jaccard}(a, b) = 1 - \frac{|A \cap B|}{|A \cup B|} = 1 - \frac{\text{popcount}(a \mathbin{\&} b)}{\text{popcount}(a \mathbin{|} b)}
-```
+$$
 
 For word-level vectors (MinHash signatures), Jaccard similarity is the fraction of matching elements:
 
-```math
+$$
 \text{jaccard}(a, b) = 1 - \frac{\sum_{i=0}^{n-1} [a_i = b_i]}{n}
-```
+$$
 
 Reformulating as Python pseudocode:
 
@@ -136,44 +136,44 @@ Measured with Wasmtime v42 (Cranelift backend).
 | __u32__                      | ░░░░░░░░░░░░░░░░░░░░░░░░ | ░░░░░░░░░░░░░░░░░░░░░░░░ | ░░░░░░░░░░░░░░░░░░░░░░░░ |
 | `nk_jaccard_u32_v128relaxed` |        0.430 gb/s, 0 ulp |         2.46 gb/s, 0 ulp |         1.08 gb/s, 0 ulp |
 
-### Apple M4
+### Apple M5
 
 #### Native
 
 | Kernel                  |                      256 |                     1024 |                     4096 |
 | :---------------------- | -----------------------: | -----------------------: | -----------------------: |
 | __u1__                  | ░░░░░░░░░░░░░░░░░░░░░░░░ | ░░░░░░░░░░░░░░░░░░░░░░░░ | ░░░░░░░░░░░░░░░░░░░░░░░░ |
-| `nk_hamming_u1_serial`  |                4.66 gb/s |                5.30 gb/s |                5.04 gb/s |
-| `nk_jaccard_u1_serial`  |         3.03 gb/s, 0 ulp |         3.72 gb/s, 0 ulp |         3.65 gb/s, 0 ulp |
-| `nk_hamming_u1_neon`    |                20.7 gb/s |                41.9 gb/s |                52.2 gb/s |
-| `nk_jaccard_u1_neon`    |         15.8 gb/s, 0 ulp |         29.5 gb/s, 0 ulp |         34.8 gb/s, 0 ulp |
+| `nk_hamming_u1_serial`  |                6.79 gb/s |                7.48 gb/s |                6.92 gb/s |
+| `nk_jaccard_u1_serial`  |         4.36 gb/s, 0 ulp |         5.38 gb/s, 0 ulp |         5.45 gb/s, 0 ulp |
+| `nk_hamming_u1_neon`    |                31.6 gb/s |                65.6 gb/s |                90.9 gb/s |
+| `nk_jaccard_u1_neon`    |         28.4 gb/s, 0 ulp |         48.1 gb/s, 0 ulp |         51.0 gb/s, 0 ulp |
 | __u8__                  | ░░░░░░░░░░░░░░░░░░░░░░░░ | ░░░░░░░░░░░░░░░░░░░░░░░░ | ░░░░░░░░░░░░░░░░░░░░░░░░ |
-| `nk_hamming_u8_serial`  |                20.7 gb/s |                21.9 gb/s |                18.1 gb/s |
-| `nk_hamming_u8_neon`    |                49.1 gb/s |                43.9 gb/s |                32.5 gb/s |
+| `nk_hamming_u8_serial`  |                27.8 gb/s |                30.1 gb/s |                31.2 gb/s |
+| `nk_hamming_u8_neon`    |                96.9 gb/s |                79.5 gb/s |                56.3 gb/s |
 | __u16__                 | ░░░░░░░░░░░░░░░░░░░░░░░░ | ░░░░░░░░░░░░░░░░░░░░░░░░ | ░░░░░░░░░░░░░░░░░░░░░░░░ |
-| `nk_jaccard_u16_serial` |         42.5 gb/s, 0 ulp |         39.7 gb/s, 0 ulp |         36.1 gb/s, 0 ulp |
-| `nk_jaccard_u16_neon`   |         43.3 gb/s, 0 ulp |         33.0 gb/s, 0 ulp |         29.2 gb/s, 0 ulp |
+| `nk_jaccard_u16_serial` |         59.3 gb/s, 0 ulp |         69.4 gb/s, 0 ulp |         66.8 gb/s, 0 ulp |
+| `nk_jaccard_u16_neon`   |         67.8 gb/s, 0 ulp |         61.6 gb/s, 0 ulp |         50.8 gb/s, 0 ulp |
 | __u32__                 | ░░░░░░░░░░░░░░░░░░░░░░░░ | ░░░░░░░░░░░░░░░░░░░░░░░░ | ░░░░░░░░░░░░░░░░░░░░░░░░ |
-| `nk_jaccard_u32_serial` |         60.6 gb/s, 0 ulp |         49.0 gb/s, 0 ulp |         51.2 gb/s, 0 ulp |
-| `nk_jaccard_u32_neon`   |         51.0 gb/s, 0 ulp |         39.9 gb/s, 0 ulp |         38.9 gb/s, 0 ulp |
+| `nk_jaccard_u32_serial` |          105 gb/s, 0 ulp |          101 gb/s, 0 ulp |         89.1 gb/s, 0 ulp |
+| `nk_jaccard_u32_neon`   |         89.3 gb/s, 0 ulp |         72.8 gb/s, 0 ulp |         68.2 gb/s, 0 ulp |
 
 #### WASM
 
-Measured with Wasmtime v42 (Cranelift backend).
+Measured with Wasmtime v43 (Cranelift backend).
 
 | Kernel                       |                      256 |                     1024 |                     4096 |
 | :--------------------------- | -----------------------: | -----------------------: | -----------------------: |
 | __u1__                       | ░░░░░░░░░░░░░░░░░░░░░░░░ | ░░░░░░░░░░░░░░░░░░░░░░░░ | ░░░░░░░░░░░░░░░░░░░░░░░░ |
-| `nk_hamming_u1_serial`       |               0.501 gb/s |             0.00424 gb/s |              0.0443 gb/s |
-| `nk_jaccard_u1_serial`       |        0.315 gb/s, 0 ulp |        0.362 gb/s, 0 ulp |        0.382 gb/s, 0 ulp |
-| `nk_hamming_u1_v128relaxed`  |               0.414 gb/s |              0.0294 gb/s |               0.233 gb/s |
-| `nk_jaccard_u1_v128relaxed`  |       0.0141 gb/s, 0 ulp |        0.317 gb/s, 0 ulp |        0.249 gb/s, 0 ulp |
+| `nk_hamming_u1_serial`       |                5.18 gb/s |                5.66 gb/s |                6.52 gb/s |
+| `nk_jaccard_u1_serial`       |         1.74 gb/s, 0 ulp |         3.32 gb/s, 0 ulp |         3.61 gb/s, 0 ulp |
+| `nk_hamming_u1_v128relaxed`  |                22.6 gb/s |                46.5 gb/s |                67.9 gb/s |
+| `nk_jaccard_u1_v128relaxed`  |         16.1 gb/s, 0 ulp |         34.5 gb/s, 0 ulp |         50.8 gb/s, 0 ulp |
 | __u8__                       | ░░░░░░░░░░░░░░░░░░░░░░░░ | ░░░░░░░░░░░░░░░░░░░░░░░░ | ░░░░░░░░░░░░░░░░░░░░░░░░ |
-| `nk_hamming_u8_serial`       |               0.551 gb/s |               0.352 gb/s |               0.154 gb/s |
-| `nk_hamming_u8_v128relaxed`  |               0.702 gb/s |               0.409 gb/s |               0.464 gb/s |
+| `nk_hamming_u8_serial`       |                8.32 gb/s |                6.09 gb/s |                5.84 gb/s |
+| `nk_hamming_u8_v128relaxed`  |                47.7 gb/s |                68.5 gb/s |                72.1 gb/s |
 | __u16__                      | ░░░░░░░░░░░░░░░░░░░░░░░░ | ░░░░░░░░░░░░░░░░░░░░░░░░ | ░░░░░░░░░░░░░░░░░░░░░░░░ |
-| `nk_jaccard_u16_serial`      |        0.647 gb/s, 0 ulp |        0.362 gb/s, 0 ulp |        0.174 gb/s, 0 ulp |
-| `nk_jaccard_u16_v128relaxed` |        0.409 gb/s, 0 ulp |      0.00109 gb/s, 0 ulp |        0.275 gb/s, 0 ulp |
+| `nk_jaccard_u16_serial`      |         19.2 gb/s, 0 ulp |         12.4 gb/s, 0 ulp |         11.9 gb/s, 0 ulp |
+| `nk_jaccard_u16_v128relaxed` |         89.8 gb/s, 0 ulp |         74.0 gb/s, 0 ulp |         71.3 gb/s, 0 ulp |
 | __u32__                      | ░░░░░░░░░░░░░░░░░░░░░░░░ | ░░░░░░░░░░░░░░░░░░░░░░░░ | ░░░░░░░░░░░░░░░░░░░░░░░░ |
-| `nk_jaccard_u32_serial`      |        0.320 gb/s, 0 ulp |        0.161 gb/s, 0 ulp |        0.607 gb/s, 0 ulp |
-| `nk_jaccard_u32_v128relaxed` |        0.397 gb/s, 0 ulp |        0.364 gb/s, 0 ulp |       0.0807 gb/s, 0 ulp |
+| `nk_jaccard_u32_serial`      |         91.6 gb/s, 0 ulp |         69.4 gb/s, 0 ulp |         68.4 gb/s, 0 ulp |
+| `nk_jaccard_u32_v128relaxed` |         94.8 gb/s, 0 ulp |         76.2 gb/s, 0 ulp |         68.8 gb/s, 0 ulp |

package/include/numkong/set/haswell.h

@@ -8,12 +8,12 @@
  *
  *  @section set_haswell_instructions Key POPCNT/AVX2 Set Instructions
  *
- *      Intrinsic                   Instruction                     Latency     Throughput  Ports
- *      _mm_popcnt_u64              POPCNT (R64, R64)               3cy         1/cy        p1
- *      _mm256_and_si256            VPAND (YMM, YMM, YMM)           1cy         0.33/cy     p015
- *      _mm256_or_si256             VPOR (YMM, YMM, YMM)            1cy         0.33/cy     p015
- *      _mm256_xor_si256            VPXOR (YMM, YMM, YMM)           1cy         0.33/cy     p015
- *      _mm256_extracti128_si256    VEXTRACTI128 (XMM, YMM, I8)     3cy         1/cy        p5
+ *      Intrinsic                 Instruction                  Haswell     Genoa
+ *      _mm_popcnt_u64            POPCNT (R64, R64)            3cy @ p1    1cy @ p0123
+ *      _mm256_and_si256          VPAND (YMM, YMM, YMM)        1cy @ p015  1cy @ p0123
+ *      _mm256_or_si256           VPOR (YMM, YMM, YMM)         1cy @ p015  1cy @ p0123
+ *      _mm256_xor_si256          VPXOR (YMM, YMM, YMM)        1cy @ p015  1cy @ p0123
+ *      _mm256_extracti128_si256  VEXTRACTI128 (XMM, YMM, I8)  3cy @ p5    1cy @ p0123
  *
  *  Haswell lacks SIMD popcount; we extract 64-bit words and use scalar POPCNT. The p1 port
  *  bottleneck limits throughput to 1 popcount/cycle. For Hamming distance, XOR + POPCNT;
@@ -55,7 +55,7 @@ extern "C" {
 #pragma GCC target("avx2", "sse4.1", "popcnt")
 #endif
 
-#pragma region - Binary Sets
+#pragma region Binary Sets
 
 NK_PUBLIC void nk_hamming_u1_haswell(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);
@@ -79,9 +79,9 @@ NK_PUBLIC void nk_jaccard_u1_haswell(nk_u1x8_t const *a, nk_u1x8_t const *b, nk_
     *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_haswell(nk_u32_t const *a, nk_u32_t const *b, nk_size_t n, nk_f32_t *result) {
     nk_u32_t intersection_count = 0;
@@ -192,9 +192,9 @@ NK_PUBLIC void nk_jaccard_u16_haswell(nk_u16_t const *a, nk_u16_t const *b, nk_s
     *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_u1x64_state_haswell_t {
     nk_u32_t intersection_count;
@@ -317,7 +317,7 @@ NK_INTERNAL void nk_jaccard_f32x4_from_dot_haswell_(nk_b128_vec_t dots, nk_u32_t
     results->xmm_ps = _mm_blendv_ps(jaccard_f32x4, _mm_setzero_ps(), zero_union_mask);
 }
 
-#pragma endregion - Stateful Streaming
+#pragma endregion Stateful Streaming
 
 #if defined(__clang__)
 #pragma clang attribute pop

package/include/numkong/set/icelake.h

@@ -8,12 +8,12 @@
  *
  *  @section set_icelake_instructions Key AVX-512 Set Instructions
  *
- *      Intrinsic                   Instruction                     Latency     Throughput  Ports
- *      _mm512_popcnt_epi64         VPOPCNTQ (ZMM, ZMM)             3cy         1/cy        p5
- *      _mm512_and_si512            VPANDQ (ZMM, ZMM, ZMM)          1cy         0.33/cy     p05
- *      _mm512_or_si512             VPORQ (ZMM, ZMM, ZMM)           1cy         0.33/cy     p05
- *      _mm512_xor_si512            VPXORQ (ZMM, ZMM, ZMM)          1cy         0.33/cy     p05
- *      _mm512_maskz_loadu_epi8     VMOVDQU8 (ZMM, mem, k1)         7cy         0.5/cy      p23
+ *      Intrinsic                Instruction              Ice Lake
+ *      _mm512_popcnt_epi64      VPOPCNTQ (ZMM, ZMM)      3cy @ p5
+ *      _mm512_and_si512         VPANDQ (ZMM, ZMM, ZMM)   1cy @ p05
+ *      _mm512_or_si512          VPORQ (ZMM, ZMM, ZMM)    1cy @ p05
+ *      _mm512_xor_si512         VPXORQ (ZMM, ZMM, ZMM)   1cy @ p05
+ *      _mm512_maskz_loadu_epi8  VMOVDQU8 (ZMM, mem, k1)  7cy @ p23
  *
  *  Ice Lake has native VPOPCNTQ instruction via AVX-512 VPOPCNTDQ extension, enabling
  *  efficient 64-bit element-wise popcount. We process 512 bits per iteration.
@@ -54,7 +54,7 @@ extern "C" {
 #pragma GCC target("avx2", "avx512f", "avx512vl", "avx512bw", "avx512vpopcntdq", "f16c", "fma", "bmi", "bmi2")
 #endif
 
-#pragma region - Binary Sets
+#pragma region Binary Sets
 
 NK_PUBLIC void nk_hamming_u1_icelake(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);
@@ -239,9 +239,9 @@ NK_PUBLIC void nk_jaccard_u1_icelake(nk_u1x8_t const *a, nk_u1x8_t const *b, nk_
     *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_icelake(nk_u32_t const *a, nk_u32_t const *b, nk_size_t n, nk_f32_t *result) {
     nk_u32_t intersection_count = 0;
@@ -300,9 +300,9 @@ NK_PUBLIC void nk_jaccard_u16_icelake(nk_u16_t const *a, nk_u16_t const *b, nk_s
     *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_u1x512_state_icelake_t {
     __m512i intersection_count_i64x8;
@@ -438,7 +438,7 @@ NK_INTERNAL void nk_jaccard_u1x512_finalize_icelake( //
     result->xmm_ps = _mm_blendv_ps(jaccard_f32x4, _mm_setzero_ps(), zero_union_mask);
 }
 
-/** @brief Hamming from_dot: computes pop_a + pop_b - 2*dot for 4 pairs (IceLake). */
+/** @brief Hamming from_dot: computes pop_a + pop_b - 2*dot for 4 pairs (Icelake). */
 NK_INTERNAL void nk_hamming_u32x4_from_dot_icelake_(nk_b128_vec_t dots, nk_u32_t query_pop, nk_b128_vec_t target_pops,
                                                     nk_b128_vec_t *results) {
     __m128i dots_i32x4 = dots.xmm;
@@ -447,7 +447,7 @@ NK_INTERNAL void nk_hamming_u32x4_from_dot_icelake_(nk_b128_vec_t dots, nk_u32_t
     results->xmm = _mm_sub_epi32(_mm_add_epi32(query_i32x4, target_i32x4), _mm_slli_epi32(dots_i32x4, 1));
 }
 
-/** @brief Jaccard from_dot: computes 1 - dot / (pop_a + pop_b - dot) for 4 pairs (IceLake). */
+/** @brief Jaccard from_dot: computes 1 - dot / (pop_a + pop_b - dot) for 4 pairs (Icelake). */
 NK_INTERNAL void nk_jaccard_f32x4_from_dot_icelake_(nk_b128_vec_t dots, nk_u32_t query_pop, nk_b128_vec_t target_pops,
                                                     nk_b128_vec_t *results) {
     __m128 dot_f32x4 = _mm_cvtepi32_ps(dots.xmm);
@@ -468,7 +468,7 @@ NK_INTERNAL void nk_jaccard_f32x4_from_dot_icelake_(nk_b128_vec_t dots, nk_u32_t
     results->xmm_ps = _mm_blendv_ps(jaccard_f32x4, _mm_setzero_ps(), zero_union_mask);
 }
 
-#pragma endregion - Stateful Streaming
+#pragma endregion Stateful Streaming
 
 #if defined(__clang__)
 #pragma clang attribute pop