usearch 0.9.2 → 0.9.4

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "usearch"
-version = "0.9.2"
+version = "0.9.4"
 authors = ["Ashot Vardanian <1983160+ashvardanian@users.noreply.github.com>"]
 description = "Smaller & Faster Single-File Vector Search Engine from Unum"
 edition = "2021"

package/VERSION

@@ -1 +1 @@
-0.9.2
+0.9.4

package/conanfile.py

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

package/include/usearch/usearch.hpp

@@ -410,71 +410,75 @@ template <typename allocator_at = std::allocator<char>> class visits_bitset_gt {
 
 #if defined(USEARCH_IS_WINDOWS)
     using slot_t = LONG volatile;
-    static_assert(sizeof(slot_t) == 8);
 #else
     using slot_t = std::uint64_t;
 #endif
 
-    std::uint64_t* u64s_{};
-    std::size_t slots_{};
+    static constexpr std::size_t bits_per_slot() { return sizeof(slot_t) * CHAR_BIT; }
+    static constexpr slot_t bits_mask() { return sizeof(slot_t) * CHAR_BIT - 1; }
+
+    slot_t* slots_{};
+    std::size_t slots_count_{};
 
   public:
     visits_bitset_gt() noexcept {}
     visits_bitset_gt(std::size_t capacity) noexcept {
-        slots_ = divide_round_up<64>(capacity);
-        u64s_ = (slot_t*)allocator_t{}.allocate(slots_ * sizeof(slot_t));
+        slots_count_ = divide_round_up<bits_per_slot()>(capacity);
+        slots_ = (slot_t*)allocator_t{}.allocate(slots_count_ * sizeof(slot_t));
         clear();
     }
-    ~visits_bitset_gt() noexcept { allocator_t{}.deallocate((byte_t*)u64s_, slots_ * sizeof(slot_t)), u64s_ = nullptr; }
-    void clear() noexcept { std::memset(u64s_, 0, slots_ * sizeof(slot_t)); }
-    inline bool test(std::size_t i) const noexcept { return u64s_[i / 64] & (1ul << (i & 63ul)); }
-    inline void set(std::size_t i) noexcept { u64s_[i / 64] |= (1ul << (i & 63ul)); }
+    ~visits_bitset_gt() noexcept {
+        allocator_t{}.deallocate((byte_t*)slots_, slots_count_ * sizeof(slot_t)), slots_ = nullptr;
+    }
+    void clear() noexcept { std::memset(slots_, 0, slots_count_ * sizeof(slot_t)); }
+    inline bool test(std::size_t i) const noexcept { return slots_[i / bits_per_slot()] & (1ul << (i & bits_mask())); }
+    inline void set(std::size_t i) noexcept { slots_[i / bits_per_slot()] |= (1ul << (i & bits_mask())); }
 
     visits_bitset_gt(visits_bitset_gt&& other) noexcept {
-        u64s_ = other.u64s_;
         slots_ = other.slots_;
-        other.u64s_ = nullptr;
-        other.slots_ = 0;
+        slots_count_ = other.slots_count_;
+        other.slots_ = nullptr;
+        other.slots_count_ = 0;
     }
 
     visits_bitset_gt& operator=(visits_bitset_gt&& other) noexcept {
-        std::swap(u64s_, other.u64s_);
         std::swap(slots_, other.slots_);
+        std::swap(slots_count_, other.slots_count_);
         return *this;
     }
 
 #if defined(USEARCH_IS_WINDOWS)
 
     inline bool atomic_test(std::size_t i) noexcept {
-        slot_t mask{1ul << (i & 63ul)};
-        return InterlockedOr(&u64s_[i / 64], 0) & mask;
+        slot_t mask{1ul << (i & bits_mask())};
+        return InterlockedOr(&slots_[i / bits_per_slot()], 0) & mask;
     }
 
     inline bool atomic_set(std::size_t i) noexcept {
-        slot_t mask{1ul << (i & 63ul)};
-        return InterLockedOr(&u64s_[i / 64], mask) & mask;
+        slot_t mask{1ul << (i & bits_mask())};
+        return InterLockedOr(&slots_[i / bits_per_slot()], mask) & mask;
     }
 
     inline void atomic_reset(std::size_t i) noexcept {
-        slot_t mask{1ul << (i & 63ul)};
-        InterLockedAnd((LONG volatile*)&u64s_[i / 64], ~mask);
+        slot_t mask{1ul << (i & bits_mask())};
+        InterLockedAnd((LONG volatile*)&slots_[i / bits_per_slot()], ~mask);
     }
 
 #else
 
     inline bool atomic_test(std::size_t i) noexcept {
-        slot_t mask{1ul << (i & 63ul)};
-        return __atomic_load_n(&u64s_[i / 64], __ATOMIC_RELAXED) & mask;
+        slot_t mask{1ul << (i & bits_mask())};
+        return __atomic_load_n(&slots_[i / bits_per_slot()], __ATOMIC_RELAXED) & mask;
     }
 
     inline bool atomic_set(std::size_t i) noexcept {
-        slot_t mask{1ul << (i & 63ul)};
-        return __atomic_fetch_or(&u64s_[i / 64], mask, __ATOMIC_ACQUIRE) & mask;
+        slot_t mask{1ul << (i & bits_mask())};
+        return __atomic_fetch_or(&slots_[i / bits_per_slot()], mask, __ATOMIC_ACQUIRE) & mask;
     }
 
     inline void atomic_reset(std::size_t i) noexcept {
-        slot_t mask{1ul << (i & 63ul)};
-        __atomic_fetch_and(&u64s_[i / 64], ~mask, __ATOMIC_RELEASE);
+        slot_t mask{1ul << (i & bits_mask())};
+        __atomic_fetch_and(&slots_[i / bits_per_slot()], ~mask, __ATOMIC_RELEASE);
     }
 
 #endif
@@ -732,7 +736,7 @@ class usearch_pack_m uint40_t {
     inline uint40_t() noexcept { std::memset(octets, 0, 5); }
     inline uint40_t(std::uint32_t n) noexcept { std::memcpy(octets + 1, (char*)&n, 4), octets[0] = 0; }
     inline uint40_t(std::uint64_t n) noexcept { std::memcpy(octets, (char*)&n + 3, 5); }
-#if defined(USEARCH_IS_CLANG)
+#if defined(USEARCH_IS_CLANG) && defined(USEARCH_IS_APPLE)
     inline uint40_t(std::size_t n) noexcept { std::memcpy(octets, (char*)&n + 3, 5); }
 #endif
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "usearch",
-    "version": "0.9.2",
+    "version": "0.9.4",
     "description": "Smaller & Faster Single-File Vector Search Engine from Unum",
     "author": "Ashot Vardanian",
     "license": "Apache 2.0",

package/pyproject.toml

@@ -46,3 +46,4 @@ before-build = [
     "git submodule update --init --recursive"
 ]
 archs = ["x86", "AMD64"]
+skip = ["*win32*"]

package/setup.py

@@ -1,7 +1,7 @@
 import os
 import sys
-import platform
 from setuptools import setup
+
 from pybind11.setup_helpers import Pybind11Extension
 
 
@@ -22,11 +22,6 @@ if sys.platform == 'darwin':
 if sys.platform == 'win32':
     compile_args = ['/std:c++14', '/O2']
 
-if platform.machine() == 'arm64':
-    compile_args.append('-march=armv8.2-a+simd+fp16+fp16fml+dotprod')
-elif platform.machine() in ('i386', 'AMD64', 'x86_64'):
-    compile_args.append('-march=haswell')
-
 ext_modules = [
     Pybind11Extension(
         'usearch.index',
@@ -58,16 +53,21 @@ setup(
     license='Apache-2.0',
 
     classifiers=[
-        'Development Status :: 4 - Beta',
+        'Development Status :: 5 - Production/Stable',
 
         'Natural Language :: English',
         'Intended Audience :: Developers',
         'Intended Audience :: Information Technology',
         'License :: OSI Approved :: Apache Software License',
 
+        'Programming Language :: C++',
         'Programming Language :: Python :: 3 :: Only',
         'Programming Language :: Python :: Implementation :: CPython',
-        'Programming Language :: C++',
+        'Programming Language :: Java',
+        'Programming Language :: JavaScript',
+        'Programming Language :: Objective C',
+        'Programming Language :: Rust',
+        'Programming Language :: Other',
 
         'Operating System :: MacOS',
         'Operating System :: Unix',

package/src/punned.hpp

@@ -595,7 +595,7 @@ class punned_gt {
         if (casted)
             vector_data = casted_data, vector_bytes = casted_vector_bytes_;
 
-        return index_->search_around(hint, {vector_data, vector_bytes}, wanted, config);
+        return index_->search_around(static_cast<id_t>(hint), {vector_data, vector_bytes}, wanted, config);
     }
 
     template <typename scalar_at> add_result_t add_(label_t label, scalar_at const* vector, cast_t const& cast) {