usearch 2.16.8 → 2.16.9

package/simsimd/scripts/test.mjs

@@ -24,7 +24,6 @@ import test from "node:test";
 import assert from "node:assert";
 
 import * as simsimd from "../javascript/dist/esm/simsimd.js";
-
 import * as fallback from "../javascript/dist/esm/fallback.js";
 
 function assertAlmostEqual(actual, expected, tolerance = 1e-6) {
@@ -40,168 +39,182 @@ test("Distance from itself", () => {
   const f32s = new Float32Array([1.0, 2.0, 3.0]);
   assertAlmostEqual(simsimd.sqeuclidean(f32s, f32s), 0.0, 0.01);
   assertAlmostEqual(simsimd.cosine(f32s, f32s), 0.0, 0.01);
+  assertAlmostEqual(fallback.sqeuclidean(f32s, f32s), 0.0, 0.01);
+  assertAlmostEqual(fallback.cosine(f32s, f32s), 0.0, 0.01);
 
   const f64s = new Float64Array([1.0, 2.0, 3.0]);
   assertAlmostEqual(simsimd.sqeuclidean(f64s, f64s), 0.0, 0.01);
   assertAlmostEqual(simsimd.cosine(f64s, f64s), 0.0, 0.01);
+  assertAlmostEqual(fallback.sqeuclidean(f64s, f64s), 0.0, 0.01);
+  assertAlmostEqual(fallback.cosine(f64s, f64s), 0.0, 0.01);
 
-  const f32sNormalized = new Float32Array([
-    1.0 / Math.sqrt(14),
-    2.0 / Math.sqrt(14),
-    3.0 / Math.sqrt(14),
-  ]);
+  const f32sNormalized = new Float32Array([1 / Math.sqrt(14), 2 / Math.sqrt(14), 3 / Math.sqrt(14)]);
   assertAlmostEqual(simsimd.inner(f32sNormalized, f32sNormalized), 1.0, 0.01);
+  assertAlmostEqual(fallback.inner(f32sNormalized, f32sNormalized), 1.0, 0.01);
 
-  const f32sDistribution = new Float32Array([1.0 / 6, 2.0 / 6, 3.0 / 6]);
-  assertAlmostEqual(
-    simsimd.kullbackleibler(f32sDistribution, f32sDistribution),
-    0.0,
-    0.01
-  );
-  assertAlmostEqual(
-    simsimd.jensenshannon(f32sDistribution, f32sDistribution),
-    0.0,
-    0.01
-  );
+  const f32sHistogram = new Float32Array([1.0 / 6, 2.0 / 6, 3.0 / 6]);
+  assertAlmostEqual(simsimd.kullbackleibler(f32sHistogram, f32sHistogram), 0.0, 0.01);
+  assertAlmostEqual(simsimd.jensenshannon(f32sHistogram, f32sHistogram), 0.0, 0.01);
+  assertAlmostEqual(fallback.kullbackleibler(f32sHistogram, f32sHistogram), 0.0, 0.01);
+  assertAlmostEqual(fallback.jensenshannon(f32sHistogram, f32sHistogram), 0.0, 0.01);
 
   const u8s = new Uint8Array([1, 2, 3]);
   assertAlmostEqual(simsimd.hamming(u8s, u8s), 0.0, 0.01);
   assertAlmostEqual(simsimd.jaccard(u8s, u8s), 0.0, 0.01);
-});
-
-test("Distance from itself JS fallback", () => {
-  const f32s = new Float32Array([1.0, 2.0, 3.0]);
-
-  assertAlmostEqual(fallback.sqeuclidean(f32s, f32s), 0.0, 0.01);
-  assertAlmostEqual(fallback.cosine(f32s, f32s), 0.0, 0.01);
-
-  const arrNormalized = new Float32Array([
-    1.0 / Math.sqrt(14),
-    2.0 / Math.sqrt(14),
-    3.0 / Math.sqrt(14),
-  ]);
-  assertAlmostEqual(fallback.inner(arrNormalized, arrNormalized), 1.0, 0.01);
-
-  const f32sDistribution = new Float32Array([1.0 / 6, 2.0 / 6, 3.0 / 6]);
-  assertAlmostEqual(
-    fallback.kullbackleibler(f32sDistribution, f32sDistribution),
-    0.0,
-    0.01
-  );
-  assertAlmostEqual(
-    fallback.jensenshannon(f32sDistribution, f32sDistribution),
-    0.0,
-    0.01
-  );
-
-  const u8s = new Uint8Array([1, 2, 3]);
   assertAlmostEqual(fallback.hamming(u8s, u8s), 0.0, 0.01);
   assertAlmostEqual(fallback.jaccard(u8s, u8s), 0.0, 0.01);
 });
 
-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);
+  const f64sOne = new Float64Array([1.0, 2.0, 3.0]);
+  const f64sTwo = new Float64Array([4.0, 5.0, 6.0]);
+  const f64sResult = simsimd.sqeuclidean(f64sOne, f64sTwo);
+  const f64sResultJS = fallback.sqeuclidean(f64sOne, f64sTwo);
+  assertAlmostEqual(f64sResultJS, 27.0, 0.01);
+  assertAlmostEqual(f64sResult, 27.0, 0.01);
+
+  const f32sOne = new Float32Array([1.0, 2.0, 3.0]);
+  const f32sTwo = new Float32Array([4.0, 5.0, 6.0]);
+  const f32sResult = simsimd.sqeuclidean(f32sOne, f32sTwo);
+  const f32sResultJS = fallback.sqeuclidean(f32sOne, f32sTwo);
+  assertAlmostEqual(f32sResultJS, 27.0, 0.01);
+  assertAlmostEqual(f32sResult, 27.0, 0.01);
+
+  const u8sOne = new Uint8Array([1, 2, 3]);
+  const u8sTwo = new Uint8Array([4, 5, 6]);
+  const u8sResult = simsimd.sqeuclidean(u8sOne, u8sTwo);
+  const u8sResultJS = fallback.sqeuclidean(u8sOne, u8sTwo);
+  assertAlmostEqual(u8sResultJS, 27.0, 0.01);
+  assertAlmostEqual(u8sResult, 27.0, 0.01);
+
+  const i8sOne = new Int8Array([1, 2, 3]);
+  const i8sTwo = new Int8Array([4, 5, 6]);
+  const i8sResult = simsimd.sqeuclidean(i8sOne, i8sTwo);
+  const i8sResultJS = fallback.sqeuclidean(i8sOne, i8sTwo);
+  assertAlmostEqual(i8sResultJS, 27.0, 0.01);
+  assertAlmostEqual(i8sResult, 27.0, 0.01);
 });
 
 test("Euclidean Distance", () => {
-  const result = simsimd.euclidean(f32Array1, f32Array2);
-  assertAlmostEqual(result, 5.2, 0.01);
-});
-
-test("Inner Distance", () => {
-  const result = simsimd.inner(f32Array1, f32Array2);
-  assertAlmostEqual(result, 32.0, 0.01);
-});
-
-test("Cosine Similarity", () => {
-  const result = simsimd.cosine(f32Array1, f32Array2);
-  assertAlmostEqual(result, 0.029, 0.01);
-});
-
-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", () => {
-  const result = fallback.inner(f32Array1, f32Array2);
-  assertAlmostEqual(result, 32.0, 0.01);
-});
-
-test("Cosine Similarity JS", () => {
-  const result = fallback.cosine(f32Array1, f32Array2);
-  assertAlmostEqual(result, 0.029, 0.01);
-});
-
-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", () => {
-  const result = simsimd.inner(f32Array1, f32Array2);
-  const resultjs = fallback.inner(f32Array1, f32Array2);
-  assertAlmostEqual(resultjs, result, 0.01);
-});
-
-test("Cosine Similarity C vs JS", () => {
-  const result = simsimd.cosine(f32Array1, f32Array2);
-  const resultjs = fallback.cosine(f32Array1, f32Array2);
-  assertAlmostEqual(resultjs, result, 0.01);
-});
-
-test("Hamming C vs JS", () => {
-  const u8s = new Uint8Array([1, 2, 3]);
-  const result = simsimd.hamming(u8s, u8s);
-  const resultjs = fallback.hamming(u8s, u8s);
-  assertAlmostEqual(resultjs, result, 0.01);
-});
-
-test("Jaccard C vs JS", () => {
-  const u8s = new Uint8Array([1, 2, 3]);
-  const result = simsimd.jaccard(u8s, u8s);
-  const resultjs = fallback.jaccard(u8s, u8s);
-  assertAlmostEqual(resultjs, result, 0.01);
-});
-
-test("Kullback-Leibler C vs JS", () => {
-  const f32sDistribution = new Float32Array([1.0 / 6, 2.0 / 6, 3.0 / 6]);
-  const result = simsimd.kullbackleibler(f32sDistribution, f32sDistribution);
-  const resultjs = fallback.kullbackleibler(f32sDistribution, f32sDistribution);
-  assertAlmostEqual(resultjs, result, 0.01);
-});
-
-test("Jensen-Shannon C vs JS", () => {
-  const f32sDistribution = new Float32Array([1.0 / 6, 2.0 / 6, 3.0 / 6]);
-  const result = simsimd.jensenshannon(f32sDistribution, f32sDistribution);
-  const resultjs = fallback.jensenshannon(f32sDistribution, f32sDistribution);
-  assertAlmostEqual(resultjs, result, 0.01);
+  const f64sOne = new Float64Array([1.0, 2.0, 3.0]);
+  const f64sTwo = new Float64Array([4.0, 5.0, 6.0]);
+  const f64sResult = simsimd.euclidean(f64sOne, f64sTwo);
+  const f64sResultJS = fallback.euclidean(f64sOne, f64sTwo);
+  assertAlmostEqual(f64sResultJS, 5.2, 0.01);
+  assertAlmostEqual(f64sResult, 5.2, 0.01);
+
+  const f32sOne = new Float32Array([1.0, 2.0, 3.0]);
+  const f32sTwo = new Float32Array([4.0, 5.0, 6.0]);
+  const f32sResult = simsimd.euclidean(f32sOne, f32sTwo);
+  const f32sResultJS = fallback.euclidean(f32sOne, f32sTwo);
+  assertAlmostEqual(f32sResultJS, 5.2, 0.01);
+  assertAlmostEqual(f32sResult, 5.2, 0.01);
+
+  const u8sOne = new Uint8Array([1, 2, 3]);
+  const u8sTwo = new Uint8Array([4, 5, 6]);
+  const u8sResult = simsimd.euclidean(u8sOne, u8sTwo);
+  const u8sResultJS = fallback.euclidean(u8sOne, u8sTwo);
+  assertAlmostEqual(u8sResultJS, 5.2, 0.01);
+  assertAlmostEqual(u8sResult, 5.2, 0.01);
+
+  const i8sOne = new Int8Array([1, 2, 3]);
+  const i8sTwo = new Int8Array([4, 5, 6]);
+  const i8sResult = simsimd.euclidean(i8sOne, i8sTwo);
+  const i8sResultJS = fallback.euclidean(i8sOne, i8sTwo);
+  assertAlmostEqual(i8sResultJS, 5.2, 0.01);
+  assertAlmostEqual(i8sResult, 5.2, 0.01);
+});
+
+
+test("Inner Product", () => {
+  const f64sOne = new Float64Array([1.0, 2.0, 3.0]);
+  const f64sTwo = new Float64Array([4.0, 5.0, 6.0]);
+  const f64sResult = simsimd.inner(f64sOne, f64sTwo);
+  const f64sResultJS = fallback.inner(f64sOne, f64sTwo);
+  assertAlmostEqual(f64sResultJS, 32.0, 0.01);
+  assertAlmostEqual(f64sResult, 32.0, 0.01);
+
+  const f32sOne = new Float32Array([1.0, 2.0, 3.0]);
+  const f32sTwo = new Float32Array([4.0, 5.0, 6.0]);
+  const f32sResult = simsimd.inner(f32sOne, f32sTwo);
+  const f32sResultJS = fallback.inner(f32sOne, f32sTwo);
+  assertAlmostEqual(f32sResultJS, 32.0, 0.01);
+  assertAlmostEqual(f32sResult, 32.0, 0.01);
+
+  const u8sOne = new Uint8Array([1, 2, 3]);
+  const u8sTwo = new Uint8Array([4, 5, 6]);
+  const u8sResult = simsimd.inner(u8sOne, u8sTwo);
+  const u8sResultJS = fallback.inner(u8sOne, u8sTwo);
+  assertAlmostEqual(u8sResultJS, 32.0, 0.01);
+  assertAlmostEqual(u8sResult, 32.0, 0.01);
+
+  const i8sOne = new Int8Array([1, 2, 3]);
+  const i8sTwo = new Int8Array([4, 5, 6]);
+  const i8sResult = simsimd.inner(i8sOne, i8sTwo);
+  const i8sResultJS = fallback.inner(i8sOne, i8sTwo);
+  assertAlmostEqual(i8sResultJS, 32.0, 0.01);
+  assertAlmostEqual(i8sResult, 32.0, 0.01);
+});
+
+test("Cosine Distance", () => {
+  const f64sOne = new Float64Array([1.0, 2.0, 3.0]);
+  const f64sTwo = new Float64Array([4.0, 5.0, 6.0]);
+  const f64sResult = simsimd.cosine(f64sOne, f64sTwo);
+  const f64sResultJS = fallback.cosine(f64sOne, f64sTwo);
+  assertAlmostEqual(f64sResultJS, 0.03, 0.01);
+  assertAlmostEqual(f64sResult, 0.03, 0.01);
+
+  const f32sOne = new Float32Array([1.0, 2.0, 3.0]);
+  const f32sTwo = new Float32Array([4.0, 5.0, 6.0]);
+  const f32sResult = simsimd.cosine(f32sOne, f32sTwo);
+  const f32sResultJS = fallback.cosine(f32sOne, f32sTwo);
+  assertAlmostEqual(f32sResultJS, 0.03, 0.01);
+  assertAlmostEqual(f32sResult, 0.03, 0.01);
+
+  const u8sOne = new Uint8Array([1, 2, 3]);
+  const u8sTwo = new Uint8Array([4, 5, 6]);
+  const u8sResult = simsimd.cosine(u8sOne, u8sTwo);
+  const u8sResultJS = fallback.cosine(u8sOne, u8sTwo);
+  assertAlmostEqual(u8sResultJS, 0.03, 0.01);
+  assertAlmostEqual(u8sResult, 0.03, 0.01);
+
+  const i8sOne = new Int8Array([1, 2, 3]);
+  const i8sTwo = new Int8Array([4, 5, 6]);
+  const i8sResult = simsimd.cosine(i8sOne, i8sTwo);
+  const i8sResultJS = fallback.cosine(i8sOne, i8sTwo);
+  assertAlmostEqual(i8sResultJS, 0.03, 0.01);
+  assertAlmostEqual(i8sResult, 0.03, 0.01);
+});
+
+test("Kullback-Leibler", () => {
+  const f64sOne = new Float64Array([1.0 / 6, 2.0 / 6, 3.0 / 6]);
+  const f64sTwo = new Float64Array([4.0 / 17, 5.0 / 17, 6.0 / 17]);
+  const f64sResult = simsimd.kullbackleibler(f64sOne, f64sTwo);
+  const f64sResultJS = fallback.kullbackleibler(f64sOne, f64sTwo);
+  assertAlmostEqual(f64sResultJS, 0.16, 0.01);
+  assertAlmostEqual(f64sResult, 0.16, 0.01);
+
+  const f32sOne = new Float32Array([1.0 / 6, 2.0 / 6, 3.0 / 6]);
+  const f32sTwo = new Float32Array([4.0 / 17, 5.0 / 17, 6.0 / 17]);
+  const f32sResult = simsimd.kullbackleibler(f32sOne, f32sTwo);
+  const f32sResultJS = fallback.kullbackleibler(f32sOne, f32sTwo);
+  assertAlmostEqual(f32sResultJS, 0.16, 0.01);
+  assertAlmostEqual(f32sResult, 0.16, 0.01);
+});
+
+test("Jensen-Shannon", () => {
+  const f64sOne = new Float64Array([1.0 / 6, 2.0 / 6, 3.0 / 6]);
+  const f64sTwo = new Float64Array([4.0 / 17, 5.0 / 17, 6.0 / 17]);
+  const f64sResult = simsimd.jensenshannon(f64sOne, f64sTwo);
+  const f64sResultJS = fallback.jensenshannon(f64sOne, f64sTwo);
+  assertAlmostEqual(f64sResultJS, 0.095, 0.01);
+  assertAlmostEqual(f64sResult, 0.095, 0.01);
+
+  const f32sOne = new Float32Array([1.0 / 6, 2.0 / 6, 3.0 / 6]);
+  const f32sTwo = new Float32Array([4.0 / 17, 5.0 / 17, 6.0 / 17]);
+  const f32sResult = simsimd.jensenshannon(f32sOne, f32sTwo);
+  const f32sResultJS = fallback.jensenshannon(f32sOne, f32sTwo);
+  assertAlmostEqual(f32sResultJS, 0.095, 0.01);
+  assertAlmostEqual(f32sResult, 0.095, 0.01);
 });

package/simsimd/scripts/test.py

@@ -38,7 +38,6 @@ Or run the script directly:
     python test.py
 
 """
-
 import os
 import math
 import time
@@ -124,7 +123,7 @@ try:
     baseline_euclidean = lambda x, y: np.array(spd.euclidean(x, y))  #! SciPy returns a scalar
     baseline_sqeuclidean = spd.sqeuclidean
     baseline_cosine = spd.cosine
-    baseline_jensenshannon = lambda x, y: spd.jensenshannon(x, y) ** 2
+    baseline_jensenshannon = lambda x, y: spd.jensenshannon(x, y)
     baseline_hamming = lambda x, y: spd.hamming(x, y) * len(x)
     baseline_jaccard = spd.jaccard
 
@@ -453,6 +452,8 @@ def name_to_kernels(name: str):
         return baseline_fma, simd.fma
     elif name == "wsum":
         return baseline_wsum, simd.wsum
+    elif name == "jensenshannon":
+        return baseline_jensenshannon, simd.jensenshannon
     else:
         raise ValueError(f"Unknown kernel name: {name}")
 
@@ -587,7 +588,7 @@ def test_invalid_argument_handling(function, expected_error, args, kwargs):
 
 
 @pytest.mark.skipif(not numpy_available, reason="NumPy is not installed")
-@pytest.mark.repeat(50)
+@pytest.mark.repeat(5)
 @pytest.mark.parametrize("ndim", [11, 97, 1536])
 @pytest.mark.parametrize("dtype", ["float64", "float32", "float16"])
 @pytest.mark.parametrize("metric", ["inner", "euclidean", "sqeuclidean", "cosine"])
@@ -616,7 +617,7 @@ def test_dense(ndim, dtype, metric, capability, stats_fixture):
 
 
 @pytest.mark.skipif(not numpy_available, reason="NumPy is not installed")
-@pytest.mark.repeat(50)
+@pytest.mark.repeat(5)
 @pytest.mark.parametrize("ndim", [11, 97])
 @pytest.mark.parametrize(
     "dtypes",  # representation datatype and compute precision
@@ -671,8 +672,42 @@ def test_curved(ndim, dtypes, metric, capability, stats_fixture):
     collect_errors(metric, ndim, dtype, accurate, accurate_dt, expected, expected_dt, result, result_dt, stats_fixture)
 
 
+@pytest.mark.skipif(is_running_under_qemu(), reason="Complex math in QEMU fails")
+@pytest.mark.skipif(not numpy_available, reason="NumPy is not installed")
+@pytest.mark.repeat(5)
+@pytest.mark.parametrize("ndim", [11, 97])
+@pytest.mark.parametrize("dtype", ["complex128", "complex64"])
+@pytest.mark.parametrize("capability", possible_capabilities)
+def test_curved_complex(ndim, dtype, capability, stats_fixture):
+    """Compares various SIMD kernels (like Bilinear Forms and Mahalanobis distances) for curved spaces
+    with their NumPy or baseline counterparts, testing accuracy for complex IEEE standard floating-point types."""
+
+    # Let's generate some uniform complex numbers
+    np.random.seed()
+    a = (np.random.randn(ndim) + 1.0j * np.random.randn(ndim)).astype(dtype)
+    b = (np.random.randn(ndim) + 1.0j * np.random.randn(ndim)).astype(dtype)
+    c = (np.random.randn(ndim, ndim) + 1.0j * np.random.randn(ndim, ndim)).astype(dtype)
+
+    keep_one_capability(capability)
+    baseline_kernel, simd_kernel = name_to_kernels("bilinear")
+    accurate_dt, accurate = profile(
+        baseline_kernel,
+        a.astype(np.complex128),
+        b.astype(np.complex128),
+        c.astype(np.complex128),
+    )
+    expected_dt, expected = profile(baseline_kernel, a, b, c)
+    result_dt, result = profile(simd_kernel, a, b, c)
+    result = np.array(result)
+
+    np.testing.assert_allclose(result, expected, atol=SIMSIMD_ATOL, rtol=SIMSIMD_RTOL)
+    collect_errors(
+        "bilinear", ndim, dtype, accurate, accurate_dt, expected, expected_dt, result, result_dt, stats_fixture
+    )
+
+
 @pytest.mark.skipif(not numpy_available, reason="NumPy is not installed")
-@pytest.mark.repeat(50)
+@pytest.mark.repeat(5)
 @pytest.mark.parametrize("ndim", [11, 97, 1536])
 @pytest.mark.parametrize("metric", ["inner", "euclidean", "sqeuclidean", "cosine"])
 @pytest.mark.parametrize("capability", possible_capabilities)
@@ -712,7 +747,7 @@ def test_dense_bf16(ndim, metric, capability, stats_fixture):
 
 
 @pytest.mark.skipif(not numpy_available, reason="NumPy is not installed")
-@pytest.mark.repeat(50)
+@pytest.mark.repeat(5)
 @pytest.mark.parametrize("ndim", [11, 16, 33])
 @pytest.mark.parametrize("metric", ["bilinear", "mahalanobis"])
 @pytest.mark.parametrize("capability", possible_capabilities)
@@ -771,7 +806,7 @@ def test_curved_bf16(ndim, metric, capability, stats_fixture):
 
 
 @pytest.mark.skipif(not numpy_available, reason="NumPy is not installed")
-@pytest.mark.repeat(50)
+@pytest.mark.repeat(5)
 @pytest.mark.parametrize("ndim", [11, 97, 1536])
 @pytest.mark.parametrize("dtype", ["int8", "uint8"])
 @pytest.mark.parametrize("metric", ["inner", "euclidean", "sqeuclidean", "cosine"])
@@ -817,7 +852,7 @@ def test_dense_i8(ndim, dtype, metric, capability, stats_fixture):
 
 @pytest.mark.skipif(not numpy_available, reason="NumPy is not installed")
 @pytest.mark.skipif(not scipy_available, reason="SciPy is not installed")
-@pytest.mark.repeat(50)
+@pytest.mark.repeat(5)
 @pytest.mark.parametrize("ndim", [11, 97, 1536])
 @pytest.mark.parametrize("metric", ["jaccard", "hamming"])
 @pytest.mark.parametrize("capability", possible_capabilities)
@@ -838,15 +873,27 @@ def test_dense_bits(ndim, metric, capability, stats_fixture):
     np.testing.assert_allclose(result, expected, atol=SIMSIMD_ATOL, rtol=SIMSIMD_RTOL)
     collect_errors(metric, ndim, "bin8", accurate, accurate_dt, expected, expected_dt, result, result_dt, stats_fixture)
 
+    # Aside from overriding the `dtype` parameter, we can also view as booleans
+    result_dt, result = profile(simd_kernel, np.packbits(a).view(np.bool_), np.packbits(b).view(np.bool_))
+    result = np.array(result)
+
+    np.testing.assert_allclose(result, expected, atol=SIMSIMD_ATOL, rtol=SIMSIMD_RTOL)
+    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")
-@pytest.mark.repeat(50)
+@pytest.mark.skipif(not numpy_available, reason="NumPy is not installed")
+@pytest.mark.skipif(not scipy_available, reason="SciPy is not installed")
+@pytest.mark.repeat(5)
 @pytest.mark.parametrize("ndim", [11, 97, 1536])
 @pytest.mark.parametrize("dtype", ["float32", "float16"])
 @pytest.mark.parametrize("capability", possible_capabilities)
-def test_jensen_shannon(ndim, dtype, capability):
+def test_jensen_shannon(ndim, dtype, capability, stats_fixture):
     """Compares the simd.jensenshannon() function with scipy.spatial.distance.jensenshannon(), measuring the accuracy error for f16, and f32 types."""
+
     np.random.seed()
+    if dtype == "float16" and is_running_under_qemu():
+        pytest.skip("Testing low-precision math isn't reliable in QEMU")
+
     a = np.abs(np.random.randn(ndim)).astype(dtype)
     b = np.abs(np.random.randn(ndim)).astype(dtype)
     a /= np.sum(a)
@@ -890,7 +937,7 @@ def test_cosine_zero_vector(ndim, dtype, capability):
 
 @pytest.mark.skip(reason="Lacks overflow protection: https://github.com/ashvardanian/SimSIMD/issues/206")  # TODO
 @pytest.mark.skipif(not numpy_available, reason="NumPy is not installed")
-@pytest.mark.repeat(50)
+@pytest.mark.repeat(5)
 @pytest.mark.parametrize("ndim", [11, 97, 1536])
 @pytest.mark.parametrize("dtype", ["float64", "float32", "float16"])
 @pytest.mark.parametrize("metric", ["inner", "euclidean", "sqeuclidean", "cosine"])
@@ -924,7 +971,7 @@ def test_overflow(ndim, dtype, metric, capability):
 
 @pytest.mark.skip(reason="Lacks overflow protection: https://github.com/ashvardanian/SimSIMD/issues/206")  # TODO
 @pytest.mark.skipif(not numpy_available, reason="NumPy is not installed")
-@pytest.mark.repeat(50)
+@pytest.mark.repeat(5)
 @pytest.mark.parametrize("ndim", [131072, 262144])
 @pytest.mark.parametrize("metric", ["inner", "euclidean", "sqeuclidean", "cosine"])
 @pytest.mark.parametrize("capability", possible_capabilities)
@@ -954,16 +1001,15 @@ def test_overflow_i8(ndim, metric, capability):
 
 @pytest.mark.skipif(is_running_under_qemu(), reason="Complex math in QEMU fails")
 @pytest.mark.skipif(not numpy_available, reason="NumPy is not installed")
-@pytest.mark.repeat(50)
-@pytest.mark.parametrize("ndim", [22, 66, 1536])
-@pytest.mark.parametrize("dtype", ["float32", "float64"])
+@pytest.mark.repeat(5)
+@pytest.mark.parametrize("ndim", [11, 97, 1536])
+@pytest.mark.parametrize("dtype", ["complex128", "complex64"])
 @pytest.mark.parametrize("capability", possible_capabilities)
 def test_dot_complex(ndim, dtype, capability, stats_fixture):
     """Compares the simd.dot() and simd.vdot() against NumPy for complex numbers."""
     np.random.seed()
-    dtype_view = np.complex64 if dtype == "float32" else np.complex128
-    a = np.random.randn(ndim).astype(dtype=dtype).view(dtype_view)
-    b = np.random.randn(ndim).astype(dtype=dtype).view(dtype_view)
+    a = (np.random.randn(ndim) + 1.0j * np.random.randn(ndim)).astype(dtype)
+    b = (np.random.randn(ndim) + 1.0j * np.random.randn(ndim)).astype(dtype)
 
     keep_one_capability(capability)
     accurate_dt, accurate = profile(np.dot, a.astype(np.complex128), b.astype(np.complex128))
@@ -972,9 +1018,7 @@ def test_dot_complex(ndim, dtype, capability, stats_fixture):
     result = np.array(result)
 
     np.testing.assert_allclose(result, expected, atol=SIMSIMD_ATOL, rtol=SIMSIMD_RTOL)
-    collect_errors(
-        "dot", ndim, dtype + "c", accurate, accurate_dt, expected, expected_dt, result, result_dt, stats_fixture
-    )
+    collect_errors("dot", ndim, dtype, accurate, accurate_dt, expected, expected_dt, result, result_dt, stats_fixture)
 
     accurate_dt, accurate = profile(np.vdot, a.astype(np.complex128), b.astype(np.complex128))
     expected_dt, expected = profile(np.vdot, a, b)
@@ -982,36 +1026,11 @@ def test_dot_complex(ndim, dtype, capability, stats_fixture):
     result = np.array(result)
 
     np.testing.assert_allclose(result, expected, atol=SIMSIMD_ATOL, rtol=SIMSIMD_RTOL)
-    collect_errors(
-        "vdot", ndim, dtype + "c", accurate, accurate_dt, expected, expected_dt, result, result_dt, stats_fixture
-    )
-
-
-@pytest.mark.skipif(is_running_under_qemu(), reason="Complex math in QEMU fails")
-@pytest.mark.skipif(not numpy_available, reason="NumPy is not installed")
-@pytest.mark.repeat(50)
-@pytest.mark.parametrize("ndim", [22, 66, 1536])
-@pytest.mark.parametrize("capability", possible_capabilities)
-def test_dot_complex_explicit(ndim, capability):
-    """Compares the simd.dot() and simd.vdot() against NumPy for complex numbers."""
-    np.random.seed()
-    a = np.random.randn(ndim).astype(dtype=np.float32)
-    b = np.random.randn(ndim).astype(dtype=np.float32)
-
-    keep_one_capability(capability)
-    expected = np.dot(a.view(np.complex64), b.view(np.complex64))
-    result = simd.dot(a, b, "complex64")
-
-    np.testing.assert_allclose(result, expected, atol=SIMSIMD_ATOL, rtol=SIMSIMD_RTOL)
-
-    expected = np.vdot(a.view(np.complex64), b.view(np.complex64))
-    result = simd.vdot(a, b, "complex64")
-
-    np.testing.assert_allclose(result, expected, atol=SIMSIMD_ATOL, rtol=SIMSIMD_RTOL)
+    collect_errors("vdot", ndim, dtype, accurate, accurate_dt, expected, expected_dt, result, result_dt, stats_fixture)
 
 
 @pytest.mark.skipif(not numpy_available, reason="NumPy is not installed")
-@pytest.mark.repeat(100)
+@pytest.mark.repeat(5)
 @pytest.mark.parametrize("dtype", ["uint16", "uint32"])
 @pytest.mark.parametrize("first_length_bound", [10, 100, 1000])
 @pytest.mark.parametrize("second_length_bound", [10, 100, 1000])
@@ -1041,7 +1060,7 @@ def test_intersect(dtype, first_length_bound, second_length_bound, capability):
 
 
 @pytest.mark.skipif(not numpy_available, reason="NumPy is not installed")
-@pytest.mark.repeat(50)
+@pytest.mark.repeat(5)
 @pytest.mark.parametrize("ndim", [11, 97, 1536])
 @pytest.mark.parametrize("dtype", ["float64", "float32", "float16", "int8", "uint8"])
 @pytest.mark.parametrize("kernel", ["fma"])
@@ -1102,7 +1121,7 @@ def test_fma(ndim, dtype, kernel, capability, stats_fixture):
 
 
 @pytest.mark.skipif(not numpy_available, reason="NumPy is not installed")
-@pytest.mark.repeat(50)
+@pytest.mark.repeat(5)
 @pytest.mark.parametrize("ndim", [11, 97, 1536])
 @pytest.mark.parametrize("dtype", ["float64", "float32", "float16", "int8", "uint8"])
 @pytest.mark.parametrize("kernel", ["wsum"])
@@ -1372,7 +1391,7 @@ def test_cdist_complex(ndim, input_dtype, out_dtype, metric, capability):
 
 @pytest.mark.skipif(not numpy_available, reason="NumPy is not installed")
 @pytest.mark.skipif(not scipy_available, reason="SciPy is not installed")
-@pytest.mark.repeat(50)
+@pytest.mark.repeat(5)
 @pytest.mark.parametrize("ndim", [11, 97, 1536])
 @pytest.mark.parametrize("out_dtype", [None, "float32", "float16", "int8"])
 @pytest.mark.parametrize("capability", possible_capabilities)