usearch 0.11.1 → 0.12.1

package/java/cloud/unum/usearch/Index.java

@@ -133,7 +133,7 @@ public class Index {
   }
 
   public static void main(String[] args) {
-    Index index = new Index.Config().metric("cos").build();
+    Index index = new Index.Config().metric("cos").dimensions(100).build();
     index.size();
   }
 

package/java/cloud/unum/usearch/cloud_unum_usearch_Index.cpp

@@ -10,9 +10,13 @@ using namespace unum::usearch;
 using namespace unum;
 
 using label_t = jint;
+using span_t = span_gt<float>;
 using distance_t = punned_distance_t;
 using punned_t = punned_gt<label_t>;
-using span_t = span_gt<float>;
+
+using add_result_t = typename punned_t::add_result_t;
+using search_result_t = typename punned_t::search_result_t;
+using serialization_result_t = typename punned_t::serialization_result_t;
 
 JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1create( //
     JNIEnv* env, jclass,                                         //
@@ -25,13 +29,10 @@ JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1create( //
     char const* accuracy_cstr{};
     try {
 
-        config_t config;
+        index_config_t config;
         config.expansion_add = static_cast<std::size_t>(expansion_add);
         config.expansion_search = static_cast<std::size_t>(expansion_search);
         config.connectivity = static_cast<std::size_t>(connectivity);
-        config.max_elements = static_cast<std::size_t>(capacity);
-        config.max_threads_add = std::thread::hardware_concurrency();
-        config.max_threads_search = std::thread::hardware_concurrency();
 
         metric_cstr = (*env).GetStringUTFChars(metric, 0);
         std::size_t metric_length = (*env).GetStringUTFLength(metric);
@@ -39,11 +40,17 @@ JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1create( //
         std::size_t accuracy_length = (*env).GetStringUTFLength(accuracy);
 
         accuracy_t accuracy = accuracy_from_name(accuracy_cstr, accuracy_length);
-        punned_t index = index_from_name<punned_t>( //
-            metric_cstr, metric_length, static_cast<std::size_t>(dimensions), accuracy, config);
+        common_metric_kind_t metric_kind = common_metric_from_name(metric_cstr, metric_length);
+        punned_t index = make_punned<punned_t>(metric_kind, static_cast<std::size_t>(dimensions), accuracy, config);
+        if (!index.reserve(static_cast<std::size_t>(capacity))) {
+            jclass jc = (*env).FindClass("java/lang/Error");
+            if (jc)
+                (*env).ThrowNew(jc, "Failed to reserve desired capacity!");
+        } else {
+            punned_t* result_ptr = new punned_t(std::move(index));
+            std::memcpy(&result, &result_ptr, sizeof(jlong));
+        }
 
-        punned_t* result_ptr = new punned_t(std::move(index));
-        std::memcpy(&result, &result_ptr, sizeof(jlong));
     } catch (...) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
@@ -56,11 +63,8 @@ JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1create( //
 }
 
 JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1save(JNIEnv* env, jclass, jlong c_ptr, jstring path) {
-    char const* path_cstr{};
-    try {
-        path_cstr = (*env).GetStringUTFChars(path, 0);
-        reinterpret_cast<punned_t*>(c_ptr)->save(path_cstr);
-    } catch (...) {
+    char const* path_cstr = (*env).GetStringUTFChars(path, 0);
+    if (!reinterpret_cast<punned_t*>(c_ptr)->save(path_cstr)) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
             (*env).ThrowNew(jc, "Failed to dump vector index to path!");
@@ -69,11 +73,8 @@ JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1save(JNIEnv* env, jclass
 }
 
 JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1load(JNIEnv* env, jclass, jlong c_ptr, jstring path) {
-    char const* path_cstr{};
-    try {
-        path_cstr = (*env).GetStringUTFChars(path, 0);
-        reinterpret_cast<punned_t*>(c_ptr)->load(path_cstr);
-    } catch (...) {
+    char const* path_cstr = (*env).GetStringUTFChars(path, 0);
+    if (!reinterpret_cast<punned_t*>(c_ptr)->load(path_cstr)) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
             (*env).ThrowNew(jc, "Failed to load vector index from path!");
@@ -82,11 +83,8 @@ JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1load(JNIEnv* env, jclass
 }
 
 JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1view(JNIEnv* env, jclass, jlong c_ptr, jstring path) {
-    char const* path_cstr{};
-    try {
-        path_cstr = (*env).GetStringUTFChars(path, 0);
-        reinterpret_cast<punned_t*>(c_ptr)->view(path_cstr);
-    } catch (...) {
+    char const* path_cstr = (*env).GetStringUTFChars(path, 0);
+    if (!reinterpret_cast<punned_t*>(c_ptr)->view(path_cstr)) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
             (*env).ThrowNew(jc, "Failed to view vector index from path!");
@@ -115,9 +113,7 @@ JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1capacity(JNIEnv*, jclas
 }
 
 JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1reserve(JNIEnv* env, jclass, jlong c_ptr, jlong capacity) {
-    try {
-        return reinterpret_cast<punned_t*>(c_ptr)->reserve(static_cast<std::size_t>(capacity));
-    } catch (...) {
+    if (!reinterpret_cast<punned_t*>(c_ptr)->reserve(static_cast<std::size_t>(capacity))) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
             (*env).ThrowNew(jc, "Failed to grow vector index!");
@@ -127,13 +123,11 @@ JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1reserve(JNIEnv* env, jcl
 JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1add( //
     JNIEnv* env, jclass, jlong c_ptr, jint label, jfloatArray vector) {
 
-    jfloat* vector_data{};
-    try {
-        vector_data = (*env).GetFloatArrayElements(vector, 0);
-        jsize vector_dims = (*env).GetArrayLength(vector);
-        span_t vector_span = span_t{vector_data, static_cast<std::size_t>(vector_dims)};
-        reinterpret_cast<punned_t*>(c_ptr)->add(label, vector_span);
-    } catch (...) {
+    jfloat* vector_data = (*env).GetFloatArrayElements(vector, 0);
+    jsize vector_dims = (*env).GetArrayLength(vector);
+    span_t vector_span = span_t{vector_data, static_cast<std::size_t>(vector_dims)};
+
+    if (!reinterpret_cast<punned_t*>(c_ptr)->add(label, vector_span)) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
             (*env).ThrowNew(jc, "Failed to insert a new point in vector index!");
@@ -153,21 +147,19 @@ JNIEXPORT jintArray JNICALL Java_cloud_unum_usearch_Index_c_1search( //
     if (matches_data == NULL)
         return NULL;
 
-    jfloat* vector_data{};
-    std::size_t found{};
-    try {
-        vector_data = (*env).GetFloatArrayElements(vector, 0);
-        jsize vector_dims = (*env).GetArrayLength(vector);
-        span_t vector_span = span_t{vector_data, static_cast<std::size_t>(vector_dims)};
-        found = reinterpret_cast<punned_t*>(c_ptr)
-                    ->search(vector_span, static_cast<std::size_t>(wanted))
-                    .dump_to(matches_data, NULL);
+    jfloat* vector_data = (*env).GetFloatArrayElements(vector, 0);
+    jsize vector_dims = (*env).GetArrayLength(vector);
+    span_t vector_span = span_t{vector_data, static_cast<std::size_t>(vector_dims)};
+    search_result_t result = reinterpret_cast<punned_t*>(c_ptr)->search(vector_span, static_cast<std::size_t>(wanted));
+    if (result) {
+        std::size_t found = result.dump_to(matches_data, NULL);
         (*env).SetIntArrayRegion(matches, 0, found, matches_data);
-    } catch (...) {
+    } else {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
             (*env).ThrowNew(jc, "Failed to find in vector index!");
     }
+
     (*env).ReleaseFloatArrayElements(vector, vector_data, 0);
     std::free(matches_data);
     return matches;

package/javascript/lib.cpp

@@ -87,9 +87,10 @@ Index::Index(Napi::CallbackInfo const& ctx) : Napi::ObjectWrap<Index>(ctx) {
     Napi::Object params = ctx[0].As<Napi::Object>();
     std::size_t dimensions = params.Has("dimensions") ? params.Get("dimensions").As<Napi::Number>().Uint32Value() : 0;
 
-    config_t config;
+    index_config_t config;
+    index_limits_t limits;
     if (params.Has("capacity"))
-        config.max_elements = params.Get("capacity").As<Napi::Number>().Uint32Value();
+        limits.elements = params.Get("capacity").As<Napi::Number>().Uint32Value();
     if (params.Has("connectivity"))
         config.connectivity = params.Get("connectivity").As<Napi::Number>().Uint32Value();
 
@@ -105,8 +106,7 @@ Index::Index(Napi::CallbackInfo const& ctx) : Napi::ObjectWrap<Index>(ctx) {
         else if (accuracy_str == "f8")
             accuracy = accuracy_t::f8_k;
         else {
-            Napi::TypeError::New(env, "Supported metrics are: [ip, cos, l2sq, haversine]")
-                .ThrowAsJavaScriptException();
+            Napi::TypeError::New(env, "Supported metrics are: [ip, cos, l2sq, haversine]").ThrowAsJavaScriptException();
             return;
         }
     }
@@ -120,23 +120,26 @@ Index::Index(Napi::CallbackInfo const& ctx) : Napi::ObjectWrap<Index>(ctx) {
                 return;
             }
             native_.reset(new punned_t(punned_t::l2sq(dimensions, accuracy, config)));
+            native_->reserve(limits);
         } else if (name == "ip" || name == "inner" || name == "dot") {
             if (!dimensions) {
                 Napi::TypeError::New(env, "Please define the number of dimensions").ThrowAsJavaScriptException();
                 return;
             }
             native_.reset(new punned_t(punned_t::ip(dimensions, accuracy, config)));
+            native_->reserve(limits);
         } else if (name == "cos" || name == "angular") {
             if (!dimensions) {
                 Napi::TypeError::New(env, "Please define the number of dimensions").ThrowAsJavaScriptException();
                 return;
             }
             native_.reset(new punned_t(punned_t::cos(dimensions, accuracy, config)));
+            native_->reserve(limits);
         } else if (name == "haversine") {
             native_.reset(new punned_t(punned_t::haversine(accuracy, config)));
+            native_->reserve(limits);
         } else {
-            Napi::TypeError::New(env, "Supported metrics are: [ip, cos, l2sq, haversine]")
-                .ThrowAsJavaScriptException();
+            Napi::TypeError::New(env, "Supported metrics are: [ip, cos, l2sq, haversine]").ThrowAsJavaScriptException();
             return;
         }
     } else {
@@ -145,6 +148,7 @@ Index::Index(Napi::CallbackInfo const& ctx) : Napi::ObjectWrap<Index>(ctx) {
             return;
         }
         native_.reset(new punned_t(punned_t::ip(dimensions, accuracy, config)));
+        native_->reserve(limits);
     }
 }
 

package/javascript/usearch.js

@@ -0,0 +1,3 @@
+const usearch = require('bindings')('usearch');
+
+module.exports = usearch;

package/objc/USearchObjective.mm

@@ -58,7 +58,7 @@ using shared_index_t = std::shared_ptr<punned_t>;
 
 + (instancetype)indexIP:(UInt32)dimensions connectivity:(UInt32)connectivity {
     std::size_t dims = static_cast<std::size_t>(dimensions);
-    config_t config;
+    index_config_t config;
 
     config.connectivity = static_cast<std::size_t>(connectivity);
     shared_index_t ptr = std::make_shared<punned_t>(punned_t::ip(dims, accuracy_t::f32_k, config));
@@ -67,7 +67,7 @@ using shared_index_t = std::shared_ptr<punned_t>;
 
 + (instancetype)indexL2sq:(UInt32)dimensions connectivity:(UInt32)connectivity {
     std::size_t dims = static_cast<std::size_t>(dimensions);
-    config_t config;
+    index_config_t config;
 
     config.connectivity = static_cast<std::size_t>(connectivity);
     shared_index_t ptr = std::make_shared<punned_t>(punned_t::l2sq(dims, accuracy_t::f32_k, config));
@@ -75,7 +75,7 @@ using shared_index_t = std::shared_ptr<punned_t>;
 }
 
 + (instancetype)indexHaversine:(UInt32)connectivity {
-    config_t config;
+    index_config_t config;
 
     config.connectivity = static_cast<std::size_t>(connectivity);
     shared_index_t ptr = std::make_shared<punned_t>(punned_t::haversine(accuracy_t::f32_k, config));

package/package.json

@@ -1,9 +1,10 @@
 {
     "name": "usearch",
-    "version": "0.11.1",
+    "version": "0.12.1",
     "description": "Smaller & Faster Single-File Vector Search Engine from Unum",
     "author": "Ashot Vardanian",
     "license": "Apache 2.0",
+    "main": "javascript/usearch.js",
     "repository": {
         "type": "git",
         "url": "https://github.com/unum-cloud/usearch.git"
@@ -23,6 +24,6 @@
         "@semantic-release/exec": "^6.0.3",
         "@semantic-release/git": "^10.0.1",
         "conventional-changelog-eslint": "^3.0.9",
-        "semantic-release": "^21.0.2"
+        "semantic-release": "^21.0.3"
     }
-}
+}