usearch 2.16.2 → 2.16.4

package/simsimd/javascript/simsimd.ts

@@ -18,47 +18,66 @@ try {
 
 /**
  * @brief Computes the squared Euclidean distance between two vectors.
- * @param {Float64Array|Float32Array|Int8Array} a - The first vector.
- * @param {Float64Array|Float32Array|Int8Array} b - The second vector.
+ * @param {Float64Array|Float32Array|Int8Array|Uint8Array} a - The first vector.
+ * @param {Float64Array|Float32Array|Int8Array|Uint8Array} b - The second vector.
  * @returns {number} The squared Euclidean distance between vectors a and b.
  */
 export const sqeuclidean = (
-  a: Float64Array | Float32Array | Int8Array,
-  b: Float64Array | Float32Array | Int8Array
+  a: Float64Array | Float32Array | Int8Array | Uint8Array,
+  b: Float64Array | Float32Array | Int8Array | Uint8Array
 ): number => {
   return compiled.sqeuclidean(a, b);
 };
 
+/**
+ * @brief Computes the Euclidean distance between two vectors.
+ * @param {Float64Array|Float32Array|Int8Array|Uint8Array} a - The first vector.
+ * @param {Float64Array|Float32Array|Int8Array|Uint8Array} b - The second vector.
+ * @returns {number} The squared Euclidean distance between vectors a and b.
+ */
+export const euclidean = (
+  a: Float64Array | Float32Array | Int8Array | Uint8Array,
+  b: Float64Array | Float32Array | Int8Array | Uint8Array
+): number => {
+  return compiled.euclidean(a, b);
+};
+
 /**
  * @brief Computes the cosine distance between two vectors.
- * @param {Float64Array|Float32Array|Int8Array} a - The first vector.
- * @param {Float64Array|Float32Array|Int8Array} b - The second vector.
+ * @param {Float64Array|Float32Array|Int8Array|Uint8Array} a - The first vector.
+ * @param {Float64Array|Float32Array|Int8Array|Uint8Array} b - The second vector.
  * @returns {number} The cosine distance between vectors a and b.
  */
 export const cosine = (
-  a: Float64Array | Float32Array | Int8Array,
-  b: Float64Array | Float32Array | Int8Array
+  a: Float64Array | Float32Array | Int8Array | Uint8Array,
+  b: Float64Array | Float32Array | Int8Array | Uint8Array
 ): number => {
   return compiled.cosine(a, b);
 };
 
 /**
  * @brief Computes the inner product of two vectors (same as dot product).
- * @param {Float64Array|Float32Array} a - The first vector.
- * @param {Float64Array|Float32Array} b - The second vector.
+ * @param {Float64Array|Float32Array|Int8Array|Uint8Array} a - The first vector.
+ * @param {Float64Array|Float32Array|Int8Array|Uint8Array} b - The second vector.
  * @returns {number} The inner product of vectors a and b.
  */
-export const inner = (a: Float64Array | Float32Array, b: Float64Array | Float32Array): number => {
+export const inner = (
+  a: Float64Array | Float32Array | Int8Array | Uint8Array,
+  b: Float64Array | Float32Array | Int8Array | Uint8Array
+): number => {
   return compiled.inner(a, b);
 };
 
 /**
  * @brief Computes the dot product of two vectors (same as inner product).
- * @param {Float64Array|Float32Array} a - The first vector.
- * @param {Float64Array|Float32Array} b - The second vector.
+ * @param {Float64Array|Float32Array|Int8Array|Uint8Array} a - The first vector.
+ * @param {Float64Array|Float32Array|Int8Array|Uint8Array} b - The second vector.
  * @returns {number} The dot product of vectors a and b.
  */
-export const dot = (a: Float64Array | Float32Array, b: Float64Array | Float32Array): number => {
+export const dot = (
+  a: Float64Array | Float32Array | Int8Array | Uint8Array,
+  b: Float64Array | Float32Array | Int8Array | Uint8Array
+): number => {
   return compiled.dot(a, b);
 };
 
@@ -127,6 +146,7 @@ export default {
   dot,
   inner,
   sqeuclidean,
+  euclidean,
   cosine,
   hamming,
   jaccard,

package/simsimd/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "simsimd",
-  "version": "4.2.1",
+  "version": "5.9.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "simsimd",
-      "version": "4.2.1",
+      "version": "5.9.2",
       "hasInstallScript": true,
       "license": "Apache 2.0",
       "dependencies": {
@@ -16,7 +16,7 @@
       },
       "devDependencies": {
         "@types/bindings": "^1.5.5",
-        "@types/node": "^20.12.2",
+        "@types/node": "^20.17.1",
         "node-gyp": "^10.0.1",
         "prebuildify": "^6.0.0",
         "typescript": "^5.3.3"
@@ -107,12 +107,13 @@
       }
     },
     "node_modules/@types/node": {
-      "version": "20.12.2",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.12.2.tgz",
-      "integrity": "sha512-zQ0NYO87hyN6Xrclcqp7f8ZbXNbRfoGWNcMvHTPQp9UUrwI0mI7XBz+cu7/W6/VClYo2g63B0cjull/srU7LgQ==",
+      "version": "20.17.1",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.17.1.tgz",
+      "integrity": "sha512-j2VlPv1NnwPJbaCNv69FO/1z4lId0QmGvpT41YxitRtWlg96g/j8qcv2RKsLKe2F6OJgyXhupN1Xo17b2m139Q==",
       "devOptional": true,
+      "license": "MIT",
       "dependencies": {
-        "undici-types": "~5.26.4"
+        "undici-types": "~6.19.2"
       }
     },
     "node_modules/abbrev": {
@@ -1525,10 +1526,11 @@
       }
     },
     "node_modules/undici-types": {
-      "version": "5.26.5",
-      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz",
-      "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==",
-      "devOptional": true
+      "version": "6.19.8",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.19.8.tgz",
+      "integrity": "sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==",
+      "devOptional": true,
+      "license": "MIT"
     },
     "node_modules/unique-filename": {
       "version": "3.0.0",

package/simsimd/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simsimd",
-  "version": "5.9.6",
+  "version": "6.0.5",
   "description": "Portable mixed-precision BLAS-like vector math library for x86 and ARM",
   "homepage": "https://github.com/ashvardanian/simsimd",
   "author": "Ash Vardanian",
@@ -48,7 +48,7 @@
   },
   "devDependencies": {
     "@types/bindings": "^1.5.5",
-    "@types/node": "^20.12.2",
+    "@types/node": "^20.17.1",
     "node-gyp": "^10.0.1",
     "prebuildify": "^6.0.0",
     "typescript": "^5.3.3"
@@ -58,4 +58,4 @@
     "mathjs": "^11.11.2",
     "usearch": "^2.8.15"
   }
-}
+}

package/simsimd/scripts/bench.cxx

@@ -1,10 +1,11 @@
 #include <cmath>         // `std::sqrt`
 #include <cstdlib>       // `std::aligned_alloc`
 #include <cstring>       // `std::memcpy`
+#include <numeric>       // `std::accumulate`
 #include <random>        // `std::uniform_int_distribution`
 #include <thread>        // `std::thread`
 #include <tuple>         // `std::tuple` for callable introspection
-#include <type_traits>   // ``
+#include <type_traits>   // `std::numeric_limits`
 #include <unordered_set> // `std::unordered_set`
 #include <vector>        // `std::vector`
 
@@ -818,10 +819,6 @@ int main(int argc, char **argv) {
     dense_<f16_k>("l2sq_f16_sve", simsimd_l2sq_f16_sve, simsimd_l2sq_f16_accurate);
     dense_<f16_k>("l2_f16_sve", simsimd_l2_f16_sve, simsimd_l2_f16_accurate);
 
-    dense_<bf16_k>("cos_bf16_sve", simsimd_cos_bf16_sve, simsimd_cos_bf16_accurate);
-    dense_<bf16_k>("l2sq_bf16_sve", simsimd_l2sq_bf16_sve, simsimd_l2sq_bf16_accurate);
-    dense_<bf16_k>("l2_bf16_sve", simsimd_l2_bf16_sve, simsimd_l2_bf16_accurate);
-
     dense_<f32_k>("dot_f32_sve", simsimd_dot_f32_sve, simsimd_dot_f32_accurate);
     dense_<f32_k>("cos_f32_sve", simsimd_cos_f32_sve, simsimd_cos_f32_accurate);
     dense_<f32_k>("l2sq_f32_sve", simsimd_l2sq_f32_sve, simsimd_l2sq_f32_accurate);

package/simsimd/scripts/bench_vectors.py

@@ -44,7 +44,7 @@ metric_families = [
     "sparse",  # Intersection of two sparse integer sets, with float/int weights
 ]
 dtype_names = [
-    "bits",  #! Not supported by SciPy
+    "bin8",  #! Not supported by SciPy
     "int8",  #! Presented as supported, but overflows most of the time
     "uint16",
     "uint32",
@@ -72,6 +72,21 @@ class Kernel:
     tensor_type: callable = np.array
 
 
+def serial_cosine(a: List[float], b: List[float]) -> float:
+    dot_product = sum(ai * bi for ai, bi in zip(a, b))
+    norm_a = sum(ai * ai for ai in a) ** 0.5
+    norm_b = sum(bi * bi for bi in b) ** 0.5
+    if norm_a == 0 and norm_b == 0:
+        return 1
+    if dot_product == 0:
+        return 0
+    return dot_product / (norm_a * norm_b)
+
+
+def serial_sqeuclidean(a: List[float], b: List[float]) -> float:
+    return sum((ai - bi) ** 2 for ai, bi in zip(a, b))
+
+
 def yield_kernels(
     metric_families: List[str],
     dtype_names: List[str],
@@ -197,6 +212,25 @@ def yield_kernels(
             simd.vdot,
             lambda A, B: simd.cdist(A, B, metric="vdot"),
         )
+    if "spatial" in metric_families:
+        yield from for_dtypes(
+            "serial.cosine",
+            ["float64", "float32", "float16", "int8"],
+            serial_cosine,
+            wrap_rows_batch_calls(serial_cosine),
+            lambda A, B: spd.cdist(A, B, "cosine"),
+            simd.cosine,
+            lambda A, B: simd.cdist(A, B, metric="cosine"),
+        )
+        yield from for_dtypes(
+            "serial.sqeuclidean",
+            ["float64", "float32", "float16", "int8"],
+            serial_sqeuclidean,
+            wrap_rows_batch_calls(serial_sqeuclidean),
+            lambda A, B: spd.cdist(A, B, "sqeuclidean"),
+            simd.sqeuclidean,
+            lambda A, B: simd.cdist(A, B, metric="sqeuclidean"),
+        )
     if "spatial" in metric_families and include_scipy:
         yield from for_dtypes(
             "scipy.cosine",
@@ -248,21 +282,21 @@ def yield_kernels(
     if "binary" in metric_families and include_scipy:
         yield from for_dtypes(
             "scipy.hamming",
-            ["bits"],
+            ["bin8"],
             spd.hamming,
             wrap_rows_batch_calls(spd.hamming),
             lambda A, B: spd.cdist(A, B, "hamming"),
-            lambda A, B: simd.hamming(A, B, "bits"),
-            lambda A, B: simd.cdist(A, B, "bits", metric="hamming"),
+            lambda A, B: simd.hamming(A, B, "bin8"),
+            lambda A, B: simd.cdist(A, B, "bin8", metric="hamming"),
         )
         yield from for_dtypes(
             "scipy.jaccard",
-            ["bits"],
+            ["bin8"],
             spd.jaccard,
             wrap_rows_batch_calls(spd.jaccard),
             lambda A, B: spd.cdist(A, B, "jaccard"),
-            lambda A, B: simd.jaccard(A, B, "bits"),
-            lambda A, B: simd.cdist(A, B, "bits", metric="jaccard"),
+            lambda A, B: simd.jaccard(A, B, "bin8"),
+            lambda A, B: simd.cdist(A, B, "bin8", metric="jaccard"),
         )
     if "spatial" in metric_families and include_scikit:
         yield from for_dtypes(
@@ -351,7 +385,7 @@ def random_matrix(count: int, ndim: int, dtype: str) -> np.ndarray:
         return np.random.randint(0, high=256, size=(count, ndim), dtype=np.int16)
     if dtype == "int8":
         return np.random.randint(-100, high=100, size=(count, ndim), dtype=np.int8)
-    if dtype == "bits":
+    if dtype == "bin8":
         return np.packbits(np.random.randint(0, high=2, size=(count, ndim), dtype=np.uint8), axis=0)
 
 
@@ -528,11 +562,11 @@ def result_to_row(result: Result) -> List[str]:
     if isinstance(result.baseline_seconds, float):
         ops_per_second = result.distance_calculations / result.baseline_seconds
         gbs_per_second = result.bytes_per_vector * ops_per_second / 1e9
-        baseline_cell = f"{ops_per_second:,.0f} ops/s, {gbs_per_second:,.2f} GB/s"
+        baseline_cell = f"{ops_per_second:,.0f} ops/s, {gbs_per_second:,.3f} GB/s"
     if isinstance(result.simsimd_seconds, float):
         ops_per_second = result.distance_calculations / result.simsimd_seconds
         gbs_per_second = result.bytes_per_vector * ops_per_second / 1e9
-        simsimd_cell = f"{ops_per_second:,.0f} ops/s, {gbs_per_second:,.2f} GB/s"
+        simsimd_cell = f"{ops_per_second:,.0f} ops/s, {gbs_per_second:,.3f} GB/s"
     if isinstance(result.baseline_seconds, float) and isinstance(result.simsimd_seconds, float):
         improvement_cell = f"{result.baseline_seconds / result.simsimd_seconds:,.2f} x"
 

package/simsimd/scripts/test.c

@@ -91,59 +91,63 @@ void test_distance_from_itself(void) {
     simsimd_f16_t f16s[1536];
     simsimd_bf16_t bf16s[1536];
     simsimd_i8_t i8s[1536];
-    simsimd_b8_t b8s[1536 / 8]; // 8 bits per word
-    simsimd_distance_t distance;
+    simsimd_u8_t u8s[1536];
+    simsimd_b8_t b8s[1536 / 8];     // 8 bits per word
+    simsimd_distance_t distance[2]; // For complex dot-products we need two values
 
     // Cosine distance between two vectors
-    simsimd_cos_i8(i8s, i8s, 1536, &distance);
-    simsimd_cos_f16(f16s, f16s, 1536, &distance);
-    simsimd_cos_bf16(bf16s, bf16s, 1536, &distance);
-    simsimd_cos_f32(f32s, f32s, 1536, &distance);
-    simsimd_cos_f64(f64s, f64s, 1536, &distance);
+    simsimd_cos_i8(i8s, i8s, 1536, &distance[0]);
+    simsimd_cos_u8(u8s, u8s, 1536, &distance[0]);
+    simsimd_cos_f16(f16s, f16s, 1536, &distance[0]);
+    simsimd_cos_bf16(bf16s, bf16s, 1536, &distance[0]);
+    simsimd_cos_f32(f32s, f32s, 1536, &distance[0]);
+    simsimd_cos_f64(f64s, f64s, 1536, &distance[0]);
 
     // Euclidean distance between two vectors
-    simsimd_l2sq_i8(i8s, i8s, 1536, &distance);
-    simsimd_l2sq_f16(f16s, f16s, 1536, &distance);
-    simsimd_l2sq_bf16(bf16s, bf16s, 1536, &distance);
-    simsimd_l2sq_f32(f32s, f32s, 1536, &distance);
-    simsimd_l2sq_f64(f64s, f64s, 1536, &distance);
+    simsimd_l2sq_i8(i8s, i8s, 1536, &distance[0]);
+    simsimd_l2sq_u8(u8s, u8s, 1536, &distance[0]);
+    simsimd_l2sq_f16(f16s, f16s, 1536, &distance[0]);
+    simsimd_l2sq_bf16(bf16s, bf16s, 1536, &distance[0]);
+    simsimd_l2sq_f32(f32s, f32s, 1536, &distance[0]);
+    simsimd_l2sq_f64(f64s, f64s, 1536, &distance[0]);
 
     // Inner product between two vectors
-    simsimd_dot_f16(f16s, f16s, 1536, &distance);
-    simsimd_dot_bf16(bf16s, bf16s, 1536, &distance);
-    simsimd_dot_f32(f32s, f32s, 1536, &distance);
-    simsimd_dot_f64(f64s, f64s, 1536, &distance);
+    simsimd_dot_i8(i8s, i8s, 1536, &distance[0]);
+    simsimd_dot_u8(u8s, u8s, 1536, &distance[0]);
+    simsimd_dot_f16(f16s, f16s, 1536, &distance[0]);
+    simsimd_dot_bf16(bf16s, bf16s, 1536, &distance[0]);
+    simsimd_dot_f32(f32s, f32s, 1536, &distance[0]);
+    simsimd_dot_f64(f64s, f64s, 1536, &distance[0]);
 
     // Complex inner product between two vectors
-    simsimd_dot_f16c(f16s, f16s, 1536, &distance);
-    simsimd_dot_bf16c(bf16s, bf16s, 1536, &distance);
-    // simsimd_dot_bf16c(bf16s, bf16s, 1536, &distance);
-    simsimd_dot_f32c(f32s, f32s, 1536, &distance);
-    simsimd_dot_f64c(f64s, f64s, 1536, &distance);
+    simsimd_dot_f16c(f16s, f16s, 1536, &distance[0]);
+    simsimd_dot_bf16c(bf16s, bf16s, 1536, &distance[0]);
+    simsimd_dot_f32c(f32s, f32s, 1536, &distance[0]);
+    simsimd_dot_f64c(f64s, f64s, 1536, &distance[0]);
 
     // Complex conjugate inner product between two vectors
-    simsimd_vdot_f16c(f16s, f16s, 1536, &distance);
-    simsimd_vdot_bf16c(bf16s, bf16s, 1536, &distance);
-    simsimd_vdot_f32c(f32s, f32s, 1536, &distance);
-    simsimd_vdot_f64c(f64s, f64s, 1536, &distance);
+    simsimd_vdot_f16c(f16s, f16s, 1536, &distance[0]);
+    simsimd_vdot_bf16c(bf16s, bf16s, 1536, &distance[0]);
+    simsimd_vdot_f32c(f32s, f32s, 1536, &distance[0]);
+    simsimd_vdot_f64c(f64s, f64s, 1536, &distance[0]);
 
     // Hamming distance between two vectors
-    simsimd_hamming_b8(b8s, b8s, 1536 / 8, &distance);
+    simsimd_hamming_b8(b8s, b8s, 1536 / 8, &distance[0]);
 
     // Jaccard distance between two vectors
-    simsimd_jaccard_b8(b8s, b8s, 1536 / 8, &distance);
+    simsimd_jaccard_b8(b8s, b8s, 1536 / 8, &distance[0]);
 
     // Jensen-Shannon divergence between two vectors
-    simsimd_js_f16(f16s, f16s, 1536, &distance);
-    simsimd_js_bf16(bf16s, bf16s, 1536, &distance);
-    simsimd_js_f32(f32s, f32s, 1536, &distance);
-    simsimd_js_f64(f64s, f64s, 1536, &distance);
+    simsimd_js_f16(f16s, f16s, 1536, &distance[0]);
+    simsimd_js_bf16(bf16s, bf16s, 1536, &distance[0]);
+    simsimd_js_f32(f32s, f32s, 1536, &distance[0]);
+    simsimd_js_f64(f64s, f64s, 1536, &distance[0]);
 
     // Kullback-Leibler divergence between two vectors
-    simsimd_kl_f16(f16s, f16s, 1536, &distance);
-    simsimd_kl_bf16(bf16s, bf16s, 1536, &distance);
-    simsimd_kl_f32(f32s, f32s, 1536, &distance);
-    simsimd_kl_f64(f64s, f64s, 1536, &distance);
+    simsimd_kl_f16(f16s, f16s, 1536, &distance[0]);
+    simsimd_kl_bf16(bf16s, bf16s, 1536, &distance[0]);
+    simsimd_kl_f32(f32s, f32s, 1536, &distance[0]);
+    simsimd_kl_f64(f64s, f64s, 1536, &distance[0]);
 }
 
 int main(int argc, char **argv) {

package/simsimd/scripts/test.mjs

@@ -102,9 +102,20 @@ test("Distance from itself JS fallback", () => {
 const f32Array1 = new Float32Array([1.0, 2.0, 3.0]);
 const f32Array2 = new Float32Array([4.0, 5.0, 6.0]);
 
+const uint8Array1 = new Uint8Array([1, 2, 3]);
+const uint8Array2 = new Uint8Array([4, 5, 6]);
+
 test("Squared Euclidean Distance", () => {
   const result = simsimd.sqeuclidean(f32Array1, f32Array2);
   assertAlmostEqual(result, 27.0, 0.01);
+
+  const uint8Result = simsimd.sqeuclidean(uint8Array1, uint8Array2);
+  assertAlmostEqual(uint8Result, 27.0, 0.01);
+});
+
+test("Euclidean Distance", () => {
+  const result = simsimd.euclidean(f32Array1, f32Array2);
+  assertAlmostEqual(result, 5.2, 0.01);
 });
 
 test("Inner Distance", () => {
@@ -120,6 +131,9 @@ test("Cosine Similarity", () => {
 test("Squared Euclidean Distance JS", () => {
   const result = fallback.sqeuclidean(f32Array1, f32Array2);
   assertAlmostEqual(result, 27.0, 0.01);
+
+  const uint8Result = fallback.sqeuclidean(uint8Array1, uint8Array2);
+  assertAlmostEqual(uint8Result, 27.0, 0.01);
 });
 
 test("Inner Distance JS", () => {
@@ -136,6 +150,20 @@ test("Squared Euclidean Distance C vs JS", () => {
   const result = simsimd.sqeuclidean(f32Array1, f32Array2);
   const resultjs = fallback.sqeuclidean(f32Array1, f32Array2);
   assertAlmostEqual(resultjs, result, 0.01);
+
+  const uint8result = simsimd.sqeuclidean(uint8Array1, uint8Array2);
+  const uint8resultjs = fallback.sqeuclidean(uint8Array1, uint8Array2);
+  assertAlmostEqual(uint8resultjs, uint8result, 0.01);
+});
+
+test("Euclidean Distance C vs JS", () => {
+  const result = simsimd.euclidean(f32Array1, f32Array2);
+  const resultjs = fallback.euclidean(f32Array1, f32Array2);
+  assertAlmostEqual(resultjs, result, 0.01);
+
+  const uint8result = simsimd.euclidean(uint8Array1, uint8Array2);
+  const uint8resultjs = fallback.euclidean(uint8Array1, uint8Array2);
+  assertAlmostEqual(uint8resultjs, uint8result, 0.01);
 });
 
 test("Inner Distance C vs JS", () => {

package/simsimd/scripts/test.py

@@ -491,25 +491,25 @@ def hex_array(arr):
 
 def test_pointers_availability():
     """Tests the availability of pre-compiled functions for compatibility with USearch."""
-    assert simd.pointer_to_sqeuclidean("f64") != 0
-    assert simd.pointer_to_cosine("f64") != 0
-    assert simd.pointer_to_inner("f64") != 0
+    assert simd.pointer_to_sqeuclidean("float64") != 0
+    assert simd.pointer_to_cosine("float64") != 0
+    assert simd.pointer_to_inner("float64") != 0
 
-    assert simd.pointer_to_sqeuclidean("f32") != 0
-    assert simd.pointer_to_cosine("f32") != 0
-    assert simd.pointer_to_inner("f32") != 0
+    assert simd.pointer_to_sqeuclidean("float32") != 0
+    assert simd.pointer_to_cosine("float32") != 0
+    assert simd.pointer_to_inner("float32") != 0
 
-    assert simd.pointer_to_sqeuclidean("f16") != 0
-    assert simd.pointer_to_cosine("f16") != 0
-    assert simd.pointer_to_inner("f16") != 0
+    assert simd.pointer_to_sqeuclidean("float16") != 0
+    assert simd.pointer_to_cosine("float16") != 0
+    assert simd.pointer_to_inner("float16") != 0
 
-    assert simd.pointer_to_sqeuclidean("i8") != 0
-    assert simd.pointer_to_cosine("i8") != 0
-    assert simd.pointer_to_inner("i8") != 0
+    assert simd.pointer_to_sqeuclidean("int8") != 0
+    assert simd.pointer_to_cosine("int8") != 0
+    assert simd.pointer_to_inner("int8") != 0
 
-    assert simd.pointer_to_sqeuclidean("u8") != 0
-    assert simd.pointer_to_cosine("u8") != 0
-    assert simd.pointer_to_inner("u8") != 0
+    assert simd.pointer_to_sqeuclidean("uint8") != 0
+    assert simd.pointer_to_cosine("uint8") != 0
+    assert simd.pointer_to_inner("uint8") != 0
 
 
 def test_capabilities_list():
@@ -832,11 +832,11 @@ def test_dense_bits(ndim, metric, capability, stats_fixture):
     baseline_kernel, simd_kernel = name_to_kernels(metric)
     accurate_dt, accurate = profile(baseline_kernel, a.astype(np.uint64), b.astype(np.uint64))
     expected_dt, expected = profile(baseline_kernel, a, b)
-    result_dt, result = profile(simd_kernel, np.packbits(a), np.packbits(b), "b8")
+    result_dt, result = profile(simd_kernel, np.packbits(a), np.packbits(b), "bin8")
     result = np.array(result)
 
     np.testing.assert_allclose(result, expected, atol=SIMSIMD_ATOL, rtol=SIMSIMD_RTOL)
-    collect_errors(metric, ndim, "bits", accurate, accurate_dt, expected, expected_dt, result, result_dt, stats_fixture)
+    collect_errors(metric, ndim, "bin8", accurate, accurate_dt, expected, expected_dt, result, result_dt, stats_fixture)
 
 
 @pytest.mark.skip(reason="Problems inferring the tolerance bounds for numerical errors")
@@ -1391,10 +1391,10 @@ def test_cdist_hamming(ndim, out_dtype, capability):
     if out_dtype is None:
         # SciPy divides the Hamming distance by the number of dimensions, so we need to multiply it back.
         expected = spd.cdist(A, B, "hamming") * ndim
-        result = simd.cdist(A_bits, B_bits, metric="hamming", dtype="b8")
+        result = simd.cdist(A_bits, B_bits, metric="hamming", dtype="bin8")
     else:
         expected = (spd.cdist(A, B, "hamming") * ndim).astype(out_dtype)
-        result = simd.cdist(A_bits, B_bits, metric="hamming", dtype="b8", out_dtype=out_dtype)
+        result = simd.cdist(A_bits, B_bits, metric="hamming", dtype="bin8", out_dtype=out_dtype)
 
     np.testing.assert_allclose(result, expected, atol=SIMSIMD_ATOL, rtol=SIMSIMD_RTOL)
 

package/simsimd/swift/SimSIMD.swift

@@ -2,9 +2,9 @@ import CSimSIMD
 
 public protocol SimSIMD {
     static var dataType: simsimd_datatype_t { get }
-    static var cosine: simsimd_metric_punned_t { get }
-    static var dotProduct: simsimd_metric_punned_t { get }
-    static var squaredEuclidean: simsimd_metric_punned_t { get }
+    static var cosine: simsimd_metric_dense_punned_t { get }
+    static var dotProduct: simsimd_metric_dense_punned_t { get }
+    static var squaredEuclidean: simsimd_metric_dense_punned_t { get }
 }
 
 extension Int8: SimSIMD {
@@ -71,7 +71,7 @@ extension RandomAccessCollection where Element: SimSIMD {
 }
 
 @inlinable @inline(__always)
-func perform<A, B>(_ metric: simsimd_metric_punned_t, a: A, b: B) -> Double? where A: Sequence, B: Sequence, A.Element == B.Element {
+func perform<A, B>(_ metric: simsimd_metric_dense_punned_t, a: A, b: B) -> Double? where A: Sequence, B: Sequence, A.Element == B.Element {
     var distance: simsimd_distance_t = 0
     let result = a.withContiguousStorageIfAvailable { a in
         b.withContiguousStorageIfAvailable { b in
@@ -118,10 +118,15 @@ extension simsimd_capability_t: OptionSet, CustomStringConvertible {
 }
 
 @inline(__always)
-private func find(kind: simsimd_metric_kind_t, dataType: simsimd_datatype_t) -> simsimd_metric_punned_t {
-    var output: simsimd_metric_punned_t?
+private func find(kind: simsimd_metric_kind_t, dataType: simsimd_datatype_t) -> simsimd_metric_dense_punned_t {
+    var output: simsimd_metric_dense_punned_t?
     var used = simsimd_capability_t.any
-    simsimd_find_metric_punned(kind, dataType, .available, .any, &output, &used)
+    // Use `withUnsafeMutablePointer` to safely cast `output` to the required pointer type.
+    withUnsafeMutablePointer(to: &output) { outputPtr in
+        // Cast the pointer to `UnsafeMutablePointer<simsimd_kernel_punned_t?>`
+        let castedPtr = outputPtr.withMemoryRebound(to: Optional<simsimd_kernel_punned_t>.self, capacity: 1) { $0 }
+        simsimd_find_kernel_punned(kind, dataType, .available, .any, castedPtr, &used)
+    }
     guard let output else { fatalError("Could not find function \(kind) for \(dataType)") }
     return output
 }