usearch 2.8.8 → 2.8.9

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.9
 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.9"
 authors = ["Ash Vardanian <1983160+ashvardanian@users.noreply.github.com>"]
 description = "Smaller & Faster Single-File Vector Search Engine from Unum"
 edition = "2021"

package/README.md

@@ -400,7 +400,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.9},
 year = {2023},
 month = oct,
 }

package/VERSION

@@ -1 +1 @@
-2.8.8
+2.8.9

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.9'
     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 9
 
 // Inferring C++ version
 // https://stackoverflow.com/a/61552074

package/include/usearch/index_plugins.hpp

@@ -1419,7 +1419,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.9",
     "description": "Smaller & Faster Single-File Vector Search Engine from Unum",
     "author": "Ash Vardanian (https://ashvardanian.com/)",
     "license": "Apache 2.0",

package/simsimd/README.md

@@ -30,24 +30,23 @@ SimSIMD leverages SIMD intrinsics, capabilities that only select compilers effec
 
 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__ |
+| 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__ |
 
 __Technical Insights__:
 
@@ -173,6 +172,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/probability.h

@@ -425,8 +425,8 @@ simsimd_avx512_f32_js_cycle:
     __mmask16 nonzero_mask_b = _mm512_cmp_ps_mask(b_vec, epsilon_vec, _CMP_GE_OQ);
     __mmask16 nonzero_mask = nonzero_mask_a & nonzero_mask_b;
     __m512 m_recip_approx = _mm512_rcp14_ps(m_vec);
-    __m512 ratio_a_vec = _mm512_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);

package/simsimd/package.json

@@ -1,6 +1,6 @@
 {
   "name": "simsimd",
-  "version": "3.5.3",
+  "version": "3.5.4",
   "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.9"
 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,
-)