Merge branch 'main-dev' of https://github.com/unum-cloud/usearch into main-dev

Author: ashvardanian

cpp/README.md

@@ -16,21 +16,29 @@ Once included, the high-level C++11 interface is as simple as it gets: `reserve(
 This covers 90% of use cases.
 
 ```cpp
-using namespace unum::usearch;
-
-metric_punned_t metric(256, metric_kind_t::l2sq_k, scalar_kind_t::f32_k);
+#include <usearch/index.hpp>
+#include <usearch/index_dense.hpp>
 
-// If you plan to store more than 4 Billion entries - use `index_dense_big_t`.
-// Or directly instantiate the template variant you need - `index_dense_gt<vector_key_t, internal_id_t>`.
-index_dense_t index = index_dense_t::make(metric);
-float vec[3] = {0.1, 0.3, 0.2};
-
-index.reserve(10); // Pre-allocate memory for 10 vectors
-index.add(42, &vec[0]); // Pass a key and a vector
-auto results = index.search(&vec[0], 5); // Pass a query and limit number of results
+using namespace unum::usearch;
 
-for (std::size_t i = 0; i != results.size(); ++i)
-    results[i].element.key, results[i].element.vector, results[i].distance;
+int main(int argc, char **argv) {
+    metric_punned_t metric(3, metric_kind_t::l2sq_k, scalar_kind_t::f32_k);
+    
+    // If you plan to store more than 4 Billion entries - use `index_dense_big_t`.
+    // Or directly instantiate the template variant you need - `index_dense_gt<vector_key_t, internal_id_t>`.
+    index_dense_t index = index_dense_t::make(metric);
+    float vec[3] = {0.1, 0.3, 0.2};
+    
+    index.reserve(10); // Pre-allocate memory for 10 vectors
+    index.add(42, &vec[0]); // Pass a key and a vector
+    auto results = index.search(&vec[0], 5); // Pass a query and limit number of results
+    
+    for (std::size_t i = 0; i != results.size(); ++i)
+        // You can access the following properties of every match:
+        // results[i].element.key, results[i].element.vector, results[i].distance;
+        std::printf("Found matching key: %zu", results[i].element.key);
+    return 0;
+}
 ```
 
 Here we:

cpp/test.cpp

@@ -122,33 +122,6 @@ void test_uint40() {
     }
 }
 
-/**
- * Tests the behavior of various move-constructors and move-assignment operators for the index.
- *
- * Constructs an index and performs tests with it before and after move operations to ensure that the index maintains
- * its integrity and functionality after being moved.
- *
- * @param config Configuration settings for the index.
- * @tparam index_at Type of the index being tested.
- */
-template <typename index_at> void test_move_constructors(index_config_t const& config) {
-    {
-        index_at index{config};
-        test_sets(index);
-    }
-    {
-        index_at index{config};
-        index.reserve(1);
-        test_sets(index_at(std::move(index)));
-    }
-    {
-        index_at index{config};
-        index.reserve(1);
-        index_at index_moved = std::move(index);
-        test_sets(index_moved);
-    }
-}
-
 /**
  * The goal of this test is to invoke as many different interfaces as possible, making sure that all code-paths compile.
  * For that it only uses a tiny set of 3 predefined vectors.
@@ -199,15 +172,18 @@ void test_minimal_three_vectors(index_at& index, //
     index.add(key_third, vector_third.data(), args...);
     expect(index.size() == 3);
 
-    // Perform exact search
-    matched_count = index.search(vector_first.data(), 5, args...).dump_to(matched_keys, matched_distances);
+    // Perform single entry search
+    matched_count = index                                        //
+                        .search(vector_first.data(), 5, args...) //
+                        .dump_to(matched_keys, matched_distances);
     expect(matched_count != 0);
 
     // Perform filtered exact search, keeping only odd values
     if constexpr (punned_ak) {
         auto is_odd = [](vector_key_t key) -> bool { return (key & 1) != 0; };
-        matched_count =
-            index.filtered_search(vector_first.data(), 5, is_odd, args...).dump_to(matched_keys, matched_distances);
+        matched_count = index                                                         //
+                            .filtered_search(vector_first.data(), 5, is_odd, args...) //
+                            .dump_to(matched_keys, matched_distances);
         expect(matched_count != 0);
         for (std::size_t i = 0; i < matched_count; i++)
             expect(is_odd(matched_keys[i]));
@@ -240,6 +216,50 @@ void test_minimal_three_vectors(index_at& index, //
 
     index.save("tmp.usearch");
 
+    // Perform content and scan validations for a copy
+    {
+        auto copy_result = index.copy();
+        expect(bool(copy_result));
+        auto& copied_index = copy_result.index;
+
+        // Perform single entry search
+        matched_count = copied_index                                 //
+                            .search(vector_first.data(), 5, args...) //
+                            .dump_to(matched_keys, matched_distances);
+        expect(matched_count != 0);
+
+        // Validate scans
+        std::size_t count = 0;
+        for (auto member : copied_index) {
+            vector_key_t id = member.key;
+            expect(id >= key_first && id <= key_third);
+            count++;
+        }
+        expect((count == 3));
+        expect((copied_index.stats(0).nodes == 3));
+    }
+
+    // Perform content and scan validations for a moved
+    {
+        index_at moved_index(std::move(index));
+
+        // Perform single entry search
+        matched_count = moved_index                                  //
+                            .search(vector_first.data(), 5, args...) //
+                            .dump_to(matched_keys, matched_distances);
+        expect(matched_count != 0);
+
+        // Validate scans
+        std::size_t count = 0;
+        for (auto member : moved_index) {
+            vector_key_t id = member.key;
+            expect(id >= key_first && id <= key_third);
+            count++;
+        }
+        expect((count == 3));
+        expect((moved_index.stats(0).nodes == 3));
+    }
+
     // Check if metadata is retrieved correctly
     if constexpr (punned_ak) {
         auto head = index_dense_metadata_from_path("tmp.usearch");

include/usearch/index_dense.hpp

@@ -1523,11 +1523,12 @@ class index_dense_gt {
         if (!config.force_vector_copy && copy.config_.exclude_vectors) {
             std::memcpy(copy.vectors_lookup_.data(), vectors_lookup_.data(), vectors_lookup_.size() * sizeof(byte_t*));
         } else {
-            for (std::size_t slot = 0; slot != vectors_lookup_.size(); ++slot)
+            std::size_t slots_count = typed_result.index.size();
+            for (std::size_t slot = 0; slot != slots_count; ++slot)
                 copy.vectors_lookup_[slot] = copy.vectors_tape_allocator_.allocate(copy.metric_.bytes_per_vector());
-            if (std::count(copy.vectors_lookup_.begin(), copy.vectors_lookup_.end(), nullptr))
+            if (std::count(copy.vectors_lookup_.begin(), copy.vectors_lookup_.begin() + slots_count, nullptr))
                 return result.failed("Out of memory!");
-            for (std::size_t slot = 0; slot != vectors_lookup_.size(); ++slot)
+            for (std::size_t slot = 0; slot != slots_count; ++slot)
                 std::memcpy(copy.vectors_lookup_[slot], vectors_lookup_[slot], metric_.bytes_per_vector());
         }