usearch 2.9.2 → 2.10.1

package/simsimd/Cargo.toml

@@ -1,44 +0,0 @@
-[package]
-name = "simsimd"
-description = "Fastest SIMD-Accelerated Vector Similarity Functions for x86 and Arm"
-version = "3.9.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" }
-half = { version = "2.4.0" }

package/simsimd/LICENSE

@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

package/simsimd/README.md

@@ -1,317 +0,0 @@
-# SimSIMD 📏
-
-<div>
-<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">
-<a href="https://github.com/ashvardanian/SimSIMD/actions/workflows/release.yml">
-    <img alt="GitHub Actions Ubuntu" src="https://img.shields.io/github/actions/workflow/status/ashvardanian/SimSIMD/release.yml?branch=main&label=Ubuntu&logo=github&color=blue">
-</a>
-<a href="https://github.com/ashvardanian/SimSIMD/actions/workflows/release.yml">
-    <img alt="GitHub Actions Windows" src="https://img.shields.io/github/actions/workflow/status/ashvardanian/SimSIMD/release.yml?branch=main&label=Windows&logo=windows&color=blue">
-</a>
-<a href="https://github.com/ashvardanian/SimSIMD/actions/workflows/release.yml">
-    <img alt="GitHub Actions MacOS" src="https://img.shields.io/github/actions/workflow/status/ashvardanian/SimSIMD/release.yml?branch=main&label=MacOS&logo=apple&color=blue">
-</a>
-<a href="https://github.com/ashvardanian/SimSIMD/actions/workflows/release.yml">
-    <img alt="GitHub Actions CentOS Linux" src="https://img.shields.io/github/actions/workflow/status/ashvardanian/SimSIMD/release.yml?branch=main&label=CentOS&logo=centos&color=blue">
-</a>
-
-</div>
-
-
-## Hardware-Accelerated Similarity Metrics and Distance Functions
-
-- Zero-dependency [header-only C 99](#using-simsimd-in-c) library.
-- Handles `f64` double-, `f32` single-, and `f16` half-precision, `i8` integral, and binary vectors.
-- Targets ARM NEON, SVE, x86 AVX2, AVX-512 (VNNI, FP16) hardware backends.
-- Bindings for [Python](#using-simsimd-in-python), [Rust](#using-simsimd-in-rust) and [JavaScript](#using-simsimd-in-javascript).
-- __Up to 200x faster__ than [`scipy.spatial.distance`][scipy] and [`numpy.inner`][numpy].
-- [Supports more Python versions][compatibility] than SciPy and NumPy.
-- Zero-copy compatible with NumPy, PyTorch, TensorFlow, and other tensors.
-- Used in [USearch](https://github.com/unum-cloud/usearch) and several DBMS products.
-
-__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
-[compatibility]: https://pypi.org/project/simsimd/#files
-
-__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:
-
-| 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 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.
-
-| 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 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__:
-
-- [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 SimSIMD in Python
-
-The package is intended to replace the usage of `numpy.inner`, `numpy.dot`, and `scipy.spatial.distance`.
-Aside from drastic performance improvements, SimSIMD significantly improves accuracy in mixed precision setups.
-NumPy and SciPy, processing `i8` or `f16` vectors, will use the same types for accumulators, while SimSIMD can combine `i8` enumeration, `i16` multiplication, and `i32` accumulation to entirely avoid overflows.
-The same applies to processing `f16` values with `f32` precision.
-
-### 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`.
-Unlike SciPy, SimSIMD allows explicitly stating the precision of the input vectors, which is especially useful for mixed-precision setups.
-
-```py
-dist = simsimd.cosine(vec1, vec2, "i8")
-dist = simsimd.cosine(vec1, vec2, "f16")
-dist = simsimd.cosine(vec1, vec2, "f32")
-dist = simsimd.cosine(vec1, vec2, "f64")
-```
-
-### 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 the 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.index import Index, CompiledMetric, MetricKind, MetricSignature
-from simsimd import pointer_to_sqeuclidean, pointer_to_cosine, pointer_to_inner
-
-metric = CompiledMetric(
-    pointer=pointer_to_cosine("f16"),
-    kind=MetricKind.Cos,
-    signature=MetricSignature.ArrayArraySize,
-)
-
-index = Index(256, metric=metric)
-```
-
-## Using SimSIMD in Rust
-
-To install, add the following to your `Cargo.toml`:
-
-```toml
-[dependencies]
-simsimd = "..."
-```
-
-Before using the SimSIMD library, ensure you have imported the necessary traits and types into your Rust source file.
-The library provides several traits for different distance/similarity kinds - `SpatialSimilarity`, `BinarySimilarity`, and `ProbabilitySimilarity`.
-
-```rust
-use simsimd::SpatialSimilarity;
-
-fn main() {
-    let vector_a: Vec<f32> = vec![1.0, 2.0, 3.0];
-    let vector_b: Vec<f32> = vec![4.0, 5.0, 6.0];
-
-    // Compute the cosine similarity between vector_a and vector_b
-    let cosine_similarity = f32::cosine(&vector_a, &vector_b)
-        .expect("Vectors must be of the same length");
-
-    println!("Cosine Similarity: {}", cosine_similarity);
-
-    // Compute the squared Euclidean distance between vector_a and vector_b
-    let sq_euclidean_distance = f32::sqeuclidean(&vector_a, &vector_b)
-        .expect("Vectors must be of the same length");
-
-    println!("Squared Euclidean Distance: {}", sq_euclidean_distance);
-}
-```
-
-Similarly, one can compute bit-level distance functions between slices of unsigned integers:
-
-```rust
-use simsimd::BinarySimilarity;
-
-fn main() {
-    let vector_a = &[0b11110000, 0b00001111, 0b10101010];
-    let vector_b = &[0b11110000, 0b00001111, 0b01010101];
-
-    // Compute the Hamming distance between vector_a and vector_b
-    let hamming_distance = u8::hamming(&vector_a, &vector_b)
-        .expect("Vectors must be of the same length");
-
-    println!("Hamming Distance: {}", hamming_distance);
-
-    // Compute the Jaccard distance between vector_a and vector_b
-    let jaccard_distance = u8::jaccard(&vector_a, &vector_b)
-        .expect("Vectors must be of the same length");
-
-    println!("Jaccard Distance: {}", jaccard_distance);
-}
-```
-
-Rust has no native support for half-precision floating-point numbers, but SimSIMD provides a `f16` type for this purpose.
-It doesn't have any functionality and is a `transparent` wrapper around `u16`, so it can be used with `half`, or any other half-precision library.
-
-```rust
-use simsimd::SpatialSimilarity;
-use simsimd::f16 as SimF16;
-use half::f16 as HalfF16;
-
-fn main() {
-    let vector_a: Vec<HalfF16> = ...
-    let vector_b: Vec<HalfF16> = ...
-
-    let buffer_a: &[SimF16] = unsafe { std::slice::from_raw_parts(a_half.as_ptr() as *const SimF16, a_half.len()) };
-    let buffer_b: &[SimF16] = unsafe { std::slice::from_raw_parts(b_half.as_ptr() as *const SimF16, b_half.len()) };
-
-    // Compute the cosine similarity between vector_a and vector_b
-    let cosine_similarity = SimF16::cosine(&vector_a, &vector_b)
-        .expect("Vectors must be of the same length");
-
-    println!("Cosine Similarity: {}", cosine_similarity);
-}
-```
-
-## Using SimSIMD in JavaScript
-
-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');
-
-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
-
-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)
-```
-
-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}`.
-
-- 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.

package/simsimd/binding.gyp

@@ -1,36 +0,0 @@
-{
-    "variables": {
-        "openssl_fips": ""
-    },
-    "targets": [
-        {
-            "target_name": "simsimd",
-            "sources": ["javascript/lib.c"],
-            "include_dirs": ["include"],
-            "defines": ["SIMSIMD_NATIVE_F16=0"],
-            "cflags": [
-                "-std=c11",
-                "-ffast-math",
-                "-Wno-unknown-pragmas",
-                "-Wno-maybe-uninitialized",
-                "-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

@@ -1,20 +0,0 @@
-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");
-}