usearch 2.7.3 → 2.7.7

package/simsimd/.github/workflows/update_version.sh

@@ -1,3 +1,5 @@
 #!/bin/sh
 
-echo $1 > VERSION
+echo $1 > VERSION && \
+    sed -i "s/\"version\": \".*\"/\"version\": \"$1\"/" package.json && \
+    sed -i "s/\"__version__\", \".*\"/\"__version__\", \"$1\"/" python/lib.c

package/simsimd/.releaserc

@@ -11,6 +11,10 @@
             {
                 "preset": "eslint",
                 "releaseRules": [
+                    {
+                        "tag": "Break",
+                        "release": "major"
+                    },
                     {
                         "tag": "Add",
                         "release": "minor"
@@ -35,6 +39,10 @@
             {
                 "preset": "eslint",
                 "releaseRules": [
+                    {
+                        "tag": "Break",
+                        "release": "major"
+                    },
                     {
                         "tag": "Add",
                         "release": "minor"
@@ -68,7 +76,7 @@
                     "VERSION",
                     "conanfile.py",
                     "package.json",
-                    "Cargo.toml",
+                    "Cargo.toml"
                 ],
                 "message": "Build: Released ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
             }

package/simsimd/.vscode/launch.json

@@ -10,6 +10,9 @@
             "request": "launch",
             "program": "${workspaceFolder}/build_debug/simsimd_bench",
             "cwd": "${workspaceFolder}",
+            "args": [
+                "--benchmark_filter=i8_cos"
+            ],
             "environment": [
                 {
                     "name": "ASAN_OPTIONS",

package/simsimd/.vscode/settings.json

@@ -86,16 +86,29 @@
         "__nullptr": "cpp",
         "unordered_set": "cpp",
         "span": "cpp",
-        "arm_neon.h": "c"
+        "arm_neon.h": "c",
+        "__tree": "cpp",
+        "filesystem": "cpp"
     },
     "cSpell.words": [
+        "castsi",
         "dtype",
         "dtypes",
+        "jaccard",
         "kann",
+        "Kullback",
+        "Leibler",
+        "loadu",
         "maccs",
+        "maskz",
+        "napi",
         "simd",
         "simsimd",
+        "sqeuclidean",
         "tanimoto",
-        "unsw"
+        "typedarray",
+        "unsw",
+        "Vardanian",
+        "vpopcntdq"
     ]
 }

package/simsimd/.vscode/tasks.json

@@ -3,7 +3,7 @@
     "tasks": [
         {
             "label": "Build Benchmark: Debug",
-            "command": "cmake -DCMAKE_BUILD_TYPE=Debug -B ./build_debug && make -j 2 -C ./build_debug",
+            "command": "cmake -DCMAKE_BUILD_TYPE=Debug -DSIMSIMD_BUILD_BENCHMARKS=1 -B ./build_debug && make -j 2 -C ./build_debug",
             "args": [],
             "type": "shell"
         },
@@ -15,7 +15,7 @@
         },
         {
             "label": "Build Benchmark: Release",
-            "command": "cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo -B ./build_release && make -j 2 -C ./build_release",
+            "command": "cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo -DSIMSIMD_BUILD_BENCHMARKS=1 -B ./build_release && make -j 2 -C ./build_release",
             "args": [],
             "type": "shell"
         }

package/simsimd/CMakeLists.txt

@@ -1,18 +1,21 @@
+# SimSIMD library CMakeLists.txt
 cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
-project(simsimd LANGUAGES CXX C)
+project(simsimd LANGUAGES C CXX)
+
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD_REQUIRED YES)
+set(CMAKE_C_EXTENSIONS NO)
+
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED YES)
 set(CMAKE_CXX_EXTENSIONS NO)
 
-option(SIMSIMD_USE_OPENMP "Use OpenMP for Parallelism" OFF)
 option(SIMSIMD_BUILD_BENCHMARKS "Compile a micro-benchmark for current ISA" OFF)
 
-# Get external content: Google Benchmark, Thrust
+# Fetch external dependencies
 include(FetchContent)
-include_directories(include/)
 
-# Fetch GBenchmark and surpress internal tests.
-# https://github.com/google/benchmark/blob/main/docs/user_guide.md#using-register-benchmark
+# Suppress building tests of Google Benchmark
 set(BENCHMARK_ENABLE_TESTING OFF)
 set(BENCHMARK_ENABLE_INSTALL OFF)
 set(BENCHMARK_ENABLE_DOXYGEN OFF)
@@ -20,67 +23,45 @@ set(BENCHMARK_INSTALL_DOCS OFF)
 set(BENCHMARK_DOWNLOAD_DEPENDENCIES ON)
 set(BENCHMARK_ENABLE_GTEST_TESTS OFF)
 set(BENCHMARK_USE_BUNDLED_GTEST ON)
+
 FetchContent_Declare(
-    benchmark
-    GIT_REPOSITORY https://github.com/google/benchmark.git
-    GIT_TAG v1.7.0
-)
+  benchmark
+  GIT_REPOSITORY https://github.com/google/benchmark.git
+  GIT_TAG v1.7.0)
 FetchContent_MakeAvailable(benchmark)
 
-# Make Release by default
+# Default to Release build type if not set
 if(NOT CMAKE_BUILD_TYPE)
-    set(CMAKE_BUILD_TYPE Release)
+  set(CMAKE_BUILD_TYPE Release)
 endif()
 
-set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g -fsanitize=address")
-set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
-set(CMAKE_C_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g -fsanitize=address")
-set(CMAKE_C_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
+# Global compiler flags for debug and release
+set(CMAKE_CXX_FLAGS_DEBUG "-g -fsanitize=address")
+set(CMAKE_CXX_FLAGS_RELEASE "-O3")
+set(CMAKE_C_FLAGS_DEBUG "-g -fsanitize=address")
+set(CMAKE_C_FLAGS_RELEASE "-O3")
 
-# List of all possible compiler IDs:
-# https://cmake.org/cmake/help/latest/variable/CMAKE_LANG_COMPILER_ID.html
-if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
+# Compiler-specific flags
+if(CMAKE_CXX_COMPILER_ID MATCHES "^(Apple)?Clang$")
+  if(NOT APPLE)
+    add_compile_options(-march=native)
+  endif()
+  add_compile_options(-pedantic -ferror-limit=1 -ffast-math)
 elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic -fmax-errors=1")
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=native")
-    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pedantic -fmax-errors=1")
-elseif(CMAKE_CXX_COMPILER_ID STREQUAL "NVIDIA" OR CMAKE_CXX_COMPILER_ID STREQUAL "NVHPC")
-    set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --expt-relaxed-constexpr --extended-lambda")
-    set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -gencode arch=compute_86,code=sm_86")
-
+  add_compile_options(-march=native -pedantic -fmax-errors=1 -ffast-math)
 elseif(CMAKE_CXX_COMPILER_ID STREQUAL "IntelLLVM")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -w")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ferror-limit=1")
+  add_compile_options(-w -ferror-limit=1)
 endif()
 
-# Define our header-only library.
+# Define the header-only library
+file(GLOB SIMSIMD_SOURCES include/simsimd/*.h)
 add_library(simsimd INTERFACE)
-target_sources(simsimd INTERFACE include/simsimd/simsimd.h)
+target_sources(simsimd INTERFACE ${SIMSIMD_SOURCES})
 target_include_directories(simsimd INTERFACE "${PROJECT_SOURCE_DIR}/include")
 
-# Build the benchmarks if needed.
-if(${SIMSIMD_BUILD_BENCHMARKS})
-    find_package(Threads REQUIRED)
-    add_executable(simsimd_bench bench.cxx)
-    target_link_libraries(simsimd_bench simsimd Threads::Threads benchmark)
-
-    if(${SIMSIMD_USE_OPENMP})
-        find_package(OpenMP REQUIRED)
-        target_link_libraries(simsimd_bench OpenMP::OpenMP_CXX)
-    endif()
-
-    if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-
-    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-
-    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "NVIDIA" OR CMAKE_CXX_COMPILER_ID STREQUAL "NVHPC")
-        set_property(SOURCE simsimd_bench.cpp PROPERTY LANGUAGE CUDA)
-        set_target_properties(simsimd_bench PROPERTIES POSITION_INDEPENDENT_CODE ON)
-        set_target_properties(simsimd_bench PROPERTIES CUDA_ARCHITECTURES "86")
-
-    elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Intel" OR CMAKE_CXX_COMPILER_ID STREQUAL "IntelLLVM")
-    endif()
+# Build benchmarks if required
+if(SIMSIMD_BUILD_BENCHMARKS)
+  find_package(Threads REQUIRED)
+  add_executable(simsimd_bench cpp/bench.cxx)
+  target_link_libraries(simsimd_bench simsimd Threads::Threads benchmark)
 endif()

package/simsimd/README.md

@@ -1,41 +1,129 @@
 # SimSIMD 📏
 
-SIMD-accelerated similarity measures, metrics, and distance functions for x86 and Arm.
-They are tuned for Machine Learning applications and mid-size vectors with 100-1024 dimensions.
-One can expect the following performance for Cosine (Angular) distance, the most common metric in AI.
+## Efficient Alternative to [`scipy.spatial.distance`][scipy] and [`numpy.inner`][numpy]
 
-| Method | Vectors | Any Length | Speed on 256b | Speed on 1024b |
-| :----- | :------ | :--------- | ------------: | -------------: |
-| Serial | `f32`   | ✅          |        5 GB/s |         5 GB/s |
-| SVE    | `f32`   | ✅          |       34 GB/s |        40 GB/s |
-| SVE    | `f16`   | ✅          |       28 GB/s |        35 GB/s |
-| NEON   | `f16`   | ❌          |       16 GB/s |        18 GB/s |
+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.
 
-> The benchmarks were done on Arm-based "Graviton 3" CPUs powering AWS `c7g.metal` instances.
-> We only use Arm NEON implementation with vector lengths multiples of 128 bits, avoiding additional head or tail `for` loops for misaligned data.
-> By default, we use GCC12, `-O3`, `-march=native` for benchmarks.
-> Serial versions imply auto-vectorization pragmas.
+- ✅ __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.
+- ✅ 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).
 
-Need something like this in your CMake-based project?
+[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
 
-```cmake
-FetchContent_Declare(
-    simsimd
-    GIT_REPOSITORY https://github.com/ashvardanian/simsimd.git
-    GIT_SHALLOW TRUE
-)
-FetchContent_MakeAvailable(simsimd)
-include_directories(${simsimd_SOURCE_DIR}/include)
+## Benchmarks
+
+### Apple M2 Pro
+
+Given 1000 embeddings from OpenAI Ada API with 1536 dimensions, running on the Apple M2 Pro Arm CPU with NEON support, here's how SimSIMD performs against conventional methods:
+
+| Conventional                           | SimSIMD           | `f32` improvement | `f16` improvement | `i8` improvement |
+| :------------------------------------- | :---------------- | ----------------: | ----------------: | ---------------: |
+| `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.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.
+
+|               | 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__ |
+
+__Technical Insights__:
+
+- [Uses Arm SVE and x86 AVX-512's masked loads to eliminate tail `for`-loops](https://ashvardanian.com/posts/simsimd-faster-scipy/#tails-of-the-past-the-significance-of-masked-loads).
+- [Uses AVX-512 FP16 for half-precision operations, that few compilers vectorize](https://ashvardanian.com/posts/simsimd-faster-scipy/#the-challenge-of-f16).
+- [Substitutes LibC's `sqrt` calls with bithacks using Jan Kadlec's constant](https://ashvardanian.com/posts/simsimd-faster-scipy/#bonus-section-bypassing-sqrt-and-libc-dependencies).
+- Avoids slow PyBind11 and SWIG, directly using the CPython C API.
+- Avoids slow `PyArg_ParseTuple` and manually unpacks argument tuples.
+
+__Broader Benchmarking Results__:
+
+- [Apple M2 Pro](https://ashvardanian.com/posts/simsimd-faster-scipy/#appendix-1-performance-on-apple-m2-pro).
+- [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
+
+### Installation
+
+```sh
+pip install simsimd
+```
+
+### Distance Between 2 Vectors
+
+```py
+import simsimd
+import numpy as np
+
+vec1 = np.random.randn(1536).astype(np.float32)
+vec2 = np.random.randn(1536).astype(np.float32)
+dist = simsimd.cosine(vec1, vec2)
+```
+
+Supported functions include `cosine`, `inner`, `sqeuclidean`, `hamming`, and `jaccard`.
+
+### Distance Between 2 Batches
+
+```py
+batch1 = np.random.randn(100, 1536).astype(np.float32)
+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 it contains just one, the value is broadcasted.
+
+### All Pairwise Distances
+
+For calculating distances between all possible pairs of rows across two matrices (akin to [`scipy.spatial.distance.cdist`](https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.distance.cdist.html)):
+
+```py
+matrix1 = np.random.randn(1000, 1536).astype(np.float32)
+matrix2 = np.random.randn(10, 1536).astype(np.float32)
+distances = simsimd.cdist(matrix1, matrix2, metric="cosine")
+```
+
+### Multithreading
+
+By default, computations use a single CPU core. To optimize and utilize all CPU cores on Linux systems, add the `threads=0` argument. Alternatively, specify a custom number of threads:
+
+```py
+distances = simsimd.cdist(matrix1, matrix2, metric="cosine", threads=0)
 ```
 
+### Hardware Backend Capabilities
+
+To view a list of hardware backends that SimSIMD supports:
+
+```py
+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.
 
 ```py
-from usearch import Index, CompiledMetric, MetricKind, MetricSignature
-from simsimd import to_int, cos_f32x4_neon
+from usearch.index import Index, CompiledMetric, MetricKind, MetricSignature
+from simsimd import pointer_to_sqeuclidean, pointer_to_cosine, pointer_to_inner
 
 metric = CompiledMetric(
-    pointer=to_int(cos_f32x4_neon),
+    pointer=pointer_to_cosine("f16"),
     kind=MetricKind.Cos,
     signature=MetricSignature.ArrayArraySize,
 )
@@ -43,100 +131,66 @@ metric = CompiledMetric(
 index = Index(256, metric=metric)
 ```
 
-## Available Metrics
-
-In the C99 interface, all functions are prepended with the `simsimd_` namespace prefix.
-The signature defines the number of arguments:
-
-- two pointers, and length,
-- two pointers.
-
-The latter is intended for cases where the number of dimensions is hard-coded.
-Constraints define the limitations on the number of dimensions an argument vector can have.
-
-| Name                    | Signature | ISA Extension |  Constraints   |
-| :---------------------- | :-------: | :-----------: | :------------: |
-| `dot_f32_sve`           |    ✳️✳️📏    |    Arm SVE    |                |
-| `dot_f32x4_neon`        |    ✳️✳️📏    |   Arm NEON    |  `d % 4 == 0`  |
-| `cos_f32_sve`           |    ✳️✳️📏    |    Arm SVE    |                |
-| `cos_f16_sve`           |    ✳️✳️📏    |    Arm SVE    |                |
-| `cos_f16x4_neon`        |    ✳️✳️📏    |   Arm NEON    |  `d % 4 == 0`  |
-| `cos_i8x16_neon`        |    ✳️✳️📏    |   Arm NEON    | `d % 16 == 0`  |
-| `cos_f32x4_neon`        |    ✳️✳️📏    |   Arm NEON    |  `d % 4 == 0`  |
-| `cos_f16x16_avx512`     |    ✳️✳️📏    |  x86 AVX-512  | `d % 16 == 0`  |
-| `cos_f32x4_avx2`        |    ✳️✳️📏    |   x86 AVX2    |  `d % 4 == 0`  |
-| `l2sq_f32_sve`          |    ✳️✳️📏    |    Arm SVE    |                |
-| `l2sq_f16_sve`          |    ✳️✳️📏    |    Arm SVE    |                |
-| `hamming_b1x8_sve`      |    ✳️✳️📏    |    Arm SVE    |  `d % 8 == 0`  |
-| `hamming_b1x128_sve`    |    ✳️✳️📏    |    Arm SVE    | `d % 128 == 0` |
-| `hamming_b1x128_avx512` |    ✳️✳️📏    |  x86 AVX-512  | `d % 128 == 0` |
-| `tanimoto_b1x8_naive`   |    ✳️✳️📏    |               |  `d % 8 == 0`  |
-| `tanimoto_maccs_naive`  |    ✳️✳️     |               |   `d == 166`   |
-| `tanimoto_maccs_neon`   |    ✳️✳️     |   Arm NEON    |   `d == 166`   |
-| `tanimoto_maccs_sve`    |    ✳️✳️     |    Arm SVE    |   `d == 166`   |
-| `tanimoto_maccs_avx512` |    ✳️✳️     |  x86 AVX-512  |   `d == 166`   |
+## Using SimSIMD in JavaScript
 
-## Benchmarks
+After you add `simsimd` as a dependency and `npm install`, you will be able to call SimSIMD function on various `TypedArray` variants:
+
+```js
+const { sqeuclidean, cosine, inner, hamming, jaccard } = require('simsimd');
+
+const vectorA = new Float32Array([1.0, 2.0, 3.0]);
+const vectorB = new Float32Array([4.0, 5.0, 6.0]);
+
+const distance = sqeuclidean(vectorA, vectorB);
+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
+FetchContent_Declare(
+    simsimd
+    GIT_REPOSITORY https://github.com/ashvardanian/simsimd.git
+    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.
+
+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.
+
+__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
+```
 
-The benchmarks are repeated for every function with a different number of cores involved.
-Light-weight distance functions would be memory bound, implying that multi-core performance may be lower if the bus bandwidth cannot saturate all the cores.
-Similarly, heavy-weight distance functions running on all cores may result in CPU frequency downclocking.
-This is well illustrated by the single-core performance of the Intel `i9-13950HX`, equipped with DDR5 memory.
-
-| Method                 | Threads | Vector Size |     Speed |
-| :--------------------- | ------: | ----------: | --------: |
-| `dot_f32x4_avx2`       |       1 |      1024 b | 96.2 GB/s |
-| `dot_f32x4_avx2`       |      32 |      1024 b | 23.6 GB/s |
-| `cos_f32_naive`        |       1 |      1024 b | 15.3 GB/s |
-| `cos_f32_naive`        |      32 |      1024 b |  4.5 GB/s |
-| `cos_f32x4_avx2`       |       1 |      1024 b | 56.3 GB/s |
-| `cos_f32x4_avx2`       |      32 |      1024 b | 13.9 GB/s |
-| `tanimoto_maccs_naive` |       1 |        21 b |  2.8 GB/s |
-| `tanimoto_maccs_naive` |      32 |        21 b |  1.2 GB/s |
-
-Switching to the Intel Sapphire Rapids server platform, we can also evaluate some of the AVX-512 extensions, including `VPOPCNTDQ` and `F16`.
-
-| Method                  | Threads | Vector Size |      Speed |
-| :---------------------- | ------: | ----------: | ---------: |
-| `dot_f32x4_avx2`        |       1 |      1024 b |  57.8 GB/s |
-| `dot_f32x4_avx2`        |     224 |      1024 b |  16.1 GB/s |
-| `cos_f32_naive`         |       1 |      1024 b |  10.7 GB/s |
-| `cos_f32_naive`         |     224 |      1024 b |   3.0 GB/s |
-| `cos_f32x4_avx2`        |       1 |      1024 b |  39.5 GB/s |
-| `cos_f32x4_avx2`        |     224 |      1024 b |  15.1 GB/s |
-| `cos_f16x16_avx512`     |       1 |      1024 b |  50.6 GB/s |
-| `cos_f16x16_avx512`     |     224 |      1024 b |  15.9 GB/s |
-| `hamming_b1x128_avx512` |       1 |      1024 b | 790.3 GB/s |
-| `hamming_b1x128_avx512` |     224 |      1024 b | 259.3 GB/s |
-| `tanimoto_maccs_naive`  |       1 |        21 b |   3.0 GB/s |
-| `tanimoto_maccs_naive`  |     224 |        21 b |   1.3 GB/s |
-| `tanimoto_maccs_avx512` |       1 |        21 b |  13.1 GB/s |
-| `tanimoto_maccs_avx512` |     224 |        21 b |   3.7 GB/s |
-
-To replicate this on your hardware, please run the following on Linux:
+__To test and benchmark with Python bindings__:
 
 ```sh
-git clone https://github.com/ashvardanian/SimSIMD.git && cd SimSIMD
-cmake -DCMAKE_BUILD_TYPE=Release -DSIMSIMD_BUILD_BENCHMARKS=1 \
-    -DCMAKE_CXX_COMPILER="g++-12" -DCMAKE_C_COMPILER="gcc-12" \
-    -B ./build && make -C ./build && ./build/simsimd_bench
+pip install -e .
+pytest python/test.py -s -x 
+python python/bench.py --n 1000 --ndim 1000000 # batch size and dimensions
 ```
 
-MacOS:
+__To test and benchmark JavaScript bindings__:
 
 ```sh
-brew install llvm
-git clone https://github.com/ashvardanian/SimSIMD.git && cd SimSIMD
-cmake -B ./build \
-    -DCMAKE_C_COMPILER="/opt/homebrew/opt/llvm/bin/clang" \
-    -DCMAKE_CXX_COMPILER="/opt/homebrew/opt/llvm/bin/clang++" \
-    -DSIMSIMD_BUILD_BENCHMARKS=1 \
-    && \
-    make -C ./build -j && ./build/simsimd_bench
+npm install --dev
+npm test
+npm bench
 ```
 
-Install and test locally:
+__To test and benchmark GoLang bindings__:
 
 ```sh
-pip install -e . && pytest python/test.py -s -x
+cd golang
+go test # To test
+go test -run=^$ -bench=. -benchmem # To benchmark
 ```

package/simsimd/binding.gyp

@@ -0,0 +1,18 @@
+{
+    "targets": [
+        {
+            "target_name": "simsimd",
+            "sources": ["javascript/lib.c"],
+            "include_dirs": ["include"],
+            "cflags": [
+                "-std=c11",
+                "-ffast-math",
+                "-Wno-unknown-pragmas",
+                "-Wno-maybe-uninitialized",
+                "-Wno-cast-function-type",
+                "-Wno-switch",
+                "-DSIMSIMD_NATIVE_F16=0",
+            ],
+        }
+    ]
+}