usearch 0.1.10 → 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.1.10",
+    "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/bench.py

@@ -2,11 +2,11 @@ import datetime
 import numpy as np
 import fire
 
-from usearchh.io import load_matrix
-
 import faiss
 import usearch
 
+import struct
+import numpy as np
 
 def measure(f) -> float:
     a = datetime.datetime.now()
@@ -44,11 +44,23 @@ def main(
     neighbors_mat = load_matrix(neighbors)
     dim = vectors_mat.shape[1]
 
+    # Test FAISS
     index = faiss.IndexHNSWFlat(dim, connectivity)
     index.hnsw.efSearch = expansion_search
     index.hnsw.efConstruction = expansion_add
     bench_faiss(index, vectors_mat, queries_mat, neighbors_mat)
 
+    # Test FAISS with default Product Quantization
+    nlist = 10000  # Number of inverted lists (number of partitions or cells).
+    nsegment = 16  # Number of segments for PQ (number of subquantizers).
+    nbit = 8       # Number of bits to encode each segment.
+    coarse_quantizer = faiss.IndexHNSWFlat(dim, connectivity)
+    index = faiss.IndexIVFPQ(coarse_quantizer, dim, nlist, nsegment, nbit)
+    index.train(vectors_mat)
+    index.nprobe = 10
+    bench_faiss(index, vectors_mat, queries_mat, neighbors_mat)
+
+    # Test USearch `Index`
     index = usearch.Index(
         ndim=dim,
         expansion_add=expansion_add,