usearch 2.3.2 → 2.4.0

package/.github/workflows/prerelease.yml

@@ -101,7 +101,7 @@ jobs:
         run: python -m pip install .
         if: ${{ matrix.os != 'ubuntu-22.04' }}
       - name: Test with PyTest
-        run: pytest python/scripts/
+        run: pytest python/scripts/ -s -x
 
 
   test_python_37:
@@ -136,7 +136,7 @@ jobs:
         if: ${{ matrix.os == 'ubuntu-22.04' }}
 
       - name: Test with PyTest
-        run: pytest python/scripts/
+        run: pytest python/scripts/ -s -x
 
 
   test_javascript:

package/.github/workflows/release.yml

@@ -215,9 +215,8 @@ jobs:
         file: "golang/*.zip"
         update_latest_release: true
 
-
-  publish_hashes:
-    name: Add hashes to release notes
+  publish_checksums:
+    name: Compute Assets Checksums
     runs-on: ubuntu-latest
     needs: [versioning, create_linux_deb_package, create_windows_dll_library, create_macos_library, deploy_docs_pages]
     steps:
@@ -270,7 +269,7 @@ jobs:
 
 
   build_wheels:
-    name: Build Wheels for ${{ matrix.os }}
+    name: Build Python
     needs: versioning
     runs-on: ${{ matrix.os }}
     strategy:
@@ -445,7 +444,7 @@ jobs:
         labels: ${{ steps.meta.outputs.labels }}
 
   build_csharp:
-    name: Build NuGet
+    name: Build C#
     needs: versioning
     strategy:
       matrix:

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.3.2
+version: 2.4.0
 doi: 10.5281/zenodo.7949416
 date-released: 2022-06-12
 url: "https://github.com/unum-cloud/usearch"

package/Cargo.toml

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

package/README.md

@@ -392,7 +392,7 @@ doi = {10.5281/zenodo.7949416},
 author = {Vardanian, Ash},
 title = {{USearch by Unum Cloud}},
 url = {https://github.com/unum-cloud/usearch},
-version = {2.3.2},
+version = {2.4.0},
 year = {2022},
 month = jun,
 }

package/conanfile.py

@@ -4,7 +4,7 @@ from conans import ConanFile
 class USearchConan(ConanFile):
 
     name = 'USearch'
-    version = '2.3.2'
+    version = '2.4.0'
     license = 'Apache 2.0'
     url = 'https://github.com/unum-cloud/usearch'
     description = 'Smaller & Faster Single-File Vector Search Engine from Unum'

package/cpp/test.cpp

@@ -36,6 +36,13 @@ void test_cosine(index_at& index, std::vector<std::vector<scalar_at>> const& vec
     scalar_t const* vector_third = vectors[2].data();
     std::size_t dimensions = vectors[0].size();
 
+    // Try checking the empty state
+    if constexpr (punned_ak) {
+        expect(!index.contains(key_first));
+        expect(!index.get(key_first, (f32_t*)nullptr, 1));
+    }
+
+    // Add data
     index.reserve(10);
     index.add(key_first, vector_first, args...);
 

package/csharp/nuget/nuget-package.props

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project>
   <PropertyGroup>
-    <Version Condition="'$(Version)' == ''">2.3.2</Version>
+    <Version Condition="'$(Version)' == ''">2.4.0</Version>
 
     <Authors>Unum</Authors>
     <Company>Unum</Company>

package/include/usearch/index.hpp

@@ -10,8 +10,8 @@
 #define UNUM_USEARCH_HPP
 
 #define USEARCH_VERSION_MAJOR 2
-#define USEARCH_VERSION_MINOR 3
-#define USEARCH_VERSION_PATCH 2
+#define USEARCH_VERSION_MINOR 4
+#define USEARCH_VERSION_PATCH 0
 
 // Inferring C++ version
 // https://stackoverflow.com/a/61552074

package/include/usearch/index_dense.hpp

@@ -1,12 +1,11 @@
 #pragma once
 #include <stdlib.h> // `aligned_alloc`
 
-#include <functional>    // `std::function`
-#include <numeric>       // `std::iota`
-#include <shared_mutex>  // `std::shared_mutex`
-#include <thread>        // `std::thread`
-#include <unordered_set> // `std::unordered_multiset`
-#include <vector>        // `std::vector`
+#include <functional>   // `std::function`
+#include <numeric>      // `std::iota`
+#include <shared_mutex> // `std::shared_mutex`
+#include <thread>       // `std::thread`
+#include <vector>       // `std::vector`
 
 #include <usearch/index.hpp>
 #include <usearch/index_plugins.hpp>
@@ -93,6 +92,17 @@ struct index_dense_config_t : public index_config_t {
     bool exclude_vectors = false;
     bool multi = false;
 
+    /**
+     *  @brief  Allows you to reduce RAM consumption by avoiding
+     *          reverse-indexing keys-to-vectors, and only keeping
+     *          the vectors-to-keys mappings.
+     *
+     *  ! This configuration parameter doesn't affect the serialized file,
+     *  ! and is not preserved between runs. Makes sense for small vector
+     *  ! representations that fit ina  single cache line.
+     */
+    bool enable_key_lookups = true;
+
     index_dense_config_t(index_config_t base) noexcept : index_config_t(base) {}
 
     index_dense_config_t(                                  //
@@ -399,7 +409,7 @@ class index_dense_gt {
     };
 
     /// @brief Multi-Map from keys to IDs, and allocated vectors.
-    std::unordered_multiset<key_and_slot_t, lookup_key_hash_t, lookup_key_same_t> slot_lookup_;
+    flat_hash_multi_set_gt<key_and_slot_t, lookup_key_hash_t, lookup_key_same_t> slot_lookup_;
 
     /// @brief Mutex, controlling concurrent access to `slot_lookup_`.
     mutable shared_mutex_t slot_lookup_mutex_;
@@ -1149,7 +1159,7 @@ class index_dense_gt {
      */
     bool contains(key_t key) const {
         shared_lock_t lock(slot_lookup_mutex_);
-        return slot_lookup_.find(key_and_slot_t::any_slot(key)) != slot_lookup_.end();
+        return slot_lookup_.contains(key_and_slot_t::any_slot(key));
     }
 
     /**
@@ -1203,7 +1213,7 @@ class index_dense_gt {
             free_keys_.push(slot);
             typed_->at(slot).key = free_key_;
         }
-        slot_lookup_.erase(matching_slots.first, matching_slots.second);
+        slot_lookup_.erase(key);
         result.completed = matching_count;
 
         return result;
@@ -1239,14 +1249,15 @@ class index_dense_gt {
             // - present in `free_keys_`
             // - missing in the `slot_lookup_`
             // - marked in the `typed_` index with a `free_key_`
+            matching_count = 0;
             for (auto slots_it = matching_slots.first; slots_it != matching_slots.second; ++slots_it) {
                 compressed_slot_t slot = (*slots_it).slot;
                 free_keys_.push(slot);
                 typed_->at(slot).key = free_key_;
+                ++matching_count;
             }
 
-            matching_count = std::distance(matching_slots.first, matching_slots.second);
-            slot_lookup_.erase(matching_slots.first, matching_slots.second);
+            slot_lookup_.erase(key);
             result.completed += matching_count;
         }
 
@@ -1265,20 +1276,18 @@ class index_dense_gt {
         labeling_result_t result;
         unique_lock_t lookup_lock(slot_lookup_mutex_);
 
-        if (!multi() && slot_lookup_.count(key_and_slot_t::any_slot(to)))
+        if (!multi() && slot_lookup_.contains(key_and_slot_t::any_slot(to)))
             return result.failed("Renaming impossible, the key is already in use");
 
         // The `from` may map to multiple entries
         while (true) {
-            auto slots_it = slot_lookup_.find(key_and_slot_t::any_slot(from));
-            if (slots_it == slot_lookup_.end())
+            key_and_slot_t key_and_slot_removed;
+            if (!slot_lookup_.pop_first(key_and_slot_t::any_slot(from), key_and_slot_removed))
                 break;
 
-            compressed_slot_t slot = (*slots_it).slot;
-            key_and_slot_t key_and_slot{to, slot};
-            slot_lookup_.erase(slots_it);
-            slot_lookup_.insert(key_and_slot);
-            typed_->at(slot).key = to;
+            key_and_slot_t key_and_slot_replacing{to, key_and_slot_removed.slot};
+            slot_lookup_.try_emplace(key_and_slot_replacing); // This can't fail
+            typed_->at(key_and_slot_removed.slot).key = to;
             ++result.completed;
         }
 
@@ -1293,11 +1302,18 @@ class index_dense_gt {
      */
     void export_keys(key_t* keys, std::size_t offset, std::size_t limit) const {
         shared_lock_t lock(slot_lookup_mutex_);
-        auto it = slot_lookup_.begin();
         offset = (std::min)(offset, slot_lookup_.size());
-        std::advance(it, offset);
-        for (; it != slot_lookup_.end() && limit; ++it, ++keys, --limit)
-            *keys = (*it).key;
+        slot_lookup_.for_each([&](key_and_slot_t const& key_and_slot) {
+            if (offset) {
+                --offset;
+                return;
+            }
+            if (limit) {
+                *keys = key_and_slot.key;
+                ++keys;
+                --limit;
+            }
+        });
     }
 
     struct copy_result_t {
@@ -1720,7 +1736,7 @@ class index_dense_gt {
         bool reuse_node = free_slot != default_free_value<compressed_slot_t>();
         auto on_success = [&](member_ref_t member) {
             unique_lock_t slot_lock(slot_lookup_mutex_);
-            slot_lookup_.insert(key_and_slot_t{key, static_cast<compressed_slot_t>(member.slot)});
+            slot_lookup_.try_emplace(key_and_slot_t{key, static_cast<compressed_slot_t>(member.slot)});
             if (copy_vector) {
                 if (!reuse_node)
                     vectors_lookup_[member.slot] = vectors_tape_allocator_.allocate(metric_.bytes_per_vector());
@@ -1842,19 +1858,23 @@ class index_dense_gt {
             count_removed += member.key == free_key_;
         }
 
+        if (!count_removed && !config_.enable_key_lookups)
+            return;
+
         // Pull entries from the underlying `typed_` into either
         // into `slot_lookup_`, or `free_keys_` if they are unused.
         unique_lock_t lock(slot_lookup_mutex_);
         slot_lookup_.clear();
-        slot_lookup_.reserve(count_total - count_removed);
+        if (config_.enable_key_lookups)
+            slot_lookup_.reserve(count_total - count_removed);
         free_keys_.clear();
         free_keys_.reserve(count_removed);
         for (std::size_t i = 0; i != typed_->size(); ++i) {
             member_cref_t member = typed_->at(i);
             if (member.key == free_key_)
                 free_keys_.push(static_cast<compressed_slot_t>(i));
-            else
-                slot_lookup_.insert(key_and_slot_t{key_t(member.key), static_cast<compressed_slot_t>(i)});
+            else if (config_.enable_key_lookups)
+                slot_lookup_.try_emplace(key_and_slot_t{key_t(member.key), static_cast<compressed_slot_t>(i)});
         }
     }
 

package/include/usearch/index_plugins.hpp

@@ -649,7 +649,9 @@ class aligned_allocator_gt {
     using size_type = std::size_t;
     using pointer = element_at*;
     using const_pointer = element_at const*;
-    template <typename other_element_at> struct rebind { using other = aligned_allocator_gt<other_element_at>; };
+    template <typename other_element_at> struct rebind {
+        using other = aligned_allocator_gt<other_element_at>;
+    };
 
     constexpr std::size_t alignment() const { return alignment_ak; }
 
@@ -1315,17 +1317,16 @@ template <typename scalar_at = float, typename result_at = scalar_at> struct met
         result_t lat_a = a[0], lon_a = a[1];
         result_t lat_b = b[0], lon_b = b[1];
 
-        result_t lat_delta = angle_to_radians<result_t>(lat_b - lat_a);
-        result_t lon_delta = angle_to_radians<result_t>(lon_b - lon_a);
+        result_t lat_delta = angle_to_radians<result_t>(lat_b - lat_a) / 2;
+        result_t lon_delta = angle_to_radians<result_t>(lon_b - lon_a) / 2;
 
         result_t converted_lat_a = angle_to_radians<result_t>(lat_a);
         result_t converted_lat_b = angle_to_radians<result_t>(lat_b);
 
-        result_t x = //
-            square(std::sin(lat_delta / 2.f)) +
-            std::cos(converted_lat_a) * std::cos(converted_lat_b) * square(std::sin(lon_delta / 2.f));
+        result_t x = square(std::sin(lat_delta)) + //
+                     std::cos(converted_lat_a) * std::cos(converted_lat_b) * square(std::sin(lon_delta));
 
-        return std::atan2(std::sqrt(x), std::sqrt(1.f - x));
+        return 2 * std::asin(std::sqrt(x));
     }
 };
 
@@ -1556,5 +1557,513 @@ class metric_punned_t {
     // clang-format on
 };
 
+/**
+ *  @brief  C++11 Multi-Hash-Set with Linear Probing.
+ *
+ *  - Allows multiple equivalent values,
+ *  - Supports transparent hashing and equality operator.
+ *  - Doesn't throw exceptions, if forbidden.
+ *  - Doesn't need reserving a value for deletions.
+ *
+ *  @section Layout
+ *
+ *  For every slot we store 2 extra bits for 3 possible states: empty, populated, or deleted.
+ */
+template <typename element_at, typename hash_at, typename equals_at, typename allocator_at = std::allocator<char>>
+class flat_hash_multi_set_gt {
+  public:
+    using element_t = element_at;
+    using hash_t = hash_at;
+    using equals_t = equals_at;
+    using allocator_t = allocator_at;
+
+    static constexpr std::size_t slots_per_bucket() { return 64; }
+    static constexpr std::size_t bytes_per_bucket() {
+        return slots_per_bucket() * sizeof(element_t) + sizeof(bucket_header_t);
+    }
+
+  private:
+    struct bucket_header_t {
+        std::uint64_t populated{};
+        std::uint64_t deleted{};
+    };
+    char* data_ = nullptr;
+    std::size_t buckets_ = 0;
+    std::size_t populated_slots_ = 0;
+    /// @brief  Number of slots
+    std::size_t capacity_slots_ = 0;
+
+    struct slot_ref_t {
+        bucket_header_t& header;
+        std::uint64_t mask;
+        element_t& element;
+    };
+
+    slot_ref_t slot_ref(char* data, std::size_t slot_index) const noexcept {
+        std::size_t bucket_index = slot_index / slots_per_bucket();
+        std::size_t in_bucket_index = slot_index % slots_per_bucket();
+        auto bucket_pointer = data + bytes_per_bucket() * bucket_index;
+        auto slot_pointer = bucket_pointer + sizeof(bucket_header_t) + sizeof(element_t) * in_bucket_index;
+        return {
+            *reinterpret_cast<bucket_header_t*>(bucket_pointer),
+            std::uint64_t(1ull) << in_bucket_index,
+            *reinterpret_cast<element_t*>(slot_pointer),
+        };
+    }
+
+    slot_ref_t slot_ref(std::size_t slot_index) const noexcept { return slot_ref(data_, slot_index); }
+
+    bool populate_slot(slot_ref_t slot, element_t const& new_element) {
+        if (slot.header.populated & slot.mask) {
+            slot.element = new_element;
+            slot.header.deleted &= ~slot.mask;
+            return false;
+        } else {
+            new (&slot.element) element_t(new_element);
+            slot.header.populated |= slot.mask;
+            return true;
+        }
+    }
+
+  public:
+    std::size_t size() const noexcept { return populated_slots_; }
+    std::size_t capacity() const noexcept { return capacity_slots_; }
+
+    flat_hash_multi_set_gt() noexcept {}
+    ~flat_hash_multi_set_gt() noexcept { reset(); }
+
+    flat_hash_multi_set_gt(flat_hash_multi_set_gt const& other) {
+
+        // On Windows allocating a zero-size array would fail
+        if (!other.buckets_) {
+            reset();
+            return;
+        }
+
+        // Allocate new memory
+        data_ = (char*)allocator_t{}.allocate(other.buckets_ * bytes_per_bucket());
+        if (!data_)
+            throw std::bad_alloc();
+
+        // Copy metadata
+        buckets_ = other.buckets_;
+        populated_slots_ = other.populated_slots_;
+        capacity_slots_ = other.capacity_slots_;
+
+        // Initialize new buckets to empty
+        std::memset(data_, 0, buckets_ * bytes_per_bucket());
+
+        // Copy elements and bucket headers
+        for (std::size_t i = 0; i < capacity_slots_; ++i) {
+            slot_ref_t old_slot = other.slot_ref(i);
+            if ((old_slot.header.populated & old_slot.mask) && !(old_slot.header.deleted & old_slot.mask)) {
+                slot_ref_t new_slot = slot_ref(i);
+                populate_slot(new_slot, old_slot.element);
+            }
+        }
+    }
+
+    flat_hash_multi_set_gt& operator=(flat_hash_multi_set_gt const& other) {
+
+        // On Windows allocating a zero-size array would fail
+        if (!other.buckets_) {
+            reset();
+            return *this;
+        }
+
+        // Handle self-assignment
+        if (this == &other)
+            return *this;
+
+        // Clear existing data
+        clear();
+        if (data_)
+            allocator_t{}.deallocate(data_, buckets_ * bytes_per_bucket());
+
+        // Allocate new memory
+        data_ = (char*)allocator_t{}.allocate(other.buckets_ * bytes_per_bucket());
+        if (!data_)
+            throw std::bad_alloc();
+
+        // Copy metadata
+        buckets_ = other.buckets_;
+        populated_slots_ = other.populated_slots_;
+        capacity_slots_ = other.capacity_slots_;
+
+        // Initialize new buckets to empty
+        std::memset(data_, 0, buckets_ * bytes_per_bucket());
+
+        // Copy elements and bucket headers
+        for (std::size_t i = 0; i < capacity_slots_; ++i) {
+            slot_ref_t old_slot = other.slot_ref(i);
+            if ((old_slot.header.populated & old_slot.mask) && !(old_slot.header.deleted & old_slot.mask)) {
+                slot_ref_t new_slot = slot_ref(i);
+                populate_slot(new_slot, old_slot.element);
+            }
+        }
+
+        return *this;
+    }
+
+    void clear() noexcept {
+        // Call the destructors
+        for (std::size_t i = 0; i < capacity_slots_; ++i) {
+            slot_ref_t slot = slot_ref(i);
+            if ((slot.header.populated & slot.mask) & (~slot.header.deleted & slot.mask))
+                slot.element.~element_t();
+        }
+
+        // Reset populated slots count
+        std::memset(data_, 0, buckets_ * bytes_per_bucket());
+        populated_slots_ = 0;
+    }
+
+    void reset() noexcept {
+        clear(); // Clear all elements
+        if (data_)
+            allocator_t{}.deallocate(data_, buckets_ * bytes_per_bucket());
+        buckets_ = 0;
+        populated_slots_ = 0;
+        capacity_slots_ = 0;
+    }
+
+    bool try_reserve(std::size_t capacity) noexcept {
+        if (capacity * 3u <= capacity_slots_ * 2u)
+            return true;
+
+        // Calculate new sizes
+        std::size_t new_slots = ceil2((capacity * 3ul) / 2ul);
+        std::size_t new_buckets = divide_round_up<slots_per_bucket()>(new_slots);
+        new_slots = new_buckets * slots_per_bucket(); // This must be a power of two!
+        std::size_t new_bytes = new_buckets * bytes_per_bucket();
+
+        // Allocate new memory
+        char* new_data = (char*)allocator_t{}.allocate(new_bytes);
+        if (!new_data)
+            return false;
+
+        // Initialize new buckets to empty
+        std::memset(new_data, 0, new_bytes);
+
+        // Rehash and copy existing elements to new_data
+        hash_t hasher;
+        for (std::size_t i = 0; i < capacity_slots_; ++i) {
+            slot_ref_t old_slot = slot_ref(i);
+            if ((~old_slot.header.populated & old_slot.mask) | (old_slot.header.deleted & old_slot.mask))
+                continue;
+
+            // Rehash
+            std::size_t hash_value = hasher(old_slot.element);
+            std::size_t new_slot_index = hash_value & (new_slots - 1);
+
+            // Linear probing to find an empty slot in new_data
+            while (true) {
+                slot_ref_t new_slot = slot_ref(new_data, new_slot_index);
+                if (!(new_slot.header.populated & new_slot.mask) || (new_slot.header.deleted & new_slot.mask)) {
+                    populate_slot(new_slot, std::move(old_slot.element));
+                    new_slot.header.populated |= new_slot.mask;
+                    break;
+                }
+                new_slot_index = (new_slot_index + 1) & (new_slots - 1);
+            }
+        }
+
+        // Deallocate old data and update pointers and sizes
+        if (data_)
+            allocator_t{}.deallocate(data_, buckets_ * bytes_per_bucket());
+        data_ = new_data;
+        buckets_ = new_buckets;
+        capacity_slots_ = new_slots;
+
+        return true;
+    }
+
+    template <typename query_at> class equal_iterator_gt {
+      public:
+        using iterator_category = std::forward_iterator_tag;
+        using value_type = element_t;
+        using difference_type = std::ptrdiff_t;
+        using pointer = element_t*;
+        using reference = element_t&;
+
+        equal_iterator_gt(std::size_t index, flat_hash_multi_set_gt* parent, const query_at& query,
+                          const equals_t& equals)
+            : index_(index), parent_(parent), query_(query), equals_(equals) {}
+
+        // Pre-increment
+        equal_iterator_gt& operator++() {
+            do {
+                ++index_;
+                if (index_ >= parent_->capacity_slots_) {
+                    break;
+                }
+            } while (!equals_(parent_->slot_ref(index_).element, query_) ||
+                     !(parent_->slot_ref(index_).header.populated & parent_->slot_ref(index_).mask));
+            return *this;
+        }
+
+        equal_iterator_gt operator++(int) {
+            equal_iterator_gt temp = *this;
+            ++(*this);
+            return temp;
+        }
+
+        reference operator*() { return parent_->slot_ref(index_).element; }
+        pointer operator->() { return &parent_->slot_ref(index_).element; }
+        bool operator!=(equal_iterator_gt const& other) const { return !(*this == other); }
+        bool operator==(equal_iterator_gt const& other) const {
+            return index_ == other.index_ && parent_ == other.parent_;
+        }
+
+      private:
+        std::size_t index_;
+        flat_hash_multi_set_gt* parent_;
+        query_at query_;  // Store the query object
+        equals_t equals_; // Store the equals functor
+    };
+
+    template <typename query_at>
+    std::pair<equal_iterator_gt<query_at>, equal_iterator_gt<query_at>>
+    equal_range(query_at const& query) const noexcept {
+
+        equals_t equals;
+        auto this_ptr = const_cast<flat_hash_multi_set_gt*>(this);
+        auto end = equal_iterator_gt<query_at>(capacity_slots_, this_ptr, query, equals);
+        if (!capacity_slots_)
+            return {end, end};
+
+        hash_t hasher;
+        std::size_t hash_value = hasher(query);
+        std::size_t slot_index = hash_value & (capacity_slots_ - 1);
+        std::size_t const start_index = slot_index;
+        std::size_t first_equal_index = capacity_slots_;
+
+        // Linear probing to find the first equal element
+        do {
+            slot_ref_t slot = slot_ref(slot_index);
+            if (slot.header.populated & ~slot.header.deleted & slot.mask) {
+                if (equals(slot.element, query)) {
+                    first_equal_index = slot_index;
+                    break;
+                }
+            }
+            // Stop if we find an empty slot
+            else if (~slot.header.populated & slot.mask)
+                break;
+
+            // Move to the next slot
+            slot_index = (slot_index + 1) & (capacity_slots_ - 1);
+        } while (slot_index != start_index);
+
+        return {equal_iterator_gt<query_at>(first_equal_index, this_ptr, query, equals), end};
+    }
+
+    template <typename similar_at> bool pop_first(similar_at&& query, element_t& popped_value) noexcept {
+
+        if (!capacity_slots_)
+            return false;
+
+        hash_t hasher;
+        equals_t equals;
+        std::size_t hash_value = hasher(query);
+        std::size_t slot_index = hash_value & (capacity_slots_ - 1); // Assuming capacity_slots_ is a power of 2
+        std::size_t start_index = slot_index;                        // To detect loop in probing
+
+        // Linear probing to find the first match
+        do {
+            slot_ref_t slot = slot_ref(slot_index);
+            if (slot.header.populated & slot.mask) {
+                if ((~slot.header.deleted & slot.mask) && equals(slot.element, query)) {
+                    // Found a match, mark as deleted
+                    slot.header.deleted |= slot.mask;
+                    --populated_slots_;
+                    popped_value = slot.element;
+                    return true; // Successfully removed
+                }
+            } else {
+                // Stop if we find an empty slot
+                break;
+            }
+
+            // Move to the next slot
+            slot_index = (slot_index + 1) & (capacity_slots_ - 1); // Assuming capacity_slots_ is a power of 2
+        } while (slot_index != start_index);
+
+        return false; // No match found
+    }
+
+    template <typename similar_at> std::size_t erase(similar_at&& query) noexcept {
+
+        if (!capacity_slots_)
+            return 0;
+
+        hash_t hasher;
+        equals_t equals;
+        std::size_t hash_value = hasher(query);
+        std::size_t slot_index = hash_value & (capacity_slots_ - 1); // Assuming capacity_slots_ is a power of 2
+        std::size_t start_index = slot_index;                        // To detect loop in probing
+        std::size_t count = 0;                                       // Count of elements removed
+
+        // Linear probing to find all matches
+        do {
+            slot_ref_t slot = slot_ref(slot_index);
+            if (slot.header.populated & slot.mask) {
+                if ((~slot.header.deleted & slot.mask) && equals(slot.element, query)) {
+                    // Found a match, mark as deleted
+                    slot.header.deleted |= slot.mask;
+                    --populated_slots_;
+                    ++count; // Increment count of elements removed
+                }
+            } else {
+                // Stop if we find an empty slot
+                break;
+            }
+
+            // Move to the next slot
+            slot_index = (slot_index + 1) & (capacity_slots_ - 1); // Assuming capacity_slots_ is a power of 2
+        } while (slot_index != start_index);
+
+        return count; // Return the number of elements removed
+    }
+
+    template <typename similar_at> element_t const* find(similar_at&& query) const noexcept {
+
+        if (!capacity_slots_)
+            return nullptr;
+
+        hash_t hasher;
+        equals_t equals;
+        std::size_t hash_value = hasher(query);
+        std::size_t slot_index = hash_value & (capacity_slots_ - 1); // Assuming capacity_slots_ is a power of 2
+        std::size_t start_index = slot_index;                        // To detect loop in probing
+
+        // Linear probing to find the first match
+        do {
+            slot_ref_t slot = slot_ref(slot_index);
+            if (slot.header.populated & slot.mask) {
+                if ((~slot.header.deleted & slot.mask) && equals(slot.element, query))
+                    return &slot.element; // Found a match, return pointer to the element
+            } else {
+                // Stop if we find an empty slot
+                break;
+            }
+
+            // Move to the next slot
+            slot_index = (slot_index + 1) & (capacity_slots_ - 1); // Assuming capacity_slots_ is a power of 2
+        } while (slot_index != start_index);
+
+        return nullptr; // No match found
+    }
+
+    element_t const* end() const noexcept { return nullptr; }
+
+    template <typename func_at> void for_each(func_at&& func) const {
+        for (std::size_t bucket_index = 0; bucket_index < buckets_; ++bucket_index) {
+            auto bucket_pointer = data_ + bytes_per_bucket() * bucket_index;
+            bucket_header_t& header = *reinterpret_cast<bucket_header_t*>(bucket_pointer);
+            std::uint64_t populated = header.populated;
+            std::uint64_t deleted = header.deleted;
+
+            // Iterate through slots in the bucket
+            for (std::size_t in_bucket_index = 0; in_bucket_index < slots_per_bucket(); ++in_bucket_index) {
+                std::uint64_t mask = std::uint64_t(1ull) << in_bucket_index;
+
+                // Check if the slot is populated and not deleted
+                if ((populated & ~deleted) & mask) {
+                    auto slot_pointer = bucket_pointer + sizeof(bucket_header_t) + sizeof(element_t) * in_bucket_index;
+                    element_t const& element = *reinterpret_cast<element_t const*>(slot_pointer);
+                    func(element);
+                }
+            }
+        }
+    }
+
+    template <typename similar_at> std::size_t count(similar_at&& query) const noexcept {
+
+        if (!capacity_slots_)
+            return 0;
+
+        hash_t hasher;
+        equals_t equals;
+        std::size_t hash_value = hasher(query);
+        std::size_t slot_index = hash_value & (capacity_slots_ - 1);
+        std::size_t start_index = slot_index; // To detect loop in probing
+        std::size_t count = 0;
+
+        // Linear probing to find the range
+        do {
+            slot_ref_t slot = slot_ref(slot_index);
+            if ((slot.header.populated & slot.mask) && (~slot.header.deleted & slot.mask)) {
+                if (equals(slot.element, query))
+                    ++count;
+            } else if (~slot.header.populated & slot.mask) {
+                // Stop if we find an empty slot
+                break;
+            }
+
+            // Move to the next slot
+            slot_index = (slot_index + 1) & (capacity_slots_ - 1);
+        } while (slot_index != start_index);
+
+        return count;
+    }
+
+    template <typename similar_at> bool contains(similar_at&& query) const noexcept {
+
+        if (!capacity_slots_)
+            return false;
+
+        hash_t hasher;
+        equals_t equals;
+        std::size_t hash_value = hasher(query);
+        std::size_t slot_index = hash_value & (capacity_slots_ - 1);
+        std::size_t start_index = slot_index; // To detect loop in probing
+
+        // Linear probing to find the first match
+        do {
+            slot_ref_t slot = slot_ref(slot_index);
+            if (slot.header.populated & slot.mask) {
+                if ((~slot.header.deleted & slot.mask) && equals(slot.element, query))
+                    return true; // Found a match, exit early
+            } else
+                // Stop if we find an empty slot
+                break;
+
+            // Move to the next slot
+            slot_index = (slot_index + 1) & (capacity_slots_ - 1);
+        } while (slot_index != start_index);
+
+        return false; // No match found
+    }
+
+    void reserve(std::size_t capacity) {
+        if (!try_reserve(capacity))
+            throw std::bad_alloc();
+    }
+
+    bool try_emplace(element_t const& element) noexcept {
+        // Check if we need to resize
+        if (populated_slots_ * 3u >= capacity_slots_ * 2u)
+            if (!try_reserve(populated_slots_ + 1))
+                return false;
+
+        hash_t hasher;
+        std::size_t hash_value = hasher(element);
+        std::size_t slot_index = hash_value & (capacity_slots_ - 1);
+
+        // Linear probing
+        while (true) {
+            slot_ref_t slot = slot_ref(slot_index);
+            if ((~slot.header.populated & slot.mask) | (slot.header.deleted & slot.mask)) {
+                // Found an empty or deleted slot
+                populated_slots_ += populate_slot(slot, element);
+                return true;
+            }
+            // Move to the next slot
+            slot_index = (slot_index + 1) & (capacity_slots_ - 1);
+        }
+    }
+};
+
 } // namespace usearch
 } // namespace unum

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "usearch",
-    "version": "2.3.2",
+    "version": "2.4.0",
     "description": "Smaller & Faster Single-File Vector Search Engine from Unum",
     "author": "Ash Vardanian",
     "license": "Apache 2.0",

package/python/lib.cpp

@@ -177,10 +177,12 @@ static dense_index_py_t make_index(      //
     metric_kind_t metric_kind,           //
     metric_signature_t metric_signature, //
     std::uintptr_t metric_uintptr,       //
-    bool multi) {
+    bool multi,                          //
+    bool enable_key_lookups) {
 
     index_dense_config_t config(connectivity, expansion_add, expansion_search);
     config.multi = multi;
+    config.enable_key_lookups = enable_key_lookups;
 
     metric_t metric =  //
         metric_uintptr //
@@ -1042,7 +1044,8 @@ PYBIND11_MODULE(compiled, m) {
           py::arg("metric_kind") = metric_kind_t::cos_k,                   //
           py::arg("metric_signature") = metric_signature_t::array_array_k, //
           py::arg("metric_pointer") = 0,                                   //
-          py::arg("multi") = false                                         //
+          py::arg("multi") = false,                                        //
+          py::arg("enable_key_lookups") = true                             //
     );
 
     i.def(                                                //

package/python/scripts/cluster.ipynb

@@ -133,13 +133,6 @@
     "plt.tight_layout()\n",
     "plt.show()"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {

package/python/usearch/index.py

@@ -476,6 +476,7 @@ class Index:
         multi: bool = False,
         path: Optional[os.PathLike] = None,
         view: bool = False,
+        enable_key_lookups: bool = True,
     ) -> None:
         """Construct the index and compiles the functions, if requested (expensive).
 
@@ -565,6 +566,7 @@ class Index:
             expansion_add=expansion_add,
             expansion_search=expansion_search,
             multi=multi,
+            enable_key_lookups=enable_key_lookups,
             metric_kind=self._metric_kind,
             metric_pointer=self._metric_pointer,
             metric_signature=self._metric_signature,
@@ -986,6 +988,8 @@ class Index:
 
     def reset(self):
         """Erases all members from index, closing files, and returning RAM to OS."""
+        if not hasattr(self, "_compiled"):
+            return
         self._compiled.reset()
 
     def __del__(self):
@@ -1175,23 +1179,28 @@ class Index:
 
     @property
     def specs(self) -> Dict[str, Union[str, int, bool]]:
+        if not hasattr(self, "_compiled"):
+            return "usearch.Index(failed)"
         return {
-            "Class": "usearch.Index",
-            "Connectivity": self.connectivity,
-            "Size": self.size,
-            "Dimensions": self.ndim,
-            "Expansion@Add": self.expansion_add,
-            "Expansion@Search": self.expansion_search,
-            "OpenMP": USES_OPENMP,
-            "SimSIMD": USES_SIMSIMD,
-            "NativeF16": USES_NATIVE_F16,
-            "JIT": self.jit,
-            "DType": self.dtype,
-            "Path": self.path,
+            "type": "usearch.Index",
+            "ndim": self.ndim,
+            "connectivity": self.connectivity,
+            "expansion_add": self.expansion_add,
+            "expansion_search": self.expansion_search,
+            "size": self.size,
+            "jit": self.jit,
+            "hardware_acceleration": self.hardware_acceleration,
+            "dtype": self.dtype,
+            "path": self.path,
+            "compiled_with_openmp": USES_OPENMP,
+            "compiled_with_simsimd": USES_SIMSIMD,
+            "compiled_with_native_f16": USES_NATIVE_F16,
         }
 
     def __repr__(self) -> str:
-        f = "usearch.Index({} x {}, {}, connectivity: {}, expansion: {} & {}, {} vectors in {} levels)"
+        if not hasattr(self, "_compiled"):
+            return "usearch.Index(failed)"
+        f = "usearch.Index({} x {}, {}, connectivity: {}, expansion: {} & {}, {:,} vectors in {} levels, {} hardware accerlation)"
         return f.format(
             self.dtype,
             self.ndim,
@@ -1201,9 +1210,12 @@ class Index:
             self.expansion_search,
             len(self),
             self.nlevels,
+            self.hardware_acceleration,
         )
 
     def _repr_pretty_(self, printer, cycle) -> str:
+        if not hasattr(self, "_compiled"):
+            return "usearch.Index(failed)"
         level_stats = [
             f"--- {i}. {self.level_stats(i).nodes:,} nodes" for i in range(self.nlevels)
         ]

package/rust/lib.rs

@@ -81,7 +81,18 @@ pub mod ffi {
         ///
         /// * `key` - The key associated with the vector.
         /// * `vector` - A slice containing the vector data.
-        pub fn add(self: &Index, key: u64, vector: &[f32]) -> Result<()>;
+        fn add<T>(self: &Index, key: u64, vector: &[T]) -> Result<()> {
+            // Use type-based dispatch
+            if std::any::TypeId::of::<T>() == std::any::TypeId::of::<i8>() {
+                add_i8(key, unsafe { std::mem::transmute::<&[T], &[i8]>(vector) })
+            } else if std::any::TypeId::of::<T>() == std::any::TypeId::of::<f32>() {
+                add_f32(key, unsafe { std::mem::transmute::<&[T], &[f32]>(vector) })
+            } else if std::any::TypeId::of::<T>() == std::any::TypeId::of::<f64>() {
+                add_f64(key, unsafe { std::mem::transmute::<&[T], &[f64]>(vector) })
+            } else {
+                Err(Box::new("Unsupported type"))
+            }
+        }
 
         pub fn add_i8(self: &Index, key: u64, vector: &[i8]) -> Result<()>;
         pub fn add_f16(self: &Index, key: u64, vector: &[u16]) -> Result<()>;
@@ -98,7 +109,18 @@ pub mod ffi {
         /// # Returns
         ///
         /// A `Result` containing the matches found.
-        pub fn search(self: &Index, query: &[f32], count: usize) -> Result<Matches>;
+        pub fn search<T>(self: &Index, query: &[T], count: usize) -> Result<Matches> {
+            // Use type-based dispatch
+            if std::any::TypeId::of::<T>() == std::any::TypeId::of::<i8>() {
+                search_i8(unsafe { std::mem::transmute::<&[T], &[i8]>(query) }, count)
+            } else if std::any::TypeId::of::<T>() == std::any::TypeId::of::<f32>() {
+                search_f32(unsafe { std::mem::transmute::<&[T], &[f32]>(query) }, count)
+            } else if std::any::TypeId::of::<T>() == std::any::TypeId::of::<f64>() {
+                search_f64(unsafe { std::mem::transmute::<&[T], &[f64]>(query) }, count)
+            } else {
+                Err(Box::new("Unsupported type"))
+            }
+        }
 
         pub fn search_i8(self: &Index, query: &[i8], count: usize) -> Result<Matches>;
         pub fn search_f16(self: &Index, query: &[u16], count: usize) -> Result<Matches>;

package/wasmer.toml

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