usearch 2.11.1 → 2.13.1

package/c/test.c

@@ -5,11 +5,15 @@
 
 #include "usearch.h"
 
-#define ASSERT(must_be_true, message)                                                                                  \
-    if (!(must_be_true)) {                                                                                             \
-        printf("Assert: %s\n", message);                                                                               \
-        exit(-1);                                                                                                      \
-    }
+void expect(bool must_be_true, char const* message) {
+    if (must_be_true)
+        return;
+    message = message ? message : "C unit test failed";
+    printf("Assert: %s\n", message);
+    exit(-1);
+}
+
+#define expect_eq(a, b, message) expect(a == b, message)
 
 /**
  * @brief Creates and initializes vectors with random float values.
@@ -20,7 +24,7 @@
  */
 float* create_vectors(size_t const count, size_t const dimensions) {
     float* data = (float*)malloc(count * dimensions * sizeof(float));
-    ASSERT(data, "Failed to allocate memory");
+    expect(data, "Failed to allocate memory");
     for (size_t index = 0; index < count * dimensions; ++index)
         data[index] = (float)rand() / (float)RAND_MAX;
     return data;
@@ -52,31 +56,31 @@ void test_init(size_t const collection_size, size_t const dimensions) {
     usearch_error_t error = NULL;
     usearch_init_options_t opts = create_options(dimensions);
     usearch_index_t index = usearch_init(&opts, &error);
-    ASSERT(!error, error);
+    expect(!error, error);
     usearch_free(index, &error);
-    ASSERT(!error, error);
+    expect(!error, error);
 
     // Init second time
     index = usearch_init(&opts, &error);
-    ASSERT(!error, error);
+    expect(!error, error);
 
-    ASSERT(usearch_size(index, &error) == 0, error);
-    ASSERT(usearch_capacity(index, &error) == 0, error);
-    ASSERT(usearch_dimensions(index, &error) == dimensions, error);
-    ASSERT(usearch_connectivity(index, &error) == opts.connectivity, error);
+    expect_eq(usearch_size(index, &error), 0, error);
+    expect_eq(usearch_capacity(index, &error), 0, error);
+    expect_eq(usearch_dimensions(index, &error), dimensions, error);
+    expect_eq(usearch_connectivity(index, &error), opts.connectivity, error);
 
     // Reserve
     usearch_reserve(index, collection_size, &error);
-    ASSERT(!error, error);
-    ASSERT(usearch_size(index, &error) == 0, error);
-    ASSERT(usearch_capacity(index, &error) == collection_size, error);
-    ASSERT(usearch_dimensions(index, &error) == dimensions, error);
-    ASSERT(usearch_connectivity(index, &error) == opts.connectivity, error);
-    ASSERT(usearch_hardware_acceleration(index, &error), error);
-    ASSERT(usearch_memory_usage(index, &error), error);
+    expect(!error, error);
+    expect_eq(usearch_size(index, &error), 0, error);
+    expect(usearch_capacity(index, &error) >= collection_size, error);
+    expect_eq(usearch_dimensions(index, &error), dimensions, error);
+    expect_eq(usearch_connectivity(index, &error), opts.connectivity, error);
+    expect(usearch_hardware_acceleration(index, &error), error);
+    expect(usearch_memory_usage(index, &error), error);
 
     usearch_free(index, &error);
-    ASSERT(!error, error);
+    expect(!error, error);
 
     printf("Test: Index Initialization - PASSED\n");
 }
@@ -99,18 +103,18 @@ void test_add_vector(size_t const collection_size, size_t const dimensions) {
     for (size_t i = 0; i < collection_size; ++i) {
         usearch_key_t key = i;
         usearch_add(index, key, data + i * dimensions, usearch_scalar_f32_k, &error);
-        ASSERT(!error, error);
+        expect(!error, error);
     }
 
-    ASSERT(usearch_size(index, &error) == collection_size, error);
-    ASSERT(usearch_capacity(index, &error) == collection_size, error);
+    expect_eq(usearch_size(index, &error), collection_size, error);
+    expect(usearch_capacity(index, &error) >= collection_size, error);
 
     // Check vectors in the index
     for (size_t i = 0; i < collection_size; ++i) {
         usearch_key_t key = i;
-        ASSERT(usearch_contains(index, key, &error), error);
+        expect(usearch_contains(index, key, &error), error);
     }
-    ASSERT(!usearch_contains(index, -1, &error), error); // Non existing key
+    expect(!usearch_contains(index, -1, &error), error); // Non existing key
 
     free(data);
     usearch_free(index, &error);
@@ -133,22 +137,22 @@ void test_find_vector(size_t const collection_size, size_t const dimensions) {
     // Create result buffers
     usearch_key_t* keys = (usearch_key_t*)malloc(collection_size * sizeof(usearch_key_t));
     float* distances = (float*)malloc(collection_size * sizeof(float));
-    ASSERT(keys && distances, "Failed to allocate memory");
+    expect(keys && distances, "Failed to allocate memory");
 
     // Add vectors
     float* data = create_vectors(collection_size, dimensions);
     for (size_t i = 0; i < collection_size; ++i) {
         usearch_key_t key = i;
         usearch_add(index, key, data + i * dimensions, usearch_scalar_f32_k, &error);
-        ASSERT(!error, error);
+        expect(!error, error);
     }
 
     // Find the vectors
     for (size_t i = 0; i < collection_size; i++) {
         size_t found_count = usearch_search(index, data + i * dimensions, usearch_scalar_f32_k, collection_size, keys,
                                             distances, &error);
-        ASSERT(!error, error);
-        ASSERT(found_count >= 1 && found_count <= collection_size, "Vector is missing");
+        expect(!error, error);
+        expect(found_count >= 1 && found_count <= collection_size, "Vector is missing");
     }
 
     free(data);
@@ -174,19 +178,19 @@ void test_get_vector(size_t const collection_size, size_t const dimensions) {
 
     // Create result buffers
     float* vectors = (float*)malloc(collection_size * dimensions * sizeof(float));
-    ASSERT(vectors, "Failed to allocate memory");
+    expect(vectors, "Failed to allocate memory");
 
     // Add multiple vectors with SAME key
     usearch_key_t const key = 1;
     float* data = create_vectors(collection_size, dimensions);
     for (size_t i = 0; i < collection_size; i++) {
         usearch_add(index, key, data + i * dimensions, usearch_scalar_f32_k, &error);
-        ASSERT(!error, error);
+        expect(!error, error);
     }
 
     // Retrieve vectors from index
     size_t found_count = usearch_get(index, key, collection_size, vectors, usearch_scalar_f32_k, &error);
-    ASSERT(found_count == collection_size, "Vector is missing");
+    expect_eq(found_count, collection_size, "Vector is missing");
 
     free(vectors);
     free(data);
@@ -213,14 +217,14 @@ void test_remove_vector(size_t const collection_size, size_t const dimensions) {
     for (size_t i = 0; i < collection_size; ++i) {
         usearch_key_t key = i;
         usearch_add(index, key, data + i * dimensions, usearch_scalar_f32_k, &error);
-        ASSERT(!error, error);
+        expect(!error, error);
     }
 
     // Remove the vectors
     for (size_t i = 0; i < collection_size; i++) {
         usearch_key_t key = i;
         usearch_remove(index, key, &error);
-        ASSERT(!error, "Currently, Remove is not supported");
+        expect(!error, "Currently, Remove is not supported");
     }
 
     free(data);
@@ -256,14 +260,14 @@ void test_save_load(size_t const collection_size, size_t const dimensions) {
         for (size_t i = 0; i < collection_size; ++i) {
             usearch_key_t key = i;
             usearch_add(index, key, data + i * dimensions, usearch_scalar_f32_k, &error);
-            ASSERT(!error, error);
+            expect(!error, error);
         }
 
         // Save and free the index
         usearch_save(index, "tmp.usearch", &error);
-        ASSERT(!error, error);
+        expect(!error, error);
         usearch_free(index, &error);
-        ASSERT(!error, error);
+        expect(!error, error);
     }
 
     // Reset the options
@@ -278,35 +282,36 @@ void test_save_load(size_t const collection_size, size_t const dimensions) {
     // Reinit
     {
 
-        usearch_index_t index = usearch_init(&opts, &error);
-        ASSERT(!error, error);
-        ASSERT(usearch_size(index, &error) == 0, error);
+        usearch_index_t index = usearch_init(NULL, &error);
+        expect(!error, error);
+        // expect(usearch_size(index, &error) == 0, error);
 
         // Load
         usearch_load(index, "tmp.usearch", &error);
-        ASSERT(!error, error);
-        ASSERT(usearch_size(index, &error) == collection_size, error);
-        ASSERT(usearch_capacity(index, &error) == collection_size, error);
-        ASSERT(usearch_dimensions(index, &error) == dimensions, error);
-        ASSERT(usearch_connectivity(index, &error) == weird_ops.connectivity, error);
+        expect(!error, error);
+        expect(usearch_size(index, &error) == collection_size, error);
+        expect(usearch_capacity(index, &error) == collection_size, error);
+        expect(usearch_dimensions(index, &error) == dimensions, error);
+        expect(usearch_connectivity(index, &error) == weird_ops.connectivity, error);
 
         // Check vectors in the index
         for (size_t i = 0; i < collection_size; ++i) {
             usearch_key_t key = i;
-            ASSERT(usearch_contains(index, key, &error), error);
+            expect(usearch_contains(index, key, &error), error);
         }
 
         // Create result buffers
         usearch_key_t* keys = (usearch_key_t*)malloc(collection_size * sizeof(usearch_key_t));
         float* distances = (float*)malloc(collection_size * sizeof(float));
-        ASSERT(keys && distances, "Failed to allocate memory");
+        expect(keys && distances, "Failed to allocate memory");
 
         // Find the vectors
+        usearch_change_threads_search(index, 1, &error);
         for (size_t i = 0; i < collection_size; i++) {
             size_t found_count = usearch_search(index, data + i * dimensions, usearch_scalar_f32_k, collection_size,
                                                 keys, distances, &error);
-            ASSERT(!error, error);
-            ASSERT(found_count >= 1 && found_count <= collection_size, "Vector is missing");
+            expect(!error, error);
+            expect(found_count >= 1 && found_count <= collection_size, "Vector is missing");
         }
 
         free(keys);
@@ -340,22 +345,22 @@ void test_view(size_t const collection_size, size_t const dimensions) {
     for (size_t i = 0; i < collection_size; ++i) {
         usearch_key_t key = i;
         usearch_add(index, key, data + i * dimensions, usearch_scalar_f32_k, &error);
-        ASSERT(!error, error);
+        expect(!error, error);
     }
 
     // Save and free the index
     usearch_save(index, "tmp.usearch", &error);
-    ASSERT(!error, error);
+    expect(!error, error);
     usearch_free(index, &error);
-    ASSERT(!error, error);
+    expect(!error, error);
 
     // Reinit
     index = usearch_init(&opts, &error);
-    ASSERT(!error, error);
+    expect(!error, error);
 
     // View
     usearch_view(index, "tmp.usearch", &error);
-    ASSERT(!error, error);
+    expect(!error, error);
 
     free(data);
     usearch_free(index, &error);

package/c/usearch.h

@@ -281,6 +281,22 @@ USEARCH_EXPORT void usearch_change_expansion_add(usearch_index_t index, size_t e
  */
 USEARCH_EXPORT void usearch_change_expansion_search(usearch_index_t index, size_t expansion, usearch_error_t* error);
 
+/**
+ *  @brief Updates the number of threads that would be used to construct the index. Rarely used.
+ *  @param[in] index The handle to the USearch index to be queried.
+ *  @param[in] threads The new limit for the number of concurrent threads.
+ *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
+ */
+USEARCH_EXPORT void usearch_change_threads_add(usearch_index_t index, size_t threads, usearch_error_t* error);
+
+/**
+ *  @brief Updates the number of threads that will be performing concurrent traversals. Rarely used.
+ *  @param[in] index The handle to the USearch index to be queried.
+ *  @param[in] threads The new limit for the number of concurrent threads.
+ *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
+ */
+USEARCH_EXPORT void usearch_change_threads_search(usearch_index_t index, size_t threads, usearch_error_t* error);
+
 /**
  *  @brief Updates the metric kind used for distance calculation between vectors.
  *  @param[in] index The handle to the USearch index to be queried.

package/cpp/CMakeLists.txt

@@ -4,6 +4,12 @@ if (USEARCH_BUILD_TEST_CPP)
     include(CTest)
     enable_testing()
     add_test(NAME test_cpp COMMAND test_cpp)
+
+    target_include_directories(test_cpp PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../stringzilla/include)
+
+    if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+        target_compile_options(test_cpp PRIVATE -Wno-vla -Wno-unused-function -Wno-cast-function-type)
+    endif ()
 endif ()
 
 if (USEARCH_BUILD_BENCH_CPP)

package/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);
-
-// 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};
+#include <usearch/index.hpp>
+#include <usearch/index_dense.hpp>
 
-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:
@@ -89,6 +97,19 @@ Aside from the `executor_default_t`, you can take advantage of one of the provid
 - `executor_stl_t`, that will spawn `std::thread` instances.
 - `dummy_executor_t`, that will run everything sequentially.
 
+## Error Handling
+
+Unlike most open-source C++ libraries USearch doesn't use exceptions, as they often lead to corrupted states in concurrent data-structures.
+They are also not suited for systems that always operate on the edge of available memory, and would end up raising `std::bad_alloc` exceptions all the time.
+For that reason, most operations return a "result" object, that can be checked for success or failure.
+
+```cpp
+bool success;
+success = (bool)index.try_reserve(10); // Recommended over `reserve()`
+success = (bool)index.add(42, &vec[0]); // Explicitly convert `add_result_t`
+success = (bool)index.search(&vec[0], 5); // Explicitly convert `search_result_t`
+```
+
 ## Clustering
 
 Aside from basic Create-Read-Update-Delete (CRUD) operations and search, USearch also supports clustering.

package/cpp/bench.cpp

@@ -72,6 +72,8 @@ struct alignas(32) persisted_matrix_gt {
     std::uint32_t cols{};
     scalar_t const* scalars{};
 
+    persisted_matrix_gt() {}
+
     persisted_matrix_gt(char const* path) noexcept(false) {
         if (!path || !std::strlen(path))
             throw std::invalid_argument("The file path is empty");
@@ -133,6 +135,11 @@ struct alignas(32) persisted_matrix_gt {
     std::size_t size_bytes() const noexcept { return rows * row_size_bytes(); }
 };
 
+/**
+ *  @brief  A view of a large dataset in external memory, that may or may not contain
+ *          ground-truth queries and their optimal search results. In the second case,
+ *          self-recall is measured.
+ */
 template <typename scalar_at, typename vector_id_at> //
 struct persisted_dataset_gt {
     using scalar_t = scalar_at;
@@ -140,12 +147,21 @@ struct persisted_dataset_gt {
     persisted_matrix_gt<scalar_t> vectors_;
     persisted_matrix_gt<scalar_t> queries_;
     persisted_matrix_gt<compressed_slot_t> neighborhoods_;
+    std::vector<compressed_slot_t> neighborhoods_iota_{};
     std::size_t vectors_to_skip_{};
     std::size_t vectors_to_take_{};
 
+    persisted_dataset_gt(char const* path_vectors, std::size_t vectors_to_skip = 0,
+                         std::size_t vectors_to_take = 0) noexcept(false)
+        : vectors_(path_vectors), queries_(), neighborhoods_(), vectors_to_skip_(vectors_to_skip),
+          vectors_to_take_(vectors_to_take) {
+        neighborhoods_iota_.resize(vectors_.rows);
+        std::iota(neighborhoods_iota_.begin(), neighborhoods_iota_.end(), 0);
+    }
+
     persisted_dataset_gt(char const* path_vectors, char const* path_queries, char const* path_neighbors,
                          std::size_t vectors_to_skip = 0, std::size_t vectors_to_take = 0) noexcept(false)
-        : vectors_(path_vectors), queries_(path_queries), neighborhoods_(path_neighbors),
+        : vectors_(path_vectors), queries_(path_queries), neighborhoods_(path_neighbors), neighborhoods_iota_(),
           vectors_to_skip_(vectors_to_skip), vectors_to_take_(vectors_to_take) {
 
         if (vectors_.cols != queries_.cols)
@@ -154,13 +170,18 @@ struct persisted_dataset_gt {
             throw std::invalid_argument("Number of ground-truth neighborhoods doesn't match number of queries");
     }
 
+    bool search_itself() const noexcept { return vectors_count() && !queries_.rows; }
+
     std::size_t dimensions() const noexcept { return vectors_.cols; }
-    std::size_t queries_count() const noexcept { return queries_.rows; }
-    std::size_t neighborhood_size() const noexcept { return neighborhoods_.cols; }
+    std::size_t queries_count() const noexcept { return search_itself() ? vectors_count() : queries_.rows; }
+    std::size_t neighborhood_size() const noexcept { return search_itself() ? 1 : neighborhoods_.cols; }
     scalar_t const* vector(std::size_t i) const noexcept { return vectors_.row(i + vectors_to_skip_); }
-    scalar_t const* query(std::size_t i) const noexcept { return queries_.row(i); }
-    compressed_slot_t const* neighborhood(std::size_t i) const noexcept { return neighborhoods_.row(i); }
-
+    scalar_t const* query(std::size_t i) const noexcept {
+        return search_itself() ? vectors_view().at(i) : queries_.row(i);
+    }
+    compressed_slot_t const* neighborhood(std::size_t i) const noexcept {
+        return search_itself() ? neighborhoods_iota_.data() + i : neighborhoods_.row(i);
+    }
     std::size_t vectors_count() const noexcept {
         return vectors_to_take_ ? vectors_to_take_ : (vectors_.rows - vectors_to_skip_);
     }
@@ -238,6 +259,8 @@ struct running_stats_printer_t {
         print(new_progress, total);
     }
 
+    void print() { print(progress.load(), total); }
+
     void print(std::size_t progress, std::size_t total) {
 
         constexpr char bars_k[] = "||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||";
@@ -263,8 +286,8 @@ struct running_stats_printer_t {
     }
 };
 
-template <typename index_at, typename vector_id_at, typename real_at>
-void index_many(index_at& index, std::size_t n, vector_id_at const* ids, real_at const* vectors, std::size_t dims) {
+template <typename index_at, typename vector_id_at, typename scalar_at>
+void index_many(index_at& index, std::size_t n, vector_id_at const* ids, scalar_at const* vectors, std::size_t dims) {
 
     running_stats_printer_t printer{n, "Indexing"};
 
@@ -276,18 +299,21 @@ void index_many(index_at& index, std::size_t n, vector_id_at const* ids, real_at
 #if USEARCH_USE_OPENMP
         config.thread = omp_get_thread_num();
 #endif
-        float_span_t vector{vectors + dims * i, dims};
+        span_gt<scalar_at const> vector{vectors + dims * i, dims};
         index.add(ids[i], vector, config.thread);
         printer.progress++;
         if (config.thread == 0)
             printer.refresh();
     }
+
+    // Refresh once again to show 100% completion
+    printer.print();
 }
 
-template <typename index_at, typename vector_id_at, typename real_at>
+template <typename index_at, typename vector_id_at, typename scalar_at, typename distance_at>
 void search_many( //
-    index_at& index, std::size_t n, real_at const* vectors, std::size_t dims, std::size_t wanted, vector_id_at* ids,
-    real_at* distances) {
+    index_at& index, std::size_t n, scalar_at const* vectors, std::size_t dims, std::size_t wanted, vector_id_at* ids,
+    distance_at* distances) {
 
     std::string name = "Search " + std::to_string(wanted);
     running_stats_printer_t printer{n, name.c_str()};
@@ -300,12 +326,15 @@ void search_many( //
 #if USEARCH_USE_OPENMP
         config.thread = omp_get_thread_num();
 #endif
-        float_span_t vector{vectors + dims * i, dims};
+        span_gt<scalar_at const> vector{vectors + dims * i, dims};
         index.search(vector, wanted, config.thread).dump_to(ids + wanted * i, distances + wanted * i);
         printer.progress++;
         if (config.thread == 0)
             printer.refresh();
     }
+
+    // Refresh once again to show 100% completion
+    printer.print();
 }
 
 template <typename dataset_at, typename index_at> //
@@ -346,7 +375,7 @@ static void single_shot(dataset_at& dataset, index_at& index, bool construct = t
     std::size_t join_attempts = 0;
     {
         index_at& men = index;
-        index_at women = index.copy().index;
+        index_at women = index.copy();
         std::fill(man_to_woman.begin(), man_to_woman.end(), missing_key);
         std::fill(woman_to_man.begin(), woman_to_man.end(), missing_key);
         {
@@ -360,6 +389,8 @@ static void single_shot(dataset_at& dataset, index_at& index, bool construct = t
                         printer.print(progress, total);
                     return true;
                 });
+            // Refresh once again to show 100% completion
+            printer.print();
             join_attempts = result.visited_members;
         }
     }
@@ -499,7 +530,7 @@ void run_punned(dataset_at& dataset, args_t const& args, index_config_t config,
 
     std::printf("Will benchmark an on-disk view\n");
 
-    index_at index_view = index.fork().index;
+    index_at index_view = index.fork();
     index_view.view(args.path_output.c_str());
     single_shot(dataset, index_view, false);
 }
@@ -521,6 +552,44 @@ void run_typed(dataset_at& dataset, args_t const& args, index_config_t config, i
     single_shot(dataset, index_view, false);
 }
 
+template <typename dataset_scalar_at> void bench_with_args(args_t const& args) {
+    using dataset_t = persisted_dataset_gt<dataset_scalar_at, compressed_slot_t>;
+    dataset_t dataset = args.path_queries.empty() && args.path_neighbors.empty()
+                            ? dataset_t(args.path_vectors.c_str(), //
+                                        args.vectors_to_skip,      //
+                                        args.vectors_to_take       //
+                                        )
+                            : dataset_t(args.path_vectors.c_str(),   //
+                                        args.path_queries.c_str(),   //
+                                        args.path_neighbors.c_str(), //
+                                        args.vectors_to_skip,        //
+                                        args.vectors_to_take         //
+                              );
+    std::printf("-- Dimensions: %zu\n", dataset.dimensions());
+    std::printf("-- Vectors count: %zu\n", dataset.vectors_count());
+    std::printf("-- Queries count: %zu\n", dataset.queries_count());
+    std::printf("-- Neighbors per query: %zu\n", dataset.neighborhood_size());
+
+    index_dense_config_t config(args.connectivity, args.expansion_add, args.expansion_search);
+    index_limits_t limits;
+    limits.threads_add = limits.threads_search = args.threads;
+    limits.members = dataset.vectors_count();
+
+    std::printf("- Index: \n");
+    std::printf("-- Connectivity: %zu\n", config.connectivity);
+    std::printf("-- Expansion @ Add: %zu\n", config.expansion_add);
+    std::printf("-- Expansion @ Search: %zu\n", config.expansion_search);
+
+    if (args.big)
+#ifdef USEARCH_64BIT_ENV
+        run_punned<index_dense_gt<default_key_t, uint40_t>>(dataset, args, config, limits);
+#else
+        std::printf("Error: Don't use 40 bit identifiers in 32bit environment\n");
+#endif
+    else
+        run_punned<index_dense_gt<default_key_t, std::uint32_t>>(dataset, args, config, limits);
+}
+
 int main(int argc, char** argv) {
 
     // Print backtrace if something goes wrong.
@@ -530,8 +599,8 @@ int main(int argc, char** argv) {
 
     auto args = args_t{};
     auto cli = ( //
-        (option("--vectors") & value("path", args.path_vectors)).doc(".fbin file path to construct the index"),
-        (option("--queries") & value("path", args.path_queries)).doc(".fbin file path to query the index"),
+        (option("--vectors") & value("path", args.path_vectors)).doc(".[fhbd]bin file path to construct the index"),
+        (option("--queries") & value("path", args.path_queries)).doc(".[fhbd]bin file path to query the index"),
         (option("--neighbors") & value("path", args.path_neighbors)).doc(".ibin file path with ground truth"),
         (option("-o", "--output") & value("path", args.path_output)).doc(".usearch output file path"),
         (option("-b", "--big").set(args.big)).doc("Will switch to uint40_t for neighbors lists with over 4B entries"),
@@ -578,39 +647,22 @@ int main(int argc, char** argv) {
     std::printf("-- Query vectors path: %s\n", args.path_queries.c_str());
     std::printf("-- Ground truth neighbors path: %s\n", args.path_neighbors.c_str());
 
-    persisted_dataset_gt<float, compressed_slot_t> dataset{
-        args.path_vectors.c_str(),   //
-        args.path_queries.c_str(),   //
-        args.path_neighbors.c_str(), //
-        args.vectors_to_skip,        //
-        args.vectors_to_take,        //
+    auto ends_with = [](std::string_view stack, std::string_view needle) -> bool {
+        if (needle.empty())
+            return false;
+        return stack.find(needle, stack.size() - needle.size()) != std::string_view::npos;
     };
-    std::printf("-- Dimensions: %zu\n", dataset.dimensions());
-    std::printf("-- Vectors count: %zu\n", dataset.vectors_count());
-    std::printf("-- Queries count: %zu\n", dataset.queries_count());
-    std::printf("-- Neighbors per query: %zu\n", dataset.neighborhood_size());
-
-    // report_alternative_setups();
-    // report_expected_losses(dataset);
-
-    index_dense_config_t config(args.connectivity, args.expansion_add, args.expansion_search);
-    index_limits_t limits;
-    limits.threads_add = limits.threads_search = args.threads;
-    limits.members = dataset.vectors_count();
-
-    std::printf("- Index: \n");
-    std::printf("-- Connectivity: %zu\n", config.connectivity);
-    std::printf("-- Expansion @ Add: %zu\n", config.expansion_add);
-    std::printf("-- Expansion @ Search: %zu\n", config.expansion_search);
 
-    if (args.big)
-#ifdef USEARCH_64BIT_ENV
-        run_punned<index_dense_gt<default_key_t, uint40_t>>(dataset, args, config, limits);
-#else
-        std::printf("Error: Don't use 40 bit identifiers in 32bit environment\n");
-#endif
+    if (ends_with(args.path_vectors, ".fbin"))
+        bench_with_args<f32_t>(args);
+    else if (ends_with(args.path_vectors, ".dbin"))
+        bench_with_args<f64_t>(args);
+    else if (ends_with(args.path_vectors, ".hbin"))
+        bench_with_args<f16_t>(args);
+    else if (ends_with(args.path_vectors, ".bbin"))
+        bench_with_args<b1x8_t>(args);
     else
-        run_punned<index_dense_gt<default_key_t, std::uint32_t>>(dataset, args, config, limits);
+        throw std::runtime_error("Unknown input file path");
 
     return 0;
 }