usearch 2.11.1 → 2.13.1

package/simsimd/include/simsimd/types.h

@@ -11,12 +11,21 @@
 #ifndef SIMSIMD_TYPES_H
 #define SIMSIMD_TYPES_H
 
-/*  Annotation for the public API symbols:
- *
- *  - `SIMSIMD_PUBLIC` is used for functions that are part of the public API.
- *  - `SIMSIMD_INTERNAL` is used for internal helper functions with unstable APIs.
- *  - `SIMSIMD_DYNAMIC` is used for functions that are part of the public API, but are dispatched at runtime.
- */
+// Inferring target OS: Windows, MacOS, or Linux
+#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
+#define SIMSIMD_DEFINED_WINDOWS
+#elif defined(__APPLE__) && defined(__MACH__)
+#define SIMSIMD_DEFINED_APPLE
+#elif defined(__linux__)
+#define SIMSIMD_DEFINED_LINUX
+#endif
+
+// Annotation for the public API symbols:
+//
+// - `SIMSIMD_PUBLIC` is used for functions that are part of the public API.
+// - `SIMSIMD_INTERNAL` is used for internal helper functions with unstable APIs.
+// - `SIMSIMD_DYNAMIC` is used for functions that are part of the public API, but are dispatched at runtime.
+//
 #if defined(_WIN32) || defined(__CYGWIN__)
 #define SIMSIMD_DYNAMIC __declspec(dllexport)
 #define SIMSIMD_PUBLIC inline static
@@ -59,6 +68,16 @@
 #endif // defined(__ARM_NEON)
 #endif // !defined(SIMSIMD_TARGET_NEON)
 
+#if !defined(SIMSIMD_TARGET_NEON_I8)
+#define SIMSIMD_TARGET_NEON_I8 SIMSIMD_TARGET_NEON
+#endif // !defined(SIMSIMD_TARGET_NEON_I8)
+#if !defined(SIMSIMD_TARGET_NEON_F16)
+#define SIMSIMD_TARGET_NEON_F16 SIMSIMD_TARGET_NEON
+#endif // !defined(SIMSIMD_TARGET_NEON_F16)
+#if !defined(SIMSIMD_TARGET_NEON_BF16)
+#define SIMSIMD_TARGET_NEON_BF16 SIMSIMD_TARGET_NEON
+#endif // !defined(SIMSIMD_TARGET_NEON_BF16)
+
 // Compiling for Arm: SIMSIMD_TARGET_SVE
 #if !defined(SIMSIMD_TARGET_SVE) || (SIMSIMD_TARGET_SVE && !SIMSIMD_TARGET_ARM)
 #if defined(__ARM_FEATURE_SVE)
@@ -69,6 +88,16 @@
 #endif // defined(__ARM_FEATURE_SVE)
 #endif // !defined(SIMSIMD_TARGET_SVE)
 
+#if !defined(SIMSIMD_TARGET_SVE_I8)
+#define SIMSIMD_TARGET_SVE_I8 SIMSIMD_TARGET_SVE
+#endif // !defined(SIMSIMD_TARGET_SVE_I8)
+#if !defined(SIMSIMD_TARGET_SVE_F16)
+#define SIMSIMD_TARGET_SVE_F16 SIMSIMD_TARGET_SVE
+#endif // !defined(SIMSIMD_TARGET_SVE_F16)
+#if !defined(SIMSIMD_TARGET_SVE_BF16)
+#define SIMSIMD_TARGET_SVE_BF16 SIMSIMD_TARGET_SVE
+#endif // !defined(SIMSIMD_TARGET_SVE_BF16)
+
 // Compiling for x86: SIMSIMD_TARGET_HASWELL
 //
 // Starting with Ivy Bridge, Intel supports the `F16C` extensions for fast half-precision
@@ -87,28 +116,6 @@
 
 // Compiling for x86: SIMSIMD_TARGET_SKYLAKE, SIMSIMD_TARGET_ICE, SIMSIMD_TARGET_SAPPHIRE
 //
-// It's important to provide fine-grained controls over AVX512 families, as they are very fragmented:
-// - Intel Skylake servers: F, CD, VL, DQ, BW
-// - Intel Cascade Lake workstations: F, CD, VL, DQ, BW, VNNI
-//      > In other words, it extends Skylake with VNNI support
-// - Intel Sunny Cove (Ice Lake) servers:
-//        F, CD, VL, DQ, BW, VNNI, VPOPCNTDQ, IFMA, VBMI, VAES, GFNI, VBMI2, BITALG, VPCLMULQDQ
-// - AMD Zen4 (Genoa):
-//        F, CD, VL, DQ, BW, VNNI, VPOPCNTDQ, IFMA, VBMI, VAES, GFNI, VBMI2, BITALG, VPCLMULQDQ, BF16
-//      > In other words, it extends Sunny Cove with BF16 support
-// - Golden Cove (Sapphire Rapids): extends Zen4 and Sunny Cove with FP16 support
-//
-// Intel Palm Cove was an irrelevant intermediate release extending Skylake with IFMA and VBMI.
-// Intel Willow Cove was an irrelevant intermediate release extending Sunny Cove with VP2INTERSECT,
-// that aren't supported by any other CPU built to date... and those are only available in Tiger Lake laptops.
-// Intel Cooper Lake was the only intermediary platform, that supported BF16, but not FP16.
-// It's mostly used in 4-socket and 8-socket high-memory configurations.
-//
-// In practical terms, it makes sense to differentiate only 3 AVX512 generations:
-// 1. Skylake (pre 2019): supports single-precision dot-products.
-// 2. Ice Lake (2019-2021): advanced integer algorithms.
-// 3. Sapphire Rapids (2023+): advanced mixed-precision float processing.
-//
 // To list all available macros for x86, take a recent compiler, like GCC 12 and run:
 //      gcc-12 -march=sapphirerapids -dM -E - < /dev/null | egrep "SSE|AVX" | sort
 // On Arm machines you may want to check for other flags:
@@ -131,6 +138,14 @@
 #define SIMSIMD_TARGET_ICE 0
 #endif
 #endif // !defined(SIMSIMD_TARGET_ICE)
+#if !defined(SIMSIMD_TARGET_GENOA) || (SIMSIMD_TARGET_GENOA && !SIMSIMD_TARGET_X86)
+#if defined(__AVX512BF16__)
+#define SIMSIMD_TARGET_GENOA 1
+#else
+#undef SIMSIMD_TARGET_GENOA
+#define SIMSIMD_TARGET_GENOA 0
+#endif
+#endif // !defined(SIMSIMD_TARGET_GENOA)
 #if !defined(SIMSIMD_TARGET_SAPPHIRE) || (SIMSIMD_TARGET_SAPPHIRE && !SIMSIMD_TARGET_X86)
 #if defined(__AVX512FP16__)
 #define SIMSIMD_TARGET_SAPPHIRE 1
@@ -185,19 +200,19 @@ typedef float simsimd_f32_t;
 typedef double simsimd_f64_t;
 typedef signed char simsimd_i8_t;
 typedef unsigned char simsimd_b8_t;
+typedef long long simsimd_i64_t;
 typedef unsigned long long simsimd_u64_t;
 
 typedef simsimd_u64_t simsimd_size_t;
 typedef simsimd_f64_t simsimd_distance_t;
 
-#if !defined(SIMSIMD_NATIVE_F16) || SIMSIMD_NATIVE_F16
-/**
- *  @brief  Half-precision floating-point type.
+/*  @brief  Half-precision floating-point type.
  *
- *  - GCC or Clang on 64-bit ARM: `__fp16`, may require `-mfp16-format` option.
+ *  - GCC or Clang on 64-bit Arm: `__fp16`, may require `-mfp16-format` option.
  *  - GCC or Clang on 64-bit x86: `_Float16`.
  *  - Default: `unsigned short`.
  */
+#if !defined(SIMSIMD_NATIVE_F16) || SIMSIMD_NATIVE_F16
 #if (defined(__GNUC__) || defined(__clang__)) && (defined(__ARM_ARCH) || defined(__aarch64__)) &&                      \
     (defined(__ARM_FP16_FORMAT_IEEE))
 #if !defined(SIMSIMD_NATIVE_F16)
@@ -219,17 +234,55 @@ typedef _Float16 simsimd_f16_t;
 typedef unsigned short simsimd_f16_t;
 #endif
 
+#if !defined(SIMSIMD_NATIVE_BF16) || SIMSIMD_NATIVE_BF16
+/**
+ *  @brief  Half-precision brain-float type.
+ *
+ *  - GCC or Clang on 64-bit Arm: `__bf16`
+ *  - GCC or Clang on 64-bit x86: `_BFloat16`.
+ *  - Default: `unsigned short`.
+ *
+ *  @warning Apple Clang has hard time with bf16.
+ *  https://developer.apple.com/documentation/xcode/writing-arm64-code-for-apple-platforms
+ *  https://forums.developer.apple.com/forums/thread/726201
+ */
+#if (defined(__GNUC__) || defined(__clang__)) && (defined(__ARM_ARCH) || defined(__aarch64__)) &&                      \
+    (defined(__ARM_BF16_FORMAT_ALTERNATIVE))
+#if !defined(SIMSIMD_NATIVE_BF16)
+#define SIMSIMD_NATIVE_BF16 1
+#endif
+typedef __fp16 simsimd_bf16_t;
+#elif ((defined(__GNUC__) || defined(__clang__)) && (defined(__x86_64__) || defined(__i386__)) &&                      \
+       (defined(__SSE2__) || defined(__AVX512F__)))
+typedef _Float16 simsimd_bf16_t;
+#if !defined(SIMSIMD_NATIVE_BF16)
+#define SIMSIMD_NATIVE_BF16 1
+#endif
+#else // Unknown compiler or architecture
+#define SIMSIMD_NATIVE_BF16 0
+#endif // Unknown compiler or architecture
+#endif // !SIMSIMD_NATIVE_BF16
+
+#if !SIMSIMD_NATIVE_BF16
+typedef unsigned short simsimd_bf16_t;
+#endif
+
 /**
  *  @brief  Alias for the half-precision floating-point type on Arm.
- *          Clang and GCC bring the `float16_t` symbol when you compile for Aarch64.
- *          MSVC lacks it, and it's `vld1_f16`-like intrinsics are in reality macros,
- *          that cast to 16-bit integers internally, instead of using floats.
+ *
+ *  Clang and GCC bring the `float16_t` symbol when you compile for Aarch64.
+ *  MSVC lacks it, and it's `vld1_f16`-like intrinsics are in reality macros,
+ *  that cast to 16-bit integers internally, instead of using floats.
+ *  Some of those are defined as aliases, so we use `#define` preprocessor
+ *  directives instead of `typedef` to avoid errors.
  */
 #if SIMSIMD_TARGET_ARM
 #if defined(_MSC_VER)
-typedef simsimd_f16_t simsimd_f16_for_arm_simd_t;
+#define simsimd_f16_for_arm_simd_t simsimd_f16_t
+#define simsimd_bf16_for_arm_simd_t simsimd_bf16_t
 #else
-typedef float16_t simsimd_f16_for_arm_simd_t;
+#define simsimd_f16_for_arm_simd_t float16_t
+#define simsimd_bf16_for_arm_simd_t bfloat16_t
 #endif
 #endif
 
@@ -241,9 +294,21 @@ typedef float16_t simsimd_f16_for_arm_simd_t;
  */
 #ifndef SIMSIMD_UNCOMPRESS_F16
 #if SIMSIMD_NATIVE_F16
-#define SIMSIMD_UNCOMPRESS_F16(x) SIMSIMD_IDENTIFY(x)
+#define SIMSIMD_UNCOMPRESS_F16(x) (SIMSIMD_IDENTIFY(x))
 #else
-#define SIMSIMD_UNCOMPRESS_F16(x) simsimd_uncompress_f16(x)
+#define SIMSIMD_UNCOMPRESS_F16(x) (simsimd_uncompress_f16(x))
+#endif
+#endif
+
+/**
+ *  @brief  Returns the value of the half-precision brain floating-point number,
+ *          potentially decompressed into single-precision.
+ */
+#ifndef SIMSIMD_UNCOMPRESS_BF16
+#if SIMSIMD_NATIVE_BF16
+#define SIMSIMD_UNCOMPRESS_BF16(x) (SIMSIMD_IDENTIFY(x))
+#else
+#define SIMSIMD_UNCOMPRESS_BF16(x) (simsimd_uncompress_bf16(x))
 #endif
 #endif
 
@@ -302,6 +367,63 @@ SIMSIMD_PUBLIC simsimd_f32_t simsimd_uncompress_f16(unsigned short x) {
     return result_union.f;
 }
 
+/**
+ *  @brief  Compresses a `float` to an `f16` representation (IEEE-754 16-bit floating-point format).
+ *
+ *  @warning  This function won't handle boundary conditions well.
+ *
+ *  https://stackoverflow.com/a/60047308
+ *  https://gist.github.com/milhidaka/95863906fe828198f47991c813dbe233
+ *  https://github.com/OpenCyphal/libcanard/blob/636795f4bc395f56af8d2c61d3757b5e762bb9e5/canard.c#L811-L834
+ */
+SIMSIMD_PUBLIC unsigned short simsimd_compress_f16(simsimd_f32_t x) {
+    union float_or_unsigned_int_t {
+        float f;
+        unsigned int i;
+    } x_union;
+    x_union.f = x;
+
+    unsigned int b = x_union.i + 0x00001000;
+    unsigned int e = (b & 0x7F800000) >> 23;
+    unsigned int m = b & 0x007FFFFF;
+    unsigned short result = ((b & 0x80000000) >> 16) | (e > 112) * ((((e - 112) << 10) & 0x7C00) | (m >> 13)) |
+                            ((e < 113) & (e > 101)) * ((((0x007FF000 + m) >> (125 - e)) + 1) >> 1) |
+                            ((e > 143) * 0x7FFF);
+    return result;
+}
+
+/**
+ *  @brief  For compilers that don't natively support the `__bf16` type,
+ *          upcasts contents into a more conventional `float`.
+ *
+ *  https://stackoverflow.com/questions/55253233/convert-fp32-to-bfloat16-in-c/55254307#55254307
+ *  https://cloud.google.com/blog/products/ai-machine-learning/bfloat16-the-secret-to-high-performance-on-cloud-tpus
+ */
+SIMSIMD_PUBLIC simsimd_f32_t simsimd_uncompress_bf16(unsigned short x) {
+    union float_or_unsigned_int_t {
+        float f;
+        unsigned int i;
+    };
+    union float_or_unsigned_int_t result_union;
+    result_union.i = x << 16; // Zero extends the mantissa
+    return result_union.f;
+}
+
+/**
+ *  @brief  Compresses a `float` to a `bf16` representation.
+ */
+SIMSIMD_PUBLIC unsigned short simsimd_compress_bf16(simsimd_f32_t x) {
+    union float_or_unsigned_int_t {
+        float f;
+        unsigned int i;
+    };
+    union float_or_unsigned_int_t value;
+    value.f = x;
+    value.i >>= 16;
+    value.i &= 0xFFFF;
+    return (unsigned short)value.i;
+}
+
 #ifdef __cplusplus
 } // extern "C"
 #endif

package/simsimd/javascript/simsimd.ts

@@ -102,6 +102,27 @@ export const jensenshannon = (a: Float64Array | Float32Array, b: Float64Array |
   return compiled.jensenshannon(a, b);
 };
 
+/**
+ * Quantizes a floating-point vector into a binary vector (1 for positive values, 0 for non-positive values) and packs the result into a Uint8Array, where each element represents 8 binary values from the original vector.
+ * This function is useful for preparing data for bitwise distance or similarity computations, such as Hamming or Jaccard indices.
+ * 
+ * @param {Float32Array | Float64Array | Int8Array} vector The floating-point vector to be quantized and packed.
+ * @returns {Uint8Array} A Uint8Array where each byte represents 8 binary quantized values from the input vector.
+ */
+export const toBinary = (vector: Float32Array | Float64Array | Int8Array): Uint8Array => {
+  const byteLength = Math.ceil(vector.length / 8);
+  const packedVector = new Uint8Array(byteLength);
+
+  for (let i = 0; i < vector.length; i++) {
+    if (vector[i] > 0) {
+      const byteIndex = Math.floor(i / 8);
+      const bitPosition = 7 - (i % 8);
+      packedVector[byteIndex] |= (1 << bitPosition);
+    }
+  }
+
+  return packedVector;
+};
 export default {
   dot,
   inner,
@@ -111,10 +132,13 @@ export default {
   jaccard,
   kullbackleibler,
   jensenshannon,
+  toBinary,
 };
 
-// utility functions to help find native builds
-
+/**
+ * @brief Finds the directory where the native build of the simsimd module is located.
+ * @param {string} dir - The directory to start the search from.
+ */
 function getBuildDir(dir: string) {
   if (existsSync(path.join(dir, "build"))) return dir;
   if (existsSync(path.join(dir, "prebuilds"))) return dir;

package/simsimd/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simsimd",
-  "version": "4.2.2",
+  "version": "5.0.0",
   "description": "Fastest SIMD-Accelerated Vector Similarity Functions for x86 and Arm",
   "homepage": "https://github.com/ashvardanian/simsimd",
   "author": "Ash Vardanian",

package/simsimd/rust/benches/cosine.rs

@@ -17,8 +17,14 @@ pub fn cos_benchmark(c: &mut Criterion) {
         group.bench_with_input(BenchmarkId::new("SimSIMD", i), &i, |b, _| {
             b.iter(|| SimSIMD::cosine(&inputs.0, &inputs.1))
         });
-        group.bench_with_input(BenchmarkId::new("Rust Native", i), &i, |b, _| {
-            b.iter(|| native::cos_similarity_cpu(&inputs.0, &inputs.1))
+        group.bench_with_input(BenchmarkId::new("Rust Procedural", i), &i, |b, _| {
+            b.iter(|| native::baseline_cos_procedural(&inputs.0, &inputs.1))
+        });
+        group.bench_with_input(BenchmarkId::new("Rust Functional", i), &i, |b, _| {
+            b.iter(|| native::baseline_cos_functional(&inputs.0, &inputs.1))
+        });
+        group.bench_with_input(BenchmarkId::new("Rust Unrolled", i), &i, |b, _| {
+            b.iter(|| native::baseline_cos_unrolled(&inputs.0, &inputs.1))
         });
     }
 }

package/simsimd/rust/benches/native.rs

@@ -5,7 +5,7 @@ pub(crate) fn generate_random_vector(dim: usize) -> Vec<f32> {
     (0..dim).map(|_| rand::thread_rng().gen()).collect()
 }
 
-pub(crate) fn cos_similarity_cpu(a: &[f32], b: &[f32]) -> Option<f32> {
+pub(crate) fn baseline_cos_functional(a: &[f32], b: &[f32]) -> Option<f32> {
     if a.len() != b.len() {
         return None;
     }
@@ -21,10 +21,248 @@ pub(crate) fn cos_similarity_cpu(a: &[f32], b: &[f32]) -> Option<f32> {
     Some(1.0 - (dot_product / (norm_a.sqrt() * norm_b.sqrt())))
 }
 
-pub(crate) fn squared_euclidean_cpu(a: &[f32], b: &[f32]) -> Option<f32> {
+pub(crate) fn baseline_l2sq_functional(a: &[f32], b: &[f32]) -> Option<f32> {
     if a.len() != b.len() {
         return None;
     }
 
     Some(a.iter().zip(b).map(|(x, y)| (x - y).powi(2)).sum())
 }
+
+pub(crate) fn baseline_cos_procedural(a: &[f32], b: &[f32]) -> Option<f32> {
+    if a.len() != b.len() {
+        return None;
+    }
+
+    let mut dot_product = 0.0;
+    let mut norm_a = 0.0;
+    let mut norm_b = 0.0;
+
+    for i in 0..a.len() {
+        dot_product += a[i] * b[i];
+        norm_a += a[i] * a[i];
+        norm_b += b[i] * b[i];
+    }
+
+    Some(1.0 - (dot_product / (norm_a.sqrt() * norm_b.sqrt())))
+}
+
+pub(crate) fn baseline_l2sq_procedural(a: &[f32], b: &[f32]) -> Option<f32> {
+    if a.len() != b.len() {
+        return None;
+    }
+
+    let mut sum = 0.0;
+    for i in 0..a.len() {
+        let diff = a[i] - b[i];
+        sum += diff * diff;
+    }
+
+    Some(sum)
+}
+
+pub(crate) fn baseline_cos_unrolled(a: &[f32], b: &[f32]) -> Option<f32> {
+    if a.len() != b.len() {
+        return None;
+    }
+
+    let mut i = 0;
+    let mut remainder = a.len() % 8;
+
+    // We do this manual unrolling to allow the compiler to vectorize
+    // the loop and avoid some branching even if we're not doing it explicitly.
+    // This made a significant difference in benchmarking ~4x
+    let mut acc1 = 0.0;
+    let mut acc2 = 0.0;
+    let mut acc3 = 0.0;
+    let mut acc4 = 0.0;
+    let mut acc5 = 0.0;
+    let mut acc6 = 0.0;
+    let mut acc7 = 0.0;
+    let mut acc8 = 0.0;
+
+    let mut norm_a_acc1 = 0.0;
+    let mut norm_a_acc2 = 0.0;
+    let mut norm_a_acc3 = 0.0;
+    let mut norm_a_acc4 = 0.0;
+    let mut norm_a_acc5 = 0.0;
+    let mut norm_a_acc6 = 0.0;
+    let mut norm_a_acc7 = 0.0;
+    let mut norm_a_acc8 = 0.0;
+
+    let mut norm_b_acc1 = 0.0;
+    let mut norm_b_acc2 = 0.0;
+    let mut norm_b_acc3 = 0.0;
+    let mut norm_b_acc4 = 0.0;
+    let mut norm_b_acc5 = 0.0;
+    let mut norm_b_acc6 = 0.0;
+    let mut norm_b_acc7 = 0.0;
+    let mut norm_b_acc8 = 0.0;
+
+    while i < (a.len() - remainder) {
+        let a1 = unsafe { *a.get_unchecked(i) };
+        let a2 = unsafe { *a.get_unchecked(i + 1) };
+        let a3 = unsafe { *a.get_unchecked(i + 2) };
+        let a4 = unsafe { *a.get_unchecked(i + 3) };
+        let a5 = unsafe { *a.get_unchecked(i + 4) };
+        let a6 = unsafe { *a.get_unchecked(i + 5) };
+        let a7 = unsafe { *a.get_unchecked(i + 6) };
+        let a8 = unsafe { *a.get_unchecked(i + 7) };
+
+        let b1 = unsafe { *b.get_unchecked(i) };
+        let b2 = unsafe { *b.get_unchecked(i + 1) };
+        let b3 = unsafe { *b.get_unchecked(i + 2) };
+        let b4 = unsafe { *b.get_unchecked(i + 3) };
+        let b5 = unsafe { *b.get_unchecked(i + 4) };
+        let b6 = unsafe { *b.get_unchecked(i + 5) };
+        let b7 = unsafe { *b.get_unchecked(i + 6) };
+        let b8 = unsafe { *b.get_unchecked(i + 7) };
+
+        acc1 += (a1 * b1);
+        acc2 += (a2 * b2);
+        acc3 += (a3 * b3);
+        acc4 += (a4 * b4);
+        acc5 += (a5 * b5);
+        acc6 += (a6 * b6);
+        acc7 += (a7 * b7);
+        acc8 += (a8 * b8);
+
+        norm_a_acc1 += (a1 * a1);
+        norm_a_acc2 += (a2 * a2);
+        norm_a_acc3 += (a3 * a3);
+        norm_a_acc4 += (a4 * a4);
+        norm_a_acc5 += (a5 * a5);
+        norm_a_acc6 += (a6 * a6);
+        norm_a_acc7 += (a7 * a7);
+        norm_a_acc8 += (a8 * a8);
+
+        norm_b_acc1 += (b1 * b1);
+        norm_b_acc2 += (b2 * b2);
+        norm_b_acc3 += (b3 * b3);
+        norm_b_acc4 += (b4 * b4);
+        norm_b_acc5 += (b5 * b5);
+        norm_b_acc6 += (b6 * b6);
+        norm_b_acc7 += (b7 * b7);
+        norm_b_acc8 += (b8 * b8);
+
+        i += 8;
+    }
+
+    acc1 += acc2;
+    acc3 += acc4;
+    acc5 += acc6;
+    acc7 += acc8;
+
+    norm_a_acc1 += norm_a_acc2;
+    norm_a_acc3 += norm_a_acc4;
+    norm_a_acc5 += norm_a_acc6;
+    norm_a_acc7 += norm_a_acc8;
+
+    norm_b_acc1 += norm_b_acc2;
+    norm_b_acc3 += norm_b_acc4;
+    norm_b_acc5 += norm_b_acc6;
+    norm_b_acc7 += norm_b_acc8;
+
+    acc1 += acc3;
+    acc5 += acc7;
+
+    norm_a_acc1 += norm_a_acc3;
+    norm_a_acc5 += norm_a_acc7;
+
+    norm_b_acc1 += norm_b_acc3;
+    norm_b_acc5 += norm_b_acc7;
+
+    acc1 += acc5;
+    norm_a_acc1 += norm_a_acc5;
+    norm_b_acc1 += norm_b_acc5;
+
+    while i < a.len() {
+        let a = unsafe { *a.get_unchecked(i) };
+        let b = unsafe { *b.get_unchecked(i) };
+
+        acc1 += (a * b);
+        norm_a_acc1 += (a * a);
+        norm_b_acc1 += (b * b);
+    }
+
+    Some(1.0 - (acc1 / (norm_a_acc1 * norm_b_acc1).sqrt()))
+}
+
+pub(crate) fn baseline_l2sq_unrolled(a: &[f32], b: &[f32]) -> Option<f32> {
+    if a.len() != b.len() {
+        return None;
+    }
+    let mut i = 0;
+    let mut remainder = a.len() % 8;
+
+    // We do this manual unrolling to allow the compiler to vectorize
+    // the loop and avoid some branching even if we're not doing it explicitly.
+    // This made a significant difference in benchmarking ~4x
+    let mut acc1 = 0.0;
+    let mut acc2 = 0.0;
+    let mut acc3 = 0.0;
+    let mut acc4 = 0.0;
+    let mut acc5 = 0.0;
+    let mut acc6 = 0.0;
+    let mut acc7 = 0.0;
+    let mut acc8 = 0.0;
+
+    while i < (a.len() - remainder) {
+        let a1 = unsafe { *a.get_unchecked(i) };
+        let a2 = unsafe { *a.get_unchecked(i + 1) };
+        let a3 = unsafe { *a.get_unchecked(i + 2) };
+        let a4 = unsafe { *a.get_unchecked(i + 3) };
+        let a5 = unsafe { *a.get_unchecked(i + 4) };
+        let a6 = unsafe { *a.get_unchecked(i + 5) };
+        let a7 = unsafe { *a.get_unchecked(i + 6) };
+        let a8 = unsafe { *a.get_unchecked(i + 7) };
+
+        let b1 = unsafe { *b.get_unchecked(i) };
+        let b2 = unsafe { *b.get_unchecked(i + 1) };
+        let b3 = unsafe { *b.get_unchecked(i + 2) };
+        let b4 = unsafe { *b.get_unchecked(i + 3) };
+        let b5 = unsafe { *b.get_unchecked(i + 4) };
+        let b6 = unsafe { *b.get_unchecked(i + 5) };
+        let b7 = unsafe { *b.get_unchecked(i + 6) };
+        let b8 = unsafe { *b.get_unchecked(i + 7) };
+
+        let diff1 = a1 - b1;
+        let diff2 = a2 - b2;
+        let diff3 = a3 - b3;
+        let diff4 = a4 - b4;
+        let diff5 = a5 - b5;
+        let diff6 = a6 - b6;
+        let diff7 = a7 - b7;
+        let diff8 = a8 - b8;
+
+        acc1 += (diff1 * diff1);
+        acc2 += (diff2 * diff2);
+        acc3 += (diff3 * diff3);
+        acc4 += (diff4 * diff4);
+        acc5 += (diff5 * diff5);
+        acc6 += (diff6 * diff6);
+        acc7 += (diff7 * diff7);
+        acc8 += (diff8 * diff8);
+
+        i += 8;
+    }
+
+    acc1 += acc2;
+    acc3 += acc4;
+    acc5 += acc6;
+    acc7 += acc8;
+
+    acc1 += acc3;
+    acc5 += acc7;
+
+    acc1 += acc5;
+
+    while i < a.len() {
+        let a = unsafe { *a.get_unchecked(i) };
+        let b = unsafe { *b.get_unchecked(i) };
+        let diff = a - b;
+        acc1 += (diff * diff);
+    }
+
+    Some(acc1)
+}

package/simsimd/rust/benches/sqeuclidean.rs

@@ -17,8 +17,14 @@ pub fn l2sq_benchmark(c: &mut Criterion) {
         group.bench_with_input(BenchmarkId::new("SimSIMD", i), &i, |b, _| {
             b.iter(|| SimSIMD::sqeuclidean(&inputs.0, &inputs.1))
         });
-        group.bench_with_input(BenchmarkId::new("Rust Native", i), &i, |b, _| {
-            b.iter(|| native::squared_euclidean_cpu(&inputs.0, &inputs.1))
+        group.bench_with_input(BenchmarkId::new("Rust Procedural", i), &i, |b, _| {
+            b.iter(|| native::baseline_l2sq_procedural(&inputs.0, &inputs.1))
+        });
+        group.bench_with_input(BenchmarkId::new("Rust Functional", i), &i, |b, _| {
+            b.iter(|| native::baseline_l2sq_functional(&inputs.0, &inputs.1))
+        });
+        group.bench_with_input(BenchmarkId::new("Rust Unrolled", i), &i, |b, _| {
+            b.iter(|| native::baseline_l2sq_unrolled(&inputs.0, &inputs.1))
         });
     }
 }