usearch 2.8.15 → 2.9.0

package/simsimd/Cargo.toml

@@ -0,0 +1,36 @@
+[package]
+name = "simsimd"
+description = "Fastest SIMD-Accelerated Vector Similarity Functions for x86 and Arm"
+version = "3.8.0"
+edition = "2021"
+license = "Apache-2.0"
+authors = [
+  "Ash Vardanian <1983160+ashvardanian@users.noreply.github.com>",
+  "Pedro Planel <pplanel@gmail.com>",
+]
+repository = "https://github.com/ashvardanian/SimSIMD"
+documentation = "https://docs.rs/simsimd"
+homepage = "https://ashvardanian.com/posts/simsimd-faster-scipy"
+keywords = ["simd", "search", "linear-algebra", "vector"]
+categories = ["mathematics", "hardware-support", "no-std", "wasm", "external-ffi-bindings"]
+
+[lib]
+name = "simsimd"
+path = "rust/lib.rs"
+
+[build-dependencies]
+cc = "1.0.83"
+
+[[bench]]
+name = "cosine"
+harness = false
+path = "rust/benches/cosine.rs"
+
+[[bench]]
+name = "sqeuclidean"
+harness = false
+path = "rust/benches/sqeuclidean.rs"
+
+[dev-dependencies]
+criterion = { version = "0.5.1" }
+rand = { version = "0.8.5" }

package/simsimd/README.md

@@ -1,25 +1,27 @@
 # SimSIMD 📏
 
 <div>
-<a href="https://pepy.tech/project/simsimd"> <img alt="PyPI" src="https://static.pepy.tech/personalized-badge/simsimd?period=month&units=abbreviation&left_color=black&right_color=blue&left_text=Python%20monthly%20installs"> </a>
+<a href="https://pepy.tech/project/simsimd"> <img alt="PyPI" src="https://static.pepy.tech/personalized-badge/simsimd?period=total&units=abbreviation&left_color=black&right_color=blue&left_text=SimSIMD%20Python%20installs"> </a>
 <a href="https://www.npmjs.com/package/simsimd"> <img alt="npm" src="https://img.shields.io/npm/dy/simsimd?label=npm%20dowloads"> </a>
+<a href="https://crates.io/crates/simsimd"> <img alt="rust" src="https://img.shields.io/crates/d/simsimd?logo=rust" /> </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]
+## Hardware-Accelerated Similarity Metrics and Distance Functions
 
-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.
+- Zero-dependency [header-only C 99](#using-simsimd-in-c) library.
+- Bindings for [Python](#using-simsimd-in-python), [Rust](#using-simsimd-in-rust) and [JavaScript](#using-simsimd-in-javascript).
+- Targets ARM NEON, SVE, x86 AVX2, AVX-512 (VNNI, FP16) hardware backends.
+- Zero-copy compatible with NumPy, PyTorch, TensorFlow, and other tensors.
+- Handles `f64` double-, `f32` single-, and `f16` half-precision, `i8` integral, and binary vectors.
+- __Up to 200x faster__ than [`scipy.spatial.distance`][scipy] and [`numpy.inner`][numpy].
+- Used in [USearch](https://github.com/unum-cloud/usearch) and several DBMS products.
 
-- ✅ __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.
-- ✅ Has __no dependencies__, not even LibC.
-- ✅ [JavaScript API](#using-simsimd-in-javascript).
-- ✅ [C API](#using-simsimd-in-c).
+__Implemented distance functions__ include:
+
+- Euclidean (L2), Inner Distance, and Cosine (Angular) spatial distances.
+- Hamming (~ Manhattan) and Jaccard (~ Tanimoto) binary distances.
+- Kullback-Leibler and Jensen–Shannon divergences for probability distributions.
 
 [scipy]: https://docs.scipy.org/doc/scipy/reference/spatial.distance.html#module-scipy.spatial.distance
 [numpy]: https://numpy.org/doc/stable/reference/generated/numpy.inner.html
@@ -43,18 +45,18 @@ Given 1000 embeddings from OpenAI Ada API with 1536 dimensions, running on the A
 | :------------- | ----------------: | ----------------: | ---------------: | :------------------------------------- | :-------------- |
 | Cosine         |          __32 x__ |          __79 x__ |        __133 x__ | `scipy.spatial.distance.cosine`        | `cosine`        |
 | Euclidean ²    |           __5 x__ |          __26 x__ |         __17 x__ | `scipy.spatial.distance.sqeuclidean`   | `sqeuclidean`   |
-| Inner Product  |           __2 x__ |           __9 x__ |         __18 x__ | `numpy.inner`                          | `inner`         |
+| Inner Distance |           __2 x__ |           __9 x__ |         __18 x__ | `numpy.inner`                          | `inner`         |
 | Jensen Shannon |          __31 x__ |          __53 x__ |                  | `scipy.spatial.distance.jensenshannon` | `jensenshannon` |
 
 ### Intel Sapphire Rapids
 
-On the Intel Sapphire Rapids platform, SimSIMD was benchmarked against auto-vectorized code using GCC 12. GCC handles single-precision `float`, but might not be the best choice for `int8` and `_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` but might not be the best choice for `int8` and `_Float16` arrays, which has been part of the C language since 2011.
 
 | Kind           | 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__ |
 | Euclidean ²    |     4.62 M/s | _147.25 k/s_ |    _5.32 M/s_ |          __36 x__ |
-| Inner Product  |     3.81 M/s | _192.02 k/s_ |    _5.99 M/s_ |          __31 x__ |
+| Inner Distance |     3.81 M/s | _192.02 k/s_ |    _5.99 M/s_ |          __31 x__ |
 | Jensen Shannon |     1.18 M/s |  _18.13 k/s_ |    _2.14 M/s_ |         __118 x__ |
 
 __Broader Benchmarking Results__:
@@ -63,7 +65,7 @@ __Broader Benchmarking Results__:
 - [4th Gen Intel Xeon Platinum](https://ashvardanian.com/posts/simsimd-faster-scipy/#appendix-2-performance-on-4th-gen-intel-xeon-platinum-8480).
 - [AWS Graviton 3](https://ashvardanian.com/posts/simsimd-faster-scipy/#appendix-3-performance-on-aws-graviton-3).
 
-## Using in Python
+## Using SimSIMD in Python
 
 ### Installation
 
@@ -92,7 +94,7 @@ batch2 = np.random.randn(100, 1536).astype(np.float32)
 dist = simsimd.cosine(batch1, batch2)
 ```
 
-If either batch has more than one vector, the other batch must have one or same number of vectors.
+If either batch has more than one vector, the other batch must have one or the same number of vectors.
 If it contains just one, the value is broadcasted.
 
 ### All Pairwise Distances
@@ -124,7 +126,7 @@ print(simsimd.get_capabilities())
 ### Using Python API with USearch
 
 Want to use it in Python with [USearch](https://github.com/unum-cloud/usearch)?
-You can wrap the raw C function pointers SimSIMD backends into a `CompiledMetric`, and pass it to USearch, similar to how it handles Numba's JIT-compiled code.
+You can wrap the raw C function pointers SimSIMD backends into a `CompiledMetric` and pass it to USearch, similar to how it handles Numba's JIT-compiled code.
 
 ```py
 from usearch.index import Index, CompiledMetric, MetricKind, MetricSignature
@@ -139,9 +141,46 @@ metric = CompiledMetric(
 index = Index(256, metric=metric)
 ```
 
+## Using SimSIMD in Rust
+
+To install, add the following to your `Cargo.toml`:
+
+```toml
+[dependencies]
+simsimd = "..."
+```
+
+To use it:
+
+```rust
+use simsimd::{cosine, sqeuclidean};
+
+fn main() {
+    let vector_a = vec![1.0, 2.0, 3.0];
+    let vector_b = vec![4.0, 5.0, 6.0];
+
+    let distance = cosine(&vector_a, &vector_b);
+    println!("Cosine Distance: {}", distance);
+
+    let distance = sqeuclidean(&vector_a, &vector_b);
+    println!("Squared Euclidean Distance: {}", distance);
+}
+```
+
 ## Using SimSIMD in JavaScript
 
-After you add `simsimd` as a dependency and `npm install`, you will be able to call SimSIMD function on various `TypedArray` variants:
+To install, choose one of the following options depending on your environment:
+
+- `npm install --save simsimd`
+- `yarn add simsimd`
+- `pnpm add simsimd`
+- `bun install simsimd`
+
+The package is distributed with prebuilt binaries for Node.js v10 and above for Linux (x86_64, arm64), macOS (x86_64, arm64), and Windows (i386,x86_64).
+
+If your platform is not supported, you can build the package from source via `npm run build`. This will automatically happen unless you install the package with `--ignore-scripts` flag or use Bun.
+
+After you install it, you will be able to call the SimSIMD functions on various `TypedArray` variants:
 
 ```js
 const { sqeuclidean, cosine, inner, hamming, jaccard } = require('simsimd');
@@ -155,8 +194,6 @@ console.log('Squared Euclidean Distance:', distance);
 
 ## Using SimSIMD in C
 
-If you're aiming to utilize the `_Float16` functionality with SimSIMD, ensure your development environment is compatible with C 11. For other functionalities of SimSIMD, C 99 compatibility will suffice.
-
 For integration within a CMake-based project, add the following segment to your `CMakeLists.txt`:
 
 ```cmake
@@ -166,12 +203,30 @@ FetchContent_Declare(
     GIT_SHALLOW TRUE
 )
 FetchContent_MakeAvailable(simsimd)
-include_directories(${simsimd_SOURCE_DIR}/include)
 ```
 
-Stay updated with the latest advancements by always using the most recent compiler available for your platform. This ensures that you benefit from the newest intrinsics.
+If you're aiming to utilize the `_Float16` functionality with SimSIMD, ensure your development environment is compatible with C 11.
+For other functionalities of SimSIMD, C 99 compatibility will suffice.
+A minimal usage example would be:
+
+```c
+#include <simsimd/simsimd.h>
+
+int main() {
+    simsimd_f32_t vector_a[1536];
+    simsimd_f32_t vector_b[1536];
+    simsimd_f32_t distance = simsimd_avx512_f32_cos(vector_a, vector_b, 1536);
+    return 0;
+}
+```
+
+All of the functions names follow the same pattern: `simsimd_{backend}_{type}_{metric}`.
 
-Should you wish to integrate SimSIMD within USearch, simply compile USearch with the flag `USEARCH_USE_SIMSIMD=1`. Notably, this is the default setting on the majority of platforms.
+- The backend can be `avx512`, `avx2`, `neon`, or `sve`.
+- The type can be `f64`, `f32`, `f16`, `i8`, or `b8`.
+- The metric can be `cos`, `ip`, `l2sq`, `hamming`, `jaccard`, `kl`, or `js`.
+
+In case you want to avoid hard-coding the backend, you can use the `simsimd_metric_punned_t` to pun the function pointer, and `simsimd_capabilities` function to get the available backends at runtime.
 
 ## Benchmarking and Contributing
 
@@ -189,6 +244,9 @@ __To test and benchmark with Python bindings__:
 ```sh
 pip install -e .
 pytest python/test.py -s -x 
+
+pip install numpy scipy scikit-learn # for comparison baselines
+python python/bench.py # to run default benchmarks
 python python/bench.py --n 1000 --ndim 1000000 # batch size and dimensions
 ```
 
@@ -207,3 +265,11 @@ cd golang
 go test # To test
 go test -run=^$ -bench=. -benchmem # To benchmark
 ```
+
+__To test and benchmark Rust bindings__:
+
+```sh
+cargo test 
+cargo bench 
+open ./target/criterion/report/index.html
+```

package/simsimd/binding.gyp

@@ -1,4 +1,7 @@
 {
+    "variables": {
+        "openssl_fips": ""
+    },
     "targets": [
         {
             "target_name": "simsimd",
@@ -13,6 +16,21 @@
                 "-Wno-cast-function-type",
                 "-Wno-switch",
             ],
+            "conditions": [
+                ["OS=='mac'", {
+                    "xcode_settings": {
+                        "MACOSX_DEPLOYMENT_TARGET": "11.0",
+                        "OTHER_CFLAGS": [
+                            "-arch arm64",
+                            "-arch x86_64"
+                        ],
+                        "OTHER_LDFLAGS": [
+                            "-arch arm64",
+                            "-arch x86_64"
+                        ]
+                    }
+                }]
+            ]
         }
     ]
 }

package/simsimd/build.rs

@@ -0,0 +1,20 @@
+fn main() {
+    cc::Build::new()
+        .file("rust/lib.c")
+        .include("include")
+        .flag("-O3")
+        .flag("-DSIMSIMD_NATIVE_F16=0")
+        .flag("-std=c99") // Enforce C99 standard
+        .flag("-pedantic") // Ensure strict compliance with the C standard
+        .warnings(false)
+        .compile("simsimd");
+
+    println!("cargo:rerun-if-changed=rust/lib.c");
+    println!("cargo:rerun-if-changed=rust/lib.rs");
+    println!("cargo:rerun-if-changed=include/simsimd/simsimd.h");
+
+    println!("cargo:rerun-if-changed=include/simsimd/binary.h");
+    println!("cargo:rerun-if-changed=include/simsimd/probability.h");
+    println!("cargo:rerun-if-changed=include/simsimd/spatial.h");
+    println!("cargo:rerun-if-changed=include/simsimd/types.h");
+}

package/simsimd/include/simsimd/probability.h

@@ -271,7 +271,7 @@ simsimd_avx2_f32_log2(__m256 x) {
 __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);
+    __m256 sum_vec = _mm256_setzero_ps();
     simsimd_f32_t epsilon = SIMSIMD_F32_DIVISION_EPSILON;
     __m256 epsilon_vec = _mm256_set1_ps(epsilon);
     simsimd_size_t i = 0;
@@ -303,7 +303,7 @@ simsimd_avx2_f16_kl(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size
 __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);
+    __m256 sum_vec = _mm256_setzero_ps();
     simsimd_f32_t epsilon = SIMSIMD_F32_DIVISION_EPSILON;
     __m256 epsilon_vec = _mm256_set1_ps(epsilon);
     simsimd_size_t i = 0;
@@ -377,7 +377,7 @@ simsimd_avx512_f32_log2(__m512 x) {
 __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);
+    __m512 sum_vec = _mm512_setzero();
     simsimd_f32_t epsilon = SIMSIMD_F32_DIVISION_EPSILON;
     __m512 epsilon_vec = _mm512_set1_ps(epsilon);
     __m512 a_vec, b_vec;
@@ -407,8 +407,8 @@ simsimd_avx512_f32_kl_cycle:
 __attribute__((target("avx512f,avx512vl,bmi2"))) //
 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);
+    __m512 sum_a_vec = _mm512_setzero();
+    __m512 sum_b_vec = _mm512_setzero();
     simsimd_f32_t epsilon = SIMSIMD_F32_DIVISION_EPSILON;
     __m512 epsilon_vec = _mm512_set1_ps(epsilon);
     __m512 a_vec, b_vec;

package/simsimd/include/simsimd/simsimd.h

@@ -11,8 +11,12 @@
  *  Detecting target CPU features at compile time: https://stackoverflow.com/a/28939692/2766161
  */
 
-#ifndef SIMSIMD_SIMSIMD_H
-#define SIMSIMD_SIMSIMD_H
+#ifndef SIMSIMD_H
+#define SIMSIMD_H
+
+#define SIMSIMD_VERSION_MAJOR 3
+#define SIMSIMD_VERSION_MINOR 8
+#define SIMSIMD_VERSION_PATCH 0
 
 #include "binary.h"      // Hamming, Jaccard
 #include "probability.h" // Kullback-Leibler, Jensen–Shannon
@@ -65,7 +69,7 @@ typedef enum {
  */
 typedef enum {
     simsimd_cap_serial_k = 1,       ///< Serial (non-SIMD) capability
-    simsimd_cap_any_k = 0xFFFFFFFF, ///< Mask representing any capability
+    simsimd_cap_any_k = 0x7FFFFFFF, ///< Mask representing any capability with `INT_MAX`
 
     simsimd_cap_arm_neon_k = 1 << 10, ///< ARM NEON capability
     simsimd_cap_arm_sve_k = 1 << 11,  ///< ARM SVE capability
@@ -108,11 +112,11 @@ typedef simsimd_f32_t (*simsimd_metric_punned_t)(void const* a, void const* b, s
  *  @brief  Function to determine the SIMD capabilities of the current machine at @b runtime.
  *  @return A bitmask of the SIMD capabilities represented as a `simsimd_capability_t` enum value.
  */
-inline static simsimd_capability_t simsimd_capabilities() {
+inline static simsimd_capability_t simsimd_capabilities(void) {
 
 #if SIMSIMD_TARGET_X86
 
-    /// The states of 4 registers populated for a specific "cpuid" assmebly call
+    /// The states of 4 registers populated for a specific "cpuid" assembly call
     union four_registers_t {
         int array[4];
         struct separate_t {

package/simsimd/include/simsimd/spatial.h

@@ -548,12 +548,11 @@ simsimd_sve_f64_cos(simsimd_f64_t const* a, simsimd_f64_t const* b, simsimd_size
     // Avoid `simsimd_approximate_inverse_square_root` on Arm NEON
     simsimd_f64_t a2_b2_arr[2] = {a2, b2};
     float64x2_t a2_b2 = vld1q_f64(a2_b2_arr);
-    a2_b2 = 	vrsqrteq_f64(a2_b2);
+    a2_b2 = vrsqrteq_f64(a2_b2);
     vst1q_f64(a2_b2_arr, a2_b2);
     return ab != 0 ? 1 - ab * a2_b2_arr[0] * a2_b2_arr[1] : 1;
 }
 
-
 #endif // SIMSIMD_TARGET_ARM_SVE
 #endif // SIMSIMD_TARGET_ARM
 
@@ -574,7 +573,7 @@ simsimd_sve_f64_cos(simsimd_f64_t const* a, simsimd_f64_t const* b, simsimd_size
 __attribute__((target("avx2,f16c,fma"))) //
 inline static simsimd_f32_t
 simsimd_avx2_f16_l2sq(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n) {
-    __m256 d2_vec = _mm256_set1_ps(0);
+    __m256 d2_vec = _mm256_setzero_ps();
     simsimd_size_t i = 0;
     for (; i + 8 <= n; i += 8) {
         __m256 a_vec = _mm256_cvtph_ps(_mm_loadu_si128((__m128i const*)(a + i)));
@@ -601,7 +600,7 @@ simsimd_avx2_f16_l2sq(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_si
 __attribute__((target("avx2,f16c,fma"))) //
 inline static simsimd_f32_t
 simsimd_avx2_f16_ip(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n) {
-    __m256 ab_vec = _mm256_set1_ps(0);
+    __m256 ab_vec = _mm256_setzero_ps();
     simsimd_size_t i = 0;
     for (; i + 8 <= n; i += 8) {
         __m256 a_vec = _mm256_cvtph_ps(_mm_loadu_si128((__m128i const*)(a + i)));
@@ -625,7 +624,7 @@ __attribute__((target("avx2,f16c,fma"))) //
 inline static simsimd_f32_t
 simsimd_avx2_f16_cos(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n) {
 
-    __m256 ab_vec = _mm256_set1_ps(0), a2_vec = _mm256_set1_ps(0), b2_vec = _mm256_set1_ps(0);
+    __m256 ab_vec = _mm256_setzero_ps(), a2_vec = _mm256_setzero_ps(), b2_vec = _mm256_setzero_ps();
     simsimd_size_t i = 0;
     for (; i + 8 <= n; i += 8) {
         __m256 a_vec = _mm256_cvtph_ps(_mm_loadu_si128((__m128i const*)(a + i)));
@@ -814,7 +813,7 @@ simsimd_avx2_i8_ip(simsimd_i8_t const* a, simsimd_i8_t const* b, simsimd_size_t
 __attribute__((target("avx512f,avx512vl,bmi2"))) //
 inline static simsimd_f32_t
 simsimd_avx512_f32_l2sq(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n) {
-    __m512 d2_vec = _mm512_set1_ps(0);
+    __m512 d2_vec = _mm512_setzero();
     __m512 a_vec, b_vec;
 
 simsimd_avx512_f32_l2sq_cycle:
@@ -839,7 +838,7 @@ simsimd_avx512_f32_l2sq_cycle:
 __attribute__((target("avx512f,avx512vl,bmi2"))) //
 inline static simsimd_f32_t
 simsimd_avx512_f32_ip(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n) {
-    __m512 ab_vec = _mm512_set1_ps(0);
+    __m512 ab_vec = _mm512_setzero();
     __m512 a_vec, b_vec;
 
 simsimd_avx512_f32_ip_cycle:
@@ -863,9 +862,9 @@ simsimd_avx512_f32_ip_cycle:
 __attribute__((target("avx512f,avx512vl,bmi2"))) //
 inline static simsimd_f32_t
 simsimd_avx512_f32_cos(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t n) {
-    __m512 ab_vec = _mm512_set1_ps(0);
-    __m512 a2_vec = _mm512_set1_ps(0);
-    __m512 b2_vec = _mm512_set1_ps(0);
+    __m512 ab_vec = _mm512_setzero();
+    __m512 a2_vec = _mm512_setzero();
+    __m512 b2_vec = _mm512_setzero();
     __m512 a_vec, b_vec;
 
 simsimd_avx512_f32_cos_cycle:
@@ -910,7 +909,7 @@ simsimd_avx512_f32_cos_cycle:
 __attribute__((target("avx512fp16,avx512vl,avx512f,bmi2"))) //
 inline static simsimd_f32_t
 simsimd_avx512_f16_l2sq(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n) {
-    __m512h d2_vec = _mm512_set1_ph(0);
+    __m512h d2_vec = _mm512_setzero_ph();
     __m512i a_i16_vec, b_i16_vec;
 
 simsimd_avx512_f16_l2sq_cycle:
@@ -935,7 +934,7 @@ simsimd_avx512_f16_l2sq_cycle:
 __attribute__((target("avx512fp16,avx512vl,avx512f,bmi2"))) //
 inline static simsimd_f32_t
 simsimd_avx512_f16_ip(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n) {
-    __m512h ab_vec = _mm512_set1_ph(0);
+    __m512h ab_vec = _mm512_setzero_ph();
     __m512i a_i16_vec, b_i16_vec;
 
 simsimd_avx512_f16_ip_cycle:
@@ -959,9 +958,9 @@ simsimd_avx512_f16_ip_cycle:
 __attribute__((target("avx512fp16,avx512vl,avx512f,bmi2"))) //
 inline static simsimd_f32_t
 simsimd_avx512_f16_cos(simsimd_f16_t const* a, simsimd_f16_t const* b, simsimd_size_t n) {
-    __m512h ab_vec = _mm512_set1_ph(0);
-    __m512h a2_vec = _mm512_set1_ph(0);
-    __m512h b2_vec = _mm512_set1_ph(0);
+    __m512h ab_vec = _mm512_setzero_ph();
+    __m512h a2_vec = _mm512_setzero_ph();
+    __m512h b2_vec = _mm512_setzero_ph();
     __m512i a_i16_vec, b_i16_vec;
 
 simsimd_avx512_f16_cos_cycle:
@@ -1084,7 +1083,7 @@ simsimd_avx512_i8_ip(simsimd_i8_t const* a, simsimd_i8_t const* b, simsimd_size_
 __attribute__((target("avx512f,avx512vl,bmi2"))) //
 inline static simsimd_f32_t
 simsimd_avx512_f64_l2sq(simsimd_f64_t const* a, simsimd_f64_t const* b, simsimd_size_t n) {
-    __m512d d2_vec = _mm512_set1_pd(0);
+    __m512d d2_vec = _mm512_setzero_pd();
     __m512d a_vec, b_vec;
 
 simsimd_avx512_f64_l2sq_cycle:
@@ -1109,7 +1108,7 @@ simsimd_avx512_f64_l2sq_cycle:
 __attribute__((target("avx512f,avx512vl,bmi2"))) //
 inline static simsimd_f32_t
 simsimd_avx512_f64_ip(simsimd_f64_t const* a, simsimd_f64_t const* b, simsimd_size_t n) {
-    __m512d ab_vec = _mm512_set1_pd(0);
+    __m512d ab_vec = _mm512_setzero_pd();
     __m512d a_vec, b_vec;
 
 simsimd_avx512_f64_ip_cycle:
@@ -1133,9 +1132,9 @@ simsimd_avx512_f64_ip_cycle:
 __attribute__((target("avx512f,avx512vl,bmi2"))) //
 inline static simsimd_f32_t
 simsimd_avx512_f64_cos(simsimd_f64_t const* a, simsimd_f64_t const* b, simsimd_size_t n) {
-    __m512d ab_vec = _mm512_set1_pd(0);
-    __m512d a2_vec = _mm512_set1_pd(0);
-    __m512d b2_vec = _mm512_set1_pd(0);
+    __m512d ab_vec = _mm512_setzero_pd();
+    __m512d a2_vec = _mm512_setzero_pd();
+    __m512d b2_vec = _mm512_setzero_pd();
     __m512d a_vec, b_vec;
 
 simsimd_avx512_f64_cos_cycle:
@@ -1173,4 +1172,4 @@ simsimd_avx512_f64_cos_cycle:
 }
 #endif
 
-#endif
+#endif

package/simsimd/include/simsimd/types.h

@@ -102,7 +102,7 @@ typedef signed char simsimd_i8_t;
 typedef unsigned char simsimd_b8_t;
 typedef unsigned long long simsimd_size_t;
 
-#if !defined(SIMSIMD_NATIVE_F16)
+#if !defined(SIMSIMD_NATIVE_F16) || SIMSIMD_NATIVE_F16
 /**
  *  @brief  Half-precision floating-point type.
  *
@@ -112,12 +112,16 @@ typedef unsigned long long simsimd_size_t;
  */
 #if (defined(__GNUC__) || defined(__clang__)) && (defined(__ARM_ARCH) || defined(__aarch64__)) &&                      \
     (defined(__ARM_FP16_FORMAT_IEEE))
+#if !defined(SIMSIMD_NATIVE_F16)
 #define SIMSIMD_NATIVE_F16 1
+#endif
 typedef __fp16 simsimd_f16_t;
 #elif ((defined(__GNUC__) || defined(__clang__)) && (defined(__x86_64__) || defined(__i386__)) &&                      \
        (defined(__SSE2__) || defined(__AVX512F__)))
 typedef _Float16 simsimd_f16_t;
+#if !defined(SIMSIMD_NATIVE_F16)
 #define SIMSIMD_NATIVE_F16 1
+#endif
 #else // Unknown compiler or architecture
 #define SIMSIMD_NATIVE_F16 0
 #endif // Unknown compiler or architecture

package/simsimd/javascript/bench.js

@@ -1,9 +1,8 @@
-import benchmark from 'benchmark';
-import bindings from 'bindings';
-import * as math from 'mathjs';
-import usearch, { MetricKind } from 'usearch';
-
-const simsimd = bindings('simsimd');
+const benchmark = require('benchmark');
+const math = require('mathjs');
+const usearch = require('usearch');
+const MetricKind = usearch.MetricKind;
+const simsimd = require("./dist/cjs/simsimd.js");
 
 // Assuming the vectors are of the same length
 function cosineDistance(a, b) {
@@ -29,6 +28,8 @@ function cosineDistanceMathJS(a, b) {
 const dimensions = 1536;  // Adjust dimensions as needed
 const array1 = Array.from({ length: dimensions }, () => Math.random() * 100);
 const array2 = Array.from({ length: dimensions }, () => Math.random() * 100);
+const mathm1 = math.matrix(Array.from({ length: dimensions }, () => Math.random() * 100));
+const mathm2 = math.matrix(Array.from({ length: dimensions }, () => Math.random() * 100));
 const floatArray1 = new Float32Array(array1);
 const floatArray2 = new Float32Array(array2);
 const intArray1 = new Int8Array(array1);
@@ -65,8 +66,8 @@ singleSuite
     .add('Array of Numbers with MathJS', () => {
         cosineDistanceMathJS(array1, array2);
     })
-    .add('TypedArray of Float32 with MathJS', () => {
-        cosineDistanceMathJS(floatArray1, floatArray2);
+    .add('MathMatrix with MathJS', () => {
+        cosineDistanceMathJS(mathm1, mathm2);
     })
 
     // SimSIMD
@@ -78,7 +79,11 @@ singleSuite
     })
 
     .on('cycle', (event) => {
-        console.log(String(event.target));
+        if (event.target.error) {
+            console.error(String(event.target.error));
+        } else {
+            console.log(String(event.target));
+        }
     })
     .on('complete', () => {
         console.log('Fastest Single-Vector Processing is ' + singleSuite.filter('fastest').map('name'));
@@ -106,7 +111,11 @@ batchSuite
         usearch.exactSearch(intMatrix1, intMatrix2, dimensions, 1, MetricKind.Cos);
     })
     .on('cycle', (event) => {
-        console.log(String(event.target));
+        if (event.target.error) {
+            console.error(String(event.target.error));
+        } else {
+            console.log(String(event.target));
+        }
     })
     .on('complete', () => {
         console.log('Fastest Batch-Vector Processing is ' + batchSuite.filter('fastest').map('name'));
@@ -115,3 +124,4 @@ batchSuite
         noCache: true,
         async: false,
     });
+

package/simsimd/javascript/dist-package-cjs.json

@@ -0,0 +1,3 @@
+{
+    "type": "commonjs"
+}

package/simsimd/javascript/dist-package-esm.json

@@ -0,0 +1,3 @@
+{
+    "type": "module"
+}