usearch 0.2.2 → 0.2.4

package/include/usearch/usearch.hpp

@@ -123,7 +123,7 @@ template <typename scalar_at, typename result_at = scalar_at> struct cos_gt {
             ab += result_t(a[i]) * result_t(b[i]), //
                 a2 += square<result_t>(a[i]),      //
                 b2 += square<result_t>(b[i]);
-        return ab / (std::sqrt(a2) * std::sqrt(b2));
+        return 1 - ab / (std::sqrt(a2) * std::sqrt(b2));
     }
 };
 
@@ -330,7 +330,8 @@ using visits_bitset_t = visits_bitset_gt<>;
 
 /**
  *  @brief  Similar to `std::priority_queue`, but allows raw access to underlying
- *          memory, in case you want to shuffle it or sort.
+ *          memory, in case you want to shuffle it or sort. Good for collections
+ *          from 100s to 10'000s elements.
  */
 template <typename element_at,                                //
           typename comparator_at = std::less<void>,           // <void> is needed before C++14.
@@ -347,23 +348,19 @@ class max_heap_gt {
     element_t* elements_;
     std::size_t size_;
     std::size_t capacity_;
-    std::size_t max_capacity_;
 
   public:
-    max_heap_gt(std::size_t max_capacity = 0) noexcept
-        : elements_(nullptr), size_(0), capacity_(0), max_capacity_(max_capacity) {}
+    max_heap_gt() noexcept : elements_(nullptr), size_(0), capacity_(0) {}
 
     max_heap_gt(max_heap_gt&& other) noexcept {
         std::swap(elements_, other.elements_);
         std::swap(size_, other.size_);
         std::swap(capacity_, other.capacity_);
-        std::swap(max_capacity_, other.max_capacity_);
     }
     max_heap_gt& operator=(max_heap_gt&& other) noexcept {
         std::swap(elements_, other.elements_);
         std::swap(size_, other.size_);
         std::swap(capacity_, other.capacity_);
-        std::swap(max_capacity_, other.max_capacity_);
         return *this;
     }
 
@@ -384,16 +381,12 @@ class max_heap_gt {
         }
     }
 
-    bool reserve(std::size_t n) noexcept {
-        if (n < capacity_)
+    bool reserve(std::size_t new_capacity) noexcept {
+        if (new_capacity < capacity_)
             return true;
-        if (max_capacity_ && capacity_ == max_capacity_)
-            return false;
-
-        auto new_capacity = (std::max<std::size_t>)(capacity_ * 2u, 16u);
-        if (max_capacity_)
-            new_capacity = (std::min)(new_capacity, max_capacity_);
 
+        new_capacity = ceil2(new_capacity);
+        new_capacity = (std::max<std::size_t>)(new_capacity, (std::max<std::size_t>)(capacity_ * 2u, 16u));
         auto allocator = allocator_t{};
         auto new_elements = allocator.allocate(new_capacity);
         if (!new_elements)
@@ -413,10 +406,15 @@ class max_heap_gt {
         if (!reserve(size_ + 1))
             return false;
 
+        emplace_reserved(std::forward<args_at>(args)...);
+        return true;
+    }
+
+    template <typename... args_at> //
+    void emplace_reserved(args_at&&... args) noexcept {
         new (&elements_[size_]) element_t({std::forward<args_at>(args)...});
         size_++;
         shift_up(size_ - 1);
-        return true;
     }
 
     element_t pop() noexcept {
@@ -430,10 +428,7 @@ class max_heap_gt {
 
     /** @brief Invalidates the "max-heap" property, transforming into ascending range. */
     void sort_ascending() noexcept { std::sort_heap(elements_, elements_ + size_, &less); }
-    /** @brief Invalidates the "max-heap" property, transforming into descending range. */
-    void sort_descending() noexcept { sort_ascending(), std::reverse(elements_, elements_ + size_); }
-    void sort_heap() noexcept { std::make_heap(elements_, elements_ + size_, &less); }
-    void shrink(std::size_t n) noexcept { size_ = n; }
+    void shrink(std::size_t n) noexcept { size_ = (std::min<std::size_t>)(n, size_); }
 
     element_t* data() noexcept { return elements_; }
     element_t const* data() const noexcept { return elements_; }
@@ -467,6 +462,108 @@ class max_heap_gt {
     }
 };
 
+/**
+ *  @brief  Similar to `std::priority_queue`, but allows raw access to underlying
+ *          memory and always keeps the data sorted. Ideal for small collections
+ *          under 128 elements.
+ */
+template <typename element_at,                                //
+          typename comparator_at = std::less<void>,           // <void> is needed before C++14.
+          typename allocator_at = std::allocator<element_at>> //
+class sorted_buffer_gt {
+  public:
+    using element_t = element_at;
+    using comparator_t = comparator_at;
+    using allocator_t = allocator_at;
+
+    using value_type = element_t;
+
+  private:
+    element_t* elements_;
+    std::size_t size_;
+    std::size_t capacity_;
+
+  public:
+    sorted_buffer_gt() noexcept : elements_(nullptr), size_(0), capacity_(0) {}
+
+    sorted_buffer_gt(sorted_buffer_gt&& other) noexcept {
+        std::swap(elements_, other.elements_);
+        std::swap(size_, other.size_);
+        std::swap(capacity_, other.capacity_);
+    }
+    sorted_buffer_gt& operator=(sorted_buffer_gt&& other) noexcept {
+        std::swap(elements_, other.elements_);
+        std::swap(size_, other.size_);
+        std::swap(capacity_, other.capacity_);
+        return *this;
+    }
+
+    sorted_buffer_gt(sorted_buffer_gt const&) = delete;
+    sorted_buffer_gt& operator=(sorted_buffer_gt const&) = delete;
+
+    ~sorted_buffer_gt() {
+        clear();
+        allocator_t{}.deallocate(elements_, capacity_);
+    }
+
+    bool empty() const noexcept { return !size_; }
+    std::size_t size() const noexcept { return size_; }
+    std::size_t capacity() const noexcept { return capacity_; }
+    element_t const& top() const noexcept { return elements_[size_ - 1]; }
+
+    void clear() noexcept {
+        while (size_)
+            size_--, elements_[size_].~element_t();
+    }
+
+    bool reserve(std::size_t new_capacity) noexcept {
+        if (new_capacity < capacity_)
+            return true;
+
+        new_capacity = ceil2(new_capacity);
+        new_capacity = (std::max<std::size_t>)(new_capacity, (std::max<std::size_t>)(capacity_ * 2u, 16u));
+        auto allocator = allocator_t{};
+        auto new_elements = allocator.allocate(new_capacity);
+        if (!new_elements)
+            return false;
+
+        if (size_) {
+            std::uninitialized_copy_n(elements_, size_, new_elements);
+            allocator.deallocate(elements_, capacity_);
+        }
+        elements_ = new_elements;
+        capacity_ = new_capacity;
+        return true;
+    }
+
+    template <typename... args_at> void emplace_reserved(args_at&&... args) {
+        element_t element({std::forward<args_at>(args)...});
+        std::size_t slot = std::lower_bound(elements_, elements_ + size_, element, &less) - elements_;
+        std::size_t to_move = size_ - slot;
+        element_t* source = elements_ + size_ - 1;
+        for (; to_move; --to_move, --source)
+            source[1] = source[0];
+        elements_[slot] = element;
+        size_++;
+    }
+
+    element_t pop() noexcept {
+        size_--;
+        element_t result = elements_[size_];
+        elements_[size_].~element_t();
+        return result;
+    }
+
+    void sort_ascending() noexcept {}
+    void shrink(std::size_t n) noexcept { size_ = (std::min<std::size_t>)(n, size_); }
+
+    element_t* data() noexcept { return elements_; }
+    element_t const* data() const noexcept { return elements_; }
+
+  private:
+    static bool less(element_t const& a, element_t const& b) noexcept { return comparator_t{}(a, b); }
+};
+
 /**
  *
  */
@@ -672,16 +769,18 @@ class index_gt {
         std::size_t neighbors_base_bytes{};
         std::size_t mutex_bytes{};
     };
-    struct distance_and_id_t {
+    struct candidate_t {
         distance_t first;
         id_t second;
     };
     struct compare_by_distance_t {
-        inline bool operator()(distance_and_id_t a, distance_and_id_t b) const noexcept { return a.first < b.first; }
+        inline bool operator()(candidate_t a, candidate_t b) const noexcept { return a.first < b.first; }
     };
 
-    using distances_and_ids_allocator_t = typename allocator_traits_t::template rebind_alloc<distance_and_id_t>;
-    using distances_and_ids_t = max_heap_gt<distance_and_id_t, compare_by_distance_t, distances_and_ids_allocator_t>;
+    using candidates_view_t = span_gt<candidate_t const>;
+    using candidates_allocator_t = typename allocator_traits_t::template rebind_alloc<candidate_t>;
+    using top_candidates_t = sorted_buffer_gt<candidate_t, compare_by_distance_t, candidates_allocator_t>;
+    using next_candidates_t = max_heap_gt<candidate_t, compare_by_distance_t, candidates_allocator_t>;
 
     struct neighbors_ref_t {
         neighbors_count_t& count_;
@@ -696,6 +795,8 @@ class index_gt {
         inline id_t& operator[](std::size_t i) noexcept { return neighbors_[i]; }
         inline id_t operator[](std::size_t i) const noexcept { return neighbors_[i]; }
         inline std::size_t size() const noexcept { return count_; }
+        inline void clear() noexcept { count_ = 0u; }
+        inline void push_back(id_t id) noexcept { neighbors_[count_] = id, count_++; }
     };
 
 #if defined(WINDOWS)
@@ -739,8 +840,8 @@ class index_gt {
     };
 
     struct usearch_align_m thread_context_t {
-        distances_and_ids_t top_candidates;
-        distances_and_ids_t candidates_set;
+        top_candidates_t top_candidates;
+        next_candidates_t next_candidates;
         visits_bitset_t visits;
         std::default_random_engine level_generator;
         metric_t metric;
@@ -920,16 +1021,14 @@ class index_gt {
         id_t closest_id = search_for_one(entry_id_, query_vec, query_dim, max_level_, 0, context);
 
         // For bottom layer we need a more optimized procedure
-        search_to_find_in_base( //
-            closest_id, query_vec, query_dim, (std::max)(config_.expansion_search, wanted), context);
-        while (context.top_candidates.size() > wanted)
-            context.top_candidates.pop();
-
-        while (context.top_candidates.size()) {
-            distance_and_id_t top = context.top_candidates.top();
-            callback(node(top.second).head.label, top.first);
-            context.top_candidates.pop();
-        }
+        std::size_t expansion = (std::max)(config_.expansion_search, wanted);
+        search_to_find_in_base(closest_id, query_vec, query_dim, expansion, context);
+        context.top_candidates.sort_ascending();
+        context.top_candidates.shrink(wanted);
+
+        candidate_t const* top = context.top_candidates.data();
+        for (std::size_t i = 0; i < context.top_candidates.size(); ++i)
+            callback(node(top[i].second).head.label, top[i].first);
     }
 
     std::size_t search(                                         //
@@ -946,8 +1045,6 @@ class index_gt {
             ++found;
         };
         search(query_span, wanted, callback, thread_idx);
-        std::reverse(matches, matches + found * (matches != nullptr));
-        std::reverse(distances, distances + found * (distances != nullptr));
         return found;
     }
 
@@ -1238,68 +1335,62 @@ class index_gt {
     id_t connect_new_element(id_t new_id, level_t level, thread_context_t& context) noexcept(false) {
 
         node_ref_t new_node = node(new_id);
-        distances_and_ids_t& top_candidates = context.top_candidates;
+        top_candidates_t& top = context.top_candidates;
         std::size_t const connectivity_max = level ? config_.connectivity : pre_.connectivity_max_base;
-        span_gt<distance_and_id_t const> top = filter_heuristic(top_candidates, config_.connectivity, context.metric);
-
-        distance_and_id_t const* const top_ordered = top.data();
-        std::size_t const top_count = top.size();
-        id_t const next_closest_entry_id = top_ordered[0].second;
 
         // Outgoing links from `new_id`:
+        neighbors_ref_t new_neighbors = neighbors(new_node, level);
         {
-            neighbors_ref_t new_neighbors = neighbors(new_node, level);
-            assert_m(!new_neighbors.count_, "The newly inserted element should have blank link list");
+            assert_m(!new_neighbors.size(), "The newly inserted element should have blank link list");
+            candidates_view_t top_view = refine(top, config_.connectivity, context);
 
-            new_neighbors.count_ = static_cast<neighbors_count_t>(top_count);
-            for (std::size_t idx = 0; idx < top_count; idx++) {
+            for (std::size_t idx = 0; idx != top_view.size(); idx++) {
                 assert_m(!new_neighbors[idx], "Possible memory corruption");
-                assert_m(level <= node(top_ordered[idx].second).head.level, "Linking to missing level");
-                new_neighbors[idx] = top_ordered[idx].second;
+                assert_m(level <= node(top_view[idx].second).head.level, "Linking to missing level");
+                new_neighbors.push_back(top_view[idx].second);
             }
         }
 
         // Reverse links from the neighbors:
-        for (std::size_t idx = 0; idx < top_count; idx++) {
-            id_t close_id = top_ordered[idx].second;
+        for (id_t close_id : new_neighbors) {
             node_ref_t close_node = node(close_id);
             lock_t close_lock = close_node.lock();
 
             neighbors_ref_t close_header = neighbors(close_node, level);
-            assert_m(close_header.count_ <= connectivity_max, "Possible corruption");
+            assert_m(close_header.size() <= connectivity_max, "Possible corruption");
             assert_m(close_id != new_id, "Self-loops are impossible");
             assert_m(level <= close_node.head.level, "Linking to missing level");
 
             // If `new_id` is already present in the neighboring connections of `close_id`
             // then no need to modify any connections or run the heuristics.
-            if (close_header.count_ < connectivity_max) {
-                close_header[close_header.count_] = new_id;
-                close_header.count_++;
+            if (close_header.size() < connectivity_max) {
+                close_header.push_back(new_id);
                 continue;
             }
 
             // To fit a new connection we need to drop an existing one.
-            distances_and_ids_t& candidates = context.candidates_set;
-            candidates.clear();
-            candidates.emplace( //
-                context.metric( //
+            top.clear();
+            top.reserve(close_header.size() + 1);
+            top.emplace_reserved( //
+                context.metric(   //
                     new_node.vector, close_node.vector, new_node.head.dim, close_node.head.dim),
                 new_id);
             for (id_t successor_id : close_header) {
                 node_ref_t successor_node = node(successor_id);
-                candidates.emplace( //
-                    context.metric( //
+                top.emplace_reserved( //
+                    context.metric(   //
                         successor_node.vector, close_node.vector, successor_node.head.dim, close_node.head.dim),
                     successor_id);
             }
-            span_gt<distance_and_id_t const> top = filter_heuristic(candidates, connectivity_max, context.metric);
 
             // Export the results:
-            for (close_header.count_ = 0u; close_header.count_ != top.size(); ++close_header.count_)
-                close_header[close_header.count_] = top[close_header.count_].second;
+            close_header.clear();
+            candidates_view_t top_view = refine(top, connectivity_max, context);
+            for (std::size_t idx = 0; idx != top_view.size(); idx++)
+                close_header.push_back(top_view[idx].second);
         }
 
-        return next_closest_entry_id;
+        return new_neighbors[0];
     }
 
     level_t choose_random_level(std::default_random_engine& level_generator) const noexcept {
@@ -1342,25 +1433,27 @@ class index_gt {
         level_t level, thread_context_t& context) noexcept(false) {
 
         visits_bitset_t& visits = context.visits;
-        distances_and_ids_t& top_candidates = context.top_candidates; // pop max, push
-        distances_and_ids_t& candidates_set = context.candidates_set; // pop min, push
+        next_candidates_t& candidates = context.next_candidates; // pop min, push
+        top_candidates_t& top = context.top_candidates;          // pop max, push
+        std::size_t const top_limit = config_.expansion_add;
 
-        top_candidates.clear();
-        candidates_set.clear();
         visits.clear();
+        candidates.clear();
+        top.clear();
+        top.reserve(top_limit + 1);
 
-        distance_t closest_dist = context.metric(query_vec, node(start_id).vector, query_dim, node(start_id).head.dim);
-        top_candidates.emplace(closest_dist, start_id);
-        candidates_set.emplace(-closest_dist, start_id);
+        distance_t radius = context.metric(query_vec, node(start_id).vector, query_dim, node(start_id).head.dim);
+        candidates.emplace(-radius, start_id);
+        top.emplace_reserved(radius, start_id);
         visits.set(start_id);
 
-        while (!candidates_set.empty()) {
+        while (!candidates.empty()) {
 
-            distance_and_id_t candidacy = candidates_set.top();
-            if ((-candidacy.first) > closest_dist && top_candidates.size() == config_.expansion_add)
+            candidate_t candidacy = candidates.top();
+            if ((-candidacy.first) > radius && top.size() == top_limit)
                 break;
 
-            candidates_set.pop();
+            candidates.pop();
             id_t candidate_id = candidacy.second;
             node_ref_t candidate_node = node(candidate_id);
             lock_t candidate_lock = candidate_node.lock();
@@ -1375,14 +1468,12 @@ class index_gt {
                 node_ref_t successor_node = node(successor_id);
                 distance_t successor_dist =
                     context.metric(query_vec, successor_node.vector, query_dim, successor_node.head.dim);
-                if (top_candidates.size() < config_.expansion_add || closest_dist > successor_dist) {
-                    candidates_set.emplace(-successor_dist, successor_id);
-
-                    top_candidates.emplace(successor_dist, successor_id);
-                    if (top_candidates.size() > config_.expansion_add)
-                        top_candidates.pop();
-                    if (!top_candidates.empty())
-                        closest_dist = top_candidates.top().first;
+                if (top.size() < top_limit || successor_dist < radius) {
+                    candidates.emplace(-successor_dist, successor_id);
+                    top.emplace_reserved(successor_dist, successor_id);
+                    if (top.size() > top_limit)
+                        top.pop();
+                    radius = top.top().first;
                 }
             }
         }
@@ -1393,27 +1484,29 @@ class index_gt {
         std::size_t expansion, thread_context_t& context) const noexcept(false) {
 
         visits_bitset_t& visits = context.visits;
-        distances_and_ids_t& top_candidates = context.top_candidates; // pop max, push
-        distances_and_ids_t& candidates_set = context.candidates_set; // pop min, push
+        next_candidates_t& candidates = context.next_candidates; // pop min, push
+        top_candidates_t& top = context.top_candidates;          // pop max, push
+        std::size_t const top_limit = expansion;
 
         visits.clear();
-        top_candidates.clear();
-        candidates_set.clear();
+        candidates.clear();
+        top.clear();
+        top.reserve(top_limit + 1);
 
-        distance_t closest_dist = context.metric(query_vec, node(start_id).vector, query_dim, node(start_id).head.dim);
-        top_candidates.emplace(closest_dist, start_id);
-        candidates_set.emplace(-closest_dist, start_id);
+        distance_t radius = context.metric(query_vec, node(start_id).vector, query_dim, node(start_id).head.dim);
+        candidates.emplace(-radius, start_id);
+        top.emplace_reserved(radius, start_id);
         visits.set(start_id);
 
-        while (!candidates_set.empty()) {
+        while (!candidates.empty()) {
 
-            distance_and_id_t current_node_node = candidates_set.top();
-            if ((-current_node_node.first) > closest_dist)
+            candidate_t candidate = candidates.top();
+            if ((-candidate.first) > radius)
                 break;
 
-            candidates_set.pop();
+            candidates.pop();
 
-            id_t candidate_id = current_node_node.second;
+            id_t candidate_id = candidate.second;
             neighbors_ref_t candidate_header = neighbors_base(node(candidate_id));
 
             prefetch_neighbors(candidate_header, visits);
@@ -1426,14 +1519,12 @@ class index_gt {
                 distance_t successor_dist =
                     context.metric(query_vec, successor_node.vector, query_dim, successor_node.head.dim);
 
-                if (top_candidates.size() < expansion || closest_dist > successor_dist) {
-                    candidates_set.emplace(-successor_dist, successor_id);
-
-                    top_candidates.emplace(successor_dist, successor_id);
-                    if (top_candidates.size() > expansion)
-                        top_candidates.pop();
-                    if (!top_candidates.empty())
-                        closest_dist = top_candidates.top().first;
+                if (top.size() < top_limit || successor_dist < radius) {
+                    candidates.emplace(-successor_dist, successor_id);
+                    top.emplace_reserved(successor_dist, successor_id);
+                    if (top.size() > top_limit)
+                        top.pop();
+                    radius = top.top().first;
                 }
             }
         }
@@ -1441,26 +1532,30 @@ class index_gt {
 
     void prefetch_neighbors(neighbors_ref_t, visits_bitset_t const&) const noexcept {}
 
-    span_gt<distance_and_id_t const> filter_heuristic( //
-        distances_and_ids_t& top_candidates, std::size_t needed, metric_t const& metric) const noexcept {
+    /**
+     *  @brief  This algorithm from the original paper implements a heuristic,
+     *          that massively reduces the number of connections a point has,
+     *          to keep only the neighbors, that are from each other.
+     */
+    candidates_view_t refine(top_candidates_t& top, std::size_t needed, thread_context_t& context) const noexcept {
 
-        top_candidates.sort_ascending();
-        distance_and_id_t* top_ordered = top_candidates.data();
-        std::size_t const top_count = top_candidates.size();
+        top.sort_ascending();
+        candidate_t* top_data = top.data();
+        std::size_t const top_count = top.size();
         if (top_count < needed)
-            return {top_ordered, top_count};
+            return {top_data, top_count};
 
         std::size_t submitted_count = 1;
         std::size_t consumed_count = 1; /// Always equal or greater than `submitted_count`.
         while (submitted_count < needed && consumed_count < top_count) {
-            distance_and_id_t candidate = top_ordered[consumed_count];
+            candidate_t candidate = top_data[consumed_count];
             node_ref_t candidate_node = node(candidate.second);
             distance_t candidate_dist = candidate.first;
             bool good = true;
             for (std::size_t idx = 0; idx < submitted_count; idx++) {
-                distance_and_id_t submitted = top_ordered[idx];
+                candidate_t submitted = top_data[idx];
                 node_ref_t submitted_node = node(submitted.second);
-                distance_t inter_result_dist = metric(            //
+                distance_t inter_result_dist = context.metric(    //
                     submitted_node.vector, candidate_node.vector, //
                     submitted_node.head.dim, candidate_node.head.dim);
                 if (inter_result_dist < candidate_dist) {
@@ -1470,13 +1565,14 @@ class index_gt {
             }
 
             if (good) {
-                top_ordered[submitted_count] = top_ordered[consumed_count];
+                top_data[submitted_count] = top_data[consumed_count];
                 submitted_count++;
             }
             consumed_count++;
         }
 
-        return {top_ordered, submitted_count};
+        top.shrink(submitted_count);
+        return {top_data, submitted_count};
     }
 };
 

package/objc/include/USearchObjective.h

@@ -10,6 +10,7 @@ typedef NS_ENUM(NSUInteger, Quantization) {
     kDoublePrecision
 };
 
+API_AVAILABLE(ios(13.0), macos(10.15), tvos(13.0), watchos(6.0))
 @interface Index: NSObject
 
 @property (readonly) UInt32 dimensions;
@@ -33,9 +34,9 @@ NS_UNAVAILABLE;
 NS_SWIFT_NAME(addSingle(label:vector:));
 
 - (UInt32)searchSingle:(Float32 const* _Nonnull)vector
-               count:(UInt32)count
-              labels:(UInt32* _Nullable)labels
-           distances:(Float32* _Nullable)distances
+                 count:(UInt32)count
+                labels:(UInt32* _Nullable)labels
+             distances:(Float32* _Nullable)distances
 NS_SWIFT_NAME(searchSingle(vector:count:labels:distances:));
 
 - (void)addPrecise:(UInt32)label
@@ -43,9 +44,9 @@ NS_SWIFT_NAME(searchSingle(vector:count:labels:distances:));
 NS_SWIFT_NAME(addPrecise(label:vector:));
 
 - (UInt32)searchPrecise:(Float64 const* _Nonnull)vector
-                count:(UInt32)count
-               labels:(UInt32* _Nullable)labels
-            distances:(Float32* _Nullable)distances
+                  count:(UInt32)count
+                 labels:(UInt32* _Nullable)labels
+              distances:(Float32* _Nullable)distances
 NS_SWIFT_NAME(searchPrecise(vector:count:labels:distances:));
 
 - (void)addImprecise:(UInt32)label
@@ -53,9 +54,9 @@ NS_SWIFT_NAME(searchPrecise(vector:count:labels:distances:));
 NS_SWIFT_NAME(addImprecise(label:vector:));
 
 - (UInt32)searchImprecise:(void const* _Nonnull)vector
-                  count:(UInt32)count
-                 labels:(UInt32* _Nullable)labels
-              distances:(Float32* _Nullable)distances
+                    count:(UInt32)count
+                   labels:(UInt32* _Nullable)labels
+                distances:(Float32* _Nullable)distances
 NS_SWIFT_NAME(searchImprecise(vector:count:labels:distances:));
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "usearch",
-    "version": "0.2.2",
+    "version": "0.2.4",
     "description": "Smaller & Faster Single-File Vector Search Engine from Unum",
     "author": "Ashot Vardanian",
     "license": "Apache 2.0",
@@ -18,5 +18,11 @@
     },
     "scripts": {
         "test": "node javascript/test.js"
+    },
+    "devDependencies": {
+        "@semantic-release/exec": "^6.0.3",
+        "@semantic-release/git": "^10.0.1",
+        "conventional-changelog-eslint": "^3.0.9",
+        "semantic-release": "^21.0.2"
     }
 }