usearch 2.7.7 → 2.8.1

package/include/usearch/index_plugins.hpp

@@ -44,10 +44,22 @@
 // Propagate the `f16` settings
 #define SIMSIMD_NATIVE_F16 USEARCH_USE_NATIVE_F16
 #if defined(USEARCH_DEFINED_LINUX)
+#define SIMSIMD_TARGET_X86_AVX512 1
+#define SIMSIMD_TARGET_ARM_SVE 1
+#define SIMSIMD_TARGET_X86_AVX2 1
+#define SIMSIMD_TARGET_ARM_NEON 1
 #include <simsimd/simsimd.h>
 #elif defined(USEARCH_DEFINED_APPLE)
 #define SIMSIMD_TARGET_X86_AVX512 0
 #define SIMSIMD_TARGET_ARM_SVE 0
+#define SIMSIMD_TARGET_X86_AVX2 1
+#define SIMSIMD_TARGET_ARM_NEON 1
+#include <simsimd/simsimd.h>
+#else
+#define SIMSIMD_TARGET_X86_AVX512 0
+#define SIMSIMD_TARGET_ARM_SVE 0
+#define SIMSIMD_TARGET_X86_AVX2 0
+#define SIMSIMD_TARGET_ARM_NEON 0
 #include <simsimd/simsimd.h>
 #endif
 #endif
@@ -100,6 +112,7 @@ enum class metric_kind_t : std::uint8_t {
     // Custom:
     pearson_k = 'p',
     haversine_k = 'h',
+    divergence_k = 'd',
 
     // Sets:
     jaccard_k = 'j',
@@ -227,6 +240,7 @@ inline char const* metric_kind_name(metric_kind_t metric) noexcept {
     case metric_kind_t::l2sq_k: return "l2sq";
     case metric_kind_t::pearson_k: return "pearson";
     case metric_kind_t::haversine_k: return "haversine";
+    case metric_kind_t::divergence_k: return "divergence";
     case metric_kind_t::jaccard_k: return "jaccard";
     case metric_kind_t::hamming_k: return "hamming";
     case metric_kind_t::tanimoto_k: return "tanimoto";
@@ -263,6 +277,8 @@ inline expected_gt<metric_kind_t> metric_from_name(char const* name, std::size_t
         parsed.result = metric_kind_t::cos_k;
     } else if (str_equals(name, len, "haversine")) {
         parsed.result = metric_kind_t::haversine_k;
+    } else if (str_equals(name, len, "divergence")) {
+        parsed.result = metric_kind_t::divergence_k;
     } else if (str_equals(name, len, "pearson")) {
         parsed.result = metric_kind_t::pearson_k;
     } else if (str_equals(name, len, "hamming")) {
@@ -272,8 +288,8 @@ inline expected_gt<metric_kind_t> metric_from_name(char const* name, std::size_t
     } else if (str_equals(name, len, "sorensen")) {
         parsed.result = metric_kind_t::sorensen_k;
     } else
-        parsed.failed(
-            "Unknown distance, choose: l2sq, ip, cos, haversine, jaccard, pearson, hamming, tanimoto, sorensen");
+        parsed.failed("Unknown distance, choose: l2sq, ip, cos, haversine, divergence, jaccard, pearson, hamming, "
+                      "tanimoto, sorensen");
     return parsed;
 }
 
@@ -556,7 +572,9 @@ class aligned_allocator_gt {
     using size_type = std::size_t;
     using pointer = element_at*;
     using const_pointer = element_at const*;
-    template <typename other_element_at> struct rebind { using other = aligned_allocator_gt<other_element_at>; };
+    template <typename other_element_at> struct rebind {
+        using other = aligned_allocator_gt<other_element_at>;
+    };
 
     constexpr std::size_t alignment() const { return alignment_ak; }
 
@@ -1166,6 +1184,32 @@ template <typename scalar_at = float, typename result_at = float> struct metric_
     }
 };
 
+/**
+ *  @brief  Measures Jensen-Shannon Divergence between two probability distributions.
+ */
+template <typename scalar_at = float, typename result_at = float> struct metric_divergence_gt {
+    using scalar_t = scalar_at;
+    using result_t = result_at;
+
+    inline result_t operator()(scalar_t const* p, scalar_t const* q, std::size_t dim) const noexcept {
+        result_t kld_pm{}, kld_qm{};
+        scalar_t epsilon = std::numeric_limits<scalar_t>::epsilon();
+#if USEARCH_USE_OPENMP
+#pragma omp simd reduction(+ : kld_pm, kld_qm)
+#elif defined(USEARCH_DEFINED_CLANG)
+#pragma clang loop vectorize(enable)
+#elif defined(USEARCH_DEFINED_GCC)
+#pragma GCC ivdep
+#endif
+        for (std::size_t i = 0; i != dim; ++i) {
+            result_t mi = result_t(p[i] + q[i]) / 2 + epsilon;
+            kld_pm += p[i] * std::log((p[i] + epsilon) / mi);
+            kld_qm += q[i] * std::log((q[i] + epsilon) / mi);
+        }
+        return (kld_pm + kld_qm) / 2;
+    }
+};
+
 struct cos_i8_t {
     using scalar_t = i8_t;
     using result_t = f32_t;
@@ -1344,8 +1388,8 @@ class metric_punned_t {
     }
 
   private:
-    bool configure_with_simsimd() noexcept {
 #if USEARCH_USE_SIMSIMD
+    bool configure_with_simsimd(simsimd_capability_t simd_caps) noexcept {
         simsimd_metric_kind_t kind = simsimd_metric_unknown_k;
         simsimd_datatype_t datatype = simsimd_datatype_unknown_k;
         simsimd_capability_t allowed = simsimd_cap_any_k;
@@ -1355,6 +1399,7 @@ class metric_punned_t {
         case metric_kind_t::l2sq_k: kind = simsimd_metric_l2sq_k; break;
         case metric_kind_t::hamming_k: kind = simsimd_metric_hamming_k; break;
         case metric_kind_t::jaccard_k: kind = simsimd_metric_jaccard_k; break;
+        default: break;
         }
         switch (scalar_kind_) {
         case scalar_kind_t::f32_k: datatype = simsimd_datatype_f32_k; break;
@@ -1362,20 +1407,25 @@ class metric_punned_t {
         case scalar_kind_t::f16_k: datatype = simsimd_datatype_f16_k; break;
         case scalar_kind_t::i8_k: datatype = simsimd_datatype_i8_k; break;
         case scalar_kind_t::b1x8_k: datatype = simsimd_datatype_b8_k; break;
+        default: break;
         }
         simsimd_metric_punned_t simd_metric = NULL;
         simsimd_capability_t simd_kind = simsimd_cap_any_k;
-        simsimd_find_metric_punned(kind, datatype, simsimd_capabilities(), allowed, &simd_metric, &simd_kind);
+        simsimd_find_metric_punned(kind, datatype, simd_caps, allowed, &simd_metric, &simd_kind);
         if (simd_metric == nullptr)
             return false;
 
         raw_ptr_ = (punned_ptr_t)simd_metric;
         isa_kind_ = simd_kind;
         return true;
+    }
+    bool configure_with_simsimd() noexcept {
+        static simsimd_capability_t static_capabilities = simsimd_capabilities();
+        return configure_with_simsimd(static_capabilities);
+    }
 #else
-        return false;
+    bool configure_with_simsimd() noexcept { return false; }
 #endif
-    }
 
     void configure_with_auto_vectorized() noexcept {
         switch (metric_kind_) {
@@ -1432,6 +1482,17 @@ class metric_punned_t {
             }
             break;
         }
+        case metric_kind_t::divergence_k: {
+            switch (scalar_kind_) {
+            case scalar_kind_t::f16_k:
+                raw_ptr_ = (punned_ptr_t)&equidimensional_<metric_divergence_gt<f16_t, f32_t>>;
+                break;
+            case scalar_kind_t::f32_k: raw_ptr_ = (punned_ptr_t)&equidimensional_<metric_divergence_gt<f32_t>>; break;
+            case scalar_kind_t::f64_k: raw_ptr_ = (punned_ptr_t)&equidimensional_<metric_divergence_gt<f64_t>>; break;
+            default: raw_ptr_ = nullptr; break;
+            }
+            break;
+        }
         case metric_kind_t::jaccard_k: // Equivalent to Tanimoto
         case metric_kind_t::tanimoto_k:
             raw_ptr_ = (punned_ptr_t)&equidimensional_<metric_tanimoto_gt<b1x8_t>>,
@@ -2118,7 +2179,8 @@ class flat_hash_multi_set_gt {
             slot_ref_t slot = slot_ref(slot_index);
             if ((~slot.header.populated & slot.mask) | (slot.header.deleted & slot.mask)) {
                 // Found an empty or deleted slot
-                populated_slots_ += populate_slot(slot, element);
+                populate_slot(slot, element);
+                ++populated_slots_;
                 return true;
             }
             // Move to the next slot

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

@@ -1,83 +1,170 @@
 package cloud.unum.usearch;
 
 import java.io.File;
+import java.io.InputStream;
 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
+ * Java bindings for Unum USearch.
+ * <p>
+ * Provides interface to interact with USearch library and perform various operations related to indexing and searching.
+ *
+ * @see <a href="https://nachtimwald.com/2017/06/06/wrapping-a-c-library-in-java/">Wrapping a C library in Java</a>
+ * @see <a href="https://www3.ntu.edu.sg/home/ehchua/programming/java/javanativeinterface.html">Java Native Interface tutorial</a>
  */
 public class Index {
 
   private long c_ptr = 0;
 
-  public Index(String metric, String quantization, //
-      long dimensions, long capacity, long connectivity, //
-      long expansion_add, long expansion_search) {
-    c_ptr = c_create(
+  /**
+   * Creates a new instance of Index with specified parameters.
+   *
+   * @param metric          the metric type for distance calculation between vectors
+   * @param quantization    the scalar type for quantization of vector data
+   * @param dimensions      the number of dimensions in the vectors
+   * @param capacity        the initial capacity of the index
+   * @param connectivity    the connectivity parameter that limits connections-per-node in graph
+   * @param expansion_add   the expansion factor used for index construction when adding vectors
+   * @param expansion_search the expansion factor used for index construction during search operations
+   */
+  public Index(
+    String metric,
+    String quantization, //
+    long dimensions,
+    long capacity,
+    long connectivity, //
+    long expansion_add,
+    long expansion_search
+  ) {
+    c_ptr =
+      c_create(
         metric,
         quantization,
         dimensions,
         capacity,
         connectivity,
         expansion_add,
-        expansion_search);
+        expansion_search
+      );
   }
 
+  /**
+   * Retrieves the current size of the index.
+   *
+   * @return the number of vectors currently indexed.
+   */
   public long size() {
     return c_size(c_ptr);
   }
 
+  /**
+   * Retrieves the connectivity parameter of the index.
+   *
+   * @return the connectivity parameter that limits connections-per-node in graph.
+   */
   public long connectivity() {
     return c_connectivity(c_ptr);
   }
 
+  /**
+   * Retrieves the number of dimensions of the vectors in the index.
+   *
+   * @return the number of dimensions in the vectors.
+   */
   public long dimensions() {
     return c_dimensions(c_ptr);
   }
 
+  /**
+   * Retrieves the current capacity of the index.
+   *
+   * @return the total capacity including current size.
+   */
   public long capacity() {
     return c_capacity(c_ptr);
   }
 
+  /**
+   * Reserves memory for a specified number of incoming vectors.
+   *
+   * @param capacity the desired total capacity including current size.
+   */
   public void reserve(long capacity) {
     c_reserve(c_ptr, capacity);
   }
 
+  /**
+   * Adds a vector with a specified key to the index.
+   *
+   * @param key     the key associated with the vector
+   * @param vector  the vector data
+   */
   public void add(int key, float vector[]) {
     c_add(c_ptr, key, vector);
   }
 
+  /**
+   * Searches for closest vectors to the specified query vector.
+   *
+   * @param vector  the query vector data
+   * @param count   the number of nearest neighbors to search
+   * @return        an array of keys of the nearest neighbors
+   */
   public int[] search(float vector[], long count) {
     return c_search(c_ptr, vector, count);
   }
 
+  /**
+   * Saves the index to a file.
+   *
+   * @param path the file path where the index will be saved.
+   */
   public void save(String path) {
     c_save(c_ptr, path);
   }
 
+  /**
+   * Loads the index from a file.
+   *
+   * @param path the file path from where the index will be loaded.
+   */
   public void load(String path) {
     c_load(c_ptr, path);
   }
 
+  /**
+   * Creates a view of the index from a file without copying it into memory.
+   *
+   * @param path the file path from where the view will be created.
+   */
   public void view(String path) {
     c_view(c_ptr, path);
   }
 
+  /**
+   * Removes the vector associated with the given key from the index.
+   *
+   * @param key the key of the vector to be removed.
+   * @return {@code true} if the vector was successfully removed, {@code false} otherwise.
+   */
   public boolean remove(int key) {
     return c_remove(c_ptr, key);
   }
-  
+
+  /**
+   * Renames the vector to map to a different key.
+   *
+   * @param from the key of the vector to be renamed.
+   * @param to the new key for the vector.
+   * @return {@code true} if the vector was successfully renamed, {@code false} otherwise.
+   */
   public boolean rename(int from, int to) {
     return c_rename(c_ptr, from, to);
   }
 
   public static class Config {
+
     private String _metric = "ip";
     private String _quantization = "f32";
     private long _dimensions = 0;
@@ -86,18 +173,18 @@ public class Index {
     private long _expansion_add = 0;
     private long _expansion_search = 0;
 
-    public Config() {
-    }
+    public Config() {}
 
     public Index build() {
       return new Index(
-          _metric,
-          _quantization,
-          _dimensions,
-          _capacity,
-          _connectivity,
-          _expansion_add,
-          _expansion_search);
+        _metric,
+        _quantization,
+        _dimensions,
+        _capacity,
+        _connectivity,
+        _expansion_add,
+        _expansion_search
+      );
     }
 
     public Config metric(String _metric) {
@@ -146,10 +233,15 @@ public class Index {
     System.out.println("Java tests passed!");
   }
 
-  private static native long c_create(//
-      String metric, String quantization, //
-      long dimensions, long capacity, long connectivity, //
-      long expansion_add, long expansion_search);
+  private static native long c_create( //
+    String metric,
+    String quantization, //
+    long dimensions,
+    long capacity,
+    long connectivity, //
+    long expansion_add,
+    long expansion_search
+  );
 
   private static native void c_destroy(long ptr);
 
@@ -176,4 +268,4 @@ public class Index {
   private static native boolean c_remove(long ptr, int key);
 
   private static native boolean c_rename(long ptr, int from, int to);
-}
+}

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

@@ -124,10 +124,10 @@ JNIEXPORT void JNICALL Java_cloud_unum_usearch_Index_c_1add( //
     jsize vector_dims = (*env).GetArrayLength(vector);
     float_span_t vector_span = float_span_t{vector_data, static_cast<std::size_t>(vector_dims)};
 
-    using key_t = typename index_dense_t::key_t;
+    using vector_key_t = typename index_dense_t::vector_key_t;
     using add_result_t = typename index_dense_t::add_result_t;
 
-    add_result_t result = reinterpret_cast<index_dense_t*>(c_ptr)->add(static_cast<key_t>(key), vector_span);
+    add_result_t result = reinterpret_cast<index_dense_t*>(c_ptr)->add(static_cast<vector_key_t>(key), vector_span);
     if (!result) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
@@ -152,13 +152,13 @@ JNIEXPORT jintArray JNICALL Java_cloud_unum_usearch_Index_c_1search( //
     jsize vector_dims = (*env).GetArrayLength(vector);
     float_span_t vector_span = float_span_t{vector_data, static_cast<std::size_t>(vector_dims)};
 
-    using key_t = typename index_dense_t::key_t;
+    using vector_key_t = typename index_dense_t::vector_key_t;
     using search_result_t = typename index_dense_t::search_result_t;
 
     search_result_t result =
         reinterpret_cast<index_dense_t*>(c_ptr)->search(vector_span, static_cast<std::size_t>(wanted));
     if (result) {
-        std::size_t found = result.dump_to(reinterpret_cast<key_t*>(matches_data), NULL);
+        std::size_t found = result.dump_to(reinterpret_cast<vector_key_t*>(matches_data), NULL);
         (*env).SetIntArrayRegion(matches, 0, found, matches_data);
     } else {
         jclass jc = (*env).FindClass("java/lang/Error");
@@ -172,9 +172,9 @@ JNIEXPORT jintArray JNICALL Java_cloud_unum_usearch_Index_c_1search( //
 }
 
 JNIEXPORT bool JNICALL Java_cloud_unum_usearch_Index_c_1remove(JNIEnv* env, jclass, jlong c_ptr, jlong key) {
-    using key_t = typename index_dense_t::key_t;
+    using vector_key_t = typename index_dense_t::vector_key_t;
     using labeling_result_t = typename index_dense_t::labeling_result_t;
-    labeling_result_t result = reinterpret_cast<index_dense_t*>(c_ptr)->remove(static_cast<key_t>(key));
+    labeling_result_t result = reinterpret_cast<index_dense_t*>(c_ptr)->remove(static_cast<vector_key_t>(key));
     if (!result) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)
@@ -184,10 +184,10 @@ JNIEXPORT bool JNICALL Java_cloud_unum_usearch_Index_c_1remove(JNIEnv* env, jcla
 }
 
 JNIEXPORT bool JNICALL Java_cloud_unum_usearch_Index_c_1rename(JNIEnv* env, jclass, jlong c_ptr, jlong from, jlong to) {
-    using key_t = typename index_dense_t::key_t;
+    using vector_key_t = typename index_dense_t::vector_key_t;
     using labeling_result_t = typename index_dense_t::labeling_result_t;
     labeling_result_t result =
-        reinterpret_cast<index_dense_t*>(c_ptr)->rename(static_cast<key_t>(from), static_cast<key_t>(to));
+        reinterpret_cast<index_dense_t*>(c_ptr)->rename(static_cast<vector_key_t>(from), static_cast<vector_key_t>(to));
     if (!result) {
         jclass jc = (*env).FindClass("java/lang/Error");
         if (jc)

package/javascript/usearch.js

@@ -11,6 +11,7 @@ const MetricKind = {
     IP: 'ip',
     L2sq: 'l2sq',
     Haversine: 'haversine',
+    Divergence: 'divergence',
     Pearson: 'pearson',
     Jaccard: 'jaccard',
     Hamming: 'hamming',

package/objc/USearchObjective.mm

@@ -14,7 +14,7 @@ using labeling_result_t = typename index_dense_t::labeling_result_t;
 using search_result_t = typename index_dense_t::search_result_t;
 using shared_index_dense_t = std::shared_ptr<index_dense_t>;
 
-static_assert(std::is_same<USearchKey, index_dense_t::key_t>::value, "Type mismatch between Objective-C and C++");
+static_assert(std::is_same<USearchKey, index_dense_t::vector_key_t>::value, "Type mismatch between Objective-C and C++");
 
 metric_kind_t to_native_metric(USearchMetric m) {
     switch (m) {
@@ -33,6 +33,9 @@ metric_kind_t to_native_metric(USearchMetric m) {
         case USearchMetricHaversine:
             return metric_kind_t::haversine_k;
 
+        case USearchMetricDivergence:
+            return metric_kind_t::divergence_k;
+
         case USearchMetricJaccard:
             return metric_kind_t::jaccard_k;
 

package/objc/include/USearchObjective.h

@@ -19,6 +19,7 @@ typedef NS_ENUM(NSUInteger, USearchMetric) {
     USearchMetricL2sq,
     USearchMetricPearson,
     USearchMetricHaversine,
+    USearchMetricDivergence,
     USearchMetricJaccard,
     USearchMetricHamming,
     USearchMetricTanimoto,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "usearch",
-    "version": "2.7.7",
+    "version": "2.8.1",
     "description": "Smaller & Faster Single-File Vector Search Engine from Unum",
     "author": "Ash Vardanian (https://ashvardanian.com/)",
     "license": "Apache 2.0",

package/pyproject.toml

@@ -8,9 +8,13 @@ addopts = ["-ra", "--showlocals", "--strict-markers", "--strict-config"]
 xfail_strict = true
 filterwarnings = ["error"]
 
+# Avoid running tests, as everything is happening in a super slow container
+# We have already run all the relavent Python tests in `prerelease.yml`
+#   test-requires = ["pytest", "numpy"]
+#   test-command = "pytest {project}/python/scripts"
 [tool.cibuildwheel]
-test-requires = ["pytest", "numpy"]
-test-command = "pytest {project}/python/scripts"
+test-requires = []
+test-command = ""
 build-verbosity = 0
 skip = ["*musllinux*", "*i686*", "pp*", "cp36-*", "cp312-*"]
 
@@ -18,22 +22,20 @@ skip = ["*musllinux*", "*i686*", "pp*", "cp36-*", "cp312-*"]
 before-build = [
     "rm -rf {project}/CMakeCache.txt {project}/build {project}/build_debug {project}/CMakeFiles.txt {project}/_deps {project}/.pytest_cache",
     "mkdir -p build/usearch",
-    "git submodule update --init --recursive"
+    "git submodule update --init --recursive",
 ]
 manylinux-x86_64-image = "manylinux_2_28"
 manylinux-aarch64-image = "manylinux_2_28"
 
 archs = ["x86_64", "aarch64"]
-before-all = [
-    "yum install -y glibc-devel wget python3-devel"
-]
+before-all = ["yum install -y glibc-devel wget python3-devel"]
 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 {project}/.pytest_cache",
     "mkdir -p build/usearch",
-    "git submodule update --init --recursive"
+    "git submodule update --init --recursive",
 ]
 archs = ["x86_64", "universal2", "arm64"]
 repair-wheel-command = "delocate-wheel --require-archs {delocate_archs} -w {dest_dir} -v {wheel}"
@@ -43,7 +45,7 @@ repair-wheel-command = "delocate-wheel --require-archs {delocate_archs} -w {dest
 before-build = [
     "rd /s /q {project}\\CMakeCache.txt {project}\\build {project}\\build_debug {project}\\CMakeFiles.txt {project}\\_deps {project}\\.pytest_cache || echo Done",
     "md build\\usearch",
-    "git submodule update --init --recursive"
+    "git submodule update --init --recursive",
 ]
 archs = ["x86", "AMD64"]
 skip = ["*win32*", "pp*", "cp36-*", "cp312-*"]

package/python/lib.cpp

@@ -38,7 +38,7 @@ using py_shape_t = py::array::ShapeContainer;
 using metric_t = metric_punned_t;
 using distance_t = distance_punned_t;
 
-using dense_key_t = typename index_dense_t::key_t;
+using dense_key_t = typename index_dense_t::vector_key_t;
 using dense_add_result_t = typename index_dense_t::add_result_t;
 using dense_search_result_t = typename index_dense_t::search_result_t;
 using dense_labeling_result_t = typename index_dense_t::labeling_result_t;
@@ -48,7 +48,7 @@ using dense_clustering_result_t = typename index_dense_t::clustering_result_t;
 using progress_func_t = std::function<bool(std::size_t /*processed*/, std::size_t /*total*/)>;
 
 struct progress_t {
-    inline progress_t(nullptr_t = nullptr) : func_(&dummy_progress) {}
+    inline progress_t(std::nullptr_t = nullptr) : func_(&dummy_progress) {}
     inline progress_t(progress_func_t const& func) : func_(func ? func : &dummy_progress) {}
     inline bool operator()(std::size_t processed, std::size_t total) const noexcept { return func_(processed, total); }
 
@@ -864,6 +864,7 @@ PYBIND11_MODULE(compiled, m) {
         .value("L2sq", metric_kind_t::l2sq_k)
 
         .value("Haversine", metric_kind_t::haversine_k)
+        .value("Divergence", metric_kind_t::divergence_k)
         .value("Pearson", metric_kind_t::pearson_k)
         .value("Jaccard", metric_kind_t::jaccard_k)
         .value("Hamming", metric_kind_t::hamming_k)

package/python/scripts/bench.ipynb

@@ -11,7 +11,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -19,6 +19,28 @@
     "import plotly.graph_objects as go"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "('auto', 'auto', 'auto')"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from usearch.index import Index\n",
+    "\n",
+    "Index(ndim=256, metric=\"cos\", dtype=\"f32\").hardware_acceleration, Index(ndim=256, metric=\"cos\", dtype=\"f16\").hardware_acceleration, Index(ndim=256, metric=\"cos\", dtype=\"i8\").hardware_acceleration"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -162,7 +184,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.11"
+   "version": "3.11.5"
   },
   "orig_nbformat": 4
  },

package/python/usearch/index.py

@@ -151,6 +151,7 @@ def _normalize_metric(metric) -> MetricKind:
             "l2sq": MetricKind.L2sq,
             "l2_sq": MetricKind.L2sq,
             "haversine": MetricKind.Haversine,
+            "divergence": MetricKind.Divergence,
             "pearson": MetricKind.Pearson,
             "hamming": MetricKind.Hamming,
             "tanimoto": MetricKind.Tanimoto,
@@ -573,7 +574,7 @@ class Index:
         )
 
         self.path = path
-        if path is not None:
+        if path is not None and os.path.exists(path):
             if view:
                 self.view(path)
             else:
@@ -873,7 +874,7 @@ class Index:
 
     @property
     def metric_kind(self) -> Union[MetricKind, CompiledMetric]:
-        return self._metric_jit if self._metric_jit.kind else self._metric_kind
+        return self._metric_jit.kind if self._metric_jit else self._metric_kind
 
     @property
     def metric(self) -> Union[MetricKind, CompiledMetric]:
@@ -965,7 +966,11 @@ class Index:
         if isinstance(path_or_buffer, bytes):
             self._compiled.load_index_from_buffer(path_or_buffer, progress)
         else:
-            self._compiled.load_index_from_path(os.fspath(path_or_buffer), progress)
+            path_or_buffer = os.fspath(path_or_buffer)
+            if os.path.exists(path_or_buffer):
+                self._compiled.load_index_from_path(path_or_buffer, progress)
+            else:
+                raise RuntimeError("Missing file!")
 
     def view(
         self,