usearch 0.11.1 → 0.12.0

package/src/bench.cpp

@@ -252,8 +252,8 @@ struct running_stats_printer_t {
         constexpr std::size_t bars_len_k = 60;
 
         float percentage = progress * 1.f / total;
-        int lpad = (int)(percentage * bars_len_k);
-        int rpad = bars_len_k - lpad;
+        int left_pad = (int)(percentage * bars_len_k);
+        int right_pad = bars_len_k - left_pad;
 
         std::size_t count_new = progress - last_printed_progress;
         timestamp_t time_new = std::chrono::high_resolution_clock::now();
@@ -261,8 +261,8 @@ struct running_stats_printer_t {
             std::chrono::duration_cast<std::chrono::nanoseconds>(time_new - last_printed_time).count();
         float vectors_per_second = count_new * 1e9 / duration;
 
-        std::printf("\r%3.3f%% [%.*s%*s] %.0f vectors/s, finished %zu/%zu", percentage * 100.f, lpad, bars_k, rpad, "",
-                    vectors_per_second, progress, total);
+        std::printf("\r%3.3f%% [%.*s%*s] %.0f vectors/s, finished %zu/%zu", percentage * 100.f, left_pad, bars_k,
+                    right_pad, "", vectors_per_second, progress, total);
         std::fflush(stdout);
 
         last_printed_progress = progress;
@@ -442,7 +442,7 @@ struct args_t {
 };
 
 template <typename index_at, typename dataset_at> //
-index_at type_punned_index_for_metric(dataset_at& dataset, args_t const& args, config_t config, accuracy_t accuracy) {
+index_at punned_index_for_metric(dataset_at& dataset, args_t const& args, index_config_t config, accuracy_t accuracy) {
     if (args.metric_l2) {
         std::printf("-- Metric: Euclidean\n");
         return index_at::l2sq(dataset.dimensions(), accuracy, config);
@@ -459,7 +459,7 @@ index_at type_punned_index_for_metric(dataset_at& dataset, args_t const& args, c
 }
 
 template <typename index_at, typename dataset_at> //
-void run_type_punned(dataset_at& dataset, args_t const& args, config_t config) {
+void run_punned(dataset_at& dataset, args_t const& args, index_config_t config, index_limits_t limits) {
 
     accuracy_t accuracy = accuracy_t::f32_k;
     if (args.quantize_f16)
@@ -469,7 +469,8 @@ void run_type_punned(dataset_at& dataset, args_t const& args, config_t config) {
 
     std::printf("-- Accuracy: %s\n", accuracy_name(accuracy));
 
-    index_at index{type_punned_index_for_metric<index_at>(dataset, args, config, accuracy)};
+    index_at index{punned_index_for_metric<index_at>(dataset, args, config, accuracy)};
+    index.reserve(limits);
     std::printf("-- Hardware acceleration: %s\n", isa_name(index.acceleration()));
     std::printf("Will benchmark in-memory\n");
 
@@ -484,9 +485,10 @@ void run_type_punned(dataset_at& dataset, args_t const& args, config_t config) {
 }
 
 template <typename index_at, typename dataset_at> //
-void run_typed(dataset_at& dataset, args_t const& args, config_t config) {
+void run_typed(dataset_at& dataset, args_t const& args, index_config_t config, index_limits_t limits) {
 
     index_at index(config);
+    index.reserve(limits);
     std::printf("Will benchmark in-memory\n");
 
     single_shot(dataset, index, true);
@@ -500,23 +502,23 @@ void run_typed(dataset_at& dataset, args_t const& args, config_t config) {
 }
 
 template <typename neighbor_id_at, typename dataset_at> //
-void run_big_or_small(dataset_at& dataset, args_t const& args, config_t config) {
+void run_big_or_small(dataset_at& dataset, args_t const& args, index_config_t config, index_limits_t limits) {
     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);
+            run_typed<index_gt<cos_gt<float>, std::size_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);
+            run_typed<index_gt<l2sq_gt<float>, std::size_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);
+            run_typed<index_gt<haversine_gt<float>, std::size_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);
+            run_typed<index_gt<ip_gt<float>, std::size_t, neighbor_id_at>>(dataset, args, config, limits);
         }
     } else
-        run_type_punned<punned_gt<std::size_t, neighbor_id_at>>(dataset, args, config);
+        run_punned<punned_gt<std::size_t, neighbor_id_at>>(dataset, args, config, limits);
 }
 
 void report_alternative_setups() {
@@ -634,12 +636,13 @@ int main(int argc, char** argv) {
     // report_alternative_setups();
     // report_expected_losses(dataset);
 
-    config_t config;
+    index_config_t config;
     config.connectivity = args.connectivity;
     config.expansion_add = args.expansion_add;
     config.expansion_search = args.expansion_search;
-    config.max_threads_add = config.max_threads_search = args.threads;
-    config.max_elements = dataset.vectors_count();
+    index_limits_t limits;
+    limits.threads_add = limits.threads_search = args.threads;
+    limits.elements = dataset.vectors_count();
 
     std::printf("- Index: \n");
     std::printf("-- Connectivity: %zu\n", config.connectivity);
@@ -647,9 +650,9 @@ int main(int argc, char** argv) {
     std::printf("-- Expansion @ Search: %zu\n", config.expansion_search);
 
     if (args.big)
-        run_big_or_small<uint40_t>(dataset, args, config);
+        run_big_or_small<uint40_t>(dataset, args, config, limits);
     else
-        run_big_or_small<std::uint32_t>(dataset, args, config);
+        run_big_or_small<std::uint32_t>(dataset, args, config, limits);
 
     return 0;
 }

package/src/punned.hpp

@@ -1,6 +1,7 @@
 #pragma once
 #include <stdlib.h> // `aligned_alloc`
 
+#include <cstring>      // `std::strncmp`
 #include <functional>   // `std::function`
 #include <numeric>      // `std::iota`
 #include <shared_mutex> // `std::shared_mutex`
@@ -37,7 +38,7 @@ using punned_distance_t = float;
 using punned_metric_t = punned_distance_t (*)(byte_t const*, byte_t const*, std::size_t, std::size_t);
 
 template <typename metric_at>
-punned_distance_t punned_metric(byte_t const* a, byte_t const* b, std::size_t a_bytes, std::size_t b_bytes) {
+inline punned_distance_t punned_metric(byte_t const* a, byte_t const* b, std::size_t a_bytes, std::size_t b_bytes) {
     using scalar_t = typename metric_at::scalar_t;
     return metric_at{}((scalar_t const*)a, (scalar_t const*)b, a_bytes / sizeof(scalar_t), b_bytes / sizeof(scalar_t));
 }
@@ -168,7 +169,7 @@ class f8_bits_t {
 inline f16_bits_t::f16_bits_t(f8_bits_t v) : f16_bits_t(float(v)) {}
 
 struct cos_f8_t {
-    punned_distance_t operator()(f8_bits_t const* a, f8_bits_t const* b, std::size_t n) const {
+    inline punned_distance_t operator()(f8_bits_t const* a, f8_bits_t const* b, std::size_t n) const {
         std::int32_t ab{}, a2{}, b2{};
         for (std::size_t i = 0; i != n; i++) {
             std::int16_t ai{a[i]};
@@ -182,7 +183,7 @@ struct cos_f8_t {
 };
 
 struct l2sq_f8_t {
-    punned_distance_t operator()(f8_bits_t const* a, f8_bits_t const* b, std::size_t n) const {
+    inline punned_distance_t operator()(f8_bits_t const* a, f8_bits_t const* b, std::size_t n) const {
         std::int32_t ab_deltas_sq{};
         for (std::size_t i = 0; i != n; i++)
             ab_deltas_sq += square(std::int16_t(a[i]) - std::int16_t(b[i]));
@@ -268,48 +269,77 @@ inline char const* accuracy_name(accuracy_t accuracy) {
 }
 
 inline bool str_equals(char const* begin, std::size_t len, char const* other_begin) {
-    std::size_t other_len = strlen(other_begin);
-    return len == other_len && strncmp(begin, other_begin, len) == 0;
+    std::size_t other_len = std::strlen(other_begin);
+    return len == other_len && std::strncmp(begin, other_begin, len) == 0;
 }
 
-inline accuracy_t accuracy_from_name(char const* name, std::size_t len) {
-    accuracy_t accuracy;
+inline expected_gt<accuracy_t> accuracy_from_name(char const* name, std::size_t len) {
+    expected_gt<accuracy_t> parsed;
     if (str_equals(name, len, "f32"))
-        accuracy = accuracy_t::f32_k;
+        parsed.result = accuracy_t::f32_k;
     else if (str_equals(name, len, "f64"))
-        accuracy = accuracy_t::f64_k;
+        parsed.result = accuracy_t::f64_k;
     else if (str_equals(name, len, "f16"))
-        accuracy = accuracy_t::f16_k;
+        parsed.result = accuracy_t::f16_k;
     else if (str_equals(name, len, "f8"))
-        accuracy = accuracy_t::f8_k;
+        parsed.result = accuracy_t::f8_k;
     else
-        throw std::invalid_argument("Unknown type, choose: f32, f16, f64, f8");
-    return accuracy;
+        parsed.failed("Unknown type, choose: f32, f16, f64, f8");
+    return parsed;
+}
+
+inline expected_gt<common_metric_kind_t> common_metric_from_name(char const* name, std::size_t len) {
+    expected_gt<common_metric_kind_t> parsed;
+    if (str_equals(name, len, "l2sq") || str_equals(name, len, "euclidean_sq")) {
+        parsed.result = common_metric_kind_t::l2sq_k;
+    } else if (str_equals(name, len, "ip") || str_equals(name, len, "inner") || str_equals(name, len, "dot")) {
+        parsed.result = common_metric_kind_t::ip_k;
+    } else if (str_equals(name, len, "cos") || str_equals(name, len, "angular")) {
+        parsed.result = common_metric_kind_t::cos_k;
+    } else if (str_equals(name, len, "haversine")) {
+        parsed.result = common_metric_kind_t::haversine_k;
+    } else if (str_equals(name, len, "pearson")) {
+        parsed.result = common_metric_kind_t::pearson_k;
+    } else if (str_equals(name, len, "hamming")) {
+        parsed.result = common_metric_kind_t::bitwise_hamming_k;
+    } else if (str_equals(name, len, "tanimoto")) {
+        parsed.result = common_metric_kind_t::bitwise_tanimoto_k;
+    } else if (str_equals(name, len, "sorensen")) {
+        parsed.result = common_metric_kind_t::bitwise_sorensen_k;
+    } else
+        parsed.failed(
+            "Unknown distance, choose: l2sq, ip, cos, haversine, jaccard, pearson, hamming, tanimoto, sorensen");
+    return parsed;
 }
 
 template <typename index_at>
-inline index_at index_from_name( //
-    char const* name, std::size_t len, std::size_t dimensions, accuracy_t accuracy, config_t const& config) {
+expected_gt<index_at> make_punned( //
+    common_metric_kind_t metric, std::size_t dimensions, accuracy_t accuracy, index_config_t const& config) {
 
-    if (str_equals(name, len, "l2sq") || str_equals(name, len, "euclidean_sq")) {
+    expected_gt<index_at> parsed;
+    if (metric == common_metric_kind_t::l2sq_k) {
         if (dimensions == 0)
-            throw std::invalid_argument("The number of dimensions must be positive");
-        return index_at::l2sq(dimensions, accuracy, config);
-    } else if (str_equals(name, len, "ip") || str_equals(name, len, "inner") || str_equals(name, len, "dot")) {
+            parsed.failed("The number of dimensions must be positive");
+        else
+            parsed.result = index_at::l2sq(dimensions, accuracy, config);
+    } else if (metric == common_metric_kind_t::ip_k) {
         if (dimensions == 0)
-            throw std::invalid_argument("The number of dimensions must be positive");
-        return index_at::ip(dimensions, accuracy, config);
-    } else if (str_equals(name, len, "cos") || str_equals(name, len, "angular")) {
+            parsed.failed("The number of dimensions must be positive");
+        else
+            parsed.result = index_at::ip(dimensions, accuracy, config);
+    } else if (metric == common_metric_kind_t::cos_k) {
         if (dimensions == 0)
-            throw std::invalid_argument("The number of dimensions must be positive");
-        return index_at::cos(dimensions, accuracy, config);
-    } else if (str_equals(name, len, "haversine")) {
+            parsed.failed("The number of dimensions must be positive");
+        else
+            parsed.result = index_at::cos(dimensions, accuracy, config);
+    } else if (metric == common_metric_kind_t::haversine_k) {
         if (dimensions != 2 && dimensions != 0)
-            throw std::invalid_argument("The number of dimensions must be equal to two");
-        return index_at::haversine(accuracy, config);
+            parsed.failed("The number of dimensions must be equal to two");
+        else
+            parsed.result = index_at::haversine(accuracy, config);
     } else
-        throw std::invalid_argument("Unknown distance, choose: l2sq, ip, cos, hamming, jaccard");
-    return {};
+        parsed.failed("Type-punned index only supports: l2sq, ip, cos, haversine");
+    return parsed;
 }
 
 enum class isa_t {
@@ -353,7 +383,7 @@ inline bool supports_arm_sve() {
 }
 
 template <typename from_scalar_at, typename to_scalar_at> struct cast_gt {
-    bool operator()(byte_t const* input, std::size_t bytes_in_input, byte_t* output) const {
+    inline bool operator()(byte_t const* input, std::size_t bytes_in_input, byte_t* output) const {
         from_scalar_at const* typed_input = reinterpret_cast<from_scalar_at const*>(input);
         to_scalar_at* typed_output = reinterpret_cast<to_scalar_at*>(output);
         std::transform( //
@@ -437,8 +467,9 @@ class punned_gt {
     tsl::robin_map<label_t, id_t> lookup_table_;
 
   public:
-    using search_results_t = typename index_t::search_results_t;
+    using search_result_t = typename index_t::search_result_t;
     using add_result_t = typename index_t::add_result_t;
+    using serialization_result_t = typename index_t::serialization_result_t;
     using stats_t = typename index_t::stats_t;
 
     punned_gt() = default;
@@ -462,36 +493,37 @@ class punned_gt {
         std::swap(available_threads_, other.available_threads_);
     }
 
-    static config_t optimize(config_t config) noexcept { return index_t::optimize(config); }
+    static index_config_t optimize(index_config_t config) { return index_t::optimize(config); }
 
     std::size_t dimensions() const { return dimensions_; }
     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(); }
+    index_config_t const& config() const { return typed_->config(); }
+    index_limits_t const& limits() const { return typed_->limits(); }
     void clear() { return typed_->clear(); }
-    void change_expansion_add(std::size_t n) noexcept { typed_->change_expansion_add(n); }
-    void change_expansion_search(std::size_t n) noexcept { typed_->change_expansion_search(n); }
+    void change_expansion_add(std::size_t n) { typed_->change_expansion_add(n); }
+    void change_expansion_search(std::size_t n) { typed_->change_expansion_search(n); }
 
-    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(); }
+    member_citerator_t cbegin() const { return typed_->cbegin(); }
+    member_citerator_t cend() const { return typed_->cend(); }
+    member_citerator_t begin() const { return typed_->begin(); }
+    member_citerator_t end() const { return typed_->end(); }
+    member_iterator_t begin() { return typed_->begin(); }
+    member_iterator_t end() { return typed_->end(); }
 
-    stats_t stats() const noexcept { return typed_->stats(); }
-    stats_t stats(std::size_t level) const noexcept { return typed_->stats(level); }
+    stats_t stats() const { return typed_->stats(); }
+    stats_t stats(std::size_t level) const { return typed_->stats(level); }
 
     accuracy_t accuracy() const { return accuracy_; }
     isa_t acceleration() const { return acceleration_; }
 
-    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); }
+    serialization_result_t save(char const* path) const { return typed_->save(path); }
+    serialization_result_t load(char const* path) { return typed_->load(path); }
+    serialization_result_t view(char const* path) { return typed_->view(path); }
+    bool reserve(index_limits_t limits) { return typed_->reserve(limits); }
 
-    std::size_t memory_usage(std::size_t allocator_entry_bytes = default_allocator_entry_bytes()) const noexcept {
+    std::size_t memory_usage(std::size_t allocator_entry_bytes = default_allocator_entry_bytes()) const {
         return typed_->memory_usage(allocator_entry_bytes);
     }
 
@@ -506,40 +538,40 @@ class punned_gt {
     add_result_t add(label_t label, f32_t const* vector, add_config_t config) { return add_(label, vector, config, casts_.from_f32); }
     add_result_t add(label_t label, f64_t const* vector, add_config_t config) { return add_(label, vector, config, casts_.from_f64); }
 
-    search_results_t search(f8_bits_t const* vector, std::size_t wanted) const { return search_(vector, wanted, casts_.from_f8); }
-    search_results_t search(f16_bits_t const* vector, std::size_t wanted) const { return search_(vector, wanted, casts_.from_f16); }
-    search_results_t search(f32_t const* vector, std::size_t wanted) const { return search_(vector, wanted, casts_.from_f32); }
-    search_results_t search(f64_t const* vector, std::size_t wanted) const { return search_(vector, wanted, casts_.from_f64); }
+    search_result_t search(f8_bits_t const* vector, std::size_t wanted) const { return search_(vector, wanted, casts_.from_f8); }
+    search_result_t search(f16_bits_t const* vector, std::size_t wanted) const { return search_(vector, wanted, casts_.from_f16); }
+    search_result_t search(f32_t const* vector, std::size_t wanted) const { return search_(vector, wanted, casts_.from_f32); }
+    search_result_t search(f64_t const* vector, std::size_t wanted) const { return search_(vector, wanted, casts_.from_f64); }
 
-    search_results_t search(f8_bits_t const* vector, std::size_t wanted, search_config_t config) const { return search_(vector, wanted, config, casts_.from_f8); }
-    search_results_t search(f16_bits_t const* vector, std::size_t wanted, search_config_t config) const { return search_(vector, wanted, config, casts_.from_f16); }
-    search_results_t search(f32_t const* vector, std::size_t wanted, search_config_t config) const { return search_(vector, wanted, config, casts_.from_f32); }
-    search_results_t search(f64_t const* vector, std::size_t wanted, search_config_t config) const { return search_(vector, wanted, config, casts_.from_f64); }
+    search_result_t search(f8_bits_t const* vector, std::size_t wanted, search_config_t config) const { return search_(vector, wanted, config, casts_.from_f8); }
+    search_result_t search(f16_bits_t const* vector, std::size_t wanted, search_config_t config) const { return search_(vector, wanted, config, casts_.from_f16); }
+    search_result_t search(f32_t const* vector, std::size_t wanted, search_config_t config) const { return search_(vector, wanted, config, casts_.from_f32); }
+    search_result_t search(f64_t const* vector, std::size_t wanted, search_config_t config) const { return search_(vector, wanted, config, casts_.from_f64); }
 
-    search_results_t search_around(label_t hint, f8_bits_t const* vector, std::size_t wanted) const { return search_around_(hint, vector, wanted, casts_.from_f8); }
-    search_results_t search_around(label_t hint, f16_bits_t const* vector, std::size_t wanted) const { return search_around_(hint, vector, wanted, casts_.from_f16); }
-    search_results_t search_around(label_t hint, f32_t const* vector, std::size_t wanted) const { return search_around_(hint, vector, wanted, casts_.from_f32); }
-    search_results_t search_around(label_t hint, f64_t const* vector, std::size_t wanted) const { return search_around_(hint, vector, wanted, casts_.from_f64); }
+    search_result_t search_around(label_t hint, f8_bits_t const* vector, std::size_t wanted) const { return search_around_(hint, vector, wanted, casts_.from_f8); }
+    search_result_t search_around(label_t hint, f16_bits_t const* vector, std::size_t wanted) const { return search_around_(hint, vector, wanted, casts_.from_f16); }
+    search_result_t search_around(label_t hint, f32_t const* vector, std::size_t wanted) const { return search_around_(hint, vector, wanted, casts_.from_f32); }
+    search_result_t search_around(label_t hint, f64_t const* vector, std::size_t wanted) const { return search_around_(hint, vector, wanted, casts_.from_f64); }
 
-    search_results_t search_around(label_t hint, f8_bits_t const* vector, std::size_t wanted, search_config_t config) const { return search_around_(hint, vector, wanted, config, casts_.from_f8); }
-    search_results_t search_around(label_t hint, f16_bits_t const* vector, std::size_t wanted, search_config_t config) const { return search_around_(hint, vector, wanted, config, casts_.from_f16); }
-    search_results_t search_around(label_t hint, f32_t const* vector, std::size_t wanted, search_config_t config) const { return search_around_(hint, vector, wanted, config, casts_.from_f32); }
-    search_results_t search_around(label_t hint, f64_t const* vector, std::size_t wanted, search_config_t config) const { return search_around_(hint, vector, wanted, config, casts_.from_f64); }
+    search_result_t search_around(label_t hint, f8_bits_t const* vector, std::size_t wanted, search_config_t config) const { return search_around_(hint, vector, wanted, config, casts_.from_f8); }
+    search_result_t search_around(label_t hint, f16_bits_t const* vector, std::size_t wanted, search_config_t config) const { return search_around_(hint, vector, wanted, config, casts_.from_f16); }
+    search_result_t search_around(label_t hint, f32_t const* vector, std::size_t wanted, search_config_t config) const { return search_around_(hint, vector, wanted, config, casts_.from_f32); }
+    search_result_t search_around(label_t hint, f64_t const* vector, std::size_t wanted, search_config_t config) const { return search_around_(hint, vector, wanted, config, casts_.from_f64); }
 
     void reconstruct(label_t label, f8_bits_t* vector) const { return reconstruct_(label, vector, casts_.to_f8); }
     void reconstruct(label_t label, f16_bits_t* vector) const { return reconstruct_(label, vector, casts_.to_f16); }
     void reconstruct(label_t label, f32_t* vector) const { return reconstruct_(label, vector, casts_.to_f32); }
     void reconstruct(label_t label, f64_t* vector) const { return reconstruct_(label, vector, casts_.to_f64); }
 
-    static punned_gt ip(std::size_t dimensions, accuracy_t accuracy = accuracy_t::f16_k, config_t config = {}) { return make_(dimensions, accuracy, ip_metric_(dimensions, accuracy), make_casts_(accuracy), config); }
-    static punned_gt l2sq(std::size_t dimensions, accuracy_t accuracy = accuracy_t::f16_k, config_t config = {}) { return make_(dimensions, accuracy, l2_metric_(dimensions, accuracy), make_casts_(accuracy), config); }
-    static punned_gt cos(std::size_t dimensions, accuracy_t accuracy = accuracy_t::f32_k, config_t config = {}) { return make_(dimensions, accuracy, cos_metric_(dimensions, accuracy), make_casts_(accuracy), config); }
-    static punned_gt haversine(accuracy_t accuracy = accuracy_t::f32_k, config_t config = {}) { return make_(2, accuracy, haversine_metric_(accuracy), make_casts_(accuracy), config); }
+    static punned_gt ip(std::size_t dimensions, accuracy_t accuracy = accuracy_t::f16_k, index_config_t config = {}) { return make_(dimensions, accuracy, ip_metric_(dimensions, accuracy), make_casts_(accuracy), config); }
+    static punned_gt l2sq(std::size_t dimensions, accuracy_t accuracy = accuracy_t::f16_k, index_config_t config = {}) { return make_(dimensions, accuracy, l2_metric_(dimensions, accuracy), make_casts_(accuracy), config); }
+    static punned_gt cos(std::size_t dimensions, accuracy_t accuracy = accuracy_t::f32_k, index_config_t config = {}) { return make_(dimensions, accuracy, cos_metric_(dimensions, accuracy), make_casts_(accuracy), config); }
+    static punned_gt haversine(accuracy_t accuracy = accuracy_t::f32_k, index_config_t config = {}) { return make_(2, accuracy, haversine_metric_(accuracy), make_casts_(accuracy), config); }
     // clang-format on
 
     static punned_gt udf(                                        //
         std::size_t dimensions, punned_stateful_metric_t metric, //
-        accuracy_t accuracy = accuracy_t::f32_k, config_t config = {}) {
+        accuracy_t accuracy = accuracy_t::f32_k, index_config_t config = {}) {
         return make_(dimensions, accuracy, {metric, isa_t::auto_k}, make_casts_(accuracy), config);
     }
 
@@ -618,7 +650,7 @@ class punned_gt {
     }
 
     template <typename scalar_at>
-    search_results_t search_(                        //
+    search_result_t search_(                         //
         scalar_at const* vector, std::size_t wanted, //
         search_config_t config, cast_t const& cast) const {
 
@@ -634,7 +666,7 @@ class punned_gt {
     }
 
     template <typename scalar_at>
-    search_results_t search_around_(                               //
+    search_result_t search_around_(                                //
         label_t hint, scalar_at const* vector, std::size_t wanted, //
         search_config_t config, cast_t const& cast) const {
 
@@ -672,7 +704,7 @@ class punned_gt {
     }
 
     template <typename scalar_at>
-    search_results_t search_(                        //
+    search_result_t search_(                         //
         scalar_at const* vector, std::size_t wanted, //
         cast_t const& cast) const {
         thread_lock_t lock = thread_lock_();
@@ -682,7 +714,7 @@ class punned_gt {
     }
 
     template <typename scalar_at>
-    search_results_t search_around_(                               //
+    search_result_t search_around_(                                //
         label_t hint, scalar_at const* vector, std::size_t wanted, //
         cast_t const& cast) const {
         thread_lock_t lock = thread_lock_();
@@ -694,23 +726,20 @@ class punned_gt {
     static punned_gt make_(                               //
         std::size_t dimensions, accuracy_t accuracy,      //
         metric_and_meta_t metric_and_meta, casts_t casts, //
-        config_t config) {
+        index_config_t config) {
 
         std::size_t hardware_threads = std::thread::hardware_concurrency();
-        config.max_threads_add = config.max_threads_add ? config.max_threads_add : hardware_threads;
-        config.max_threads_search = config.max_threads_search ? config.max_threads_search : hardware_threads;
-        std::size_t max_threads = (std::max)(config.max_threads_add, config.max_threads_search);
         punned_gt result;
         result.dimensions_ = dimensions;
         result.accuracy_ = accuracy;
         result.casted_vector_bytes_ = bytes_per_scalar(accuracy) * dimensions;
-        result.cast_buffer_.resize(max_threads * result.casted_vector_bytes_);
+        result.cast_buffer_.resize(hardware_threads * result.casted_vector_bytes_);
         result.casts_ = casts;
         result.acceleration_ = metric_and_meta.acceleration;
         result.root_metric_ = metric_and_meta.metric;
 
         // Fill the thread IDs.
-        result.available_threads_.resize(max_threads);
+        result.available_threads_.resize(hardware_threads);
         std::iota(result.available_threads_.begin(), result.available_threads_.end(), 0ul);
 
         // Available since C11, but only C++17, so we use the C version.

package/src/test.cpp

@@ -2,7 +2,7 @@
  * @brief A trivial test.
  */
 #include <algorithm>
-#include <cassert>
+#include <stdexcept>
 
 #include "punned.hpp"
 
@@ -11,13 +11,20 @@ using namespace unum;
 
 using point_id_t = std::int64_t;
 
+void expect(bool must_be_true) {
+    if (!must_be_true)
+        throw std::runtime_error("Failed!");
+}
+
 template <typename scalar_at, typename index_at> void test3d(index_at&& index) {
-    using view_t = span_gt<scalar_at const>;
+
+    using scalar_t = scalar_at;
+    using view_t = span_gt<scalar_t const>;
     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};
+    scalar_t vec[3] = {10, 20, 15};
+    scalar_t vec_a[3] = {15, 16, 17};
+    scalar_t vec_b[3] = {16, 17, 18};
 
     index.reserve(10);
     index.add(42, view_t{&vec[0], 3ul});
@@ -27,16 +34,16 @@ template <typename scalar_at, typename index_at> void test3d(index_at&& index) {
     distance_t matched_distances[10] = {0};
     std::size_t matched_count = index.search(view_t{&vec[0], 3ul}, 5).dump_to(matched_labels, matched_distances);
 
-    assert(matched_count == 1);
-    assert(matched_labels[0] == 42);
-    assert(std::abs(matched_distances[0]) < 0.01);
+    expect(matched_count == 1);
+    expect(matched_labels[0] == 42);
+    expect(std::abs(matched_distances[0]) < 0.01);
 
     // Add more entries
     search_config_t search_config;
     search_config.exact = true;
     index.add(43, view_t{&vec_a[0], 3ul});
     index.add(44, view_t{&vec_b[0], 3ul});
-    assert(index.size() == 3);
+    expect(index.size() == 3);
 
     // Perform exact search
     matched_count = index.search(view_t{&vec[0], 3ul}, 5, search_config).dump_to(matched_labels, matched_distances);
@@ -45,47 +52,84 @@ template <typename scalar_at, typename index_at> void test3d(index_at&& index) {
     std::size_t count = 0;
     for (auto member : index) {
         point_id_t id = member.label;
-        assert(id >= 42 && id <= 44);
+        expect(id >= 42 && id <= 44);
         count++;
     }
-    assert((count == 3));
-    assert((index.stats(0).nodes == 3));
+    expect((count == 3));
+    expect((index.stats(0).nodes == 3));
 
     // Search again over reconstructed index
     index.save("tmp.usearch");
     index.load("tmp.usearch");
     matched_count = index.search(view_t{&vec[0], 3ul}, 5).dump_to(matched_labels, matched_distances);
-    assert(matched_count == 3);
-    assert(matched_labels[0] == 42);
-    assert(std::abs(matched_distances[0]) < 0.01);
+    expect(matched_count == 3);
+    expect(matched_labels[0] == 42);
+    expect(std::abs(matched_distances[0]) < 0.01);
 
     // Search again over mapped index
     index.view("tmp.usearch");
     matched_count = index.search(view_t{&vec[0], 3ul}, 5).dump_to(matched_labels, matched_distances);
-    assert(matched_count == 3);
-    assert(matched_labels[0] == 42);
-    assert(std::abs(matched_distances[0]) < 0.01);
+    expect(matched_count == 3);
+    expect(matched_labels[0] == 42);
+    expect(std::abs(matched_distances[0]) < 0.01);
 
-    assert(index.memory_usage() > 0);
-    assert(index.stats().max_edges > 0);
+    expect(index.memory_usage() > 0);
+    expect(index.stats().max_edges > 0);
 }
 
 template <typename scalar_at, typename index_at> void test3d_punned(index_at&& index) {
-    using view_t = span_gt<scalar_at const>;
+
+    using scalar_t = scalar_at;
+    using view_t = span_gt<scalar_t const>;
     using span_t = span_gt<scalar_at>;
-    using distance_t = typename index_at::distance_t;
 
-    scalar_at vec[3] = {10, 20, 15};
+    scalar_t vec[3] = {10, 20, 15};
 
     index.reserve(10);
     index.add(42, view_t{&vec[0], 3ul});
 
     // Reconstruct
-    scalar_at vec_reconstructed[3] = {0, 0, 0};
+    scalar_t vec_reconstructed[3] = {0, 0, 0};
     index.reconstruct(42, span_t{&vec_reconstructed[0], 3ul});
-    assert(vec_reconstructed[0] == vec[0]);
-    assert(vec_reconstructed[1] == vec[1]);
-    assert(vec_reconstructed[2] == vec[2]);
+    expect(vec_reconstructed[0] == vec[0]);
+    expect(vec_reconstructed[1] == vec[1]);
+    expect(vec_reconstructed[2] == vec[2]);
+}
+
+template <typename index_at> void test_sets(index_at&& index) {
+
+    using index_t = typename std::remove_reference<index_at>::type;
+    using scalar_t = typename index_t::scalar_t;
+    using view_t = span_gt<scalar_t const>;
+
+    scalar_t vec0[] = {10, 20};
+    scalar_t vec1[] = {10, 15, 20};
+    scalar_t vec2[] = {10, 20, 30, 35};
+
+    index.reserve(10);
+    index.add(42, view_t{&vec0[0], 2ul});
+    index.add(43, view_t{&vec1[0], 3ul});
+    index.add(44, view_t{&vec2[0], 4ul});
+
+    expect(index.size() == 3);
+}
+
+template <typename index_at> void test_sets_moved() {
+    {
+        index_at index;
+        test_sets(index);
+    }
+    {
+        index_at index;
+        index.reserve(1);
+        test_sets(index_at(std::move(index)));
+    }
+    {
+        index_at index;
+        index.reserve(1);
+        index_at index_moved = std::move(index);
+        test_sets(index_moved);
+    }
 }
 
 int main(int, char**) {
@@ -105,5 +149,11 @@ int main(int, char**) {
     test3d_punned<float>(punned_small_t::cos(3));
     test3d_punned<float>(punned_small_t::l2sq(3));
 
+    test_sets(index_gt<jaccard_gt<std::int32_t, float>, point_id_t, std::uint32_t, std::int32_t>{});
+    test_sets(index_gt<jaccard_gt<std::int64_t, float>, point_id_t, std::uint32_t, std::int64_t>{});
+
+    test_sets_moved<index_gt<jaccard_gt<std::int32_t, float>, point_id_t, std::uint32_t, std::int32_t>>();
+    test_sets_moved<index_gt<jaccard_gt<std::int64_t, float>, point_id_t, std::uint32_t, std::int64_t>>();
+
     return 0;
 }