usearch 2.15.1 → 2.15.3

package/simsimd/include/simsimd/simsimd.h

@@ -44,7 +44,7 @@
  *  @section    Choosing Arm Target Generations
  *
  *  Arm CPUs share design IP, but are produced by different vendors, potentially making the platform
- *  even more fragmented than x86. There are 2 imporatant families of SIMD extensions - NEON and SVE.
+ *  even more fragmented than x86. There are 2 important families of SIMD extensions - NEON and SVE.
  *
  *  - Armv8-A: +fp, +simd
  *  - Armv8.1-A: armv8-a, +crc, +lse, +rdma
@@ -68,7 +68,7 @@
  *  Here are the most important recent families of CPU cores designed by Arm:
  *
  *  - Neoverse N1: armv8.2-a, extended with Armv8.4 "dotprod" instructions.
- *    Used in AWS @b Graviton2 and Amere @b Altra.
+ *    Used in AWS @b Graviton2 and Ampere @b Altra.
  *    https://developer.arm.com/Processors/Neoverse%20N1
  *  - Neoverse V1: armv8.4-a, extended with Armv8.6 bfloat/int8 "matmul" instructions.
  *    Used in AWS @b Graviton3, which also enables `sve`, `svebf16`, and `svei8mm`.
@@ -87,8 +87,8 @@
 #define SIMSIMD_H
 
 #define SIMSIMD_VERSION_MAJOR 5
-#define SIMSIMD_VERSION_MINOR 0
-#define SIMSIMD_VERSION_PATCH 0
+#define SIMSIMD_VERSION_MINOR 6
+#define SIMSIMD_VERSION_PATCH 4
 
 /**
  *  @brief  Removes compile-time dispatching, and replaces it with runtime dispatching.
@@ -101,9 +101,11 @@
 #endif
 
 #include "binary.h"      // Hamming, Jaccard
+#include "curved.h"      // Mahalanobis, Bilinear Forms
 #include "dot.h"         // Inner (dot) product, and its conjugate
 #include "geospatial.h"  // Haversine and Vincenty
 #include "probability.h" // Kullback-Leibler, Jensen–Shannon
+#include "sparse.h"      // Intersect
 #include "spatial.h"     // L2, Cosine
 
 // On Apple Silicon, `mrs` is not allowed in user-space, so we need to use the `sysctl` API.
@@ -132,6 +134,8 @@ typedef enum {
     simsimd_metric_cosine_k = 'c',  ///< Cosine similarity alias
     simsimd_metric_angular_k = 'c', ///< Cosine similarity alias
 
+    simsimd_metric_l2_k = '2',          ///< Euclidean distance alias
+    simsimd_metric_euclidean_k = '2',   ///< Euclidean distance alias
     simsimd_metric_l2sq_k = 'e',        ///< Squared Euclidean distance
     simsimd_metric_sqeuclidean_k = 'e', ///< Squared Euclidean distance alias
 
@@ -142,6 +146,13 @@ typedef enum {
     simsimd_metric_jaccard_k = 'j',  ///< Jaccard coefficient
     simsimd_metric_tanimoto_k = 'j', ///< Tanimoto coefficient is same as Jaccard
 
+    // Sets:
+    simsimd_metric_intersect_k = 'x', ///< Equivalent to unnormalized Jaccard
+
+    // Curved Spaces:
+    simsimd_metric_bilinear_k = 'b',    ///< Bilinear form
+    simsimd_metric_mahalanobis_k = 'm', ///< Mahalanobis distance
+
     // Probability:
     simsimd_metric_kl_k = 'k',               ///< Kullback-Leibler divergence
     simsimd_metric_kullback_leibler_k = 'k', ///< Kullback-Leibler divergence alias
@@ -164,14 +175,16 @@ typedef enum {
     simsimd_cap_genoa_k = 1 << 13,    ///< x86 AVX512 capability with `bf16` support
     simsimd_cap_sapphire_k = 1 << 14, ///< x86 AVX512 capability with `f16` support
 
-    simsimd_cap_neon_k = 1 << 20,      ///< ARM NEON capability
-    simsimd_cap_neon_f16_k = 1 << 21,  ///< ARM NEON FP16 capability
-    simsimd_cap_neon_bf16_k = 1 << 22, ///< ARM NEON BF16 capability
-    simsimd_cap_neon_i8_k = 1 << 23,   ///< ARM NEON Int8 capability
-    simsimd_cap_sve_k = 1 << 24,       ///< ARM SVE capability
-    simsimd_cap_sve_f16_k = 1 << 25,   ///< ARM SVE FP16 capability
-    simsimd_cap_sve_bf16_k = 1 << 26,  ///< ARM SVE BF16 capability
-    simsimd_cap_sve_i8_k = 1 << 27,    ///< ARM SVE Int8 capability
+    simsimd_cap_neon_k = 1 << 20,      ///< ARM NEON baseline capability
+    simsimd_cap_neon_f16_k = 1 << 21,  ///< ARM NEON `f16` capability
+    simsimd_cap_neon_bf16_k = 1 << 22, ///< ARM NEON `bf16` capability
+    simsimd_cap_neon_i8_k = 1 << 23,   ///< ARM NEON `i8` capability
+    simsimd_cap_sve_k = 1 << 24,       ///< ARM SVE baseline capability
+    simsimd_cap_sve_f16_k = 1 << 25,   ///< ARM SVE `f16` capability
+    simsimd_cap_sve_bf16_k = 1 << 26,  ///< ARM SVE `bf16` capability
+    simsimd_cap_sve_i8_k = 1 << 27,    ///< ARM SVE `i8` capability
+    simsimd_cap_sve2_k = 1 << 28,      ///< ARM SVE2 capability
+    simsimd_cap_sve2p1_k = 1 << 29,    ///< ARM SVE2p1 capability
 
 } simsimd_capability_t;
 
@@ -184,9 +197,17 @@ typedef enum {
  */
 typedef enum {
     simsimd_datatype_unknown_k = 0, ///< Unknown data type
-
     simsimd_datatype_b8_k = 1 << 1, ///< Single-bit values packed into 8-bit words
-    simsimd_datatype_i8_k = 1 << 2, ///< 8-bit integer
+
+    simsimd_datatype_i8_k = 1 << 2,  ///< 8-bit signed integer
+    simsimd_datatype_i16_k = 1 << 3, ///< 16-bit signed integer
+    simsimd_datatype_i32_k = 1 << 4, ///< 32-bit signed integer
+    simsimd_datatype_i64_k = 1 << 5, ///< 64-bit signed integer
+
+    simsimd_datatype_u8_k = 1 << 6,  ///< 8-bit unsigned integer
+    simsimd_datatype_u16_k = 1 << 7, ///< 16-bit unsigned integer
+    simsimd_datatype_u32_k = 1 << 8, ///< 32-bit unsigned integer
+    simsimd_datatype_u64_k = 1 << 9, ///< 64-bit unsigned integer
 
     simsimd_datatype_f64_k = 1 << 10,  ///< Double precision floating point
     simsimd_datatype_f32_k = 1 << 11,  ///< Single precision floating point
@@ -200,21 +221,67 @@ typedef enum {
 } simsimd_datatype_t;
 
 /**
- *  @brief  Type-punned function pointer accepting two vectors and outputting their similarity/distance.
+ *  @brief  Type-punned function pointer for dense vector representations and simplest similarity measures.
+ *
+ *  @param[in] a    Pointer to the first data array.
+ *  @param[in] b    Pointer to the second data array.
+ *  @param[in] n    Number of scalar words in the input arrays.
+ *                  When dealing with sub-byte data types, the number of scalar words is the number of bytes.
+ *  @param[out] d   Output value as a double-precision float.
+ *                  In complex dot-products @b two scalars are exported for the real and imaginary parts.
+ */
+typedef void (*simsimd_metric_dense_punned_t)(void const* a, void const* b, simsimd_size_t n, simsimd_distance_t* d);
+
+/**
+ *  @brief  Type-punned function pointer for sparse vector representations and similarity measures.
+ *
+ *  @param[in] a          Pointer to the first data array, generally a sorted array of integers.
+ *  @param[in] b          Pointer to the second data array, generally a sorted array of integers.
+ *  @param[in] a_length   Number of scalar words in the first input array.
+ *  @param[in] b_length   Number of scalar words in the second input array.
+ *  @param[out] d         Output value as a double-precision float, generally without decimals.
+ */
+typedef void (*simsimd_metric_sparse_punned_t)(void const* a, void const* b,                     //
+                                               simsimd_size_t a_length, simsimd_size_t b_length, //
+                                               simsimd_distance_t* d);
+
+/**
+ *  @brief  Type-punned function pointer for curved vector spaces and similarity measures.
  *
  *  @param[in] a    Pointer to the first data array.
  *  @param[in] b    Pointer to the second data array.
+ *  @param[in] c    Pointer to the metric tensor array or some covariance matrix.
  *  @param[in] n    Number of scalar words in the input arrays.
  *  @param[out] d   Output value as a double-precision float.
- *                  In complex dot-products @b two double-precision scalars are exported
- *                  for the real and imaginary parts.
  */
-typedef void (*simsimd_metric_punned_t)(void const* a, void const* b, simsimd_size_t n, simsimd_distance_t* d);
+typedef void (*simsimd_metric_curved_punned_t)(void const* a, void const* b, void const* c, //
+                                               simsimd_size_t n, simsimd_distance_t* d);
+
+/**
+ *  @brief  Type-punned function pointer for a SimSIMD public interface.
+ *          Can be a `simsimd_metric_dense_punned_t`, `simsimd_metric_sparse_punned_t`,
+ *          or `simsimd_metric_curved_punned_t`.
+ */
+typedef simsimd_metric_dense_punned_t simsimd_metric_punned_t;
 
 #if SIMSIMD_DYNAMIC_DISPATCH
 SIMSIMD_DYNAMIC simsimd_capability_t simsimd_capabilities(void);
+SIMSIMD_DYNAMIC void simsimd_find_metric_punned( //
+    simsimd_metric_kind_t kind,                  //
+    simsimd_datatype_t datatype,                 //
+    simsimd_capability_t supported,              //
+    simsimd_capability_t allowed,                //
+    simsimd_metric_punned_t* metric_output,      //
+    simsimd_capability_t* capability_output);
 #else
 SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities(void);
+SIMSIMD_PUBLIC void simsimd_find_metric_punned( //
+    simsimd_metric_kind_t kind,                 //
+    simsimd_datatype_t datatype,                //
+    simsimd_capability_t supported,             //
+    simsimd_capability_t allowed,               //
+    simsimd_metric_punned_t* metric_output,     //
+    simsimd_capability_t* capability_output);
 #endif
 
 #if SIMSIMD_TARGET_X86
@@ -223,7 +290,7 @@ SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities(void);
  *  @brief  Function to determine the SIMD capabilities of the current 64-bit x86 machine at @b runtime.
  *  @return A bitmask of the SIMD capabilities represented as a `simsimd_capability_t` enum value.
  */
-SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities_x86(void) {
+SIMSIMD_PUBLIC simsimd_capability_t _simsimd_capabilities_x86(void) {
 
     /// The states of 4 registers populated for a specific "cpuid" assembly call
     union four_registers_t {
@@ -300,7 +367,7 @@ SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities_x86(void) {
 
 /*  Compiling the next section one may get: selected processor does not support system register name 'id_aa64zfr0_el1'.
  *  Suppressing assembler errors is very complicated, so when dealing with older ARM CPUs it's simpler to compile this
- *  function targetting newer ones.
+ *  function targeting newer ones.
  */
 #pragma GCC push_options
 #pragma GCC target("arch=armv8.5-a+sve")
@@ -310,7 +377,7 @@ SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities_x86(void) {
  *  @brief  Function to determine the SIMD capabilities of the current 64-bit Arm machine at @b runtime.
  *  @return A bitmask of the SIMD capabilities represented as a `simsimd_capability_t` enum value.
  */
-SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities_arm(void) {
+SIMSIMD_PUBLIC simsimd_capability_t _simsimd_capabilities_arm(void) {
 #if defined(SIMSIMD_DEFINED_APPLE)
     // On Apple Silicon, `mrs` is not allowed in user-space, so we need to use the `sysctl` API.
     uint32_t supports_neon = 0, supports_fp16 = 0, supports_bf16 = 0, supports_i8mm = 0;
@@ -388,8 +455,8 @@ SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities_arm(void) {
     //  - 0b0001: SVE2 is implemented
     //  - 0b0010: SVE2.1 is implemented
     // This value must match the existing indicator obtained from ID_AA64PFR0_EL1:
-    //    unsigned supports_sve = ((id_aa64zfr0_el1) & 0xF) >= 1;
-    //    unsigned supports_sve2 = ((id_aa64zfr0_el1) & 0xF) >= 2;
+    unsigned supports_sve2 = ((id_aa64zfr0_el1) & 0xF) >= 1;
+    unsigned supports_sve2p1 = ((id_aa64zfr0_el1) & 0xF) >= 2;
     unsigned supports_neon = 1; // NEON is always supported
 
     return (simsimd_capability_t)(                                                                    //
@@ -401,6 +468,8 @@ SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities_arm(void) {
         (simsimd_cap_sve_f16_k * (supports_sve && supports_fp16)) |                                   //
         (simsimd_cap_sve_bf16_k * (supports_sve && supports_sve_bf16)) |                              //
         (simsimd_cap_sve_i8_k * (supports_sve && supports_sve_i8mm)) |                                //
+        (simsimd_cap_sve2_k * (supports_sve2)) |                                                      //
+        (simsimd_cap_sve2p1_k * (supports_sve2p1)) |                                                  //
         (simsimd_cap_serial_k));
 #else // SIMSIMD_DEFINED_LINUX
     return simsimd_cap_serial_k;
@@ -409,18 +478,19 @@ SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities_arm(void) {
 
 #pragma clang attribute pop
 #pragma GCC pop_options
+
 #endif
 
 /**
  *  @brief  Function to determine the SIMD capabilities of the current 64-bit x86 machine at @b runtime.
  *  @return A bitmask of the SIMD capabilities represented as a `simsimd_capability_t` enum value.
  */
-SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities_implementation(void) {
+SIMSIMD_PUBLIC simsimd_capability_t _simsimd_capabilities_implementation(void) {
 #if SIMSIMD_TARGET_X86
-    return simsimd_capabilities_x86();
+    return _simsimd_capabilities_x86();
 #endif // SIMSIMD_TARGET_X86
 #if SIMSIMD_TARGET_ARM
-    return simsimd_capabilities_arm();
+    return _simsimd_capabilities_arm();
 #endif // SIMSIMD_TARGET_ARM
     return simsimd_cap_serial_k;
 }
@@ -430,6 +500,11 @@ SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities_implementation(void) {
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wcast-function-type"
 
+#ifdef __cplusplus //! option ‘-Wvolatile’ is valid for C++/ObjC++ but not for C
+#pragma GCC diagnostic ignored "-Wvolatile"
+#pragma clang diagnostic ignored "-Wvolatile"
+#endif
+
 /**
  *  @brief  Determines the best suited metric implementation based on the given datatype,
  *          supported and allowed by hardware capabilities.
@@ -441,17 +516,26 @@ SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities_implementation(void) {
  *  @param metric_output Output variable for the selected similarity function.
  *  @param capability_output Output variable for the utilized hardware capabilities.
  */
-SIMSIMD_PUBLIC void simsimd_find_metric_punned( //
-    simsimd_metric_kind_t kind,                 //
-    simsimd_datatype_t datatype,                //
-    simsimd_capability_t supported,             //
-    simsimd_capability_t allowed,               //
-    simsimd_metric_punned_t* metric_output,     //
+SIMSIMD_INTERNAL void _simsimd_find_metric_punned_implementation( //
+    simsimd_metric_kind_t kind,                                   //
+    simsimd_datatype_t datatype,                                  //
+    simsimd_capability_t supported,                               //
+    simsimd_capability_t allowed,                                 //
+    simsimd_metric_punned_t* metric_output,                       //
     simsimd_capability_t* capability_output) {
 
-    simsimd_metric_punned_t* m = metric_output;
-    simsimd_capability_t* c = capability_output;
-    simsimd_capability_t viable = (simsimd_capability_t)(supported & allowed);
+    // Modern compilers abso-freaking-lutely love optimizing-out my logic!
+    // Just marking the variables as `volatile` is not enough, so we have
+    // to add inline assembly to further discourage them!
+#if defined(_MSC_VER)
+    _ReadWriteBarrier();
+#else
+    __asm__ __volatile__("" ::: "memory");
+#endif
+
+    volatile simsimd_metric_punned_t* m = metric_output;
+    volatile simsimd_capability_t* c = capability_output;
+    volatile simsimd_capability_t viable = (simsimd_capability_t)(supported & allowed);
     *m = (simsimd_metric_punned_t)0;
     *c = (simsimd_capability_t)0;
 
@@ -460,15 +544,31 @@ SIMSIMD_PUBLIC void simsimd_find_metric_punned( //
 
     case simsimd_datatype_unknown_k: break;
 
-    // Double-precision floating-point vectors
-    case simsimd_datatype_f64_k:
+    // These data-types are not supported yet
+    case simsimd_datatype_i16_k: break;
+    case simsimd_datatype_i32_k: break;
+    case simsimd_datatype_i64_k: break;
+    case simsimd_datatype_u8_k: break;
+    case simsimd_datatype_u64_k: break;
 
+    // Double-precision floating-point vectors
+    case simsimd_datatype_f64_k: {
 #if SIMSIMD_TARGET_SVE
-        if (viable & simsimd_cap_skylake_k)
+        if (viable & simsimd_cap_sve_k)
             switch (kind) {
             case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f64_sve, *c = simsimd_cap_sve_k; return;
             case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f64_sve, *c = simsimd_cap_sve_k; return;
             case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f64_sve, *c = simsimd_cap_sve_k; return;
+            case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f64_sve, *c = simsimd_cap_sve_k; return;
+            default: break;
+            }
+#endif
+#if SIMSIMD_TARGET_NEON
+        if (viable & simsimd_cap_neon_k)
+            switch (kind) {
+            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f64_neon, *c = simsimd_cap_neon_k; return;
+            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f64_neon, *c = simsimd_cap_neon_k; return;
+            case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f64_neon, *c = simsimd_cap_neon_k; return;
             default: break;
             }
 #endif
@@ -478,6 +578,7 @@ SIMSIMD_PUBLIC void simsimd_find_metric_punned( //
             case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f64_skylake, *c = simsimd_cap_skylake_k; return;
             case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f64_skylake, *c = simsimd_cap_skylake_k; return;
             case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f64_skylake, *c = simsimd_cap_skylake_k; return;
+            case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f64_skylake, *c = simsimd_cap_skylake_k; return;
             default: break;
             }
 #endif
@@ -486,15 +587,21 @@ SIMSIMD_PUBLIC void simsimd_find_metric_punned( //
             case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f64_serial, *c = simsimd_cap_serial_k; return;
             case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f64_serial, *c = simsimd_cap_serial_k; return;
             case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f64_serial, *c = simsimd_cap_serial_k; return;
+            case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f64_serial, *c = simsimd_cap_serial_k; return;
             case simsimd_metric_js_k: *m = (m_t)&simsimd_js_f64_serial, *c = simsimd_cap_serial_k; return;
             case simsimd_metric_kl_k: *m = (m_t)&simsimd_kl_f64_serial, *c = simsimd_cap_serial_k; return;
+            case simsimd_metric_bilinear_k: *m = (m_t)&simsimd_bilinear_f64_serial, *c = simsimd_cap_serial_k; return;
+            case simsimd_metric_mahalanobis_k:
+                *m = (m_t)&simsimd_mahalanobis_f64_serial, *c = simsimd_cap_serial_k;
+                return;
             default: break;
             }
 
         break;
+    }
 
     // Single-precision floating-point vectors
-    case simsimd_datatype_f32_k:
+    case simsimd_datatype_f32_k: {
 
 #if SIMSIMD_TARGET_SVE
         if (viable & simsimd_cap_sve_k)
@@ -502,6 +609,7 @@ SIMSIMD_PUBLIC void simsimd_find_metric_punned( //
             case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f32_sve, *c = simsimd_cap_sve_k; return;
             case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f32_sve, *c = simsimd_cap_sve_k; return;
             case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f32_sve, *c = simsimd_cap_sve_k; return;
+            case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f32_sve, *c = simsimd_cap_sve_k; return;
             default: break;
             }
 #endif
@@ -511,6 +619,7 @@ SIMSIMD_PUBLIC void simsimd_find_metric_punned( //
             case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f32_neon, *c = simsimd_cap_neon_k; return;
             case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f32_neon, *c = simsimd_cap_neon_k; return;
             case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f32_neon, *c = simsimd_cap_neon_k; return;
+            case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f32_neon, *c = simsimd_cap_neon_k; return;
             case simsimd_metric_js_k: *m = (m_t)&simsimd_js_f32_neon, *c = simsimd_cap_neon_k; return;
             case simsimd_metric_kl_k: *m = (m_t)&simsimd_kl_f32_neon, *c = simsimd_cap_neon_k; return;
             default: break;
@@ -522,8 +631,13 @@ SIMSIMD_PUBLIC void simsimd_find_metric_punned( //
             case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f32_skylake, *c = simsimd_cap_skylake_k; return;
             case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f32_skylake, *c = simsimd_cap_skylake_k; return;
             case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f32_skylake, *c = simsimd_cap_skylake_k; return;
+            case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f32_skylake, *c = simsimd_cap_skylake_k; return;
             case simsimd_metric_js_k: *m = (m_t)&simsimd_js_f32_skylake, *c = simsimd_cap_skylake_k; return;
             case simsimd_metric_kl_k: *m = (m_t)&simsimd_kl_f32_skylake, *c = simsimd_cap_skylake_k; return;
+            case simsimd_metric_bilinear_k: *m = (m_t)&simsimd_bilinear_f32_skylake, *c = simsimd_cap_skylake_k; return;
+            case simsimd_metric_mahalanobis_k:
+                *m = (m_t)&simsimd_mahalanobis_f32_skylake, *c = simsimd_cap_skylake_k;
+                return;
             default: break;
             }
 #endif
@@ -533,6 +647,7 @@ SIMSIMD_PUBLIC void simsimd_find_metric_punned( //
             case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f32_haswell, *c = simsimd_cap_haswell_k; return;
             case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f32_haswell, *c = simsimd_cap_haswell_k; return;
             case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f32_haswell, *c = simsimd_cap_haswell_k; return;
+            case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f32_haswell, *c = simsimd_cap_haswell_k; return;
             default: break;
             }
 #endif
@@ -542,33 +657,44 @@ SIMSIMD_PUBLIC void simsimd_find_metric_punned( //
             case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f32_serial, *c = simsimd_cap_serial_k; return;
             case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f32_serial, *c = simsimd_cap_serial_k; return;
             case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f32_serial, *c = simsimd_cap_serial_k; return;
+            case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f32_serial, *c = simsimd_cap_serial_k; return;
             case simsimd_metric_js_k: *m = (m_t)&simsimd_js_f32_serial, *c = simsimd_cap_serial_k; return;
             case simsimd_metric_kl_k: *m = (m_t)&simsimd_kl_f32_serial, *c = simsimd_cap_serial_k; return;
+            case simsimd_metric_bilinear_k: *m = (m_t)&simsimd_bilinear_f32_serial, *c = simsimd_cap_serial_k; return;
+            case simsimd_metric_mahalanobis_k:
+                *m = (m_t)&simsimd_mahalanobis_f32_serial, *c = simsimd_cap_serial_k;
+                return;
             default: break;
             }
 
         break;
-
+    }
     // Half-precision floating-point vectors
-    case simsimd_datatype_f16_k:
+    case simsimd_datatype_f16_k: {
 
-#if SIMSIMD_TARGET_SVE
+#if SIMSIMD_TARGET_SVE_F16
         if (viable & simsimd_cap_sve_k)
             switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16_sve, *c = simsimd_cap_sve_k; return;
-            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f16_sve, *c = simsimd_cap_sve_k; return;
-            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f16_sve, *c = simsimd_cap_sve_k; return;
+            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16_sve, *c = simsimd_cap_sve_f16_k; return;
+            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f16_sve, *c = simsimd_cap_sve_f16_k; return;
+            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f16_sve, *c = simsimd_cap_sve_f16_k; return;
+            case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f16_sve, *c = simsimd_cap_sve_f16_k; return;
             default: break;
             }
 #endif
-#if SIMSIMD_TARGET_NEON
+#if SIMSIMD_TARGET_NEON_F16
         if (viable & simsimd_cap_neon_f16_k)
             switch (kind) {
             case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16_neon, *c = simsimd_cap_neon_f16_k; return;
             case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f16_neon, *c = simsimd_cap_neon_f16_k; return;
             case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f16_neon, *c = simsimd_cap_neon_f16_k; return;
+            case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f16_neon, *c = simsimd_cap_neon_f16_k; return;
             case simsimd_metric_js_k: *m = (m_t)&simsimd_js_f16_neon, *c = simsimd_cap_neon_f16_k; return;
             case simsimd_metric_kl_k: *m = (m_t)&simsimd_kl_f16_neon, *c = simsimd_cap_neon_f16_k; return;
+            case simsimd_metric_bilinear_k: *m = (m_t)&simsimd_bilinear_f16_neon, *c = simsimd_cap_neon_f16_k; return;
+            case simsimd_metric_mahalanobis_k:
+                *m = (m_t)&simsimd_mahalanobis_f16_neon, *c = simsimd_cap_neon_f16_k;
+                return;
             default: break;
             }
 #endif
@@ -578,8 +704,15 @@ SIMSIMD_PUBLIC void simsimd_find_metric_punned( //
             case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16_sapphire, *c = simsimd_cap_sapphire_k; return;
             case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f16_sapphire, *c = simsimd_cap_sapphire_k; return;
             case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f16_sapphire, *c = simsimd_cap_sapphire_k; return;
+            case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f16_sapphire, *c = simsimd_cap_sapphire_k; return;
             case simsimd_metric_js_k: *m = (m_t)&simsimd_js_f16_sapphire, *c = simsimd_cap_sapphire_k; return;
             case simsimd_metric_kl_k: *m = (m_t)&simsimd_kl_f16_sapphire, *c = simsimd_cap_sapphire_k; return;
+            case simsimd_metric_bilinear_k:
+                *m = (m_t)&simsimd_bilinear_f16_sapphire, *c = simsimd_cap_sapphire_k;
+                return;
+            case simsimd_metric_mahalanobis_k:
+                *m = (m_t)&simsimd_mahalanobis_f16_sapphire, *c = simsimd_cap_sapphire_k;
+                return;
             default: break;
             }
 #endif
@@ -589,8 +722,13 @@ SIMSIMD_PUBLIC void simsimd_find_metric_punned( //
             case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16_haswell, *c = simsimd_cap_haswell_k; return;
             case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f16_haswell, *c = simsimd_cap_haswell_k; return;
             case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f16_haswell, *c = simsimd_cap_haswell_k; return;
+            case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f16_haswell, *c = simsimd_cap_haswell_k; return;
             case simsimd_metric_js_k: *m = (m_t)&simsimd_js_f16_haswell, *c = simsimd_cap_haswell_k; return;
             case simsimd_metric_kl_k: *m = (m_t)&simsimd_kl_f16_haswell, *c = simsimd_cap_haswell_k; return;
+            case simsimd_metric_bilinear_k: *m = (m_t)&simsimd_bilinear_f16_haswell, *c = simsimd_cap_haswell_k; return;
+            case simsimd_metric_mahalanobis_k:
+                *m = (m_t)&simsimd_mahalanobis_f16_haswell, *c = simsimd_cap_haswell_k;
+                return;
             default: break;
             }
 #endif
@@ -600,30 +738,36 @@ SIMSIMD_PUBLIC void simsimd_find_metric_punned( //
             case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16_serial, *c = simsimd_cap_serial_k; return;
             case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_f16_serial, *c = simsimd_cap_serial_k; return;
             case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_f16_serial, *c = simsimd_cap_serial_k; return;
+            case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_f16_serial, *c = simsimd_cap_serial_k; return;
             case simsimd_metric_js_k: *m = (m_t)&simsimd_js_f16_serial, *c = simsimd_cap_serial_k; return;
             case simsimd_metric_kl_k: *m = (m_t)&simsimd_kl_f16_serial, *c = simsimd_cap_serial_k; return;
+            case simsimd_metric_bilinear_k: *m = (m_t)&simsimd_bilinear_f16_serial, *c = simsimd_cap_serial_k; return;
+            case simsimd_metric_mahalanobis_k:
+                *m = (m_t)&simsimd_mahalanobis_f16_serial, *c = simsimd_cap_serial_k;
+                return;
             default: break;
             }
 
         break;
-
+    }
     // Brain floating-point vectors
-    case simsimd_datatype_bf16_k:
+    case simsimd_datatype_bf16_k: {
+#if SIMSIMD_TARGET_SVE_BF16
+        if (viable & simsimd_cap_sve_bf16_k)
+            switch (kind) {
+            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_bf16_sve, *c = simsimd_cap_sve_bf16_k; return;
+            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_bf16_sve, *c = simsimd_cap_sve_bf16_k; return;
+            case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_bf16_sve, *c = simsimd_cap_sve_bf16_k; return;
+            default: break;
+            }
+#endif
 #if SIMSIMD_TARGET_NEON_BF16
         if (viable & simsimd_cap_neon_bf16_k)
             switch (kind) {
             case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_bf16_neon, *c = simsimd_cap_neon_bf16_k; return;
             case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_bf16_neon, *c = simsimd_cap_neon_bf16_k; return;
             case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_bf16_neon, *c = simsimd_cap_neon_bf16_k; return;
-            default: break;
-            }
-#endif
-#if SIMSIMD_TARGET_HASWELL
-        if (viable & simsimd_cap_haswell_k)
-            switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_bf16_haswell, *c = simsimd_cap_haswell_k; return;
-            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_bf16_haswell, *c = simsimd_cap_haswell_k; return;
-            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_bf16_haswell, *c = simsimd_cap_haswell_k; return;
+            case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_bf16_neon, *c = simsimd_cap_neon_bf16_k; return;
             default: break;
             }
 #endif
@@ -633,6 +777,27 @@ SIMSIMD_PUBLIC void simsimd_find_metric_punned( //
             case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_bf16_genoa, *c = simsimd_cap_genoa_k; return;
             case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_bf16_genoa, *c = simsimd_cap_genoa_k; return;
             case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_bf16_genoa, *c = simsimd_cap_genoa_k; return;
+            case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_bf16_genoa, *c = simsimd_cap_genoa_k; return;
+            case simsimd_metric_bilinear_k: *m = (m_t)&simsimd_bilinear_bf16_genoa, *c = simsimd_cap_genoa_k; return;
+            case simsimd_metric_mahalanobis_k:
+                *m = (m_t)&simsimd_mahalanobis_bf16_genoa, *c = simsimd_cap_genoa_k;
+                return;
+            default: break;
+            }
+#endif
+#if SIMSIMD_TARGET_HASWELL
+        if (viable & simsimd_cap_haswell_k)
+            switch (kind) {
+            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_bf16_haswell, *c = simsimd_cap_haswell_k; return;
+            case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_bf16_haswell, *c = simsimd_cap_haswell_k; return;
+            case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_bf16_haswell, *c = simsimd_cap_haswell_k; return;
+            case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_bf16_haswell, *c = simsimd_cap_haswell_k; return;
+            case simsimd_metric_bilinear_k:
+                *m = (m_t)&simsimd_bilinear_bf16_haswell, *c = simsimd_cap_haswell_k;
+                return;
+            case simsimd_metric_mahalanobis_k:
+                *m = (m_t)&simsimd_mahalanobis_bf16_haswell, *c = simsimd_cap_haswell_k;
+                return;
             default: break;
             }
 #endif
@@ -641,21 +806,27 @@ SIMSIMD_PUBLIC void simsimd_find_metric_punned( //
             case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_bf16_serial, *c = simsimd_cap_serial_k; return;
             case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_bf16_serial, *c = simsimd_cap_serial_k; return;
             case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_bf16_serial, *c = simsimd_cap_serial_k; return;
+            case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_bf16_serial, *c = simsimd_cap_serial_k; return;
             case simsimd_metric_js_k: *m = (m_t)&simsimd_js_bf16_serial, *c = simsimd_cap_serial_k; return;
             case simsimd_metric_kl_k: *m = (m_t)&simsimd_kl_bf16_serial, *c = simsimd_cap_serial_k; return;
+            case simsimd_metric_bilinear_k: *m = (m_t)&simsimd_bilinear_bf16_serial, *c = simsimd_cap_serial_k; return;
+            case simsimd_metric_mahalanobis_k:
+                *m = (m_t)&simsimd_mahalanobis_bf16_serial, *c = simsimd_cap_serial_k;
+                return;
             default: break;
             }
 
         break;
-
+    }
     // Single-byte integer vectors
-    case simsimd_datatype_i8_k:
-#if SIMSIMD_TARGET_NEON
+    case simsimd_datatype_i8_k: {
+#if SIMSIMD_TARGET_NEON_I8
         if (viable & simsimd_cap_neon_i8_k)
             switch (kind) {
             case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_i8_neon, *c = simsimd_cap_neon_i8_k; return;
             case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_i8_neon, *c = simsimd_cap_neon_i8_k; return;
             case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_i8_neon, *c = simsimd_cap_neon_i8_k; return;
+            case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_i8_neon, *c = simsimd_cap_neon_i8_k; return;
             default: break;
             }
 #endif
@@ -665,6 +836,7 @@ SIMSIMD_PUBLIC void simsimd_find_metric_punned( //
             case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_i8_ice, *c = simsimd_cap_ice_k; return;
             case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_i8_ice, *c = simsimd_cap_ice_k; return;
             case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_i8_ice, *c = simsimd_cap_ice_k; return;
+            case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_i8_ice, *c = simsimd_cap_ice_k; return;
             default: break;
             }
 #endif
@@ -674,6 +846,7 @@ SIMSIMD_PUBLIC void simsimd_find_metric_punned( //
             case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_i8_haswell, *c = simsimd_cap_haswell_k; return;
             case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_i8_haswell, *c = simsimd_cap_haswell_k; return;
             case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_i8_haswell, *c = simsimd_cap_haswell_k; return;
+            case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_i8_haswell, *c = simsimd_cap_haswell_k; return;
             default: break;
             }
 #endif
@@ -683,13 +856,14 @@ SIMSIMD_PUBLIC void simsimd_find_metric_punned( //
             case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_i8_serial, *c = simsimd_cap_serial_k; return;
             case simsimd_metric_cos_k: *m = (m_t)&simsimd_cos_i8_serial, *c = simsimd_cap_serial_k; return;
             case simsimd_metric_l2sq_k: *m = (m_t)&simsimd_l2sq_i8_serial, *c = simsimd_cap_serial_k; return;
+            case simsimd_metric_l2_k: *m = (m_t)&simsimd_l2_i8_serial, *c = simsimd_cap_serial_k; return;
             default: break;
             }
 
         break;
-
+    }
     // Binary vectors
-    case simsimd_datatype_b8_k:
+    case simsimd_datatype_b8_k: {
 
 #if SIMSIMD_TARGET_SVE
         if (viable & simsimd_cap_sve_k)
@@ -732,8 +906,9 @@ SIMSIMD_PUBLIC void simsimd_find_metric_punned( //
             }
 
         break;
-
-    case simsimd_datatype_f32c_k:
+    }
+    // Complex floating-point vectors
+    case simsimd_datatype_f32c_k: {
 
 #if SIMSIMD_TARGET_SVE
         if (viable & simsimd_cap_sve_k)
@@ -776,8 +951,9 @@ SIMSIMD_PUBLIC void simsimd_find_metric_punned( //
             }
 
         break;
-
-    case simsimd_datatype_f64c_k:
+    }
+    // Complex double-precision floating-point vectors
+    case simsimd_datatype_f64c_k: {
 
 #if SIMSIMD_TARGET_SVE
         if (viable & simsimd_cap_sve_k)
@@ -804,18 +980,19 @@ SIMSIMD_PUBLIC void simsimd_find_metric_punned( //
             }
 
         break;
+    }
+    // Complex half-precision floating-point vectors
+    case simsimd_datatype_f16c_k: {
 
-    case simsimd_datatype_f16c_k:
-
-#if SIMSIMD_TARGET_SVE
+#if SIMSIMD_TARGET_SVE_F16
         if (viable & simsimd_cap_sve_k)
             switch (kind) {
-            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16c_sve, *c = simsimd_cap_sve_k; return;
-            case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f16c_sve, *c = simsimd_cap_sve_k; return;
+            case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16c_sve, *c = simsimd_cap_sve_f16_k; return;
+            case simsimd_metric_vdot_k: *m = (m_t)&simsimd_vdot_f16c_sve, *c = simsimd_cap_sve_f16_k; return;
             default: break;
             }
 #endif
-#if SIMSIMD_TARGET_NEON
+#if SIMSIMD_TARGET_NEON_F16
         if (viable & simsimd_cap_neon_f16_k)
             switch (kind) {
             case simsimd_metric_dot_k: *m = (m_t)&simsimd_dot_f16c_neon, *c = simsimd_cap_neon_f16_k; return;
@@ -848,7 +1025,9 @@ SIMSIMD_PUBLIC void simsimd_find_metric_punned( //
             }
 
         break;
-    case simsimd_datatype_bf16c_k:
+    }
+    // Complex Brain floating-point vectors
+    case simsimd_datatype_bf16c_k: {
 
 #if SIMSIMD_TARGET_NEON_BF16
         if (viable & simsimd_cap_neon_bf16_k)
@@ -876,6 +1055,81 @@ SIMSIMD_PUBLIC void simsimd_find_metric_punned( //
 
         break;
     }
+
+    // Unsigned 16-bit integer vectors
+    case simsimd_datatype_u16_k: {
+
+#if SIMSIMD_TARGET_SVE2
+        if (viable & simsimd_cap_sve_k)
+            switch (kind) {
+            case simsimd_metric_intersect_k: *m = (m_t)&simsimd_intersect_u16_sve2, *c = simsimd_cap_sve_k; return;
+            default: break;
+            }
+#endif
+#if SIMSIMD_TARGET_NEON
+        if (viable & simsimd_cap_neon_k)
+            switch (kind) {
+            case simsimd_metric_intersect_k: *m = (m_t)&simsimd_intersect_u16_neon, *c = simsimd_cap_neon_k; return;
+            default: break;
+            }
+#endif
+#if SIMSIMD_TARGET_ICE
+        if (viable & simsimd_cap_ice_k)
+            switch (kind) {
+            case simsimd_metric_intersect_k: *m = (m_t)&simsimd_intersect_u16_ice, *c = simsimd_cap_skylake_k; return;
+            default: break;
+            }
+#endif
+        if (viable & simsimd_cap_serial_k)
+            switch (kind) {
+            case simsimd_metric_intersect_k: *m = (m_t)&simsimd_intersect_u16_serial, *c = simsimd_cap_serial_k; return;
+            default: break;
+            }
+
+        break;
+    }
+    // Unsigned 32-bit integer vectors
+    case simsimd_datatype_u32_k: {
+
+#if SIMSIMD_TARGET_SVE2
+        if (viable & simsimd_cap_sve_k)
+            switch (kind) {
+            case simsimd_metric_intersect_k: *m = (m_t)&simsimd_intersect_u32_sve2, *c = simsimd_cap_sve_k; return;
+            default: break;
+            }
+#endif
+#if SIMSIMD_TARGET_NEON
+        if (viable & simsimd_cap_neon_k)
+            switch (kind) {
+            case simsimd_metric_intersect_k: *m = (m_t)&simsimd_intersect_u32_neon, *c = simsimd_cap_neon_k; return;
+            default: break;
+            }
+#endif
+#if SIMSIMD_TARGET_ICE
+        if (viable & simsimd_cap_ice_k)
+            switch (kind) {
+            case simsimd_metric_intersect_k: *m = (m_t)&simsimd_intersect_u32_ice, *c = simsimd_cap_skylake_k; return;
+            default: break;
+            }
+#endif
+        if (viable & simsimd_cap_serial_k)
+            switch (kind) {
+            case simsimd_metric_intersect_k: *m = (m_t)&simsimd_intersect_u32_serial, *c = simsimd_cap_serial_k; return;
+            default: break;
+            }
+
+        break;
+    }
+    }
+
+    // Modern compilers abso-freaking-lutely love optimizing-out my logic!
+    // Just marking the variables as `volatile` is not enough, so we have
+    // to add inline assembly to further discourage them!
+#if defined(_MSC_VER)
+    _ReadWriteBarrier();
+#else
+    __asm__ __volatile__("" ::: "memory");
+#endif
 }
 
 #pragma GCC diagnostic pop
@@ -922,12 +1176,13 @@ SIMSIMD_DYNAMIC int simsimd_uses_sve(void);
 SIMSIMD_DYNAMIC int simsimd_uses_sve_f16(void);
 SIMSIMD_DYNAMIC int simsimd_uses_sve_bf16(void);
 SIMSIMD_DYNAMIC int simsimd_uses_sve_i8(void);
+SIMSIMD_DYNAMIC int simsimd_uses_sve2(void);
 SIMSIMD_DYNAMIC int simsimd_uses_haswell(void);
 SIMSIMD_DYNAMIC int simsimd_uses_skylake(void);
 SIMSIMD_DYNAMIC int simsimd_uses_ice(void);
 SIMSIMD_DYNAMIC int simsimd_uses_sapphire(void);
 SIMSIMD_DYNAMIC int simsimd_uses_genoa(void);
-SIMSIMD_DYNAMIC simsimd_capability_t simsimd_capabilities(void);
+SIMSIMD_DYNAMIC int simsimd_uses_dynamic_dispatch(void);
 
 /*  Inner products
  *  - Dot product: the sum of the products of the corresponding elements of two vectors.
@@ -1024,9 +1279,9 @@ SIMSIMD_DYNAMIC void simsimd_jaccard_b8(simsimd_b8_t const* a, simsimd_b8_t cons
  *  - Jensen-Shannon divergence: a measure of similarity between two probability distributions.
  *  - Kullback-Leibler divergence: a measure of how one probability distribution diverges from a second.
  *
- *  @param a The first descrete probability distribution.
- *  @param b The second descrete probability distribution.
- *  @param n The number of elements in the descrete distributions.
+ *  @param a The first discrete probability distribution.
+ *  @param b The second discrete probability distribution.
+ *  @param n The number of elements in the discrete distributions.
  *  @param d The output divergence value.
  *
  *  @note The distributions are assumed to be normalized.
@@ -1066,20 +1321,31 @@ SIMSIMD_DYNAMIC void simsimd_js_f64(simsimd_f64_t const* a, simsimd_f64_t const*
  */
 
 // clang-format off
+SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities(void) { return _simsimd_capabilities_implementation(); }
+SIMSIMD_PUBLIC int simsimd_uses_dynamic_dispatch(void) { return 0; }
 SIMSIMD_PUBLIC int simsimd_uses_neon(void) { return SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_NEON; }
-SIMSIMD_PUBLIC int simsimd_uses_neon_f16(void) { return SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_NEON && SIMSIMD_NATIVE_F16; }
-SIMSIMD_PUBLIC int simsimd_uses_neon_bf16(void) { return SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_NEON && SIMSIMD_NATIVE_BF16; }
-SIMSIMD_PUBLIC int simsimd_uses_neon_i8(void) { return SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_NEON; }
+SIMSIMD_PUBLIC int simsimd_uses_neon_f16(void) { return SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_NEON_F16 ; }
+SIMSIMD_PUBLIC int simsimd_uses_neon_bf16(void) { return SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_NEON_BF16; }
+SIMSIMD_PUBLIC int simsimd_uses_neon_i8(void) { return SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_NEON_I8; }
 SIMSIMD_PUBLIC int simsimd_uses_sve(void) { return SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_SVE; }
-SIMSIMD_PUBLIC int simsimd_uses_sve_f16(void) { return SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_SVE && SIMSIMD_NATIVE_F16; }
-SIMSIMD_PUBLIC int simsimd_uses_sve_bf16(void) { return SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_SVE && SIMSIMD_NATIVE_BF16; }
-SIMSIMD_PUBLIC int simsimd_uses_sve_i8(void) { return SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_SVE; }
+SIMSIMD_PUBLIC int simsimd_uses_sve_f16(void) { return SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_SVE_F16; }
+SIMSIMD_PUBLIC int simsimd_uses_sve_bf16(void) { return SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_SVE_BF16; }
+SIMSIMD_PUBLIC int simsimd_uses_sve_i8(void) { return SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_SVE_I8; }
+SIMSIMD_PUBLIC int simsimd_uses_sve2(void) { return SIMSIMD_TARGET_ARM && SIMSIMD_TARGET_SVE2; }
 SIMSIMD_PUBLIC int simsimd_uses_haswell(void) { return SIMSIMD_TARGET_X86 && SIMSIMD_TARGET_HASWELL; }
 SIMSIMD_PUBLIC int simsimd_uses_skylake(void) { return SIMSIMD_TARGET_X86 && SIMSIMD_TARGET_SKYLAKE; }
 SIMSIMD_PUBLIC int simsimd_uses_ice(void) { return SIMSIMD_TARGET_X86 && SIMSIMD_TARGET_ICE; }
 SIMSIMD_PUBLIC int simsimd_uses_sapphire(void) { return SIMSIMD_TARGET_X86 && SIMSIMD_TARGET_SAPPHIRE; }
 SIMSIMD_PUBLIC int simsimd_uses_genoa(void) { return SIMSIMD_TARGET_X86 && SIMSIMD_TARGET_GENOA; }
-SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities(void) { return simsimd_capabilities_implementation(); }
+SIMSIMD_PUBLIC void simsimd_find_metric_punned( //
+    simsimd_metric_kind_t kind,                 //
+    simsimd_datatype_t datatype,                //
+    simsimd_capability_t supported,             //
+    simsimd_capability_t allowed,               //
+    simsimd_metric_punned_t* metric_output,     //
+    simsimd_capability_t* capability_output) {
+    _simsimd_find_metric_punned_implementation(kind, datatype, supported, allowed, metric_output, capability_output);
+}
 // clang-format on
 
 /*  Inner products
@@ -1098,9 +1364,9 @@ SIMSIMD_PUBLIC simsimd_capability_t simsimd_capabilities(void) { return simsimd_
  */
 SIMSIMD_PUBLIC void simsimd_dot_f16(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n,
                                     simsimd_distance_t* d) {
-#if SIMSIMD_TARGET_SVE
+#if SIMSIMD_TARGET_SVE_F16
     simsimd_dot_f16_sve(a, b, n, d);
-#elif SIMSIMD_TARGET_NEON
+#elif SIMSIMD_TARGET_NEON_F16
     simsimd_dot_f16_neon(a, b, n, d);
 #elif SIMSIMD_TARGET_SAPPHIRE
     simsimd_dot_f16_sapphire(a, b, n, d);
@@ -1117,6 +1383,8 @@ SIMSIMD_PUBLIC void simsimd_dot_bf16(simsimd_bf16_t const* a, simsimd_bf16_t con
     simsimd_dot_bf16_genoa(a, b, n, d);
 #elif SIMSIMD_TARGET_HASWELL
     simsimd_dot_bf16_haswell(a, b, n, d);
+#elif SIMSIMD_TARGET_NEON_BF16
+    simsimd_dot_bf16_neon(a, b, n, d);
 #else
     simsimd_dot_bf16_serial(a, b, n, d);
 #endif
@@ -1148,9 +1416,9 @@ SIMSIMD_PUBLIC void simsimd_dot_f64(simsimd_f64_t const* a, simsimd_f64_t const*
 }
 SIMSIMD_PUBLIC void simsimd_dot_f16c(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n,
                                      simsimd_distance_t* d) {
-#if SIMSIMD_TARGET_SVE
+#if SIMSIMD_TARGET_SVE_F16
     simsimd_dot_f16c_sve(a, b, n, d);
-#elif SIMSIMD_TARGET_NEON
+#elif SIMSIMD_TARGET_NEON_F16
     simsimd_dot_f16c_neon(a, b, n, d);
 #elif SIMSIMD_TARGET_SAPPHIRE
     simsimd_dot_f16c_sapphire(a, b, n, d);
@@ -1164,6 +1432,8 @@ SIMSIMD_PUBLIC void simsimd_dot_bf16c(simsimd_bf16_t const* a, simsimd_bf16_t co
                                       simsimd_distance_t* d) {
 #if SIMSIMD_TARGET_GENOA
     simsimd_dot_bf16c_genoa(a, b, n, d);
+#elif SIMSIMD_TARGET_NEON_BF16
+    simsimd_dot_bf16c_neon(a, b, n, d);
 #else
     simsimd_dot_bf16c_serial(a, b, n, d);
 #endif
@@ -1208,7 +1478,13 @@ SIMSIMD_PUBLIC void simsimd_vdot_f16c(simsimd_f16_t const* a, simsimd_f16_t cons
 }
 SIMSIMD_PUBLIC void simsimd_vdot_bf16c(simsimd_bf16_t const* a, simsimd_bf16_t const* b, simsimd_size_t n,
                                        simsimd_distance_t* d) {
+#if SIMSIMD_TARGET_GENOA
+    simsimd_vdot_bf16c_genoa(a, b, n, d);
+#elif SIMSIMD_TARGET_NEON_BF16
+    simsimd_dot_bf16c_neon(a, b, n, d);
+#else
     simsimd_vdot_bf16c_serial(a, b, n, d);
+#endif
 }
 SIMSIMD_PUBLIC void simsimd_vdot_f32c(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n,
                                       simsimd_distance_t* d) {
@@ -1260,23 +1536,11 @@ SIMSIMD_PUBLIC void simsimd_cos_i8(simsimd_i8_t const* a, simsimd_i8_t const* b,
     simsimd_cos_i8_serial(a, b, n, d);
 #endif
 }
-SIMSIMD_PUBLIC void simsimd_l2sq_i8(simsimd_i8_t const* a, simsimd_i8_t const* b, simsimd_size_t n,
-                                    simsimd_distance_t* d) {
-#if SIMSIMD_TARGET_NEON
-    simsimd_l2sq_i8_neon(a, b, n, d);
-#elif SIMSIMD_TARGET_ICE
-    simsimd_l2sq_i8_ice(a, b, n, d);
-#elif SIMSIMD_TARGET_HASWELL
-    simsimd_l2sq_i8_haswell(a, b, n, d);
-#else
-    simsimd_l2sq_i8_serial(a, b, n, d);
-#endif
-}
 SIMSIMD_PUBLIC void simsimd_cos_f16(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n,
                                     simsimd_distance_t* d) {
-#if SIMSIMD_TARGET_SVE
+#if SIMSIMD_TARGET_SVE_F16
     simsimd_cos_f16_sve(a, b, n, d);
-#elif SIMSIMD_TARGET_NEON
+#elif SIMSIMD_TARGET_NEON_F16
     simsimd_cos_f16_neon(a, b, n, d);
 #elif SIMSIMD_TARGET_SAPPHIRE
     simsimd_cos_f16_sapphire(a, b, n, d);
@@ -1292,6 +1556,10 @@ SIMSIMD_PUBLIC void simsimd_cos_bf16(simsimd_bf16_t const* a, simsimd_bf16_t con
     simsimd_cos_bf16_genoa(a, b, n, d);
 #elif SIMSIMD_TARGET_HASWELL
     simsimd_cos_bf16_haswell(a, b, n, d);
+#elif SIMSIMD_TARGET_SVE_BF16
+    simsimd_cos_bf16_sve(a, b, n, d);
+#elif SIMSIMD_TARGET_NEON_BF16
+    simsimd_cos_bf16_neon(a, b, n, d);
 #else
     simsimd_cos_bf16_serial(a, b, n, d);
 #endif
@@ -1314,17 +1582,31 @@ SIMSIMD_PUBLIC void simsimd_cos_f64(simsimd_f64_t const* a, simsimd_f64_t const*
                                     simsimd_distance_t* d) {
 #if SIMSIMD_TARGET_SVE
     simsimd_cos_f64_sve(a, b, n, d);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_cos_f64_neon(a, b, n, d);
 #elif SIMSIMD_TARGET_SKYLAKE
     simsimd_cos_f64_skylake(a, b, n, d);
 #else
     simsimd_cos_f64_serial(a, b, n, d);
 #endif
 }
+SIMSIMD_PUBLIC void simsimd_l2sq_i8(simsimd_i8_t const* a, simsimd_i8_t const* b, simsimd_size_t n,
+                                    simsimd_distance_t* d) {
+#if SIMSIMD_TARGET_NEON
+    simsimd_l2sq_i8_neon(a, b, n, d);
+#elif SIMSIMD_TARGET_ICE
+    simsimd_l2sq_i8_ice(a, b, n, d);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_l2sq_i8_haswell(a, b, n, d);
+#else
+    simsimd_l2sq_i8_serial(a, b, n, d);
+#endif
+}
 SIMSIMD_PUBLIC void simsimd_l2sq_f16(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n,
                                      simsimd_distance_t* d) {
-#if SIMSIMD_TARGET_SVE
+#if SIMSIMD_TARGET_SVE_F16
     simsimd_l2sq_f16_sve(a, b, n, d);
-#elif SIMSIMD_TARGET_NEON
+#elif SIMSIMD_TARGET_NEON_F16
     simsimd_l2sq_f16_neon(a, b, n, d);
 #elif SIMSIMD_TARGET_SAPPHIRE
     simsimd_l2sq_f16_sapphire(a, b, n, d);
@@ -1340,6 +1622,10 @@ SIMSIMD_PUBLIC void simsimd_l2sq_bf16(simsimd_bf16_t const* a, simsimd_bf16_t co
     simsimd_l2sq_bf16_genoa(a, b, n, d);
 #elif SIMSIMD_TARGET_HASWELL
     simsimd_l2sq_bf16_haswell(a, b, n, d);
+#elif SIMSIMD_TARGET_SVE_BF16
+    simsimd_l2sq_bf16_sve(a, b, n, d);
+#elif SIMSIMD_TARGET_NEON_BF16
+    simsimd_l2sq_bf16_neon(a, b, n, d);
 #else
     simsimd_l2sq_bf16_serial(a, b, n, d);
 #endif
@@ -1362,12 +1648,80 @@ SIMSIMD_PUBLIC void simsimd_l2sq_f64(simsimd_f64_t const* a, simsimd_f64_t const
                                      simsimd_distance_t* d) {
 #if SIMSIMD_TARGET_SVE
     simsimd_l2sq_f64_sve(a, b, n, d);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_l2sq_f64_neon(a, b, n, d);
 #elif SIMSIMD_TARGET_SKYLAKE
     simsimd_l2sq_f64_skylake(a, b, n, d);
 #else
     simsimd_l2sq_f64_serial(a, b, n, d);
 #endif
 }
+SIMSIMD_PUBLIC void simsimd_l2_i8(simsimd_i8_t const* a, simsimd_i8_t const* b, simsimd_size_t n,
+                                  simsimd_distance_t* d) {
+#if SIMSIMD_TARGET_NEON
+    simsimd_l2_i8_neon(a, b, n, d);
+#elif SIMSIMD_TARGET_ICE
+    simsimd_l2_i8_ice(a, b, n, d);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_l2_i8_haswell(a, b, n, d);
+#else
+    simsimd_l2_i8_serial(a, b, n, d);
+#endif
+}
+SIMSIMD_PUBLIC void simsimd_l2_f16(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n,
+                                   simsimd_distance_t* d) {
+#if SIMSIMD_TARGET_SVE_F16
+    simsimd_l2_f16_sve(a, b, n, d);
+#elif SIMSIMD_TARGET_NEON_F16
+    simsimd_l2_f16_neon(a, b, n, d);
+#elif SIMSIMD_TARGET_SAPPHIRE
+    simsimd_l2_f16_sapphire(a, b, n, d);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_l2_f16_haswell(a, b, n, d);
+#else
+    simsimd_l2_f16_serial(a, b, n, d);
+#endif
+}
+SIMSIMD_PUBLIC void simsimd_l2_bf16(simsimd_bf16_t const* a, simsimd_bf16_t const* b, simsimd_size_t n,
+                                    simsimd_distance_t* d) {
+#if SIMSIMD_TARGET_GENOA
+    simsimd_l2_bf16_genoa(a, b, n, d);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_l2_bf16_haswell(a, b, n, d);
+#elif SIMSIMD_TARGET_SVE_BF16
+    simsimd_l2_bf16_sve(a, b, n, d);
+#elif SIMSIMD_TARGET_NEON_BF16
+    simsimd_l2_bf16_neon(a, b, n, d);
+#else
+    simsimd_l2_bf16_serial(a, b, n, d);
+#endif
+}
+SIMSIMD_PUBLIC void simsimd_l2_f32(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n,
+                                   simsimd_distance_t* d) {
+#if SIMSIMD_TARGET_SVE
+    simsimd_l2_f32_sve(a, b, n, d);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_l2_f32_neon(a, b, n, d);
+#elif SIMSIMD_TARGET_SKYLAKE
+    simsimd_l2_f32_skylake(a, b, n, d);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_l2_f32_haswell(a, b, n, d);
+#else
+    simsimd_l2_f32_serial(a, b, n, d);
+#endif
+}
+SIMSIMD_PUBLIC void simsimd_l2_f64(simsimd_f64_t const* a, simsimd_f64_t const* b, simsimd_size_t n,
+                                   simsimd_distance_t* d) {
+#if SIMSIMD_TARGET_SVE
+    simsimd_l2_f64_sve(a, b, n, d);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_l2_f64_neon(a, b, n, d);
+#elif SIMSIMD_TARGET_SKYLAKE
+    simsimd_l2_f64_skylake(a, b, n, d);
+#else
+    simsimd_l2_f64_serial(a, b, n, d);
+#endif
+}
 
 /*  Binary distances
  *  - Hamming distance: the number of positions at which the corresponding bits are different.
@@ -1415,9 +1769,9 @@ SIMSIMD_PUBLIC void simsimd_jaccard_b8(simsimd_b8_t const* a, simsimd_b8_t const
  *  - Jensen-Shannon divergence: a measure of similarity between two probability distributions.
  *  - Kullback-Leibler divergence: a measure of how one probability distribution diverges from a second.
  *
- *  @param a The first descrete probability distribution.
- *  @param b The second descrete probability distribution.
- *  @param n The number of elements in the descrete distributions.
+ *  @param a The first discrete probability distribution.
+ *  @param b The second discrete probability distribution.
+ *  @param n The number of elements in the discrete distributions.
  *  @param d The output divergence value.
  *
  *  @note The distributions are assumed to be normalized.
@@ -1482,6 +1836,126 @@ SIMSIMD_PUBLIC void simsimd_js_f64(simsimd_f64_t const* a, simsimd_f64_t const*
     simsimd_js_f64_serial(a, b, n, d);
 }
 
+/*  Set operations
+ *
+ *  @param a The first sorted array of integers.
+ *  @param b The second sorted array of integers.
+ *  @param a_length The number of elements in the first array.
+ *  @param b_length The number of elements in the second array.
+ *  @param d The output for the number of elements in the intersection.
+ */
+SIMSIMD_PUBLIC void simsimd_intersect_u16(simsimd_u16_t const* a, simsimd_u16_t const* b, simsimd_size_t a_length,
+                                          simsimd_size_t b_length, simsimd_distance_t* d) {
+#if SIMSIMD_TARGET_SVE2
+    simsimd_intersect_u16_sve2(a, b, a_length, b_length, d);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_intersect_u16_neon(a, b, a_length, b_length, d);
+#elif SIMSIMD_TARGET_SKYLAKE
+    simsimd_intersect_u16_ice(a, b, a_length, b_length, d);
+#else
+    simsimd_intersect_u16_serial(a, b, a_length, b_length, d);
+#endif
+}
+
+SIMSIMD_PUBLIC void simsimd_intersect_u32(simsimd_u32_t const* a, simsimd_u32_t const* b, simsimd_size_t a_length,
+                                          simsimd_size_t b_length, simsimd_distance_t* d) {
+#if SIMSIMD_TARGET_SVE2
+    simsimd_intersect_u32_sve2(a, b, a_length, b_length, d);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_intersect_u32_neon(a, b, a_length, b_length, d);
+#elif SIMSIMD_TARGET_SKYLAKE
+    simsimd_intersect_u32_ice(a, b, a_length, b_length, d);
+#else
+    simsimd_intersect_u32_serial(a, b, a_length, b_length, d);
+#endif
+}
+
+/*  Curved space distances
+ *
+ *  @param a The first vector of floating point values.
+ *  @param b The second vector of floating point values.
+ *  @param c The metric tensor or covariance matrix.
+ *  @param n The number of dimensions in the vectors.
+ *  @param d The output for the number of elements in the intersection.
+ */
+SIMSIMD_PUBLIC void simsimd_bilinear_f64(simsimd_f64_t const* a, simsimd_f64_t const* b, simsimd_f64_t const* c,
+                                         simsimd_size_t n, simsimd_distance_t* d) {
+
+    simsimd_bilinear_f64_serial(a, b, c, n, d);
+}
+SIMSIMD_PUBLIC void simsimd_mahalanobis_f64(simsimd_f64_t const* a, simsimd_f64_t const* b, simsimd_f64_t const* c,
+                                            simsimd_size_t n, simsimd_distance_t* d) {
+    simsimd_mahalanobis_f64_serial(a, b, c, n, d);
+}
+SIMSIMD_PUBLIC void simsimd_bilinear_f32(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_f32_t const* c,
+                                         simsimd_size_t n, simsimd_distance_t* d) {
+#if SIMSIMD_TARGET_SKYLAKE
+    simsimd_bilinear_f32_skylake(a, b, c, n, d);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_bilinear_f32_neon(a, b, c, n, d);
+#else
+    simsimd_bilinear_f32_serial(a, b, c, n, d);
+#endif
+}
+SIMSIMD_PUBLIC void simsimd_mahalanobis_f32(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_f32_t const* c,
+                                            simsimd_size_t n, simsimd_distance_t* d) {
+#if SIMSIMD_TARGET_SKYLAKE
+    simsimd_mahalanobis_f32_skylake(a, b, c, n, d);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_mahalanobis_f32_neon(a, b, c, n, d);
+#else
+    simsimd_mahalanobis_f32_serial(a, b, c, n, d);
+#endif
+}
+SIMSIMD_PUBLIC void simsimd_bilinear_f16(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_f16_t const* c,
+                                         simsimd_size_t n, simsimd_distance_t* d) {
+#if SIMSIMD_TARGET_SAPPHIRE
+    simsimd_bilinear_f16_sapphire(a, b, c, n, d);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_bilinear_f16_haswell(a, b, c, n, d);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_bilinear_f16_neon(a, b, c, n, d);
+#else
+    simsimd_bilinear_f16_serial(a, b, c, n, d);
+#endif
+}
+SIMSIMD_PUBLIC void simsimd_mahalanobis_f16(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_f16_t const* c,
+                                            simsimd_size_t n, simsimd_distance_t* d) {
+#if SIMSIMD_TARGET_SAPPHIRE
+    simsimd_mahalanobis_f16_sapphire(a, b, c, n, d);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_mahalanobis_f16_haswell(a, b, c, n, d);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_mahalanobis_f16_neon(a, b, c, n, d);
+#else
+    simsimd_mahalanobis_f16_serial(a, b, c, n, d);
+#endif
+}
+SIMSIMD_PUBLIC void simsimd_bilinear_bf16(simsimd_bf16_t const* a, simsimd_bf16_t const* b, simsimd_bf16_t const* c,
+                                          simsimd_size_t n, simsimd_distance_t* d) {
+#if SIMSIMD_TARGET_GENOA
+    simsimd_bilinear_bf16_genoa(a, b, c, n, d);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_bilinear_bf16_haswell(a, b, c, n, d);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_bilinear_bf16_neon(a, b, c, n, d);
+#else
+    simsimd_bilinear_bf16_serial(a, b, c, n, d);
+#endif
+}
+SIMSIMD_PUBLIC void simsimd_mahalanobis_bf16(simsimd_bf16_t const* a, simsimd_bf16_t const* b, simsimd_bf16_t const* c,
+                                             simsimd_size_t n, simsimd_distance_t* d) {
+#if SIMSIMD_TARGET_GENOA
+    simsimd_mahalanobis_bf16_genoa(a, b, c, n, d);
+#elif SIMSIMD_TARGET_HASWELL
+    simsimd_mahalanobis_bf16_haswell(a, b, c, n, d);
+#elif SIMSIMD_TARGET_NEON
+    simsimd_mahalanobis_bf16_neon(a, b, c, n, d);
+#else
+    simsimd_mahalanobis_bf16_serial(a, b, c, n, d);
+#endif
+}
+
 #endif
 
 #ifdef __cplusplus