usearch 2.8.2 → 2.8.4

package/cpp/README.md

@@ -25,14 +25,20 @@ metric_punned_t metric(256, metric_kind_t::l2sq_k, scalar_kind_t::f32_k);
 index_dense_t index = index_dense_t::make(metric);
 float vec[3] = {0.1, 0.3, 0.2};
 
-index.reserve(10);
-index.add(/* key: */ 42, /* vector: */ {&vec[0], 3});
-auto results = index.search(/* query: */ {&vec[0], 3}, 5 /* neighbors */);
+index.reserve(10); // Pre-allocate memory for 10 vectors
+index.add(42, &vec[0]); // Pass a key and a vector
+auto results = index.search(&vec[0], 5); // Pass a query and limit number of results
 
 for (std::size_t i = 0; i != results.size(); ++i)
     results[i].element.key, results[i].element.vector, results[i].distance;
 ```
 
+Here we:
+
+- define a metric of kind [`metric_kind_t::l2sq_k`](https://unum-cloud.github.io/usearch/cpp/reference.html#_CPPv413metric_kind_t),
+- to be applied to [`scalar_kind_t::f32_k`](https://unum-cloud.github.io/usearch/cpp/reference.html#_CPPv413scalar_kind_t) floating-point vectors,
+- instantiate an [`index_dense_t`](https://unum-cloud.github.io/usearch/cpp/reference.html#_CPPv4I00EN4unum7usearch14index_dense_gtE) index.
+
 The `add` is thread-safe for concurrent index construction.
 It also has an overload for different vector types, casting them under the hood.
 The same applies to the `search`, `get`, `cluster`, and `distance_between` functions.
@@ -52,20 +58,78 @@ index.load("index.usearch"); // Copying from disk
 index.view("index.usearch"); // Memory-mapping from disk
 ```
 
-## User-Defined Metrics in C++
+## Multi-Threading
 
-For advanced users, more compile-time abstractions are available.
+Most AI, HPC, or Big Data packages use some form of a thread pool.
+Instead of spawning additional threads within USearch, we focus on the thread safety of `add()` function, simplifying resource management.
 
 ```cpp
-template <typename distance_at = default_distance_t,              // `float`
-          typename key_at = default_key_t,                        // `int64_t`, `uuid_t`
-          typename compressed_slot_at = default_slot_t,           // `uint32_t`, `uint40_t`
-          typename dynamic_allocator_at = std::allocator<byte_t>, //
-          typename tape_allocator_at = dynamic_allocator_at>      //
-class index_gt;
+#pragma omp parallel for
+    for (std::size_t i = 0; i < n; ++i)
+        native.add(key, span_t{vector, dims});
+```
+
+During initialization, we allocate enough temporary memory for all the cores on the machine.
+On the call, the user can supply the identifier of the current thread, making this library easy to integrate with OpenMP and similar tools.
+
+Moreover, you can take advantage of one of the provided "executors" to parallelize the search:
+
+- `executor_openmp_t`, that would use OpenMP under the hood.
+- `executor_stl_t`, that will spawn `std::thread` instances.
+- `dummy_executor_t`, that will run everything sequentially.
+
+## Clustering
+
+Aside from basic Create-Read-Update-Delete (CRUD) operations and search, USearch also supports clustering.
+Once the index is constructed, you can either:
+
+- Identify a cluster to which any external vector belongs, once mapped onto the index.
+- Split the entire index into a set of clusters, each with its own centroid.
+
+For the first, the interface accepts a vector and a "clustering level", which is essentially the index of the HNSW graph layer, in which to search.
+If you pass zero, the traversal will happen in every level except the bottom one.
+Otherwise, the search will be limited to the specified level.
+
+```cpp
+some_scalar_t vector[3] = {0.1, 0.3, 0.2};
+cluster_result_t result = index.cluster(&vector, index.max_level() / 2);
+match_t cluster = result.cluster;
+member_cref_t member = cluster.member;
+distance_t distance = cluster.distance;
 ```
 
-The following distances are pre-packaged:
+If you wish to split the whole structure into clusters, you must provide an iterator over a range of vectors, that will be processed in parallel using the previously described function.
+Unlike the previous function, you don't have to manually specify the level, as the algorithm will pick the best one for you, depending on the number of clusters you want to highlight.
+Aside from that auto-tuning, this function will regroup some of the clusters, if they are too small, and return the final number of clusters.
+
+```cpp
+std::size_t queries_count = queries_end - queries_begin;
+index_dense_clustering_config_t config;
+config.min_clusters = 1000;
+config.max_clusters = 2000;
+config.mode = index_dense_clustering_config_t::merge_smallest_k;
+
+// Outputs:
+vector_key_t cluster_centroids_keys[queries_count];
+distance_t distances_to_cluster_centroids[queries_count];
+executor_default_t thread_pool;
+dummy_progress_t progress_bar;
+
+clustering_result_t result = cluster(
+        queries_begin, queries_end,
+        config,
+        &cluster_centroids_keys, &distances_to_cluster_centroids,
+        thread_pool, progress_bar);
+```
+
+This approach requires basic understanding of templates meta-programming to implement the `queries_begin` and `queries_end` smart-iterators.
+On the bright side, it allows iteratively deepening into a specific cluster.
+
+As in many other bulk-processing APIs, the `executor` and `progress` are optional.
+
+## User-Defined Metrics
+
+In its high-level interface, USearch supports a variety of metrics, including the most popular ones:
 
 - `metric_cos_gt<scalar_t>` for "Cosine" or "Angular" distance.
 - `metric_ip_gt<scalar_t>` for "Inner Product" or "Dot Product" distance.
@@ -78,16 +142,20 @@ The following distances are pre-packaged:
 - `metric_haversine_gt<scalar_t>` for "Haversine" or "Great Circle" distance between coordinates used in GIS applications.
 - `metric_divergence_gt<scalar_t>` for the "Jensen Shannon" similarity between probability distributions.
 
-## Multi-Threading
+In reality, for most common types, one of the [SimSIMD](https://github.com/ashvardanian/SimSIMD) backends will be triggered, providing hardware-acceleration for most common CPUs.
 
-Most AI, HPC, or Big Data packages use some form of a thread pool.
-Instead of spawning additional threads within USearch, we focus on the thread safety of `add()` function, simplifying resource management.
+If you need a different metric, you can implement it yourself and wrap it into a `metric_punned_t`, which is our alternative to the `std::function`.
+Unlike the `std::function`, it is a trivial type, which is important for performance.
+
+## Advanced Interface
+
+If you are proficient in C++ and ready to get your hands dirty, you can use the low-level interface.
 
 ```cpp
-#pragma omp parallel for
-    for (std::size_t i = 0; i < n; ++i)
-        native.add(key, span_t{vector, dims});
+template <typename distance_at = default_distance_t,              // `float`
+          typename key_at = default_key_t,                        // `int64_t`, `uuid_t`
+          typename compressed_slot_at = default_slot_t,           // `uint32_t`, `uint40_t`
+          typename dynamic_allocator_at = std::allocator<byte_t>, //
+          typename tape_allocator_at = dynamic_allocator_at>      //
+class index_gt;
 ```
-
-During initialization, we allocate enough temporary memory for all the cores on the machine.
-On the call, the user can supply the identifier of the current thread, making this library easy to integrate with OpenMP and similar tools.

package/csharp/DEV_SETUP.md

@@ -11,7 +11,7 @@ To obtain all libraries, download the artifacts generated by the GitHub workflow
 
 To get a library for your current platform (Linux or Macos), execute: `./eng/build_lib.sh`.
 
-For more details, refer to the [compilation guide](https://github.com/unum-cloud/usearch/blob/main/docs/compilation.md).
+For more details, refer to the [compilation guide](https://github.com/unum-cloud/usearch/blob/main/CONTRIBUTING.md).
 
 # Build and Test
 

package/csharp/nuget/nuget-package.props

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project>
   <PropertyGroup>
-    <Version Condition="'$(Version)' == ''">2.8.2</Version>
+    <Version Condition="'$(Version)' == ''">2.8.4</Version>
 
     <Authors>Unum</Authors>
     <Company>Unum</Company>

package/docs/{compilation.rst → contributing.rst}

@@ -1,5 +1,5 @@
 ========================
-Compilation
+Contributing
 ========================
 
-.. mdinclude:: compilation.md
+.. mdinclude:: ../CONTRIBUTING.md

package/docs/index.rst

@@ -22,7 +22,7 @@ Overview
    :hidden:
    :caption: �
 
-   compilation
+   contributing
    benchmarks
    format
 

package/include/usearch/index.hpp

@@ -11,7 +11,7 @@
 
 #define USEARCH_VERSION_MAJOR 2
 #define USEARCH_VERSION_MINOR 8
-#define USEARCH_VERSION_PATCH 2
+#define USEARCH_VERSION_PATCH 4
 
 // Inferring C++ version
 // https://stackoverflow.com/a/61552074
@@ -547,6 +547,7 @@ class max_heap_gt {
     inline bool empty() const noexcept { return !size_; }
     inline std::size_t size() const noexcept { return size_; }
     inline std::size_t capacity() const noexcept { return capacity_; }
+
     /// @brief  Selects the largest element in the heap.
     /// @return Reference to the stored element.
     inline element_t const& top() const noexcept { return elements_[0]; }
@@ -2205,7 +2206,7 @@ class index_gt {
             node_t node = nodes_[candidate.slot];
             return {member_cref_t{node.ckey(), candidate.slot}, candidate.distance};
         }
-        inline std::size_t merge_into(          //
+        inline std::size_t merge_into(                 //
             vector_key_t* keys, distance_t* distances, //
             std::size_t old_count, std::size_t max_count) const noexcept {
 
@@ -2279,10 +2280,10 @@ class index_gt {
         typename callback_at = dummy_callback_t, //
         typename prefetch_at = dummy_prefetch_t  //
         >
-    add_result_t add(                                    //
+    add_result_t add(                                           //
         vector_key_t key, value_at&& value, metric_at&& metric, //
-        index_update_config_t config = {},               //
-        callback_at&& callback = callback_at{},          //
+        index_update_config_t config = {},                      //
+        callback_at&& callback = callback_at{},                 //
         prefetch_at&& prefetch = prefetch_at{}) usearch_noexcept_m {
 
         add_result_t result;
@@ -2389,7 +2390,7 @@ class index_gt {
         >
     add_result_t update(                        //
         member_iterator_t iterator,             //
-        vector_key_t key,                              //
+        vector_key_t key,                       //
         value_at&& value,                       //
         metric_at&& metric,                     //
         index_update_config_t config = {},      //

package/include/usearch/index_dense.hpp

@@ -323,7 +323,7 @@ class index_dense_gt {
     /// @brief Schema: input buffer, bytes in input buffer, output buffer.
     using cast_t = std::function<bool(byte_t const*, std::size_t, byte_t*)>;
     /// @brief Punned index.
-    using index_t = index_gt<                 //
+    using index_t = index_gt<                        //
         distance_t, vector_key_t, compressed_slot_t, //
         dynamic_allocator_t, tape_allocator_t>;
     using index_allocator_t = aligned_allocator_gt<index_t, 64>;
@@ -1512,10 +1512,14 @@ class index_dense_gt {
      *  @brief  Implements clustering, classifying the given objects (vectors of member keys)
      *          into a given number of clusters.
      *
-     *  @param[in] queries_begin Iterator targeting the fiest query.
-     *  @param[in] queries_end
+     *  @param[in] queries_begin Iterator pointing to the first query.
+     *  @param[in] queries_end Iterator pointing to the last query.
      *  @param[in] executor Thread-pool to execute the job in parallel.
      *  @param[in] progress Callback to report the execution progress.
+     *  @param[in] config Configuration parameters for clustering.
+     *
+     *  @param[out] cluster_keys Pointer to the array where the cluster keys will be exported.
+     *  @param[out] cluster_distances Pointer to the array where the distances to those centroids will be exported.
      */
     template <                                   //
         typename queries_iterator_at,            //
@@ -1526,7 +1530,7 @@ class index_dense_gt {
         queries_iterator_at queries_begin,      //
         queries_iterator_at queries_end,        //
         index_dense_clustering_config_t config, //
-        vector_key_t* cluster_keys,                    //
+        vector_key_t* cluster_keys,             //
         distance_t* cluster_distances,          //
         executor_at&& executor = executor_at{}, //
         progress_at&& progress = progress_at{}) {
@@ -1715,7 +1719,7 @@ class index_dense_gt {
     }
 
     template <typename scalar_at>
-    add_result_t add_(                      //
+    add_result_t add_(                             //
         vector_key_t key, scalar_at const* vector, //
         std::size_t thread, bool force_vector_copy, cast_t const& cast) {
 
@@ -1811,8 +1815,8 @@ class index_dense_gt {
     }
 
     template <typename scalar_at>
-    aggregated_distances_t distance_between_( //
-        vector_key_t key, scalar_at const* vector,   //
+    aggregated_distances_t distance_between_(      //
+        vector_key_t key, scalar_at const* vector, //
         std::size_t thread, cast_t const& cast) const {
 
         // Cast the vector, if needed for compatibility with `metric_`

package/javascript/usearch.js

@@ -84,7 +84,7 @@ class BatchMatches {
 }
 
 function isOneKey(keys) {
-    return typeof keys === 'number' || typeof keys === 'bigint';
+    return (!Number.isNaN(keys) && typeof keys === 'number') || typeof keys === 'bigint';
 }
 
 function normalizeKeys(keys) {
@@ -92,7 +92,7 @@ function normalizeKeys(keys) {
         keys = BigUint64Array.of(BigInt(keys));
     } else if (Array.isArray(keys)) {
         keys = keys.map(key => {
-            if (typeof key !== 'bigint' && typeof key !== 'number')
+            if ((typeof key !== 'bigint' && typeof key !== 'number') || Number.isNaN(key))
                 throw new Error("All keys must be integers or bigints.");
             return BigInt(key);
         });
@@ -151,7 +151,7 @@ class Index {
         if (typeof dimensionsOrConfigs === 'object' && dimensionsOrConfigs !== null) {
             // Parameters are provided as an object
             ({ dimensions, metric = MetricKind.Cos, quantization = ScalarKind.F32, connectivity = 0, expansion_add = 0, expansion_search = 0, multi = false } = dimensionsOrConfigs);
-        } else if (typeof dimensionsOrConfigs === 'number' || typeof dimensionsOrConfigs === 'bigint') {
+        } else if ((typeof dimensionsOrConfigs === 'number' && !Number.isNaN(dimensionsOrConfigs)) || typeof dimensionsOrConfigs === 'bigint') {
             // Parameters are provided as individual arguments
             dimensions = dimensionsOrConfigs;
         } else {
@@ -238,7 +238,7 @@ class Index {
      * @throws Will throw an error if `vectors` is not a valid input type (TypedArray or an array of arrays) or if its flattened size is not a multiple of dimensions.
      */
     search(vectors, k) {
-        if (typeof k !== 'number' || k <= 0) {
+        if ((!Number.isNaN(k) && typeof k !== 'number') || k <= 0) {
             throw new Error("`k` must be a positive integer representing the number of nearest neighbors to search for.");
         }
 

package/javascript/usearch.test.js

@@ -35,3 +35,25 @@ test('Batch operations', () => {
     assert.deepEqual(results.keys, new BigUint64Array([15n, 16n]), 'keys should be 15 and 16');
     assert.deepEqual(results.distances, new Float32Array([45, 130]), 'distances should be 45 and 130');
 });
+
+
+test('Operations with invalid values', () => {
+    const indexBatch = new usearch.Index(2, 'l2sq');
+
+    const keys = [NaN, 16n];
+    const vectors = [new Float32Array([10, 30]), new Float32Array([1, 5])];
+
+    try {
+        indexBatch.add(keys, vectors);
+        throw new Error('indexBatch.add should have thrown an error.');
+    } catch (err) {
+        assert.equal(err.message, 'All keys must be integers or bigints.');
+    }
+
+    try {
+        indexBatch.search(NaN, 2);
+        throw new Error('indexBatch.search should have thrown an error.');
+    } catch (err) {
+        assert.equal(err.message, 'Vectors must be a TypedArray or an array of arrays.');
+    }
+});

package/package-ci.json

@@ -0,0 +1,10 @@
+{
+    "name": "usearch-ci",
+    "version": "1.0.0",
+    "devDependencies": {
+        "@semantic-release/exec": "^6.0.3",
+        "@semantic-release/git": "^10.0.1",
+        "conventional-changelog-eslint": "^3.0.9",
+        "semantic-release": "^21.1.2"
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "usearch",
-    "version": "2.8.2",
+    "version": "2.8.4",
     "description": "Smaller & Faster Single-File Vector Search Engine from Unum",
     "author": "Ash Vardanian (https://ashvardanian.com/)",
     "license": "Apache 2.0",
@@ -27,10 +27,6 @@
         "test": "node --test ./javascript/usearch.test.js"
     },
     "devDependencies": {
-        "@semantic-release/exec": "^6.0.3",
-        "@semantic-release/git": "^10.0.1",
-        "conventional-changelog-eslint": "^3.0.9",
-        "semantic-release": "^21.1.2",
         "typescript": "^5.1.6"
     }
 }

package/python/README.md

@@ -10,7 +10,7 @@ pip install usearch
 
 ```python
 import numpy as np
-from usearch.index import Index
+from usearch.index import Index, Matches
 
 index = Index(
     ndim=3, # Define the number of dimensions in input vectors

package/simsimd/CMakeLists.txt

@@ -48,7 +48,7 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "^(Apple)?Clang$")
   endif()
   add_compile_options(-pedantic -ferror-limit=1)
 elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-  add_compile_options(-march=native -pedantic -fmax-errors=1)
+  add_compile_options(-march=native -pedantic -fmax-errors=1 -Wno-tautological-constant-compare)
 elseif(CMAKE_CXX_COMPILER_ID STREQUAL "IntelLLVM")
   add_compile_options(-w -ferror-limit=1)
 endif()

package/simsimd/README.md

@@ -1,5 +1,11 @@
 # SimSIMD 📏
 
+<div>
+<a href="https://pypi.org/project/simsimd/"> <img alt="PyPI - Downloads" src="https://img.shields.io/pypi/dm/simsimd?label=pypi%20downloads"> </a>
+<a href="https://www.npmjs.com/package/simsimd"> <img alt="npm" src="https://img.shields.io/npm/dy/simsimd?label=npm%20dowloads"> </a>
+<img alt="GitHub code size in bytes" src="https://img.shields.io/github/languages/code-size/ashvardanian/simsimd">
+</div>
+
 ## Efficient Alternative to [`scipy.spatial.distance`][scipy] and [`numpy.inner`][numpy]
 
 SimSIMD leverages SIMD intrinsics, capabilities that only select compilers effectively utilize. This framework supports conventional AVX2 instructions on x86, NEON on Arm, as well as __rare__ AVX-512 FP16 instructions on x86 and Scalable Vector Extensions (SVE) on Arm. Designed specifically for Machine Learning contexts, it's optimized for handling high-dimensional vector embeddings.
@@ -189,7 +195,7 @@ __To test and benchmark JavaScript bindings__:
 ```sh
 npm install --dev
 npm test
-npm bench
+npm run bench
 ```
 
 __To test and benchmark GoLang bindings__:

package/simsimd/include/simsimd/probability.h

@@ -52,17 +52,17 @@
 extern "C" {
 #endif
 
-SIMSIMD_MAKE_KL(serial, f32, f32, SIMSIMD_IDENTIFY, 1e-6) // simsimd_serial_f32_kl
-SIMSIMD_MAKE_JS(serial, f32, f32, SIMSIMD_IDENTIFY, 1e-6) // simsimd_serial_f32_js
+SIMSIMD_MAKE_KL(serial, f32, f32, SIMSIMD_IDENTIFY, SIMSIMD_F32_DIVISION_EPSILON) // simsimd_serial_f32_kl
+SIMSIMD_MAKE_JS(serial, f32, f32, SIMSIMD_IDENTIFY, SIMSIMD_F32_DIVISION_EPSILON) // simsimd_serial_f32_js
 
-SIMSIMD_MAKE_KL(serial, f16, f32, SIMSIMD_UNCOMPRESS_F16, 1e-3) // simsimd_serial_f16_kl
-SIMSIMD_MAKE_JS(serial, f16, f32, SIMSIMD_UNCOMPRESS_F16, 1e-3) // simsimd_serial_f16_js
+SIMSIMD_MAKE_KL(serial, f16, f32, SIMSIMD_UNCOMPRESS_F16, SIMSIMD_F32_DIVISION_EPSILON) // simsimd_serial_f16_kl
+SIMSIMD_MAKE_JS(serial, f16, f32, SIMSIMD_UNCOMPRESS_F16, SIMSIMD_F32_DIVISION_EPSILON) // simsimd_serial_f16_js
 
-SIMSIMD_MAKE_KL(accurate, f32, f64, SIMSIMD_IDENTIFY, 1e-6) // simsimd_accurate_f32_kl
-SIMSIMD_MAKE_JS(accurate, f32, f64, SIMSIMD_IDENTIFY, 1e-6) // simsimd_accurate_f32_js
+SIMSIMD_MAKE_KL(accurate, f32, f64, SIMSIMD_IDENTIFY, SIMSIMD_F32_DIVISION_EPSILON) // simsimd_accurate_f32_kl
+SIMSIMD_MAKE_JS(accurate, f32, f64, SIMSIMD_IDENTIFY, SIMSIMD_F32_DIVISION_EPSILON) // simsimd_accurate_f32_js
 
-SIMSIMD_MAKE_KL(accurate, f16, f64, SIMSIMD_UNCOMPRESS_F16, 1e-6) // simsimd_accurate_f16_kl
-SIMSIMD_MAKE_JS(accurate, f16, f64, SIMSIMD_UNCOMPRESS_F16, 1e-6) // simsimd_accurate_f16_js
+SIMSIMD_MAKE_KL(accurate, f16, f64, SIMSIMD_UNCOMPRESS_F16, SIMSIMD_F32_DIVISION_EPSILON) // simsimd_accurate_f16_kl
+SIMSIMD_MAKE_JS(accurate, f16, f64, SIMSIMD_UNCOMPRESS_F16, SIMSIMD_F32_DIVISION_EPSILON) // simsimd_accurate_f16_js
 
 #if SIMSIMD_TARGET_ARM
 #if SIMSIMD_TARGET_ARM_NEON
@@ -108,7 +108,7 @@ __attribute__((target("+simd"))) //
 inline static simsimd_f32_t
 simsimd_neon_f32_kl(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n) {
     float32x4_t sum_vec = vdupq_n_f32(0);
-    simsimd_f32_t epsilon = 1e-6;
+    simsimd_f32_t epsilon = SIMSIMD_F32_DIVISION_EPSILON;
     float32x4_t epsilon_vec = vdupq_n_f32(epsilon);
     simsimd_size_t i = 0;
     for (; i + 4 <= n; i += 4) {
@@ -129,7 +129,7 @@ simsimd_neon_f32_kl(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size
 __attribute__((target("+simd"))) inline static simsimd_f32_t
 simsimd_neon_f32_js(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n) {
     float32x4_t sum_vec = vdupq_n_f32(0);
-    simsimd_f32_t epsilon = 1e-6;
+    simsimd_f32_t epsilon = SIMSIMD_F32_DIVISION_EPSILON;
     float32x4_t epsilon_vec = vdupq_n_f32(epsilon);
     simsimd_size_t i = 0;
     for (; i + 4 <= n; i += 4) {
@@ -147,11 +147,11 @@ simsimd_neon_f32_js(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size
     simsimd_f32_t log2_normalizer = 0.693147181f;
     simsimd_f32_t sum = vaddvq_f32(sum_vec) * log2_normalizer;
     for (; i < n; ++i) {
-        simsimd_f32_t mi = a[i] + b[i];
+        simsimd_f32_t mi = 0.5f * (a[i] + b[i]);
         sum += a[i] * SIMSIMD_LOG((a[i] + epsilon) / (mi + epsilon));
         sum += b[i] * SIMSIMD_LOG((b[i] + epsilon) / (mi + epsilon));
     }
-    return sum * 0.5f;
+    return sum;
 }
 
 /*
@@ -168,7 +168,7 @@ __attribute__((target("+simd+fp16"))) //
 inline static simsimd_f32_t
 simsimd_neon_f16_kl(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n) {
     float32x4_t sum_vec = vdupq_n_f32(0);
-    simsimd_f32_t epsilon = 1e-3;
+    simsimd_f32_t epsilon = SIMSIMD_F32_DIVISION_EPSILON;
     float32x4_t epsilon_vec = vdupq_n_f32(epsilon);
     simsimd_size_t i = 0;
     for (; i + 4 <= n; i += 4) {
@@ -191,7 +191,7 @@ __attribute__((target("+simd+fp16"))) //
 inline static simsimd_f32_t
 simsimd_neon_f16_js(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n) {
     float32x4_t sum_vec = vdupq_n_f32(0);
-    simsimd_f32_t epsilon = 1e-3;
+    simsimd_f32_t epsilon = SIMSIMD_F32_DIVISION_EPSILON;
     float32x4_t epsilon_vec = vdupq_n_f32(epsilon);
     simsimd_size_t i = 0;
     for (; i + 4 <= n; i += 4) {
@@ -211,11 +211,11 @@ simsimd_neon_f16_js(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size
     for (; i < n; ++i) {
         simsimd_f32_t ai = SIMSIMD_UNCOMPRESS_F16(a[i]);
         simsimd_f32_t bi = SIMSIMD_UNCOMPRESS_F16(b[i]);
-        simsimd_f32_t mi = ai + bi;
+        simsimd_f32_t mi = 0.5f * (ai + bi);
         sum += ai * SIMSIMD_LOG((ai + epsilon) / (mi + epsilon));
         sum += bi * SIMSIMD_LOG((bi + epsilon) / (mi + epsilon));
     }
-    return sum / 2;
+    return sum;
 }
 
 #endif // SIMSIMD_TARGET_ARM_NEON
@@ -268,7 +268,7 @@ __attribute__((target("avx2,f16c,fma"))) //
 inline static simsimd_f32_t
 simsimd_avx2_f16_kl(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n) {
     __m256 sum_vec = _mm256_set1_ps(0);
-    simsimd_f32_t epsilon = 1e-5;
+    simsimd_f32_t epsilon = SIMSIMD_F32_DIVISION_EPSILON;
     __m256 epsilon_vec = _mm256_set1_ps(epsilon);
     simsimd_size_t i = 0;
     for (; i + 8 <= n; i += 8) {
@@ -300,7 +300,7 @@ __attribute__((target("avx2,f16c,fma"))) //
 inline static simsimd_f32_t
 simsimd_avx2_f16_js(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n) {
     __m256 sum_vec = _mm256_set1_ps(0);
-    simsimd_f32_t epsilon = 1e-5;
+    simsimd_f32_t epsilon = SIMSIMD_F32_DIVISION_EPSILON;
     __m256 epsilon_vec = _mm256_set1_ps(epsilon);
     simsimd_size_t i = 0;
     for (; i + 8 <= n; i += 8) {
@@ -374,7 +374,7 @@ __attribute__((target("avx512f,avx512vl,bmi2"))) //
 inline static simsimd_f32_t
 simsimd_avx512_f32_kl(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n) {
     __m512 sum_vec = _mm512_set1_ps(0);
-    simsimd_f32_t epsilon = 1e-6;
+    simsimd_f32_t epsilon = SIMSIMD_F32_DIVISION_EPSILON;
     __m512 epsilon_vec = _mm512_set1_ps(epsilon);
     __m512 a_vec, b_vec;
 
@@ -405,7 +405,7 @@ inline static simsimd_f32_t
 simsimd_avx512_f32_js(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n) {
     __m512 sum_a_vec = _mm512_set1_ps(0);
     __m512 sum_b_vec = _mm512_set1_ps(0);
-    simsimd_f32_t epsilon = 1e-6;
+    simsimd_f32_t epsilon = SIMSIMD_F32_DIVISION_EPSILON;
     __m512 epsilon_vec = _mm512_set1_ps(epsilon);
     __m512 a_vec, b_vec;
 
@@ -425,8 +425,8 @@ simsimd_avx512_f32_js_cycle:
     __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 ratio_a_vec = _mm512_div_ps(a_vec, m_vec);
+    __m512 ratio_b_vec = _mm512_div_ps(b_vec, m_vec);
     __m512 log_ratio_a_vec = simsimd_avx512_f32_log2(ratio_a_vec);
     __m512 log_ratio_b_vec = simsimd_avx512_f32_log2(ratio_b_vec);
     sum_a_vec = _mm512_maskz_fmadd_ps(nonzero_mask, a_vec, log_ratio_a_vec, sum_a_vec);
@@ -472,7 +472,7 @@ __attribute__((target("avx512f,avx512vl,avx512fp16,bmi2"))) //
 inline static simsimd_f32_t
 simsimd_avx512_f16_kl(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n) {
     __m512h sum_vec = _mm512_set1_ph((_Float16)0);
-    __m512h epsilon_vec = _mm512_set1_ph((_Float16)1e-6f);
+    __m512h epsilon_vec = _mm512_set1_ph((_Float16)SIMSIMD_F16_DIVISION_EPSILON);
     __m512h a_vec, b_vec;
 
 simsimd_avx512_f16_kl_cycle:
@@ -502,7 +502,7 @@ inline static simsimd_f32_t
 simsimd_avx512_f16_js(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n) {
     __m512h sum_a_vec = _mm512_set1_ph((_Float16)0);
     __m512h sum_b_vec = _mm512_set1_ph((_Float16)0);
-    __m512h epsilon_vec = _mm512_set1_ph((_Float16)1e-6f);
+    __m512h epsilon_vec = _mm512_set1_ph((_Float16)SIMSIMD_F16_DIVISION_EPSILON);
     __m512h a_vec, b_vec;
 
 simsimd_avx512_f16_js_cycle:

package/simsimd/include/simsimd/types.h

@@ -91,6 +91,14 @@
 #define SIMSIMD_LOG(x) (logf(x))
 #endif
 
+#ifndef SIMSIMD_F32_DIVISION_EPSILON
+#define SIMSIMD_F32_DIVISION_EPSILON 1e-7
+#endif
+
+#ifndef SIMSIMD_F16_DIVISION_EPSILON
+#define SIMSIMD_F16_DIVISION_EPSILON 1e-3
+#endif
+
 #ifdef __cplusplus
 extern "C" {
 #endif

package/simsimd/javascript/{test.js → test/simsimd.test.js}

@@ -4,12 +4,6 @@ import assert from 'node:assert';
 
 const simsimd = bindings('simsimd');
 
-const f32Array1 = new Float32Array([1.0, 2.0, 3.0]);
-const f32Array2 = new Float32Array([4.0, 5.0, 6.0]);
-
-const u8Array1 = new Uint8Array([1, 2, 3]);
-const u8Array2 = new Uint8Array([4, 5, 6]);
-
 function assertAlmostEqual(actual, expected, tolerance = 1e-6) {
     const lowerBound = expected - tolerance;
     const upperBound = expected + tolerance;
@@ -17,20 +11,26 @@ function assertAlmostEqual(actual, expected, tolerance = 1e-6) {
 }
 
 test('Distance from itself', () => {
-    assertAlmostEqual(simsimd.sqeuclidean(f32Array1, f32Array1), 0.0, 0.01);
-    assertAlmostEqual(simsimd.cosine(f32Array1, f32Array1), 0.0, 0.01);
 
-    // Inner-product distance on non-nroamalized vectors would yield:
-    // 1 - 1 - 4 - 9 = -13
-    assertAlmostEqual(simsimd.inner(f32Array1, f32Array1), -13.0, 0.01);
+    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(simsimd.kullbackleibler(f32Array1, f32Array1), 0.0, 0.01);
-    assertAlmostEqual(simsimd.jensenshannon(f32Array1, f32Array1), 0.0, 0.01);
+    const f32sNormalized = new Float32Array([1.0 / Math.sqrt(14), 2.0 / Math.sqrt(14), 3.0 / Math.sqrt(14)]);
+    assertAlmostEqual(simsimd.inner(f32sNormalized, f32sNormalized), 0.0, 0.01);
 
-    assertAlmostEqual(simsimd.hamming(u8Array1, u8Array1), 0.0, 0.01);
-    assertAlmostEqual(simsimd.jaccard(u8Array1, u8Array1), 0.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 u8s = new Uint8Array([1, 2, 3]);
+    assertAlmostEqual(simsimd.hamming(u8s, u8s), 0.0, 0.01);
+    assertAlmostEqual(simsimd.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]);
+
 test('Squared Euclidean Distance', () => {
     const result = simsimd.sqeuclidean(f32Array1, f32Array2);
     assertAlmostEqual(result, 27.0, 0.01);