usearch 0.20.0 → 0.22.0

package/c/lib.cpp

@@ -2,6 +2,10 @@
 
 #include <usearch/index_punned_dense.hpp>
 
+#ifndef USEARCH_EXPORT
+#define USEARCH_EXPORT
+#endif
+
 extern "C" {
 #include "usearch.h"
 }
@@ -88,7 +92,7 @@ index_punned_dense_metric_t udf(metric_kind_t kind, usearch_metric_t raw_ptr) {
 
 extern "C" {
 
-usearch_index_t usearch_init(usearch_init_options_t* options, usearch_error_t* error) {
+USEARCH_EXPORT usearch_index_t usearch_init(usearch_init_options_t* options, usearch_error_t* error) {
 
     assert(options && error);
 
@@ -108,48 +112,48 @@ usearch_index_t usearch_init(usearch_init_options_t* options, usearch_error_t* e
     return result_ptr;
 }
 
-void usearch_free(usearch_index_t index, usearch_error_t*) { delete reinterpret_cast<index_t*>(index); }
+USEARCH_EXPORT void usearch_free(usearch_index_t index, usearch_error_t*) { delete reinterpret_cast<index_t*>(index); }
 
-void usearch_save(usearch_index_t index, char const* path, usearch_error_t* error) {
+USEARCH_EXPORT void usearch_save(usearch_index_t index, char const* path, usearch_error_t* error) {
     serialization_result_t result = reinterpret_cast<index_t*>(index)->save(path);
     if (!result)
         *error = result.error.what();
 }
 
-void usearch_load(usearch_index_t index, char const* path, usearch_error_t* error) {
+USEARCH_EXPORT void usearch_load(usearch_index_t index, char const* path, usearch_error_t* error) {
     serialization_result_t result = reinterpret_cast<index_t*>(index)->load(path);
     if (!result)
         *error = result.error.what();
 }
 
-void usearch_view(usearch_index_t index, char const* path, usearch_error_t* error) {
+USEARCH_EXPORT void usearch_view(usearch_index_t index, char const* path, usearch_error_t* error) {
     serialization_result_t result = reinterpret_cast<index_t*>(index)->view(path);
     if (!result)
         *error = result.error.what();
 }
 
-size_t usearch_size(usearch_index_t index, usearch_error_t*) { //
+USEARCH_EXPORT size_t usearch_size(usearch_index_t index, usearch_error_t*) { //
     return reinterpret_cast<index_t*>(index)->size();
 }
 
-size_t usearch_capacity(usearch_index_t index, usearch_error_t*) {
+USEARCH_EXPORT size_t usearch_capacity(usearch_index_t index, usearch_error_t*) {
     return reinterpret_cast<index_t*>(index)->capacity();
 }
 
-size_t usearch_dimensions(usearch_index_t index, usearch_error_t*) {
+USEARCH_EXPORT size_t usearch_dimensions(usearch_index_t index, usearch_error_t*) {
     return reinterpret_cast<index_t*>(index)->dimensions();
 }
 
-size_t usearch_connectivity(usearch_index_t index, usearch_error_t*) {
+USEARCH_EXPORT size_t usearch_connectivity(usearch_index_t index, usearch_error_t*) {
     return reinterpret_cast<index_t*>(index)->connectivity();
 }
 
-void usearch_reserve(usearch_index_t index, size_t capacity, usearch_error_t*) {
+USEARCH_EXPORT void usearch_reserve(usearch_index_t index, size_t capacity, usearch_error_t*) {
     // TODO: Consider returning the new capacity.
     reinterpret_cast<index_t*>(index)->reserve(capacity);
 }
 
-void usearch_add(                                                                                 //
+USEARCH_EXPORT void usearch_add(                                                                          //
     usearch_index_t index, usearch_label_t label, void const* vector, usearch_scalar_kind_t kind, //
     usearch_error_t* error) {
     add_result_t result = add_(reinterpret_cast<index_t*>(index), label, vector, to_native_scalar(kind));
@@ -157,11 +161,11 @@ void usearch_add(
         *error = result.error.what();
 }
 
-bool usearch_contains(usearch_index_t index, usearch_label_t label, usearch_error_t*) {
+USEARCH_EXPORT bool usearch_contains(usearch_index_t index, usearch_label_t label, usearch_error_t*) {
     return reinterpret_cast<index_t*>(index)->contains(label);
 }
 
-size_t usearch_search(                                                                           //
+USEARCH_EXPORT size_t usearch_search(                                                                    //
     usearch_index_t index, void const* vector, usearch_scalar_kind_t kind, size_t results_limit, //
     usearch_label_t* found_labels, usearch_distance_t* found_distances, usearch_error_t* error) {
     search_result_t result = search_(reinterpret_cast<index_t*>(index), vector, to_native_scalar(kind), results_limit);
@@ -173,13 +177,13 @@ size_t usearch_search(
     return result.dump_to(found_labels, found_distances);
 }
 
-bool usearch_get(                                 //
+USEARCH_EXPORT bool usearch_get(                          //
     usearch_index_t index, usearch_label_t label, //
     void* vector, usearch_scalar_kind_t kind, usearch_error_t*) {
     return get_(reinterpret_cast<index_t*>(index), label, vector, to_native_scalar(kind));
 }
 
-void usearch_remove(usearch_index_t, usearch_label_t, usearch_error_t* error) {
+USEARCH_EXPORT void usearch_remove(usearch_index_t, usearch_label_t, usearch_error_t* error) {
     if (error != nullptr)
         *error = "USearch does not support removal of elements yet.";
 }

package/c/usearch.h

@@ -4,17 +4,20 @@
 #ifdef __cplusplus
 extern "C" {
 #endif
+#ifndef USEARCH_EXPORT
+#define USEARCH_EXPORT
+#endif
 #include <stdbool.h> // `bool`
 #include <stdint.h>  // `size_t`
 
-typedef void* usearch_index_t;
-typedef uint32_t usearch_label_t;
-typedef float usearch_distance_t;
-typedef char const* usearch_error_t;
+USEARCH_EXPORT typedef void* usearch_index_t;
+USEARCH_EXPORT typedef uint32_t usearch_label_t;
+USEARCH_EXPORT typedef float usearch_distance_t;
+USEARCH_EXPORT typedef char const* usearch_error_t;
 
-typedef usearch_distance_t (*usearch_metric_t)(void const*, void const*);
+USEARCH_EXPORT typedef usearch_distance_t (*usearch_metric_t)(void const*, void const*);
 
-typedef enum usearch_metric_kind_t {
+USEARCH_EXPORT typedef enum usearch_metric_kind_t {
     usearch_metric_ip_k = 0,
     usearch_metric_l2sq_k,
     usearch_metric_cos_k,
@@ -27,7 +30,7 @@ typedef enum usearch_metric_kind_t {
     usearch_metric_unknown_k,
 } usearch_metric_kind_t;
 
-typedef enum usearch_scalar_kind_t {
+USEARCH_EXPORT typedef enum usearch_scalar_kind_t {
     usearch_scalar_f32_k = 0,
     usearch_scalar_f64_k,
     usearch_scalar_f16_k,
@@ -36,7 +39,7 @@ typedef enum usearch_scalar_kind_t {
     usearch_scalar_unknown_k,
 } usearch_scalar_kind_t;
 
-typedef struct usearch_init_options_t {
+USEARCH_EXPORT typedef struct usearch_init_options_t {
 
     usearch_metric_kind_t metric_kind;
     usearch_metric_t metric;
@@ -48,39 +51,39 @@ typedef struct usearch_init_options_t {
     size_t expansion_search;
 } usearch_init_options_t;
 
-usearch_index_t usearch_init(usearch_init_options_t*, usearch_error_t*);
-void usearch_free(usearch_index_t, usearch_error_t*);
+USEARCH_EXPORT usearch_index_t usearch_init(usearch_init_options_t*, usearch_error_t*);
+USEARCH_EXPORT void usearch_free(usearch_index_t, usearch_error_t*);
 
-void usearch_save(usearch_index_t, char const* path, usearch_error_t*);
-void usearch_load(usearch_index_t, char const* path, usearch_error_t*);
-void usearch_view(usearch_index_t, char const* path, usearch_error_t*);
+USEARCH_EXPORT void usearch_save(usearch_index_t, char const* path, usearch_error_t*);
+USEARCH_EXPORT void usearch_load(usearch_index_t, char const* path, usearch_error_t*);
+USEARCH_EXPORT void usearch_view(usearch_index_t, char const* path, usearch_error_t*);
 
-size_t usearch_size(usearch_index_t, usearch_error_t*);
-size_t usearch_capacity(usearch_index_t, usearch_error_t*);
-size_t usearch_dimensions(usearch_index_t, usearch_error_t*);
-size_t usearch_connectivity(usearch_index_t, usearch_error_t*);
+USEARCH_EXPORT size_t usearch_size(usearch_index_t, usearch_error_t*);
+USEARCH_EXPORT size_t usearch_capacity(usearch_index_t, usearch_error_t*);
+USEARCH_EXPORT size_t usearch_dimensions(usearch_index_t, usearch_error_t*);
+USEARCH_EXPORT size_t usearch_connectivity(usearch_index_t, usearch_error_t*);
 
-void usearch_reserve(usearch_index_t, size_t capacity, usearch_error_t*);
+USEARCH_EXPORT void usearch_reserve(usearch_index_t, size_t capacity, usearch_error_t*);
 
-void usearch_add(                                                                            //
+USEARCH_EXPORT void usearch_add(                                                                     //
     usearch_index_t, usearch_label_t, void const* vector, usearch_scalar_kind_t vector_kind, //
     usearch_error_t*);
 
-bool usearch_contains(usearch_index_t, usearch_label_t, usearch_error_t*);
+USEARCH_EXPORT bool usearch_contains(usearch_index_t, usearch_label_t, usearch_error_t*);
 
 /**
  *  @brief      Performs k-Approximate Nearest Neighbors Search.
  *  @return     Number of found matches.
  */
-size_t usearch_search(                                                                                 //
+USEARCH_EXPORT size_t usearch_search(                                                                          //
     usearch_index_t, void const* query_vector, usearch_scalar_kind_t query_kind, size_t results_limit, //
     usearch_label_t* found_labels, usearch_distance_t* found_distances, usearch_error_t*);
 
-bool usearch_get(                     //
+USEARCH_EXPORT bool usearch_get(              //
     usearch_index_t, usearch_label_t, //
     void* vector, usearch_scalar_kind_t vector_kind, usearch_error_t*);
 
-void usearch_remove(usearch_index_t, usearch_label_t, usearch_error_t*);
+USEARCH_EXPORT void usearch_remove(usearch_index_t, usearch_label_t, usearch_error_t*);
 
 #ifdef __cplusplus
 }

package/cmake/emscripten.cmake

@@ -0,0 +1,8 @@
+include(FetchContent)
+FetchContent_Declare(
+    emscripten
+    GIT_REPOSITORY https://github.com/emscripten-core/emscripten
+    GIT_TAG main
+)
+FetchContent_MakeAvailable(emscripten)
+include_directories(${emscripten_SOURCE_DIR}/include)

package/conanfile.py

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

package/cpp/CMakeLists.txt

@@ -13,7 +13,9 @@ endif()
 # https://cmake.org/cmake/help/latest/variable/CMAKE_LANG_COMPILER_ID.html
 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
-    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize=address")
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g")
+    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -O3 -g")
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize=address -fsanitize=leak -fsanitize=alignment -fsanitize=undefined")
     set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wall -Wextra -Wno-conversion -Wno-unknown-pragmas")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fmax-errors=1")
@@ -22,7 +24,9 @@ if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
 
 elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
     set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
-    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize=address")
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g")
+    set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -O3 -g")
+    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fsanitize=address -fsanitize=leak -fsanitize=alignment -fsanitize=undefined")
     set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Wfatal-errors")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fopenmp")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic")

package/cpp/README.md

@@ -0,0 +1,88 @@
+# USearch C++ Inteface
+
+## Installation
+
+To use in a C++ project simply copy the `include/usearch/index.hpp` header into your project.
+Alternatively fetch it with CMake:
+
+```cmake
+FetchContent_Declare(usearch GIT_REPOSITORY https://github.com/unum-cloud/usearch.git)
+FetchContent_MakeAvailable(usearch)
+```
+
+## Quickstart
+
+Once included, the low-level C++11 interface is as simple as it gets: `reserve()`, `add()`, `search()`, `size()`, `capacity()`, `save()`, `load()`, `view()`.
+This covers 90% of use-cases.
+
+```c++
+using namespace unum::usearch;
+
+index_gt<cos_gt<float>> index;
+float vec[3] = {0.1, 0.3, 0.2};
+
+index.reserve(10);
+index.add(/* label: */ 42, /* vector: */ {&vec[0], 3});
+auto results = index.search(/* query: */ {&vec[0], 3}, 5 /* neighbors */);
+
+for (std::size_t i = 0; i != results.size(); ++i)
+    results[i].element.label, results[i].element.vector, results[i].distance;
+```
+
+The `add` is thread-safe for concurrent index construction.
+
+## Serialization
+
+```c++
+index.save("index.usearch");
+index.load("index.usearch"); // Copying from disk
+index.view("index.usearch"); // Memory-mapping from disk
+```
+
+## User-Defined Metrics in C++
+
+For advanced users, more compile-time abstractions are available.
+
+```cpp
+template <typename metric_at = ip_gt<float>,            //
+          typename label_at = std::size_t,              // `uint32_t`, `uuid_t`...
+          typename id_at = std::uint32_t,               // `uint40_t`, `uint64_t`...
+          typename scalar_at = float,                   // `double`, `half`, `char`...
+          typename allocator_at = std::allocator<char>> //
+class index_gt;
+```
+
+You may want to use a custom memory allocator or a rare scalar type, but most often, you would start by defining a custom similarity measure.
+The function object should have the following signature to support different-length vectors.
+
+```cpp
+struct custom_metric_t {
+    T operator()(T const* a, T const* b, std::size_t a_length, std::size_t b_length) const;
+};
+```
+
+The following distances are pre-packaged:
+
+- `cos_gt<scalar_t>` for "Cosine" or "Angular" distance.
+- `ip_gt<scalar_t>` for "Inner Product" or "Dot Product" distance.
+- `l2sq_gt<scalar_t>` for the squared "L2" or "Euclidean" distance.
+- `jaccard_gt<scalar_t>` for "Jaccard" distance between two ordered sets of unique elements.
+- `hamming_gt<scalar_t>` for "Hamming" distance, as the number of shared bits in hashes.
+- `tanimoto_gt<scalar_t>` for "Tanimoto" coefficient for bit-strings.
+- `sorensen_gt<scalar_t>` for "Dice-Sorensen" coefficient for bit-strings.
+- `pearson_correlation_gt<scalar_t>` for "Pearson" correlation between probability distributions.
+- `haversine_gt<scalar_t>` for "Haversine" or "Great Circle" distance between coordinates used in GIS applications.
+
+## Multi-Threading
+
+Most AI, HPC, or Big Data packages use some form of a thread pool.
+Instead of spawning additional threads within USearch, we focus on the thread safety of `add()` function, simplifying resource management.
+
+```cpp
+#pragma omp parallel for
+    for (std::size_t i = 0; i < n; ++i)
+        native.add(label, span_t{vector, dims}, add_config_t { .thread = omp_get_thread_num() });
+```
+
+During initialization, we allocate enough temporary memory for all the cores on the machine.
+On the call, the user can supply the identifier of the current thread, making this library easy to integrate with OpenMP and similar tools.

package/cpp/bench.cpp

@@ -15,7 +15,9 @@
 
 #define STDERR_FILENO HANDLE(2)
 #else
-#include <execinfo.h>
+#if defined(__linux__)
+#include <execinfo.h> // `backtrace`
+#endif
 #include <fcntl.h>    // `open`
 #include <stdlib.h>   // `getenv`
 #include <sys/mman.h> // `mmap`
@@ -24,6 +26,7 @@
 
 #include <sys/stat.h> // `stat`
 
+#include <algorithm>
 #include <csignal>
 #include <cstdio>
 #include <iostream>  // `std::cerr`
@@ -32,9 +35,12 @@
 #include <string>    // `std::to_string`
 #include <thread>    // `std::thread::hardware_concurrency()`
 #include <variant>   // `std::monostate`
+#include <vector>
 
 #include <clipp.h> // Command Line Interface
-#include <omp.h>   // `omp_set_num_threads()`
+#if USEARCH_USE_OPENMP
+#include <omp.h> // `omp_set_num_threads()`
+#endif
 
 #include <simsimd/simsimd.h>
 
@@ -43,6 +49,7 @@
 using namespace unum::usearch;
 using namespace unum;
 
+using label_t = std::int64_t;
 using vector_id_t = std::uint32_t;
 using vector_view_t = span_gt<float const>;
 
@@ -243,10 +250,10 @@ struct running_stats_printer_t {
         std::size_t new_progress = progress.load();
         if (new_progress - last_printed_progress < step)
             return;
-        print(new_progress);
+        print(new_progress, total);
     }
 
-    void print(std::size_t progress) {
+    void print(std::size_t progress, std::size_t total) {
 
         constexpr char bars_k[] = "||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||";
         constexpr std::size_t bars_len_k = 60;
@@ -267,6 +274,7 @@ struct running_stats_printer_t {
 
         last_printed_progress = progress;
         last_printed_time = time_new;
+        this->total = total;
     }
 };
 
@@ -275,15 +283,19 @@ void index_many(index_at& native, std::size_t n, vector_id_at const* ids, real_a
 
     running_stats_printer_t printer{n, "Indexing"};
 
+#if USEARCH_USE_OPENMP
 #pragma omp parallel for schedule(static, 32)
+#endif
     for (std::size_t i = 0; i < n; ++i) {
         add_config_t config;
+#if USEARCH_USE_OPENMP
         config.thread = omp_get_thread_num();
+#endif
         config.store_vector = true;
         vector_view_t vector{vectors + dims * i, dims};
         native.add(ids[i], vector, config);
         printer.progress++;
-        if (omp_get_thread_num() == 0)
+        if (config.thread == 0)
             printer.refresh();
     }
 }
@@ -296,34 +308,18 @@ void search_many( //
     std::string name = "Search " + std::to_string(wanted);
     running_stats_printer_t printer{n, name.c_str()};
 
+#if USEARCH_USE_OPENMP
 #pragma omp parallel for schedule(static, 32)
+#endif
     for (std::size_t i = 0; i < n; ++i) {
         search_config_t config;
+#if USEARCH_USE_OPENMP
         config.thread = omp_get_thread_num();
+#endif
         vector_view_t vector{vectors + dims * i, dims};
         native.search(vector, wanted, config).dump_to(ids + wanted * i, distances + wanted * i);
         printer.progress++;
-        if (omp_get_thread_num() == 0)
-            printer.refresh();
-    }
-}
-
-template <typename index_at, typename vector_id_at, typename real_at>
-void paginate_many( //
-    index_at& native, std::size_t n, real_at const* vectors, std::size_t dims, std::size_t wanted,
-    vector_id_at const* hints) {
-
-    std::string name = "Paginate " + std::to_string(wanted);
-    running_stats_printer_t printer{n, name.c_str()};
-
-#pragma omp parallel for schedule(static, 32)
-    for (std::size_t i = 0; i < n; ++i) {
-        search_config_t config;
-        config.thread = omp_get_thread_num();
-        vector_view_t vector{vectors + dims * i, dims};
-        native.search_around(hints[i], vector, wanted, config);
-        printer.progress++;
-        if (omp_get_thread_num() == 0)
+        if (config.thread == 0)
             printer.refresh();
     }
 }
@@ -332,6 +328,8 @@ template <typename dataset_at, typename index_at> //
 static void single_shot(dataset_at& dataset, index_at& index, bool construct = true) {
     using label_t = typename index_at::label_t;
     using distance_t = typename index_at::distance_t;
+    using join_result_t = typename index_at::join_result_t;
+    constexpr std::size_t missing_label = std::numeric_limits<label_t>::max();
 
     std::printf("\n");
     std::printf("------------\n");
@@ -348,7 +346,7 @@ static void single_shot(dataset_at& dataset, index_at& index, bool construct = t
     search_many(index, dataset.queries_count(), dataset.query(0), dataset.dimensions(), dataset.neighborhood_size(),
                 found_neighbors.data(), found_distances.data());
 
-    // Evaluate quality
+    // Evaluate search quality
     std::size_t recall_at_1 = 0, recall_full = 0;
     for (std::size_t i = 0; i != dataset.queries_count(); ++i) {
         auto expected = dataset.neighborhood(i);
@@ -360,13 +358,37 @@ static void single_shot(dataset_at& dataset, index_at& index, bool construct = t
     std::printf("Recall@1 %.2f %%\n", recall_at_1 * 100.f / dataset.queries_count());
     std::printf("Recall %.2f %%\n", recall_full * 100.f / dataset.queries_count());
 
-    // Paginate
-    std::vector<vector_id_t> hints(dataset.queries_count());
-    for (std::size_t i = 0; i != hints.size(); ++i)
-        hints[i] = dataset.neighborhood(i)[0];
-    paginate_many(index, dataset.queries_count(), dataset.query(0), dataset.dimensions(), 10, hints.data());
-    paginate_many(index, dataset.queries_count(), dataset.query(0), dataset.dimensions(), 100, hints.data());
-    paginate_many(index, dataset.queries_count(), dataset.query(0), dataset.dimensions(), 1000, hints.data());
+    // Perform joins
+    std::vector<label_t> man_to_woman(dataset.vectors_count());
+    std::vector<label_t> woman_to_man(dataset.vectors_count());
+    std::size_t join_attempts = 0;
+    {
+        index_at& men = index;
+        index_at women = index.copy().index;
+        std::fill(man_to_woman.begin(), man_to_woman.end(), missing_label);
+        std::fill(woman_to_man.begin(), woman_to_man.end(), missing_label);
+        {
+            executor_default_t executor(index.limits().threads());
+            running_stats_printer_t printer{1, "Join"};
+            join_result_t result = index_at::join(          //
+                men, women, join_config_t{executor.size()}, //
+                man_to_woman.data(), woman_to_man.data(),   //
+                executor, [&](std::size_t progress, std::size_t total) {
+                    if (progress % 1000 == 0)
+                        printer.print(progress, total);
+                });
+            join_attempts = result.cycles;
+        }
+    }
+    // Evaluate join quality
+    std::size_t recall_join = 0, unmatched_count = 0;
+    for (std::size_t i = 0; i != index.size(); ++i) {
+        recall_join += man_to_woman[i] == i;
+        unmatched_count += man_to_woman[i] == missing_label;
+    }
+    std::printf("Recall Joins %.2f %%\n", recall_join * 100.f / index.size());
+    std::printf("Unmatched %.2f %% (%zu items)\n", unmatched_count * 100.f / index.size(), unmatched_count);
+    std::printf("Proposals %.2f / man (%zu total)\n", join_attempts * 1.f / index.size(), join_attempts);
 
     std::printf("------------\n");
     std::printf("\n");
@@ -379,7 +401,7 @@ void handler(int sig) {
     // get void*'s for all entries on the stack
 #if defined(USEARCH_DEFINED_WINDOWS)
     size = CaptureStackBackTrace(0, 10, array, NULL);
-#else
+#elif defined(USEARCH_DEFINED_LINUX)
     size = backtrace(array, 10);
 #endif // WINDOWS
 
@@ -401,7 +423,7 @@ void handler(int sig) {
         WriteFile(STDERR_FILENO, "\n", 1, &bytes_written, NULL);
     }
     free(symbol);
-#else
+#elif defined(USEARCH_DEFINED_LINUX)
     backtrace_symbols_fd(array, size, STDERR_FILENO);
 #endif // WINDOWS
 
@@ -491,7 +513,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_at index_view = index.fork().index;
     index_view.view(args.path_output.c_str());
     single_shot(dataset, index_view, false);
 }
@@ -518,24 +540,24 @@ void run_big_or_small(dataset_at& dataset, args_t const& args, index_config_t co
     if (args.native) {
         if (args.metric_cos) {
             std::printf("-- Metric: Angular\n");
-            run_typed<index_gt<cos_gt<float>, std::size_t, neighbor_id_at>>(dataset, args, config, limits);
+            run_typed<index_gt<cos_gt<float>, label_t, neighbor_id_at>>(dataset, args, config, limits);
         } else if (args.metric_l2) {
             std::printf("-- Metric: Euclidean\n");
-            run_typed<index_gt<l2sq_gt<float>, std::size_t, neighbor_id_at>>(dataset, args, config, limits);
+            run_typed<index_gt<l2sq_gt<float>, label_t, neighbor_id_at>>(dataset, args, config, limits);
         } else if (args.metric_haversine) {
             std::printf("-- Metric: Haversine\n");
-            run_typed<index_gt<haversine_gt<float>, std::size_t, neighbor_id_at>>(dataset, args, config, limits);
+            run_typed<index_gt<haversine_gt<float>, label_t, neighbor_id_at>>(dataset, args, config, limits);
         } else {
             std::printf("-- Metric: Inner Product\n");
-            run_typed<index_gt<ip_gt<float>, std::size_t, neighbor_id_at>>(dataset, args, config, limits);
+            run_typed<index_gt<ip_gt<float>, label_t, neighbor_id_at>>(dataset, args, config, limits);
         }
     } else
-        run_punned<index_punned_dense_gt<std::size_t, neighbor_id_at>>(dataset, args, config, limits);
+        run_punned<index_punned_dense_gt<label_t, neighbor_id_at>>(dataset, args, config, limits);
 }
 
 void report_alternative_setups() {
     using set_member_t = std::uint32_t;
-    using sets_index_t = index_gt<jaccard_gt<set_member_t>, std::size_t, std::uint32_t>;
+    using sets_index_t = index_gt<jaccard_gt<set_member_t>, label_t, std::uint32_t>;
     set_member_t set_a[] = {10, 12, 15};
     set_member_t set_b[] = {11, 12, 15, 16};
     sets_index_t index;
@@ -625,12 +647,14 @@ int main(int argc, char** argv) {
         exit(0);
     }
 
+#if USEARCH_USE_OPENMP
     // Instead of relying on `multithreaded` from "index_punned_dense.hpp" we will use OpenMP
     // to better estimate statistics between tasks batches, without having to recreate
     // the threads.
     omp_set_dynamic(true);
     omp_set_num_threads(args.threads);
     std::printf("- OpenMP threads: %d\n", omp_get_max_threads());
+#endif
 
     std::printf("- Dataset: \n");
     std::printf("-- Base vectors path: %s\n", args.path_vectors.c_str());
@@ -658,7 +682,7 @@ int main(int argc, char** argv) {
     // config.expansion_search = args.expansion_search;
     index_limits_t limits;
     limits.threads_add = limits.threads_search = args.threads;
-    limits.elements = dataset.vectors_count();
+    limits.members = dataset.vectors_count();
 
     std::printf("- Index: \n");
     std::printf("-- Connectivity: %zu\n", config.connectivity);
@@ -666,7 +690,11 @@ int main(int argc, char** argv) {
     // std::printf("-- Expansion @ Search: %zu\n", config.expansion_search);
 
     if (args.big)
+#ifdef USEARCH_64BIT_ENV
         run_big_or_small<uint40_t>(dataset, args, config, limits);
+#else
+        std::printf("Error: Don't use 40 bit identifiers in 32bit environment\n");
+#endif
     else
         run_big_or_small<std::uint32_t>(dataset, args, config, limits);
 

package/cpp/test.cpp

@@ -84,17 +84,23 @@ template <typename scalar_at, typename index_at> void test3d_punned(index_at&& i
     using view_t = span_gt<scalar_t const>;
     using span_t = span_gt<scalar_at>;
 
-    scalar_t vec[3] = {10, 20, 15};
+    scalar_t vec42[3] = {10, 20, 15};
+    scalar_t vec43[3] = {19, 22, 11};
 
     index.reserve(10);
-    index.add(42, view_t{&vec[0], 3ul});
+    index.add(42, view_t{&vec42[0], 3ul});
 
     // Reconstruct
-    scalar_t vec_reconstructed[3] = {0, 0, 0};
-    index.get(42, span_t{&vec_reconstructed[0], 3ul});
-    expect(vec_reconstructed[0] == vec[0]);
-    expect(vec_reconstructed[1] == vec[1]);
-    expect(vec_reconstructed[2] == vec[2]);
+    scalar_t vec42_reconstructed[3] = {0, 0, 0};
+    index.get(42, span_t{&vec42_reconstructed[0], 3ul});
+    expect(vec42_reconstructed[0] == vec42[0]);
+    expect(vec42_reconstructed[1] == vec42[1]);
+    expect(vec42_reconstructed[2] == vec42[2]);
+
+    index.add(43, view_t{&vec43[0], 3ul});
+    expect(index.size() == 2);
+    index.remove(43);
+    expect(index.size() == 1);
 }
 
 template <typename index_at> void test_sets(index_at&& index) {