numkong 7.0.0 → 7.4.2

package/include/numkong/spatial/genoa.h

@@ -139,74 +139,6 @@ nk_angular_bf16_genoa_cycle:
     *result = nk_angular_normalize_f32_haswell_(dot_product_f32, a_norm_sq_f32, b_norm_sq_f32);
 }
 
-NK_PUBLIC void nk_sqeuclidean_e4m3_genoa(nk_e4m3_t const *a, nk_e4m3_t const *b, nk_size_t n, nk_f32_t *result) {
-    __m512 a_sq_f32x16 = _mm512_setzero_ps();
-    __m512 b_sq_f32x16 = _mm512_setzero_ps();
-    __m512 ab_f32x16 = _mm512_setzero_ps();
-    __m256i a_e4m3x32, b_e4m3x32;
-
-nk_sqeuclidean_e4m3_genoa_cycle:
-    if (n < 32) {
-        __mmask32 mask = (__mmask32)_bzhi_u32(0xFFFFFFFF, n);
-        a_e4m3x32 = _mm256_maskz_loadu_epi8(mask, a);
-        b_e4m3x32 = _mm256_maskz_loadu_epi8(mask, b);
-        n = 0;
-    }
-    else {
-        a_e4m3x32 = _mm256_loadu_epi8(a);
-        b_e4m3x32 = _mm256_loadu_epi8(b);
-        a += 32, b += 32, n -= 32;
-    }
-    __m512i a_bf16x32 = nk_e4m3x32_to_bf16x32_icelake_(a_e4m3x32);
-    __m512i b_bf16x32 = nk_e4m3x32_to_bf16x32_icelake_(b_e4m3x32);
-    a_sq_f32x16 = _mm512_dpbf16_ps(a_sq_f32x16, nk_m512bh_from_m512i_(a_bf16x32), nk_m512bh_from_m512i_(a_bf16x32));
-    b_sq_f32x16 = _mm512_dpbf16_ps(b_sq_f32x16, nk_m512bh_from_m512i_(b_bf16x32), nk_m512bh_from_m512i_(b_bf16x32));
-    ab_f32x16 = _mm512_dpbf16_ps(ab_f32x16, nk_m512bh_from_m512i_(a_bf16x32), nk_m512bh_from_m512i_(b_bf16x32));
-    if (n) goto nk_sqeuclidean_e4m3_genoa_cycle;
-
-    // (a-b)² = a² + b² - 2ab
-    __m512 sum_sq_f32x16 = _mm512_add_ps(a_sq_f32x16, b_sq_f32x16);
-    *result = nk_reduce_add_f32x16_skylake_(_mm512_fnmadd_ps(_mm512_set1_ps(2.0f), ab_f32x16, sum_sq_f32x16));
-}
-
-NK_PUBLIC void nk_euclidean_e4m3_genoa(nk_e4m3_t const *a, nk_e4m3_t const *b, nk_size_t n, nk_f32_t *result) {
-    nk_sqeuclidean_e4m3_genoa(a, b, n, result);
-    *result = nk_f32_sqrt_haswell(*result);
-}
-
-NK_PUBLIC void nk_angular_e4m3_genoa(nk_e4m3_t const *a, nk_e4m3_t const *b, nk_size_t n, nk_f32_t *result) {
-    __m512 dot_f32x16 = _mm512_setzero_ps();
-    __m512 a_norm_sq_f32x16 = _mm512_setzero_ps();
-    __m512 b_norm_sq_f32x16 = _mm512_setzero_ps();
-    __m256i a_e4m3x32, b_e4m3x32;
-
-nk_angular_e4m3_genoa_cycle:
-    if (n < 32) {
-        __mmask32 mask = (__mmask32)_bzhi_u32(0xFFFFFFFF, n);
-        a_e4m3x32 = _mm256_maskz_loadu_epi8(mask, a);
-        b_e4m3x32 = _mm256_maskz_loadu_epi8(mask, b);
-        n = 0;
-    }
-    else {
-        a_e4m3x32 = _mm256_loadu_epi8(a);
-        b_e4m3x32 = _mm256_loadu_epi8(b);
-        a += 32, b += 32, n -= 32;
-    }
-    __m512i a_bf16x32 = nk_e4m3x32_to_bf16x32_icelake_(a_e4m3x32);
-    __m512i b_bf16x32 = nk_e4m3x32_to_bf16x32_icelake_(b_e4m3x32);
-    dot_f32x16 = _mm512_dpbf16_ps(dot_f32x16, nk_m512bh_from_m512i_(a_bf16x32), nk_m512bh_from_m512i_(b_bf16x32));
-    a_norm_sq_f32x16 = _mm512_dpbf16_ps(a_norm_sq_f32x16, nk_m512bh_from_m512i_(a_bf16x32),
-                                        nk_m512bh_from_m512i_(a_bf16x32));
-    b_norm_sq_f32x16 = _mm512_dpbf16_ps(b_norm_sq_f32x16, nk_m512bh_from_m512i_(b_bf16x32),
-                                        nk_m512bh_from_m512i_(b_bf16x32));
-    if (n) goto nk_angular_e4m3_genoa_cycle;
-
-    nk_f32_t dot_f32 = nk_reduce_add_f32x16_skylake_(dot_f32x16);
-    nk_f32_t a_norm_sq_f32 = nk_reduce_add_f32x16_skylake_(a_norm_sq_f32x16);
-    nk_f32_t b_norm_sq_f32 = nk_reduce_add_f32x16_skylake_(b_norm_sq_f32x16);
-    *result = nk_angular_normalize_f32_haswell_(dot_f32, a_norm_sq_f32, b_norm_sq_f32);
-}
-
 NK_PUBLIC void nk_sqeuclidean_e5m2_genoa(nk_e5m2_t const *a, nk_e5m2_t const *b, nk_size_t n, nk_f32_t *result) {
     __m512 a_sq_f32x16 = _mm512_setzero_ps();
     __m512 b_sq_f32x16 = _mm512_setzero_ps();

package/include/numkong/spatial/haswell.h

@@ -8,14 +8,14 @@
  *
  *  @section spatial_haswell_instructions Key AVX2 Spatial Instructions
  *
- *      Intrinsic                   Instruction                     Latency     Throughput  Ports
- *      _mm256_fmadd_ps             VFMADD (YMM, YMM, YMM)          5cy         0.5/cy      p01
- *      _mm256_mul_ps               VMULPS (YMM, YMM, YMM)          5cy         0.5/cy      p01
- *      _mm256_add_ps               VADDPS (YMM, YMM, YMM)          3cy         1/cy        p01
- *      _mm256_sub_ps               VSUBPS (YMM, YMM, YMM)          3cy         1/cy        p01
- *      _mm_rsqrt_ps                VRSQRTPS (XMM, XMM)             5cy         1/cy        p0
- *      _mm_sqrt_ps                 VSQRTPS (XMM, XMM)              11cy        7cy         p0
- *      _mm256_sqrt_ps              VSQRTPS (YMM, YMM)              12cy        14cy        p0
+ *      Intrinsic        Instruction             Haswell    Genoa
+ *      _mm256_fmadd_ps  VFMADD (YMM, YMM, YMM)  5cy @ p01  4cy @ p01
+ *      _mm256_mul_ps    VMULPS (YMM, YMM, YMM)  5cy @ p01  3cy @ p01
+ *      _mm256_add_ps    VADDPS (YMM, YMM, YMM)  3cy @ p01  3cy @ p23
+ *      _mm256_sub_ps    VSUBPS (YMM, YMM, YMM)  3cy @ p01  3cy @ p23
+ *      _mm_rsqrt_ps     VRSQRTPS (XMM, XMM)     5cy @ p0   4cy @ p01
+ *      _mm_sqrt_ps      VSQRTPS (XMM, XMM)      11cy @ p0  15cy @ p01
+ *      _mm256_sqrt_ps   VSQRTPS (YMM, YMM)      19cy @ p0  15cy @ p01
  *
  *  For angular distance normalization, `_mm_rsqrt_ps` provides ~12-bit precision (1.5 x 2⁻¹² error).
  *  Newton-Raphson refinement doubles precision to ~22-24 bits, sufficient for f32. For f64 we use
@@ -52,7 +52,7 @@ NK_INTERNAL __m128 nk_rsqrt_f32x4_haswell_(__m128 x) {
 }
 
 /** @brief Safe square root of 4 floats with zero-clamping for numerical stability. */
-NK_INTERNAL __m128 nk_safe_sqrt_f32x4_haswell_(__m128 x) { return _mm_sqrt_ps(_mm_max_ps(x, _mm_setzero_ps())); }
+NK_INTERNAL __m128 nk_sqrt_f32x4_haswell_(__m128 x) { return _mm_sqrt_ps(_mm_max_ps(x, _mm_setzero_ps())); }
 
 /** @brief Angular from_dot: computes 1 − dot × rsqrt(query_sumsq × target_sumsq) for 4 pairs. */
 NK_INTERNAL void nk_angular_through_f32_from_dot_haswell_(nk_b128_vec_t dots, nk_f32_t query_sumsq,
@@ -73,7 +73,7 @@ NK_INTERNAL void nk_euclidean_through_f32_from_dot_haswell_(nk_b128_vec_t dots,
     __m128 query_sumsq_f32x4 = _mm_set1_ps(query_sumsq);
     __m128 sum_sq_f32x4 = _mm_add_ps(query_sumsq_f32x4, target_sumsqs.xmm_ps);
     __m128 dist_sq_f32x4 = _mm_fnmadd_ps(_mm_set1_ps(2.0f), dots_f32x4, sum_sq_f32x4);
-    results->xmm_ps = nk_safe_sqrt_f32x4_haswell_(dist_sq_f32x4);
+    results->xmm_ps = nk_sqrt_f32x4_haswell_(dist_sq_f32x4);
 }
 
 /** @brief Angular from_dot for native f64: 1 − dot / √(query_sumsq × target_sumsq) for 4 pairs. */
@@ -117,7 +117,7 @@ NK_INTERNAL void nk_euclidean_through_i32_from_dot_haswell_(nk_b128_vec_t dots,
     __m128 query_sumsq_f32x4 = _mm_set1_ps((nk_f32_t)query_sumsq);
     __m128 sum_sq_f32x4 = _mm_add_ps(query_sumsq_f32x4, _mm_cvtepi32_ps(target_sumsqs.xmm));
     __m128 dist_sq_f32x4 = _mm_fnmadd_ps(_mm_set1_ps(2.0f), dots_f32x4, sum_sq_f32x4);
-    results->xmm_ps = nk_safe_sqrt_f32x4_haswell_(dist_sq_f32x4);
+    results->xmm_ps = nk_sqrt_f32x4_haswell_(dist_sq_f32x4);
 }
 
 /** @brief Angular from_dot for u32 accumulators: cast to f32, rsqrt+NR, clamp. 4 pairs. */
@@ -139,7 +139,7 @@ NK_INTERNAL void nk_euclidean_through_u32_from_dot_haswell_(nk_b128_vec_t dots,
     __m128 query_sumsq_f32x4 = _mm_set1_ps((nk_f32_t)query_sumsq);
     __m128 sum_sq_f32x4 = _mm_add_ps(query_sumsq_f32x4, _mm_cvtepi32_ps(target_sumsqs.xmm));
     __m128 dist_sq_f32x4 = _mm_fnmadd_ps(_mm_set1_ps(2.0f), dots_f32x4, sum_sq_f32x4);
-    results->xmm_ps = nk_safe_sqrt_f32x4_haswell_(dist_sq_f32x4);
+    results->xmm_ps = nk_sqrt_f32x4_haswell_(dist_sq_f32x4);
 }
 
 NK_INTERNAL nk_f64_t nk_angular_normalize_f64_haswell_(nk_f64_t ab, nk_f64_t a2, nk_f64_t b2) {
@@ -173,28 +173,30 @@ NK_INTERNAL nk_f32_t nk_angular_normalize_f32_haswell_(nk_f32_t ab, nk_f32_t a2,
     else if (ab == 0.0f) return 1.0f;
 
     // Load the squares into an __m128 register for single-precision floating-point operations
-    __m128 squares = _mm_set_ps(a2, b2, a2, b2); // We replicate to make use of full register
+    __m128 squares_f32x4 = _mm_set_ps(a2, b2, a2, b2); // We replicate to make use of full register
 
     // Compute the reciprocal square root of the squares using `_mm_rsqrt_ps` (single-precision)
-    __m128 rsqrts = _mm_rsqrt_ps(squares);
+    __m128 rsqrts_f32x4 = _mm_rsqrt_ps(squares_f32x4);
 
     // Perform one iteration of Newton-Raphson refinement to improve the precision of rsqrt:
     // Formula: y' = y × (1.5 - 0.5 × x × y × y)
-    __m128 half = _mm_set1_ps(0.5f);
-    __m128 three_halves = _mm_set1_ps(1.5f);
-    rsqrts = _mm_mul_ps(rsqrts,
-                        _mm_sub_ps(three_halves, _mm_mul_ps(half, _mm_mul_ps(squares, _mm_mul_ps(rsqrts, rsqrts)))));
+    __m128 half_f32x4 = _mm_set1_ps(0.5f);
+    __m128 three_halves_f32x4 = _mm_set1_ps(1.5f);
+    rsqrts_f32x4 = _mm_mul_ps(
+        rsqrts_f32x4,
+        _mm_sub_ps(three_halves_f32x4,
+                   _mm_mul_ps(half_f32x4, _mm_mul_ps(squares_f32x4, _mm_mul_ps(rsqrts_f32x4, rsqrts_f32x4)))));
 
     // Extract the reciprocal square roots of a2 and b2 from the __m128 register
-    nk_f32_t a2_reciprocal = _mm_cvtss_f32(_mm_shuffle_ps(rsqrts, rsqrts, _MM_SHUFFLE(0, 0, 0, 1)));
-    nk_f32_t b2_reciprocal = _mm_cvtss_f32(rsqrts);
+    nk_f32_t a2_reciprocal = _mm_cvtss_f32(_mm_shuffle_ps(rsqrts_f32x4, rsqrts_f32x4, _MM_SHUFFLE(0, 0, 0, 1)));
+    nk_f32_t b2_reciprocal = _mm_cvtss_f32(rsqrts_f32x4);
 
     // Calculate the angular distance: 1 - dot_product × a2_reciprocal × b2_reciprocal
     nk_f32_t result = 1.0f - ab * a2_reciprocal * b2_reciprocal;
     return result > 0 ? result : 0;
 }
 
-#pragma region - Smaller Floats
+#pragma region F16 and BF16 Floats
 
 NK_PUBLIC void nk_sqeuclidean_f16_haswell(nk_f16_t const *a, nk_f16_t const *b, nk_size_t n, nk_f32_t *result) {
     __m256 a_f32x8, b_f32x8;
@@ -257,25 +259,32 @@ nk_angular_f16_haswell_cycle:
 }
 
 NK_PUBLIC void nk_sqeuclidean_bf16_haswell(nk_bf16_t const *a, nk_bf16_t const *b, nk_size_t n, nk_f32_t *result) {
-    __m256 a_f32x8, b_f32x8;
+    __m256i a_bf16_i16x16, b_bf16_i16x16;
     __m256 distance_sq_f32x8 = _mm256_setzero_ps();
+    __m256i mask_high_u32x8 = _mm256_set1_epi32((int)0xFFFF0000);
 
 nk_sqeuclidean_bf16_haswell_cycle:
-    if (n < 8) {
+    if (n < 16) {
         nk_b256_vec_t a_vec, b_vec;
-        nk_partial_load_bf16x8_to_f32x8_haswell_(a, &a_vec, n);
-        nk_partial_load_bf16x8_to_f32x8_haswell_(b, &b_vec, n);
-        a_f32x8 = a_vec.ymm_ps;
-        b_f32x8 = b_vec.ymm_ps;
+        nk_partial_load_b16x16_serial_(a, &a_vec, n);
+        nk_partial_load_b16x16_serial_(b, &b_vec, n);
+        a_bf16_i16x16 = a_vec.ymm;
+        b_bf16_i16x16 = b_vec.ymm;
         n = 0;
     }
     else {
-        a_f32x8 = nk_bf16x8_to_f32x8_haswell_(_mm_loadu_si128((__m128i const *)a));
-        b_f32x8 = nk_bf16x8_to_f32x8_haswell_(_mm_loadu_si128((__m128i const *)b));
-        n -= 8, a += 8, b += 8;
-    }
-    __m256 diff_f32x8 = _mm256_sub_ps(a_f32x8, b_f32x8);
-    distance_sq_f32x8 = _mm256_fmadd_ps(diff_f32x8, diff_f32x8, distance_sq_f32x8);
+        a_bf16_i16x16 = _mm256_loadu_si256((__m256i const *)a);
+        b_bf16_i16x16 = _mm256_loadu_si256((__m256i const *)b);
+        n -= 16, a += 16, b += 16;
+    }
+    __m256 a_even_f32x8 = _mm256_castsi256_ps(_mm256_slli_epi32(a_bf16_i16x16, 16));
+    __m256 b_even_f32x8 = _mm256_castsi256_ps(_mm256_slli_epi32(b_bf16_i16x16, 16));
+    __m256 diff_even_f32x8 = _mm256_sub_ps(a_even_f32x8, b_even_f32x8);
+    distance_sq_f32x8 = _mm256_fmadd_ps(diff_even_f32x8, diff_even_f32x8, distance_sq_f32x8);
+    __m256 a_odd_f32x8 = _mm256_castsi256_ps(_mm256_and_si256(a_bf16_i16x16, mask_high_u32x8));
+    __m256 b_odd_f32x8 = _mm256_castsi256_ps(_mm256_and_si256(b_bf16_i16x16, mask_high_u32x8));
+    __m256 diff_odd_f32x8 = _mm256_sub_ps(a_odd_f32x8, b_odd_f32x8);
+    distance_sq_f32x8 = _mm256_fmadd_ps(diff_odd_f32x8, diff_odd_f32x8, distance_sq_f32x8);
     if (n) goto nk_sqeuclidean_bf16_haswell_cycle;
 
     *result = nk_reduce_add_f32x8_haswell_(distance_sq_f32x8);
@@ -287,27 +296,35 @@ NK_PUBLIC void nk_euclidean_bf16_haswell(nk_bf16_t const *a, nk_bf16_t const *b,
 }
 
 NK_PUBLIC void nk_angular_bf16_haswell(nk_bf16_t const *a, nk_bf16_t const *b, nk_size_t n, nk_f32_t *result) {
-    __m256 a_f32x8, b_f32x8;
+    __m256i a_bf16_i16x16, b_bf16_i16x16;
     __m256 dot_product_f32x8 = _mm256_setzero_ps(), a_norm_sq_f32x8 = _mm256_setzero_ps(),
            b_norm_sq_f32x8 = _mm256_setzero_ps();
+    __m256i mask_high_u32x8 = _mm256_set1_epi32((int)0xFFFF0000);
 
 nk_angular_bf16_haswell_cycle:
-    if (n < 8) {
+    if (n < 16) {
         nk_b256_vec_t a_vec, b_vec;
-        nk_partial_load_bf16x8_to_f32x8_haswell_(a, &a_vec, n);
-        nk_partial_load_bf16x8_to_f32x8_haswell_(b, &b_vec, n);
-        a_f32x8 = a_vec.ymm_ps;
-        b_f32x8 = b_vec.ymm_ps;
+        nk_partial_load_b16x16_serial_(a, &a_vec, n);
+        nk_partial_load_b16x16_serial_(b, &b_vec, n);
+        a_bf16_i16x16 = a_vec.ymm;
+        b_bf16_i16x16 = b_vec.ymm;
         n = 0;
     }
     else {
-        a_f32x8 = nk_bf16x8_to_f32x8_haswell_(_mm_loadu_si128((__m128i const *)a));
-        b_f32x8 = nk_bf16x8_to_f32x8_haswell_(_mm_loadu_si128((__m128i const *)b));
-        n -= 8, a += 8, b += 8;
-    }
-    dot_product_f32x8 = _mm256_fmadd_ps(a_f32x8, b_f32x8, dot_product_f32x8);
-    a_norm_sq_f32x8 = _mm256_fmadd_ps(a_f32x8, a_f32x8, a_norm_sq_f32x8);
-    b_norm_sq_f32x8 = _mm256_fmadd_ps(b_f32x8, b_f32x8, b_norm_sq_f32x8);
+        a_bf16_i16x16 = _mm256_loadu_si256((__m256i const *)a);
+        b_bf16_i16x16 = _mm256_loadu_si256((__m256i const *)b);
+        n -= 16, a += 16, b += 16;
+    }
+    __m256 a_even_f32x8 = _mm256_castsi256_ps(_mm256_slli_epi32(a_bf16_i16x16, 16));
+    __m256 b_even_f32x8 = _mm256_castsi256_ps(_mm256_slli_epi32(b_bf16_i16x16, 16));
+    dot_product_f32x8 = _mm256_fmadd_ps(a_even_f32x8, b_even_f32x8, dot_product_f32x8);
+    a_norm_sq_f32x8 = _mm256_fmadd_ps(a_even_f32x8, a_even_f32x8, a_norm_sq_f32x8);
+    b_norm_sq_f32x8 = _mm256_fmadd_ps(b_even_f32x8, b_even_f32x8, b_norm_sq_f32x8);
+    __m256 a_odd_f32x8 = _mm256_castsi256_ps(_mm256_and_si256(a_bf16_i16x16, mask_high_u32x8));
+    __m256 b_odd_f32x8 = _mm256_castsi256_ps(_mm256_and_si256(b_bf16_i16x16, mask_high_u32x8));
+    dot_product_f32x8 = _mm256_fmadd_ps(a_odd_f32x8, b_odd_f32x8, dot_product_f32x8);
+    a_norm_sq_f32x8 = _mm256_fmadd_ps(a_odd_f32x8, a_odd_f32x8, a_norm_sq_f32x8);
+    b_norm_sq_f32x8 = _mm256_fmadd_ps(b_odd_f32x8, b_odd_f32x8, b_norm_sq_f32x8);
     if (n) goto nk_angular_bf16_haswell_cycle;
 
     nk_f32_t dot_product_f32 = nk_reduce_add_f32x8_haswell_(dot_product_f32x8);
@@ -316,8 +333,8 @@ nk_angular_bf16_haswell_cycle:
     *result = nk_angular_normalize_f32_haswell_(dot_product_f32, a_norm_sq_f32, b_norm_sq_f32);
 }
 
-#pragma endregion - Smaller Floats
-#pragma region - Small Integers
+#pragma endregion F16 and BF16 Floats
+#pragma region I8 and U8 Integers
 
 NK_PUBLIC void nk_sqeuclidean_i8_haswell(nk_i8_t const *a, nk_i8_t const *b, nk_size_t n, nk_u32_t *result) {
     // Optimized i8 L2-squared using saturating subtract + VPMADDWD
@@ -433,7 +450,8 @@ NK_PUBLIC void nk_angular_i8_haswell(nk_i8_t const *a, nk_i8_t const *b, nk_size
         b_norm_sq_i32 += b_element_i32 * b_element_i32;
     }
 
-    *result = nk_angular_normalize_f32_haswell_(dot_product_i32, a_norm_sq_i32, b_norm_sq_i32);
+    *result = nk_angular_normalize_f32_haswell_((nk_f32_t)dot_product_i32, (nk_f32_t)a_norm_sq_i32,
+                                                (nk_f32_t)b_norm_sq_i32);
 }
 
 NK_PUBLIC void nk_sqeuclidean_u8_haswell(nk_u8_t const *a, nk_u8_t const *b, nk_size_t n, nk_u32_t *result) {
@@ -539,11 +557,12 @@ NK_PUBLIC void nk_angular_u8_haswell(nk_u8_t const *a, nk_u8_t const *b, nk_size
         b_norm_sq_i32 += b_element_i32 * b_element_i32;
     }
 
-    *result = nk_angular_normalize_f32_haswell_(dot_product_i32, a_norm_sq_i32, b_norm_sq_i32);
+    *result = nk_angular_normalize_f32_haswell_((nk_f32_t)dot_product_i32, (nk_f32_t)a_norm_sq_i32,
+                                                (nk_f32_t)b_norm_sq_i32);
 }
 
-#pragma endregion - Small Integers
-#pragma region - Traditional Floats
+#pragma endregion I8 and U8 Integers
+#pragma region F32 and F64 Floats
 
 NK_PUBLIC void nk_sqeuclidean_f32_haswell(nk_f32_t const *a, nk_f32_t const *b, nk_size_t n, nk_f64_t *result) {
     // Upcast to f64 for higher precision accumulation
@@ -693,8 +712,8 @@ nk_angular_f64_haswell_cycle:
         nk_reduce_add_f64x4_haswell_(a_norm_sq_f64x4), nk_reduce_add_f64x4_haswell_(b_norm_sq_f64x4));
 }
 
-#pragma endregion - Traditional Floats
-#pragma region - Smaller Floats
+#pragma endregion F32 and F64 Floats
+#pragma region FP8 Floats
 
 NK_PUBLIC void nk_sqeuclidean_e2m3_haswell(nk_e2m3_t const *a, nk_e2m3_t const *b, nk_size_t n, nk_f32_t *result) {
     __m256 distance_sq_f32x8 = _mm256_setzero_ps();
@@ -954,7 +973,7 @@ nk_angular_e5m2_haswell_cycle:
 } // extern "C"
 #endif
 
-#pragma endregion - Smaller Floats
+#pragma endregion FP8 Floats
 #endif // NK_TARGET_HASWELL
 #endif // NK_TARGET_X86_
 #endif // NK_SPATIAL_HASWELL_H