usearch 2.8.8 → 2.8.10

package/CITATION.cff

@@ -5,7 +5,7 @@ authors:
   given-names: "Ash"
   orcid: "https://orcid.org/0000-0002-4882-1815"
 title: "USearch by Unum Cloud"
-version: 2.8.8
+version: 2.8.10
 doi: 10.5281/zenodo.7949416
 date-released: 2023-10-22
 url: "https://github.com/unum-cloud/usearch"

package/CONTRIBUTING.md

@@ -144,6 +144,29 @@ node --test ./javascript/usearch.test.js
 npm publish
 ```
 
+To compile for AWS Lambda you'd need to recompile the binding.
+You can test the setup locally, overriding some of the compilation variables in Docker image:
+
+```Dockerfile
+FROM public.ecr.aws/lambda/nodejs:18-x86_64
+RUN npm init -y
+RUN yum install tar git python3 cmake gcc-c++ -y && yum groupinstall "Development Tools" -y
+
+# Assuming AWS Linux 2 uses old compilers:
+ENV USEARCH_USE_FP16LIB 1
+ENV DUSEARCH_USE_SIMSIMD 1
+ENV SIMSIMD_TARGET_X86_AVX2 1
+ENV SIMSIMD_TARGET_X86_AVX512 0
+ENV SIMSIMD_TARGET_ARM_NEON 1
+ENV SIMSIMD_TARGET_ARM_SVE 0
+
+# For specific PR:
+# RUN npm install --build-from-source unum-cloud/usearch#pull/302/head
+# For specific version:
+# RUN npm install --build-from-source usearch@2.8.8
+RUN npm install --build-from-source usearch
+```
+
 To compile to WebAssembly make sure you have `emscripten` installed and run the following script:
 
 ```sh

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "usearch"
-version = "2.8.8"
+version = "2.8.10"
 authors = ["Ash Vardanian <1983160+ashvardanian@users.noreply.github.com>"]
 description = "Smaller & Faster Single-File Vector Search Engine from Unum"
 edition = "2021"

package/README.md

@@ -50,6 +50,7 @@ Linux • MacOS • Windows • iOS • WebAssembly
 - ✅ [20x faster than][faster-than-faiss] [FAISS][faiss] implementation of [HNSW algorithm][hnsw-algorithm].
 - ✅ Simple and extensible [single C++11 header][usearch-header] implementation.
 - ✅ Compatible with a dozen programming languages out of the box.
+- ✅ [Trusted](#integrations) by some of the most loved Datalakes and Databases, like [ClickHouse][clickhouse-docs].
 - ✅ [SIMD][simd]-optimized and [user-defined metrics](#user-defined-functions) with JIT compilation.
 - ✅ Hardware-agnostic `f16` & `i8` - [half-precision & quarter-precision support](#memory-efficiency-downcasting-and-quantization).
 - ✅ [View large indexes from disk](#serving-index-from-disk) without loading into RAM.
@@ -67,6 +68,17 @@ Linux • MacOS • Windows • iOS • WebAssembly
 [hnsw-algorithm]: https://arxiv.org/abs/1603.09320
 [simd]: https://en.wikipedia.org/wiki/Single_instruction,_multiple_data
 [faster-than-faiss]: https://www.unum.cloud/blog/2023-11-07-scaling-vector-search-with-intel
+[clickhouse-docs]: https://clickhouse.com/docs/en/engines/table-engines/mergetree-family/annindexes#usearch
+
+__Technical Insights__ and related articles:
+
+- [Uses Horner's method for polynomial approximations, beating GCC 12 by 119x](https://ashvardanian.com/posts/gcc-12-vs-avx512fp16/).
+- [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).
+- [For every language implements a custom separate binding](https://ashvardanian.com/posts/porting-cpp-library-to-ten-languages/).
+- [For Python avoids slow PyBind11, and even `PyArg_ParseTuple` for speed](https://ashvardanian.com/posts/pybind11-cpython-tutorial/).
+- [For JavaScript uses typed arrays and NAPI for zero-copy calls](https://ashvardanian.com/posts/javascript-ai-vector-search/).
 
 ## Comparison with FAISS
 
@@ -132,34 +144,6 @@ index = Index(
 )
 ```
 
-## User-Defined Functions
-
-While most vector search packages concentrate on just a few metrics - "Inner Product distance" and "Euclidean distance," USearch extends this list to include any user-defined metrics.
-This flexibility allows you to customize your search for various applications, from computing geospatial coordinates with the rare [Haversine][haversine] distance to creating custom metrics for composite embeddings from multiple AI models.
-
-![USearch: Vector Search Approaches](https://github.com/unum-cloud/usearch/blob/main/assets/usearch-approaches-white.png?raw=true)
-
-Unlike older approaches indexing high-dimensional spaces, like KD-Trees and Locality Sensitive Hashing, HNSW doesn't require vectors to be identical in length.
-They only have to be comparable.
-So you can apply it in [obscure][obscure] applications, like searching for similar sets or fuzzy text matching, using [GZip][gzip-similarity] as a distance function.
-
-> Read more about [JIT and UDF in USearch Python SDK](https://unum-cloud.github.io/usearch/python#user-defined-metrics-and-jit-in-python).
-
-[haversine]: https://ashvardanian.com/posts/abusing-vector-search#geo-spatial-indexing
-[obscure]: https://ashvardanian.com/posts/abusing-vector-search
-[gzip-similarity]: https://twitter.com/LukeGessler/status/1679211291292889100?s=20
-
-## Memory Efficiency, Downcasting, and Quantization
-
-Training a quantization model and dimension-reduction is a common approach to accelerate vector search.
-Those, however, are only sometimes reliable, can significantly affect the statistical properties of your data, and require regular adjustments if your distribution shifts.
-
-![USearch uint40_t support](https://github.com/unum-cloud/usearch/blob/main/assets/usearch-neighbor-types.png?raw=true)
-
-Instead, we have focused on high-precision arithmetic over low-precision downcasted vectors.
-The same index, and `add` and `search` operations will automatically down-cast or up-cast between `f32_t`, `f16_t`, `f64_t`, and `i8_t` representations, even if the hardware doesn't natively support it.
-Continuing the topic of memory efficiency, we provide a `uint40_t` to allow collection with over 4B+ vectors without allocating 8 bytes for every neighbor reference in the proximity graph.
-
 ## Serialization & Serving `Index` from Disk
 
 USearch supports multiple forms of serialization:
@@ -275,16 +259,56 @@ pairs: dict = men.join(women, max_proposals=0, exact=False)
 
 > Read more in the post: [Combinatorial Stable Marriages for Semantic Search 💍](https://ashvardanian.com/posts/searching-stable-marriages)
 
+## User-Defined Functions
+
+While most vector search packages concentrate on just a few metrics - "Inner Product distance" and "Euclidean distance," USearch extends this list to include any user-defined metrics.
+This flexibility allows you to customize your search for various applications, from computing geospatial coordinates with the rare [Haversine][haversine] distance to creating custom metrics for composite embeddings from multiple AI models.
+
+![USearch: Vector Search Approaches](https://github.com/unum-cloud/usearch/blob/main/assets/usearch-approaches-white.png?raw=true)
+
+Unlike older approaches indexing high-dimensional spaces, like KD-Trees and Locality Sensitive Hashing, HNSW doesn't require vectors to be identical in length.
+They only have to be comparable.
+So you can apply it in [obscure][obscure] applications, like searching for similar sets or fuzzy text matching, using [GZip][gzip-similarity] as a distance function.
+
+> Read more about [JIT and UDF in USearch Python SDK](https://unum-cloud.github.io/usearch/python#user-defined-metrics-and-jit-in-python).
+
+[haversine]: https://ashvardanian.com/posts/abusing-vector-search#geo-spatial-indexing
+[obscure]: https://ashvardanian.com/posts/abusing-vector-search
+[gzip-similarity]: https://twitter.com/LukeGessler/status/1679211291292889100?s=20
+
+## Memory Efficiency, Downcasting, and Quantization
+
+Training a quantization model and dimension-reduction is a common approach to accelerate vector search.
+Those, however, are only sometimes reliable, can significantly affect the statistical properties of your data, and require regular adjustments if your distribution shifts.
+Instead, we have focused on high-precision arithmetic over low-precision downcasted vectors.
+The same index, and `add` and `search` operations will automatically down-cast or up-cast between `f64_t`, `f32_t`, `f16_t`, `i8_t`, and single-bit representations.
+You can use the following command to check, if hardware acceleration is enabled:
+
+```sh
+$ python -c 'from usearch.index import Index; print(Index(ndim=768, metric="cos", dtype="f16").hardware_acceleration)'
+> avx512+f16
+$ python -c 'from usearch.index import Index; print(Index(ndim=166, metric="tanimoto").hardware_acceleration)'
+> avx512+popcnt
+```
+
+Using smaller numeric types will save you RAM needed to store the vectors, but you can also compress the neighbors lists forming our proximity graphs.
+By default, 32-bit `uint32_t` is used to enumerate those, which is not enough if you need to address over 4 Billion entries.
+For such cases we provide a custom `uint40_t` type, that will still be 37.5% more space-efficient than the commonly used 8-byte integers, and will scale up to 1 Trillion entries.
+
+![USearch uint40_t support](https://github.com/unum-cloud/usearch/blob/main/assets/usearch-neighbor-types.png?raw=true)
+
 ## Functionality
 
 By now, the core functionality is supported across all bindings.
 Broader functionality is ported per request.
+In some cases, like Batch operations, feature parity is meaningless, as the host language has full multi-threading capabilities and the USearch index structure is concurrent by design, so the users can implement batching/scheduling/load-balancing in the most optimal way for their applications.
 
 |                         | C++ 11 | Python 3 | C 99  | Java  | JavaScript | Rust  | GoLang | Swift |
 | :---------------------- | :----: | :------: | :---: | :---: | :--------: | :---: | :----: | :---: |
-| Add, search             |   ✅    |    ✅     |   ✅   |   ✅   |     ✅      |   ✅   |   ✅    |   ✅   |
+| Add, search, remove     |   ✅    |    ✅     |   ✅   |   ✅   |     ✅      |   ✅   |   ✅    |   ✅   |
 | Save, load, view        |   ✅    |    ✅     |   ✅   |   ✅   |     ✅      |   ✅   |   ✅    |   ✅   |
 | User-defined metrics    |   ✅    |    ✅     |   ✅   |   ❌   |     ❌      |   ❌   |   ❌    |   ❌   |
+| Batch operations        |   ❌    |    ✅     |   ❌   |   ❌   |     ✅      |   ❌   |   ❌    |   ❌   |
 | Joins                   |   ✅    |    ✅     |   ❌   |   ❌   |     ❌      |   ❌   |   ❌    |   ❌   |
 | Variable-length vectors |   ✅    |    ❌     |   ❌   |   ❌   |     ❌      |   ❌   |   ❌    |   ❌   |
 | 4B+ capacities          |   ✅    |    ❌     |   ❌   |   ❌   |     ❌      |   ❌   |   ❌    |   ❌   |
@@ -400,7 +424,7 @@ doi = {10.5281/zenodo.7949416},
 author = {Vardanian, Ash},
 title = {{USearch by Unum Cloud}},
 url = {https://github.com/unum-cloud/usearch},
-version = {2.8.8},
+version = {2.8.10},
 year = {2023},
 month = oct,
 }

package/VERSION

@@ -1 +1 @@
-2.8.8
+2.8.10

package/conanfile.py

@@ -7,7 +7,7 @@ required_conan_version = ">=1.53.0"
 class USearchConan(ConanFile):
 
     name = "usearch"
-    version = '2.8.8'
+    version = '2.8.10'
     license = "Apache-2.0"
     description = "Smaller & Faster Single-File Vector Search Engine from Unum"
     homepage = "https://github.com/unum-cloud/usearch"

package/include/usearch/index.hpp

@@ -11,7 +11,7 @@
 
 #define USEARCH_VERSION_MAJOR 2
 #define USEARCH_VERSION_MINOR 8
-#define USEARCH_VERSION_PATCH 8
+#define USEARCH_VERSION_PATCH 10
 
 // Inferring C++ version
 // https://stackoverflow.com/a/61552074

package/include/usearch/index_plugins.hpp

@@ -1402,6 +1402,7 @@ class metric_punned_t {
         case metric_kind_t::cos_k: kind = simsimd_metric_cos_k; break;
         case metric_kind_t::l2sq_k: kind = simsimd_metric_l2sq_k; break;
         case metric_kind_t::hamming_k: kind = simsimd_metric_hamming_k; break;
+        case metric_kind_t::tanimoto_k: kind = simsimd_metric_jaccard_k; break;
         case metric_kind_t::jaccard_k: kind = simsimd_metric_jaccard_k; break;
         default: break;
         }
@@ -1419,7 +1420,7 @@ class metric_punned_t {
         if (simd_metric == nullptr)
             return false;
 
-        raw_ptr_ = (punned_ptr_t)simd_metric;
+        std::memcpy(&raw_ptr_, &simd_metric, sizeof(simd_metric));
         isa_kind_ = simd_kind;
         return true;
     }

package/javascript/README.md

@@ -1,15 +1,16 @@
 # USearch for JavaScript
 
+USearch is a high-performance library for building and querying vector search indexes, optimized for Node.js and WASM environments.
+
 ## Installation
 
-USearch is available both for Node.js backend runtime and WASM frontend runtime.
-For the first option, use the conventional `npm install`:
+For Node.js environments, install USearch using `npm`:
 
 ```sh
 npm install usearch
 ```
 
-For latter:
+For front-end applications using WASM, use the Wasmer package manager:
 
 ```sh
 wasmer install unum/usearch
@@ -17,20 +18,71 @@ wasmer install unum/usearch
 
 ## Quickstart
 
+Create an index, add vectors, and perform searches with ease:
+
 ```js
-var index = new usearch.Index({ metric: 'cos', connectivity: 16n, dimensions: 3n })
-index.add(42n, new Float32Array([0.2, 0.6, 0.4]))
-var results = index.search(new Float32Array([0.2, 0.6, 0.4]), 10n)
+const usearch = require('usearch');
+const index = new usearch.Index({ metric: 'cos', connectivity: 16, dimensions: 3 });
+index.add(42n, new Float32Array([0.2, 0.6, 0.4]));
+const results = index.search(new Float32Array([0.2, 0.6, 0.4]), 10);
+
+assert(index.size() === 1);
+assert.deepEqual(results.keys, new BigUint64Array([42n]));
+assert.deepEqual(results.distances, new Float32Array([0]));
 
-assert.equal(index.size(), 1n)
-assert.deepEqual(results.keys, new BigUint64Array([42n]))
-assert.deepEqual(results.distances, new Float32Array([0]))
+index.remove(42n);
 ```
 
 ## Serialization
 
+Persist and restore your index with serialization methods:
+
+```js
+index.save('index.usearch'); // Save the index to a file
+index.load('index.usearch'); // Load the index from a file
+index.view('index.usearch'); // View the index from a file without loading into memory
+```
+
+## Advanced Index Configuration
+
+Customize your index with additional configuration options:
+
+```js
+const index = new usearch.Index({
+  dimensions: 128,
+  metric: 'ip',
+  quantization: 'f32',
+  connectivity: 10,
+  expansion_add: 5,
+  expansion_search: 3,
+  multi: true
+});
+```
+
+## Batch Operations
+
+Process multiple vectors at once for efficiency.
+For performance reasons we prefer a flattened `TypedArray` over an Array of Arrays:
+
+```js
+const keys = new BigUint64Array([15n, 16n]);
+const vectors = new Float32Array([10, 20, 10, 25]);
+index.add(keys, vectors);
+```
+
+Retrieve batch search results:
+
+```js
+const batchResults = index.search(vectors, 2);
+const firstMatch = batchResults.get(0);
+```
+
+## Index Introspection
+
+Inspect and interact with the index:
+
 ```js
-index.save('index.usearch')
-index.load('index.usearch')
-index.view('index.usearch')
+const dimensions = index.dimensions(); // Get the number of dimensions
+const containsKey = index.contains(42n); // Check if a key is in the index
+const count = index.count(42n); // Get the count of vectors for a key
 ```

package/javascript/lib.cpp

@@ -181,7 +181,7 @@ Napi::Value CompiledIndex::Search(Napi::CallbackInfo const& ctx) {
     std::size_t tasks = queries.ElementLength() / native_->dimensions();
     std::size_t wanted = napi_argument_to_size(ctx[1]);
 
-    auto run_parallel = [&](auto vectors) {
+    auto run_parallel = [&](auto vectors) -> Napi::Value {
         Napi::Array result_js = Napi::Array::New(env, 3);
         Napi::BigUint64Array matches_js = Napi::BigUint64Array::New(env, tasks * wanted);
         Napi::Float32Array distances_js = Napi::Float32Array::New(env, tasks * wanted);
@@ -192,21 +192,29 @@ Napi::Value CompiledIndex::Search(Napi::CallbackInfo const& ctx) {
         auto counts_data = counts_js.Data();
 
         try {
+            bool failed = false;
             executor_stl_t executor;
             executor.fixed(tasks, [&](std::size_t /*thread_idx*/, std::size_t task_idx) {
                 auto result = native_->search(vectors + task_idx * native_->dimensions(), wanted);
                 if (!result) {
-                    // Handle the error appropriately
-                    // For example, log the error or set some flag in the result_js object
+                    failed = true;
+                    Napi::TypeError::New(env, result.error.release()).ThrowAsJavaScriptException();
                 } else {
                     counts_data[task_idx] = result.dump_to(matches_data + task_idx * native_->dimensions(),
                                                            distances_data + task_idx * native_->dimensions());
                 }
             });
+
+            if (failed)
+                return env.Null();
+
         } catch (std::bad_alloc const&) {
             Napi::TypeError::New(env, "Out of memory").ThrowAsJavaScriptException();
+            return env.Null();
+
         } catch (...) {
             Napi::TypeError::New(env, "Search failed").ThrowAsJavaScriptException();
+            return env.Null();
         }
 
         result_js.Set(0u, matches_js);

package/javascript/usearch.js

@@ -247,10 +247,12 @@ class Index {
         // Call the compiled method and create Matches or BatchMatches object with the result
         const result = this._compiledIndex.search(normalizedVectors, k);
         const countInQueries = normalizedVectors.length / Number(this._compiledIndex.dimensions());
+        const batchMatches = new BatchMatches(result[0], result[1], result[2], k);
+
         if (countInQueries === 1) {
-            return new Matches(result[0], result[1]);
+            return batchMatches.get(0);
         } else {
-            return new BatchMatches(result[0], result[1], result[2], k);
+            return batchMatches;
         }
     }
 

package/javascript/usearch.test.js

@@ -36,6 +36,21 @@ test('Batch operations', () => {
     assert.deepEqual(results.distances, new Float32Array([45, 130]), 'distances should be 45 and 130');
 });
 
+test("Expected results", () => {
+    var index = new usearch.Index({
+        metric: "cos",
+        connectivity: 16,
+        dimensions: 3,
+    });
+    index.add(42n, new Float32Array([0.2, 0.6, 0.4]));
+    var results = index.search(new Float32Array([0.2, 0.6, 0.4]), 10);
+
+    assert.equal(index.size(), 1);
+    assert.deepEqual(results.keys, new BigUint64Array([42n]));
+    assert.deepEqual(results.distances, new Float32Array([0]));
+});
+
+
 
 test('Operations with invalid values', () => {
     const indexBatch = new usearch.Index(2, 'l2sq');

package/package.json

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

package/pyproject.toml

@@ -9,7 +9,7 @@ xfail_strict = true
 filterwarnings = ["error"]
 
 # Avoid running tests, as everything is happening in a super slow container
-# We have already run all the relavent Python tests in `prerelease.yml`
+# We have already run all the relavent Python tests in `prerelease.yml`
 #   test-requires = ["pytest", "numpy"]
 #   test-command = "pytest {project}/python/scripts"
 [tool.cibuildwheel]

package/setup.py

@@ -1,6 +1,6 @@
 import os
 import sys
-import subprocess
+import platform
 from setuptools import setup
 
 from pybind11.setup_helpers import Pybind11Extension
@@ -14,28 +14,19 @@ def get_bool_env(name: str, preference: bool) -> bool:
     return os.environ.get(name, "1" if preference else "0") == "1"
 
 
-def get_bool_env_w_name(name: str, preference: bool) -> bool:
-    return name, get_bool_env(name, preference)
-
-
-def get_is_gcc():
-    try:
-        compiler_version = subprocess.check_output(
-            ["c++", "--version"], universal_newlines=True
-        )
-        return "gcc" in compiler_version.lower()
-    except Exception:
-        return False
+def get_bool_env_w_name(name: str, preference: bool) -> tuple:
+    return name, "1" if get_bool_env(name, preference) else "0"
 
 
 # Check the environment variables
+is_gcc = "GCC" in platform.python_compiler().upper()
 is_linux: bool = sys.platform == "linux"
 is_macos: bool = sys.platform == "darwin"
 is_windows: bool = sys.platform == "win32"
 
 prefer_simsimd: bool = is_linux or is_macos
 prefer_fp16lib: bool = True
-prefer_openmp: bool = is_linux and get_is_gcc()
+prefer_openmp: bool = is_linux and is_gcc
 
 use_simsimd: bool = get_bool_env("USEARCH_USE_SIMSIMD", prefer_simsimd)
 use_fp16lib: bool = get_bool_env("USEARCH_USE_FP16LIB", prefer_fp16lib)
@@ -123,6 +114,8 @@ if is_windows:
             ]
         )
 
+print("macros_args", macros_args)
+
 ext_modules = [
     Pybind11Extension(
         "usearch.compiled",

package/simsimd/README.md

@@ -24,38 +24,38 @@ SimSIMD leverages SIMD intrinsics, capabilities that only select compilers effec
 [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
 
+__Technical Insights__ and related articles:
+
+- [Uses Horner's method for polynomial approximations, beating GCC 12 by 119x](https://ashvardanian.com/posts/gcc-12-vs-avx512fp16/).
+- [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).
+- [For Python avoids slow PyBind11, SWIG, and even `PyArg_ParseTuple` for speed](https://ashvardanian.com/posts/pybind11-cpython-tutorial/).
+- [For JavaScript uses typed arrays and NAPI for zero-copy calls](https://ashvardanian.com/posts/javascript-ai-vector-search/).
+
 ## 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`   |          __31 x__ |          __53 x__ |                  |
-| `scipy.special.kl_div`                 | `kullbackleibler` |          __21 x__ |          __18 x__ |                  |
+| Kind           | `f32` improvement | `f16` improvement | `i8` improvement | Conventional method                    | SimSIMD         |
+| :------------- | ----------------: | ----------------: | ---------------: | :------------------------------------- | :-------------- |
+| 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`         |
+| 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.
 
-|                 | GCC 12 `f32` | GCC 12 `f16` | SimSIMD `f16` | `f16` improvement |
-| :-------------- | -----------: | -----------: | ------------: | ----------------: |
-| `cosine`        |     3.28 M/s | _336.29 k/s_ |    _6.88 M/s_ |          __20 x__ |
-| `sqeuclidean`   |     4.62 M/s | _147.25 k/s_ |    _5.32 M/s_ |          __36 x__ |
-| `inner`         |     3.81 M/s | _192.02 k/s_ |    _5.99 M/s_ |          __31 x__ |
-| `jensenshannon` |     1.18 M/s |  _18.13 k/s_ |    _2.14 M/s_ |         __118 x__ |
-
-__Technical Insights__:
-
-- [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.
+| 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__ |
+| Jensen Shannon |     1.18 M/s |  _18.13 k/s_ |    _2.14 M/s_ |         __118 x__ |
 
 __Broader Benchmarking Results__:
 
@@ -173,6 +173,8 @@ Stay updated with the latest advancements by always using the most recent compil
 
 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.
 
+## Benchmarking and Contributing
+
 __To rerun experiments__ utilize the following command:
 
 ```sh

package/simsimd/include/simsimd/binary.h

@@ -17,8 +17,9 @@
  *  x86 intrinsics: https://www.intel.com/content/www/us/en/docs/intrinsics-guide/
  *  Arm intrinsics: https://developer.arm.com/architectures/instruction-sets/intrinsics/
  */
+#ifndef SIMSIMD_BINARY_H
+#define SIMSIMD_BINARY_H
 
-#pragma once
 #include "types.h"
 
 #ifdef __cplusplus
@@ -195,4 +196,6 @@ simsimd_avx512_b8_jaccard_cycle:
 
 #ifdef __cplusplus
 }
-#endif
+#endif
+
+#endif

package/simsimd/include/simsimd/probability.h

@@ -18,8 +18,9 @@
  *  x86 intrinsics: https://www.intel.com/content/www/us/en/docs/intrinsics-guide/
  *  Arm intrinsics: https://developer.arm.com/architectures/instruction-sets/intrinsics/
  */
+#ifndef SIMSIMD_PROBABILITY_H
+#define SIMSIMD_PROBABILITY_H
 
-#pragma once
 #include "types.h"
 
 #define SIMSIMD_MAKE_KL(name, input_type, accumulator_type, converter, epsilon)                                        \
@@ -425,8 +426,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_div_ps(a_vec, m_vec);
-    __m512 ratio_b_vec = _mm512_div_ps(b_vec, 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 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);
@@ -539,4 +540,6 @@ simsimd_avx512_f16_js_cycle:
 
 #ifdef __cplusplus
 }
-#endif
+#endif
+
+#endif

package/simsimd/include/simsimd/simsimd.h

@@ -11,7 +11,9 @@
  *  Detecting target CPU features at compile time: https://stackoverflow.com/a/28939692/2766161
  */
 
-#pragma once
+#ifndef SIMSIMD_SIMSIMD_H
+#define SIMSIMD_SIMSIMD_H
+
 #include "binary.h"      // Hamming, Jaccard
 #include "probability.h" // Kullback-Leibler, Jensen–Shannon
 #include "spatial.h"     // L2, Inner Product, Cosine
@@ -423,3 +425,5 @@ inline static simsimd_metric_punned_t simsimd_metric_punned( //
 #ifdef __cplusplus
 }
 #endif
+
+#endif

package/simsimd/include/simsimd/spatial.h

@@ -20,8 +20,9 @@
  *  x86 intrinsics: https://www.intel.com/content/www/us/en/docs/intrinsics-guide/
  *  Arm intrinsics: https://developer.arm.com/architectures/instruction-sets/intrinsics/
  */
+#ifndef SIMSIMD_SPATIAL_H
+#define SIMSIMD_SPATIAL_H
 
-#pragma once
 #include "types.h"
 
 #define SIMSIMD_MAKE_L2SQ(name, input_type, accumulator_type, converter)                                               \
@@ -1000,4 +1001,6 @@ simsimd_avx512_i8_ip(simsimd_i8_t const* a, simsimd_i8_t const* b, simsimd_size_
 
 #ifdef __cplusplus
 }
+#endif
+
 #endif

package/simsimd/include/simsimd/types.h

@@ -1,67 +1,59 @@
-#pragma once
+#ifndef SIMSIMD_TYPES_H
+#define SIMSIMD_TYPES_H
 
 // Compiling for Arm: SIMSIMD_TARGET_ARM
+#if !defined(SIMSIMD_TARGET_ARM)
 #if defined(__aarch64__) || defined(_M_ARM64)
 #define SIMSIMD_TARGET_ARM 1
+#else
+#define SIMSIMD_TARGET_ARM 0
+#endif // defined(__aarch64__) || defined(_M_ARM64)
+#endif // !defined(SIMSIMD_TARGET_ARM)
+
+// Compiling for x86: SIMSIMD_TARGET_X86
+#if !defined(SIMSIMD_TARGET_X86)
+#if defined(__x86_64__) || defined(_M_X64)
+#define SIMSIMD_TARGET_X86 1
+#else
+#define SIMSIMD_TARGET_X86 0
+#endif // defined(__x86_64__) || defined(_M_X64)
+#endif // !defined(SIMSIMD_TARGET_X86)
 
 // Compiling for Arm: SIMSIMD_TARGET_ARM_NEON
-#if !defined(SIMSIMD_TARGET_ARM_NEON)
+#if !defined(SIMSIMD_TARGET_ARM_NEON) || !SIMSIMD_TARGET_ARM
 #if defined(__ARM_NEON)
-#define SIMSIMD_TARGET_ARM_NEON 1
+#define SIMSIMD_TARGET_ARM_NEON SIMSIMD_TARGET_ARM
 #else
 #define SIMSIMD_TARGET_ARM_NEON 0
-#endif
-#endif
+#endif // defined(__ARM_NEON)
+#endif // !defined(SIMSIMD_TARGET_ARM_NEON)
 
 // Compiling for Arm: SIMSIMD_TARGET_ARM_SVE
-#if !defined(SIMSIMD_TARGET_ARM_SVE)
+#if !defined(SIMSIMD_TARGET_ARM_SVE) || !SIMSIMD_TARGET_ARM
 #if defined(__ARM_FEATURE_SVE)
-#define SIMSIMD_TARGET_ARM_SVE 1
+#define SIMSIMD_TARGET_ARM_SVE SIMSIMD_TARGET_ARM
 #else
 #define SIMSIMD_TARGET_ARM_SVE 0
-#endif
-#endif
-
-#undef SIMSIMD_TARGET_X86
-#undef SIMSIMD_TARGET_X86_AVX2
-#undef SIMSIMD_TARGET_X86_AVX512
-#define SIMSIMD_TARGET_X86 0
-#define SIMSIMD_TARGET_X86_AVX2 0
-#define SIMSIMD_TARGET_X86_AVX512 0
-
-// Compiling for x86: SIMSIMD_TARGET_X86
-#elif defined(__x86_64__) || defined(_M_X64)
-#define SIMSIMD_TARGET_X86 1
+#endif // defined(__ARM_FEATURE_SVE)
+#endif // !defined(SIMSIMD_TARGET_ARM_SVE)
 
 // Compiling for x86: SIMSIMD_TARGET_X86_AVX2
-#if !defined(SIMSIMD_TARGET_X86_AVX2)
+#if !defined(SIMSIMD_TARGET_X86_AVX2) || !SIMSIMD_TARGET_X86
 #if defined(__AVX2__)
 #define SIMSIMD_TARGET_X86_AVX2 1
 #else
 #define SIMSIMD_TARGET_X86_AVX2 0
-#endif
-#endif
+#endif // defined(__AVX2__)
+#endif // !defined(SIMSIMD_TARGET_X86_AVX2)
 
 // Compiling for x86: SIMSIMD_TARGET_X86_AVX512
-#if !defined(SIMSIMD_TARGET_X86_AVX512)
-#if defined(__AVX512F__) || defined(__AVX512VPOPCNTDQ__)
+#if !defined(SIMSIMD_TARGET_X86_AVX512) || !SIMSIMD_TARGET_X86
+#if defined(__AVX512F__) && defined(__AVX512FP16__) && defined(__AVX512VNNI__) && defined(__AVX512VPOPCNTDQ__)
 #define SIMSIMD_TARGET_X86_AVX512 1
 #else
 #define SIMSIMD_TARGET_X86_AVX512 0
-#endif
-#endif
-
-#undef SIMSIMD_TARGET_ARM
-#undef SIMSIMD_TARGET_ARM_NEON
-#undef SIMSIMD_TARGET_ARM_SVE
-#define SIMSIMD_TARGET_ARM 0
-#define SIMSIMD_TARGET_ARM_NEON 0
-#define SIMSIMD_TARGET_ARM_SVE 0
-
-// Compiling for unknown hardware architecture
-#else
-#error Unknown hardware architecture!
-#endif
+#endif // defined(__AVX512F__) && defined(__AVX512FP16__) && defined(__AVX512VNNI__) && defined(__AVX512VPOPCNTDQ__)
+#endif // !defined(SIMSIMD_TARGET_X86_AVX512)
 
 #ifdef _MSC_VER
 #include <intrin.h>
@@ -206,4 +198,6 @@ inline static float simsimd_uncompress_f16(unsigned short x) {
 
 #ifdef __cplusplus
 } // extern "C"
-#endif
+#endif
+
+#endif

package/simsimd/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simsimd",
-  "version": "3.5.3",
+  "version": "3.5.5",
   "description": "Vector Similarity Functions 3x-200x Faster than SciPy and NumPy",
   "author": "Ash Vardanian",
   "license": "Apache 2.0",

package/wasmer.toml

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

package/simsimd/CMakeLists.txt

@@ -1,67 +0,0 @@
-# SimSIMD library CMakeLists.txt
-cmake_minimum_required(VERSION 3.14 FATAL_ERROR)
-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_BUILD_BENCHMARKS "Compile a micro-benchmark for current ISA" OFF)
-
-# Fetch external dependencies
-include(FetchContent)
-
-# Suppress building tests of Google Benchmark
-set(BENCHMARK_ENABLE_TESTING OFF)
-set(BENCHMARK_ENABLE_INSTALL OFF)
-set(BENCHMARK_ENABLE_DOXYGEN OFF)
-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)
-FetchContent_MakeAvailable(benchmark)
-
-# Default to Release build type if not set
-if(NOT CMAKE_BUILD_TYPE)
-  set(CMAKE_BUILD_TYPE Release)
-endif()
-
-# 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")
-
-# 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)
-elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-  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()
-
-# Define the header-only library
-file(GLOB SIMSIMD_SOURCES include/simsimd/*.h)
-add_library(simsimd INTERFACE)
-target_sources(simsimd INTERFACE ${SIMSIMD_SOURCES})
-target_include_directories(simsimd INTERFACE "${PROJECT_SOURCE_DIR}/include")
-
-# 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/cpp/bench.cxx

@@ -1,206 +0,0 @@
-#include <cmath>  // `std::sqrt`
-#include <thread> // `std::thread`
-
-#include <benchmark/benchmark.h>
-
-#define SIMSIMD_RSQRT(x) (1 / sqrtf(x))
-#define SIMSIMD_LOG(x) (logf(x))
-#include <simsimd/simsimd.h>
-
-namespace bm = benchmark;
-
-template <typename return_at, typename... args_at>
-constexpr std::size_t number_of_arguments(return_at (*f)(args_at...)) {
-    return sizeof...(args_at);
-}
-
-template <typename scalar_at, std::size_t dimensions_ak> struct vectors_pair_gt {
-    scalar_at a[dimensions_ak]{};
-    scalar_at b[dimensions_ak]{};
-
-    std::size_t dimensions() const noexcept { return dimensions_ak; }
-    std::size_t size_bytes() const noexcept { return dimensions_ak * sizeof(scalar_at); }
-
-    void set(scalar_at v) noexcept {
-        for (std::size_t i = 0; i != dimensions_ak; ++i)
-            a[i] = b[i] = v;
-    }
-
-    void randomize() noexcept {
-
-        double a2_sum = 0, b2_sum = 0;
-        for (std::size_t i = 0; i != dimensions_ak; ++i) {
-            if constexpr (std::is_integral_v<scalar_at>)
-                a[i] = static_cast<scalar_at>(rand()), b[i] = static_cast<scalar_at>(rand());
-            else {
-                double ai = double(rand()) / double(RAND_MAX), bi = double(rand()) / double(RAND_MAX);
-                a2_sum += ai * ai, b2_sum += bi * bi;
-                a[i] = static_cast<scalar_at>(ai), b[i] = static_cast<scalar_at>(bi);
-            }
-        }
-
-        // Normalize the vectors:
-        if constexpr (!std::is_integral_v<scalar_at>) {
-            a2_sum = std::sqrt(a2_sum);
-            b2_sum = std::sqrt(b2_sum);
-            for (std::size_t i = 0; i != dimensions_ak; ++i)
-                a[i] = static_cast<scalar_at>(a[i] / a2_sum), b[i] = static_cast<scalar_at>(b[i] / b2_sum);
-        }
-    }
-};
-
-template <typename pair_at, typename metric_at = void>
-static void measure(bm::State& state, metric_at metric, metric_at baseline) {
-
-    pair_at pair;
-    pair.randomize();
-    // pair.set(1);
-
-    double c_baseline = baseline(pair.a, pair.b, pair.dimensions());
-    double c = 0;
-    std::size_t iterations = 0;
-    for (auto _ : state)
-        bm::DoNotOptimize((c = metric(pair.a, pair.b, pair.dimensions()))), iterations++;
-
-    state.counters["bytes"] = bm::Counter(iterations * pair.size_bytes() * 2, bm::Counter::kIsRate);
-    state.counters["pairs"] = bm::Counter(iterations, bm::Counter::kIsRate);
-
-    double delta = std::abs(c - c_baseline) > 0.0001 ? std::abs(c - c_baseline) : 0;
-    double error = delta != 0 && c_baseline != 0 ? delta / c_baseline : 0;
-    state.counters["abs_delta"] = delta;
-    state.counters["relative_error"] = error;
-}
-
-template <typename scalar_at, typename metric_at = void>
-void register_(std::string name, metric_at* distance_func, metric_at* baseline_func) {
-
-    using pair_dims_t = vectors_pair_gt<scalar_at, 1536>;
-    using pair_bytes_t = vectors_pair_gt<scalar_at, 1536 / sizeof(scalar_at)>;
-
-    std::size_t seconds = 10;
-    std::size_t threads = 1; // std::thread::hardware_concurrency(); // 1;
-    std::string name_dims = name + "_" + std::to_string(pair_dims_t{}.dimensions()) + "d";
-    std::string name_bytes = name + "_" + std::to_string(pair_bytes_t{}.size_bytes()) + "b";
-
-    bm::RegisterBenchmark(name_dims.c_str(), measure<pair_dims_t, metric_at*>, distance_func, baseline_func)
-        ->MinTime(seconds)
-        ->Threads(threads);
-    bm::RegisterBenchmark(name_bytes.c_str(), measure<pair_bytes_t, metric_at*>, distance_func, baseline_func)
-        ->MinTime(seconds)
-        ->Threads(threads);
-}
-
-int main(int argc, char** argv) {
-
-    bool compiled_with_sve = false;
-    bool compiled_with_neon = false;
-    bool compiled_with_avx2 = false;
-    bool compiled_with_avx512vpopcntdq = false;
-    bool compiled_with_avx512vnni = false;
-
-#if defined(__ARM_FEATURE_SVE)
-    compiled_with_sve = true;
-#endif
-#if defined(__ARM_NEON)
-    compiled_with_neon = true;
-#endif
-#if defined(__AVX2__)
-    compiled_with_avx2 = true;
-#endif
-#if defined(__AVX512VPOPCNTDQ__)
-    compiled_with_avx512vpopcntdq = true;
-#endif
-#if defined(__AVX512VNNI__)
-    compiled_with_avx512vnni = true;
-#endif
-
-    // Log supported functionality
-    char const* flags[2] = {"false", "true"};
-    std::printf("Benchmarking Similarity Measures\n");
-    std::printf("\n");
-    std::printf("- Arm NEON support enabled: %s\n", flags[compiled_with_neon]);
-    std::printf("- Arm SVE support enabled: %s\n", flags[compiled_with_sve]);
-    std::printf("- x86 AVX2 support enabled: %s\n", flags[compiled_with_avx2]);
-    std::printf("- x86 AVX512VPOPCNTDQ support enabled: %s\n", flags[compiled_with_avx512vpopcntdq]);
-    std::printf("- x86 AVX512VNNI support enabled: %s\n", flags[compiled_with_avx512vnni]);
-    std::printf("\n");
-
-    // Run the benchmarks
-    bm::Initialize(&argc, argv);
-    if (bm::ReportUnrecognizedArguments(argc, argv))
-        return 1;
-
-#if SIMSIMD_TARGET_ARM_NEON
-    register_<simsimd_f16_t>("neon_f16_ip", simsimd_neon_f16_ip, simsimd_accurate_f16_ip);
-    register_<simsimd_f16_t>("neon_f16_cos", simsimd_neon_f16_cos, simsimd_accurate_f16_cos);
-    register_<simsimd_f16_t>("neon_f16_l2sq", simsimd_neon_f16_l2sq, simsimd_accurate_f16_l2sq);
-    register_<simsimd_f16_t>("neon_f16_kl", simsimd_neon_f16_kl, simsimd_accurate_f16_kl);
-    register_<simsimd_f16_t>("neon_f16_js", simsimd_neon_f16_js, simsimd_accurate_f16_js);
-
-    register_<simsimd_f32_t>("neon_f32_ip", simsimd_neon_f32_ip, simsimd_accurate_f32_ip);
-    register_<simsimd_f32_t>("neon_f32_cos", simsimd_neon_f32_cos, simsimd_accurate_f32_cos);
-    register_<simsimd_f32_t>("neon_f32_l2sq", simsimd_neon_f32_l2sq, simsimd_accurate_f32_l2sq);
-    register_<simsimd_f32_t>("neon_f32_kl", simsimd_neon_f32_kl, simsimd_accurate_f32_kl);
-    register_<simsimd_f32_t>("neon_f32_js", simsimd_neon_f32_js, simsimd_accurate_f32_js);
-
-    register_<simsimd_i8_t>("neon_i8_cos", simsimd_neon_i8_cos, simsimd_accurate_i8_cos);
-    register_<simsimd_i8_t>("neon_i8_l2sq", simsimd_neon_i8_l2sq, simsimd_accurate_i8_l2sq);
-#endif
-
-#if SIMSIMD_TARGET_ARM_SVE
-    register_<simsimd_f16_t>("sve_f16_ip", simsimd_sve_f16_ip, simsimd_accurate_f16_ip);
-    register_<simsimd_f16_t>("sve_f16_cos", simsimd_sve_f16_cos, simsimd_accurate_f16_cos);
-    register_<simsimd_f16_t>("sve_f16_l2sq", simsimd_sve_f16_l2sq, simsimd_accurate_f16_l2sq);
-
-    register_<simsimd_f32_t>("sve_f32_ip", simsimd_sve_f32_ip, simsimd_accurate_f32_ip);
-    register_<simsimd_f32_t>("sve_f32_cos", simsimd_sve_f32_cos, simsimd_accurate_f32_cos);
-    register_<simsimd_f32_t>("sve_f32_l2sq", simsimd_sve_f32_l2sq, simsimd_accurate_f32_l2sq);
-#endif
-
-#if SIMSIMD_TARGET_X86_AVX2
-    register_<simsimd_f16_t>("avx2_f16_ip", simsimd_avx2_f16_ip, simsimd_accurate_f16_ip);
-    register_<simsimd_f16_t>("avx2_f16_cos", simsimd_avx2_f16_cos, simsimd_accurate_f16_cos);
-    register_<simsimd_f16_t>("avx2_f16_l2sq", simsimd_avx2_f16_l2sq, simsimd_accurate_f16_l2sq);
-    register_<simsimd_f16_t>("avx2_f16_kl", simsimd_avx2_f16_kl, simsimd_accurate_f16_kl);
-    register_<simsimd_f16_t>("avx2_f16_js", simsimd_avx2_f16_js, simsimd_accurate_f16_js);
-
-    register_<simsimd_i8_t>("avx2_i8_cos", simsimd_avx2_i8_cos, simsimd_accurate_i8_cos);
-    register_<simsimd_i8_t>("avx2_i8_l2sq", simsimd_avx2_i8_l2sq, simsimd_accurate_i8_l2sq);
-#endif
-
-#if SIMSIMD_TARGET_X86_AVX512
-    register_<simsimd_f16_t>("avx512_f16_ip", simsimd_avx512_f16_ip, simsimd_accurate_f16_ip);
-    register_<simsimd_f16_t>("avx512_f16_cos", simsimd_avx512_f16_cos, simsimd_accurate_f16_cos);
-    register_<simsimd_f16_t>("avx512_f16_l2sq", simsimd_avx512_f16_l2sq, simsimd_accurate_f16_l2sq);
-    register_<simsimd_f16_t>("avx512_f16_kl", simsimd_avx512_f16_kl, simsimd_accurate_f16_kl);
-    register_<simsimd_f16_t>("avx512_f16_js", simsimd_avx512_f16_js, simsimd_accurate_f16_js);
-
-    register_<simsimd_i8_t>("avx512_i8_cos", simsimd_avx512_i8_cos, simsimd_accurate_i8_cos);
-    register_<simsimd_i8_t>("avx512_i8_l2sq", simsimd_avx512_i8_l2sq, simsimd_accurate_i8_l2sq);
-
-    register_<simsimd_f32_t>("avx512_f32_ip", simsimd_avx512_f32_ip, simsimd_accurate_f32_ip);
-    register_<simsimd_f32_t>("avx512_f32_cos", simsimd_avx512_f32_cos, simsimd_accurate_f32_cos);
-    register_<simsimd_f32_t>("avx512_f32_l2sq", simsimd_avx512_f32_l2sq, simsimd_accurate_f32_l2sq);
-    register_<simsimd_f32_t>("avx512_f32_kl", simsimd_avx512_f32_kl, simsimd_accurate_f32_kl);
-    register_<simsimd_f32_t>("avx512_f32_js", simsimd_avx512_f32_js, simsimd_accurate_f32_js);
-#endif
-
-    register_<simsimd_f16_t>("serial_f16_ip", simsimd_serial_f16_ip, simsimd_accurate_f16_ip);
-    register_<simsimd_f16_t>("serial_f16_cos", simsimd_serial_f16_cos, simsimd_accurate_f16_cos);
-    register_<simsimd_f16_t>("serial_f16_l2sq", simsimd_serial_f16_l2sq, simsimd_accurate_f16_l2sq);
-    register_<simsimd_f16_t>("serial_f16_kl", simsimd_serial_f16_kl, simsimd_accurate_f16_kl);
-    register_<simsimd_f16_t>("serial_f16_js", simsimd_serial_f16_js, simsimd_accurate_f16_js);
-
-    register_<simsimd_f32_t>("serial_f32_ip", simsimd_serial_f32_ip, simsimd_accurate_f32_ip);
-    register_<simsimd_f32_t>("serial_f32_cos", simsimd_serial_f32_cos, simsimd_accurate_f32_cos);
-    register_<simsimd_f32_t>("serial_f32_l2sq", simsimd_serial_f32_l2sq, simsimd_accurate_f32_l2sq);
-    register_<simsimd_f32_t>("serial_f32_kl", simsimd_serial_f32_kl, simsimd_accurate_f32_kl);
-    register_<simsimd_f32_t>("serial_f32_js", simsimd_serial_f32_js, simsimd_accurate_f32_js);
-
-    register_<simsimd_i8_t>("serial_i8_cos", simsimd_serial_i8_cos, simsimd_accurate_i8_cos);
-    register_<simsimd_i8_t>("serial_i8_l2sq", simsimd_serial_i8_l2sq, simsimd_accurate_i8_l2sq);
-
-    bm::RunSpecifiedBenchmarks();
-    bm::Shutdown();
-    return 0;
-}

package/simsimd/package-ci.json

@@ -1,10 +0,0 @@
-{
-    "name": "simsimd-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/simsimd/setup.py

@@ -1,86 +0,0 @@
-import os
-import sys
-import platform
-from os.path import dirname
-from setuptools import setup, Extension
-
-import glob
-import numpy
-
-__version__ = open("VERSION", "r").read().strip()
-__lib_name__ = "simsimd"
-
-compile_args = []
-link_args = []
-macros_args = []
-
-if sys.platform == "linux":
-    compile_args.append("-std=c11")
-    compile_args.append("-O3")
-    compile_args.append("-ffast-math")
-    compile_args.append("-fdiagnostics-color=always")
-
-    # Disable warnings
-    compile_args.append("-w")
-
-    # Enable OpenMP for 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")
-    compile_args.append("-ffast-math")
-
-    # Disable warnings
-    compile_args.append("-w")
-
-if sys.platform == "win32":
-    compile_args.append("/std:c11")
-    compile_args.append("/O2")
-    compile_args.append("/fp:fast")
-
-    # Dealing with MinGW linking errors
-    # https://cibuildwheel.readthedocs.io/en/stable/faq/#windows-importerror-dll-load-failed-the-specific-module-could-not-be-found
-    compile_args.append("/d2FH4-")
-
-ext_modules = [
-    Extension(
-        "simsimd",
-        sources=["python/lib.c"],
-        include_dirs=["include", numpy.get_include()],
-        extra_compile_args=compile_args,
-        extra_link_args=link_args,
-        define_macros=macros_args,
-    ),
-]
-
-this_directory = os.path.abspath(dirname(__file__))
-with open(os.path.join(this_directory, "README.md"), "r", encoding="utf8") as f:
-    long_description = f.read()
-
-setup(
-    name=__lib_name__,
-    version=__version__,
-    author="Ash Vardanian",
-    author_email="1983160+ashvardanian@users.noreply.github.com",
-    url="https://github.com/ashvardanian/simsimd",
-    description="Vector Similarity Functions 3x-200x Faster than SciPy and NumPy",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    license="Apache-2.0",
-    classifiers=[
-        "Development Status :: 5 - Production/Stable",
-        "Natural Language :: English",
-        "Intended Audience :: Developers",
-        "Intended Audience :: Information Technology",
-        "License :: OSI Approved :: Apache Software License",
-        "Programming Language :: C",
-        "Programming Language :: Python :: Implementation :: CPython",
-    ],
-    ext_modules=ext_modules,
-    zip_safe=False,
-)