usearch 0.9.3 → 0.9.5

package/.github/workflows/prerelease.yml

@@ -0,0 +1,105 @@
+name: Pre-Release
+
+on:
+  push:
+  pull_request:
+    branches: ["main-dev"]
+
+env:
+  BUILD_TYPE: Release
+  GH_TOKEN: ${{ secrets.SEMANTIC_RELEASE_TOKEN }}
+  PYTHONUTF8: 1
+
+# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+permissions:
+  contents: read
+
+jobs:
+
+  test_python:
+    name: Test Python
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-20.04, macOS-11, windows-2022]
+        python-version: ["3.11"]
+
+    steps:
+      - uses: actions/checkout@v3
+      - run: git submodule update --init --recursive
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install pytest numpy
+      - name: Build locally
+        run: python -m pip install .
+      - name: Test with PyTest on NIX
+        if: matrix.os != 'windows-2022'
+        run: pytest python/scripts/test.py
+
+  test_javascript:
+    name: Test JavaScript
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - run: git submodule update --init --recursive
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 18
+      - run: npm install
+      - run: npm ci
+      - run: npm test
+
+  test_rust:
+    name: Test Rust
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - run: git submodule update --init --recursive
+    - uses: actions-rs/toolchain@v1
+      with:
+          toolchain: stable
+          override: true
+
+  test_java:
+    name: Test Java
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - run: git submodule update --init --recursive
+    - uses: actions/setup-java@v3
+      with:
+        java-version: '11'
+        distribution: 'adopt'
+    - name: Setup Gradle
+      uses: gradle/gradle-build-action@v2.4.2
+    - name: Execute Gradle build
+      run: gradle clean build
+
+  test_swift:
+    name: Test ObjC & Swift
+    runs-on: macos-latest
+    steps:
+    - uses: actions/checkout@v3
+    - run: git submodule update --init --recursive
+    - name: Build
+      run: swift build
+    - name: Run tests
+      run: swift test
+
+  build_docker:
+    name: Test Docker Image
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - run: git submodule update --init --recursive
+    - name: Build
+      uses: docker/build-push-action@v4
+      with:
+        context: .
+        load: true
+        push: false

package/Cargo.toml

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

package/VERSION

@@ -1 +1 @@
-0.9.3
+0.9.5

package/conanfile.py

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

package/docs/compilation.md

@@ -35,7 +35,13 @@ cmake -B ./build_release \
     -DUSEARCH_BUILD_BENCHMARK=1 \
     -DUSEARCH_BUILD_TEST=1 \
     && \
-    make -C ./build_release -j 
+    make -C ./build_release -j
+```
+
+Linting:
+
+```sh
+cppcheck --enable=all --suppress=cstyleCast --suppress=unusedFunction include/usearch/usearch.hpp src/punned.hpp
 ```
 
 Benchmarking:
@@ -61,6 +67,13 @@ pip install -e .
 pytest python/scripts/test.py
 ```
 
+Linting:
+
+```sh
+pip install ruff
+ruff --format=github --select=E9,F63,F7,F82 --target-version=py37 python
+```
+
 Benchmarking:
 
 ```sh

package/include/usearch/usearch.hpp

@@ -103,7 +103,7 @@ using f64_t = double;
 using f32_t = float;
 using byte_t = char;
 
-template <typename at> at angle_to_radians(at angle) noexcept { return angle * M_PI / 180.f; }
+template <typename at> at angle_to_radians(at angle) noexcept { return angle * at(3.14159265358979323846) / at(180); }
 
 template <typename at> at square(at value) noexcept { return value * value; }
 
@@ -409,72 +409,66 @@ template <typename allocator_at = std::allocator<char>> class visits_bitset_gt {
     static_assert(sizeof(byte_t) == 1, "Allocator must allocate separate addressable bytes");
 
 #if defined(USEARCH_IS_WINDOWS)
-    using slot_t = LONG volatile;
-    static_assert(sizeof(slot_t) == 8);
+    using slot_t = LONGLONG;
 #else
-    using slot_t = std::uint64_t;
+    using slot_t = unsigned long;
 #endif
 
-    std::uint64_t* u64s_{};
-    std::size_t slots_{};
+    static constexpr std::size_t bits_per_slot() { return sizeof(slot_t) * CHAR_BIT; }
+    static constexpr slot_t bits_mask() { return sizeof(slot_t) * CHAR_BIT - 1; }
+
+    slot_t* slots_{};
+    std::size_t slots_count_{};
 
   public:
     visits_bitset_gt() noexcept {}
-    visits_bitset_gt(std::size_t capacity) noexcept {
-        slots_ = divide_round_up<64>(capacity);
-        u64s_ = (slot_t*)allocator_t{}.allocate(slots_ * sizeof(slot_t));
+    explicit visits_bitset_gt(std::size_t capacity) noexcept {
+        slots_count_ = divide_round_up<bits_per_slot()>(capacity);
+        slots_ = (slot_t*)allocator_t{}.allocate(slots_count_ * sizeof(slot_t));
         clear();
     }
-    ~visits_bitset_gt() noexcept { allocator_t{}.deallocate((byte_t*)u64s_, slots_ * sizeof(slot_t)), u64s_ = nullptr; }
-    void clear() noexcept { std::memset(u64s_, 0, slots_ * sizeof(slot_t)); }
-    inline bool test(std::size_t i) const noexcept { return u64s_[i / 64] & (1ul << (i & 63ul)); }
-    inline void set(std::size_t i) noexcept { u64s_[i / 64] |= (1ul << (i & 63ul)); }
+    ~visits_bitset_gt() noexcept {
+        allocator_t{}.deallocate((byte_t*)slots_, slots_count_ * sizeof(slot_t)), slots_ = nullptr;
+    }
+    void clear() noexcept { std::memset(slots_, 0, slots_count_ * sizeof(slot_t)); }
+    inline bool test(std::size_t i) const noexcept { return slots_[i / bits_per_slot()] & (1ul << (i & bits_mask())); }
+    inline void set(std::size_t i) noexcept { slots_[i / bits_per_slot()] |= (1ul << (i & bits_mask())); }
 
     visits_bitset_gt(visits_bitset_gt&& other) noexcept {
-        u64s_ = other.u64s_;
         slots_ = other.slots_;
-        other.u64s_ = nullptr;
-        other.slots_ = 0;
+        slots_count_ = other.slots_count_;
+        other.slots_ = nullptr;
+        other.slots_count_ = 0;
     }
 
     visits_bitset_gt& operator=(visits_bitset_gt&& other) noexcept {
-        std::swap(u64s_, other.u64s_);
         std::swap(slots_, other.slots_);
+        std::swap(slots_count_, other.slots_count_);
         return *this;
     }
 
 #if defined(USEARCH_IS_WINDOWS)
 
-    inline bool atomic_test(std::size_t i) noexcept {
-        slot_t mask{1ul << (i & 63ul)};
-        return InterlockedOr(&u64s_[i / 64], 0) & mask;
-    }
-
     inline bool atomic_set(std::size_t i) noexcept {
-        slot_t mask{1ul << (i & 63ul)};
-        return InterLockedOr(&u64s_[i / 64], mask) & mask;
+        slot_t mask{1ul << (i & bits_mask())};
+        return InterlockedOr64Acquire((slot_t volatile*)&slots_[i / bits_per_slot()], mask) & mask;
     }
 
     inline void atomic_reset(std::size_t i) noexcept {
-        slot_t mask{1ul << (i & 63ul)};
-        InterLockedAnd((LONG volatile*)&u64s_[i / 64], ~mask);
+        slot_t mask{1ul << (i & bits_mask())};
+        InterlockedAnd64Release((slot_t volatile*)&slots_[i / bits_per_slot()], ~mask);
     }
 
 #else
 
-    inline bool atomic_test(std::size_t i) noexcept {
-        slot_t mask{1ul << (i & 63ul)};
-        return __atomic_load_n(&u64s_[i / 64], __ATOMIC_RELAXED) & mask;
-    }
-
     inline bool atomic_set(std::size_t i) noexcept {
-        slot_t mask{1ul << (i & 63ul)};
-        return __atomic_fetch_or(&u64s_[i / 64], mask, __ATOMIC_ACQUIRE) & mask;
+        slot_t mask{1ul << (i & bits_mask())};
+        return __atomic_fetch_or(&slots_[i / bits_per_slot()], mask, __ATOMIC_ACQUIRE) & mask;
     }
 
     inline void atomic_reset(std::size_t i) noexcept {
-        slot_t mask{1ul << (i & 63ul)};
-        __atomic_fetch_and(&u64s_[i / 64], ~mask, __ATOMIC_RELEASE);
+        slot_t mask{1ul << (i & bits_mask())};
+        __atomic_fetch_and(&slots_[i / bits_per_slot()], ~mask, __ATOMIC_RELEASE);
     }
 
 #endif
@@ -777,7 +771,7 @@ template <typename scalar_at> class span_gt {
     std::size_t size_;
 
   public:
-    span_gt(scalar_at* begin, scalar_at* end) noexcept : data_(begin), size_(end - begin) {}
+    span_gt(scalar_at* begin, scalar_at const* end) noexcept : data_(begin), size_(end - begin) {}
     span_gt(scalar_at* begin, std::size_t size) noexcept : data_(begin), size_(size) {}
     scalar_at* data() const noexcept { return data_; }
     std::size_t size() const noexcept { return size_; }
@@ -924,11 +918,12 @@ class index_gt {
 
     template <typename ref_at> class member_iterator_gt {
         using ref_t = ref_at;
-        index_gt& index_;
-        std::size_t offset_;
+        index_gt* index_{};
+        std::size_t offset_{};
 
+        friend class index_gt;
         member_iterator_gt() noexcept {}
-        member_iterator_gt(index_gt& index, std::size_t offset) noexcept : index_(index), offset_(offset) {}
+        member_iterator_gt(index_gt* index, std::size_t offset) noexcept : index_(index), offset_(offset) {}
 
       public:
         using iterator_category = std::random_access_iterator_tag;
@@ -937,7 +932,7 @@ class index_gt {
         using pointer = void;
         using reference = ref_t;
 
-        reference operator*() const noexcept { return index_.node_with_id_(offset_); }
+        reference operator*() const noexcept { return index_->node_with_id_(offset_).ref(); }
         member_iterator_gt operator++(int) noexcept { return member_iterator_gt(index_, offset_ + 1); }
         member_iterator_gt operator--(int) noexcept { return member_iterator_gt(index_, offset_ - 1); }
         member_iterator_gt operator+(difference_type d) noexcept { return member_iterator_gt(index_, offset_ + d); }
@@ -959,8 +954,11 @@ class index_gt {
             offset_ -= d;
             return *this;
         }
-        bool operator!=(member_iterator_gt const& other) noexcept {
-            return &index_ != &other.index_ || offset_ != other.offset_;
+        bool operator==(member_iterator_gt const& other) const noexcept {
+            return index_ == other.index_ && offset_ == other.offset_;
+        }
+        bool operator!=(member_iterator_gt const& other) const noexcept {
+            return index_ != other.index_ || offset_ != other.offset_;
         }
     };
 
@@ -1052,7 +1050,7 @@ class index_gt {
 
         operator vector_view_t() const noexcept { return {vector(), dim()}; }
         vector_view_t vector_view() const noexcept { return {vector(), dim()}; }
-        member_ref_t ref() noexcept { return {label(), vector_view()}; }
+        member_ref_t ref() noexcept { return {{tape_}, vector_view()}; }
         member_cref_t cref() const noexcept { return {label(), vector_view()}; }
     };
 
@@ -1133,19 +1131,10 @@ class index_gt {
     config_t const& config() const { return config_; }
     bool is_immutable() const noexcept { return viewed_file_descriptor_ != 0; }
 
-    index_gt(config_t config = {}, metric_t metric = {}, allocator_t allocator = {}) noexcept(false)
-        : config_(normalize(config)), metric_(metric), allocator_(allocator) {
-
-        // Externally defined hyper-parameters:
-        pre_ = precompute_(config);
+    explicit index_gt(config_t config = {}, metric_t metric = {}, allocator_t allocator = {}) noexcept(false)
+        : config_(normalize(config)), metric_(metric), allocator_(allocator), pre_(precompute_(config)),
+          viewed_file_descriptor_(0), size_(0u), max_level_(-1), entry_id_(0u) {
 
-        // Configure initial empty state:
-        size_ = 0u;
-        max_level_ = -1;
-        entry_id_ = 0u;
-        viewed_file_descriptor_ = 0;
-
-        // Dynamic memory:
         thread_contexts_.resize(config.max_threads());
         for (thread_context_t& context : thread_contexts_)
             context.metric = metric;
@@ -1155,7 +1144,7 @@ class index_gt {
     /**
      *  @brief  Clones the structure with the same hyper-parameters, but without contents.
      */
-    index_gt fork() noexcept(false) { return {config_, metric_, allocator_}; }
+    index_gt fork() noexcept(false) { return index_gt{config_, metric_, allocator_}; }
 
     ~index_gt() noexcept { clear(); }
 
@@ -1166,6 +1155,13 @@ class index_gt {
         return *this;
     }
 
+    member_citerator_t cbegin() const noexcept { return {this, 0}; }
+    member_citerator_t cend() const noexcept { return {this, size()}; }
+    member_citerator_t begin() const noexcept { return {this, 0}; }
+    member_citerator_t end() const noexcept { return {this, size()}; }
+    member_iterator_t begin() noexcept { return {this, 0}; }
+    member_iterator_t end() noexcept { return {this, size()}; }
+
 #pragma region Adjusting Configuration
 
     /**
@@ -1196,12 +1192,12 @@ class index_gt {
         std::swap(thread_contexts_, other.thread_contexts_);
 
         // Non-atomic parts.
-        std::size_t capacity = capacity_;
-        std::size_t size = size_;
+        std::size_t capacity_copy = capacity_;
+        std::size_t size_copy = size_;
         capacity_ = other.capacity_.load();
         size_ = other.size_.load();
-        other.capacity_ = capacity;
-        other.size_ = size;
+        other.capacity_ = capacity_copy;
+        other.size_ = size_copy;
     }
 
     /**
@@ -1226,7 +1222,7 @@ class index_gt {
         precomputed_constants_t pre = precompute_(config);
         std::size_t bytes_per_node_base = node_head_bytes_() + pre.neighbors_base_bytes;
         std::size_t rounded_size = divide_round_up<64>(bytes_per_node_base) * 64;
-        std::size_t added_connections = (rounded_size - rounded_size) / sizeof(id_t);
+        std::size_t added_connections = (rounded_size - bytes_per_node_base) / sizeof(id_t);
         config.connectivity = config.connectivity + added_connections / base_level_multiple_();
         return config;
     }
@@ -1305,11 +1301,11 @@ class index_gt {
 
         // Determining how much memory to allocate depends on the target level
         std::unique_lock<std::mutex> new_level_lock(global_mutex_);
-        level_t max_level = max_level_; // Copy under lock
-        id_t entry_id = entry_id_;      // Copy under lock
+        level_t max_level_copy = max_level_; // Copy under lock
+        id_t entry_id_copy = entry_id_;      // Copy under lock
         thread_context_t& context = thread_contexts_[config.thread];
         level_t target_level = choose_random_level_(context.level_generator);
-        if (target_level <= max_level)
+        if (target_level <= max_level_copy)
             new_level_lock.unlock();
 
         // Allocate the neighbors
@@ -1329,10 +1325,10 @@ class index_gt {
         result.cycles = context.iteration_cycles;
 
         // Go down the level, tracking only the closest match
-        id_t closest_id = search_for_one_(entry_id, vector, max_level, target_level, context);
+        id_t closest_id = search_for_one_(entry_id_copy, vector, max_level_copy, target_level, context);
 
         // From `target_level` down perform proper extensive search
-        for (level_t level = (std::min)(target_level, max_level); level >= 0; level--) {
+        for (level_t level = (std::min)(target_level, max_level_copy); level >= 0; --level) {
             search_to_insert_(closest_id, vector, level, context);
             closest_id = connect_new_node_(new_id, level, context);
         }
@@ -1342,7 +1338,7 @@ class index_gt {
         result.cycles = context.iteration_cycles - result.cycles;
 
         // Updating the entry point if needed
-        if (target_level > max_level) {
+        if (target_level > max_level_copy) {
             entry_id_ = new_id;
             max_level_ = target_level;
         }
@@ -1419,12 +1415,12 @@ class index_gt {
     struct stats_t {
         std::size_t nodes;
         std::size_t edges;
-        std::size_t max_edged;
+        std::size_t max_edges;
     };
 
     stats_t stats() const noexcept {
         stats_t result{};
-        result.nodes = nodes_.size();
+        result.nodes = size();
         for (std::size_t i = 0; i != result.nodes; ++i) {
             node_t node = node_with_id_(i);
             std::size_t max_edges = node.level() * config_.connectivity + base_level_multiple_() * config_.connectivity;
@@ -1440,7 +1436,7 @@ class index_gt {
 
     stats_t stats(std::size_t level) const noexcept {
         stats_t result{};
-        result.nodes = nodes_.size();
+        result.nodes = size();
         for (std::size_t i = 0; i != result.nodes; ++i) {
             node_t node = node_with_id_(i);
             if (node.level() >= level)
@@ -1792,7 +1788,7 @@ class index_gt {
         thread_context_t& context) const noexcept {
 
         distance_t closest_dist = context.measure(query, node_with_id_(closest_id));
-        for (level_t level = begin_level; level > end_level; level--) {
+        for (level_t level = begin_level; level > end_level; --level) {
             bool changed;
             do {
                 changed = false;
@@ -1919,7 +1915,7 @@ class index_gt {
         top_candidates_t& top = context.top_candidates;
         top.clear();
         top.reserve(count);
-        for (std::size_t i = 0; i != nodes_.size(); ++i)
+        for (std::size_t i = 0; i != size(); ++i)
             top.emplace_reserved(context.measure(query, node_with_id_(i)), static_cast<id_t>(i));
     }
 

package/package.json

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

package/pyproject.toml

@@ -46,3 +46,4 @@ before-build = [
     "git submodule update --init --recursive"
 ]
 archs = ["x86", "AMD64"]
+skip = ["*win32*"]

package/python/scripts/bench_params.py

@@ -1,6 +1,5 @@
 import os
 import time
-import numpy as np
 
 import fire
 import plotly.express as px

package/python/usearch/client.py

@@ -18,9 +18,16 @@ def _vector_to_ascii(vector: np.ndarray) -> Optional[str]:
     return ascii
 
 
+Triplet = tuple[np.ndarray, np.ndarray, np.ndarray]
+
+
 class IndexClient:
 
-    def __init__(self, uri: str = '127.0.0.1', port: int = 8545, use_http: bool = True) -> None:
+    def __init__(
+            self,
+            uri: str = '127.0.0.1',
+            port: int = 8545,
+            use_http: bool = True) -> None:
         self.client = Client(uri=uri, port=port, use_http=use_http)
 
     def add_one(self, label: int, vector: np.ndarray):
@@ -46,7 +53,7 @@ class IndexClient:
         else:
             return self.add_many(labels, vectors)
 
-    def search_one(self, vector: np.ndarray, count: int) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    def search_one(self, vector: np.ndarray, count: int) -> Triplet:
         matches: list[dict] = []
         vector = vector.flatten()
         ascii = _vector_to_ascii(vector)
@@ -68,7 +75,7 @@ class IndexClient:
 
         return labels, distances, counts
 
-    def search_many(self, vectors: np.ndarray, count: int) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    def search_many(self, vectors: np.ndarray, count: int) -> Triplet:
         batch_size: int = vectors.shape[0]
         list_of_matches: list[list[dict]] = self.client.search_many(
             vectors=vectors, count=count)
@@ -84,7 +91,7 @@ class IndexClient:
 
         return labels, distances, counts
 
-    def search(self, vectors: np.ndarray, count: int) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    def search(self, vectors: np.ndarray, count: int) -> Triplet:
         if vectors.ndim == 1 or (vectors.ndim == 2 and vectors.shape[0] == 1):
             return self.search_one(vectors, count)
         else:

package/python/usearch/server.py

@@ -8,12 +8,16 @@ import numpy as np
 from ucall.rich_posix import Server
 from usearch.index import Index
 
+Triplet = tuple[np.ndarray, np.ndarray, np.ndarray]
+
+
+def _results_to_json(results: Triplet, row: int) -> list[dict]:
 
-def _results_to_json(results: tuple[np.ndarray, np.ndarray, np.ndarray], row: int) -> list[dict]:
     count = results[2][row]
     labels = results[0][row, :count]
     distances = results[1][row, :count]
-    return [{'label': int(l), 'distance': float(d)} for l, d in zip(labels, distances)]
+    return [{'label': int(label), 'distance': float(distance)}
+            for label, distance in zip(labels, distances)]
 
 
 def _ascii_to_vector(string: str) -> np.ndarray:

package/src/punned.hpp

@@ -399,12 +399,15 @@ class punned_gt {
         isa_t acceleration;
     };
 
+    using member_iterator_t = typename index_t::member_iterator_t;
+    using member_citerator_t = typename index_t::member_citerator_t;
+
     std::size_t dimensions_ = 0;
     std::size_t casted_vector_bytes_ = 0;
     accuracy_t accuracy_ = accuracy_t::f32_k;
     isa_t acceleration_ = isa_t::auto_k;
 
-    index_t* index_{};
+    index_t* typed_{};
     mutable std::vector<byte_t> cast_buffer_{};
     struct casts_t {
         cast_t from_f8{};
@@ -421,6 +424,7 @@ class punned_gt {
   public:
     using search_results_t = typename index_t::search_results_t;
     using add_result_t = typename index_t::add_result_t;
+    using stats_t = typename index_t::stats_t;
 
     punned_gt() = default;
     punned_gt(punned_gt&& other) { swap(other); }
@@ -429,14 +433,14 @@ class punned_gt {
         return *this;
     }
 
-    ~punned_gt() { aligned_index_free_(index_); }
+    ~punned_gt() { aligned_index_free_(typed_); }
 
     void swap(punned_gt& other) {
         std::swap(dimensions_, other.dimensions_);
         std::swap(casted_vector_bytes_, other.casted_vector_bytes_);
         std::swap(accuracy_, other.accuracy_);
         std::swap(acceleration_, other.acceleration_);
-        std::swap(index_, other.index_);
+        std::swap(typed_, other.typed_);
         std::swap(cast_buffer_, other.cast_buffer_);
         std::swap(casts_, other.casts_);
         std::swap(root_metric_, other.root_metric_);
@@ -446,19 +450,29 @@ class punned_gt {
     static config_t optimize(config_t config) noexcept { return index_t::optimize(config); }
 
     std::size_t dimensions() const { return dimensions_; }
-    std::size_t connectivity() const { return index_->connectivity(); }
-    std::size_t size() const { return index_->size(); }
-    std::size_t capacity() const { return index_->capacity(); }
-    config_t const& config() const { return index_->config(); }
-    void clear() { return index_->clear(); }
+    std::size_t connectivity() const { return typed_->connectivity(); }
+    std::size_t size() const { return typed_->size(); }
+    std::size_t capacity() const { return typed_->capacity(); }
+    config_t const& config() const { return typed_->config(); }
+    void clear() { return typed_->clear(); }
+
+    member_citerator_t cbegin() const noexcept { return typed_->cbegin(); }
+    member_citerator_t cend() const noexcept { return typed_->cend(); }
+    member_citerator_t begin() const noexcept { return typed_->begin(); }
+    member_citerator_t end() const noexcept { return typed_->end(); }
+    member_iterator_t begin() noexcept { return typed_->begin(); }
+    member_iterator_t end() noexcept { return typed_->end(); }
+
+    stats_t stats() const noexcept { return typed_->stats(); }
+    stats_t stats(std::size_t level) const noexcept { return typed_->stats(level); }
 
     accuracy_t accuracy() const { return accuracy_; }
     isa_t acceleration() const { return acceleration_; }
 
-    void save(char const* path) const { index_->save(path); }
-    void load(char const* path) { index_->load(path); }
-    void view(char const* path) { index_->view(path); }
-    void reserve(std::size_t capacity) { index_->reserve(capacity); }
+    void save(char const* path) const { typed_->save(path); }
+    void load(char const* path) { typed_->load(path); }
+    void view(char const* path) { typed_->view(path); }
+    void reserve(std::size_t capacity) { typed_->reserve(capacity); }
 
     // clang-format off
     add_result_t add(label_t label, f8_bits_t const* vector) { return add_(label, vector, casts_.from_f8); }
@@ -516,7 +530,7 @@ class punned_gt {
         result.root_metric_ = root_metric_;
         index_t* raw = aligned_index_alloc_();
         new (raw) index_t(config(), root_metric_);
-        result.index_ = raw;
+        result.typed_ = raw;
 
         return result;
     }
@@ -563,7 +577,7 @@ class punned_gt {
         if (casted)
             vector_data = casted_data, vector_bytes = casted_vector_bytes_, config.store_vector = true;
 
-        return index_->add(label, {vector_data, vector_bytes}, config);
+        return typed_->add(label, {vector_data, vector_bytes}, config);
     }
 
     template <typename scalar_at>
@@ -579,7 +593,7 @@ class punned_gt {
         if (casted)
             vector_data = casted_data, vector_bytes = casted_vector_bytes_;
 
-        return index_->search({vector_data, vector_bytes}, wanted, config);
+        return typed_->search({vector_data, vector_bytes}, wanted, config);
     }
 
     template <typename scalar_at>
@@ -595,14 +609,14 @@ class punned_gt {
         if (casted)
             vector_data = casted_data, vector_bytes = casted_vector_bytes_;
 
-        return index_->search_around(static_cast<id_t>(hint), {vector_data, vector_bytes}, wanted, config);
+        return typed_->search_around(static_cast<id_t>(hint), {vector_data, vector_bytes}, wanted, config);
     }
 
     template <typename scalar_at> add_result_t add_(label_t label, scalar_at const* vector, cast_t const& cast) {
         thread_lock_t lock = thread_lock_();
-        add_config_t config;
-        config.thread = lock.thread_id;
-        return add_(label, vector, config, cast);
+        add_config_t add_config;
+        add_config.thread = lock.thread_id;
+        return add_(label, vector, add_config, cast);
     }
 
     template <typename scalar_at>
@@ -610,9 +624,9 @@ class punned_gt {
         scalar_at const* vector, std::size_t wanted, //
         cast_t const& cast) const {
         thread_lock_t lock = thread_lock_();
-        search_config_t config;
-        config.thread = lock.thread_id;
-        return search_(vector, wanted, config, cast);
+        search_config_t search_config;
+        search_config.thread = lock.thread_id;
+        return search_(vector, wanted, search_config, cast);
     }
 
     template <typename scalar_at>
@@ -620,9 +634,9 @@ class punned_gt {
         label_t hint, scalar_at const* vector, std::size_t wanted, //
         cast_t const& cast) const {
         thread_lock_t lock = thread_lock_();
-        search_config_t config;
-        config.thread = lock.thread_id;
-        return search_around_(hint, vector, wanted, config, cast);
+        search_config_t search_config;
+        search_config.thread = lock.thread_id;
+        return search_around_(hint, vector, wanted, search_config, cast);
     }
 
     static punned_gt make_(                               //
@@ -650,7 +664,7 @@ class punned_gt {
         // Available since C11, but only C++17, so we use the C version.
         index_t* raw = aligned_index_alloc_();
         new (raw) index_t(config, metric_and_meta.metric);
-        result.index_ = raw;
+        result.typed_ = raw;
         return result;
     }
 

package/src/test.cpp

@@ -1,6 +1,7 @@
 /**
  * @brief A trivial test.
  */
+#include <algorithm>
 #include <cassert>
 
 #include "punned.hpp"
@@ -15,10 +16,13 @@ template <typename scalar_at, typename index_at> void test3d(index_at&& index) {
     using distance_t = typename index_at::distance_t;
 
     scalar_at vec[3] = {10, 20, 15};
+    scalar_at vec_a[3] = {15, 16, 17};
+    scalar_at vec_b[3] = {16, 17, 18};
 
     index.reserve(10);
     index.add(42, span_t{&vec[0], 3ul});
 
+    // Default approximate search
     point_id_t matched_labels[10] = {0};
     distance_t matched_distances[10] = {0};
     std::size_t matched_count = index.search(span_t{&vec[0], 3ul}, 5).dump_to(matched_labels, matched_distances);
@@ -27,19 +31,38 @@ template <typename scalar_at, typename index_at> void test3d(index_at&& index) {
     assert(matched_labels[0] == 42);
     assert(std::abs(matched_distances[0]) < 0.01);
 
-    index.save("tmp.usearch");
+    // Add more entries
+    search_config_t search_config;
+    search_config.exact = true;
+    index.add(43, span_t{&vec_a[0], 3ul});
+    index.add(44, span_t{&vec_b[0], 3ul});
+    assert(index.size() == 3);
+
+    // Perform exact search
+    matched_count = index.search(span_t{&vec[0], 3ul}, 5, search_config).dump_to(matched_labels, matched_distances);
+
+    // Validate scans
+    std::size_t count = 0;
+    for (auto member : index) {
+        point_id_t id = member.label;
+        assert(id >= 42 && id <= 44);
+        count++;
+    }
+    assert((count == 3));
+    assert((index.stats(0).nodes == 3));
 
     // Search again over reconstructed index
+    index.save("tmp.usearch");
     index.load("tmp.usearch");
     matched_count = index.search(span_t{&vec[0], 3ul}, 5).dump_to(matched_labels, matched_distances);
-    assert(matched_count == 1);
+    assert(matched_count == 3);
     assert(matched_labels[0] == 42);
     assert(std::abs(matched_distances[0]) < 0.01);
 
     // Search again over mapped index
     index.view("tmp.usearch");
     matched_count = index.search(span_t{&vec[0], 3ul}, 5).dump_to(matched_labels, matched_distances);
-    assert(matched_count == 1);
+    assert(matched_count == 3);
     assert(matched_labels[0] == 42);
     assert(std::abs(matched_distances[0]) < 0.01);
 }