usearch 2.21.2 → 2.21.3

package/README.md

@@ -552,7 +552,7 @@ doi = {10.5281/zenodo.7949416},
 author = {Vardanian, Ash},
 title = {{USearch by Unum Cloud}},
 url = {https://github.com/unum-cloud/usearch},
-version = {2.21.2},
+version = {2.21.3},
 year = {2023},
 month = oct,
 }

package/include/usearch/index.hpp

@@ -9,7 +9,7 @@
 
 #define USEARCH_VERSION_MAJOR 2
 #define USEARCH_VERSION_MINOR 21
-#define USEARCH_VERSION_PATCH 2
+#define USEARCH_VERSION_PATCH 3
 
 // Inferring C++ version
 // https://stackoverflow.com/a/61552074

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "usearch",
-    "version": "2.21.2",
+    "version": "2.21.3",
     "description": "Smaller & Faster Single-File Vector Search Engine from Unum",
     "author": "Ash Vardanian (https://ashvardanian.com/)",
     "license": "Apache 2.0",

package/simsimd/CONTRIBUTING.md

@@ -49,7 +49,7 @@ sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-12 100
 sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-12 100
 ```
 
-To compile with the default Apple Clang on MacOS, use:
+To compile with the default Apple Clang on macOS, use:
 
 ```sh
 brew install openblas
@@ -63,8 +63,8 @@ cmake -D CMAKE_BUILD_TYPE=Release \
 cmake --build build_release --config Release
 ```
 
-On MacOS it's recommended to use Homebrew and install Clang, as opposed to "Apple Clang".
-Replacing the default compiler across the entire system is not recommended on MacOS, as it may break the system, but you can pass it as an environment variable:
+On macOS it's recommended to use Homebrew and install Clang, as opposed to "Apple Clang".
+Replacing the default compiler across the entire system is not recommended on macOS, as it may break the system, but you can pass it as an environment variable:
 
 ```sh
 brew install llvm openblas
@@ -124,7 +124,7 @@ Here, `-s` will output the logs.
 The `-x` will stop on the first failure.
 The `-Wd` will silence overflows and runtime warnings.
 
-When building on MacOS, same as with C/C++, use non-Apple Clang version:
+When building on macOS, same as with C/C++, use non-Apple Clang version:
 
 ```sh
 brew install llvm
@@ -174,7 +174,7 @@ $ python scripts/bench_vectors.py --help
 
 
 Before merging your changes you may want to test your changes against the entire matrix of Python versions USearch supports.
-For that you need the `cibuildwheel`, which is tricky to use on MacOS and Windows, as it would target just the local environment.
+For that you need the `cibuildwheel`, which is tricky to use on macOS and Windows, as it would target just the local environment.
 Still, if you have Docker running on any desktop OS, you can use it to build and test the Python bindings for all Python versions for Linux:
 
 ```sh
@@ -184,7 +184,7 @@ cibuildwheel --platform linux                   # works on any OS and builds all
 cibuildwheel --platform linux --archs x86_64    # 64-bit x86, the most common on desktop and servers
 cibuildwheel --platform linux --archs aarch64   # 64-bit Arm for mobile devices, Apple M-series, and AWS Graviton
 cibuildwheel --platform linux --archs i686      # 32-bit Linux
-cibuildwheel --platform macos                   # works only on MacOS
+cibuildwheel --platform macos                   # works only on macOS
 cibuildwheel --platform windows                 # works only on Windows
 ```
 
@@ -194,7 +194,7 @@ You may need root privileges for multi-architecture builds:
 sudo $(which cibuildwheel) --platform linux
 ```
 
-On Windows and MacOS, to avoid frequent path resolution issues, you may want to use:
+On Windows and macOS, to avoid frequent path resolution issues, you may want to use:
 
 ```sh
 python -m cibuildwheel --platform windows
@@ -209,6 +209,13 @@ cargo bench
 open target/criterion/report/index.html
 ```
 
+To automatically detect the Minimum Supported Rust Version (MSRV):
+
+```sh
+cargo +stable install cargo-msrv
+cargo msrv find --ignore-lockfile
+```
+
 ## JavaScript
 
 ### NodeJS
@@ -217,7 +224,7 @@ If you don't have the environment configured, here are the [installation options
 
 ```sh
 wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash # Linux
-curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash  # MacOS
+curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash  # macOS
 ```
 
 Install dependencies:
@@ -242,7 +249,7 @@ If you don't have the environment configured, here are [installation options](ht
 
 ```sh
 wget -qO- https://deno.land/x/install/install.sh | sh # Linux
-curl -fsSL https://deno.land/install.sh | sh          # MacOS
+curl -fsSL https://deno.land/install.sh | sh          # macOS
 irm https://deno.land/install.ps1 | iex               # Windows
 ```
 

package/simsimd/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "simsimd"
 description = "Portable mixed-precision BLAS-like vector math library for x86 and ARM"
-version = "6.5.1"
+version = "6.5.5"
 edition = "2021"
 license = "Apache-2.0"
 authors = ["Ash Vardanian <1983160+ashvardanian@users.noreply.github.com>"]
@@ -16,7 +16,8 @@ categories = [
   "wasm",
   "external-ffi-bindings",
 ]
-include = ["/rust/**", "/c/**", "/include/**", "/build.rs"]
+rust-version = "1.64" # Introduced Core C FFI in stable Rust
+include = ["rust/**", "c/**", "include/**", "build.rs"]
 
 
 [lib]
@@ -24,18 +25,13 @@ name = "simsimd"
 path = "rust/lib.rs"
 
 [build-dependencies]
-cc = "1.0.83"
+cc = "1.2.36"
 
 
 [[bench]]
-name = "cosine"
+name = "bench"
 harness = false
-path = "scripts/bench_cosine.rs"
-
-[[bench]]
-name = "sqeuclidean"
-harness = false
-path = "scripts/bench_sqeuclidean.rs"
+path = "scripts/bench.rs"
 
 [profile.bench]
 opt-level = 3     # Corresponds to -O3
@@ -48,6 +44,6 @@ default = []
 std = []
 
 [dev-dependencies]
-criterion = { version = "0.6.0" }
+criterion = { version = "0.7.0" }
 rand = { version = "0.9.1" }
 half = { version = "2.6.0" }

package/simsimd/MANIFEST.in

@@ -1,3 +1,4 @@
 include include/simsimd/*.h
 include include/*
+include scripts/test.py
 include VERSION

package/simsimd/README.md

@@ -1,6 +1,6 @@
 ![SimSIMD banner](https://github.com/ashvardanian/ashvardanian/blob/master/repositories/SimSIMD.jpg?raw=true)
 
-Computing dot-products, similarity measures, and distances between low- and high-dimensional vectors is ubiquitous in Machine Learning, Scientific Computing, Geo-Spatial Analysis, and Information Retrieval.
+Computing dot-products, similarity measures, and distances between low- and high-dimensional vectors is ubiquitous in Machine Learning, Scientific Computing, Geospatial Analysis, and Information Retrieval.
 These algorithms generally have linear complexity in time, constant or linear complexity in space, and are data-parallel.
 In other words, it is easily parallelizable and vectorizable and often available in packages like BLAS (level 1) and LAPACK, as well as higher-level `numpy` and `scipy` Python libraries.
 Ironically, even with decades of evolution in compilers and numerical computing, [most libraries can be 3-200x slower than hardware potential][benchmarks] even on the most popular hardware, like 64-bit x86 and Arm CPUs.
@@ -32,7 +32,7 @@ SimSIMD provides an alternative.
     <img alt="GitHub Actions Windows" src="https://img.shields.io/github/actions/workflow/status/ashvardanian/SimSIMD/release.yml?branch=main&label=Windows&logo=windows&color=blue">
 </a>
 <a href="https://github.com/ashvardanian/SimSIMD/actions/workflows/release.yml">
-    <img alt="GitHub Actions MacOS" src="https://img.shields.io/github/actions/workflow/status/ashvardanian/SimSIMD/release.yml?branch=main&label=MacOS&logo=apple&color=blue">
+    <img alt="GitHub Actions macOS" src="https://img.shields.io/github/actions/workflow/status/ashvardanian/SimSIMD/release.yml?branch=main&label=macOS&logo=apple&color=blue">
 </a>
 <a href="https://github.com/ashvardanian/SimSIMD/actions/workflows/release.yml">
     <img alt="GitHub Actions CentOS Linux" src="https://img.shields.io/github/actions/workflow/status/ashvardanian/SimSIMD/release.yml?branch=main&label=CentOS&logo=centos&color=blue">
@@ -43,7 +43,7 @@ SimSIMD provides an alternative.
 ## Features
 
 __SimSIMD__ (Arabic: "سيمسيم دي") is a mixed-precision math library of __over 350 SIMD-optimized kernels__ extensively used in AI, Search, and DBMS workloads.
-Named after the iconic ["Open Sesame"](https://en.wikipedia.org/wiki/Open_sesame) command that opened doors to treasure in _Ali Baba and the Forty Thieves_, SimSimd can help you 10x the cost-efficiency of your computational pipelines.
+Named after the iconic ["Open Sesame"](https://en.wikipedia.org/wiki/Open_sesame) command that opened doors to treasure in _Ali Baba and the Forty Thieves_, SimSIMD can help you 10x the cost-efficiency of your computational pipelines.
 Implemented distance functions include:
 
 - Euclidean (L2) and Cosine (Angular) spatial distances for Vector Search. _[docs][docs-spatial]_
@@ -85,7 +85,7 @@ You can learn more about the technical implementation details in the following b
 
 - [Uses Horner's method for polynomial approximations, beating GCC 12 by 119x](https://ashvardanian.com/posts/gcc-12-vs-avx512fp16/).
 - [Uses Arm SVE and x86 AVX-512's masked loads to eliminate tail `for`-loops](https://ashvardanian.com/posts/simsimd-faster-scipy/#tails-of-the-past-the-significance-of-masked-loads).
-- [Substitutes LibC's `sqrt` with Newton Raphson iterations](https://github.com/ashvardanian/SimSIMD/releases/tag/v5.4.0).
+- [Substitutes libc's `sqrt` with Newton Raphson iterations](https://github.com/ashvardanian/SimSIMD/releases/tag/v5.4.0).
 - [Uses Galloping and SVE2 histograms to intersect sparse vectors](https://ashvardanian.com/posts/simd-set-intersections-sve2-avx512/).
 - For Python: [avoids slow PyBind11, SWIG, & `PyArg_ParseTuple`](https://ashvardanian.com/posts/pybind11-cpython-tutorial/) [using faster calling convention](https://ashvardanian.com/posts/discount-on-keyword-arguments-in-python/).
 - For JavaScript: [uses typed arrays and NAPI for zero-copy calls](https://ashvardanian.com/posts/javascript-ai-vector-search/).
@@ -625,13 +625,13 @@ fn main() {
     let vector_a: Vec<f32> = vec![1.0, 2.0, 3.0];
     let vector_b: Vec<f32> = vec![4.0, 5.0, 6.0];
 
-    // Compute the cosine similarity between vector_a and vector_b
-    let cosine_similarity = f32::cosine(&vector_a, &vector_b)
+    // Compute the cosine distance between vectors
+    let cosine_distance = f32::cosine(&vector_a, &vector_b)
         .expect("Vectors must be of the same length");
 
-    println!("Cosine Similarity: {}", cosine_similarity);
+    println!("Cosine Distance: {}", cosine_distance);
 
-    // Compute the squared Euclidean distance between vector_a and vector_b
+    // Compute the squared Euclidean distance between vectors
     let sq_euclidean_distance = f32::sqeuclidean(&vector_a, &vector_b)
         .expect("Vectors must be of the same length");
 
@@ -648,16 +648,17 @@ use simsimd::SpatialSimilarity;
 use simsimd::ComplexProducts;
 
 fn main() {
+    // Complex vectors have interleaved real & imaginary components
     let vector_a: Vec<f32> = vec![1.0, 2.0, 3.0, 4.0];
     let vector_b: Vec<f32> = vec![5.0, 6.0, 7.0, 8.0];
 
-    // Compute the inner product between vector_a and vector_b
+    // Compute the inner product between vectors
     let inner_product = SpatialSimilarity::dot(&vector_a, &vector_b)
         .expect("Vectors must be of the same length");
 
     println!("Inner Product: {}", inner_product);
 
-    // Compute the complex inner product between complex_vector_a and complex_vector_b
+    // Compute the complex inner product between vectors
     let complex_inner_product = ComplexProducts::dot(&vector_a, &vector_b)
         .expect("Vectors must be of the same length");
 
@@ -705,13 +706,13 @@ fn main() {
     let vector_a = &[0b11110000, 0b00001111, 0b10101010];
     let vector_b = &[0b11110000, 0b00001111, 0b01010101];
 
-    // Compute the Hamming distance between vector_a and vector_b
+    // Compute the Hamming distance between vectors
     let hamming_distance = u8::hamming(&vector_a, &vector_b)
         .expect("Vectors must be of the same length");
 
     println!("Hamming Distance: {}", hamming_distance);
 
-    // Compute the Jaccard distance between vector_a and vector_b
+    // Compute the Jaccard distance between vectors
     let jaccard_distance = u8::jaccard(&vector_a, &vector_b)
         .expect("Vectors must be of the same length");
 
@@ -734,11 +735,11 @@ fn main() {
     let vector_a: Vec<f16> = vec![1.0, 2.0, 3.0].iter().map(|&x| f16::from_f32(x)).collect();
     let vector_b: Vec<f16> = vec![4.0, 5.0, 6.0].iter().map(|&x| f16::from_f32(x)).collect();
 
-    // Compute the cosine similarity
-    let cosine_similarity = f16::cosine(&vector_a, &vector_b)
+    // Compute the cosine distance
+    let cosine_distance = f16::cosine(&vector_a, &vector_b)
         .expect("Vectors must be of the same length");
     
-    println!("Cosine Similarity: {}", cosine_similarity);
+    println!("Cosine Distance: {}", cosine_distance);
 
     // Direct bit manipulation
     let half = f16::from_f32(3.14159);
@@ -764,10 +765,10 @@ fn main() {
     let buffer_a: &[SimF16] = unsafe { std::slice::from_raw_parts(vector_a.as_ptr() as *const SimF16, vector_a.len()) };
     let buffer_b: &[SimF16] = unsafe { std::slice::from_raw_parts(vector_b.as_ptr() as *const SimF16, vector_b.len()) };
 
-    let cosine_similarity = SimF16::cosine(buffer_a, buffer_b)
+    let cosine_distance = SimF16::cosine(buffer_a, buffer_b)
         .expect("Vectors must be of the same length");
 
-    println!("Cosine Similarity: {}", cosine_similarity);
+    println!("Cosine Distance: {}", cosine_distance);
 }
 ```
 
@@ -787,10 +788,10 @@ fn main() {
     let vector_b: Vec<bf16> = vec![4.0, 5.0, 6.0].iter().map(|&x| bf16::from_f32(x)).collect();
 
     // Compute the cosine similarity
-    let cosine_similarity = bf16::cosine(&vector_a, &vector_b)
+    let cosine_distance = bf16::cosine(&vector_a, &vector_b)
         .expect("Vectors must be of the same length");
     
-    println!("Cosine Similarity: {}", cosine_similarity);
+    println!("Cosine Distance: {}", cosine_distance);
 
     // Direct bit manipulation
     let brain_half = bf16::from_f32(3.14159);
@@ -899,8 +900,8 @@ import SimSIMD
 let vectorA: [Int8] = [1, 2, 3]
 let vectorB: [Int8] = [4, 5, 6]
 
-let cosineSimilarity = vectorA.cosine(vectorB)  // Computes the cosine similarity
 let dotProduct = vectorA.dot(vectorB)           // Computes the dot product
+let cosineDistance = vectorA.cosine(vectorB)    // Computes the cosine distance
 let sqEuclidean = vectorA.sqeuclidean(vectorB)  // Computes the squared Euclidean distance
 ```
 

package/simsimd/build.rs

@@ -2,14 +2,15 @@ fn main() -> Result<(), cc::Error> {
     let mut build = cc::Build::new();
 
     build
+        // Prefer portable flags to support MSVC and older toolchains
+        .std("c99") // Enforce C99 standard when supported
         .file("c/lib.c")
         .include("include")
         .define("SIMSIMD_NATIVE_F16", "0")
         .define("SIMSIMD_NATIVE_BF16", "0")
         .define("SIMSIMD_DYNAMIC_DISPATCH", "1")
-        .flag("-O3")
-        .flag("-std=c99") // Enforce C99 standard
-        .flag("-pedantic") // Ensure strict compliance with the C standard
+        .opt_level(3)
+        .flag_if_supported("-pedantic") // Strict compliance when supported
         .warnings(false);
 
     if let Err(e) = build.try_compile("simsimd") {

package/simsimd/c/lib.c

@@ -18,7 +18,7 @@
  *
  *  - Linux: everything is available in GCC 12+ and Clang 16+.
  *  - Windows - MSVC: everything except Sapphire Rapids and ARM SVE.
- *  - MacOS - Apple Clang: only Arm NEON and x86 AVX2 Haswell extensions are available.
+ *  - macOS - Apple Clang: only Arm NEON and x86 AVX2 Haswell extensions are available.
  */
 #if !defined(SIMSIMD_TARGET_NEON) && (defined(__APPLE__) || defined(__linux__))
 #define SIMSIMD_TARGET_NEON 1

package/simsimd/include/simsimd/binary.h

@@ -5,8 +5,9 @@
  *  @date       July 1, 2023
  *
  *  Contains:
- *  - Hamming distance
- *  - Jaccard similarity (Tanimoto coefficient)
+ *  - Bit-level Hamming distance
+ *  - Bit-level Jaccard distance (Tanimoto coefficient)
+ *  - TODO: Hamming distance for integer vectors - `u16`, `u32`
  *
  *  For hardware architectures:
  *  - Arm: NEON, SVE
@@ -19,7 +20,7 @@
  *  - Lookup tables, mostly using nibbles (4-bit lookups)
  *  - Harley-Seal population counts: https://arxiv.org/pdf/1611.07612
  *
- *  On binary vectors, when computing Jaccard similarity we can clearly see how the CPU struggles
+ *  On binary vectors, when computing Jaccard distance we can clearly see how the CPU struggles
  *  to compute that many population counts. There are several instructions we should keep in mind
  *  for future optimizations:
  *
@@ -55,23 +56,23 @@ extern "C" {
 
 // clang-format off
 
-/*  Serial backends for bitsets. */
+/*  Serial backends for bitsets and integers. */
 SIMSIMD_PUBLIC void simsimd_hamming_b8_serial(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words, simsimd_distance_t* distance);
 SIMSIMD_PUBLIC void simsimd_jaccard_b8_serial(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words, simsimd_distance_t* distance);
 
-/*  Arm NEON backend for bitsets. */
+/*  Arm NEON backend for bitsets and integers. */
 SIMSIMD_PUBLIC void simsimd_hamming_b8_neon(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words, simsimd_distance_t* distance);
 SIMSIMD_PUBLIC void simsimd_jaccard_b8_neon(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words, simsimd_distance_t* distance);
 
-/*  Arm SVE backend for bitsets. */
+/*  Arm SVE backend for bitsets and integers. */
 SIMSIMD_PUBLIC void simsimd_hamming_b8_sve(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words, simsimd_distance_t* distance);
 SIMSIMD_PUBLIC void simsimd_jaccard_b8_sve(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words, simsimd_distance_t* distance);
 
-/*  x86 AVX2 backend for bitsets for Intel Haswell CPUs and newer, needs only POPCNT extensions. */
+/*  x86 AVX2 backend for bitsets and integers for Intel Haswell CPUs and newer, needs only POPCNT extensions. */
 SIMSIMD_PUBLIC void simsimd_hamming_b8_haswell(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words, simsimd_distance_t* distance);
 SIMSIMD_PUBLIC void simsimd_jaccard_b8_haswell(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words, simsimd_distance_t* distance);
 
-/*  x86 AVX512 backend for bitsets for Intel Ice Lake CPUs and newer, using VPOPCNTDQ extensions. */
+/*  x86 AVX512 backend for bitsets and integers for Intel Ice Lake CPUs and newer, using VPOPCNTDQ extensions. */
 SIMSIMD_PUBLIC void simsimd_hamming_b8_ice(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words, simsimd_distance_t* distance);
 SIMSIMD_PUBLIC void simsimd_jaccard_b8_ice(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words, simsimd_distance_t* distance);
 // clang-format on
@@ -91,14 +92,14 @@ SIMSIMD_PUBLIC unsigned char simsimd_popcount_b8(simsimd_b8_t x) {
 
 SIMSIMD_PUBLIC void simsimd_hamming_b8_serial(simsimd_b8_t const *a, simsimd_b8_t const *b, simsimd_size_t n_words,
                                               simsimd_distance_t *result) {
-    simsimd_i32_t differences = 0;
+    simsimd_u32_t differences = 0;
     for (simsimd_size_t i = 0; i != n_words; ++i) differences += simsimd_popcount_b8(a[i] ^ b[i]);
     *result = differences;
 }
 
 SIMSIMD_PUBLIC void simsimd_jaccard_b8_serial(simsimd_b8_t const *a, simsimd_b8_t const *b, simsimd_size_t n_words,
                                               simsimd_distance_t *result) {
-    simsimd_i32_t intersection = 0, union_ = 0;
+    simsimd_u32_t intersection = 0, union_ = 0;
     for (simsimd_size_t i = 0; i != n_words; ++i)
         intersection += simsimd_popcount_b8(a[i] & b[i]), union_ += simsimd_popcount_b8(a[i] | b[i]);
     *result = (union_ != 0) ? 1 - (simsimd_f64_t)intersection / (simsimd_f64_t)union_ : 1;

package/simsimd/include/simsimd/dot.h

@@ -545,7 +545,7 @@ SIMSIMD_PUBLIC void simsimd_dot_bf16_neon(simsimd_bf16_t const *a_scalars, simsi
     float32x4_t ab_vec = vdupq_n_f32(0);
 
 simsimd_dot_bf16_neon_cycle:
-    if (count_scalars < 4) {
+    if (count_scalars < 8) {
         a_vec = _simsimd_partial_load_bf16x8_neon(a_scalars, count_scalars);
         b_vec = _simsimd_partial_load_bf16x8_neon(b_scalars, count_scalars);
         count_scalars = 0;
@@ -553,7 +553,7 @@ simsimd_dot_bf16_neon_cycle:
     else {
         a_vec = vld1q_bf16((simsimd_bf16_for_arm_simd_t const *)a_scalars);
         b_vec = vld1q_bf16((simsimd_bf16_for_arm_simd_t const *)b_scalars);
-        a_scalars += 4, b_scalars += 4, count_scalars -= 4;
+        a_scalars += 8, b_scalars += 8, count_scalars -= 8;
     }
     ab_vec = vbfdotq_f32(ab_vec, a_vec, b_vec);
     if (count_scalars) goto simsimd_dot_bf16_neon_cycle;
@@ -1163,7 +1163,7 @@ SIMSIMD_PUBLIC void simsimd_dot_i8_haswell(simsimd_i8_t const *a_scalars, simsim
         __m256i b_i16_low_vec = _mm256_cvtepi8_epi16(_mm256_extracti128_si256(b_i8_vec, 0));
         __m256i b_i16_high_vec = _mm256_cvtepi8_epi16(_mm256_extracti128_si256(b_i8_vec, 1));
 
-        // Multiply and accumulate at int16 level, accumulate at `int32` level
+        // Multiply and accumulate at `int16` level, accumulate at `int32` level
         ab_i32_low_vec = _mm256_add_epi32(ab_i32_low_vec, _mm256_madd_epi16(a_i16_low_vec, b_i16_low_vec));
         ab_i32_high_vec = _mm256_add_epi32(ab_i32_high_vec, _mm256_madd_epi16(a_i16_high_vec, b_i16_high_vec));
     }
@@ -1197,7 +1197,7 @@ SIMSIMD_PUBLIC void simsimd_dot_u8_haswell(simsimd_u8_t const *a_scalars, simsim
         __m256i b_i16_low_vec = _mm256_unpacklo_epi8(b_u8_vec, zeros_vec);
         __m256i b_i16_high_vec = _mm256_unpackhi_epi8(b_u8_vec, zeros_vec);
 
-        // Multiply and accumulate at int16 level, accumulate at int32 level
+        // Multiply and accumulate at `int16` level, accumulate at `int32` level
         ab_i32_low_vec = _mm256_add_epi32(ab_i32_low_vec, _mm256_madd_epi16(a_i16_low_vec, b_i16_low_vec));
         ab_i32_high_vec = _mm256_add_epi32(ab_i32_high_vec, _mm256_madd_epi16(a_i16_high_vec, b_i16_high_vec));
     }

package/simsimd/include/simsimd/geospatial.h

@@ -1,6 +1,6 @@
 /**
  *  @file       geospatial.h
- *  @brief      SIMD-accelerated Geo-Spatial distance functions.
+ *  @brief      SIMD-accelerated Geospatial distance functions.
  *  @author     Ash Vardanian
  *  @date       July 1, 2023
  *

package/simsimd/include/simsimd/mesh.h

@@ -15,7 +15,7 @@
  *  - 16-bit brain-floating point
  *
  *  For hardware architectures:
- *  - Arm: Neon
+ *  - Arm: NEON
  *  - x86: Genoa, Sapphire
  *
  *  x86 intrinsics: https://www.intel.com/content/www/us/en/docs/intrinsics-guide/

package/simsimd/include/simsimd/probability.h

@@ -389,11 +389,9 @@ simsimd_js_f16_haswell_cycle:
         b_vec = _mm256_cvtph_ps(_mm_lddqu_si128((__m128i const *)b));
         n -= 8, a += 8, b += 8;
     }
-    a_vec = _mm256_add_ps(a_vec, epsilon_vec);
-    b_vec = _mm256_add_ps(b_vec, epsilon_vec);
     __m256 m_vec = _mm256_mul_ps(_mm256_add_ps(a_vec, b_vec), _mm256_set1_ps(0.5f)); // M = (P + Q) / 2
-    __m256 ratio_a_vec = _mm256_div_ps(a_vec, m_vec);
-    __m256 ratio_b_vec = _mm256_div_ps(b_vec, m_vec);
+    __m256 ratio_a_vec = _mm256_div_ps(_mm256_add_ps(a_vec, epsilon_vec), _mm256_add_ps(m_vec, epsilon_vec));
+    __m256 ratio_b_vec = _mm256_div_ps(_mm256_add_ps(b_vec, epsilon_vec), _mm256_add_ps(m_vec, epsilon_vec));
     __m256 log_ratio_a_vec = _simsimd_log2_f32_haswell(ratio_a_vec);
     __m256 log_ratio_b_vec = _simsimd_log2_f32_haswell(ratio_b_vec);
     __m256 prod_a_vec = _mm256_mul_ps(a_vec, log_ratio_a_vec);
@@ -487,13 +485,14 @@ simsimd_js_f32_skylake_cycle:
     __mmask16 nonzero_mask_a = _mm512_cmp_ps_mask(a_vec, epsilon_vec, _CMP_GE_OQ);
     __mmask16 nonzero_mask_b = _mm512_cmp_ps_mask(b_vec, epsilon_vec, _CMP_GE_OQ);
     __mmask16 nonzero_mask = nonzero_mask_a & nonzero_mask_b;
-    __m512 m_recip_approx = _mm512_rcp14_ps(m_vec);
-    __m512 ratio_a_vec = _mm512_mul_ps(a_vec, m_recip_approx);
-    __m512 ratio_b_vec = _mm512_mul_ps(b_vec, m_recip_approx);
+    __m512 m_with_epsilon = _mm512_add_ps(m_vec, epsilon_vec);
+    __m512 m_recip_approx = _mm512_rcp14_ps(m_with_epsilon);
+    __m512 ratio_a_vec = _mm512_mul_ps(_mm512_add_ps(a_vec, epsilon_vec), m_recip_approx);
+    __m512 ratio_b_vec = _mm512_mul_ps(_mm512_add_ps(b_vec, epsilon_vec), m_recip_approx);
     __m512 log_ratio_a_vec = _simsimd_log2_f32_skylake(ratio_a_vec);
     __m512 log_ratio_b_vec = _simsimd_log2_f32_skylake(ratio_b_vec);
-    sum_a_vec = _mm512_maskz_fmadd_ps(nonzero_mask, a_vec, log_ratio_a_vec, sum_a_vec);
-    sum_b_vec = _mm512_maskz_fmadd_ps(nonzero_mask, b_vec, log_ratio_b_vec, sum_b_vec);
+    sum_a_vec = _mm512_mask3_fmadd_ps(a_vec, log_ratio_a_vec, sum_a_vec, nonzero_mask);
+    sum_b_vec = _mm512_mask3_fmadd_ps(b_vec, log_ratio_b_vec, sum_b_vec, nonzero_mask);
     if (n) goto simsimd_js_f32_skylake_cycle;
 
     simsimd_f32_t log2_normalizer = 0.693147181f;
@@ -579,13 +578,14 @@ simsimd_js_f16_sapphire_cycle:
     __mmask32 nonzero_mask_a = _mm512_cmp_ph_mask(a_vec, epsilon_vec, _CMP_GE_OQ);
     __mmask32 nonzero_mask_b = _mm512_cmp_ph_mask(b_vec, epsilon_vec, _CMP_GE_OQ);
     __mmask32 nonzero_mask = nonzero_mask_a & nonzero_mask_b;
-    __m512h m_recip_approx = _mm512_rcp_ph(m_vec);
-    __m512h ratio_a_vec = _mm512_mul_ph(a_vec, m_recip_approx);
-    __m512h ratio_b_vec = _mm512_mul_ph(b_vec, m_recip_approx);
+    __m512h m_with_epsilon = _mm512_add_ph(m_vec, epsilon_vec);
+    __m512h m_recip_approx = _mm512_rcp_ph(m_with_epsilon);
+    __m512h ratio_a_vec = _mm512_mul_ph(_mm512_add_ph(a_vec, epsilon_vec), m_recip_approx);
+    __m512h ratio_b_vec = _mm512_mul_ph(_mm512_add_ph(b_vec, epsilon_vec), m_recip_approx);
     __m512h log_ratio_a_vec = _simsimd_log2_f16_sapphire(ratio_a_vec);
     __m512h log_ratio_b_vec = _simsimd_log2_f16_sapphire(ratio_b_vec);
-    sum_a_vec = _mm512_maskz_fmadd_ph(nonzero_mask, a_vec, log_ratio_a_vec, sum_a_vec);
-    sum_b_vec = _mm512_maskz_fmadd_ph(nonzero_mask, b_vec, log_ratio_b_vec, sum_b_vec);
+    sum_a_vec = _mm512_mask3_fmadd_ph(a_vec, log_ratio_a_vec, sum_a_vec, nonzero_mask);
+    sum_b_vec = _mm512_mask3_fmadd_ph(b_vec, log_ratio_b_vec, sum_b_vec, nonzero_mask);
     if (n) goto simsimd_js_f16_sapphire_cycle;
 
     simsimd_f32_t log2_normalizer = 0.693147181f;