usearch 2.26.0 → 2.26.2

package/numkong/include/numkong/spatial/skylake.h

@@ -25,8 +25,10 @@
 #if NK_TARGET_SKYLAKE
 
 #include "numkong/types.h"
-#include "numkong/reduce/skylake.h" // `nk_reduce_add_f32x16_skylake_`
-#include "numkong/dot/skylake.h"    // `nk_dot_f64x8_state_skylake_t`
+#include "numkong/reduce/skylake.h"  // `nk_reduce_add_f32x16_skylake_`
+#include "numkong/dot/skylake.h"     // `nk_dot_f64x8_state_skylake_t`
+#include "numkong/scalar/haswell.h"  // `nk_f32_sqrt_haswell`, `nk_f64_sqrt_haswell`
+#include "numkong/spatial/haswell.h" // `nk_angular_normalize_f32_haswell_`
 
 #if defined(__cplusplus)
 extern "C" {
@@ -224,61 +226,64 @@ nk_angular_f64_skylake_cycle:
 }
 
 /** @brief Angular from_dot for native f64: 1 − dot / √(query_sumsq × target_sumsq) for 4 pairs. */
-NK_INTERNAL void nk_angular_f64x4_from_dot_skylake_(nk_b256_vec_t dots, nk_f64_t query_sumsq,
-                                                    nk_b256_vec_t target_sumsqs, nk_b256_vec_t *results) {
-    __m256d dots_f64x4 = dots.ymm_pd;
+NK_INTERNAL void nk_angular_f64x4_from_dot_skylake_(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) {
+    __m256d dots_f64x4 = dots_vec->ymm_pd;
     __m256d query_sumsq_f64x4 = _mm256_set1_pd(query_sumsq);
-    __m256d products_f64x4 = _mm256_mul_pd(query_sumsq_f64x4, target_sumsqs.ymm_pd);
+    __m256d products_f64x4 = _mm256_mul_pd(query_sumsq_f64x4, target_sumsqs_vec->ymm_pd);
     __m256d sqrt_products_f64x4 = _mm256_sqrt_pd(products_f64x4);
     __m256d normalized_f64x4 = _mm256_div_pd(dots_f64x4, sqrt_products_f64x4);
     __m256d ones_f64x4 = _mm256_set1_pd(1.0);
     __m256d angular_f64x4 = _mm256_sub_pd(ones_f64x4, normalized_f64x4);
-    results->ymm_pd = _mm256_max_pd(angular_f64x4, _mm256_setzero_pd());
+    result_vec->ymm_pd = _mm256_max_pd(angular_f64x4, _mm256_setzero_pd());
 }
 
 /** @brief Euclidean from_dot for native f64: √(query_sumsq + target_sumsq − 2 × dot) for 4 pairs. */
-NK_INTERNAL void nk_euclidean_f64x4_from_dot_skylake_(nk_b256_vec_t dots, nk_f64_t query_sumsq,
-                                                      nk_b256_vec_t target_sumsqs, nk_b256_vec_t *results) {
-    __m256d dots_f64x4 = dots.ymm_pd;
+NK_INTERNAL void nk_euclidean_f64x4_from_dot_skylake_(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) {
+    __m256d dots_f64x4 = dots_vec->ymm_pd;
     __m256d query_sumsq_f64x4 = _mm256_set1_pd(query_sumsq);
     __m256d two_f64x4 = _mm256_set1_pd(2.0);
-    __m256d sum_sq_f64x4 = _mm256_add_pd(query_sumsq_f64x4, target_sumsqs.ymm_pd);
+    __m256d sum_sq_f64x4 = _mm256_add_pd(query_sumsq_f64x4, target_sumsqs_vec->ymm_pd);
     __m256d dist_sq_f64x4 = _mm256_fnmadd_pd(two_f64x4, dots_f64x4, sum_sq_f64x4);
     __m256d zeros_f64x4 = _mm256_setzero_pd();
     __m256d clamped_f64x4 = _mm256_max_pd(dist_sq_f64x4, zeros_f64x4);
-    results->ymm_pd = _mm256_sqrt_pd(clamped_f64x4);
+    result_vec->ymm_pd = _mm256_sqrt_pd(clamped_f64x4);
 }
 
 /** @brief Angular from_dot: f32 dots upcast to f64 for precision. Output via nk_b128_vec_t (f32). */
-NK_INTERNAL void nk_angular_through_f64_from_dot_skylake_(nk_b128_vec_t dots, nk_f32_t query_sumsq,
-                                                          nk_b128_vec_t target_sumsqs, nk_b128_vec_t *results) {
-    __m128 dots_f32x4 = dots.xmm_ps;
+NK_INTERNAL void nk_angular_through_f64_from_dot_skylake_(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) {
+    __m128 dots_f32x4 = dots_vec->xmm_ps;
     __m256d dots_f64x4 = _mm256_cvtps_pd(dots_f32x4);
     __m256d query_sumsq_f64x4 = _mm256_set1_pd((nk_f64_t)query_sumsq);
-    __m256d target_sumsqs_f64x4 = _mm256_cvtps_pd(target_sumsqs.xmm_ps);
+    __m256d target_sumsqs_f64x4 = _mm256_cvtps_pd(target_sumsqs_vec->xmm_ps);
     __m256d products_f64x4 = _mm256_mul_pd(query_sumsq_f64x4, target_sumsqs_f64x4);
     __m256d sqrt_products_f64x4 = _mm256_sqrt_pd(products_f64x4);
     __m256d normalized_f64x4 = _mm256_div_pd(dots_f64x4, sqrt_products_f64x4);
     __m256d ones_f64x4 = _mm256_set1_pd(1.0);
     __m256d angular_f64x4 = _mm256_sub_pd(ones_f64x4, normalized_f64x4);
     angular_f64x4 = _mm256_max_pd(angular_f64x4, _mm256_setzero_pd());
-    results->xmm_ps = _mm256_cvtpd_ps(angular_f64x4);
+    result_vec->xmm_ps = _mm256_cvtpd_ps(angular_f64x4);
 }
 
 /** @brief Euclidean from_dot: f32 dots upcast to f64 for precision. Output via nk_b128_vec_t (f32). */
-NK_INTERNAL void nk_euclidean_through_f64_from_dot_skylake_(nk_b128_vec_t dots, nk_f32_t query_sumsq,
-                                                            nk_b128_vec_t target_sumsqs, nk_b128_vec_t *results) {
-    __m128 dots_f32x4 = dots.xmm_ps;
+NK_INTERNAL void nk_euclidean_through_f64_from_dot_skylake_(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) {
+    __m128 dots_f32x4 = dots_vec->xmm_ps;
     __m256d dots_f64x4 = _mm256_cvtps_pd(dots_f32x4);
     __m256d query_sumsq_f64x4 = _mm256_set1_pd((nk_f64_t)query_sumsq);
-    __m256d target_sumsqs_f64x4 = _mm256_cvtps_pd(target_sumsqs.xmm_ps);
+    __m256d target_sumsqs_f64x4 = _mm256_cvtps_pd(target_sumsqs_vec->xmm_ps);
     __m256d two_f64x4 = _mm256_set1_pd(2.0);
     __m256d sum_sq_f64x4 = _mm256_add_pd(query_sumsq_f64x4, target_sumsqs_f64x4);
     __m256d dist_sq_f64x4 = _mm256_fnmadd_pd(two_f64x4, dots_f64x4, sum_sq_f64x4);
     __m256d zeros_f64x4 = _mm256_setzero_pd();
     __m256d clamped_f64x4 = _mm256_max_pd(dist_sq_f64x4, zeros_f64x4);
     __m256d dist_f64x4 = _mm256_sqrt_pd(clamped_f64x4);
-    results->xmm_ps = _mm256_cvtpd_ps(dist_f64x4);
+    result_vec->xmm_ps = _mm256_cvtpd_ps(dist_f64x4);
 }
 
 #pragma endregion F32 and F64 Floats

package/numkong/include/numkong/spatial/sve.h

@@ -60,9 +60,9 @@ extern "C" {
  *  Marked `__arm_streaming_compatible` so the helper is callable from both streaming
  *  (SME) and non-streaming (SVE) contexts without mode transitions.
  *
- *  @param predicate Active-lane mask
- *  @param x         Input vector (must be positive for meaningful results)
- *  @return          Approximate 1/sqrt(x) with ~23-bit mantissa accuracy
+ *  @param predicate_b32x Active-lane mask
+ *  @param x Input vector (must be positive for meaningful results)
+ *  @return Approximate 1/sqrt(x) with ~23-bit mantissa accuracy
  */
 NK_INTERNAL svfloat32_t nk_rsqrt_f32x_sve_(svbool_t predicate_b32x, svfloat32_t x) NK_STREAMING_COMPATIBLE_ {
     svfloat32_t r = svrsqrte_f32(x);
@@ -80,9 +80,9 @@ NK_INTERNAL svfloat32_t nk_rsqrt_f32x_sve_(svbool_t predicate_b32x, svfloat32_t
  *  Marked `__arm_streaming_compatible` so the helper is callable from both streaming
  *  (SME) and non-streaming (SVE) contexts without mode transitions.
  *
- *  @param predicate_b32x Active-lane mask
- *  @param x         Input vector (must be positive for meaningful results)
- *  @return          Approximate 1/sqrt(x) with ~52-bit mantissa accuracy
+ *  @param predicate_b64x Active-lane mask
+ *  @param x Input vector (must be positive for meaningful results)
+ *  @return Approximate 1/sqrt(x) with ~52-bit mantissa accuracy
  */
 NK_INTERNAL svfloat64_t nk_rsqrt_f64x_sve_(svbool_t predicate_b64x, svfloat64_t x) NK_STREAMING_COMPATIBLE_ {
     svfloat64_t r = svrsqrte_f64(x);

package/numkong/include/numkong/spatial/svebfdot.h

@@ -1,6 +1,6 @@
 /**
  *  @brief SIMD-accelerated Spatial Similarity Measures for SVE BF16.
- *  @file include/numkong/spatial/sve.h
+ *  @file include/numkong/spatial/svebfdot.h
  *  @author Ash Vardanian
  *  @date December 27, 2025
  *

package/numkong/include/numkong/spatial/svehalf.h

@@ -1,6 +1,6 @@
 /**
  *  @brief SIMD-accelerated Spatial Similarity Measures for SVE FP16.
- *  @file include/numkong/spatial/sve.h
+ *  @file include/numkong/spatial/svehalf.h
  *  @author Ash Vardanian
  *  @date December 27, 2025
  *

package/numkong/include/numkong/spatial/v128relaxed.h

@@ -618,75 +618,81 @@ nk_angular_e3m2_v128relaxed_cycle:
 #pragma region Spatial From Dot Helpers
 
 /** @brief Angular from_dot: computes 1 − dot / √(query_sumsq × target_sumsq) for 4 pairs in f32. */
-NK_INTERNAL void nk_angular_through_f32_from_dot_v128relaxed_(nk_b128_vec_t dots, nk_f32_t query_sumsq,
-                                                              nk_b128_vec_t target_sumsqs, nk_b128_vec_t *results) {
-    v128_t dots_f32x4 = dots.v128;
+NK_INTERNAL void nk_angular_through_f32_from_dot_v128relaxed_(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) {
+    v128_t dots_f32x4 = dots_vec->v128;
     v128_t query_sumsq_f32x4 = wasm_f32x4_splat(query_sumsq);
-    v128_t products_f32x4 = wasm_f32x4_mul(query_sumsq_f32x4, target_sumsqs.v128);
+    v128_t products_f32x4 = wasm_f32x4_mul(query_sumsq_f32x4, target_sumsqs_vec->v128);
     v128_t sqrt_products_f32x4 = wasm_f32x4_sqrt(products_f32x4);
     v128_t normalized_f32x4 = wasm_f32x4_div(dots_f32x4, sqrt_products_f32x4);
     v128_t angular_f32x4 = wasm_f32x4_sub(wasm_f32x4_splat(1.0f), normalized_f32x4);
-    results->v128 = wasm_f32x4_max(angular_f32x4, wasm_f32x4_splat(0.0f));
+    result_vec->v128 = wasm_f32x4_max(angular_f32x4, wasm_f32x4_splat(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_v128relaxed_(nk_b128_vec_t dots, nk_f32_t query_sumsq,
-                                                                nk_b128_vec_t target_sumsqs, nk_b128_vec_t *results) {
-    v128_t dots_f32x4 = dots.v128;
+NK_INTERNAL void nk_euclidean_through_f32_from_dot_v128relaxed_(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) {
+    v128_t dots_f32x4 = dots_vec->v128;
     v128_t query_sumsq_f32x4 = wasm_f32x4_splat(query_sumsq);
     v128_t two_f32x4 = wasm_f32x4_splat(2.0f);
-    v128_t sum_sq_f32x4 = wasm_f32x4_add(query_sumsq_f32x4, target_sumsqs.v128);
+    v128_t sum_sq_f32x4 = wasm_f32x4_add(query_sumsq_f32x4, target_sumsqs_vec->v128);
     v128_t dist_sq_f32x4 = wasm_f32x4_relaxed_nmadd(two_f32x4, dots_f32x4, sum_sq_f32x4);
     dist_sq_f32x4 = wasm_f32x4_max(dist_sq_f32x4, wasm_f32x4_splat(0.0f));
-    results->v128 = wasm_f32x4_sqrt(dist_sq_f32x4);
+    result_vec->v128 = wasm_f32x4_sqrt(dist_sq_f32x4);
 }
 
 /** @brief Angular from_dot for i32 accumulators: cast to f32, then angular normalization. 4 pairs. */
-NK_INTERNAL void nk_angular_through_i32_from_dot_v128relaxed_(nk_b128_vec_t dots, nk_i32_t query_sumsq,
-                                                              nk_b128_vec_t target_sumsqs, nk_b128_vec_t *results) {
-    v128_t dots_f32x4 = wasm_f32x4_convert_i32x4(dots.v128);
+NK_INTERNAL void nk_angular_through_i32_from_dot_v128relaxed_(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) {
+    v128_t dots_f32x4 = wasm_f32x4_convert_i32x4(dots_vec->v128);
     v128_t query_sumsq_f32x4 = wasm_f32x4_splat((nk_f32_t)query_sumsq);
-    v128_t products_f32x4 = wasm_f32x4_mul(query_sumsq_f32x4, wasm_f32x4_convert_i32x4(target_sumsqs.v128));
+    v128_t products_f32x4 = wasm_f32x4_mul(query_sumsq_f32x4, wasm_f32x4_convert_i32x4(target_sumsqs_vec->v128));
     v128_t sqrt_products_f32x4 = wasm_f32x4_sqrt(products_f32x4);
     v128_t normalized_f32x4 = wasm_f32x4_div(dots_f32x4, sqrt_products_f32x4);
     v128_t angular_f32x4 = wasm_f32x4_sub(wasm_f32x4_splat(1.0f), normalized_f32x4);
-    results->v128 = wasm_f32x4_max(angular_f32x4, wasm_f32x4_splat(0.0f));
+    result_vec->v128 = wasm_f32x4_max(angular_f32x4, wasm_f32x4_splat(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_v128relaxed_(nk_b128_vec_t dots, nk_i32_t query_sumsq,
-                                                                nk_b128_vec_t target_sumsqs, nk_b128_vec_t *results) {
-    v128_t dots_f32x4 = wasm_f32x4_convert_i32x4(dots.v128);
+NK_INTERNAL void nk_euclidean_through_i32_from_dot_v128relaxed_(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) {
+    v128_t dots_f32x4 = wasm_f32x4_convert_i32x4(dots_vec->v128);
     v128_t query_sumsq_f32x4 = wasm_f32x4_splat((nk_f32_t)query_sumsq);
     v128_t two_f32x4 = wasm_f32x4_splat(2.0f);
-    v128_t sum_sq_f32x4 = wasm_f32x4_add(query_sumsq_f32x4, wasm_f32x4_convert_i32x4(target_sumsqs.v128));
+    v128_t sum_sq_f32x4 = wasm_f32x4_add(query_sumsq_f32x4, wasm_f32x4_convert_i32x4(target_sumsqs_vec->v128));
     v128_t dist_sq_f32x4 = wasm_f32x4_relaxed_nmadd(two_f32x4, dots_f32x4, sum_sq_f32x4);
     dist_sq_f32x4 = wasm_f32x4_max(dist_sq_f32x4, wasm_f32x4_splat(0.0f));
-    results->v128 = wasm_f32x4_sqrt(dist_sq_f32x4);
+    result_vec->v128 = wasm_f32x4_sqrt(dist_sq_f32x4);
 }
 
 /** @brief Angular from_dot for u32 accumulators: cast to f32, then angular normalization. 4 pairs. */
-NK_INTERNAL void nk_angular_through_u32_from_dot_v128relaxed_(nk_b128_vec_t dots, nk_u32_t query_sumsq,
-                                                              nk_b128_vec_t target_sumsqs, nk_b128_vec_t *results) {
-    v128_t dots_f32x4 = wasm_f32x4_convert_u32x4(dots.v128);
+NK_INTERNAL void nk_angular_through_u32_from_dot_v128relaxed_(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) {
+    v128_t dots_f32x4 = wasm_f32x4_convert_u32x4(dots_vec->v128);
     v128_t query_sumsq_f32x4 = wasm_f32x4_splat((nk_f32_t)query_sumsq);
-    v128_t products_f32x4 = wasm_f32x4_mul(query_sumsq_f32x4, wasm_f32x4_convert_u32x4(target_sumsqs.v128));
+    v128_t products_f32x4 = wasm_f32x4_mul(query_sumsq_f32x4, wasm_f32x4_convert_u32x4(target_sumsqs_vec->v128));
     v128_t sqrt_products_f32x4 = wasm_f32x4_sqrt(products_f32x4);
     v128_t normalized_f32x4 = wasm_f32x4_div(dots_f32x4, sqrt_products_f32x4);
     v128_t angular_f32x4 = wasm_f32x4_sub(wasm_f32x4_splat(1.0f), normalized_f32x4);
-    results->v128 = wasm_f32x4_max(angular_f32x4, wasm_f32x4_splat(0.0f));
+    result_vec->v128 = wasm_f32x4_max(angular_f32x4, wasm_f32x4_splat(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_v128relaxed_(nk_b128_vec_t dots, nk_u32_t query_sumsq,
-                                                                nk_b128_vec_t target_sumsqs, nk_b128_vec_t *results) {
-    v128_t dots_f32x4 = wasm_f32x4_convert_u32x4(dots.v128);
+NK_INTERNAL void nk_euclidean_through_u32_from_dot_v128relaxed_(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) {
+    v128_t dots_f32x4 = wasm_f32x4_convert_u32x4(dots_vec->v128);
     v128_t query_sumsq_f32x4 = wasm_f32x4_splat((nk_f32_t)query_sumsq);
     v128_t two_f32x4 = wasm_f32x4_splat(2.0f);
-    v128_t sum_sq_f32x4 = wasm_f32x4_add(query_sumsq_f32x4, wasm_f32x4_convert_u32x4(target_sumsqs.v128));
+    v128_t sum_sq_f32x4 = wasm_f32x4_add(query_sumsq_f32x4, wasm_f32x4_convert_u32x4(target_sumsqs_vec->v128));
     v128_t dist_sq_f32x4 = wasm_f32x4_relaxed_nmadd(two_f32x4, dots_f32x4, sum_sq_f32x4);
     dist_sq_f32x4 = wasm_f32x4_max(dist_sq_f32x4, wasm_f32x4_splat(0.0f));
-    results->v128 = wasm_f32x4_sqrt(dist_sq_f32x4);
+    result_vec->v128 = wasm_f32x4_sqrt(dist_sq_f32x4);
 }
 
 #pragma endregion Spatial From Dot Helpers

package/numkong/include/numkong/spatials/README.md

@@ -34,20 +34,20 @@ def euclideans_packed(a: np.ndarray, b: np.ndarray) -> np.ndarray:
 
 ## Input & Output Types
 
-| Input Type | Output Type | Description                                    |
-| ---------- | ----------- | ---------------------------------------------- |
-| `f64`      | `f64`       | 64-bit IEEE 754 double precision               |
-| `f32`      | `f32`       | 32-bit IEEE 754 single precision               |
-| `f16`      | `f32`       | 16-bit IEEE 754 half precision, widened output |
-| `bf16`     | `f32`       | 16-bit brain float, widened output             |
-| `e4m3`     | `f32`       | 8-bit Float8: 4 exponent, 3 mantissa bits      |
-| `e5m2`     | `f32`       | 8-bit Float8: 5 exponent, 2 mantissa bits      |
-| `e2m3`     | `f32`       | 8-bit MX format: 2 exponent, 3 mantissa bits   |
-| `e3m2`     | `f32`       | 8-bit MX format: 3 exponent, 2 mantissa bits   |
-| `i8`       | `f32`       | 8-bit signed integers, float output            |
-| `u8`       | `f32`       | 8-bit unsigned integers, float output          |
-| `i4`       | `f32`       | 4-bit signed integers, float output            |
-| `u4`       | `f32`       | 4-bit unsigned integers, float output          |
+| Input Type | Output Type | Description                                      |
+| ---------- | ----------- | ------------------------------------------------ |
+| `f64`      | `f64`       | 64-bit IEEE 754 double precision                 |
+| `f32`      | `f64`       | 32-bit IEEE 754 single precision, widened output |
+| `f16`      | `f32`       | 16-bit IEEE 754 half precision, widened output   |
+| `bf16`     | `f32`       | 16-bit brain float, widened output               |
+| `e4m3`     | `f32`       | 8-bit Float8: 4 exponent, 3 mantissa bits        |
+| `e5m2`     | `f32`       | 8-bit Float8: 5 exponent, 2 mantissa bits        |
+| `e2m3`     | `f32`       | 8-bit MX format: 2 exponent, 3 mantissa bits     |
+| `e3m2`     | `f32`       | 8-bit MX format: 3 exponent, 2 mantissa bits     |
+| `i8`       | `f32`       | 8-bit signed integers, float output              |
+| `u8`       | `f32`       | 8-bit unsigned integers, float output            |
+| `i4`       | `f32`       | 4-bit signed integers, float output              |
+| `u4`       | `f32`       | 4-bit unsigned integers, float output            |
 
 ## Optimizations
 
@@ -65,7 +65,7 @@ The singular `spatial/` kernels compute these three sums ($\sum a_i b_i$, $\sum
 `nk_angular_through_f32_from_dot_haswell_` replaces this with hardware `_mm_rsqrt_ps` (~12-bit approximation, 5cy latency, 1/cy on port 0) plus one Newton-Raphson refinement step (~22–24 correct bits).
 `nk_euclidean_through_f32_from_dot_serial_` computes `sqrt(x)` as `x * rsqrt(x)` — reusing the same rsqrt path.
 `nk_euclidean_through_f32_from_dot_haswell_` uses exact `_mm_sqrt_ps` (11cy latency, 7cy throughput for XMM) instead of the rsqrt approximation — the subtraction $\|a\|^2 + \|b\|^2 - 2 \cdot \text{dot}$ can produce values near zero where rsqrt error would be amplified by the subsequent multiply.
-For Float64, all backends use exact division and sqrt — no fast rsqrt approximation, since reaching 52 mantissa bits of precision would need 4+ Newton-Raphson iterations, negating the speed advantage.
+For Float64, the SIMD backends use exact division and sqrt — no fast rsqrt approximation, since reaching 52 mantissa bits of precision would need 4+ Newton-Raphson iterations, negating the speed advantage — while `nk_angular_through_f64_from_dot_serial_` still routes through `nk_f64_rsqrt_serial` and its four iterations.
 The 4-wide finalizer batching amortizes these costs: one rsqrt or sqrt call processes 4 output elements simultaneously, hiding the latency behind the GEMM tile's computation.
 
 ### Norm Precomputation in Packed Buffers

package/numkong/include/numkong/spatials/genoa.h

@@ -14,6 +14,9 @@
 
 #include "numkong/spatial/haswell.h"
 #include "numkong/dots/genoa.h"
+#include "numkong/cast/icelake.h"   // `nk_e5m2x32_to_bf16x32_icelake_`
+#include "numkong/dot/skylake.h"    // `nk_dot_through_f32_finalize_skylake_`
+#include "numkong/reduce/skylake.h" // `nk_reduce_add_f32x16_skylake_`
 
 #if defined(__cplusplus)
 extern "C" {

package/numkong/include/numkong/spatials/graniteamx.h

@@ -15,6 +15,8 @@
 #include "numkong/spatial/skylake.h"
 #include "numkong/spatial/serial.h"
 #include "numkong/dots/graniteamx.h"
+#include "numkong/dots/sapphireamx.h"     // `nk_compiler_barrier_sapphireamx_`
+#include "numkong/spatials/sapphireamx.h" // `nk_angulars_row_f32dots_sapphireamx_`
 
 #if defined(__cplusplus)
 extern "C" {

package/numkong/include/numkong/spatials/icelake.h

@@ -14,6 +14,7 @@
 
 #include "numkong/spatial/haswell.h"
 #include "numkong/dots/icelake.h"
+#include "numkong/reduce/skylake.h" // `nk_reduce_add_f32x16_skylake_`
 
 #if defined(__cplusplus)
 extern "C" {

package/numkong/include/numkong/spatials/sierra.h

@@ -15,6 +15,7 @@
 #include "numkong/spatial/haswell.h"
 #include "numkong/spatial/serial.h"
 #include "numkong/dots/sierra.h"
+#include "numkong/reduce/haswell.h" // `nk_reduce_add_i32x8_haswell_`
 
 #if defined(__cplusplus)
 extern "C" {