usearch 2.7.7 → 2.8.0

package/.gitignore

@@ -16,6 +16,7 @@ bin
 build
 build_release
 build_debug
+build_artifacts
 _deps
 CMakeCache.txt
 CMakeFiles

package/.vscode/settings.json

@@ -102,7 +102,9 @@
         "__verbose_abort": "cpp",
         "shared_mutex": "cpp",
         "ranges": "cpp",
-        "span": "cpp"
+        "span": "cpp",
+        "format": "cpp",
+        "charconv": "cpp"
     },
     "cSpell.words": [
         "allclose",

package/CITATION.cff

@@ -5,7 +5,7 @@ authors:
   given-names: "Ash"
   orcid: "https://orcid.org/0000-0002-4882-1815"
 title: "USearch by Unum Cloud"
-version: 2.7.7
+version: 2.8.0
 doi: 10.5281/zenodo.7949416
 date-released: 2023-10-22
 url: "https://github.com/unum-cloud/usearch"

package/CMakeLists.txt

@@ -260,13 +260,43 @@ function (setup_target TARGET_NAME)
     endif ()
 
     target_include_directories(${TARGET_NAME} PRIVATE ${USEARCH_HEADER_INCLUDES})
-    set_target_properties(${TARGET_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR})
-    set_target_properties(${TARGET_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR})
-    set_target_properties(${TARGET_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
-    set_target_properties(${TARGET_NAME} PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
-    set_target_properties(${TARGET_NAME} PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
     set_target_properties(${TARGET_NAME} PROPERTIES CXX_STANDARD 17)
 
+    # On Windows, when using multi-configuration CMake builds, the paths will be nested, resulting in
+    # "build_debug\Debug" on Windows instead of "build_debug". That's why we override all the configs to use the same
+    # output directory.
+    set_target_properties(
+        ${TARGET_NAME}
+        PROPERTIES RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}"
+                   ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}"
+                   LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}"
+    )
+    set_target_properties(
+        ${TARGET_NAME}
+        PROPERTIES RUNTIME_OUTPUT_DIRECTORY_DEBUG "${CMAKE_BINARY_DIR}"
+                   ARCHIVE_OUTPUT_DIRECTORY_DEBUG "${CMAKE_BINARY_DIR}"
+                   LIBRARY_OUTPUT_DIRECTORY_DEBUG "${CMAKE_BINARY_DIR}"
+    )
+    set_target_properties(
+        ${TARGET_NAME}
+        PROPERTIES RUNTIME_OUTPUT_DIRECTORY_RELEASE "${CMAKE_BINARY_DIR}"
+                   ARCHIVE_OUTPUT_DIRECTORY_RELEASE "${CMAKE_BINARY_DIR}"
+                   LIBRARY_OUTPUT_DIRECTORY_RELEASE "${CMAKE_BINARY_DIR}"
+    )
+    set_target_properties(
+        ${TARGET_NAME}
+        PROPERTIES RUNTIME_OUTPUT_DIRECTORY_RELWITHDEBINFO "${CMAKE_BINARY_DIR}"
+                   ARCHIVE_OUTPUT_DIRECTORY_RELWITHDEBINFO "${CMAKE_BINARY_DIR}"
+                   LIBRARY_OUTPUT_DIRECTORY_RELWITHDEBINFO "${CMAKE_BINARY_DIR}"
+    )
+
+    # On Linux and MacOS our primary shared libraries for C are called `libusearch_c.so` and `libusearch_c.dylib`, while
+    # on Windows the "lib" prefix might be missing by default, so let's ensure it's always there
+    get_target_property(TARGET_TYPE ${TARGET_NAME} TYPE)
+    if (TARGET_TYPE STREQUAL "SHARED_LIBRARY" OR TARGET_TYPE STREQUAL "STATIC_LIBRARY")
+        set_target_properties(${TARGET_NAME} PROPERTIES PREFIX "lib")
+    endif ()
+
     # Core compilation settings affecting "index.hpp"
     target_compile_definitions(${TARGET_NAME} PRIVATE $<$<NOT:$<BOOL:${USEARCH_USE_OPENMP}>>:USEARCH_USE_OPENMP=0>)
 

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "usearch"
-version = "2.7.7"
+version = "2.8.0"
 authors = ["Ash Vardanian <1983160+ashvardanian@users.noreply.github.com>"]
 description = "Smaller & Faster Single-File Vector Search Engine from Unum"
 edition = "2021"

package/README.md

@@ -392,7 +392,7 @@ doi = {10.5281/zenodo.7949416},
 author = {Vardanian, Ash},
 title = {{USearch by Unum Cloud}},
 url = {https://github.com/unum-cloud/usearch},
-version = {2.7.7},
+version = {2.8.0},
 year = {2023},
 month = oct,
 }

package/build.gradle

@@ -36,6 +36,11 @@ task sourcesJar(type: Jar, dependsOn: classes) {
     from sourceSets.main.allSource
 }
 
+task javadocJar(type: Jar, dependsOn: javadoc) {
+    archiveClassifier.set('javadoc')
+    from javadoc.destinationDir
+}
+
 dependencies {
     testImplementation('junit:junit:4.13.2')
 }
@@ -117,6 +122,7 @@ publishing {
             from components.java
             
             artifact sourcesJar
+            artifact javadocJar
 
             if (project.hasProperty('signArtifacts') && signArtifacts.toBoolean()) {
                 signing {

package/c/README.md

@@ -6,9 +6,9 @@ The simplest form to integrate is to copy the contents of `usearch/c/` into your
 To build the library `libusearch_static_c` and `libusearch_c`, pass enable the `USEARCH_BUILD_LIB_C` CMake option:
 
 ```bash
-cmake -B ./build -DUSEARCH_BUILD_LIB_C=1 -DUSEARCH_BUILD_TEST_C=1 -DUSEARCH_BUILD_TEST_CPP=0 -DUSEARCH_BUILD_BENCH_CPP=0
-make -C ./build
-./build/test_c
+cmake -DCMAKE_BUILD_TYPE=Release -DUSEARCH_BUILD_LIB_C=1 -DUSEARCH_BUILD_TEST_C=1 -DUSEARCH_BUILD_TEST_CPP=0 -DUSEARCH_BUILD_BENCH_CPP=0 -B ./build_release
+cmake --build ./build_release --config Release
+./build_release/test_c
 ```
 
 ## Quickstart

package/c/lib.cpp

@@ -13,16 +13,16 @@ using add_result_t = typename index_dense_t::add_result_t;
 using search_result_t = typename index_dense_t::search_result_t;
 using labeling_result_t = typename index_dense_t::labeling_result_t;
 
-static_assert(std::is_same<usearch_key_t, index_dense_t::key_t>::value, "Type mismatch between C and C++");
+static_assert(std::is_same<usearch_key_t, index_dense_t::vector_key_t>::value, "Type mismatch between C and C++");
 static_assert(std::is_same<usearch_distance_t, index_dense_t::distance_t>::value, "Type mismatch between C and C++");
 
-// helper functions that are not part of the C ABI
-metric_kind_t to_native_metric(usearch_metric_kind_t kind) {
+metric_kind_t metric_kind_to_cpp(usearch_metric_kind_t kind) {
     switch (kind) {
     case usearch_metric_ip_k: return metric_kind_t::ip_k;
     case usearch_metric_l2sq_k: return metric_kind_t::l2sq_k;
     case usearch_metric_cos_k: return metric_kind_t::cos_k;
     case usearch_metric_haversine_k: return metric_kind_t::haversine_k;
+    case usearch_metric_divergence_k: return metric_kind_t::divergence_k;
     case usearch_metric_pearson_k: return metric_kind_t::pearson_k;
     case usearch_metric_jaccard_k: return metric_kind_t::jaccard_k;
     case usearch_metric_hamming_k: return metric_kind_t::hamming_k;
@@ -32,7 +32,22 @@ metric_kind_t to_native_metric(usearch_metric_kind_t kind) {
     }
 }
 
-scalar_kind_t to_native_scalar(usearch_scalar_kind_t kind) {
+usearch_metric_kind_t metric_kind_to_c(metric_kind_t kind) {
+    switch (kind) {
+    case metric_kind_t::ip_k: return usearch_metric_ip_k;
+    case metric_kind_t::l2sq_k: return usearch_metric_l2sq_k;
+    case metric_kind_t::cos_k: return usearch_metric_cos_k;
+    case metric_kind_t::haversine_k: return usearch_metric_haversine_k;
+    case metric_kind_t::divergence_k: return usearch_metric_divergence_k;
+    case metric_kind_t::pearson_k: return usearch_metric_pearson_k;
+    case metric_kind_t::jaccard_k: return usearch_metric_jaccard_k;
+    case metric_kind_t::hamming_k: return usearch_metric_hamming_k;
+    case metric_kind_t::tanimoto_k: return usearch_metric_tanimoto_k;
+    case metric_kind_t::sorensen_k: return usearch_metric_sorensen_k;
+    default: return usearch_metric_unknown_k;
+    }
+}
+scalar_kind_t scalar_kind_to_cpp(usearch_scalar_kind_t kind) {
     switch (kind) {
     case usearch_scalar_f32_k: return scalar_kind_t::f32_k;
     case usearch_scalar_f64_k: return scalar_kind_t::f64_k;
@@ -43,6 +58,17 @@ scalar_kind_t to_native_scalar(usearch_scalar_kind_t kind) {
     }
 }
 
+usearch_scalar_kind_t scalar_kind_to_c(scalar_kind_t kind) {
+    switch (kind) {
+    case scalar_kind_t::f32_k: return usearch_scalar_f32_k;
+    case scalar_kind_t::f64_k: return usearch_scalar_f64_k;
+    case scalar_kind_t::f16_k: return usearch_scalar_f16_k;
+    case scalar_kind_t::i8_k: return usearch_scalar_i8_k;
+    case scalar_kind_t::b1x8_k: return usearch_scalar_b1_k;
+    default: return usearch_scalar_unknown_k;
+    }
+}
+
 add_result_t add_(index_dense_t* index, usearch_key_t key, void const* vector, scalar_kind_t kind) {
     switch (kind) {
     case scalar_kind_t::f32_k: return index->add(key, (f32_t const*)vector);
@@ -84,8 +110,8 @@ USEARCH_EXPORT usearch_index_t usearch_init(usearch_init_options_t* options, use
 
     index_dense_config_t config(options->connectivity, options->expansion_add, options->expansion_search);
     config.multi = options->multi;
-    metric_kind_t metric_kind = to_native_metric(options->metric_kind);
-    scalar_kind_t scalar_kind = to_native_scalar(options->quantization);
+    metric_kind_t metric_kind = metric_kind_to_cpp(options->metric_kind);
+    scalar_kind_t scalar_kind = scalar_kind_to_cpp(options->quantization);
 
     metric_punned_t metric = //
         !options->metric ? metric_punned_t(options->dimensions, metric_kind, scalar_kind)
@@ -134,6 +160,24 @@ USEARCH_EXPORT void usearch_view(usearch_index_t index, char const* path, usearc
         *error = result.error.release();
 }
 
+USEARCH_EXPORT void usearch_metadata(char const* path, usearch_init_options_t* options, usearch_error_t* error) {
+
+    assert(path && options && error);
+    index_dense_metadata_result_t result = index_dense_metadata_from_path(path);
+    if (!result)
+        *error = result.error.release();
+
+    options->metric_kind = metric_kind_to_c(result.head.kind_metric);
+    options->quantization = scalar_kind_to_c(result.head.kind_scalar);
+    options->dimensions = result.head.dimensions;
+    options->multi = result.head.multi;
+
+    options->connectivity = 0;
+    options->expansion_add = 0;
+    options->expansion_search = 0;
+    options->metric = NULL;
+}
+
 USEARCH_EXPORT void usearch_save_buffer(usearch_index_t index, void* buffer, size_t length, usearch_error_t* error) {
 
     assert(index && buffer && length && error);
@@ -163,6 +207,26 @@ USEARCH_EXPORT void usearch_view_buffer(usearch_index_t index, void const* buffe
         *error = result.error.release();
 }
 
+USEARCH_EXPORT void usearch_metadata_buffer(void const* buffer, size_t length, usearch_init_options_t* options,
+                                            usearch_error_t* error) {
+
+    assert(buffer && length && options && error);
+    index_dense_metadata_result_t result =
+        index_dense_metadata_from_buffer(memory_mapped_file_t((byte_t*)(buffer), length));
+    if (!result)
+        *error = result.error.release();
+
+    options->metric_kind = metric_kind_to_c(result.head.kind_metric);
+    options->quantization = scalar_kind_to_c(result.head.kind_scalar);
+    options->dimensions = result.head.dimensions;
+    options->multi = result.head.multi;
+
+    options->connectivity = 0;
+    options->expansion_add = 0;
+    options->expansion_search = 0;
+    options->metric = NULL;
+}
+
 USEARCH_EXPORT size_t usearch_size(usearch_index_t index, usearch_error_t*) { //
     return reinterpret_cast<index_dense_t*>(index)->size();
 }
@@ -190,7 +254,7 @@ USEARCH_EXPORT void usearch_add(
     usearch_error_t* error) {
 
     assert(index && vector && error);
-    add_result_t result = add_(reinterpret_cast<index_dense_t*>(index), key, vector, to_native_scalar(kind));
+    add_result_t result = add_(reinterpret_cast<index_dense_t*>(index), key, vector, scalar_kind_to_cpp(kind));
     if (!result)
         *error = result.error.release();
 }
@@ -211,7 +275,7 @@ USEARCH_EXPORT size_t usearch_search(
 
     assert(index && vector && error);
     search_result_t result =
-        search_(reinterpret_cast<index_dense_t*>(index), vector, to_native_scalar(kind), results_limit);
+        search_(reinterpret_cast<index_dense_t*>(index), vector, scalar_kind_to_cpp(kind), results_limit);
     if (!result) {
         *error = result.error.release();
         return 0;
@@ -225,7 +289,7 @@ USEARCH_EXPORT size_t usearch_get(                          //
     void* vectors, usearch_scalar_kind_t kind, usearch_error_t*) {
 
     assert(index && vectors);
-    return get_(reinterpret_cast<index_dense_t*>(index), key, count, vectors, to_native_scalar(kind));
+    return get_(reinterpret_cast<index_dense_t*>(index), key, count, vectors, scalar_kind_to_cpp(kind));
 }
 
 USEARCH_EXPORT size_t usearch_remove(usearch_index_t index, usearch_key_t key, usearch_error_t* error) {
@@ -253,7 +317,7 @@ USEARCH_EXPORT usearch_distance_t usearch_distance(       //
     usearch_metric_kind_t metric_kind, usearch_error_t* error) {
 
     (void)error;
-    metric_punned_t metric(dimensions, to_native_metric(metric_kind), to_native_scalar(scalar_kind));
+    metric_punned_t metric(dimensions, metric_kind_to_cpp(metric_kind), scalar_kind_to_cpp(scalar_kind));
     return metric((byte_t const*)vector_first, (byte_t const*)vector_second);
 }
 
@@ -266,7 +330,7 @@ USEARCH_EXPORT void usearch_exact_search(                             //
     usearch_distance_t* distances, size_t distances_stride,           //
     usearch_error_t* error) {
 
-    metric_punned_t metric(dimensions, to_native_metric(metric_kind), to_native_scalar(scalar_kind));
+    metric_punned_t metric(dimensions, metric_kind_to_cpp(metric_kind), scalar_kind_to_cpp(scalar_kind));
     executor_default_t executor(threads);
     static exact_search_t search;
     exact_search_results_t result = search(                    //

package/c/usearch.h

@@ -14,7 +14,8 @@ extern "C" {
 #endif
 
 #include <stdbool.h> // `bool`
-#include <stdint.h>  // `size_t`
+#include <stddef.h>  // `size_t`
+#include <stdint.h>  // `uint64_t`
 
 USEARCH_EXPORT typedef void* usearch_index_t;
 USEARCH_EXPORT typedef uint64_t usearch_key_t;
@@ -42,6 +43,7 @@ USEARCH_EXPORT typedef enum usearch_metric_kind_t {
     usearch_metric_ip_k,
     usearch_metric_l2sq_k,
     usearch_metric_haversine_k,
+    usearch_metric_divergence_k,
     usearch_metric_pearson_k,
     usearch_metric_jaccard_k,
     usearch_metric_hamming_k,
@@ -136,6 +138,15 @@ USEARCH_EXPORT void usearch_load(usearch_index_t, char const* path, usearch_erro
  */
 USEARCH_EXPORT void usearch_view(usearch_index_t, char const* path, usearch_error_t* error);
 
+/**
+ *  @brief Loads index metadata from a file.
+ *  @param[in] path The file path from where the index will be loaded.
+ *  @param[out] options Pointer to the `usearch_init_options_t` structure to be populated.
+ *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
+ *  @return A handle to the initialized USearch index, or `NULL` on failure.
+ */
+USEARCH_EXPORT void usearch_metadata(char const* path, usearch_init_options_t* options, usearch_error_t* error);
+
 /**
  *  @brief Saves the index to an in-memory buffer.
  *  @param[in] buffer The in-memory continuous buffer where the index will be saved.
@@ -157,6 +168,16 @@ USEARCH_EXPORT void usearch_load_buffer(usearch_index_t, void const* buffer, siz
  */
 USEARCH_EXPORT void usearch_view_buffer(usearch_index_t, void const* buffer, size_t length, usearch_error_t* error);
 
+/**
+ *  @brief Loads index metadata from an in-memory buffer.
+ *  @param[in] path The file path from where the index will be loaded.
+ *  @param[out] options Pointer to the `usearch_init_options_t` structure to be populated.
+ *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
+ *  @return A handle to the initialized USearch index, or `NULL` on failure.
+ */
+USEARCH_EXPORT void usearch_metadata_buffer(void const* buffer, size_t length, usearch_init_options_t* options,
+                                            usearch_error_t* error);
+
 USEARCH_EXPORT size_t usearch_size(usearch_index_t, usearch_error_t* error);
 USEARCH_EXPORT size_t usearch_capacity(usearch_index_t, usearch_error_t* error);
 USEARCH_EXPORT size_t usearch_dimensions(usearch_index_t, usearch_error_t* error);

package/conanfile.py

@@ -7,7 +7,7 @@ required_conan_version = ">=1.53.0"
 class USearchConan(ConanFile):
 
     name = "usearch"
-    version = '2.7.7'
+    version = '2.8.0'
     license = "Apache-2.0"
     description = "Smaller & Faster Single-File Vector Search Engine from Unum"
     homepage = "https://github.com/unum-cloud/usearch"

package/cpp/README.md

@@ -21,7 +21,7 @@ using namespace unum::usearch;
 metric_punned_t metric(256, metric_kind_t::l2sq_k, scalar_kind_t::f32_k);
 
 // If you plan to store more than 4 Billion entries - use `index_dense_big_t`.
-// Or directly instantiate the template variant you need - `index_dense_gt<key_t, internal_id_t>`.
+// Or directly instantiate the template variant you need - `index_dense_gt<vector_key_t, internal_id_t>`.
 index_dense_t index = index_dense_t::make(metric);
 float vec[3] = {0.1, 0.3, 0.2};
 
@@ -76,6 +76,7 @@ The following distances are pre-packaged:
 - `metric_sorensen_gt<scalar_t>` for "Dice-Sorensen" coefficient for bit-strings.
 - `metric_pearson_gt<scalar_t>` for "Pearson" correlation between probability distributions.
 - `metric_haversine_gt<scalar_t>` for "Haversine" or "Great Circle" distance between coordinates used in GIS applications.
+- `metric_divergence_gt<scalar_t>` for the "Jensen Shannon" similarity between probability distributions.
 
 ## Multi-Threading
 

package/cpp/bench.cpp

@@ -447,6 +447,7 @@ struct args_t {
     bool metric_l2 = false;
     bool metric_cos = false;
     bool metric_haversine = false;
+    bool metric_divergence = false;
     bool metric_hamming = false;
     bool metric_tanimoto = false;
     bool metric_sorensen = false;
@@ -458,6 +459,8 @@ struct args_t {
             return metric_kind_t::cos_k;
         if (metric_haversine)
             return metric_kind_t::haversine_k;
+        if (metric_divergence)
+            return metric_kind_t::divergence_k;
         if (metric_hamming)
             return metric_kind_t::hamming_k;
         if (metric_tanimoto)

package/cpp/test.cpp

@@ -25,15 +25,15 @@ void test_cosine(index_at& index, std::vector<std::vector<scalar_at>> const& vec
 
     using scalar_t = scalar_at;
     using index_t = index_at;
-    using key_t = typename index_t::key_t;
+    using vector_key_t = typename index_t::vector_key_t;
     using distance_t = typename index_t::distance_t;
 
     // Generate some keys starting from end,
     // for three vectors from the dataset
-    key_t const key_max = default_free_value<key_t>() - 1;
-    key_t const key_first = key_max - 0;
-    key_t const key_second = key_max - 1;
-    key_t const key_third = key_max - 2;
+    vector_key_t const key_max = default_free_value<vector_key_t>() - 1;
+    vector_key_t const key_first = key_max - 0;
+    vector_key_t const key_second = key_max - 1;
+    vector_key_t const key_third = key_max - 2;
     scalar_t const* vector_first = vectors[0].data();
     scalar_t const* vector_second = vectors[1].data();
     scalar_t const* vector_third = vectors[2].data();
@@ -50,7 +50,7 @@ void test_cosine(index_at& index, std::vector<std::vector<scalar_at>> const& vec
     index.add(key_first, vector_first, args...);
 
     // Default approximate search
-    key_t matched_keys[10] = {0};
+    vector_key_t matched_keys[10] = {0};
     distance_t matched_distances[10] = {0};
     std::size_t matched_count = index.search(vector_first, 5, args...).dump_to(matched_keys, matched_distances);
 
@@ -69,7 +69,7 @@ void test_cosine(index_at& index, std::vector<std::vector<scalar_at>> const& vec
     // Validate scans
     std::size_t count = 0;
     for (auto member : index) {
-        key_t id = member.key;
+        vector_key_t id = member.key;
         expect(id <= key_first && id >= key_third);
         count++;
     }
@@ -159,10 +159,10 @@ template <typename scalar_at, typename key_at, typename slot_at> //
 void test_cosine(std::size_t collection_size, std::size_t dimensions) {
 
     using scalar_t = scalar_at;
-    using key_t = key_at;
+    using vector_key_t = key_at;
     using slot_t = slot_at;
 
-    using index_typed_t = index_gt<float, key_t, slot_t>;
+    using index_typed_t = index_gt<float, vector_key_t, slot_t>;
     using member_cref_t = typename index_typed_t::member_cref_t;
     using member_citerator_t = typename index_typed_t::member_citerator_t;
 
@@ -205,7 +205,7 @@ void test_cosine(std::size_t collection_size, std::size_t dimensions) {
     for (bool multi : {false, true}) {
         for (std::size_t connectivity : {3, 13, 50}) {
             std::printf("- punned with connectivity %zu \n", connectivity);
-            using index_t = index_dense_gt<key_t, slot_t>;
+            using index_t = index_dense_gt<vector_key_t, slot_t>;
             metric_punned_t metric(dimensions, metric_kind_t::cos_k, scalar_kind<scalar_at>());
             index_dense_config_t config(connectivity);
             config.multi = multi;
@@ -217,10 +217,10 @@ void test_cosine(std::size_t collection_size, std::size_t dimensions) {
 
 template <typename key_at, typename slot_at> void test_tanimoto(std::size_t dimensions, std::size_t connectivity) {
 
-    using key_t = key_at;
+    using vector_key_t = key_at;
     using slot_t = slot_at;
 
-    using index_punned_t = index_dense_gt<key_t, slot_t>;
+    using index_punned_t = index_dense_gt<vector_key_t, slot_t>;
     std::size_t words = divide_round_up<CHAR_BIT>(dimensions);
     metric_punned_t metric(words, metric_kind_t::tanimoto_k, scalar_kind_t::b1x8_k);
     index_config_t config(connectivity);

package/csharp/nuget/nuget-package.props

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project>
   <PropertyGroup>
-    <Version Condition="'$(Version)' == ''">2.7.7</Version>
+    <Version Condition="'$(Version)' == ''">2.8.0</Version>
 
     <Authors>Unum</Authors>
     <Company>Unum</Company>

package/docs/compilation.md

@@ -23,6 +23,7 @@ cmake -B ./build_release \
     -DUSEARCH_BUILD_BENCH_CPP=1 \
     -DUSEARCH_BUILD_LIB_C=1 \
     -DUSEARCH_BUILD_TEST_C=1 \
+    -DUSEARCH_USE_NATIVE_F16=1 \
     && \
     make -C ./build_release -j
 ```
@@ -157,18 +158,6 @@ swift test -v
 There are a few ways to compile the C 99 USearch SDK.
 Using the Makefile, specifying the targets you need:
 
-```sh
-make -C ./c libusearch_c.so
-```
-
-With options:
-
-```sh
-make USEARCH_USE_OPENMP=1 USEARCH_USE_SIMSIMD=1 -C ./c libusearch_c.so
-```
-
-Using CMake:
-
 ```sh
 cmake -B ./build_release -DUSEARCH_BUILD_LIB_C=1 -DUSEARCH_BUILD_TEST_C=1 -DUSEARCH_USE_OPENMP=1 -DUSEARCH_USE_SIMSIMD=1 
 cmake --build ./build_release --config Release -j
@@ -183,7 +172,10 @@ GoLang bindings are based on C.
 So one should first compile the C library, link it with GoLang, and only then run tests.
 
 ```sh
-make -C ./c libusearch_c.so && mv ./c/libusearch_c.so ./golang/ && cp ./c/usearch.h ./golang/
+cmake -B ./build_release -DUSEARCH_BUILD_LIB_C=1 -DUSEARCH_BUILD_TEST_C=1 -DUSEARCH_USE_OPENMP=1 -DUSEARCH_USE_SIMSIMD=1 
+cmake --build ./build_release --config Release -j
+mv ./c/libusearch_c.so ./golang/
+cp ./c/usearch.h ./golang/
 cd golang && go test -v ; cd ..
 ```
 

package/golang/lib.go

@@ -6,7 +6,7 @@ import (
 )
 
 /*
-#cgo LDFLAGS: -L. -lusearch_c
+#cgo LDFLAGS: -L. -L/usr/local/lib -lusearch_c
 #include "usearch.h"
 #include <stdlib.h>
 */
@@ -21,6 +21,7 @@ const (
 	Cosine
 	L2sq
 	Haversine
+	Divergence
 	Pearson
 	Hamming
 	Tanimoto
@@ -37,6 +38,8 @@ func (m Metric) String() string {
 		return "cos"
 	case Haversine:
 		return "haversine"
+	case Divergence:
+		return "divergence"
 	case Pearson:
 		return "pearson"
 	case Hamming: