usearch 0.2.0 → 0.2.2

package/javascript/lib.cpp

@@ -9,6 +9,12 @@
  *  @see NodeJS docs: https://nodejs.org/api/addons.html#hello-world
  *
  */
+
+#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
+#define _USE_MATH_DEFINES
+#define NAPI_CPP_EXCEPTIONS
+#endif
+
 #include <napi.h>
 #include <node_api.h>
 
@@ -87,8 +93,8 @@ Index::Index(Napi::CallbackInfo const& ctx) : Napi::ObjectWrap<Index>(ctx) {
             accuracy = accuracy_t::f64_k;
         else if (accuracy_str == "f16")
             accuracy = accuracy_t::f16_k;
-        else if (accuracy_str == "i8q100")
-            accuracy = accuracy_t::i8q100_k;
+        else if (accuracy_str == "f8")
+            accuracy = accuracy_t::f8_k;
         else {
             Napi::TypeError::New(env, "Supported metrics are: [ip, cos, l2_sq, haversine]")
                 .ThrowAsJavaScriptException();

package/objc/USearchObjective.mm

@@ -0,0 +1,150 @@
+#import "USearchObjective.h"
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdocumentation"
+#import "advanced.hpp"
+#pragma clang diagnostic pop
+
+using namespace unum::usearch;
+using namespace unum;
+
+using distance_t = punned_distance_t;
+using native_index_t = auto_index_gt<UInt32>;
+using shared_index_t = std::shared_ptr<native_index_t>;
+
+@interface Index ()
+
+@property (readonly) shared_index_t native;
+
+- (instancetype)initWithIndex:(shared_index_t)native;
+
+@end
+
+@implementation Index
+
+- (instancetype)initWithIndex:(shared_index_t)native {
+    self = [super init];
+    _native = native;
+    return self;
+}
+
+- (Boolean)isEmpty {
+    return _native->size() != 0;
+}
+
+- (UInt32)dimensions {
+    return static_cast<UInt32>(_native->dimensions());
+}
+
+- (UInt32)connectivity {
+    return static_cast<UInt32>(_native->connectivity());
+}
+
+- (UInt32)length {
+    return static_cast<UInt32>(_native->size());
+}
+
+- (UInt32)capacity {
+    return static_cast<UInt32>(_native->capacity());
+}
+
+- (UInt32)expansion_add {
+    return static_cast<UInt32>(_native->config().expansion_add);
+}
+
+- (UInt32)expansion_search {
+    return static_cast<UInt32>(_native->config().expansion_search);
+}
+
++ (instancetype)indexIP:(UInt32)dimensions connectivity:(UInt32)connectivity {
+    std::size_t dims = static_cast<std::size_t>(dimensions);
+    config_t config;
+    config.connectivity = static_cast<std::size_t>(connectivity);
+    shared_index_t ptr = std::make_shared<native_index_t>(native_index_t::ip(dims, accuracy_t::f32_k, config));
+    return [[Index alloc] initWithIndex:ptr];
+}
+
++ (instancetype)indexL2:(UInt32)dimensions connectivity:(UInt32)connectivity {
+    std::size_t dims = static_cast<std::size_t>(dimensions);
+    config_t config;
+    config.connectivity = static_cast<std::size_t>(connectivity);
+    shared_index_t ptr = std::make_shared<native_index_t>(native_index_t::l2(dims, accuracy_t::f32_k, config));
+    return [[Index alloc] initWithIndex:ptr];
+}
+
++ (instancetype)indexHaversine:(UInt32)connectivity {
+    config_t config;
+    config.connectivity = static_cast<std::size_t>(connectivity);
+    shared_index_t ptr = std::make_shared<native_index_t>(native_index_t::haversine(accuracy_t::f32_k, config));
+    return [[Index alloc] initWithIndex:ptr];
+}
+
+- (void)addSingle:(UInt32)label
+           vector:(Float32 const * _Nonnull)vector {
+    _native->add(label, vector);
+}
+
+- (UInt32)searchSingle:(Float32 const* _Nonnull)vector
+                 count:(UInt32)wanted
+                labels:(UInt32* _Nullable)labels
+             distances:(Float32* _Nullable)distances {
+    std::size_t found = _native->search(vector, static_cast<std::size_t>(wanted), labels, distances);
+    return static_cast<UInt32>(found);
+}
+
+- (void)addPrecise:(UInt32)label
+            vector:(Float64 const * _Nonnull)vector {
+    _native->add(label, (f64_t const *)vector);
+}
+
+- (UInt32)searchPrecise:(Float64 const* _Nonnull)vector
+                  count:(UInt32)wanted
+                 labels:(UInt32* _Nullable)labels
+              distances:(Float32* _Nullable)distances {
+    std::size_t found = _native->search((f64_t const *)vector, static_cast<std::size_t>(wanted), labels, distances);
+    return static_cast<UInt32>(found);
+}
+
+- (void)addImprecise:(UInt32)label
+              vector:(void const * _Nonnull)vector {
+    _native->add(label, (f16_converted_t const *)vector);
+}
+
+- (UInt32)searchImprecise:(void const* _Nonnull)vector
+                    count:(UInt32)wanted
+                   labels:(UInt32* _Nullable)labels
+                distances:(Float32* _Nullable)distances {
+    std::size_t found = _native->search((f16_converted_t const *)vector, static_cast<std::size_t>(wanted), labels, distances);
+    return static_cast<UInt32>(found);
+}
+
+- (void)clear { _native->clear(); }
+
+- (void)save:(NSString*)path {
+    char const *path_c = [path UTF8String];
+    if (!path_c)
+        @throw [NSException exceptionWithName:@"Can't save to disk"
+                                       reason:@"The path must be convertible to UTF8"
+                                     userInfo:nil];
+    _native->save(path_c);
+}
+
+- (void)load:(NSString*)path {
+    char const *path_c = [path UTF8String];
+    if (!path_c)
+        @throw [NSException exceptionWithName:@"Can't load from disk"
+                                       reason:@"The path must be convertible to UTF8"
+                                     userInfo:nil];
+    _native->load(path_c);
+}
+
+- (void)view:(NSString*)path {
+    char const *path_c = [path UTF8String];
+    if (!path_c)
+        @throw [NSException exceptionWithName:@"Can't view from disk"
+                                       reason:@"The path must be convertible to UTF8"
+                                     userInfo:nil];
+    _native->view(path_c);
+}
+
+@end

package/objc/include/USearchObjective.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#import <Foundation/Foundation.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+typedef NS_ENUM(NSUInteger, Quantization) {
+    kSinglePrecision,
+    kHalfPrecision,
+    kDoublePrecision
+};
+
+@interface Index: NSObject
+
+@property (readonly) UInt32 dimensions;
+@property (readonly) UInt32 connectivity;
+@property (readonly) UInt32 expansion_add;
+@property (readonly) UInt32 expansion_search;
+
+@property (readonly) UInt32 length;
+@property (readonly) UInt32 capacity;
+@property (readonly) Boolean isEmpty;
+
+- (instancetype)init
+NS_UNAVAILABLE;
+
++ (instancetype)indexIP:(UInt32)dimensions connectivity:(UInt32)connectivity NS_SWIFT_NAME(indexIP(dimensions:connectivity:));
++ (instancetype)indexL2:(UInt32)dimensions connectivity:(UInt32)connectivity NS_SWIFT_NAME(l2(dimensions:connectivity:));
++ (instancetype)indexHaversine:(UInt32)connectivity NS_SWIFT_NAME(indexHaversine(connectivity:));
+
+- (void)addSingle:(UInt32)label
+           vector:(Float32 const* _Nonnull)vector
+NS_SWIFT_NAME(addSingle(label:vector:));
+
+- (UInt32)searchSingle:(Float32 const* _Nonnull)vector
+               count:(UInt32)count
+              labels:(UInt32* _Nullable)labels
+           distances:(Float32* _Nullable)distances
+NS_SWIFT_NAME(searchSingle(vector:count:labels:distances:));
+
+- (void)addPrecise:(UInt32)label
+            vector:(Float64 const* _Nonnull)vector
+NS_SWIFT_NAME(addPrecise(label:vector:));
+
+- (UInt32)searchPrecise:(Float64 const* _Nonnull)vector
+                count:(UInt32)count
+               labels:(UInt32* _Nullable)labels
+            distances:(Float32* _Nullable)distances
+NS_SWIFT_NAME(searchPrecise(vector:count:labels:distances:));
+
+- (void)addImprecise:(UInt32)label
+              vector:(void const* _Nonnull)vector
+NS_SWIFT_NAME(addImprecise(label:vector:));
+
+- (UInt32)searchImprecise:(void const* _Nonnull)vector
+                  count:(UInt32)count
+                 labels:(UInt32* _Nullable)labels
+              distances:(Float32* _Nullable)distances
+NS_SWIFT_NAME(searchImprecise(vector:count:labels:distances:));
+
+
+- (void)save:(NSString*)path NS_SWIFT_NAME(dump(path:));
+- (void)load:(NSString*)path NS_SWIFT_NAME(load(path:));
+- (void)view:(NSString*)path NS_SWIFT_NAME(view(path:));
+- (void)clear NS_SWIFT_NAME(clear());
+
+@end
+
+NS_ASSUME_NONNULL_END

package/package.json

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

package/pyproject.toml

@@ -10,15 +10,15 @@ filterwarnings = ["error"]
 
 [tool.cibuildwheel]
 build-verbosity = 0
+
+skip = ["*musllinux*", "*i686*", "pp*"]
+
+[tool.cibuildwheel.linux]
 before-build = [
     "rm -rf {project}/CMakeCache.txt {project}/build {project}/build_debug {project}/CMakeFiles.txt {project}/_deps",
     "mkdir -p build/usearch",
     "git submodule update --init --recursive"
 ]
-
-skip = ["*musllinux*", "*i686*", "pp*"]
-
-[tool.cibuildwheel.linux]
 manylinux-x86_64-image = "manylinux_2_28"
 manylinux-aarch64-image = "manylinux_2_28"
 
@@ -29,5 +29,19 @@ before-all = [
 repair-wheel-command = "auditwheel repair --lib-sdir . -w {dest_dir} {wheel}"
 
 [tool.cibuildwheel.macos]
+before-build = [
+    "rm -rf {project}/CMakeCache.txt {project}/build {project}/build_debug {project}/CMakeFiles.txt {project}/_deps",
+    "mkdir -p build/usearch",
+    "git submodule update --init --recursive"
+]
 archs = ["x86_64", "universal2", "arm64"]
 repair-wheel-command = "delocate-wheel --require-archs {delocate_archs} -w {dest_dir} -v {wheel}"
+
+
+[tool.cibuildwheel.windows]
+before-build = [
+    "rd /s /q {project}\\CMakeCache.txt {project}\\build {project}\\build_debug {project}\\CMakeFiles.txt {project}\\_deps || echo Done",
+    "md build\\usearch",
+    "git submodule update --init --recursive"
+]
+archs = ["x86", "AMD64"]

package/python/lib.cpp

@@ -137,7 +137,7 @@ static void add_one_to_index(native_index_t& index, label_t label, py::buffer ve
 
     // https://docs.python.org/3/library/struct.html#format-characters
     if (vector_info.format == "e")
-        index.add(label, reinterpret_cast<f16_converted_t const*>(vector_data), 0, copy);
+        index.add(label, reinterpret_cast<f16_bits_t const*>(vector_data), 0, copy);
     else if (vector_info.format == "f")
         index.add(label, reinterpret_cast<float const*>(vector_data), 0, copy);
     else if (vector_info.format == "d")
@@ -179,8 +179,8 @@ static void add_many_to_index(native_index_t& index, py::buffer labels, py::buff
     if (vectors_info.format == "e")
         multithreaded(index.concurrency(), vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
             label_t label = *reinterpret_cast<label_t const*>(labels_data + task_idx * labels_info.strides[0]);
-            f16_converted_t const* vector =
-                reinterpret_cast<f16_converted_t const*>(vectors_data + task_idx * vectors_info.strides[0]);
+            f16_bits_t const* vector =
+                reinterpret_cast<f16_bits_t const*>(vectors_data + task_idx * vectors_info.strides[0]);
             index.add(label, vector, thread_idx, copy);
         });
     else if (vectors_info.format == "f")
@@ -216,7 +216,7 @@ static py::tuple search_one_in_index(native_index_t& index, py::buffer vector, s
     // https://docs.python.org/3/library/struct.html#format-characters
     if (vector_info.format == "e")
         count = index.search( //
-            reinterpret_cast<f16_converted_t const*>(vector_data), wanted, &labels_py1d(0), &distances_py1d(0), 0);
+            reinterpret_cast<f16_bits_t const*>(vector_data), wanted, &labels_py1d(0), &distances_py1d(0), 0);
     else if (vector_info.format == "f")
         count = index.search( //
             reinterpret_cast<float const*>(vector_data), wanted, &labels_py1d(0), &distances_py1d(0), 0);
@@ -272,7 +272,7 @@ static py::tuple search_many_in_index(native_index_t& index, py::buffer vectors,
     // https://docs.python.org/3/library/struct.html#format-characters
     if (vectors_info.format == "e")
         multithreaded(index.concurrency(), vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
-            f16_converted_t const* vector = (f16_converted_t const*)(vectors_data + task_idx * vectors_info.strides[0]);
+            f16_bits_t const* vector = (f16_bits_t const*)(vectors_data + task_idx * vectors_info.strides[0]);
             counts_py1d(task_idx) = static_cast<Py_ssize_t>(
                 index.search(vector, wanted, &labels_py2d(task_idx, 0), &distances_py2d(task_idx, 0), thread_idx));
         });
@@ -371,7 +371,7 @@ void hash_buffer(hash_index_w_meta_t& index, py::buffer vector) {
         throw std::invalid_argument("Array elements must be 16, 32, or 64 bit hashable integers!");
 }
 
-PYBIND11_MODULE(usearch, m) {
+PYBIND11_MODULE(index, m) {
     m.doc() = "Unum USearch Python bindings";
 
     auto i = py::class_<native_index_t>(m, "Index");

package/python/test.py

@@ -1,7 +1,6 @@
 import numpy as np
 
-import usearch
-
+from usearch.index import Index, SetsIndex
 from numba import cfunc, types, carray
 
 # Showcases how to use Numba to JIT-compile similarity measures for USearch.
@@ -29,13 +28,13 @@ vectors = np.random.uniform(
     0, 0.3, (count_vectors, count_dimensions)).astype(np.float32)
 labels = np.array(range(count_vectors), dtype=np.longlong)
 
-index_udf = usearch.Index(ndim=96, metric_pointer=python_dot.address)
+index_udf = Index(ndim=96, metric_pointer=python_dot.address)
 index_udf.add(labels, vectors, copy=True)
 results = index_udf.search(vectors, 10)
 print('found', results[0].shape, results[1].shape, results[2].shape)
 
 
-index = usearch.Index(ndim=96)
+index = Index(ndim=96)
 index.add(labels, vectors, copy=True)
 assert index.ndim == count_dimensions
 assert index.capacity >= count_vectors
@@ -45,7 +44,7 @@ results = index.search(vectors, 10)
 print('found', results[0].shape, results[1].shape, results[2].shape)
 
 
-index_sets = usearch.SetsIndex()
+index_sets = SetsIndex()
 index_sets.add(10, np.array([10, 12, 15], dtype=np.uint32))
 index_sets.add(11, np.array([11, 12, 15, 16], dtype=np.uint32))
 results = index_sets.search(np.array([12, 15], dtype=np.uint32), 20)

package/rust/lib.cpp

@@ -24,9 +24,20 @@ Matches Index::search_in_thread(rust::Slice<float const> vector, size_t count, s
     return results;
 }
 
-void Index::add(uint32_t label, rust::Slice<float const> vector) const { return add_in_thread(label, vector, 0); }
+void Index::add(uint32_t label, rust::Slice<float const> vector) const {
+    index_->add(label, vector.data()); //
+}
+
 Matches Index::search(rust::Slice<float const> vector, size_t count) const {
-    return search_in_thread(vector, count, 0);
+    Matches results;
+    results.labels.reserve(count);
+    results.distances.reserve(count);
+    for (size_t i = 0; i != count; ++i)
+        results.labels.push_back(0), results.distances.push_back(0);
+    results.count = index_->search(vector.data(), count, results.labels.data(), results.distances.data());
+    results.labels.truncate(results.count);
+    results.distances.truncate(results.count);
+    return results;
 }
 
 void Index::reserve(size_t capacity) const { index_->reserve(capacity); }

package/setup.py

@@ -9,11 +9,15 @@ compile_args = ['-std=c++11', '-O3']
 if sys.platform == 'darwin':
     compile_args.append('-mmacosx-version-min=10.13')
 
+if sys.platform == 'win32':
+    compile_args = ['/std:c++14', '/O2']
+
+
 ext_modules = [
     Pybind11Extension(
-        'usearch',
+        'usearch.index',
         ['python/lib.cpp'],
-        extra_compile_args=compile_args,
+        extra_compile_args=compile_args
     ),
 ]
 
@@ -30,7 +34,8 @@ setup(
 
     name=__lib_name__,
     version=__version__,
-    packages=find_packages(),
+    packages=['usearch'],
+    package_dir={'usearch': 'python/usearch'},
 
     description='Smaller & Faster Single-File Vector Search Engine from Unum',
     long_description=long_description,

package/simsimd/include/simsimd/simsimd.h

@@ -255,6 +255,21 @@ inline static simsimd_f32_t simsimd_dot_f32x4avx2(simsimd_f32_t const* a, simsim
 #endif
 }
 
+inline static simsimd_f32_t simsimd_dot_f16x16avx512(simsimd_f16_t const* a, simsimd_f16_t const* b, size_t d) {
+#if defined(__AVX512F__)
+    __m512 ab_vec = _mm512_set1_ps(0);
+    for (size_t i = 0; i != d; i += 16)
+        ab_vec = _mm512_fmadd_ps(                     //
+            _mm512_cvtxph_ps(_mm256_loadu_ph(a + i)), //
+            _mm512_cvtxph_ps(_mm256_loadu_ph(b + i)), //
+            ab_vec);
+    return _mm512_reduce_add_ps(ab_vec);
+#else
+    (void)a, (void)b, (void)d;
+    return 0;
+#endif
+}
+
 inline static int32_t simsimd_dot_i8x16avx2(int8_t const* a, int8_t const* b, size_t d) {
 #if defined(__AVX2__)
     __m256i ab_vec = _mm256_set1_epi32(0);