usearch 0.1.5 → 0.1.7

package/.gitattributes

@@ -0,0 +1,9 @@
+#
+# https://help.github.com/articles/dealing-with-line-endings/
+#
+# Linux start script should use lf
+/gradlew        text eol=lf
+
+# These are Windows script files and should use crlf
+*.bat           text eol=crlf
+

package/.github/workflows/release.yml

@@ -108,6 +108,28 @@ jobs:
       with:
           registry-token: ${{ secrets.CARGO_REGISTRY_TOKEN }}          
 
+  publish_java:
+    name: Publish Java
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+    steps:
+    - uses: actions/checkout@v3
+    - run: git submodule update --init --recursive
+    - uses: actions/setup-java@v3
+      with:
+        java-version: '11'
+        distribution: 'adopt'
+    - name: Setup Gradle
+      uses: gradle/gradle-build-action@v2    
+    - name: Execute Gradle build
+      run: gradle clean build
+    - name: Publish package
+      run: gradle publish
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
   deploy_docs:
     name: Deploy Docs
     environment: 

package/.vscode/settings.json

@@ -105,5 +105,6 @@
         "ndim",
         "simsimd",
         "usearch"
-    ]
+    ],
+    "java.configuration.updateBuildConfiguration": "interactive"
 }

package/{CMakeListsInstructuons.md → CMakeListsInstructions.md}

@@ -75,13 +75,40 @@ cargo publish
 ### Java
 
 ```sh
-cs java
+gradle clean build
+java -cp . -Djava.library.path=/Users/av/github/usearch/build/libs/usearch/shared java/cloud/unum/usearch/Index.java
+```
+
+Or step by-step:
+
+```sh
+cs java/unum/cloud/usearch
 javac -h . Index.java
 
+# Ubuntu:
+g++ -c -fPIC -I${JAVA_HOME}/include -I${JAVA_HOME}/include/linux cloud_unum_usearch_Index.cpp -o cloud_unum_usearch_Index.o
+g++ -shared -fPIC -o libusearch.so cloud_unum_usearch_Index.o -lc
+
+# Windows
+g++ -c -I%JAVA_HOME%\include -I%JAVA_HOME%\include\win32 cloud_unum_usearch_Index.cpp -o cloud_unum_usearch_Index.o
+g++ -shared -o USearchJNI.dll cloud_unum_usearch_Index.o -Wl,--add-stdcall-alias
+
+# MacOS
+g++ -std=c++11 -c -fPIC \
+    -I../../../../include -I../../../../src -I../../../../fp16/include -I../../../../simsimd/include \
+    -I${JAVA_HOME}/include -I${JAVA_HOME}/include/darwin cloud_unum_usearch_Index.cpp -o cloud_unum_usearch_Index.o
+g++ -dynamiclib -o libusearch.dylib cloud_unum_usearch_Index.o -lc
+# Run linking to that directory
+java -cp . -Djava.library.path=/Users/av/github/usearch/java/cloud/unum/usearch/ Index.java
+java -cp . -Djava.library.path=/Users/av/github/usearch/java cloud.unum.usearch.Index
 ```
 
 ### Wolfram
 
+```sh
+brew install --cask wolfram-engine
+```
+
 ## Benchmarks
 
 ### Datasets

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "usearch"
-version = "0.1.5"
+version = "0.1.7"
 authors = ["Ashot Vardanian <1983160+ashvardanian@users.noreply.github.com>"]
 description = "The Mighty Tiny Vector Search Engine with Automatic Quantization and Hardware Acceleration"
 edition = "2021"

package/README.md

@@ -29,9 +29,11 @@ Compact, yet Powerful<br/>
 - [x] Don't copy vectors if not needed.
 - [x] Bring your threads.
 - [x] Multiple vectors per label.
-- [x] Python bindings: `pip install usearch`
-- [x] JavaScript bindings: `npm install usearch`
-- [x] Rust bindings: `cargo add usearch`
+- [x] Python bindings: `pip install usearch`.
+- [x] JavaScript bindings: `npm install usearch`.
+- [x] Rust bindings: `cargo add usearch`.
+- [x] Java bindings: `cloud.unum:usearch` on GitHub.
+- [ ] GoLang bindings.
 - [ ] Wolfram language bindings.
 - [x] For Linux: GCC, Clang.
 - [x] For MacOS: Apple Clang.
@@ -55,6 +57,10 @@ index.add(/* label: */ 42, /* vector: */ {&vec, 3});
 index.search(
   /* query: */ {&vec, 3}, 10 /* results */,
   /* callback: */ [](std::size_t label, float distance) { });
+
+index.save("index.usearch"); // Serializing to disk
+index.load("index.usearch"); // Reconstructing from disk
+index.view("index.usearch"); // Memory-mapping from disk
 ```
 
 Alternatively fetch it with CMake:
@@ -64,6 +70,8 @@ FetchContent_Declare(usearch GIT_REPOSITORY https://github.com/unum-cloud/usearc
 FetchContent_MakeAvailable(usearch)
 ```
 
+
+
 ## Features
 
 ### Bring your Threads

package/VERSION

@@ -1 +1 @@
-0.1.5
+0.1.7

package/build.gradle

@@ -0,0 +1,127 @@
+import org.gradle.internal.jvm.Jvm
+
+plugins {
+    id 'java-library'
+    id 'cpp'
+    id 'maven-publish'
+}
+
+group "cloud.unum.usearch"
+version = file("VERSION").text.trim()
+
+sourceCompatibility = 1.8
+targetCompatibility = 1.8
+
+repositories {
+    mavenCentral()
+}
+
+sourceSets {
+    main {
+        java {
+            srcDir "java/"
+            exclude "test/"
+        }
+    }
+    test {
+        java {
+            srcDir "java/test"
+        }
+    }
+}
+
+dependencies {
+    testImplementation('junit:junit:4.13.2')
+}
+
+model {
+
+    components {
+        usearch(NativeLibrarySpec) {
+            sources {
+                cpp {
+                    source {
+                        srcDirs "java/cloud/unum/usearch"
+                        include "**/*.cpp"
+                    }
+                    exportedHeaders {
+                        srcDirs "include", "src", "fp16/include", "simsimd/include", "${Jvm.current().javaHome}/include"
+                    }
+                }
+            }
+            binaries.withType(StaticLibraryBinarySpec) {
+                buildable = false
+            }
+            binaries.withType(SharedLibraryBinarySpec) {
+                if (targetPlatform.operatingSystem.linux) {
+                    cppCompiler.args '-I', "${Jvm.current().javaHome}/include/linux"
+                    cppCompiler.args '-D_FILE_OFFSET_BITS=64'
+                } else if (targetPlatform.operatingSystem.macOsX) {
+                    cppCompiler.args '-I', "${Jvm.current().javaHome}/include/darwin"
+                    cppCompiler.args '-D_FILE_OFFSET_BITS=64'
+                }
+                cppCompiler.args '-std=c++11'
+            }
+        }
+    }
+}
+
+test {
+    forkEvery 1
+
+    dependsOn jar
+
+    // Rearrange test classpath, add compiled JAR instead of main classes
+    classpath = project.sourceSets.test.output + configurations.testRuntimeClasspath + files(jar.archiveFile)
+}
+
+jar {
+    dependsOn("usearchSharedLibrary")
+    into("usearch") {
+        from("$buildDir/libs/usearch/shared/libusearch.dylib")
+        from("$buildDir/libs/usearch/shared/libusearch.so")
+    }
+}
+
+publishing {
+    publications {
+        library(MavenPublication) {
+            from components.java
+
+            pom {
+                name = "USearch"
+                description = "The Mighty Tiny Vector Search Engine with Automatic Quantization and Hardware Acceleration"
+                url = "https://github.com/unum-cloud/usearch"
+                licenses {
+                    license {
+                        name = 'The Apache License, Version 2.0'
+                        url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
+                    }
+                }
+            }
+        }
+    }
+
+    // Publishing to GitHub is much easier ;)
+    // repositories {
+    //     maven {
+    //         name = "OSSRH"
+    //         url = "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
+    //         credentials {
+    //             username = System.getenv("MAVEN_USERNAME")
+    //             password = System.getenv("MAVEN_PASSWORD")
+    //         }
+    //     }
+    // }
+
+    repositories {
+        maven {
+            name = "GitHubPackages"
+            url = "https://maven.pkg.github.com/unum-cloud/usearch"
+            credentials {
+                username = System.getenv("GITHUB_ACTOR")
+                password = System.getenv("GITHUB_TOKEN")
+            }
+        }
+    }
+}

package/include/usearch/usearch.hpp

@@ -7,21 +7,25 @@
  *  @copyright Copyright (c) 2023
  */
 #pragma once
-#include <atomic>
-#include <bitset>  // `std::bitset`
-#include <climits> // `CHAR_BIT`
-#include <cmath>   // `std::sqrt`
-#include <cstring> // `std::memset`
-#include <mutex>
-#include <random>
-#include <utility> // `std::exchange`
-#include <vector>
-
+#include <algorithm> // `std::sort_heap`
+#include <atomic>    // `std::atomic`
+#include <bitset>    // `std::bitset`
+#include <climits>   // `CHAR_BIT`
+#include <cmath>     // `std::sqrt`
+#include <cstring>   // `std::memset`
+#include <mutex>     // `std::unique_lock` - replacement candidate
+#include <random>    // `std::default_random_engine` - replacement candidate
+#include <unistd.h>  // `open`, `close`
+#include <utility>   // `std::exchange`
+#include <vector>    // `std::vector`
+
+#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
+#else
 #include <fcntl.h>    // `fallocate`
 #include <stdlib.h>   // `posix_memalign`
 #include <sys/mman.h> // `mmap`
 #include <sys/stat.h> // `fstat` for file size
-#include <unistd.h>   // `open`, `close`
+#endif
 
 #if defined(__GNUC__)
 // https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html
@@ -965,6 +969,9 @@ class index_gt {
      *  Compatibility: Linux, MacOS.
      */
     void view(char const* file_path) noexcept(false) {
+#if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
+        throw std::logic_error("Memory-mapping is not yet available for Windows");
+#else
         state_t state;
         int open_flags = O_RDONLY;
 #if __linux__
@@ -1012,6 +1019,7 @@ class index_gt {
         }
 
         viewed_file_descriptor_ = descriptor;
+#endif
     }
 
 #pragma endregion

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

@@ -0,0 +1,166 @@
+package cloud.unum.usearch;
+
+import java.io.File;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+import java.io.InputStream;
+
+/**
+ * @brief Java bindings for Unum USearch.
+ * 
+ * @see Tutorials:
+ *      https://nachtimwald.com/2017/06/06/wrapping-a-c-library-in-java/
+ *      https://www3.ntu.edu.sg/home/ehchua/programming/java/javanativeinterface.html
+ */
+public class Index {
+
+  private long c_ptr = 0;
+
+  public Index(String metric, String accuracy, //
+      long dimensions, long capacity, long connectivity, //
+      long expansion_add, long expansion_search) {
+    c_ptr = c_create(
+        metric,
+        accuracy,
+        dimensions,
+        capacity,
+        connectivity,
+        expansion_add,
+        expansion_search);
+  }
+
+  public long size() {
+    return c_size(c_ptr);
+  }
+
+  public long connectivity() {
+    return c_connectivity(c_ptr);
+  }
+
+  public long dimensions() {
+    return c_dimensions(c_ptr);
+  }
+
+  public long capacity() {
+    return c_capacity(c_ptr);
+  }
+
+  public void reserve(long capacity) {
+    c_reserve(c_ptr, capacity);
+  }
+
+  public void add(int label, float vector[]) {
+    c_add(c_ptr, label, vector);
+  }
+
+  public int[] search(float vector[], long count) {
+    return c_search(c_ptr, vector, count);
+  }
+
+  public void save(String path) {
+    c_save(c_ptr, path);
+  }
+
+  public void load(String path) {
+    c_load(c_ptr, path);
+  }
+
+  public void view(String path) {
+    c_view(c_ptr, path);
+  }
+
+  public static class Config {
+    private String _metric = "ip";
+    private String _accuracy = "f32";
+    private long _dimensions = 0;
+    private long _capacity = 0;
+    private long _connectivity = 0;
+    private long _expansion_add = 0;
+    private long _expansion_search = 0;
+
+    public Config() {
+    }
+
+    public Index build() {
+      return new Index(
+          _metric,
+          _accuracy,
+          _dimensions,
+          _capacity,
+          _connectivity,
+          _expansion_add,
+          _expansion_search);
+    }
+
+    public Config metric(String _metric) {
+      this._metric = _metric;
+      return this;
+    }
+
+    public Config accuracy(String _accuracy) {
+      this._accuracy = _accuracy;
+      return this;
+    }
+
+    public Config dimensions(long _dimensions) {
+      this._dimensions = _dimensions;
+      return this;
+    }
+
+    public Config capacity(long _capacity) {
+      this._capacity = _capacity;
+      return this;
+    }
+
+    public Config connectivity(long _connectivity) {
+      this._connectivity = _connectivity;
+      return this;
+    }
+
+    public Config expansion_add(long _expansion_add) {
+      this._expansion_add = _expansion_add;
+      return this;
+    }
+
+    public Config expansion_search(long _expansion_search) {
+      this._expansion_search = _expansion_search;
+      return this;
+    }
+  }
+
+  static {
+    System.loadLibrary("usearch");
+  }
+
+  public static void main(String[] args) {
+    Index index = new Index.Config().metric("cos").build();
+    index.size();
+  }
+
+  private static native long c_create(//
+      String metric, String accuracy, //
+      long dimensions, long capacity, long connectivity, //
+      long expansion_add, long expansion_search);
+
+  private static native void c_destroy(long ptr);
+
+  private static native long c_size(long ptr);
+
+  private static native long c_connectivity(long ptr);
+
+  private static native long c_dimensions(long ptr);
+
+  private static native long c_capacity(long ptr);
+
+  private static native void c_reserve(long ptr, long capacity);
+
+  private static native void c_add(long ptr, int label, float vector[]);
+
+  private static native int[] c_search(long ptr, float vector[], long count);
+
+  private static native void c_save(long ptr, String path);
+
+  private static native void c_load(long ptr, String path);
+
+  private static native void c_view(long ptr, String path);
+}

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

@@ -0,0 +1,173 @@
+#include <jni.h>
+
+#include "cloud_unum_usearch_Index.h"
+
+#include <thread>
+
+#include "advanced.hpp"
+
+using namespace unum::usearch;
+using namespace unum;
+
+using label_t = jint;
+using distance_t = punned_distance_t;
+using native_index_t = auto_index_gt<label_t>;
+using span_t = span_gt<float>;
+
+JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1create( //
+    JNIEnv* env, jclass,                                         //
+    jstring metric, jstring accuracy,                            //
+    jlong dimensions, jlong capacity, jlong connectivity,        //
+    jlong expansion_add, jlong expansion_search) {
+
+    jlong result{};
+    char const* metric_cstr{};
+    char const* accuracy_cstr{};
+    try {
+
+        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);
+        accuracy_cstr = (*env).GetStringUTFChars(accuracy, 0);
+        std::size_t accuracy_length = (*env).GetStringUTFLength(accuracy);
+
+        accuracy_t accuracy = accuracy_from_name(accuracy_cstr, accuracy_length);
+        native_index_t index = index_from_name<native_index_t>( //
+            metric_cstr, metric_length, static_cast<std::size_t>(dimensions), accuracy, config);
+
+        native_index_t* result_ptr = new native_index_t(std::move(index));
+        std::memcpy(&result, &result_ptr, sizeof(jlong));
+    } catch (...) {
+        jclass jc = (*env).FindClass("java/lang/Error");
+        if (jc)
+            (*env).ThrowNew(jc, "Failed to initialize the vector index!");
+    }
+
+    (*env).ReleaseStringUTFChars(metric, metric_cstr);
+    (*env).ReleaseStringUTFChars(accuracy, accuracy_cstr);
+    return result;
+}
+
+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<native_index_t*>(c_ptr)->save(path_cstr);
+    } catch (...) {
+        jclass jc = (*env).FindClass("java/lang/Error");
+        if (jc)
+            (*env).ThrowNew(jc, "Failed to dump vector index to path!");
+    }
+    (*env).ReleaseStringUTFChars(path, path_cstr);
+}
+
+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<native_index_t*>(c_ptr)->load(path_cstr);
+    } catch (...) {
+        jclass jc = (*env).FindClass("java/lang/Error");
+        if (jc)
+            (*env).ThrowNew(jc, "Failed to load vector index from path!");
+    }
+    (*env).ReleaseStringUTFChars(path, path_cstr);
+}
+
+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<native_index_t*>(c_ptr)->view(path_cstr);
+    } catch (...) {
+        jclass jc = (*env).FindClass("java/lang/Error");
+        if (jc)
+            (*env).ThrowNew(jc, "Failed to view vector index from path!");
+    }
+    (*env).ReleaseStringUTFChars(path, path_cstr);
+}
+
+JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1destroy(JNIEnv*, jclass, jlong c_ptr) {
+    delete reinterpret_cast<native_index_t*>(c_ptr);
+}
+
+JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1size(JNIEnv*, jclass, jlong c_ptr) {
+    return reinterpret_cast<native_index_t*>(c_ptr)->size();
+}
+
+JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1connectivity(JNIEnv*, jclass, jlong c_ptr) {
+    return reinterpret_cast<native_index_t*>(c_ptr)->connectivity();
+}
+
+JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1dimensions(JNIEnv*, jclass, jlong c_ptr) {
+    return reinterpret_cast<native_index_t*>(c_ptr)->dimensions();
+}
+
+JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1capacity(JNIEnv*, jclass, jlong c_ptr) {
+    return reinterpret_cast<native_index_t*>(c_ptr)->capacity();
+}
+
+JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1reserve(JNIEnv* env, jclass, jlong c_ptr, jlong capacity) {
+    try {
+        return reinterpret_cast<native_index_t*>(c_ptr)->reserve(static_cast<std::size_t>(capacity));
+    } catch (...) {
+        jclass jc = (*env).FindClass("java/lang/Error");
+        if (jc)
+            (*env).ThrowNew(jc, "Failed to grow vector index!");
+    }
+}
+
+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<native_index_t*>(c_ptr)->add(label, vector_span);
+    } catch (...) {
+        jclass jc = (*env).FindClass("java/lang/Error");
+        if (jc)
+            (*env).ThrowNew(jc, "Failed to insert a new point in vector index!");
+    }
+    (*env).ReleaseFloatArrayElements(vector, vector_data, 0);
+}
+
+JNIEXPORT jintArray JNICALL Java_cloud_unum_usearch_Index_c_1search( //
+    JNIEnv* env, jclass, jlong c_ptr, jfloatArray vector, jlong wanted) {
+
+    jintArray matches;
+    matches = (*env).NewIntArray(wanted);
+    if (matches == NULL)
+        return NULL;
+
+    jint* matches_data = (jint*)std::malloc(sizeof(jint) * wanted);
+    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<native_index_t*>(c_ptr)->search( //
+            vector_span, static_cast<std::size_t>(wanted), matches_data, NULL);
+        (*env).SetIntArrayRegion(matches, 0, found, matches_data);
+    } catch (...) {
+        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/java/cloud/unum/usearch/cloud_unum_usearch_Index.h

@@ -0,0 +1,109 @@
+/* DO NOT EDIT THIS FILE - it is machine generated */
+#include <jni.h>
+/* Header for class cloud_unum_usearch_Index */
+
+#ifndef _Included_cloud_unum_usearch_Index
+#define _Included_cloud_unum_usearch_Index
+#ifdef __cplusplus
+extern "C" {
+#endif
+/*
+ * Class:     cloud_unum_usearch_Index
+ * Method:    c_create
+ * Signature: (Ljava/lang/String;Ljava/lang/String;JJJJJ)J
+ */
+JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1create
+  (JNIEnv *, jclass, jstring, jstring, jlong, jlong, jlong, jlong, jlong);
+
+/*
+ * Class:     cloud_unum_usearch_Index
+ * Method:    c_destroy
+ * Signature: (J)V
+ */
+JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1destroy
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     cloud_unum_usearch_Index
+ * Method:    c_size
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1size
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     cloud_unum_usearch_Index
+ * Method:    c_connectivity
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1connectivity
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     cloud_unum_usearch_Index
+ * Method:    c_dimensions
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1dimensions
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     cloud_unum_usearch_Index
+ * Method:    c_capacity
+ * Signature: (J)J
+ */
+JNIEXPORT jlong JNICALL Java_cloud_unum_usearch_Index_c_1capacity
+  (JNIEnv *, jclass, jlong);
+
+/*
+ * Class:     cloud_unum_usearch_Index
+ * Method:    c_reserve
+ * Signature: (JJ)V
+ */
+JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1reserve
+  (JNIEnv *, jclass, jlong, jlong);
+
+/*
+ * Class:     cloud_unum_usearch_Index
+ * Method:    c_add
+ * Signature: (JI[F)V
+ */
+JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1add
+  (JNIEnv *, jclass, jlong, jint, jfloatArray);
+
+/*
+ * Class:     cloud_unum_usearch_Index
+ * Method:    c_search
+ * Signature: (J[FJ)[I
+ */
+JNIEXPORT jintArray JNICALL Java_cloud_unum_usearch_Index_c_1search
+  (JNIEnv *, jclass, jlong, jfloatArray, jlong);
+
+/*
+ * Class:     cloud_unum_usearch_Index
+ * Method:    c_save
+ * Signature: (JLjava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1save
+  (JNIEnv *, jclass, jlong, jstring);
+
+/*
+ * Class:     cloud_unum_usearch_Index
+ * Method:    c_load
+ * Signature: (JLjava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1load
+  (JNIEnv *, jclass, jlong, jstring);
+
+/*
+ * Class:     cloud_unum_usearch_Index
+ * Method:    c_view
+ * Signature: (JLjava/lang/String;)V
+ */
+JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1view
+  (JNIEnv *, jclass, jlong, jstring);
+
+#ifdef __cplusplus
+}
+#endif
+#endif

package/java/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.0-bin.zip
+networkTimeout=10000
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

package/java/gradlew

@@ -0,0 +1,244 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

package/java/test/IndexTest.java

@@ -0,0 +1,25 @@
+import java.io.File;
+import java.util.Arrays;
+
+import org.junit.Test;
+
+import cloud.unum.usearch.Index;
+
+public class IndexTest {
+    public static void deleteDirectoryFiles(String path) {
+        File directory = new File(path);
+        if (!directory.isDirectory())
+            return;
+
+        for (File f : directory.listFiles())
+            f.delete();
+    }
+
+    @Test
+    public void test() {
+        String path = "./tmp/";
+        deleteDirectoryFiles(path);
+        new Index("cos", "f32", 1, 10, 1, 1, 1);
+        System.out.println("Java Tests Passed!");
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "usearch",
-    "version": "0.1.5",
+    "version": "0.1.7",
     "description": "The Mighty Tiny Vector Search Engine with Automatic Quantization and Hardware Acceleration",
     "author": "Ashot Vardanian",
     "license": "Apache 2.0",

package/python/lib.cpp

@@ -47,30 +47,8 @@ static native_index_t make_index(   //
     config.max_threads_add = std::thread::hardware_concurrency();
     config.max_threads_search = std::thread::hardware_concurrency();
 
-    accuracy_t accuracy;
-    if (scalar_type == "f32")
-        accuracy = accuracy_t::f32_k;
-    else if (scalar_type == "f64")
-        accuracy = accuracy_t::f64_k;
-    else if (scalar_type == "f16")
-        accuracy = accuracy_t::f16_k;
-    else if (scalar_type == "i8q100")
-        accuracy = accuracy_t::i8q100_k;
-    else
-        throw std::runtime_error("Unknown type, choose: f32, f16, f64, i8q100");
-
-    if (metric == "l2_sq" || metric == "euclidean_sq")
-        return native_index_t::l2(dimensions, accuracy, config);
-    else if (metric == "ip" || metric == "inner" || metric == "dot")
-        return native_index_t::ip(dimensions, accuracy, config);
-    else if (metric == "cos" || metric == "angular")
-        return native_index_t::cos(dimensions, accuracy, config);
-    else if (metric == "haversine")
-        return native_index_t::haversine(accuracy, config);
-    else
-        throw std::runtime_error("Unknown distance, choose: l2_sq, ip, cos, hamming, jaccard");
-
-    return {};
+    accuracy_t accuracy = accuracy_from_name(scalar_type.c_str(), scalar_type.size());
+    return index_from_name<native_index_t>(metric.c_str(), metric.size(), dimensions, accuracy, config);
 }
 
 static void add_to_index(native_index_t& index, py::buffer labels, py::buffer vectors, bool copy) {

package/rust/lib.cpp

@@ -40,7 +40,7 @@ void Index::save(rust::Str path) const { index_->save(std::string(path).c_str())
 void Index::load(rust::Str path) const { index_->load(std::string(path).c_str()); }
 void Index::view(rust::Str path) const { index_->view(std::string(path).c_str()); }
 
-accuracy_t accuracy(rust::Str quant) { return accuracy(quant.data(), quant.size()); }
+accuracy_t accuracy(rust::Str quant) { return accuracy_from_name(quant.data(), quant.size()); }
 
 std::unique_ptr<Index> wrap(native_index_t&& index) {
     std::shared_ptr<native_index_t> native = std::make_shared<native_index_t>(std::move(index));

package/src/advanced.hpp

@@ -172,26 +172,43 @@ enum class accuracy_t {
     i8q100_k,
 };
 
-inline bool str_equals(char const* begin, size_t len, char const* other_begin) noexcept {
-    size_t other_len = strlen(other_begin);
+inline bool str_equals(char const* begin, std::size_t len, char const* other_begin) noexcept {
+    std::size_t other_len = strlen(other_begin);
     return len == other_len && strncmp(begin, other_begin, len) == 0;
 }
 
-inline accuracy_t accuracy(char const* str, size_t len) {
+inline accuracy_t accuracy_from_name(char const* name, std::size_t len) {
     accuracy_t accuracy;
-    if (str_equals(str, len, "f32"))
+    if (str_equals(name, len, "f32"))
         accuracy = accuracy_t::f32_k;
-    else if (str_equals(str, len, "f64"))
+    else if (str_equals(name, len, "f64"))
         accuracy = accuracy_t::f64_k;
-    else if (str_equals(str, len, "f16"))
+    else if (str_equals(name, len, "f16"))
         accuracy = accuracy_t::f16_k;
-    else if (str_equals(str, len, "i8q100"))
+    else if (str_equals(name, len, "i8q100"))
         accuracy = accuracy_t::i8q100_k;
     else
         throw std::runtime_error("Unknown type, choose: f32, f16, f64, i8q100");
     return accuracy;
 }
 
+template <typename index_at>
+inline index_at index_from_name( //
+    char const* name, std::size_t len, std::size_t dimensions, accuracy_t accuracy, config_t const& config) {
+
+    if (str_equals(name, len, "l2_sq") || str_equals(name, len, "euclidean_sq"))
+        return index_at::l2(dimensions, accuracy, config);
+    else if (str_equals(name, len, "ip") || str_equals(name, len, "inner") || str_equals(name, len, "dot"))
+        return index_at::ip(dimensions, accuracy, config);
+    else if (str_equals(name, len, "cos") || str_equals(name, len, "angular"))
+        return index_at::cos(dimensions, accuracy, config);
+    else if (str_equals(name, len, "haversine"))
+        return index_at::haversine(accuracy, config);
+    else
+        throw std::runtime_error("Unknown distance, choose: l2_sq, ip, cos, hamming, jaccard");
+    return {};
+}
+
 enum class isa_t {
     auto_k,
     neon_k,

package/wolfram/lib.cpp

@@ -0,0 +1,21 @@
+#include "WolframLibrary.h"
+
+EXTERN_C DLLEXPORT mint WolframLibrary_getVersion() { return WolframLibraryVersion; }
+EXTERN_C DLLEXPORT int WolframLibrary_initialize(WolframLibraryData libData) { return 0; }
+EXTERN_C DLLEXPORT void WolframLibrary_uninitialize(WolframLibraryData libData) { return; }
+
+EXTERN_C DLLEXPORT int IndexInit(WolframLibraryData libData, mint Argc, MArgument* Args, MArgument Res) {
+    return LIBRARY_NO_ERROR;
+}
+
+EXTERN_C DLLEXPORT int IndexReserve(WolframLibraryData libData, mint Argc, MArgument* Args, MArgument Res) {
+    return LIBRARY_NO_ERROR;
+}
+
+EXTERN_C DLLEXPORT int IndexAdd(WolframLibraryData libData, mint Argc, MArgument* Args, MArgument Res) {
+    return LIBRARY_NO_ERROR;
+}
+
+EXTERN_C DLLEXPORT int IndexSearch(WolframLibraryData libData, mint Argc, MArgument* Args, MArgument Res) {
+    return LIBRARY_NO_ERROR;
+}