usearch 0.18.3 → 0.18.5

package/Cargo.toml

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

package/conanfile.py

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

package/include/usearch/index.hpp

@@ -269,7 +269,7 @@ template <typename scalar_at = float, typename result_at = scalar_at> struct cos
             ab += result_t(a[i]) * result_t(b[i]), //
                 a2 += square<result_t>(a[i]),      //
                 b2 += square<result_t>(b[i]);
-        return ab ? (1 - ab / (std::sqrt(a2) * std::sqrt(b2))) : 0;
+        return (ab != 0) ? (1 - ab / (std::sqrt(a2) * std::sqrt(b2))) : 0;
     }
 };
 

package/include/usearch/index_punned_dense.hpp

@@ -36,7 +36,7 @@ struct cos_f8_t {
             a2 += square(ai);
             b2 += square(bi);
         }
-        return 1.f - ab / (std::sqrt(a2) * std::sqrt(b2));
+        return (ab != 0) ? (1.f - ab / (std::sqrt(a2) * std::sqrt(b2))) : 0;
     }
 };
 
@@ -328,7 +328,7 @@ class index_punned_dense_gt {
         std::size_t vector_bytes = dimensions_ * sizeof(scalar_at);
 
         byte_t* casted_data = cast_buffer_.data() + casted_vector_bytes_ * config.thread;
-        bool casted = cast(vector_data, vector_bytes, casted_data);
+        bool casted = cast(vector_data, dimensions_, casted_data);
         if (casted)
             vector_data = casted_data, vector_bytes = casted_vector_bytes_, config.store_vector = true;
 
@@ -349,7 +349,7 @@ class index_punned_dense_gt {
         std::size_t vector_bytes = dimensions_ * sizeof(scalar_at);
 
         byte_t* casted_data = cast_buffer_.data() + casted_vector_bytes_ * config.thread;
-        bool casted = cast(vector_data, vector_bytes, casted_data);
+        bool casted = cast(vector_data, dimensions_, casted_data);
         if (casted)
             vector_data = casted_data, vector_bytes = casted_vector_bytes_;
 
@@ -365,7 +365,7 @@ class index_punned_dense_gt {
         std::size_t vector_bytes = dimensions_ * sizeof(scalar_at);
 
         byte_t* casted_data = cast_buffer_.data() + casted_vector_bytes_ * config.thread;
-        bool casted = cast(vector_data, vector_bytes, casted_data);
+        bool casted = cast(vector_data, dimensions_, casted_data);
         if (casted)
             vector_data = casted_data, vector_bytes = casted_vector_bytes_;
 
@@ -388,10 +388,10 @@ class index_punned_dense_gt {
         }
         member_citerator_t iterator = typed_->cbegin() + id;
         member_cref_t member = *iterator;
-        byte_t const* casted_vector = reinterpret_cast<byte_t const*>(member.vector.data());
-        bool casted = cast(casted_vector, casted_vector_bytes_, (byte_t*)reconstructed);
+        byte_t const* punned_vector = reinterpret_cast<byte_t const*>(member.vector.data());
+        bool casted = cast(punned_vector, dimensions_, (byte_t*)reconstructed);
         if (!casted)
-            std::memcpy(reconstructed, casted_vector, casted_vector_bytes_);
+            std::memcpy(reconstructed, punned_vector, casted_vector_bytes_);
         return true;
     }
 
@@ -505,30 +505,27 @@ class index_punned_dense_gt {
     static metric_and_meta_t ip_metric_f32_(std::size_t dimensions) {
         (void)dimensions;
 #if USEARCH_USE_SIMSIMD
-#if defined(USEARCH_DEFINED_X86)
-        if (dimensions % 4 == 0)
+        if (hardware_supports(isa_t::avx2_k) && dimensions % 4 == 0)
             return {
                 pun_metric_<simsimd_f32_t>([=](simsimd_f32_t const* a, simsimd_f32_t const* b) {
                     return 1.f - simsimd_dot_f32x4avx2(a, b, dimensions);
                 }),
                 isa_t::avx2_k,
             };
-#elif defined(USEARCH_DEFINED_ARM)
-        if (supports_arm_sve())
+        if (hardware_supports(isa_t::sve_k))
             return {
                 pun_metric_<simsimd_f32_t>([=](simsimd_f32_t const* a, simsimd_f32_t const* b) {
                     return 1.f - simsimd_dot_f32sve(a, b, dimensions);
                 }),
                 isa_t::sve_k,
             };
-        if (dimensions % 4 == 0)
+        if (hardware_supports(isa_t::neon_k) && dimensions % 4 == 0)
             return {
                 pun_metric_<simsimd_f32_t>([=](simsimd_f32_t const* a, simsimd_f32_t const* b) {
                     return 1.f - simsimd_dot_f32x4neon(a, b, dimensions);
                 }),
                 isa_t::neon_k,
             };
-#endif
 #endif
         return pun_metric_<f32_t>(ip_gt<f32_t>{});
     }
@@ -536,23 +533,20 @@ class index_punned_dense_gt {
     static metric_and_meta_t cos_metric_f16_(std::size_t dimensions) {
         (void)dimensions;
 #if USEARCH_USE_SIMSIMD
-#if defined(USEARCH_DEFINED_X86)
-        if (dimensions % 16 == 0)
+        if (hardware_supports(isa_t::avx512_k) && dimensions % 16 == 0)
             return {
                 pun_metric_<simsimd_f16_t>([=](simsimd_f16_t const* a, simsimd_f16_t const* b) {
                     return 1.f - simsimd_cos_f16x16avx512(a, b, dimensions);
                 }),
                 isa_t::avx512_k,
             };
-#elif defined(USEARCH_DEFINED_ARM)
-        if (dimensions % 4 == 0)
+        if (hardware_supports(isa_t::neon_k) && dimensions % 4 == 0)
             return {
                 pun_metric_<simsimd_f16_t>([=](simsimd_f16_t const* a, simsimd_f16_t const* b) {
                     return 1.f - simsimd_cos_f16x4neon(a, b, dimensions);
                 }),
                 isa_t::neon_k,
             };
-#endif
 #endif
         return pun_metric_<f16_t>(cos_gt<f16_t, f32_t>{});
     }
@@ -560,14 +554,12 @@ class index_punned_dense_gt {
     static metric_and_meta_t cos_metric_f8_(std::size_t dimensions) {
         (void)dimensions;
 #if USEARCH_USE_SIMSIMD
-#if defined(USEARCH_DEFINED_ARM)
-        if (dimensions % 16 == 0)
+        if (hardware_supports(isa_t::neon_k) && dimensions % 16 == 0)
             return {
                 pun_metric_<int8_t>(
                     [=](int8_t const* a, int8_t const* b) { return 1.f - simsimd_cos_i8x16neon(a, b, dimensions); }),
                 isa_t::neon_k,
             };
-#endif
 #endif
         return pun_metric_<f8_bits_t>(cos_f8_t{dimensions});
     }

package/include/usearch/index_punned_helpers.hpp

@@ -76,13 +76,23 @@ inline char const* isa_name(isa_t isa) noexcept {
     }
 }
 
-inline bool supports_arm_sve() noexcept {
-#if defined(USEARCH_DEFINED_ARM)
-#if defined(USEARCH_DEFINED_LINUX)
+inline bool hardware_supports(isa_t isa) noexcept {
+#if defined(USEARCH_DEFINED_ARM) && defined(USEARCH_DEFINED_LINUX)
     unsigned long capabilities = getauxval(AT_HWCAP);
-    if (capabilities & HWCAP_SVE)
-        return true;
+    switch (isa) {
+    case isa_t::neon_k: return capabilities & HWCAP_NEON;
+    case isa_t::sve_k: return capabilities & HWCAP_SVE;
+    default: return false;
+    }
 #endif
+
+#if defined(USEARCH_DEFINED_X86) && defined(USEARCH_DEFINED_GCC)
+    __builtin_cpu_init();
+    switch (isa) {
+    case isa_t::avx2_k: return __builtin_cpu_supports("avx2");
+    case isa_t::avx512_k: return __builtin_cpu_supports("avx512f");
+    default: return false;
+    }
 #endif
     return false;
 }
@@ -482,12 +492,11 @@ using memory_mapping_allocator_t = aligned_allocator_t;
 #endif
 
 template <typename from_scalar_at, typename to_scalar_at> struct cast_gt {
-    inline 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 dimensions, 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::size_t size_input = bytes_in_input / sizeof(from_scalar_at);
         auto converter = [](from_scalar_at from) { return to_scalar_at(from); };
-        std::transform(typed_input, typed_input + size_input, typed_output, converter);
+        std::transform(typed_input, typed_input + dimensions, typed_output, converter);
         return true;
     }
 };
@@ -513,23 +522,21 @@ template <> struct cast_gt<b1x8_t, b1x8_t> {
 };
 
 template <typename from_scalar_at> struct cast_gt<from_scalar_at, b1x8_t> {
-    inline 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 dimensions, byte_t* output) const {
         from_scalar_at const* typed_input = reinterpret_cast<from_scalar_at const*>(input);
         unsigned char* typed_output = reinterpret_cast<unsigned char*>(output);
-        std::size_t size_input = bytes_in_input / sizeof(from_scalar_at);
-        for (std::size_t i = 0; i != size_input; ++i)
-            typed_output[i / CHAR_BIT] |= bool(typed_input[i]) ? (1 << (i & (CHAR_BIT - 1))) : 0;
+        for (std::size_t i = 0; i != dimensions; ++i)
+            typed_output[i / CHAR_BIT] |= bool(typed_input[i]) ? (128 >> (i & (CHAR_BIT - 1))) : 0;
         return true;
     }
 };
 
 template <typename to_scalar_at> struct cast_gt<b1x8_t, to_scalar_at> {
-    inline 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 dimensions, byte_t* output) const {
         unsigned char const* typed_input = reinterpret_cast<unsigned char const*>(input);
         to_scalar_at* typed_output = reinterpret_cast<to_scalar_at*>(output);
-        std::size_t size_input = bytes_in_input * CHAR_BIT;
-        for (std::size_t i = 0; i != size_input; ++i)
-            typed_output[i] = bool(typed_input[i / CHAR_BIT] & (1 << (i & (CHAR_BIT - 1))));
+        for (std::size_t i = 0; i != dimensions; ++i)
+            typed_output[i] = bool(typed_input[i / CHAR_BIT] & (128 >> (i & (CHAR_BIT - 1))));
         return true;
     }
 };

package/package.json

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

package/python/lib.cpp

@@ -13,6 +13,7 @@
  *  @copyright Copyright (c) 2023
  */
 #define PY_SSIZE_T_CLEAN
+#define NOMINMAX // Some of our dependencies call `std::max(x, y)`, which crashes Windows builds
 #include <thread>
 
 #include <pybind11/numpy.h>
@@ -393,7 +394,8 @@ template <typename index_at> void view_index(index_at& index, std::string const&
 
 template <typename internal_at, typename external_at = internal_at, typename index_at = void>
 py::object get_typed_member(index_at const& index, label_t label) {
-    py::array_t<external_at> result_py(static_cast<Py_ssize_t>(index.scalar_words()));
+    std::size_t result_slots = std::is_same<internal_at, b1x8_t>() ? index.scalar_words() : index.dimensions();
+    py::array_t<external_at> result_py(static_cast<Py_ssize_t>(result_slots));
     auto result_py1d = result_py.template mutable_unchecked<1>();
     if (!index.get(label, (internal_at*)&result_py1d(0)))
         return py::none();

package/python/scripts/bench.py

@@ -4,7 +4,6 @@ import itertools
 from typing import List, Optional, Iterable
 from dataclasses import asdict
 
-import fire
 import numpy as np
 import pandas as pd
 

package/python/scripts/test.py

@@ -5,7 +5,7 @@ import numpy as np
 from usearch.io import load_matrix, save_matrix
 from usearch.eval import recall_members, random_vectors
 
-from usearch.index import Index, SparseIndex, MetricKind, ScalarKind, Matches
+from usearch.index import Index, SparseIndex, MetricKind, ScalarKind, Matches, MetricKindBitwise
 from usearch.index import _normalize_dtype
 from usearch.index import (
     DEFAULT_CONNECTIVITY,
@@ -181,10 +181,13 @@ def test_bitwise_index(bits: int, metric: MetricKind, connectivity: int, batch_s
     index = Index(ndim=bits, metric=metric, connectivity=connectivity)
 
     labels = np.arange(batch_size)
-    bit_vectors = np.random.randint(2, size=(batch_size, bits))
-    bit_vectors = np.packbits(bit_vectors, axis=1)
+    byte_vectors = np.random.randint(2, size=(batch_size, bits))
+    bit_vectors = np.packbits(byte_vectors, axis=1)
 
     index.add(labels, bit_vectors)
+    assert np.allclose(index.get_vectors(labels), byte_vectors, atol=0.1)
+    assert np.alltrue(index.get_vectors(labels, ScalarKind.B1) == bit_vectors)
+    
     index.search(bit_vectors, 10)
 
 

package/setup.py

@@ -9,7 +9,7 @@ compile_args = ['-std=c++11', '-O3']
 link_args = []
 macros_args = [
     ('USEARCH_USE_NATIVE_F16', '0'),
-    ('USEARCH_USE_SIMSIMD', '1'),
+    ('USEARCH_USE_SIMSIMD', '0'),
 ]
 
 if sys.platform == 'linux':