usearch 2.15.3 → 2.16.0

package/simsimd/include/simsimd/geospatial.h

@@ -13,8 +13,8 @@
  *  - 64-bit IEEE-754 floating point
  *
  *  For hardware architectures:
- *  - Arm (NEON)
- *  - x86 (AVX2)
+ *  - Arm: NEON
+ *  - x86: Haswell
  *
  *  In most cases, for distance computations, we don't need the exact Haversine formula.
  *  The very last part of the computation applies `asin(sqrt(x))` non-linear transformation.

package/simsimd/include/simsimd/mesh.h

@@ -15,8 +15,8 @@
  *  - 16-bit brain-floating point
  *
  *  For hardware architectures:
- *  - Arm (NEON, SVE)
- *  - x86 (AVX512)
+ *  - Arm: Neon
+ *  - x86: Genoa, Sapphire
  *
  *  x86 intrinsics: https://www.intel.com/content/www/us/en/docs/intrinsics-guide/
  *  Arm intrinsics: https://developer.arm.com/architectures/instruction-sets/intrinsics/

package/simsimd/include/simsimd/probability.h

@@ -14,8 +14,8 @@
  *  - 16-bit brain-floating point numbers
  *
  *  For hardware architectures:
- *  - Arm (NEON, SVE)
- *  - x86 (AVX2, AVX512)
+ *  - Arm: NEON
+ *  - x86: Haswell, Skylake, Sapphire
  *
  *  x86 intrinsics: https://www.intel.com/content/www/us/en/docs/intrinsics-guide/
  *  Arm intrinsics: https://developer.arm.com/architectures/instruction-sets/intrinsics/
@@ -83,32 +83,32 @@ SIMSIMD_PUBLIC void simsimd_kl_f16_sapphire(simsimd_f16_t const* a, simsimd_f16_
 SIMSIMD_PUBLIC void simsimd_js_f16_sapphire(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n, simsimd_distance_t* divergence);
 // clang-format on
 
-#define SIMSIMD_MAKE_KL(name, input_type, accumulator_type, load_and_convert, epsilon)                                 \
-    SIMSIMD_PUBLIC void simsimd_kl_##input_type##_##name(simsimd_##input_type##_t const* a,                            \
-                                                         simsimd_##input_type##_t const* b, simsimd_size_t n,          \
-                                                         simsimd_distance_t* result) {                                 \
-        simsimd_##accumulator_type##_t d = 0;                                                                          \
-        for (simsimd_size_t i = 0; i != n; ++i) {                                                                      \
-            simsimd_##accumulator_type##_t ai = load_and_convert(a + i);                                               \
-            simsimd_##accumulator_type##_t bi = load_and_convert(b + i);                                               \
-            d += ai * SIMSIMD_LOG((ai + epsilon) / (bi + epsilon));                                                    \
-        }                                                                                                              \
-        *result = (simsimd_distance_t)d;                                                                               \
+#define SIMSIMD_MAKE_KL(name, input_type, accumulator_type, load_and_convert, epsilon)                        \
+    SIMSIMD_PUBLIC void simsimd_kl_##input_type##_##name(simsimd_##input_type##_t const *a,                   \
+                                                         simsimd_##input_type##_t const *b, simsimd_size_t n, \
+                                                         simsimd_distance_t *result) {                        \
+        simsimd_##accumulator_type##_t d = 0;                                                                 \
+        for (simsimd_size_t i = 0; i != n; ++i) {                                                             \
+            simsimd_##accumulator_type##_t ai = load_and_convert(a + i);                                      \
+            simsimd_##accumulator_type##_t bi = load_and_convert(b + i);                                      \
+            d += ai * SIMSIMD_LOG((ai + epsilon) / (bi + epsilon));                                           \
+        }                                                                                                     \
+        *result = (simsimd_distance_t)d;                                                                      \
     }
 
-#define SIMSIMD_MAKE_JS(name, input_type, accumulator_type, load_and_convert, epsilon)                                 \
-    SIMSIMD_PUBLIC void simsimd_js_##input_type##_##name(simsimd_##input_type##_t const* a,                            \
-                                                         simsimd_##input_type##_t const* b, simsimd_size_t n,          \
-                                                         simsimd_distance_t* result) {                                 \
-        simsimd_##accumulator_type##_t d = 0;                                                                          \
-        for (simsimd_size_t i = 0; i != n; ++i) {                                                                      \
-            simsimd_##accumulator_type##_t ai = load_and_convert(a + i);                                               \
-            simsimd_##accumulator_type##_t bi = load_and_convert(b + i);                                               \
-            simsimd_##accumulator_type##_t mi = (ai + bi) / 2;                                                         \
-            d += ai * SIMSIMD_LOG((ai + epsilon) / (mi + epsilon));                                                    \
-            d += bi * SIMSIMD_LOG((bi + epsilon) / (mi + epsilon));                                                    \
-        }                                                                                                              \
-        *result = (simsimd_distance_t)d / 2;                                                                           \
+#define SIMSIMD_MAKE_JS(name, input_type, accumulator_type, load_and_convert, epsilon)                        \
+    SIMSIMD_PUBLIC void simsimd_js_##input_type##_##name(simsimd_##input_type##_t const *a,                   \
+                                                         simsimd_##input_type##_t const *b, simsimd_size_t n, \
+                                                         simsimd_distance_t *result) {                        \
+        simsimd_##accumulator_type##_t d = 0;                                                                 \
+        for (simsimd_size_t i = 0; i != n; ++i) {                                                             \
+            simsimd_##accumulator_type##_t ai = load_and_convert(a + i);                                      \
+            simsimd_##accumulator_type##_t bi = load_and_convert(b + i);                                      \
+            simsimd_##accumulator_type##_t mi = (ai + bi) / 2;                                                \
+            d += ai * SIMSIMD_LOG((ai + epsilon) / (mi + epsilon));                                           \
+            d += bi * SIMSIMD_LOG((bi + epsilon) / (mi + epsilon));                                           \
+        }                                                                                                     \
+        *result = (simsimd_distance_t)d / 2;                                                                  \
     }
 
 SIMSIMD_MAKE_KL(serial, f64, f64, SIMSIMD_DEREFERENCE, SIMSIMD_F32_DIVISION_EPSILON) // simsimd_kl_f64_serial
@@ -132,7 +132,7 @@ SIMSIMD_MAKE_JS(accurate, f16, f64, SIMSIMD_F16_TO_F32, SIMSIMD_F32_DIVISION_EPS
 SIMSIMD_MAKE_KL(accurate, bf16, f64, SIMSIMD_BF16_TO_F32, SIMSIMD_F32_DIVISION_EPSILON) // simsimd_kl_bf16_accurate
 SIMSIMD_MAKE_JS(accurate, bf16, f64, SIMSIMD_BF16_TO_F32, SIMSIMD_F32_DIVISION_EPSILON) // simsimd_js_bf16_accurate
 
-#if SIMSIMD_TARGET_ARM
+#if _SIMSIMD_TARGET_ARM
 #if SIMSIMD_TARGET_NEON
 #pragma GCC push_options
 #pragma GCC target("arch=armv8.2-a+simd")
@@ -163,8 +163,8 @@ SIMSIMD_PUBLIC float32x4_t _simsimd_log2_f32_neon(float32x4_t x) {
     return result;
 }
 
-SIMSIMD_PUBLIC void simsimd_kl_f32_neon(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n,
-                                        simsimd_distance_t* result) {
+SIMSIMD_PUBLIC void simsimd_kl_f32_neon(simsimd_f32_t const *a, simsimd_f32_t const *b, simsimd_size_t n,
+                                        simsimd_distance_t *result) {
     simsimd_f32_t epsilon = SIMSIMD_F32_DIVISION_EPSILON;
     float32x4_t epsilon_vec = vdupq_n_f32(epsilon);
     float32x4_t sum_vec = vdupq_n_f32(0);
@@ -175,7 +175,8 @@ simsimd_kl_f32_neon_cycle:
         a_vec = _simsimd_partial_load_f32x4_neon(a, n);
         b_vec = _simsimd_partial_load_f32x4_neon(b, n);
         n = 0;
-    } else {
+    }
+    else {
         a_vec = vld1q_f32(a);
         b_vec = vld1q_f32(b);
         n -= 4, a += 4, b += 4;
@@ -185,16 +186,15 @@ simsimd_kl_f32_neon_cycle:
     float32x4_t log_ratio_vec = _simsimd_log2_f32_neon(ratio_vec);
     float32x4_t prod_vec = vmulq_f32(a_vec, log_ratio_vec);
     sum_vec = vaddq_f32(sum_vec, prod_vec);
-    if (n != 0)
-        goto simsimd_kl_f32_neon_cycle;
+    if (n != 0) goto simsimd_kl_f32_neon_cycle;
 
     simsimd_f32_t log2_normalizer = 0.693147181f;
     simsimd_f32_t sum = vaddvq_f32(sum_vec) * log2_normalizer;
     *result = sum;
 }
 
-SIMSIMD_PUBLIC void simsimd_js_f32_neon(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n,
-                                        simsimd_distance_t* result) {
+SIMSIMD_PUBLIC void simsimd_js_f32_neon(simsimd_f32_t const *a, simsimd_f32_t const *b, simsimd_size_t n,
+                                        simsimd_distance_t *result) {
     simsimd_f32_t epsilon = SIMSIMD_F32_DIVISION_EPSILON;
     float32x4_t epsilon_vec = vdupq_n_f32(epsilon);
     float32x4_t sum_vec = vdupq_n_f32(0);
@@ -205,7 +205,8 @@ simsimd_js_f32_neon_cycle:
         a_vec = _simsimd_partial_load_f32x4_neon(a, n);
         b_vec = _simsimd_partial_load_f32x4_neon(b, n);
         n = 0;
-    } else {
+    }
+    else {
         a_vec = vld1q_f32(a);
         b_vec = vld1q_f32(b);
         n -= 4, a += 4, b += 4;
@@ -219,8 +220,7 @@ simsimd_js_f32_neon_cycle:
     float32x4_t prod_a_vec = vmulq_f32(a_vec, log_ratio_a_vec);
     float32x4_t prod_b_vec = vmulq_f32(b_vec, log_ratio_b_vec);
     sum_vec = vaddq_f32(sum_vec, vaddq_f32(prod_a_vec, prod_b_vec));
-    if (n != 0)
-        goto simsimd_js_f32_neon_cycle;
+    if (n != 0) goto simsimd_js_f32_neon_cycle;
 
     simsimd_f32_t log2_normalizer = 0.693147181f;
     simsimd_f32_t sum = vaddvq_f32(sum_vec) * log2_normalizer;
@@ -236,8 +236,8 @@ simsimd_js_f32_neon_cycle:
 #pragma GCC target("arch=armv8.2-a+simd+fp16")
 #pragma clang attribute push(__attribute__((target("arch=armv8.2-a+simd+fp16"))), apply_to = function)
 
-SIMSIMD_PUBLIC void simsimd_kl_f16_neon(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n,
-                                        simsimd_distance_t* result) {
+SIMSIMD_PUBLIC void simsimd_kl_f16_neon(simsimd_f16_t const *a, simsimd_f16_t const *b, simsimd_size_t n,
+                                        simsimd_distance_t *result) {
     float32x4_t sum_vec = vdupq_n_f32(0);
     simsimd_f32_t epsilon = SIMSIMD_F32_DIVISION_EPSILON;
     float32x4_t epsilon_vec = vdupq_n_f32(epsilon);
@@ -248,9 +248,10 @@ simsimd_kl_f16_neon_cycle:
         a_vec = vcvt_f32_f16(_simsimd_partial_load_f16x4_neon(a, n));
         b_vec = vcvt_f32_f16(_simsimd_partial_load_f16x4_neon(b, n));
         n = 0;
-    } else {
-        a_vec = vcvt_f32_f16(vld1_f16((simsimd_f16_for_arm_simd_t const*)a));
-        b_vec = vcvt_f32_f16(vld1_f16((simsimd_f16_for_arm_simd_t const*)b));
+    }
+    else {
+        a_vec = vcvt_f32_f16(vld1_f16((simsimd_f16_for_arm_simd_t const *)a));
+        b_vec = vcvt_f32_f16(vld1_f16((simsimd_f16_for_arm_simd_t const *)b));
         n -= 4, a += 4, b += 4;
     }
 
@@ -258,16 +259,15 @@ simsimd_kl_f16_neon_cycle:
     float32x4_t log_ratio_vec = _simsimd_log2_f32_neon(ratio_vec);
     float32x4_t prod_vec = vmulq_f32(a_vec, log_ratio_vec);
     sum_vec = vaddq_f32(sum_vec, prod_vec);
-    if (n)
-        goto simsimd_kl_f16_neon_cycle;
+    if (n) goto simsimd_kl_f16_neon_cycle;
 
     simsimd_f32_t log2_normalizer = 0.693147181f;
     simsimd_f32_t sum = vaddvq_f32(sum_vec) * log2_normalizer;
     *result = sum;
 }
 
-SIMSIMD_PUBLIC void simsimd_js_f16_neon(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n,
-                                        simsimd_distance_t* result) {
+SIMSIMD_PUBLIC void simsimd_js_f16_neon(simsimd_f16_t const *a, simsimd_f16_t const *b, simsimd_size_t n,
+                                        simsimd_distance_t *result) {
     float32x4_t sum_vec = vdupq_n_f32(0);
     simsimd_f32_t epsilon = SIMSIMD_F32_DIVISION_EPSILON;
     float32x4_t epsilon_vec = vdupq_n_f32(epsilon);
@@ -278,9 +278,10 @@ simsimd_js_f16_neon_cycle:
         a_vec = vcvt_f32_f16(_simsimd_partial_load_f16x4_neon(a, n));
         b_vec = vcvt_f32_f16(_simsimd_partial_load_f16x4_neon(b, n));
         n = 0;
-    } else {
-        a_vec = vcvt_f32_f16(vld1_f16((simsimd_f16_for_arm_simd_t const*)a));
-        b_vec = vcvt_f32_f16(vld1_f16((simsimd_f16_for_arm_simd_t const*)b));
+    }
+    else {
+        a_vec = vcvt_f32_f16(vld1_f16((simsimd_f16_for_arm_simd_t const *)a));
+        b_vec = vcvt_f32_f16(vld1_f16((simsimd_f16_for_arm_simd_t const *)b));
         n -= 4, a += 4, b += 4;
     }
 
@@ -292,8 +293,7 @@ simsimd_js_f16_neon_cycle:
     float32x4_t prod_a_vec = vmulq_f32(a_vec, log_ratio_a_vec);
     float32x4_t prod_b_vec = vmulq_f32(b_vec, log_ratio_b_vec);
     sum_vec = vaddq_f32(sum_vec, vaddq_f32(prod_a_vec, prod_b_vec));
-    if (n)
-        goto simsimd_js_f16_neon_cycle;
+    if (n) goto simsimd_js_f16_neon_cycle;
 
     simsimd_f32_t log2_normalizer = 0.693147181f;
     simsimd_f32_t sum = vaddvq_f32(sum_vec) * log2_normalizer;
@@ -303,9 +303,9 @@ simsimd_js_f16_neon_cycle:
 #pragma clang attribute pop
 #pragma GCC pop_options
 #endif // SIMSIMD_TARGET_NEON_F16
-#endif // SIMSIMD_TARGET_ARM
+#endif // _SIMSIMD_TARGET_ARM
 
-#if SIMSIMD_TARGET_X86
+#if _SIMSIMD_TARGET_X86
 #if SIMSIMD_TARGET_HASWELL
 #pragma GCC push_options
 #pragma GCC target("avx2", "f16c", "fma")
@@ -338,8 +338,8 @@ SIMSIMD_INTERNAL __m256 _simsimd_log2_f32_haswell(__m256 x) {
     return result;
 }
 
-SIMSIMD_PUBLIC void simsimd_kl_f16_haswell(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n,
-                                           simsimd_distance_t* result) {
+SIMSIMD_PUBLIC void simsimd_kl_f16_haswell(simsimd_f16_t const *a, simsimd_f16_t const *b, simsimd_size_t n,
+                                           simsimd_distance_t *result) {
     __m256 sum_vec = _mm256_setzero_ps();
     simsimd_f32_t epsilon = SIMSIMD_F32_DIVISION_EPSILON;
     __m256 epsilon_vec = _mm256_set1_ps(epsilon);
@@ -350,9 +350,10 @@ simsimd_kl_f16_haswell_cycle:
         a_vec = _simsimd_partial_load_f16x8_haswell(a, n);
         b_vec = _simsimd_partial_load_f16x8_haswell(b, n);
         n = 0;
-    } else {
-        a_vec = _mm256_cvtph_ps(_mm_loadu_si128((__m128i const*)a));
-        b_vec = _mm256_cvtph_ps(_mm_loadu_si128((__m128i const*)b));
+    }
+    else {
+        a_vec = _mm256_cvtph_ps(_mm_lddqu_si128((__m128i const *)a));
+        b_vec = _mm256_cvtph_ps(_mm_lddqu_si128((__m128i const *)b));
         n -= 8, a += 8, b += 8;
     }
     a_vec = _mm256_add_ps(a_vec, epsilon_vec);
@@ -361,8 +362,7 @@ simsimd_kl_f16_haswell_cycle:
     __m256 log_ratio_vec = _simsimd_log2_f32_haswell(ratio_vec);
     __m256 prod_vec = _mm256_mul_ps(a_vec, log_ratio_vec);
     sum_vec = _mm256_add_ps(sum_vec, prod_vec);
-    if (n)
-        goto simsimd_kl_f16_haswell_cycle;
+    if (n) goto simsimd_kl_f16_haswell_cycle;
 
     simsimd_f32_t log2_normalizer = 0.693147181f;
     simsimd_f32_t sum = _simsimd_reduce_f32x8_haswell(sum_vec);
@@ -370,8 +370,8 @@ simsimd_kl_f16_haswell_cycle:
     *result = sum;
 }
 
-SIMSIMD_PUBLIC void simsimd_js_f16_haswell(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n,
-                                           simsimd_distance_t* result) {
+SIMSIMD_PUBLIC void simsimd_js_f16_haswell(simsimd_f16_t const *a, simsimd_f16_t const *b, simsimd_size_t n,
+                                           simsimd_distance_t *result) {
     simsimd_f32_t epsilon = SIMSIMD_F32_DIVISION_EPSILON;
     __m256 epsilon_vec = _mm256_set1_ps(epsilon);
     __m256 sum_vec = _mm256_setzero_ps();
@@ -382,9 +382,10 @@ simsimd_js_f16_haswell_cycle:
         a_vec = _simsimd_partial_load_f16x8_haswell(a, n);
         b_vec = _simsimd_partial_load_f16x8_haswell(b, n);
         n = 0;
-    } else {
-        a_vec = _mm256_cvtph_ps(_mm_loadu_si128((__m128i const*)a));
-        b_vec = _mm256_cvtph_ps(_mm_loadu_si128((__m128i const*)b));
+    }
+    else {
+        a_vec = _mm256_cvtph_ps(_mm_lddqu_si128((__m128i const *)a));
+        b_vec = _mm256_cvtph_ps(_mm_lddqu_si128((__m128i const *)b));
         n -= 8, a += 8, b += 8;
     }
     a_vec = _mm256_add_ps(a_vec, epsilon_vec);
@@ -398,8 +399,7 @@ simsimd_js_f16_haswell_cycle:
     __m256 prod_b_vec = _mm256_mul_ps(b_vec, log_ratio_b_vec);
     sum_vec = _mm256_add_ps(sum_vec, prod_a_vec);
     sum_vec = _mm256_add_ps(sum_vec, prod_b_vec);
-    if (n)
-        goto simsimd_js_f16_haswell_cycle;
+    if (n) goto simsimd_js_f16_haswell_cycle;
 
     simsimd_f32_t log2_normalizer = 0.693147181f;
     simsimd_f32_t sum = _simsimd_reduce_f32x8_haswell(sum_vec);
@@ -433,8 +433,8 @@ SIMSIMD_INTERNAL __m512 _simsimd_log2_f32_skylake(__m512 x) {
     return _mm512_add_ps(_mm512_mul_ps(p, _mm512_sub_ps(m, one)), e);
 }
 
-SIMSIMD_PUBLIC void simsimd_kl_f32_skylake(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n,
-                                           simsimd_distance_t* result) {
+SIMSIMD_PUBLIC void simsimd_kl_f32_skylake(simsimd_f32_t const *a, simsimd_f32_t const *b, simsimd_size_t n,
+                                           simsimd_distance_t *result) {
     __m512 sum_vec = _mm512_setzero();
     simsimd_f32_t epsilon = SIMSIMD_F32_DIVISION_EPSILON;
     __m512 epsilon_vec = _mm512_set1_ps(epsilon);
@@ -446,7 +446,8 @@ simsimd_kl_f32_skylake_cycle:
         a_vec = _mm512_add_ps(_mm512_maskz_loadu_ps(mask, a), epsilon_vec);
         b_vec = _mm512_add_ps(_mm512_maskz_loadu_ps(mask, b), epsilon_vec);
         n = 0;
-    } else {
+    }
+    else {
         a_vec = _mm512_add_ps(_mm512_loadu_ps(a), epsilon_vec);
         b_vec = _mm512_add_ps(_mm512_loadu_ps(b), epsilon_vec);
         a += 16, b += 16, n -= 16;
@@ -455,15 +456,14 @@ simsimd_kl_f32_skylake_cycle:
     __m512 log_ratio_vec = _simsimd_log2_f32_skylake(ratio_vec);
     __m512 prod_vec = _mm512_mul_ps(a_vec, log_ratio_vec);
     sum_vec = _mm512_add_ps(sum_vec, prod_vec);
-    if (n)
-        goto simsimd_kl_f32_skylake_cycle;
+    if (n) goto simsimd_kl_f32_skylake_cycle;
 
     simsimd_f32_t log2_normalizer = 0.693147181f;
     *result = _mm512_reduce_add_ps(sum_vec) * log2_normalizer;
 }
 
-SIMSIMD_PUBLIC void simsimd_js_f32_skylake(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n,
-                                           simsimd_distance_t* result) {
+SIMSIMD_PUBLIC void simsimd_js_f32_skylake(simsimd_f32_t const *a, simsimd_f32_t const *b, simsimd_size_t n,
+                                           simsimd_distance_t *result) {
     __m512 sum_a_vec = _mm512_setzero();
     __m512 sum_b_vec = _mm512_setzero();
     simsimd_f32_t epsilon = SIMSIMD_F32_DIVISION_EPSILON;
@@ -476,7 +476,8 @@ simsimd_js_f32_skylake_cycle:
         a_vec = _mm512_maskz_loadu_ps(mask, a);
         b_vec = _mm512_maskz_loadu_ps(mask, b);
         n = 0;
-    } else {
+    }
+    else {
         a_vec = _mm512_loadu_ps(a);
         b_vec = _mm512_loadu_ps(b);
         a += 16, b += 16, n -= 16;
@@ -492,8 +493,7 @@ simsimd_js_f32_skylake_cycle:
     __m512 log_ratio_b_vec = _simsimd_log2_f32_skylake(ratio_b_vec);
     sum_a_vec = _mm512_maskz_fmadd_ps(nonzero_mask, a_vec, log_ratio_a_vec, sum_a_vec);
     sum_b_vec = _mm512_maskz_fmadd_ps(nonzero_mask, b_vec, log_ratio_b_vec, sum_b_vec);
-    if (n)
-        goto simsimd_js_f32_skylake_cycle;
+    if (n) goto simsimd_js_f32_skylake_cycle;
 
     simsimd_f32_t log2_normalizer = 0.693147181f;
     *result = _mm512_reduce_add_ps(_mm512_add_ps(sum_a_vec, sum_b_vec)) * log2_normalizer / 2;
@@ -525,8 +525,8 @@ SIMSIMD_INTERNAL __m512h _simsimd_log2_f16_sapphire(__m512h x) {
     return _mm512_add_ph(_mm512_mul_ph(p, _mm512_sub_ph(m, one)), e);
 }
 
-SIMSIMD_PUBLIC void simsimd_kl_f16_sapphire(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n,
-                                            simsimd_distance_t* result) {
+SIMSIMD_PUBLIC void simsimd_kl_f16_sapphire(simsimd_f16_t const *a, simsimd_f16_t const *b, simsimd_size_t n,
+                                            simsimd_distance_t *result) {
     __m512h sum_vec = _mm512_setzero_ph();
     __m512h epsilon_vec = _mm512_set1_ph((simsimd_f16_t)SIMSIMD_F16_DIVISION_EPSILON);
     __m512h a_vec, b_vec;
@@ -537,7 +537,8 @@ simsimd_kl_f16_sapphire_cycle:
         a_vec = _mm512_maskz_add_ph(mask, _mm512_castsi512_ph(_mm512_maskz_loadu_epi16(mask, a)), epsilon_vec);
         b_vec = _mm512_maskz_add_ph(mask, _mm512_castsi512_ph(_mm512_maskz_loadu_epi16(mask, b)), epsilon_vec);
         n = 0;
-    } else {
+    }
+    else {
         a_vec = _mm512_add_ph(_mm512_castsi512_ph(_mm512_loadu_epi16(a)), epsilon_vec);
         b_vec = _mm512_add_ph(_mm512_castsi512_ph(_mm512_loadu_epi16(b)), epsilon_vec);
         a += 32, b += 32, n -= 32;
@@ -546,15 +547,14 @@ simsimd_kl_f16_sapphire_cycle:
     __m512h log_ratio_vec = _simsimd_log2_f16_sapphire(ratio_vec);
     __m512h prod_vec = _mm512_mul_ph(a_vec, log_ratio_vec);
     sum_vec = _mm512_add_ph(sum_vec, prod_vec);
-    if (n)
-        goto simsimd_kl_f16_sapphire_cycle;
+    if (n) goto simsimd_kl_f16_sapphire_cycle;
 
     simsimd_f32_t log2_normalizer = 0.693147181f;
     *result = _mm512_reduce_add_ph(sum_vec) * log2_normalizer;
 }
 
-SIMSIMD_PUBLIC void simsimd_js_f16_sapphire(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n,
-                                            simsimd_distance_t* result) {
+SIMSIMD_PUBLIC void simsimd_js_f16_sapphire(simsimd_f16_t const *a, simsimd_f16_t const *b, simsimd_size_t n,
+                                            simsimd_distance_t *result) {
     __m512h sum_a_vec = _mm512_setzero_ph();
     __m512h sum_b_vec = _mm512_setzero_ph();
     __m512h epsilon_vec = _mm512_set1_ph((simsimd_f16_t)SIMSIMD_F16_DIVISION_EPSILON);
@@ -566,7 +566,8 @@ simsimd_js_f16_sapphire_cycle:
         a_vec = _mm512_castsi512_ph(_mm512_maskz_loadu_epi16(mask, a));
         b_vec = _mm512_castsi512_ph(_mm512_maskz_loadu_epi16(mask, b));
         n = 0;
-    } else {
+    }
+    else {
         a_vec = _mm512_castsi512_ph(_mm512_loadu_epi16(a));
         b_vec = _mm512_castsi512_ph(_mm512_loadu_epi16(b));
         a += 32, b += 32, n -= 32;
@@ -582,8 +583,7 @@ simsimd_js_f16_sapphire_cycle:
     __m512h log_ratio_b_vec = _simsimd_log2_f16_sapphire(ratio_b_vec);
     sum_a_vec = _mm512_maskz_fmadd_ph(nonzero_mask, a_vec, log_ratio_a_vec, sum_a_vec);
     sum_b_vec = _mm512_maskz_fmadd_ph(nonzero_mask, b_vec, log_ratio_b_vec, sum_b_vec);
-    if (n)
-        goto simsimd_js_f16_sapphire_cycle;
+    if (n) goto simsimd_js_f16_sapphire_cycle;
 
     simsimd_f32_t log2_normalizer = 0.693147181f;
     *result = _mm512_reduce_add_ph(_mm512_add_ph(sum_a_vec, sum_b_vec)) * log2_normalizer / 2;
@@ -592,7 +592,7 @@ simsimd_js_f16_sapphire_cycle:
 #pragma clang attribute pop
 #pragma GCC pop_options
 #endif // SIMSIMD_TARGET_SAPPHIRE
-#endif // SIMSIMD_TARGET_X86
+#endif // _SIMSIMD_TARGET_X86
 
 #ifdef __cplusplus
 }