usearch 2.21.3 → 2.25.0

package/simsimd/scripts/bench_vectors_live.py

@@ -1,213 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Module: bench_vectors_live.py
-
-This script visualizes the performance difference between SimSIMD and default
-numerics libraries like NumPy and SimSIMD for the most common kernels.
-
-One plot contains information about one distance function, but many data types
-and libraries. For each benchmark, the baseline is the NumPy/SciPy distance function
-applied to `float64` input data. The "x" axis represents the growth in the number of
-dimensions of the input vectors, while the "y" axis represents the speedup factor
-of every kernel against the baseline.
-"""
-import os
-import argparse
-from typing import List
-
-import numpy as np
-
-import perfplot
-
-from bench_vectors import (
-    metric_families,
-    dtype_names,
-    Kernel,
-    yield_kernels,
-    random_matrix,
-)
-
-
-def ndim_argument(value):
-    if value == "default":
-        return [2**k for k in range(16)]
-    try:
-        # Split the input string by commas and convert each part to an integer
-        return [int(x) for x in value.split(",")]
-    except ValueError:
-        raise argparse.ArgumentTypeError("Value must be 'default' or a comma-separated list of integers")
-
-
-def main():
-    # Argument parsing
-    parser = argparse.ArgumentParser(description="Visualize Performance Difference between SimSIMD and other libraries")
-    parser.add_argument(
-        "--ndim-min",
-        type=int,
-        default=2,
-        help="",
-    )
-    parser.add_argument(
-        "--ndim-max",
-        type=int,
-        default=1024 * 1024,
-        help="",
-    )
-    parser.add_argument(
-        "-o",
-        "--output-path",
-        type=str,
-        default=None,
-        help="File to save the plot to (default: None, plot is shown live)",
-    )
-    parser.add_argument(
-        "-n",
-        "--count",
-        type=int,
-        default=1,
-        help="""Number of vectors per batch (default: 1)
-            
-        By default, when set to 1 the benchmark will generate many vectors of size (ndim, )
-        and call the functions on pairs of single vectors: both directly, and through `cdist`.
-        Alternatively, for larger batch sizes the benchmark will generate two matrices of 
-        size (n, ndim) and compute:
-            
-        - batch mode: (n) distances between vectors in identical rows of the two matrices,
-        - all-pairs mode: (n^2) distances between all pairs of vectors in the two matrices via `cdist`.
-        """,
-    )
-    parser.add_argument(
-        "--mode",
-        choices=["batch", "all-pairs"],
-        default="batch",
-        help="""Choose between 'batch' and 'all-pairs' mode (default: batch)
-        
-        In 'batch' mode, the latency will generate two matrices of size (n, ndim) 
-        and compute (n) distances between vectors in identical rows of the two matrices.
-        In 'all-pairs' mode, the latency will generate two matrices of size (n, ndim)
-        and compute (n^2) distances between all pairs of vectors in the two matrices via `cdist`.
-        """,
-    )
-    parser.add_argument(
-        "--metric",
-        choices=metric_families,
-        default="dot",
-        help=f"Distance metric to use, profiles `dot` by default",
-    )
-    parser.add_argument(
-        "--dtype",
-        choices=dtype_names,
-        default="float64",
-        help=f"Defines numeric types to latency, profiles `float64` by default",
-    )
-    parser.add_argument("--scipy", action="store_true", help="Profile SciPy, must be installed")
-    parser.add_argument("--scikit", action="store_true", help="Profile scikit-learn, must be installed")
-    parser.add_argument("--torch", action="store_true", help="Profile PyTorch, must be installed")
-    parser.add_argument("--tf", action="store_true", help="Profile TensorFlow, must be installed")
-    parser.add_argument("--jax", action="store_true", help="Profile JAX, must be installed")
-
-    args = parser.parse_args()
-    assert args.count > 0, "Number of vectors per batch must be greater than 0"
-    assert args.ndim_min > 0, "Number of dimensions must be greater than 0"
-    assert args.ndim_max > 0, "Number of dimensions must be greater than 0"
-
-    ndim_range = [args.ndim_min]
-    while ndim_range[-1] <= args.ndim_max:
-        ndim_range.append(ndim_range[-1] * 2)
-
-    kernels: List[Kernel] = list(
-        yield_kernels(
-            [args.metric],
-            dtype_names,
-            include_scipy=args.scipy,
-            include_scikit=args.scikit,
-            include_torch=args.torch,
-            include_tf=args.tf,
-            include_jax=args.jax,
-        )
-    )
-    if len(kernels) == 0:
-        raise RuntimeError("No kernels found!")
-
-    def precomputed_flops(ndim: int) -> int:
-        if args.mode == "all-pairs":
-            return ndim * (args.count**2)
-        else:
-            return ndim * (args.count)
-
-    def generate_matrix(ndim: int) -> np.ndarray:
-        if args.count == 1:
-            return random_matrix(1, ndim, dtype=args.dtype).flatten()
-        else:
-            return random_matrix(args.count, ndim, dtype=args.dtype)
-
-    def wrap_binary_function(function):
-        def wrapped(A):
-            return function(A, A)
-
-        return wrapped
-
-    kernel_labels: List[str] = []
-    kernel_callables: List[callable] = []
-
-    # Add SimSIMD kernels
-    for kernel in kernels:
-        if not kernel.name.startswith("numpy.") and not kernel.name.startswith("scipy."):
-            continue
-        _, _, function_name = kernel.name.partition(".")
-        kernel_labels.append(f"simsimd.{function_name}<{kernel.dtype}>")
-        if args.mode == "all-pairs":
-            kernel_callables.append(wrap_binary_function(kernel.simsimd_all_pairs_func))
-        else:
-            kernel_callables.append(wrap_binary_function(kernel.simsimd_func))
-
-    # Add other kernels
-    for kernel in kernels:
-        kernel_labels.append(f"{kernel.name}<{kernel.dtype}>")
-        if args.mode == "all-pairs":
-            kernel_callables.append(wrap_binary_function(kernel.baseline_all_pairs_func))
-        elif args.count == 1:
-            kernel_callables.append(wrap_binary_function(kernel.baseline_one_to_one_func))
-        else:
-            kernel_callables.append(wrap_binary_function(kernel.baseline_many_to_many_func))
-
-    # Filter-out kernels that raise any exceptions
-    safe_callables = []
-    safe_labels = []
-    for kernel_label, kernel_callable in zip(kernel_labels, kernel_callables):
-        try:
-            kernel_callable(generate_matrix(ndim_range[0]))
-            safe_callables.append(kernel_callable)
-            safe_labels.append(kernel_label)
-        except:
-            print(f"Skipping {kernel_label}")
-
-    print(safe_callables)
-    print(safe_labels)
-
-    # Settings are mostly the same for live charts and exported ones
-    profiler_settings = dict(
-        setup=generate_matrix,
-        kernels=safe_callables,
-        labels=safe_labels,
-        n_range=ndim_range,
-        flops=precomputed_flops,
-        xlabel="ndim",
-        equality_check=None,  # bypass correctness check, we have tests for that
-    )
-
-    # Plot the results
-    if args.output_path is not None:
-        plot_fp = os.path.abspath(args.output_path)
-        profiler_settings["filename"] = plot_fp
-        profiler_settings["show_progress"] = False
-        results = perfplot.bench(**profiler_settings)
-        results.save(plot_fp, transparent=False, bbox_inches="tight", relative_to=0, logy="auto")
-    else:
-        profiler_settings.pop("flops")
-        perfplot.live(**profiler_settings)
-
-
-if __name__ == "__main__":
-    main()

package/simsimd/scripts/test.c

@@ -1,187 +0,0 @@
-/**
- *  @file   test.c
- *  @brief  Test focusing only on the simplest functionality.
- */
-
-#include <assert.h> // `assert`
-#include <math.h>   // `sqrtf`
-#include <stdio.h>  // `printf`
-
-#define SIMSIMD_NATIVE_F16 0
-#define SIMSIMD_NATIVE_BF16 0
-#include <simsimd/simsimd.h>
-
-/**
- *  @brief  Logs CPU capabilities supported by the current build (compile-time) and runtime.
- */
-void print_capabilities(void) {
-    simsimd_capability_t runtime_caps = simsimd_capabilities();
-
-    // Log supported functionality
-    char const *flags[2] = {"false", "true"};
-    printf("Benchmarking Similarity Measures\n");
-    printf("- Compiler used native F16: %s\n", flags[SIMSIMD_NATIVE_F16]);
-    printf("- Compiler used native BF16: %s\n", flags[SIMSIMD_NATIVE_BF16]);
-    printf("\n");
-    printf("Compile-time settings:\n");
-    printf("- Arm NEON support enabled: %s\n", flags[SIMSIMD_TARGET_NEON]);
-    printf("- Arm SVE support enabled: %s\n", flags[SIMSIMD_TARGET_SVE]);
-    printf("- Arm SVE2 support enabled: %s\n", flags[SIMSIMD_TARGET_SVE2]);
-    printf("- x86 Haswell support enabled: %s\n", flags[SIMSIMD_TARGET_HASWELL]);
-    printf("- x86 Skylake support enabled: %s\n", flags[SIMSIMD_TARGET_SKYLAKE]);
-    printf("- x86 Ice Lake support enabled: %s\n", flags[SIMSIMD_TARGET_ICE]);
-    printf("- x86 Genoa support enabled: %s\n", flags[SIMSIMD_TARGET_GENOA]);
-    printf("- x86 Sapphire Rapids support enabled: %s\n", flags[SIMSIMD_TARGET_SAPPHIRE]);
-    printf("- x86 Turin support enabled: %s\n", flags[SIMSIMD_TARGET_TURIN]);
-    printf("- x86 Sierra Forest support enabled: %s\n", flags[SIMSIMD_TARGET_SIERRA]);
-    printf("\n");
-    printf("Run-time settings:\n");
-    printf("- Arm NEON support enabled: %s\n", flags[(runtime_caps & simsimd_cap_neon_k) != 0]);
-    printf("- Arm NEON F16 support enabled: %s\n", flags[(runtime_caps & simsimd_cap_neon_f16_k) != 0]);
-    printf("- Arm NEON BF16 support enabled: %s\n", flags[(runtime_caps & simsimd_cap_neon_bf16_k) != 0]);
-    printf("- Arm NEON I8 support enabled: %s\n", flags[(runtime_caps & simsimd_cap_neon_i8_k) != 0]);
-    printf("- Arm SVE support enabled: %s\n", flags[(runtime_caps & simsimd_cap_sve_k) != 0]);
-    printf("- Arm SVE F16 support enabled: %s\n", flags[(runtime_caps & simsimd_cap_sve_f16_k) != 0]);
-    printf("- Arm SVE BF16 support enabled: %s\n", flags[(runtime_caps & simsimd_cap_sve_bf16_k) != 0]);
-    printf("- Arm SVE I8 support enabled: %s\n", flags[(runtime_caps & simsimd_cap_sve_i8_k) != 0]);
-    printf("- Arm SVE2 support enabled: %s\n", flags[(runtime_caps & simsimd_cap_sve2_k) != 0]);
-    printf("- x86 Haswell support enabled: %s\n", flags[(runtime_caps & simsimd_cap_haswell_k) != 0]);
-    printf("- x86 Skylake support enabled: %s\n", flags[(runtime_caps & simsimd_cap_skylake_k) != 0]);
-    printf("- x86 Ice Lake support enabled: %s\n", flags[(runtime_caps & simsimd_cap_ice_k) != 0]);
-    printf("- x86 Genoa support enabled: %s\n", flags[(runtime_caps & simsimd_cap_genoa_k) != 0]);
-    printf("- x86 Sapphire Rapids support enabled: %s\n", flags[(runtime_caps & simsimd_cap_sapphire_k) != 0]);
-    printf("- x86 Turin support enabled: %s\n", flags[(runtime_caps & simsimd_cap_turin_k) != 0]);
-    printf("\n");
-}
-
-/**
- *  @brief  A trivial test that checks if the utility functions return the expected values.
- */
-void test_utilities(void) {
-    simsimd_capability_t capabilities = simsimd_capabilities();
-
-    int uses_neon = simsimd_uses_neon();
-    int uses_sve = simsimd_uses_sve();
-    int uses_haswell = simsimd_uses_haswell();
-    int uses_skylake = simsimd_uses_skylake();
-    int uses_ice = simsimd_uses_ice();
-    int uses_genoa = simsimd_uses_genoa();
-    int uses_sapphire = simsimd_uses_sapphire();
-    int uses_turin = simsimd_uses_turin();
-    int uses_sierra = simsimd_uses_sierra();
-
-    assert(uses_neon == ((capabilities & simsimd_cap_neon_k) != 0));
-    assert(uses_sve == ((capabilities & simsimd_cap_sve_k) != 0));
-    assert(uses_haswell == ((capabilities & simsimd_cap_haswell_k) != 0));
-    assert(uses_skylake == ((capabilities & simsimd_cap_skylake_k) != 0));
-    assert(uses_ice == ((capabilities & simsimd_cap_ice_k) != 0));
-    assert(uses_genoa == ((capabilities & simsimd_cap_genoa_k) != 0));
-    assert(uses_sapphire == ((capabilities & simsimd_cap_sapphire_k) != 0));
-    assert(uses_turin == ((capabilities & simsimd_cap_turin_k) != 0));
-    assert(uses_sierra == ((capabilities & simsimd_cap_sierra_k) != 0));
-}
-
-/**
- *  @brief  A trivial test that calls every implemented distance function and their dispatch versions
- *          on vectors A and B, where A and B are equal.
- */
-void test_distance_from_itself(void) {
-    simsimd_f64_t f64s[1536];
-    simsimd_f32_t f32s[1536];
-    simsimd_f16_t f16s[1536];
-    simsimd_bf16_t bf16s[1536];
-
-    simsimd_f64c_t f64cs[768];
-    simsimd_f32c_t f32cs[768];
-    simsimd_f16c_t f16cs[768];
-    simsimd_bf16c_t bf16cs[768];
-
-    simsimd_i8_t i8s[1536];
-    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[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[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_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_bf16c(bf16cs, bf16cs, 768, &distance[0]);
-    simsimd_dot_f16c(f16cs, f16cs, 768, &distance[0]);
-    simsimd_dot_f32c(f32cs, f32cs, 768, &distance[0]);
-    simsimd_dot_f64c(f64cs, f64cs, 768, &distance[0]);
-
-    // Complex conjugate inner product between two vectors
-    simsimd_vdot_bf16c(bf16cs, bf16cs, 768, &distance[0]);
-    simsimd_vdot_f16c(f16cs, f16cs, 768, &distance[0]);
-    simsimd_vdot_f32c(f32cs, f32cs, 768, &distance[0]);
-    simsimd_vdot_f64c(f64cs, f64cs, 768, &distance[0]);
-
-    // Hamming distance between two vectors
-    simsimd_hamming_b8(b8s, b8s, 1536 / 8, &distance[0]);
-
-    // Jaccard distance between two vectors
-    simsimd_jaccard_b8(b8s, b8s, 1536 / 8, &distance[0]);
-
-    // Jensen-Shannon divergence between two vectors
-    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[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]);
-}
-
-/**
- *  @brief Test whether denormals are being flushed to zero or not.
- *
- *  We create subnormal float values, do a small computation (multiplication),
- *  and classify the result. If flush-to-zero @b (FTZ) is enabled, the result is
- *  likely zero. Otherwise, you may see another subnormal or normal number.
- */
-static void test_denormals(void) {
-
-    // Create two subnormal floats:
-    // 1e-40 ~ 1.0 * 10^-40 is typically a subnormal in IEEE-754 single precision
-    float subnorm1 = 1e-40f;
-    float subnorm2 = 2e-40f;
-    float result = subnorm1 * subnorm2; // This might be subnormal, zero, or normal
-    int classification = fpclassify(result);
-    if (classification == FP_SUBNORMAL) { printf("Denormal test: result is subnormal: %.8g\n", result); }
-    else if (result == 0.0f) { printf("Denormal test: result is zero (denormals likely flushed).\n"); }
-    else if (classification == FP_NORMAL) { printf("Denormal test: result is normal: %.8g\n", result); }
-    else { printf("Denormal test: result has unexpected classification.\n"); }
-}
-
-int main(int argc, char **argv) {
-
-    print_capabilities();
-    test_utilities();
-    test_distance_from_itself();
-    test_denormals();
-    return 0;
-}

package/simsimd/scripts/test.mjs

@@ -1,220 +0,0 @@
-// Currently the builds are expected to run only on Node.js,
-// but Deno tests pass as well.
-//
-// Bun supports `node:assert`, but not `node:test`.
-// Using `require` we can make the tests compatible with Bun.
-//
-//    const isBun = typeof Bun !== "undefined";
-//    let assert, test;
-//    if (isBun) {
-//      assert = require('node:assert');
-//      test = require('bun:test');
-//    } else {
-//      assert = require('node:assert');
-//      test = require('node:test');
-//    }
-//
-// That, however, leads to other issues, like the following:
-//
-//    require is not defined in ES module scope, you can use import instead
-//
-// https://bun.sh/docs/runtime/nodejs-apis
-// https://bun.sh/guides/util/detect-bun
-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) {
-  const lowerBound = expected - tolerance;
-  const upperBound = expected + tolerance;
-  assert(
-    actual >= lowerBound && actual <= upperBound,
-    `Expected ${actual} to be almost equal to ${expected}`
-  );
-}
-
-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 / 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 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);
-  assertAlmostEqual(fallback.hamming(u8s, u8s), 0.0, 0.01);
-  assertAlmostEqual(fallback.jaccard(u8s, u8s), 0.0, 0.01);
-});
-
-
-test("Squared Euclidean Distance", () => {
-  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 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);
-});