usearch 2.26.1 → 2.26.2

package/numkong/include/numkong/spatial/neon.h

@@ -670,13 +670,14 @@ nk_angular_e5m2_neon_cycle:
 }
 
 /** @brief Angular from_dot: computes 1 − dot × rsqrt(query_sumsq × target_sumsq) for 4 pairs in f64. */
-NK_INTERNAL void nk_angular_through_f64_from_dot_neon_(nk_b256_vec_t dots, nk_f64_t query_sumsq,
-                                                       nk_b256_vec_t target_sumsqs, nk_b256_vec_t *results) {
-    float64x2_t dots_ab_f64x2 = dots.f64x2s[0];
-    float64x2_t dots_cd_f64x2 = dots.f64x2s[1];
+NK_INTERNAL void nk_angular_through_f64_from_dot_neon_(nk_b256_vec_t const *dots_vec, nk_f64_t query_sumsq,
+                                                       nk_b256_vec_t const *target_sumsqs_vec,
+                                                       nk_b256_vec_t *result_vec) {
+    float64x2_t dots_ab_f64x2 = dots_vec->f64x2s[0];
+    float64x2_t dots_cd_f64x2 = dots_vec->f64x2s[1];
     float64x2_t query_sumsq_f64x2 = vdupq_n_f64(query_sumsq);
-    float64x2_t target_sumsqs_ab_f64x2 = target_sumsqs.f64x2s[0];
-    float64x2_t target_sumsqs_cd_f64x2 = target_sumsqs.f64x2s[1];
+    float64x2_t target_sumsqs_ab_f64x2 = target_sumsqs_vec->f64x2s[0];
+    float64x2_t target_sumsqs_cd_f64x2 = target_sumsqs_vec->f64x2s[1];
 
     // products = query_sumsq * target_sumsq
     float64x2_t products_ab_f64x2 = vmulq_f64(query_sumsq_f64x2, target_sumsqs_ab_f64x2);
@@ -723,18 +724,19 @@ NK_INTERNAL void nk_angular_through_f64_from_dot_neon_(nk_b256_vec_t dots, nk_f6
     result_ab_f64x2 = vbslq_f64(prod_zero_dot_nonzero_ab_u64x2, ones_f64x2, result_ab_f64x2);
     result_cd_f64x2 = vbslq_f64(prod_zero_dot_nonzero_cd_u64x2, ones_f64x2, result_cd_f64x2);
 
-    results->f64x2s[0] = result_ab_f64x2;
-    results->f64x2s[1] = result_cd_f64x2;
+    result_vec->f64x2s[0] = result_ab_f64x2;
+    result_vec->f64x2s[1] = result_cd_f64x2;
 }
 
 /** @brief Euclidean from_dot: computes √(query_sumsq + target_sumsq − 2 × dot) for 4 pairs in f64. */
-NK_INTERNAL void nk_euclidean_through_f64_from_dot_neon_(nk_b256_vec_t dots, nk_f64_t query_sumsq,
-                                                         nk_b256_vec_t target_sumsqs, nk_b256_vec_t *results) {
-    float64x2_t dots_ab_f64x2 = dots.f64x2s[0];
-    float64x2_t dots_cd_f64x2 = dots.f64x2s[1];
+NK_INTERNAL void nk_euclidean_through_f64_from_dot_neon_(nk_b256_vec_t const *dots_vec, nk_f64_t query_sumsq,
+                                                         nk_b256_vec_t const *target_sumsqs_vec,
+                                                         nk_b256_vec_t *result_vec) {
+    float64x2_t dots_ab_f64x2 = dots_vec->f64x2s[0];
+    float64x2_t dots_cd_f64x2 = dots_vec->f64x2s[1];
     float64x2_t query_sumsq_f64x2 = vdupq_n_f64(query_sumsq);
-    float64x2_t target_sumsqs_ab_f64x2 = target_sumsqs.f64x2s[0];
-    float64x2_t target_sumsqs_cd_f64x2 = target_sumsqs.f64x2s[1];
+    float64x2_t target_sumsqs_ab_f64x2 = target_sumsqs_vec->f64x2s[0];
+    float64x2_t target_sumsqs_cd_f64x2 = target_sumsqs_vec->f64x2s[1];
 
     // dist_sq = query_sumsq + target_sumsq − 2 × dot
     float64x2_t neg_two_f64x2 = vdupq_n_f64(-2.0);
@@ -750,16 +752,17 @@ NK_INTERNAL void nk_euclidean_through_f64_from_dot_neon_(nk_b256_vec_t dots, nk_
     float64x2_t dist_ab_f64x2 = vsqrtq_f64(dist_sq_ab_f64x2);
     float64x2_t dist_cd_f64x2 = vsqrtq_f64(dist_sq_cd_f64x2);
 
-    results->f64x2s[0] = dist_ab_f64x2;
-    results->f64x2s[1] = dist_cd_f64x2;
+    result_vec->f64x2s[0] = dist_ab_f64x2;
+    result_vec->f64x2s[1] = dist_cd_f64x2;
 }
 
 /** @brief Angular from_dot: computes 1 − dot × rsqrt(query_sumsq × target_sumsq) for 4 pairs in f32. */
-NK_INTERNAL void nk_angular_through_f32_from_dot_neon_(nk_b128_vec_t dots, nk_f32_t query_sumsq,
-                                                       nk_b128_vec_t target_sumsqs, nk_b128_vec_t *results) {
-    float32x4_t dots_f32x4 = dots.f32x4;
+NK_INTERNAL void nk_angular_through_f32_from_dot_neon_(nk_b128_vec_t const *dots_vec, nk_f32_t query_sumsq,
+                                                       nk_b128_vec_t const *target_sumsqs_vec,
+                                                       nk_b128_vec_t *result_vec) {
+    float32x4_t dots_f32x4 = dots_vec->f32x4;
     float32x4_t query_sumsq_f32x4 = vdupq_n_f32(query_sumsq);
-    float32x4_t products_f32x4 = vmulq_f32(query_sumsq_f32x4, target_sumsqs.f32x4);
+    float32x4_t products_f32x4 = vmulq_f32(query_sumsq_f32x4, target_sumsqs_vec->f32x4);
 
     // rsqrt with Newton-Raphson refinement (2 iterations)
     float32x4_t rsqrt_f32x4 = vrsqrteq_f32(products_f32x4);
@@ -768,66 +771,71 @@ NK_INTERNAL void nk_angular_through_f32_from_dot_neon_(nk_b128_vec_t dots, nk_f3
 
     float32x4_t normalized_f32x4 = vmulq_f32(dots_f32x4, rsqrt_f32x4);
     float32x4_t angular_f32x4 = vsubq_f32(vdupq_n_f32(1.0f), normalized_f32x4);
-    results->f32x4 = vmaxq_f32(angular_f32x4, vdupq_n_f32(0.0f));
+    result_vec->f32x4 = vmaxq_f32(angular_f32x4, vdupq_n_f32(0.0f));
 }
 
 /** @brief Euclidean from_dot: computes √(query_sumsq + target_sumsq − 2 × dot) for 4 pairs in f32. */
-NK_INTERNAL void nk_euclidean_through_f32_from_dot_neon_(nk_b128_vec_t dots, nk_f32_t query_sumsq,
-                                                         nk_b128_vec_t target_sumsqs, nk_b128_vec_t *results) {
-    float32x4_t dots_f32x4 = dots.f32x4;
+NK_INTERNAL void nk_euclidean_through_f32_from_dot_neon_(nk_b128_vec_t const *dots_vec, nk_f32_t query_sumsq,
+                                                         nk_b128_vec_t const *target_sumsqs_vec,
+                                                         nk_b128_vec_t *result_vec) {
+    float32x4_t dots_f32x4 = dots_vec->f32x4;
     float32x4_t query_sumsq_f32x4 = vdupq_n_f32(query_sumsq);
-    float32x4_t sum_sq_f32x4 = vaddq_f32(query_sumsq_f32x4, target_sumsqs.f32x4);
+    float32x4_t sum_sq_f32x4 = vaddq_f32(query_sumsq_f32x4, target_sumsqs_vec->f32x4);
     // dist_sq = sum_sq − 2 × dot
     float32x4_t dist_sq_f32x4 = vfmsq_f32(sum_sq_f32x4, vdupq_n_f32(2.0f), dots_f32x4);
     // Clamp and sqrt
     dist_sq_f32x4 = vmaxq_f32(dist_sq_f32x4, vdupq_n_f32(0.0f));
-    results->f32x4 = vsqrtq_f32(dist_sq_f32x4);
+    result_vec->f32x4 = vsqrtq_f32(dist_sq_f32x4);
 }
 
 /** @brief Angular from_dot for i32 accumulators: cast to f32, rsqrt+NR, clamp. 4 pairs. */
-NK_INTERNAL void nk_angular_through_i32_from_dot_neon_(nk_b128_vec_t dots, nk_i32_t query_sumsq,
-                                                       nk_b128_vec_t target_sumsqs, nk_b128_vec_t *results) {
-    float32x4_t dots_f32x4 = vcvtq_f32_s32(dots.i32x4);
+NK_INTERNAL void nk_angular_through_i32_from_dot_neon_(nk_b128_vec_t const *dots_vec, nk_i32_t query_sumsq,
+                                                       nk_b128_vec_t const *target_sumsqs_vec,
+                                                       nk_b128_vec_t *result_vec) {
+    float32x4_t dots_f32x4 = vcvtq_f32_s32(dots_vec->i32x4);
     float32x4_t query_sumsq_f32x4 = vdupq_n_f32((nk_f32_t)query_sumsq);
-    float32x4_t products_f32x4 = vmulq_f32(query_sumsq_f32x4, vcvtq_f32_s32(target_sumsqs.i32x4));
+    float32x4_t products_f32x4 = vmulq_f32(query_sumsq_f32x4, vcvtq_f32_s32(target_sumsqs_vec->i32x4));
     float32x4_t rsqrt_f32x4 = nk_rsqrt_f32x4_neon_(products_f32x4);
     float32x4_t normalized_f32x4 = vmulq_f32(dots_f32x4, rsqrt_f32x4);
     float32x4_t angular_f32x4 = vsubq_f32(vdupq_n_f32(1.0f), normalized_f32x4);
-    results->f32x4 = vmaxq_f32(angular_f32x4, vdupq_n_f32(0.0f));
+    result_vec->f32x4 = vmaxq_f32(angular_f32x4, vdupq_n_f32(0.0f));
 }
 
 /** @brief Euclidean from_dot for i32 accumulators: cast to f32, then √(a² + b² − 2ab). 4 pairs. */
-NK_INTERNAL void nk_euclidean_through_i32_from_dot_neon_(nk_b128_vec_t dots, nk_i32_t query_sumsq,
-                                                         nk_b128_vec_t target_sumsqs, nk_b128_vec_t *results) {
-    float32x4_t dots_f32x4 = vcvtq_f32_s32(dots.i32x4);
+NK_INTERNAL void nk_euclidean_through_i32_from_dot_neon_(nk_b128_vec_t const *dots_vec, nk_i32_t query_sumsq,
+                                                         nk_b128_vec_t const *target_sumsqs_vec,
+                                                         nk_b128_vec_t *result_vec) {
+    float32x4_t dots_f32x4 = vcvtq_f32_s32(dots_vec->i32x4);
     float32x4_t query_sumsq_f32x4 = vdupq_n_f32((nk_f32_t)query_sumsq);
-    float32x4_t sum_sq_f32x4 = vaddq_f32(query_sumsq_f32x4, vcvtq_f32_s32(target_sumsqs.i32x4));
+    float32x4_t sum_sq_f32x4 = vaddq_f32(query_sumsq_f32x4, vcvtq_f32_s32(target_sumsqs_vec->i32x4));
     float32x4_t dist_sq_f32x4 = vfmsq_f32(sum_sq_f32x4, vdupq_n_f32(2.0f), dots_f32x4);
     dist_sq_f32x4 = vmaxq_f32(dist_sq_f32x4, vdupq_n_f32(0.0f));
-    results->f32x4 = vsqrtq_f32(dist_sq_f32x4);
+    result_vec->f32x4 = vsqrtq_f32(dist_sq_f32x4);
 }
 
 /** @brief Angular from_dot for u32 accumulators: cast to f32, rsqrt+NR, clamp. 4 pairs. */
-NK_INTERNAL void nk_angular_through_u32_from_dot_neon_(nk_b128_vec_t dots, nk_u32_t query_sumsq,
-                                                       nk_b128_vec_t target_sumsqs, nk_b128_vec_t *results) {
-    float32x4_t dots_f32x4 = vcvtq_f32_u32(dots.u32x4);
+NK_INTERNAL void nk_angular_through_u32_from_dot_neon_(nk_b128_vec_t const *dots_vec, nk_u32_t query_sumsq,
+                                                       nk_b128_vec_t const *target_sumsqs_vec,
+                                                       nk_b128_vec_t *result_vec) {
+    float32x4_t dots_f32x4 = vcvtq_f32_u32(dots_vec->u32x4);
     float32x4_t query_sumsq_f32x4 = vdupq_n_f32((nk_f32_t)query_sumsq);
-    float32x4_t products_f32x4 = vmulq_f32(query_sumsq_f32x4, vcvtq_f32_u32(target_sumsqs.u32x4));
+    float32x4_t products_f32x4 = vmulq_f32(query_sumsq_f32x4, vcvtq_f32_u32(target_sumsqs_vec->u32x4));
     float32x4_t rsqrt_f32x4 = nk_rsqrt_f32x4_neon_(products_f32x4);
     float32x4_t normalized_f32x4 = vmulq_f32(dots_f32x4, rsqrt_f32x4);
     float32x4_t angular_f32x4 = vsubq_f32(vdupq_n_f32(1.0f), normalized_f32x4);
-    results->f32x4 = vmaxq_f32(angular_f32x4, vdupq_n_f32(0.0f));
+    result_vec->f32x4 = vmaxq_f32(angular_f32x4, vdupq_n_f32(0.0f));
 }
 
 /** @brief Euclidean from_dot for u32 accumulators: cast to f32, then √(a² + b² − 2ab). 4 pairs. */
-NK_INTERNAL void nk_euclidean_through_u32_from_dot_neon_(nk_b128_vec_t dots, nk_u32_t query_sumsq,
-                                                         nk_b128_vec_t target_sumsqs, nk_b128_vec_t *results) {
-    float32x4_t dots_f32x4 = vcvtq_f32_u32(dots.u32x4);
+NK_INTERNAL void nk_euclidean_through_u32_from_dot_neon_(nk_b128_vec_t const *dots_vec, nk_u32_t query_sumsq,
+                                                         nk_b128_vec_t const *target_sumsqs_vec,
+                                                         nk_b128_vec_t *result_vec) {
+    float32x4_t dots_f32x4 = vcvtq_f32_u32(dots_vec->u32x4);
     float32x4_t query_sumsq_f32x4 = vdupq_n_f32((nk_f32_t)query_sumsq);
-    float32x4_t sum_sq_f32x4 = vaddq_f32(query_sumsq_f32x4, vcvtq_f32_u32(target_sumsqs.u32x4));
+    float32x4_t sum_sq_f32x4 = vaddq_f32(query_sumsq_f32x4, vcvtq_f32_u32(target_sumsqs_vec->u32x4));
     float32x4_t dist_sq_f32x4 = vfmsq_f32(sum_sq_f32x4, vdupq_n_f32(2.0f), dots_f32x4);
     dist_sq_f32x4 = vmaxq_f32(dist_sq_f32x4, vdupq_n_f32(0.0f));
-    results->f32x4 = vsqrtq_f32(dist_sq_f32x4);
+    result_vec->f32x4 = vsqrtq_f32(dist_sq_f32x4);
 }
 
 #if defined(__clang__)

package/numkong/include/numkong/spatial/neonbfdot.h

@@ -49,7 +49,7 @@ extern "C" {
 
 NK_PUBLIC void nk_angular_bf16_neonbfdot(nk_bf16_t const *a, nk_bf16_t const *b, nk_size_t n, nk_f32_t *result) {
 
-    // Similar to `nk_angular_i8_neon`, we can use the `BFMMLA` instruction through
+    // Similar to `nk_angular_i8_neonsdot`, we can use the `BFMMLA` instruction through
     // the `vbfmmlaq_f32` intrinsic to compute matrix products and later drop 1/4 of values.
     // The only difference is that `zip` isn't provided for `bf16` and we need to reinterpret back
     // and forth before zipping. Same as with integers, on modern Arm CPUs, this "smart"

package/numkong/include/numkong/spatial/powervsx.h

@@ -587,13 +587,14 @@ nk_angular_u8_powervsx_cycle:
 }
 
 /** @brief Angular from_dot: computes 1 − dot × rsqrt(query_sumsq × target_sumsq) for 4 pairs in f64. */
-NK_INTERNAL void nk_angular_through_f64_from_dot_powervsx_(nk_b256_vec_t dots, nk_f64_t query_sumsq,
-                                                           nk_b256_vec_t target_sumsqs, nk_b256_vec_t *results) {
-    nk_vf64x2_t dots_ab_f64x2 = dots.vf64x2s[0];
-    nk_vf64x2_t dots_cd_f64x2 = dots.vf64x2s[1];
+NK_INTERNAL void nk_angular_through_f64_from_dot_powervsx_(nk_b256_vec_t const *dots_vec, nk_f64_t query_sumsq,
+                                                           nk_b256_vec_t const *target_sumsqs_vec,
+                                                           nk_b256_vec_t *result_vec) {
+    nk_vf64x2_t dots_ab_f64x2 = dots_vec->vf64x2s[0];
+    nk_vf64x2_t dots_cd_f64x2 = dots_vec->vf64x2s[1];
     nk_vf64x2_t query_f64x2 = vec_splats(query_sumsq);
-    nk_vf64x2_t targets_ab_f64x2 = target_sumsqs.vf64x2s[0];
-    nk_vf64x2_t targets_cd_f64x2 = target_sumsqs.vf64x2s[1];
+    nk_vf64x2_t targets_ab_f64x2 = target_sumsqs_vec->vf64x2s[0];
+    nk_vf64x2_t targets_cd_f64x2 = target_sumsqs_vec->vf64x2s[1];
 
     nk_vf64x2_t products_ab_f64x2 = vec_mul(query_f64x2, targets_ab_f64x2);
     nk_vf64x2_t products_cd_f64x2 = vec_mul(query_f64x2, targets_cd_f64x2);
@@ -616,109 +617,116 @@ NK_INTERNAL void nk_angular_through_f64_from_dot_powervsx_(nk_b256_vec_t dots, n
     result_cd_f64x2 = vec_sel(result_cd_f64x2, zeros_f64x2, vec_and(prodzero_cd_u64x2, dotzero_cd_u64x2));
     result_cd_f64x2 = vec_sel(result_cd_f64x2, ones_f64x2, vec_andc(prodzero_cd_u64x2, dotzero_cd_u64x2));
 
-    results->vf64x2s[0] = result_ab_f64x2;
-    results->vf64x2s[1] = result_cd_f64x2;
+    result_vec->vf64x2s[0] = result_ab_f64x2;
+    result_vec->vf64x2s[1] = result_cd_f64x2;
 }
 
 /** @brief Euclidean from_dot: computes √(query_sumsq + target_sumsq − 2×dot) for 4 pairs in f64. */
-NK_INTERNAL void nk_euclidean_through_f64_from_dot_powervsx_(nk_b256_vec_t dots, nk_f64_t query_sumsq,
-                                                             nk_b256_vec_t target_sumsqs, nk_b256_vec_t *results) {
+NK_INTERNAL void nk_euclidean_through_f64_from_dot_powervsx_(nk_b256_vec_t const *dots_vec, nk_f64_t query_sumsq,
+                                                             nk_b256_vec_t const *target_sumsqs_vec,
+                                                             nk_b256_vec_t *result_vec) {
     nk_vf64x2_t query_f64x2 = vec_splats(query_sumsq);
     nk_vf64x2_t neg_two_f64x2 = vec_splats(-2.0);
     nk_vf64x2_t zeros_f64x2 = vec_splats(0.0);
 
-    nk_vf64x2_t sum_sq_ab_f64x2 = vec_add(query_f64x2, target_sumsqs.vf64x2s[0]);
-    nk_vf64x2_t sum_sq_cd_f64x2 = vec_add(query_f64x2, target_sumsqs.vf64x2s[1]);
-    nk_vf64x2_t dist_sq_ab_f64x2 = vec_max(vec_madd(neg_two_f64x2, dots.vf64x2s[0], sum_sq_ab_f64x2), zeros_f64x2);
-    nk_vf64x2_t dist_sq_cd_f64x2 = vec_max(vec_madd(neg_two_f64x2, dots.vf64x2s[1], sum_sq_cd_f64x2), zeros_f64x2);
+    nk_vf64x2_t sum_sq_ab_f64x2 = vec_add(query_f64x2, target_sumsqs_vec->vf64x2s[0]);
+    nk_vf64x2_t sum_sq_cd_f64x2 = vec_add(query_f64x2, target_sumsqs_vec->vf64x2s[1]);
+    nk_vf64x2_t dist_sq_ab_f64x2 = vec_max(vec_madd(neg_two_f64x2, dots_vec->vf64x2s[0], sum_sq_ab_f64x2), zeros_f64x2);
+    nk_vf64x2_t dist_sq_cd_f64x2 = vec_max(vec_madd(neg_two_f64x2, dots_vec->vf64x2s[1], sum_sq_cd_f64x2), zeros_f64x2);
 
-    results->vf64x2s[0] = vec_sqrt(dist_sq_ab_f64x2);
-    results->vf64x2s[1] = vec_sqrt(dist_sq_cd_f64x2);
+    result_vec->vf64x2s[0] = vec_sqrt(dist_sq_ab_f64x2);
+    result_vec->vf64x2s[1] = vec_sqrt(dist_sq_cd_f64x2);
 }
 
 /** @brief Angular from_dot: computes 1 − dot × rsqrt(query_sumsq × target_sumsq) for 4 pairs in f32. */
-NK_INTERNAL void nk_angular_through_f32_from_dot_powervsx_(nk_b128_vec_t dots, nk_f32_t query_sumsq,
-                                                           nk_b128_vec_t target_sumsqs, nk_b128_vec_t *results) {
-    nk_vf32x4_t dots_f32x4 = dots.vf32x4;
+NK_INTERNAL void nk_angular_through_f32_from_dot_powervsx_(nk_b128_vec_t const *dots_vec, nk_f32_t query_sumsq,
+                                                           nk_b128_vec_t const *target_sumsqs_vec,
+                                                           nk_b128_vec_t *result_vec) {
+    nk_vf32x4_t dots_f32x4 = dots_vec->vf32x4;
     nk_vf32x4_t query_f32x4 = vec_splats(query_sumsq);
-    nk_vf32x4_t products_f32x4 = vec_mul(query_f32x4, target_sumsqs.vf32x4);
+    nk_vf32x4_t products_f32x4 = vec_mul(query_f32x4, target_sumsqs_vec->vf32x4);
     nk_vf32x4_t rsqrt_f32x4 = nk_rsqrt_f32x4_powervsx_(products_f32x4);
     nk_vf32x4_t normalized_f32x4 = vec_mul(dots_f32x4, rsqrt_f32x4);
     nk_vf32x4_t angular_f32x4 = vec_sub(vec_splats(1.0f), normalized_f32x4);
     nk_vf32x4_t result_f32x4 = vec_max(angular_f32x4, vec_splats(0.0f));
-    results->vf32x4 = result_f32x4;
+    result_vec->vf32x4 = result_f32x4;
 }
 
 /** @brief Euclidean from_dot: computes √(query_sumsq + target_sumsq − 2×dot) for 4 pairs in f32. */
-NK_INTERNAL void nk_euclidean_through_f32_from_dot_powervsx_(nk_b128_vec_t dots, nk_f32_t query_sumsq,
-                                                             nk_b128_vec_t target_sumsqs, nk_b128_vec_t *results) {
-    nk_vf32x4_t dots_f32x4 = dots.vf32x4;
+NK_INTERNAL void nk_euclidean_through_f32_from_dot_powervsx_(nk_b128_vec_t const *dots_vec, nk_f32_t query_sumsq,
+                                                             nk_b128_vec_t const *target_sumsqs_vec,
+                                                             nk_b128_vec_t *result_vec) {
+    nk_vf32x4_t dots_f32x4 = dots_vec->vf32x4;
     nk_vf32x4_t query_f32x4 = vec_splats(query_sumsq);
-    nk_vf32x4_t sum_sq_f32x4 = vec_add(query_f32x4, target_sumsqs.vf32x4);
+    nk_vf32x4_t sum_sq_f32x4 = vec_add(query_f32x4, target_sumsqs_vec->vf32x4);
     // dist_sq = sum_sq − 2 × dot
     nk_vf32x4_t dist_sq_f32x4 = vec_madd(vec_splats(-2.0f), dots_f32x4, sum_sq_f32x4);
     // Clamp and sqrt
     dist_sq_f32x4 = vec_max(dist_sq_f32x4, vec_splats(0.0f));
     nk_vf32x4_t dist_f32x4 = vec_sqrt(dist_sq_f32x4);
-    results->vf32x4 = dist_f32x4;
+    result_vec->vf32x4 = dist_f32x4;
 }
 
 /** @brief Angular from_dot for i32 accumulators: cast to f32, rsqrt+NR, clamp. 4 pairs. */
-NK_INTERNAL void nk_angular_through_i32_from_dot_powervsx_(nk_b128_vec_t dots, nk_i32_t query_sumsq,
-                                                           nk_b128_vec_t target_sumsqs, nk_b128_vec_t *results) {
-    nk_vi32x4_t dots_i32x4 = dots.vi32x4;
+NK_INTERNAL void nk_angular_through_i32_from_dot_powervsx_(nk_b128_vec_t const *dots_vec, nk_i32_t query_sumsq,
+                                                           nk_b128_vec_t const *target_sumsqs_vec,
+                                                           nk_b128_vec_t *result_vec) {
+    nk_vi32x4_t dots_i32x4 = dots_vec->vi32x4;
     nk_vf32x4_t dots_f32x4 = vec_ctf(dots_i32x4, 0);
     nk_vf32x4_t query_f32x4 = vec_splats((nk_f32_t)query_sumsq);
-    nk_vi32x4_t targets_i32x4 = target_sumsqs.vi32x4;
+    nk_vi32x4_t targets_i32x4 = target_sumsqs_vec->vi32x4;
     nk_vf32x4_t products_f32x4 = vec_mul(query_f32x4, vec_ctf(targets_i32x4, 0));
     nk_vf32x4_t rsqrt_f32x4 = nk_rsqrt_f32x4_powervsx_(products_f32x4);
     nk_vf32x4_t normalized_f32x4 = vec_mul(dots_f32x4, rsqrt_f32x4);
     nk_vf32x4_t angular_f32x4 = vec_sub(vec_splats(1.0f), normalized_f32x4);
     nk_vf32x4_t result_f32x4 = vec_max(angular_f32x4, vec_splats(0.0f));
-    results->vf32x4 = result_f32x4;
+    result_vec->vf32x4 = result_f32x4;
 }
 
 /** @brief Euclidean from_dot for i32 accumulators: cast to f32, then √(a² + b² − 2ab). 4 pairs. */
-NK_INTERNAL void nk_euclidean_through_i32_from_dot_powervsx_(nk_b128_vec_t dots, nk_i32_t query_sumsq,
-                                                             nk_b128_vec_t target_sumsqs, nk_b128_vec_t *results) {
-    nk_vi32x4_t dots_i32x4 = dots.vi32x4;
+NK_INTERNAL void nk_euclidean_through_i32_from_dot_powervsx_(nk_b128_vec_t const *dots_vec, nk_i32_t query_sumsq,
+                                                             nk_b128_vec_t const *target_sumsqs_vec,
+                                                             nk_b128_vec_t *result_vec) {
+    nk_vi32x4_t dots_i32x4 = dots_vec->vi32x4;
     nk_vf32x4_t dots_f32x4 = vec_ctf(dots_i32x4, 0);
     nk_vf32x4_t query_f32x4 = vec_splats((nk_f32_t)query_sumsq);
-    nk_vi32x4_t targets_i32x4 = target_sumsqs.vi32x4;
+    nk_vi32x4_t targets_i32x4 = target_sumsqs_vec->vi32x4;
     nk_vf32x4_t sum_sq_f32x4 = vec_add(query_f32x4, vec_ctf(targets_i32x4, 0));
     nk_vf32x4_t dist_sq_f32x4 = vec_madd(vec_splats(-2.0f), dots_f32x4, sum_sq_f32x4);
     dist_sq_f32x4 = vec_max(dist_sq_f32x4, vec_splats(0.0f));
     nk_vf32x4_t dist_f32x4 = vec_sqrt(dist_sq_f32x4);
-    results->vf32x4 = dist_f32x4;
+    result_vec->vf32x4 = dist_f32x4;
 }
 
 /** @brief Angular from_dot for u32 accumulators: cast to f32, rsqrt+NR, clamp. 4 pairs. */
-NK_INTERNAL void nk_angular_through_u32_from_dot_powervsx_(nk_b128_vec_t dots, nk_u32_t query_sumsq,
-                                                           nk_b128_vec_t target_sumsqs, nk_b128_vec_t *results) {
-    nk_vu32x4_t dots_u32x4 = dots.vu32x4;
+NK_INTERNAL void nk_angular_through_u32_from_dot_powervsx_(nk_b128_vec_t const *dots_vec, nk_u32_t query_sumsq,
+                                                           nk_b128_vec_t const *target_sumsqs_vec,
+                                                           nk_b128_vec_t *result_vec) {
+    nk_vu32x4_t dots_u32x4 = dots_vec->vu32x4;
     nk_vf32x4_t dots_f32x4 = vec_ctf(dots_u32x4, 0);
     nk_vf32x4_t query_f32x4 = vec_splats((nk_f32_t)query_sumsq);
-    nk_vu32x4_t targets_u32x4 = target_sumsqs.vu32x4;
+    nk_vu32x4_t targets_u32x4 = target_sumsqs_vec->vu32x4;
     nk_vf32x4_t products_f32x4 = vec_mul(query_f32x4, vec_ctf(targets_u32x4, 0));
     nk_vf32x4_t rsqrt_f32x4 = nk_rsqrt_f32x4_powervsx_(products_f32x4);
     nk_vf32x4_t normalized_f32x4 = vec_mul(dots_f32x4, rsqrt_f32x4);
     nk_vf32x4_t angular_f32x4 = vec_sub(vec_splats(1.0f), normalized_f32x4);
     nk_vf32x4_t result_f32x4 = vec_max(angular_f32x4, vec_splats(0.0f));
-    results->vf32x4 = result_f32x4;
+    result_vec->vf32x4 = result_f32x4;
 }
 
 /** @brief Euclidean from_dot for u32 accumulators: cast to f32, then √(a² + b² − 2ab). 4 pairs. */
-NK_INTERNAL void nk_euclidean_through_u32_from_dot_powervsx_(nk_b128_vec_t dots, nk_u32_t query_sumsq,
-                                                             nk_b128_vec_t target_sumsqs, nk_b128_vec_t *results) {
-    nk_vu32x4_t dots_u32x4 = dots.vu32x4;
+NK_INTERNAL void nk_euclidean_through_u32_from_dot_powervsx_(nk_b128_vec_t const *dots_vec, nk_u32_t query_sumsq,
+                                                             nk_b128_vec_t const *target_sumsqs_vec,
+                                                             nk_b128_vec_t *result_vec) {
+    nk_vu32x4_t dots_u32x4 = dots_vec->vu32x4;
     nk_vf32x4_t dots_f32x4 = vec_ctf(dots_u32x4, 0);
     nk_vf32x4_t query_f32x4 = vec_splats((nk_f32_t)query_sumsq);
-    nk_vu32x4_t targets_u32x4 = target_sumsqs.vu32x4;
+    nk_vu32x4_t targets_u32x4 = target_sumsqs_vec->vu32x4;
     nk_vf32x4_t sum_sq_f32x4 = vec_add(query_f32x4, vec_ctf(targets_u32x4, 0));
     nk_vf32x4_t dist_sq_f32x4 = vec_madd(vec_splats(-2.0f), dots_f32x4, sum_sq_f32x4);
     dist_sq_f32x4 = vec_max(dist_sq_f32x4, vec_splats(0.0f));
     nk_vf32x4_t dist_f32x4 = vec_sqrt(dist_sq_f32x4);
-    results->vf32x4 = dist_f32x4;
+    result_vec->vf32x4 = dist_f32x4;
 }
 
 #pragma endregion I8 and U8 Integers

package/numkong/include/numkong/spatial/serial.h

@@ -253,108 +253,118 @@ NK_PUBLIC void nk_angular_u4_serial(nk_u4x2_t const *a, nk_u4x2_t const *b, nk_s
     }
 }
 
+#if defined(__clang__)
+#pragma clang attribute pop
+#elif defined(__GNUC__)
+#pragma GCC pop_options
+#endif
+
 /** @brief Angular from_dot: computes 1 − dot × rsqrt(query_sumsq × target_sumsq) for 4 pairs (serial). */
-NK_INTERNAL void nk_angular_through_f32_from_dot_serial_(nk_b128_vec_t dots, nk_f32_t query_sumsq,
-                                                         nk_b128_vec_t target_sumsqs, nk_b128_vec_t *results) {
+NK_INTERNAL void nk_angular_through_f32_from_dot_serial_(nk_b128_vec_t const *dots_vec, nk_f32_t query_sumsq,
+                                                         nk_b128_vec_t const *target_sumsqs_vec,
+                                                         nk_b128_vec_t *result_vec) {
     for (int i = 0; i < 4; ++i) {
-        nk_f32_t product = query_sumsq * target_sumsqs.f32s[i];
+        nk_f32_t product = query_sumsq * target_sumsqs_vec->f32s[i];
         if (product > 0) {
             nk_f32_t rsqrt_val = nk_f32_rsqrt_serial(product);
-            nk_f32_t normalized = dots.f32s[i] * rsqrt_val;
+            nk_f32_t normalized = dots_vec->f32s[i] * rsqrt_val;
             nk_f32_t result = 1.0f - normalized;
-            results->f32s[i] = result > 0 ? result : 0;
+            result_vec->f32s[i] = result > 0 ? result : 0;
         }
-        else { results->f32s[i] = (dots.f32s[i] == 0) ? 0.0f : 1.0f; }
+        else { result_vec->f32s[i] = (dots_vec->f32s[i] == 0) ? 0.0f : 1.0f; }
     }
 }
 
 /** @brief Euclidean from_dot: computes √(query_sumsq + target_sumsq − 2 × dot) for 4 pairs (serial). */
-NK_INTERNAL void nk_euclidean_through_f32_from_dot_serial_(nk_b128_vec_t dots, nk_f32_t query_sumsq,
-                                                           nk_b128_vec_t target_sumsqs, nk_b128_vec_t *results) {
+NK_INTERNAL void nk_euclidean_through_f32_from_dot_serial_(nk_b128_vec_t const *dots_vec, nk_f32_t query_sumsq,
+                                                           nk_b128_vec_t const *target_sumsqs_vec,
+                                                           nk_b128_vec_t *result_vec) {
     for (int i = 0; i < 4; ++i) {
-        nk_f32_t dist_sq = query_sumsq + target_sumsqs.f32s[i] - 2.0f * dots.f32s[i];
-        results->f32s[i] = dist_sq > 0 ? nk_f32_sqrt_serial(dist_sq) : 0.0f;
+        nk_f32_t dist_sq = query_sumsq + target_sumsqs_vec->f32s[i] - 2.0f * dots_vec->f32s[i];
+        result_vec->f32s[i] = dist_sq > 0 ? nk_f32_sqrt_serial(dist_sq) : 0.0f;
     }
 }
 
 /** @brief Angular from_dot for f64 precision. */
-NK_INTERNAL void nk_angular_through_f64_from_dot_serial_(nk_b256_vec_t dots, nk_f64_t query_sumsq,
-                                                         nk_b256_vec_t target_sumsqs, nk_b256_vec_t *results) {
+NK_INTERNAL void nk_angular_through_f64_from_dot_serial_(nk_b256_vec_t const *dots_vec, nk_f64_t query_sumsq,
+                                                         nk_b256_vec_t const *target_sumsqs_vec,
+                                                         nk_b256_vec_t *result_vec) {
     for (int i = 0; i < 4; ++i) {
-        nk_f64_t product = query_sumsq * target_sumsqs.f64s[i];
+        nk_f64_t product = query_sumsq * target_sumsqs_vec->f64s[i];
         if (product > 0) {
             nk_f64_t rsqrt_val = nk_f64_rsqrt_serial(product);
-            nk_f64_t normalized = dots.f64s[i] * rsqrt_val;
+            nk_f64_t normalized = dots_vec->f64s[i] * rsqrt_val;
             nk_f64_t result = 1.0 - normalized;
-            results->f64s[i] = result > 0 ? result : 0;
+            result_vec->f64s[i] = result > 0 ? result : 0;
         }
-        else { results->f64s[i] = (dots.f64s[i] == 0) ? 0.0 : 1.0; }
+        else { result_vec->f64s[i] = (dots_vec->f64s[i] == 0) ? 0.0 : 1.0; }
     }
 }
 
 /** @brief Euclidean from_dot for f64 precision. */
-NK_INTERNAL void nk_euclidean_through_f64_from_dot_serial_(nk_b256_vec_t dots, nk_f64_t query_sumsq,
-                                                           nk_b256_vec_t target_sumsqs, nk_b256_vec_t *results) {
+NK_INTERNAL void nk_euclidean_through_f64_from_dot_serial_(nk_b256_vec_t const *dots_vec, nk_f64_t query_sumsq,
+                                                           nk_b256_vec_t const *target_sumsqs_vec,
+                                                           nk_b256_vec_t *result_vec) {
     for (int i = 0; i < 4; ++i) {
-        nk_f64_t dist_sq = query_sumsq + target_sumsqs.f64s[i] - 2.0 * dots.f64s[i];
-        results->f64s[i] = dist_sq > 0 ? nk_f64_sqrt_serial(dist_sq) : 0.0;
+        nk_f64_t dist_sq = query_sumsq + target_sumsqs_vec->f64s[i] - 2.0 * dots_vec->f64s[i];
+        result_vec->f64s[i] = dist_sq > 0 ? nk_f64_sqrt_serial(dist_sq) : 0.0;
     }
 }
 
 /** @brief Angular from_dot for i32 accumulators: cast to f32, then same math as f32 variant. */
-NK_INTERNAL void nk_angular_through_i32_from_dot_serial_(nk_b128_vec_t dots, nk_i32_t query_sumsq,
-                                                         nk_b128_vec_t target_sumsqs, nk_b128_vec_t *results) {
+NK_INTERNAL void nk_angular_through_i32_from_dot_serial_(nk_b128_vec_t const *dots_vec, nk_i32_t query_sumsq,
+                                                         nk_b128_vec_t const *target_sumsqs_vec,
+                                                         nk_b128_vec_t *result_vec) {
     for (int i = 0; i < 4; ++i) {
-        nk_f32_t product = (nk_f32_t)query_sumsq * (nk_f32_t)target_sumsqs.i32s[i];
+        nk_f32_t product = (nk_f32_t)query_sumsq * (nk_f32_t)target_sumsqs_vec->i32s[i];
         if (product > 0) {
             nk_f32_t rsqrt_val = nk_f32_rsqrt_serial(product);
-            nk_f32_t normalized = (nk_f32_t)dots.i32s[i] * rsqrt_val;
+            nk_f32_t normalized = (nk_f32_t)dots_vec->i32s[i] * rsqrt_val;
             nk_f32_t result = 1.0f - normalized;
-            results->f32s[i] = result > 0 ? result : 0;
+            result_vec->f32s[i] = result > 0 ? result : 0;
         }
-        else { results->f32s[i] = (dots.i32s[i] == 0) ? 0.0f : 1.0f; }
+        else { result_vec->f32s[i] = (dots_vec->i32s[i] == 0) ? 0.0f : 1.0f; }
     }
 }
 
 /** @brief Euclidean from_dot for i32 accumulators: cast to f32, then same math as f32 variant. */
-NK_INTERNAL void nk_euclidean_through_i32_from_dot_serial_(nk_b128_vec_t dots, nk_i32_t query_sumsq,
-                                                           nk_b128_vec_t target_sumsqs, nk_b128_vec_t *results) {
+NK_INTERNAL void nk_euclidean_through_i32_from_dot_serial_(nk_b128_vec_t const *dots_vec, nk_i32_t query_sumsq,
+                                                           nk_b128_vec_t const *target_sumsqs_vec,
+                                                           nk_b128_vec_t *result_vec) {
     for (int i = 0; i < 4; ++i) {
-        nk_f32_t dist_sq = (nk_f32_t)query_sumsq + (nk_f32_t)target_sumsqs.i32s[i] - 2.0f * (nk_f32_t)dots.i32s[i];
-        results->f32s[i] = dist_sq > 0 ? nk_f32_sqrt_serial(dist_sq) : 0.0f;
+        nk_f32_t dist_sq = (nk_f32_t)query_sumsq + (nk_f32_t)target_sumsqs_vec->i32s[i] -
+                           2.0f * (nk_f32_t)dots_vec->i32s[i];
+        result_vec->f32s[i] = dist_sq > 0 ? nk_f32_sqrt_serial(dist_sq) : 0.0f;
     }
 }
 
 /** @brief Angular from_dot for u32 accumulators: cast to f32, then same math as f32 variant. */
-NK_INTERNAL void nk_angular_through_u32_from_dot_serial_(nk_b128_vec_t dots, nk_u32_t query_sumsq,
-                                                         nk_b128_vec_t target_sumsqs, nk_b128_vec_t *results) {
+NK_INTERNAL void nk_angular_through_u32_from_dot_serial_(nk_b128_vec_t const *dots_vec, nk_u32_t query_sumsq,
+                                                         nk_b128_vec_t const *target_sumsqs_vec,
+                                                         nk_b128_vec_t *result_vec) {
     for (int i = 0; i < 4; ++i) {
-        nk_f32_t product = (nk_f32_t)query_sumsq * (nk_f32_t)target_sumsqs.u32s[i];
+        nk_f32_t product = (nk_f32_t)query_sumsq * (nk_f32_t)target_sumsqs_vec->u32s[i];
         if (product > 0) {
             nk_f32_t rsqrt_val = nk_f32_rsqrt_serial(product);
-            nk_f32_t normalized = (nk_f32_t)dots.u32s[i] * rsqrt_val;
+            nk_f32_t normalized = (nk_f32_t)dots_vec->u32s[i] * rsqrt_val;
             nk_f32_t result = 1.0f - normalized;
-            results->f32s[i] = result > 0 ? result : 0;
+            result_vec->f32s[i] = result > 0 ? result : 0;
         }
-        else { results->f32s[i] = (dots.u32s[i] == 0) ? 0.0f : 1.0f; }
+        else { result_vec->f32s[i] = (dots_vec->u32s[i] == 0) ? 0.0f : 1.0f; }
     }
 }
 
 /** @brief Euclidean from_dot for u32 accumulators: cast to f32, then same math as f32 variant. */
-NK_INTERNAL void nk_euclidean_through_u32_from_dot_serial_(nk_b128_vec_t dots, nk_u32_t query_sumsq,
-                                                           nk_b128_vec_t target_sumsqs, nk_b128_vec_t *results) {
+NK_INTERNAL void nk_euclidean_through_u32_from_dot_serial_(nk_b128_vec_t const *dots_vec, nk_u32_t query_sumsq,
+                                                           nk_b128_vec_t const *target_sumsqs_vec,
+                                                           nk_b128_vec_t *result_vec) {
     for (int i = 0; i < 4; ++i) {
-        nk_f32_t dist_sq = (nk_f32_t)query_sumsq + (nk_f32_t)target_sumsqs.u32s[i] - 2.0f * (nk_f32_t)dots.u32s[i];
-        results->f32s[i] = dist_sq > 0 ? nk_f32_sqrt_serial(dist_sq) : 0.0f;
+        nk_f32_t dist_sq = (nk_f32_t)query_sumsq + (nk_f32_t)target_sumsqs_vec->u32s[i] -
+                           2.0f * (nk_f32_t)dots_vec->u32s[i];
+        result_vec->f32s[i] = dist_sq > 0 ? nk_f32_sqrt_serial(dist_sq) : 0.0f;
     }
 }
 
-#if defined(__clang__)
-#pragma clang attribute pop
-#elif defined(__GNUC__)
-#pragma GCC pop_options
-#endif
-
 #if defined(__cplusplus)
 } // extern "C"
 #endif

package/numkong/include/numkong/spatial/sierra.h

@@ -26,9 +26,10 @@
 #if NK_TARGET_SIERRA
 
 #include "numkong/types.h"
-#include "numkong/scalar/haswell.h" // `nk_f32_sqrt_haswell`
-#include "numkong/reduce/haswell.h" // `nk_reduce_add_i32x8_haswell_`
-#include "numkong/cast/serial.h"    // `nk_partial_load_b8x32_serial_`
+#include "numkong/scalar/haswell.h"  // `nk_f32_sqrt_haswell`
+#include "numkong/reduce/haswell.h"  // `nk_reduce_add_i32x8_haswell_`
+#include "numkong/spatial/haswell.h" // `nk_angular_normalize_f32_haswell_`
+#include "numkong/cast/serial.h"     // `nk_partial_load_b8x32_serial_`
 
 #if defined(__cplusplus)
 extern "C" {