usearch 2.8.3 → 2.8.5

package/java/cloud/unum/usearch/Index.java

@@ -1,17 +1,17 @@
 package cloud.unum.usearch;
 
-import java.io.File;
-import java.io.InputStream;
-import java.nio.file.Files;
-import java.nio.file.StandardCopyOption;
-
 /**
  * Java bindings for Unum USearch.
  * <p>
- * Provides interface to interact with USearch library and perform various operations related to indexing and searching.
+ * Provides interface to interact with USearch library and perform various
+ * operations related to indexing and searching.
  *
- * @see <a href="https://nachtimwald.com/2017/06/06/wrapping-a-c-library-in-java/">Wrapping a C library in Java</a>
- * @see <a href="https://www3.ntu.edu.sg/home/ehchua/programming/java/javanativeinterface.html">Java Native Interface tutorial</a>
+ * @see <a href=
+ *      "https://nachtimwald.com/2017/06/06/wrapping-a-c-library-in-java/">Wrapping
+ *      a C library in Java</a>
+ * @see <a href=
+ *      "https://www3.ntu.edu.sg/home/ehchua/programming/java/javanativeinterface.html">Java
+ *      Native Interface tutorial</a>
  */
 public class Index {
 
@@ -20,33 +20,34 @@ public class Index {
   /**
    * Creates a new instance of Index with specified parameters.
    *
-   * @param metric          the metric type for distance calculation between vectors
-   * @param quantization    the scalar type for quantization of vector data
-   * @param dimensions      the number of dimensions in the vectors
-   * @param capacity        the initial capacity of the index
-   * @param connectivity    the connectivity parameter that limits connections-per-node in graph
-   * @param expansion_add   the expansion factor used for index construction when adding vectors
-   * @param expansion_search the expansion factor used for index construction during search operations
+   * @param metric           the metric type for distance calculation between
+   *                         vectors
+   * @param quantization     the scalar type for quantization of vector data
+   * @param dimensions       the number of dimensions in the vectors
+   * @param capacity         the initial capacity of the index
+   * @param connectivity     the connectivity parameter that limits
+   *                         connections-per-node in graph
+   * @param expansion_add    the expansion factor used for index construction when
+   *                         adding vectors
+   * @param expansion_search the expansion factor used for index construction
+   *                         during search operations
    */
   public Index(
-    String metric,
-    String quantization, //
-    long dimensions,
-    long capacity,
-    long connectivity, //
-    long expansion_add,
-    long expansion_search
-  ) {
-    c_ptr =
-      c_create(
+      String metric,
+      String quantization,
+      long dimensions,
+      long capacity,
+      long connectivity,
+      long expansion_add,
+      long expansion_search) {
+    c_ptr = c_create(
         metric,
         quantization,
         dimensions,
         capacity,
         connectivity,
         expansion_add,
-        expansion_search
-      );
+        expansion_search);
   }
 
   /**
@@ -97,8 +98,8 @@ public class Index {
   /**
    * Adds a vector with a specified key to the index.
    *
-   * @param key     the key associated with the vector
-   * @param vector  the vector data
+   * @param key    the key associated with the vector
+   * @param vector the vector data
    */
   public void add(int key, float vector[]) {
     c_add(c_ptr, key, vector);
@@ -107,9 +108,9 @@ public class Index {
   /**
    * Searches for closest vectors to the specified query vector.
    *
-   * @param vector  the query vector data
-   * @param count   the number of nearest neighbors to search
-   * @return        an array of keys of the nearest neighbors
+   * @param vector the query vector data
+   * @param count  the number of nearest neighbors to search
+   * @return an array of keys of the nearest neighbors
    */
   public int[] search(float vector[], long count) {
     return c_search(c_ptr, vector, count);
@@ -146,7 +147,8 @@ public class Index {
    * Removes the vector associated with the given key from the index.
    *
    * @param key the key of the vector to be removed.
-   * @return {@code true} if the vector was successfully removed, {@code false} otherwise.
+   * @return {@code true} if the vector was successfully removed, {@code false}
+   *         otherwise.
    */
   public boolean remove(int key) {
     return c_remove(c_ptr, key);
@@ -156,13 +158,21 @@ public class Index {
    * Renames the vector to map to a different key.
    *
    * @param from the key of the vector to be renamed.
-   * @param to the new key for the vector.
-   * @return {@code true} if the vector was successfully renamed, {@code false} otherwise.
+   * @param to   the new key for the vector.
+   * @return {@code true} if the vector was successfully renamed, {@code false}
+   *         otherwise.
    */
   public boolean rename(int from, int to) {
     return c_rename(c_ptr, from, to);
   }
 
+  /**
+   * Configuration class for building an Index instance.
+   * <p>
+   * This class provides a builder pattern to set various configurations for an
+   * Index. Once all configurations
+   * are set, calling {@link #build()} will produce an instance of {@link Index}.
+   */
   public static class Config {
 
     private String _metric = "ip";
@@ -173,50 +183,102 @@ public class Index {
     private long _expansion_add = 0;
     private long _expansion_search = 0;
 
-    public Config() {}
+    /**
+     * Default constructor for the Config class.
+     */
+    public Config() {
+    }
 
+    /**
+     * Constructs an Index instance based on the current configuration settings.
+     *
+     * @return a newly constructed Index instance.
+     */
     public Index build() {
       return new Index(
-        _metric,
-        _quantization,
-        _dimensions,
-        _capacity,
-        _connectivity,
-        _expansion_add,
-        _expansion_search
-      );
+          _metric,
+          _quantization,
+          _dimensions,
+          _capacity,
+          _connectivity,
+          _expansion_add,
+          _expansion_search);
     }
 
+    /**
+     * Sets the metric for distance calculation between vectors.
+     *
+     * @param _metric the metric type
+     * @return this configuration instance
+     */
     public Config metric(String _metric) {
       this._metric = _metric;
       return this;
     }
 
+    /**
+     * Sets the scalar type for quantization of vector data.
+     *
+     * @param _quantization the quantization type
+     * @return this configuration instance
+     */
     public Config quantization(String _quantization) {
       this._quantization = _quantization;
       return this;
     }
 
+    /**
+     * Sets the number of dimensions in the vectors.
+     *
+     * @param _dimensions the number of dimensions
+     * @return this configuration instance
+     */
     public Config dimensions(long _dimensions) {
       this._dimensions = _dimensions;
       return this;
     }
 
+    /**
+     * Sets the initial capacity of the index.
+     *
+     * @param _capacity the index capacity
+     * @return this configuration instance
+     */
     public Config capacity(long _capacity) {
       this._capacity = _capacity;
       return this;
     }
 
+    /**
+     * Sets the connectivity parameter that limits connections-per-node in the
+     * graph.
+     *
+     * @param _connectivity the connectivity value
+     * @return this configuration instance
+     */
     public Config connectivity(long _connectivity) {
       this._connectivity = _connectivity;
       return this;
     }
 
+    /**
+     * Sets the expansion factor used for index construction when adding vectors.
+     *
+     * @param _expansion_add the expansion factor for adding vectors
+     * @return this configuration instance
+     */
     public Config expansion_add(long _expansion_add) {
       this._expansion_add = _expansion_add;
       return this;
     }
 
+    /**
+     * Sets the expansion factor used for index construction during search
+     * operations.
+     *
+     * @param _expansion_search the expansion factor for search
+     * @return this configuration instance
+     */
     public Config expansion_search(long _expansion_search) {
       this._expansion_search = _expansion_search;
       return this;
@@ -227,21 +289,25 @@ public class Index {
     System.loadLibrary("usearch");
   }
 
+  /**
+   * A simple main method to test the Index functionalities.
+   *
+   * @param args command line arguments (not used in this case)
+   */
   public static void main(String[] args) {
     Index index = new Index.Config().metric("cos").dimensions(100).build();
     index.size();
     System.out.println("Java tests passed!");
   }
 
-  private static native long c_create( //
-    String metric,
-    String quantization, //
-    long dimensions,
-    long capacity,
-    long connectivity, //
-    long expansion_add,
-    long expansion_search
-  );
+  private static native long c_create(
+      String metric,
+      String quantization,
+      long dimensions,
+      long capacity,
+      long connectivity,
+      long expansion_add,
+      long expansion_search);
 
   private static native void c_destroy(long ptr);
 

package/package.json

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

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);

package/simsimd/package.json

@@ -1,14 +1,14 @@
 {
   "name": "simsimd",
-  "version": "3.3.0",
+  "version": "3.5.3",
   "description": "Vector Similarity Functions 3x-200x Faster than SciPy and NumPy",
   "author": "Ash Vardanian",
   "license": "Apache 2.0",
   "main": "javascript/simsimd.js",
   "type": "module",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/ashvardanian/simsimd.git"
+  "scripts": {
+    "test": "node --test ./javascript/test",
+    "bench": "node ./javascript/bench.js"
   },
   "gypfile": true,
   "engines": {
@@ -19,10 +19,6 @@
     "bindings": "~1.2.1",
     "node-addon-api": "^3.0.0"
   },
-  "scripts": {
-    "test": "node --test ./javascript/test.js",
-    "bench": "node ./javascript/bench.js"
-  },
   "devDependencies": {
     "benchmark": "^2.1.4",
     "mathjs": "^11.11.2",

package/simsimd/setup.py

@@ -27,6 +27,9 @@ if sys.platform == "linux":
     compile_args.append("-fopenmp")
     link_args.append("-lgomp")
 
+    # Add vectorized `logf` implementation from the `glibc`
+    link_args.append("-lm")
+
 if sys.platform == "darwin":
     compile_args.append("-std=c11")
     compile_args.append("-O3")

package/wasmer.toml

@@ -1,6 +1,6 @@
 [package]
 name="unum/usearch"
-version="2.8.3"
+version="2.8.5"
 description="Smaller & Faster Single-File Vector Search Engine from Unum"
 license="Apache-2.0"
 readme="README.md"