usearch 0.1.4 → 0.1.6

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/CMakeListsInstructuons.md

@@ -47,10 +47,10 @@ cmake \
 
 ```sh
 pip install -e .
-python src/test.py
+python python/test.py
 
 # To benchmark:
-python src/bench.py \
+python python/bench.py \
     --vectors datasets/wiki_1M/base.1M.fbin \
     --queries datasets/wiki_1M/query.public.100K.fbin \
     --neighbors datasets/wiki_1M/groundtruth.public.100K.ibin \
@@ -61,7 +61,7 @@ python src/bench.py \
 
 ```sh
 npm install
-node src/test.js
+node javascript/test.js
 npm publish
 ```
 
@@ -74,8 +74,34 @@ cargo publish
 
 ### Java
 
+```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 libUSearchJNI.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 libUSearchJNI.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,8 +1,8 @@
 [package]
 name = "usearch"
-version = "0.1.4"
+version = "0.1.6"
 authors = ["Ashot Vardanian <1983160+ashvardanian@users.noreply.github.com>"]
-description = "The Tiny Vector Search Engine from Unum"
+description = "The Mighty Tiny Vector Search Engine with Automatic Quantization and Hardware Acceleration"
 edition = "2021"
 license = "Apache-2.0"
 publish = true
@@ -10,7 +10,7 @@ repository = "https://github.com/unum-cloud/usearch"
 
 [lib]
 name = "usearch"
-path = "src/lib.rs"
+path = "rust/lib.rs"
 
 [dependencies]
 cxx = "1.0"

package/VERSION

@@ -1 +1 @@
-0.1.4
+0.1.6

package/binding.gyp

@@ -3,11 +3,12 @@
         {
             "target_name": "usearch",
             "sources": [
-                "src/javascript.cpp"
+                "javascript/lib.cpp"
             ],
             "include_dirs": [
                 "<!@(node -p \"require('node-addon-api').include\")",
                 "include",
+                "src",
                 "fp16/include",
                 "simsimd/include"
             ],

package/build.gradle

@@ -0,0 +1,111 @@
+import org.gradle.internal.jvm.Jvm
+
+plugins {
+    id 'java-library'
+    id 'c'
+    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 "java/test/"
+        }
+    }
+    test {
+        java {
+            srcDir "java/test"
+        }
+    }
+}
+
+dependencies {
+    testImplementation('junit:junit:4.13.2')
+}
+
+model {
+
+    components {
+        usearch(NativeLibrarySpec) {
+            sources {
+                cpp {
+                    source {
+                        srcDirs "cloud/unum/usearch"
+                        include "**/*.cpp"
+                    }
+                    exportedHeaders {
+                        srcDirs "include", "src", "${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'
+                }
+            }
+        }
+    }
+}
+
+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")
+    from("$buildDir/libs/usearch/shared/libUSearchJNI.dylib")
+}
+
+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'
+                    }
+                }
+            }
+        }
+    }
+    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")
+            }
+        }
+    }
+}

package/build.rs

@@ -1,16 +1,17 @@
 fn main() {
-    cxx_build::bridge("src/lib.rs")
-        .file("src/rust.cpp")
+    cxx_build::bridge("rust/lib.rs")
+        .file("rust/lib.cpp")
         .flag_if_supported("-std=c++11")
         .include("include")
+        .include("rust")
         .include("src")
         .include("fp16/include")
         .include("simsimd/include")
         .compile("usearch");
 
-    println!("cargo:rerun-if-changed=src/lib.rs");
-    println!("cargo:rerun-if-changed=src/rust.cpp");
-    println!("cargo:rerun-if-changed=src/rust.hpp");
+    println!("cargo:rerun-if-changed=rust/lib.rs");
+    println!("cargo:rerun-if-changed=rust/lib.cpp");
+    println!("cargo:rerun-if-changed=rust/lib.hpp");
     println!("cargo:rerun-if-changed=src/advanced.hpp");
     println!("cargo:rerun-if-changed=include/usearch/usearch.hpp");
 }

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

@@ -0,0 +1,161 @@
+package cloud.unum.usearch;
+
+/**
+ * @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("USearchJNI");
+  }
+
+  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/test/IndexTest.java

@@ -0,0 +1,26 @@
+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();
+        System.out.println("Java Tests Passed!");
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "usearch",
-    "version": "0.1.4",
+    "version": "0.1.6",
     "description": "The Mighty Tiny Vector Search Engine with Automatic Quantization and Hardware Acceleration",
     "author": "Ashot Vardanian",
     "license": "Apache 2.0",
@@ -17,6 +17,6 @@
         "node-addon-api": "^3.0.0"
     },
     "scripts": {
-        "test": "node src/test.js"
+        "test": "node javascript/test.js"
     }
 }

package/pom.xml

@@ -0,0 +1,8 @@
+<dependencies>
+  <dependency>
+    <groupId>junit</groupId>
+    <artifactId>junit</artifactId>
+    <version>4.12</version>
+    <scope>test</scope>
+  </dependency>
+</dependencies>

package/{src/python.cpp → 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/{src/rust.cpp → rust/lib.cpp}

@@ -1,5 +1,5 @@
-#include "usearch/src/rust.hpp"
-#include "usearch/src/lib.rs.h"
+#include "lib.hpp"
+#include "usearch/rust/lib.rs.h"
 
 using namespace unum::usearch;
 using namespace unum;
@@ -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 → rust}/lib.rs

@@ -10,7 +10,7 @@ pub mod ffi {
 
     // C++ types and signatures exposed to Rust.
     unsafe extern "C++" {
-        include!("rust.hpp");
+        include!("lib.hpp");
 
         type Index;
 

package/setup.py

@@ -12,7 +12,7 @@ if sys.platform == 'darwin':
 ext_modules = [
     Pybind11Extension(
         'usearch',
-        ['src/python.cpp'],
+        ['python/lib.cpp'],
         extra_compile_args=compile_args,
     ),
 ]
@@ -58,6 +58,6 @@ setup(
         'Topic :: Scientific/Engineering :: Artificial Intelligence',
     ],
 
-    include_dirs=['include', 'fp16/include', 'simsimd/include'],
+    include_dirs=['include', 'fp16/include', 'simsimd/include', 'src'],
     ext_modules=ext_modules,
 )

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;
+}