usearch 2.7.7 → 2.8.0

package/rust/lib.cpp

@@ -8,6 +8,7 @@ using index_t = index_dense_t;
 using add_result_t = typename index_t::add_result_t;
 using search_result_t = typename index_t::search_result_t;
 using labeling_result_t = typename index_t::labeling_result_t;
+using vector_key_t = typename index_dense_t::vector_key_t;
 
 template <typename scalar_at> Matches search_(index_dense_t& index, scalar_at const* vec, size_t count) {
     Matches matches;
@@ -26,20 +27,20 @@ template <typename scalar_at> Matches search_(index_dense_t& index, scalar_at co
 NativeIndex::NativeIndex(std::unique_ptr<index_t> index) : index_(std::move(index)) {}
 
 // clang-format off
-void NativeIndex::add_i8(key_t key, rust::Slice<int8_t const> vec) const { index_->add(key, vec.data()).error.raise(); }
-void NativeIndex::add_f16(key_t key, rust::Slice<uint16_t const> vec) const { index_->add(key, (f16_t const*)vec.data()).error.raise(); }
-void NativeIndex::add_f32(key_t key, rust::Slice<float const> vec) const { index_->add(key, vec.data()).error.raise(); }
-void NativeIndex::add_f64(key_t key, rust::Slice<double const> vec) const { index_->add(key, vec.data()).error.raise(); }
+void NativeIndex::add_i8(vector_key_t key, rust::Slice<int8_t const> vec) const { index_->add(key, vec.data()).error.raise(); }
+void NativeIndex::add_f16(vector_key_t key, rust::Slice<uint16_t const> vec) const { index_->add(key, (f16_t const*)vec.data()).error.raise(); }
+void NativeIndex::add_f32(vector_key_t key, rust::Slice<float const> vec) const { index_->add(key, vec.data()).error.raise(); }
+void NativeIndex::add_f64(vector_key_t key, rust::Slice<double const> vec) const { index_->add(key, vec.data()).error.raise(); }
 
 Matches NativeIndex::search_i8(rust::Slice<int8_t const> vec, size_t count) const { return search_(*index_, vec.data(), count); }
 Matches NativeIndex::search_f16(rust::Slice<uint16_t const> vec, size_t count) const { return search_(*index_, (f16_t const*)vec.data(), count); }
 Matches NativeIndex::search_f32(rust::Slice<float const> vec, size_t count) const { return search_(*index_, vec.data(), count); }
 Matches NativeIndex::search_f64(rust::Slice<double const> vec, size_t count) const { return search_(*index_, vec.data(), count); }
 
-size_t NativeIndex::get_i8(key_t key, rust::Slice<int8_t> vec) const { if (vec.size() % dimensions()) throw std::invalid_argument("Vector length must be a multiple of index dimensionality"); return index_->get(key, vec.data(), vec.size() / dimensions()); }
-size_t NativeIndex::get_f16(key_t key, rust::Slice<uint16_t> vec) const { if (vec.size() % dimensions()) throw std::invalid_argument("Vector length must be a multiple of index dimensionality"); return index_->get(key, (f16_t*)vec.data(), vec.size() / dimensions()); }
-size_t NativeIndex::get_f32(key_t key, rust::Slice<float> vec) const { if (vec.size() % dimensions()) throw std::invalid_argument("Vector length must be a multiple of index dimensionality"); return index_->get(key, vec.data(), vec.size() / dimensions()); }
-size_t NativeIndex::get_f64(key_t key, rust::Slice<double> vec) const { if (vec.size() % dimensions()) throw std::invalid_argument("Vector length must be a multiple of index dimensionality"); return index_->get(key, vec.data(), vec.size() / dimensions()); }
+size_t NativeIndex::get_i8(vector_key_t key, rust::Slice<int8_t> vec) const { if (vec.size() % dimensions()) throw std::invalid_argument("Vector length must be a multiple of index dimensionality"); return index_->get(key, vec.data(), vec.size() / dimensions()); }
+size_t NativeIndex::get_f16(vector_key_t key, rust::Slice<uint16_t> vec) const { if (vec.size() % dimensions()) throw std::invalid_argument("Vector length must be a multiple of index dimensionality"); return index_->get(key, (f16_t*)vec.data(), vec.size() / dimensions()); }
+size_t NativeIndex::get_f32(vector_key_t key, rust::Slice<float> vec) const { if (vec.size() % dimensions()) throw std::invalid_argument("Vector length must be a multiple of index dimensionality"); return index_->get(key, vec.data(), vec.size() / dimensions()); }
+size_t NativeIndex::get_f64(vector_key_t key, rust::Slice<double> vec) const { if (vec.size() % dimensions()) throw std::invalid_argument("Vector length must be a multiple of index dimensionality"); return index_->get(key, vec.data(), vec.size() / dimensions()); }
 // clang-format on
 
 size_t NativeIndex::expansion_add() const { return index_->expansion_add(); }
@@ -47,20 +48,20 @@ size_t NativeIndex::expansion_search() const { return index_->expansion_search()
 void NativeIndex::change_expansion_add(size_t n) const { index_->change_expansion_add(n); }
 void NativeIndex::change_expansion_search(size_t n) const { index_->change_expansion_search(n); }
 
-size_t NativeIndex::remove(key_t key) const {
+size_t NativeIndex::remove(vector_key_t key) const {
     labeling_result_t result = index_->remove(key);
     result.error.raise();
     return result.completed;
 }
 
-size_t NativeIndex::rename(key_t from, key_t to) const {
+size_t NativeIndex::rename(vector_key_t from, vector_key_t to) const {
     labeling_result_t result = index_->rename(from, to);
     result.error.raise();
     return result.completed;
 }
 
-size_t NativeIndex::count(key_t key) const { return index_->count(key); }
-bool NativeIndex::contains(key_t key) const { return index_->contains(key); }
+size_t NativeIndex::count(vector_key_t key) const { return index_->count(key); }
+bool NativeIndex::contains(vector_key_t key) const { return index_->contains(key); }
 
 void NativeIndex::reserve(size_t capacity) const { index_->reserve(capacity); }
 
@@ -106,6 +107,7 @@ metric_kind_t rust_to_cpp_metric(MetricKind value) {
     case MetricKind::Cos: return metric_kind_t::cos_k;
     case MetricKind::Pearson: return metric_kind_t::pearson_k;
     case MetricKind::Haversine: return metric_kind_t::haversine_k;
+    case MetricKind::Divergence: return metric_kind_t::divergence_k;
     case MetricKind::Hamming: return metric_kind_t::hamming_k;
     case MetricKind::Tanimoto: return metric_kind_t::tanimoto_k;
     case MetricKind::Sorensen: return metric_kind_t::sorensen_k;

package/rust/lib.hpp

@@ -15,36 +15,36 @@ class NativeIndex {
     using index_dense_t = unum::usearch::index_dense_t;
     using add_result_t = typename index_dense_t::add_result_t;
     using search_result_t = typename index_dense_t::search_result_t;
-    using key_t = typename index_dense_t::key_t;
+    using vector_key_t = typename index_dense_t::vector_key_t;
 
     NativeIndex(std::unique_ptr<index_dense_t> index);
 
     void reserve(size_t) const;
 
-    void add_i8(key_t key, rust::Slice<int8_t const> vector) const;
-    void add_f16(key_t key, rust::Slice<uint16_t const> vector) const;
-    void add_f32(key_t key, rust::Slice<float const> vector) const;
-    void add_f64(key_t key, rust::Slice<double const> vector) const;
+    void add_i8(vector_key_t key, rust::Slice<int8_t const> vector) const;
+    void add_f16(vector_key_t key, rust::Slice<uint16_t const> vector) const;
+    void add_f32(vector_key_t key, rust::Slice<float const> vector) const;
+    void add_f64(vector_key_t key, rust::Slice<double const> vector) const;
 
     Matches search_i8(rust::Slice<int8_t const> vector, size_t count) const;
     Matches search_f16(rust::Slice<uint16_t const> vector, size_t count) const;
     Matches search_f32(rust::Slice<float const> vector, size_t count) const;
     Matches search_f64(rust::Slice<double const> vector, size_t count) const;
 
-    size_t get_i8(key_t key, rust::Slice<int8_t> vector) const;
-    size_t get_f16(key_t key, rust::Slice<uint16_t> vector) const;
-    size_t get_f32(key_t key, rust::Slice<float> vector) const;
-    size_t get_f64(key_t key, rust::Slice<double> vector) const;
+    size_t get_i8(vector_key_t key, rust::Slice<int8_t> vector) const;
+    size_t get_f16(vector_key_t key, rust::Slice<uint16_t> vector) const;
+    size_t get_f32(vector_key_t key, rust::Slice<float> vector) const;
+    size_t get_f64(vector_key_t key, rust::Slice<double> vector) const;
 
     size_t expansion_add() const;
     size_t expansion_search() const;
     void change_expansion_add(size_t n) const;
     void change_expansion_search(size_t n) const;
 
-    size_t count(key_t key) const;
-    size_t remove(key_t key) const;
-    size_t rename(key_t from, key_t to) const;
-    bool contains(key_t key) const;
+    size_t count(vector_key_t key) const;
+    size_t remove(vector_key_t key) const;
+    size_t rename(vector_key_t from, vector_key_t to) const;
+    bool contains(vector_key_t key) const;
 
     size_t dimensions() const;
     size_t connectivity() const;

package/rust/lib.rs

@@ -432,6 +432,7 @@ pub fn new_index(options: &ffi::IndexOptions) -> Result<Index, cxx::Exception> {
 mod tests {
     use crate::ffi::IndexOptions;
     use crate::ffi::MetricKind;
+    use crate::ffi::ScalarKind;
 
     use crate::new_index;
     use crate::Index;
@@ -466,6 +467,51 @@ mod tests {
         assert!(result.is_err());
     }
 
+    #[test]
+    fn test_add_remove_vector() {
+        let mut options = IndexOptions::default();
+        options.dimensions = 4;
+        options.metric = MetricKind::IP;
+        options.quantization = ScalarKind::F64;
+        options.connectivity = 10;
+        options.expansion_add = 128;
+        options.expansion_search = 3;
+        let index = Index::new(&options).unwrap();
+        assert!(index.reserve(10).is_ok());
+        assert_eq!(index.capacity(), 10);
+
+        let first: [f32; 4] = [0.2, 0.1, 0.2, 0.1];
+        let second: [f32; 4] = [0.3, 0.2, 0.4, 0.0];
+
+        // IDs until 18446744073709551615 should be fine:
+        let id1 = 483367403120493160;
+        let id2 = 483367403120558696;
+        let id3 = 483367403120624232;
+        let id4 = 483367403120624233;
+
+        assert!(index.add(id1, &first).is_ok());
+        let mut found_slice = [0.0 as f32; 4];
+        assert_eq!(index.get(id1, &mut found_slice).unwrap(), 1);
+        assert!(index.remove(id1).is_ok());
+    
+        assert!(index.add(id2, &second).is_ok());
+        let mut found_slice = [0.0 as f32; 4];
+        assert_eq!(index.get(id2, &mut found_slice).unwrap(), 1);
+        assert!(index.remove(id2).is_ok());
+        
+        assert!(index.add(id3, &second).is_ok());
+        let mut found_slice = [0.0 as f32; 4];
+        assert_eq!(index.get(id3, &mut found_slice).unwrap(), 1);
+        assert!(index.remove(id3).is_ok());
+                
+        assert!(index.add(id4, &second).is_ok());
+        let mut found_slice = [0.0 as f32; 4];
+        assert_eq!(index.get(id4, &mut found_slice).unwrap(), 1);
+        assert!(index.remove(id4).is_ok());
+
+        assert_eq!(index.size(), 0);
+    }
+
     #[test]
     fn integration() {
         let mut options = IndexOptions::default();

package/setup.py

@@ -1,5 +1,6 @@
 import os
 import sys
+import subprocess
 from setuptools import setup
 
 from pybind11.setup_helpers import Pybind11Extension
@@ -9,6 +10,13 @@ compile_args = []
 link_args = []
 macros_args = []
 
+def is_gcc():
+    try:
+        compiler_version = subprocess.check_output(["c++", "--version"], universal_newlines=True)
+        return "gcc" in compiler_version.lower()
+    except Exception:
+        return False
+
 if sys.platform == "linux":
     compile_args.append("-std=c++17")
     compile_args.append("-O3")  # Maximize performance
@@ -21,9 +29,13 @@ if sys.platform == "linux":
 
     macros_args.append(("USEARCH_USE_NATIVE_F16", "0"))
     macros_args.append(("USEARCH_USE_SIMSIMD", "1"))
-    macros_args.append(("USEARCH_USE_OPENMP", "1"))
-    compile_args.append("-fopenmp")
-    link_args.append("-lgomp")
+
+    if is_gcc():
+        macros_args.append(("USEARCH_USE_OPENMP", "1"))
+        compile_args.append("-fopenmp")
+        link_args.append("-lgomp")
+    else:
+        macros_args.append(("USEARCH_USE_OPENMP", "0"))
 
 if sys.platform == "darwin":
     # MacOS 10.15 or higher is needed for `aligned_alloc` support.

package/simsimd/.github/workflows/prerelease.yml

@@ -16,7 +16,6 @@ permissions:
   contents: read
 
 jobs:
-
   test_python:
     name: Test Python ${{ matrix.python-version }} on ${{ matrix.architecture }} ${{ matrix.os }}
     runs-on: ${{ matrix.os }}
@@ -34,7 +33,7 @@ jobs:
         uses: actions/setup-python@v4
         with:
           python-version: ${{ matrix.python-version }}
-        
+
       - name: Install dependencies
         run: |
           python -m pip install --no-cache-dir --upgrade pip
@@ -58,24 +57,24 @@ jobs:
       - name: Test with PyTest
         run: |
           python -c "import simsimd; print(simsimd.get_capabilities())"
-          pytest python/test.py
-        
+          pytest python/test.py -s -x -v
+
   test_javascript:
     name: Test JavaScript
     runs-on: ubuntu-latest
     strategy:
       matrix:
+        os: [ubuntu-22.04, macOS-11, windows-2022]
         node-version: [18.x]
     steps:
-    
       - uses: actions/checkout@v4
       - name: Set up Node.js
         uses: actions/setup-node@v3
         with:
-          node-version: '18.x'
-      
+          node-version: "18.x"
+
       - name: Build locally
-        run: npm i
+        run: npm install
 
       - name: Test
         run: npm test

package/simsimd/.github/workflows/release.yml

@@ -16,17 +16,15 @@ permissions:
   id-token: write
 
 jobs:
-
   versioning:
     name: Semantic Release
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v3
-      with:
-        persist-credentials: false
-    - uses: actions/setup-node@v3
-    - run: npm install --save-dev @semantic-release/exec @semantic-release/git conventional-changelog-eslint semantic-release && npx semantic-release
-
+      - uses: actions/checkout@v3
+        with:
+          persist-credentials: false
+      - uses: actions/setup-node@v3
+      - run: npm install --save-dev @semantic-release/exec @semantic-release/git conventional-changelog-eslint semantic-release && npx semantic-release
 
   rebase:
     name: Rebase Dev. Branch
@@ -40,9 +38,10 @@ jobs:
 
       - name: Perform rebase
         run: |
+          git fetch origin main
           git checkout main-dev
-          git rebase main
-          
+          git rebase origin/main
+
       - name: Push changes
         uses: CasperWA/push-protected@v2
         with:
@@ -58,19 +57,19 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-20.04, macOS-11, windows-2022]
+        os: [ubuntu-22.04, macOS-11, windows-2022]
     steps:
       - uses: actions/checkout@v3
         with:
-          ref: 'main'      
+          ref: "main"
       - uses: actions/setup-python@v3
-      
+
       - name: Setup Docker
-        if: matrix.os == 'ubuntu-20.04'
+        if: matrix.os == 'ubuntu-22.04'
         uses: docker-practice/actions-setup-docker@master
-        
+
       - name: Setup QEMU
-        if: matrix.os == 'ubuntu-20.04'
+        if: matrix.os == 'ubuntu-22.04'
         uses: docker/setup-qemu-action@v2.1.0
 
       - name: Install CIBuildWheel
@@ -82,12 +81,11 @@ jobs:
       - uses: actions/upload-artifact@v3
         with:
           path: ./wheelhouse/*.whl
-  
-  
+
   publish_python:
     name: Publish Python
     needs: build_wheels
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-22.04
     environment:
       name: pypi
       url: https://pypi.org/p/simsimd
@@ -110,11 +108,11 @@ jobs:
   publish_javascript:
     name: Publish JavaScript
     needs: versioning
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
     steps:
       - uses: actions/checkout@v3
         with:
-          ref: 'main'  
+          ref: "main"
       - run: git submodule update --init --recursive
       - uses: actions/setup-node@v3
         with:

package/simsimd/README.md

@@ -7,6 +7,7 @@ SimSIMD leverages SIMD intrinsics, capabilities that only select compilers effec
 - ✅ __3-200x faster__ than NumPy and SciPy distance functions.
 - ✅ Euclidean (L2), Inner Product, and Cosine (Angular) spatial distances.
 - ✅ Hamming (~ Manhattan) and Jaccard (~ Tanimoto) binary distances.
+- ✅ Kullback-Leibler and Jensen–Shannon divergences for probability distributions.
 - ✅ Single-precision `f32`, half-precision `f16`, `i8`, and binary vectors.
 - ✅ Compatible with GCC and Clang on MacOS and Linux, and MinGW on Windows.
 - ✅ Compatible with NumPy, PyTorch, TensorFlow, and other tensors.
@@ -28,18 +29,19 @@ Given 1000 embeddings from OpenAI Ada API with 1536 dimensions, running on the A
 | `numpy.inner`                          | `inner`           |           __2 x__ |           __9 x__ |         __18 x__ |
 | `scipy.spatial.distance.cosine`        | `cosine`          |          __32 x__ |          __79 x__ |        __133 x__ |
 | `scipy.spatial.distance.sqeuclidean`   | `sqeuclidean`     |           __5 x__ |          __26 x__ |         __17 x__ |
-| `scipy.spatial.distance.jensenshannon` | `jensenshannon`   |          __41 x__ |          __76 x__ |                  |
+| `scipy.spatial.distance.jensenshannon` | `jensenshannon`   |          __31 x__ |          __53 x__ |                  |
 | `scipy.special.kl_div`                 | `kullbackleibler` |          __21 x__ |          __18 x__ |                  |
 
 ### Intel Sapphire Rapids
 
-On the Intel Sapphire Rapids platform, SimSIMD was benchmarked against autovectorized-code using GCC 12. GCC handles single-precision `float` and `int8_t` well. However, it fails on `_Float16` arrays, which has been part of the C language since 2011.
+On the Intel Sapphire Rapids platform, SimSIMD was benchmarked against auto-vectorized code using GCC 12. GCC handles single-precision `float` and `int8_t` well. However, it fails on `_Float16` arrays, which has been part of the C language since 2011.
 
-|               | GCC 12 `f32` | GCC 12 `f16` | SimSIMD `f16` | `f16` improvement |
-| :------------ | -----------: | -----------: | ------------: | ----------------: |
-| `cosine`      |     3.28 M/s |   336.29 k/s |      6.88 M/s |          __20 x__ |
-| `sqeuclidean` |     4.62 M/s |   147.25 k/s |      5.32 M/s |          __36 x__ |
-| `inner`       |     3.81 M/s |   192.02 k/s |      5.99 M/s |          __31 x__ |
+|                 | GCC 12 `f32` | GCC 12 `f16` | SimSIMD `f16` | `f16` improvement |
+| :-------------- | -----------: | -----------: | ------------: | ----------------: |
+| `cosine`        |     3.28 M/s | _336.29 k/s_ |    _6.88 M/s_ |          __20 x__ |
+| `sqeuclidean`   |     4.62 M/s | _147.25 k/s_ |    _5.32 M/s_ |          __36 x__ |
+| `inner`         |     3.81 M/s | _192.02 k/s_ |    _5.99 M/s_ |          __31 x__ |
+| `jensenshannon` |     1.18 M/s |  _18.13 k/s_ |    _2.14 M/s_ |         __118 x__ |
 
 __Technical Insights__:
 
@@ -168,7 +170,10 @@ Should you wish to integrate SimSIMD within USearch, simply compile USearch with
 __To rerun experiments__ utilize the following command:
 
 ```sh
-cmake -DCMAKE_BUILD_TYPE=Release -DSIMSIMD_BUILD_BENCHMARKS=1 -B ./build_release && make -C ./build_release && ./build_release/simsimd_bench
+cmake -DCMAKE_BUILD_TYPE=Release -DSIMSIMD_BUILD_BENCHMARKS=1 -B ./build_release
+cmake --build build_release --config Release
+./build_release/simsimd_bench
+./build_release/simsimd_bench --benchmark_filter=js
 ```
 
 __To test and benchmark with Python bindings__:

package/simsimd/binding.gyp

@@ -4,6 +4,7 @@
             "target_name": "simsimd",
             "sources": ["javascript/lib.c"],
             "include_dirs": ["include"],
+            "defines": ["SIMSIMD_NATIVE_F16=0"],
             "cflags": [
                 "-std=c11",
                 "-ffast-math",
@@ -11,7 +12,6 @@
                 "-Wno-maybe-uninitialized",
                 "-Wno-cast-function-type",
                 "-Wno-switch",
-                "-DSIMSIMD_NATIVE_F16=0",
             ],
         }
     ]

package/simsimd/cpp/bench.cxx

@@ -3,8 +3,8 @@
 
 #include <benchmark/benchmark.h>
 
-#define SIMSIMD_RSQRT simsimd_approximate_inverse_square_root
-#define SIMSIMD_LOG simsimd_approximate_log
+#define SIMSIMD_RSQRT sqrtf
+#define SIMSIMD_LOG logf
 #include <simsimd/simsimd.h>
 
 namespace bm = benchmark;
@@ -44,7 +44,7 @@ template <typename scalar_at, std::size_t dimensions_ak> struct vectors_pair_gt
             a2_sum = std::sqrt(a2_sum);
             b2_sum = std::sqrt(b2_sum);
             for (std::size_t i = 0; i != dimensions_ak; ++i)
-                a[i] /= a2_sum, b[i] /= b2_sum;
+                a[i] = static_cast<scalar_at>(a[i] / a2_sum), b[i] = static_cast<scalar_at>(b[i] / b2_sum);
         }
     }
 };
@@ -129,10 +129,14 @@ int main(int argc, char** argv) {
     register_<simsimd_f16_t>("neon_f16_ip", simsimd_neon_f16_ip, simsimd_accurate_f16_ip);
     register_<simsimd_f16_t>("neon_f16_cos", simsimd_neon_f16_cos, simsimd_accurate_f16_cos);
     register_<simsimd_f16_t>("neon_f16_l2sq", simsimd_neon_f16_l2sq, simsimd_accurate_f16_l2sq);
+    register_<simsimd_f16_t>("neon_f16_kl", simsimd_neon_f16_kl, simsimd_accurate_f16_kl);
+    register_<simsimd_f16_t>("neon_f16_js", simsimd_neon_f16_js, simsimd_accurate_f16_js);
 
     register_<simsimd_f32_t>("neon_f32_ip", simsimd_neon_f32_ip, simsimd_accurate_f32_ip);
     register_<simsimd_f32_t>("neon_f32_cos", simsimd_neon_f32_cos, simsimd_accurate_f32_cos);
     register_<simsimd_f32_t>("neon_f32_l2sq", simsimd_neon_f32_l2sq, simsimd_accurate_f32_l2sq);
+    register_<simsimd_f32_t>("neon_f32_kl", simsimd_neon_f32_kl, simsimd_accurate_f32_kl);
+    register_<simsimd_f32_t>("neon_f32_js", simsimd_neon_f32_js, simsimd_accurate_f32_js);
 
     register_<simsimd_i8_t>("neon_i8_cos", simsimd_neon_i8_cos, simsimd_accurate_i8_cos);
     register_<simsimd_i8_t>("neon_i8_l2sq", simsimd_neon_i8_l2sq, simsimd_accurate_i8_l2sq);
@@ -152,6 +156,8 @@ int main(int argc, char** argv) {
     register_<simsimd_f16_t>("avx2_f16_ip", simsimd_avx2_f16_ip, simsimd_accurate_f16_ip);
     register_<simsimd_f16_t>("avx2_f16_cos", simsimd_avx2_f16_cos, simsimd_accurate_f16_cos);
     register_<simsimd_f16_t>("avx2_f16_l2sq", simsimd_avx2_f16_l2sq, simsimd_accurate_f16_l2sq);
+    register_<simsimd_f16_t>("avx2_f16_kl", simsimd_avx2_f16_kl, simsimd_accurate_f16_kl);
+    register_<simsimd_f16_t>("avx2_f16_js", simsimd_avx2_f16_js, simsimd_accurate_f16_js);
 
     register_<simsimd_i8_t>("avx2_i8_cos", simsimd_avx2_i8_cos, simsimd_accurate_i8_cos);
     register_<simsimd_i8_t>("avx2_i8_l2sq", simsimd_avx2_i8_l2sq, simsimd_accurate_i8_l2sq);
@@ -161,6 +167,8 @@ int main(int argc, char** argv) {
     register_<simsimd_f16_t>("avx512_f16_ip", simsimd_avx512_f16_ip, simsimd_accurate_f16_ip);
     register_<simsimd_f16_t>("avx512_f16_cos", simsimd_avx512_f16_cos, simsimd_accurate_f16_cos);
     register_<simsimd_f16_t>("avx512_f16_l2sq", simsimd_avx512_f16_l2sq, simsimd_accurate_f16_l2sq);
+    register_<simsimd_f16_t>("avx512_f16_kl", simsimd_avx512_f16_kl, simsimd_accurate_f16_kl);
+    register_<simsimd_f16_t>("avx512_f16_js", simsimd_avx512_f16_js, simsimd_accurate_f16_js);
 
     register_<simsimd_i8_t>("avx512_i8_cos", simsimd_avx512_i8_cos, simsimd_accurate_i8_cos);
     register_<simsimd_i8_t>("avx512_i8_l2sq", simsimd_avx512_i8_l2sq, simsimd_accurate_i8_l2sq);
@@ -168,15 +176,21 @@ int main(int argc, char** argv) {
     register_<simsimd_f32_t>("avx512_f32_ip", simsimd_avx512_f32_ip, simsimd_accurate_f32_ip);
     register_<simsimd_f32_t>("avx512_f32_cos", simsimd_avx512_f32_cos, simsimd_accurate_f32_cos);
     register_<simsimd_f32_t>("avx512_f32_l2sq", simsimd_avx512_f32_l2sq, simsimd_accurate_f32_l2sq);
+    register_<simsimd_f32_t>("avx512_f32_kl", simsimd_avx512_f32_kl, simsimd_accurate_f32_kl);
+    register_<simsimd_f32_t>("avx512_f32_js", simsimd_avx512_f32_js, simsimd_accurate_f32_js);
 #endif
 
     register_<simsimd_f16_t>("serial_f16_ip", simsimd_serial_f16_ip, simsimd_accurate_f16_ip);
     register_<simsimd_f16_t>("serial_f16_cos", simsimd_serial_f16_cos, simsimd_accurate_f16_cos);
     register_<simsimd_f16_t>("serial_f16_l2sq", simsimd_serial_f16_l2sq, simsimd_accurate_f16_l2sq);
+    register_<simsimd_f16_t>("serial_f16_kl", simsimd_serial_f16_kl, simsimd_accurate_f16_kl);
+    register_<simsimd_f16_t>("serial_f16_js", simsimd_serial_f16_js, simsimd_accurate_f16_js);
 
     register_<simsimd_f32_t>("serial_f32_ip", simsimd_serial_f32_ip, simsimd_accurate_f32_ip);
     register_<simsimd_f32_t>("serial_f32_cos", simsimd_serial_f32_cos, simsimd_accurate_f32_cos);
     register_<simsimd_f32_t>("serial_f32_l2sq", simsimd_serial_f32_l2sq, simsimd_accurate_f32_l2sq);
+    register_<simsimd_f32_t>("serial_f32_kl", simsimd_serial_f32_kl, simsimd_accurate_f32_kl);
+    register_<simsimd_f32_t>("serial_f32_js", simsimd_serial_f32_js, simsimd_accurate_f32_js);
 
     register_<simsimd_i8_t>("serial_i8_cos", simsimd_serial_i8_cos, simsimd_accurate_i8_cos);
     register_<simsimd_i8_t>("serial_i8_l2sq", simsimd_serial_i8_l2sq, simsimd_accurate_i8_l2sq);

package/simsimd/include/simsimd/binary.h

@@ -136,12 +136,11 @@ simsimd_sve_b8_jaccard(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_siz
 __attribute__((target("avx512vpopcntdq,avx512vl,avx512bw,avx512f"))) //
 inline static simsimd_f32_t
 simsimd_avx512_b8_hamming(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_size_t n_words) {
-    __m512i differences_vec = _mm512_setzero_si512(), union_vec = _mm512_setzero_si512();
+    __m512i differences_vec = _mm512_setzero_si512();
     for (simsimd_size_t i = 0; i < n_words; i += 64) {
 
         // Compute mask for tail elements
         __mmask64 mask = (i + 64 <= n_words) ? 0xFFFFFFFFFFFFFFFF : (((1ull << (n_words - i)) - 1ull));
-
         __m512i a_vec = _mm512_maskz_loadu_epi8(mask, a + i);
         __m512i b_vec = _mm512_maskz_loadu_epi8(mask, b + i);
         __m512i xor_vec = _mm512_xor_si512(a_vec, b_vec);
@@ -161,7 +160,6 @@ simsimd_avx512_b8_jaccard(simsimd_b8_t const* a, simsimd_b8_t const* b, simsimd_
 
         // Compute mask for tail elements
         __mmask64 mask = (i + 64 <= n_words) ? 0xFFFFFFFFFFFFFFFF : (((1ull << (n_words - i)) - 1ull));
-
         __m512i a_vec = _mm512_maskz_loadu_epi8(mask, a + i);
         __m512i b_vec = _mm512_maskz_loadu_epi8(mask, b + i);
         __m512i and_vec = _mm512_and_si512(a_vec, b_vec);