usearch 2.7.6 → 2.8.0

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',
@@ -186,20 +199,6 @@ inline bool str_equals(char const* begin, std::size_t len, char const* other_beg
     return len == other_len && std::strncmp(begin, other_begin, len) == 0;
 }
 
-inline char const* isa_name(simsimd_capability_t isa_kind) noexcept {
-    switch (isa_kind) {
-    case simsimd_cap_serial_k: return "serial";
-    case simsimd_cap_arm_neon_k: return "neon";
-    case simsimd_cap_arm_sve_k: return "sve";
-    case simsimd_cap_x86_avx2_k: return "avx2";
-    case simsimd_cap_x86_avx512_k: return "avx512";
-    case simsimd_cap_x86_avx2fp16_k: return "avx2+f16";
-    case simsimd_cap_x86_avx512fp16_k: return "avx512+f16";
-    case simsimd_cap_x86_avx512vpopcntdq_k: return "avx512+popcnt";
-    default: return "unknown";
-    }
-}
-
 inline std::size_t bits_per_scalar(scalar_kind_t scalar_kind) noexcept {
     switch (scalar_kind) {
     case scalar_kind_t::f64_k: return 64;
@@ -241,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";
@@ -277,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")) {
@@ -286,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;
 }
 
@@ -570,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; }
 
@@ -1180,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;
@@ -1283,7 +1313,10 @@ class metric_punned_t {
     std::size_t dimensions_ = 0;
     metric_kind_t metric_kind_ = metric_kind_t::unknown_k;
     scalar_kind_t scalar_kind_ = scalar_kind_t::unknown_k;
+
+#if USEARCH_USE_SIMSIMD
     simsimd_capability_t isa_kind_ = simsimd_cap_serial_k;
+#endif
 
   public:
     /**
@@ -1303,7 +1336,7 @@ class metric_punned_t {
         metric_kind_t metric_kind = metric_kind_t::l2sq_k, //
         scalar_kind_t scalar_kind = scalar_kind_t::f32_k) noexcept
         : raw_arg3_(dimensions), raw_arg4_(dimensions), dimensions_(dimensions), metric_kind_(metric_kind),
-          scalar_kind_(scalar_kind), isa_kind_(simsimd_cap_serial_k) {
+          scalar_kind_(scalar_kind) {
 
 #if USEARCH_USE_SIMSIMD
         if (configure_with_simsimd())
@@ -1328,7 +1361,23 @@ class metric_punned_t {
     inline std::size_t dimensions() const noexcept { return dimensions_; }
     inline metric_kind_t metric_kind() const noexcept { return metric_kind_; }
     inline scalar_kind_t scalar_kind() const noexcept { return scalar_kind_; }
-    inline simsimd_capability_t isa_kind() const noexcept { return isa_kind_; }
+
+    inline char const* isa_name() const noexcept {
+#if USEARCH_USE_SIMSIMD
+        switch (isa_kind_) {
+        case simsimd_cap_serial_k: return "serial";
+        case simsimd_cap_arm_neon_k: return "neon";
+        case simsimd_cap_arm_sve_k: return "sve";
+        case simsimd_cap_x86_avx2_k: return "avx2";
+        case simsimd_cap_x86_avx512_k: return "avx512";
+        case simsimd_cap_x86_avx2fp16_k: return "avx2+f16";
+        case simsimd_cap_x86_avx512fp16_k: return "avx512+f16";
+        case simsimd_cap_x86_avx512vpopcntdq_k: return "avx512+popcnt";
+        default: return "unknown";
+        }
+#endif
+        return "serial";
+    }
 
     inline std::size_t bytes_per_vector() const noexcept {
         return divide_round_up<CHAR_BIT>(dimensions_ * bits_per_scalar(scalar_kind_));
@@ -1339,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;
@@ -1350,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;
@@ -1357,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_) {
@@ -1427,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>>,
@@ -2113,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.6",
+    "version": "2.8.0",
     "description": "Smaller & Faster Single-File Vector Search Engine from Unum",
     "author": "Ash Vardanian (https://ashvardanian.com/)",
     "license": "Apache 2.0",

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)
@@ -918,7 +919,7 @@ PYBIND11_MODULE(compiled, m) {
     m.def(
         "hardware_acceleration",
         [](scalar_kind_t scalar_kind, std::size_t dimensions, metric_kind_t metric_kind) -> py::str {
-            return isa_name(metric_t(dimensions, metric_kind, scalar_kind).isa_kind());
+            return metric_t(dimensions, metric_kind, scalar_kind).isa_name();
         },
         py::kw_only(),                                //
         py::arg("dtype") = scalar_kind_t::f32_k,      //
@@ -1087,9 +1088,8 @@ PYBIND11_MODULE(compiled, m) {
         py::arg("metric_pointer") = 0                                           //
     );
 
-    i.def_property_readonly("hardware_acceleration", [](dense_index_py_t const& index) -> py::str {
-        return isa_name(index.metric().isa_kind());
-    });
+    i.def_property_readonly("hardware_acceleration",
+                            [](dense_index_py_t const& index) -> py::str { return index.metric().isa_name(); });
 
     i.def("contains_one", &dense_index_py_t::contains);
     i.def("count_one", &dense_index_py_t::count);

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
  },