usearch 2.9.0 → 2.9.2

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.9.0
+version: 2.9.2
 doi: 10.5281/zenodo.7949416
 date-released: 2023-10-22
 url: "https://github.com/unum-cloud/usearch"

package/CONTRIBUTING.md

@@ -104,6 +104,13 @@ cppcheck --enable=all --force --suppress=cstyleCast --suppress=unusedFunction \
     include/index_plugins.hpp
 ```
 
+I'd recommend putting the following breakpoints when debugging the code in GDB:
+
+- `__asan::ReportGenericError` - to detect illegal memory accesses.
+- `__ubsan::ScopedReport::~ScopedReport` - to catch undefined behavior.
+- `__GI_exit` - to stop at exit points - the end of running any executable.
+- `__builtin_unreachable` - to catch all the places where the code is expected to be unreachable.
+
 ## Python 3
 
 Python bindings are built using PyBind11 and are available on [PyPi](https://pypi.org/project/usearch/).
@@ -215,10 +222,11 @@ USearch provides both Objective-C and Swift bindings through the [Swift Package
 The compilation settings are controlled by the `Package.swift` and are independent from CMake used for C/C++ builds.
 
 ```sh
-swift build
-swift test -v
+swift build && swift test -v
 ```
 
+Those depend on Apple's `Foundation` library and can only run on Apple devices.
+
 ## GoLang
 
 USearch provides GoLang bindings, that depend on the C library that must be installed beforehand.
@@ -291,6 +299,32 @@ cp cloud/unum/usearch/libusearch.* .
 java -cp . -Djava.library.path="$(pwd)" cloud.unum.usearch.Index
 ```
 
+## C#
+
+Setup the .NET environment:
+
+```sh
+dotnet nuget add source https://api.nuget.org/v3/index.json -n nuget.org
+```
+
+USearch provides CSharp bindings, that depend on the C library that must be installed beforehand.
+So one should first compile the C library, link it with CSharp, and only then run tests.
+
+```sh
+cmake -B ./build_artifacts -DUSEARCH_BUILD_LIB_C=1 -DUSEARCH_BUILD_TEST_C=1 -DUSEARCH_USE_OPENMP=1 -DUSEARCH_USE_SIMSIMD=1 
+cmake --build ./build_artifacts --config Release -j
+```
+
+Then, on Windows, copy the library to the CSharp project and run the tests:
+
+```sh
+mkdir -p ".\csharp\lib\runtimes\win-x64\native"
+cp ".\build_artifacts\libusearch_c.dll" ".\csharp\lib\runtimes\win-x64\native"
+cd csharp
+dotnet test -c Debug --logger "console;verbosity=detailed"
+dotnet test -c Release
+```
+
 ## Wolfram
 
 ```sh

package/Cargo.toml

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

package/README.md

@@ -30,19 +30,18 @@ Spatial • Binary • Probabilistic • User-Defined Metrics
 <a href="https://unum-cloud.github.io/usearch/swift">Swift</a> •
 <a href="https://unum-cloud.github.io/usearch/csharp">C#</a> •
 <a href="https://unum-cloud.github.io/usearch/golang">GoLang</a> •
-<a href="https://unum-cloud.github.io/usearch/wolfram">Wolfram</a> •
-<a href="https://unum-cloud.github.io/usearch/sqlite">SQLite3</a>
+<a href="https://unum-cloud.github.io/usearch/wolfram">Wolfram</a>
 <br/>
-Linux • MacOS • Windows • iOS • WebAssembly
+Linux • MacOS • Windows • iOS • WebAssembly •
+<a href="https://unum-cloud.github.io/usearch/sqlite">SQLite3</a>
 </p>
 
 <div align="center">
-<a href="https://pepy.tech/project/usearch"> <img alt="PyPI" src="https://static.pepy.tech/personalized-badge/usearch?period=total&units=abbreviation&left_color=black&right_color=blue&left_text=USearch%20Python%20installs"> </a>
-<a href="https://www.npmjs.com/package/usearch"> <img alt="NPM" src="https://img.shields.io/npm/dy/usearch?label=NPM%20installs"> </a>
-<a href="https://crates.io/crates/usearch"> <img alt="Crate" src="https://img.shields.io/crates/d/usearch?label=Crate%20installs"> </a>
-<a href="https://www.nuget.org/packages/Cloud.Unum.USearch"> <img alt="NuGet" src="https://img.shields.io/nuget/dt/Cloud.Unum.USearch?label=NuGet%20installs"> </a>
-<a href="https://central.sonatype.com/artifact/cloud.unum/usearch/overview"> <img alt="Maven" src="https://img.shields.io/nexus/r/cloud.unum/usearch?server=https%3A%2F%2Fs01.oss.sonatype.org%2F&label=Maven%20version"> </a>
-<a href="https://hub.docker.com/r/unum/usearch"> <img alt="Docker" src="https://img.shields.io/docker/pulls/unum/usearch?label=Docker%20installs"> </a>
+<a href="https://pepy.tech/project/usearch"> <img alt="PyPI" src="https://static.pepy.tech/personalized-badge/usearch?period=total&units=abbreviation&left_color=black&right_color=blue&left_text=Python%20PyPi%20installs"> </a>
+<a href="https://www.npmjs.com/package/usearch"> <img alt="NPM" src="https://img.shields.io/npm/dy/usearch?label=JavaScript%20NPM%20installs"> </a>
+<a href="https://crates.io/crates/usearch"> <img alt="Crate" src="https://img.shields.io/crates/d/usearch?label=Rust%20Crate%20installs"> </a>
+<a href="https://www.nuget.org/packages/Cloud.Unum.USearch"> <img alt="NuGet" src="https://img.shields.io/nuget/dt/Cloud.Unum.USearch?label=CSharp%20NuGet%20installs"> </a>
+<a href="https://central.sonatype.com/artifact/cloud.unum/usearch/overview"> <img alt="Maven" src="https://img.shields.io/nexus/r/cloud.unum/usearch?server=https%3A%2F%2Fs01.oss.sonatype.org%2F&label=Java%20Maven%20version"> </a>
 <img alt="GitHub code size in bytes" src="https://img.shields.io/github/languages/code-size/unum-cloud/usearch?label=Repo%20size">
 </div>
 
@@ -50,18 +49,16 @@ Linux • MacOS • Windows • iOS • WebAssembly
 
 - ✅ __[10x faster][faster-than-faiss]__ [HNSW][hnsw-algorithm] implementation than [FAISS][faiss].
 - ✅ Simple and extensible [single C++11 header][usearch-header] __library__.
-- ✅ Compatible with a dozen programming languages out of the box.
 - ✅ [Trusted](#integrations) by giants like Google and databases like [ClickHouse][clickhouse-docs].
 - ✅ [SIMD][simd]-optimized and [user-defined metrics](#user-defined-functions) with JIT compilation.
 - ✅ Hardware-agnostic `f16` & `i8` - [half-precision & quarter-precision support](#memory-efficiency-downcasting-and-quantization).
 - ✅ [View large indexes from disk](#serving-index-from-disk) without loading into RAM.
 - ✅ Heterogeneous lookups, renaming/relabeling, and on-the-fly deletions.
-- ✅ Variable dimensionality vectors for unique applications, including search over compressed data.
 - ✅ Binary Tanimoto and Sorensen coefficients for [Genomics and Chemistry applications](#usearch--rdkit--molecular-search).
 - ✅ Space-efficient point-clouds with `uint40_t`, accommodating 4B+ size.
-- ✅ Compatible with OpenMP and custom "executors" for fine-grained control over CPU utilization.
-- ✅ Near-real-time [clustering and sub-clustering](#clustering) for Tens or Millions of clusters.
+- ✅ Compatible with OpenMP and custom "executors" for fine-grained parallelism.
 - ✅ [Semantic Search](#usearch--ai--multi-modal-semantic-search) and [Joins](#joins-one-to-one-one-to-many-and-many-to-many-mappings).
+- 🔄 Near-real-time [clustering and sub-clustering](#clustering) for Tens or Millions of clusters.
 
 [faiss]: https://github.com/facebookresearch/faiss
 [usearch-header]: https://github.com/unum-cloud/usearch/blob/main/include/usearch/index.hpp
@@ -133,7 +130,7 @@ matches = index.search(vector, 10)
 
 assert matches[0].key == 42
 assert matches[0].distance <= 0.001
-assert np.allclose(index[42], vector)
+assert np.allclose(index[42], vector, atol=0.1) # Ensure high tolerance in mixed-precision comparisons
 ```
 
 More settings are always available, and the API is designed to be as flexible as possible.
@@ -434,7 +431,7 @@ doi = {10.5281/zenodo.7949416},
 author = {Vardanian, Ash},
 title = {{USearch by Unum Cloud}},
 url = {https://github.com/unum-cloud/usearch},
-version = {2.9.0},
+version = {2.9.2},
 year = {2023},
 month = oct,
 }

package/VERSION

@@ -1 +1 @@
-2.9.0
+2.9.2

package/c/lib.cpp

@@ -106,7 +106,7 @@ extern "C" {
 
 USEARCH_EXPORT usearch_index_t usearch_init(usearch_init_options_t* options, usearch_error_t* error) {
 
-    assert(options && error);
+    assert(options && error && "Missing arguments");
 
     index_dense_config_t config(options->connectivity, options->expansion_add, options->expansion_search);
     config.multi = options->multi;
@@ -132,13 +132,13 @@ USEARCH_EXPORT void usearch_free(usearch_index_t index, usearch_error_t*) {
 }
 
 USEARCH_EXPORT size_t usearch_serialized_length(usearch_index_t index, usearch_error_t*) {
-    assert(index);
+    assert(index && "Missing arguments");
     return reinterpret_cast<index_dense_t*>(index)->serialized_length();
 }
 
 USEARCH_EXPORT void usearch_save(usearch_index_t index, char const* path, usearch_error_t* error) {
 
-    assert(index && path && error);
+    assert(index && path && error && "Missing arguments");
     serialization_result_t result = reinterpret_cast<index_dense_t*>(index)->save(path);
     if (!result)
         *error = result.error.release();
@@ -146,7 +146,7 @@ USEARCH_EXPORT void usearch_save(usearch_index_t index, char const* path, usearc
 
 USEARCH_EXPORT void usearch_load(usearch_index_t index, char const* path, usearch_error_t* error) {
 
-    assert(index && path && error);
+    assert(index && path && error && "Missing arguments");
     serialization_result_t result = reinterpret_cast<index_dense_t*>(index)->load(path);
     if (!result)
         *error = result.error.release();
@@ -154,7 +154,7 @@ USEARCH_EXPORT void usearch_load(usearch_index_t index, char const* path, usearc
 
 USEARCH_EXPORT void usearch_view(usearch_index_t index, char const* path, usearch_error_t* error) {
 
-    assert(index && path && error);
+    assert(index && path && error && "Missing arguments");
     serialization_result_t result = reinterpret_cast<index_dense_t*>(index)->view(path);
     if (!result)
         *error = result.error.release();
@@ -162,7 +162,7 @@ USEARCH_EXPORT void usearch_view(usearch_index_t index, char const* path, usearc
 
 USEARCH_EXPORT void usearch_metadata(char const* path, usearch_init_options_t* options, usearch_error_t* error) {
 
-    assert(path && options && error);
+    assert(path && options && error && "Missing arguments");
     index_dense_metadata_result_t result = index_dense_metadata_from_path(path);
     if (!result)
         *error = result.error.release();
@@ -180,7 +180,7 @@ USEARCH_EXPORT void usearch_metadata(char const* path, usearch_init_options_t* o
 
 USEARCH_EXPORT void usearch_save_buffer(usearch_index_t index, void* buffer, size_t length, usearch_error_t* error) {
 
-    assert(index && buffer && length && error);
+    assert(index && buffer && length && error && "Missing arguments");
     memory_mapped_file_t memory_map((byte_t*)buffer, length);
     serialization_result_t result = reinterpret_cast<index_dense_t*>(index)->save(std::move(memory_map));
     if (!result)
@@ -190,7 +190,7 @@ USEARCH_EXPORT void usearch_save_buffer(usearch_index_t index, void* buffer, siz
 USEARCH_EXPORT void usearch_load_buffer(usearch_index_t index, void const* buffer, size_t length,
                                         usearch_error_t* error) {
 
-    assert(index && buffer && length && error);
+    assert(index && buffer && length && error && "Missing arguments");
     memory_mapped_file_t memory_map((byte_t*)buffer, length);
     serialization_result_t result = reinterpret_cast<index_dense_t*>(index)->load(std::move(memory_map));
     if (!result)
@@ -200,7 +200,7 @@ USEARCH_EXPORT void usearch_load_buffer(usearch_index_t index, void const* buffe
 USEARCH_EXPORT void usearch_view_buffer(usearch_index_t index, void const* buffer, size_t length,
                                         usearch_error_t* error) {
 
-    assert(index && buffer && length && error);
+    assert(index && buffer && length && error && "Missing arguments");
     memory_mapped_file_t memory_map((byte_t*)buffer, length);
     serialization_result_t result = reinterpret_cast<index_dense_t*>(index)->view(std::move(memory_map));
     if (!result)
@@ -210,7 +210,7 @@ USEARCH_EXPORT void usearch_view_buffer(usearch_index_t index, void const* buffe
 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);
+    assert(buffer && length && options && error && "Missing arguments");
     index_dense_metadata_result_t result =
         index_dense_metadata_from_buffer(memory_mapped_file_t((byte_t*)(buffer), length));
     if (!result)
@@ -244,7 +244,7 @@ USEARCH_EXPORT size_t usearch_connectivity(usearch_index_t index, usearch_error_
 }
 
 USEARCH_EXPORT void usearch_reserve(usearch_index_t index, size_t capacity, usearch_error_t* error) {
-    assert(index && error);
+    assert(index && error && "Missing arguments");
     if (!reinterpret_cast<index_dense_t*>(index)->reserve(capacity))
         *error = "Out of memory!";
 }
@@ -253,19 +253,19 @@ USEARCH_EXPORT void usearch_add(
     usearch_index_t index, usearch_key_t key, void const* vector, usearch_scalar_kind_t kind, //
     usearch_error_t* error) {
 
-    assert(index && vector && error);
+    assert(index && vector && error && "Missing arguments");
     add_result_t result = add_(reinterpret_cast<index_dense_t*>(index), key, vector, scalar_kind_to_cpp(kind));
     if (!result)
         *error = result.error.release();
 }
 
 USEARCH_EXPORT bool usearch_contains(usearch_index_t index, usearch_key_t key, usearch_error_t*) {
-    assert(index);
+    assert(index && "Missing arguments");
     return reinterpret_cast<index_dense_t*>(index)->contains(key);
 }
 
 USEARCH_EXPORT size_t usearch_count(usearch_index_t index, usearch_key_t key, usearch_error_t*) {
-    assert(index);
+    assert(index && "Missing arguments");
     return reinterpret_cast<index_dense_t*>(index)->count(key);
 }
 
@@ -273,7 +273,7 @@ USEARCH_EXPORT size_t usearch_search(
     usearch_index_t index, void const* vector, usearch_scalar_kind_t kind, size_t results_limit, //
     usearch_key_t* found_keys, usearch_distance_t* found_distances, usearch_error_t* error) {
 
-    assert(index && vector && error);
+    assert(index && vector && error && "Missing arguments");
     search_result_t result =
         search_(reinterpret_cast<index_dense_t*>(index), vector, scalar_kind_to_cpp(kind), results_limit);
     if (!result) {
@@ -294,7 +294,7 @@ USEARCH_EXPORT size_t usearch_get(                          //
 
 USEARCH_EXPORT size_t usearch_remove(usearch_index_t index, usearch_key_t key, usearch_error_t* error) {
 
-    assert(index && error);
+    assert(index && error && "Missing arguments");
     labeling_result_t result = reinterpret_cast<index_dense_t*>(index)->remove(key);
     if (!result)
         *error = result.error.release();
@@ -304,7 +304,7 @@ USEARCH_EXPORT size_t usearch_remove(usearch_index_t index, usearch_key_t key, u
 USEARCH_EXPORT size_t usearch_rename( //
     usearch_index_t index, usearch_key_t from, usearch_key_t to, usearch_error_t* error) {
 
-    assert(index && error);
+    assert(index && error && "Missing arguments");
     labeling_result_t result = reinterpret_cast<index_dense_t*>(index)->rename(from, to);
     if (!result)
         *error = result.error.release();
@@ -330,6 +330,8 @@ USEARCH_EXPORT void usearch_exact_search(                             //
     usearch_distance_t* distances, size_t distances_stride,           //
     usearch_error_t* error) {
 
+    assert(dataset && queries && keys && distances && error && "Missing arguments");
+
     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;

package/c/test.c

@@ -1,5 +1,5 @@
 #include <errno.h>
-#include <stdio.h>
+#include <stdio.h> // `remove`
 #include <stdlib.h>
 #include <sys/stat.h>
 
@@ -35,6 +35,7 @@ usearch_init_options_t create_options(size_t const dimensions) {
     opts.metric_kind = usearch_metric_ip_k;
     opts.metric = NULL;
     opts.quantization = usearch_scalar_f32_k;
+    opts.multi = false;
     return opts;
 }
 
@@ -45,7 +46,7 @@ usearch_init_options_t create_options(size_t const dimensions) {
  *  dimensions, and connectivity after each operation.
  */
 void test_init(size_t const collection_size, size_t const dimensions) {
-    printf("Test: Index Initialization...\n");
+    printf("Test: Index Initialization... %zu vectors, %zu dimensions \n", collection_size, dimensions);
 
     // Init index
     usearch_error_t error = NULL;
@@ -84,7 +85,7 @@ void test_init(size_t const collection_size, size_t const dimensions) {
  *  size, capacity, and presence of each vector in the index.
  */
 void test_add_vector(size_t const collection_size, size_t const dimensions) {
-    printf("Test: Add Vector...\n");
+    printf("Test: Add Vector... %zu vectors, %zu dimensions \n", collection_size, dimensions);
 
     usearch_error_t error = NULL;
     usearch_init_options_t opts = create_options(dimensions);
@@ -120,7 +121,7 @@ void test_add_vector(size_t const collection_size, size_t const dimensions) {
  *  found in the index, validating the count of found vectors.
  */
 void test_find_vector(size_t const collection_size, size_t const dimensions) {
-    printf("Test: Find Vector...\n");
+    printf("Test: Find Vector... %zu vectors, %zu dimensions \n", collection_size, dimensions);
 
     usearch_error_t error = NULL;
     usearch_init_options_t opts = create_options(dimensions);
@@ -161,7 +162,7 @@ void test_find_vector(size_t const collection_size, size_t const dimensions) {
  *  retrieves vectors associated with the key from the index and checks the count of retrieved vectors.
  */
 void test_get_vector(size_t const collection_size, size_t const dimensions) {
-    printf("Test: Get Vector...\n");
+    printf("Test: Get Vector... %zu vectors, %zu dimensions \n", collection_size, dimensions);
 
     usearch_error_t error = NULL;
     usearch_init_options_t opts = create_options(dimensions);
@@ -198,7 +199,7 @@ void test_get_vector(size_t const collection_size, size_t const dimensions) {
  *  the assert in this test expects an error, indicating that the remove functionality is not currently supported.
  */
 void test_remove_vector(size_t const collection_size, size_t const dimensions) {
-    printf("Test: Remove Vector...\n");
+    printf("Test: Remove Vector... %zu vectors, %zu dimensions \n", collection_size, dimensions);
 
     usearch_error_t error = NULL;
     usearch_init_options_t opts = create_options(dimensions);
@@ -232,48 +233,89 @@ void test_remove_vector(size_t const collection_size, size_t const dimensions) {
  *  from the saved index.
  */
 void test_save_load(size_t const collection_size, size_t const dimensions) {
-    printf("Test: Save/Load...\n");
+    printf("Test: Save/Load... %zu vectors, %zu dimensions \n", collection_size, dimensions);
+    float* data = create_vectors(collection_size, dimensions);
 
     usearch_error_t error = NULL;
     usearch_init_options_t opts = create_options(dimensions);
-    usearch_index_t index = usearch_init(&opts, &error);
-    usearch_reserve(index, collection_size, &error);
+    usearch_init_options_t weird_ops = opts;
+    weird_ops.connectivity = 11;
+    weird_ops.expansion_add = 15;
+    weird_ops.expansion_search = 19;
+    weird_ops.metric_kind = usearch_metric_pearson_k;
+    weird_ops.quantization = usearch_scalar_f64_k;
+
+    {
+
+        usearch_index_t index = usearch_init(&weird_ops, &error);
+        usearch_reserve(index, collection_size, &error);
+
+        // Add vectors
+        for (size_t i = 0; i < collection_size; ++i) {
+            usearch_key_t key = i;
+            usearch_add(index, key, data + i * dimensions, usearch_scalar_f32_k, &error);
+            ASSERT(!error, error);
+        }
 
-    // Add vectors
-    float* data = create_vectors(collection_size, dimensions);
-    for (size_t i = 0; i < collection_size; ++i) {
-        usearch_key_t key = i;
-        usearch_add(index, key, data + i * dimensions, usearch_scalar_f32_k, &error);
+        // Save and free the index
+        usearch_save(index, "tmp.usearch", &error);
+        ASSERT(!error, error);
+        usearch_free(index, &error);
         ASSERT(!error, error);
     }
 
-    // Save and free the index
-    usearch_save(index, "usearch_index.bin", &error);
-    ASSERT(!error, error);
-    usearch_free(index, &error);
-    ASSERT(!error, error);
+    // Reset the options
+    opts.connectivity = 0;
+    opts.dimensions = 0;
+    opts.expansion_add = 0;
+    opts.expansion_search = 0;
+    opts.metric = NULL;
+    opts.quantization = usearch_scalar_unknown_k;
+    opts.metric_kind = usearch_metric_unknown_k;
 
     // Reinit
-    index = usearch_init(&opts, &error);
-    ASSERT(!error, error);
-    ASSERT(usearch_size(index, &error) == 0, error);
+    {
 
-    // Load
-    usearch_load(index, "usearch_index.bin", &error);
-    ASSERT(!error, error);
-    ASSERT(usearch_size(index, &error) == collection_size, error);
-    ASSERT(usearch_capacity(index, &error) == collection_size, error);
-    ASSERT(usearch_dimensions(index, &error) == dimensions, error);
-    ASSERT(usearch_connectivity(index, &error) == opts.connectivity, error);
+        usearch_index_t index = usearch_init(&opts, &error);
+        ASSERT(!error, error);
+        ASSERT(usearch_size(index, &error) == 0, error);
 
-    // Check vectors in the index
-    for (size_t i = 0; i < collection_size; ++i) {
-        usearch_key_t key = i;
-        ASSERT(usearch_contains(index, key, &error), error);
+        // Load
+        usearch_load(index, "tmp.usearch", &error);
+        ASSERT(!error, error);
+        ASSERT(usearch_size(index, &error) == collection_size, error);
+        ASSERT(usearch_capacity(index, &error) == collection_size, error);
+        ASSERT(usearch_dimensions(index, &error) == dimensions, error);
+        ASSERT(usearch_connectivity(index, &error) == weird_ops.connectivity, error);
+
+        // Check vectors in the index
+        for (size_t i = 0; i < collection_size; ++i) {
+            usearch_key_t key = i;
+            ASSERT(usearch_contains(index, key, &error), error);
+        }
+
+        // Create result buffers
+        usearch_key_t* keys = (usearch_key_t*)malloc(collection_size * sizeof(usearch_key_t));
+        float* distances = (float*)malloc(collection_size * sizeof(float));
+        ASSERT(keys && distances, "Failed to allocate memory");
+
+        // Find the vectors
+        for (size_t i = 0; i < collection_size; i++) {
+            size_t found_count = usearch_search(index, data + i * dimensions, usearch_scalar_f32_k, collection_size,
+                                                keys, distances, &error);
+            ASSERT(!error, error);
+            ASSERT(found_count >= 1 && found_count <= collection_size, "Vector is missing");
+        }
+
+        free(keys);
+        free(distances);
+        usearch_free(index, &error);
     }
 
     free(data);
-    usearch_free(index, &error);
+
+    // Remove the file from disk
+    remove("tmp.usearch");
     printf("Test: Save/Load - PASSED\n");
 }
 
@@ -284,7 +326,7 @@ void test_save_load(size_t const collection_size, size_t const dimensions) {
  *  not verify the properties or contents of the viewed index.
  */
 void test_view(size_t const collection_size, size_t const dimensions) {
-    printf("Test: View...\n");
+    printf("Test: View... %zu vectors, %zu dimensions \n", collection_size, dimensions);
 
     usearch_error_t error = NULL;
     usearch_init_options_t opts = create_options(dimensions);
@@ -300,7 +342,7 @@ void test_view(size_t const collection_size, size_t const dimensions) {
     }
 
     // Save and free the index
-    usearch_save(index, "usearch_index.bin", &error);
+    usearch_save(index, "tmp.usearch", &error);
     ASSERT(!error, error);
     usearch_free(index, &error);
     ASSERT(!error, error);
@@ -310,7 +352,7 @@ void test_view(size_t const collection_size, size_t const dimensions) {
     ASSERT(!error, error);
 
     // View
-    usearch_view(index, "usearch_index.bin", &error);
+    usearch_view(index, "tmp.usearch", &error);
     ASSERT(!error, error);
 
     free(data);
@@ -321,7 +363,7 @@ void test_view(size_t const collection_size, size_t const dimensions) {
 int main(int argc, char const* argv[]) {
 
     size_t collection_sizes[] = {11, 512};
-    size_t dimensions[] = {83, 1};
+    size_t dimensions[] = {83, 2}; // Not all distance functions make sense for 1 dimensional data
     for (size_t index = 0; index < sizeof(collection_sizes) / sizeof(collection_sizes[0]); ++index) {
         for (size_t jdx = 0; jdx < sizeof(dimensions) / sizeof(dimensions[0]); ++jdx) {
             test_init(collection_sizes[index], dimensions[jdx]);

package/c/usearch.h

@@ -39,25 +39,25 @@ USEARCH_EXPORT typedef usearch_distance_t (*usearch_metric_t)(void const*, void
  */
 USEARCH_EXPORT typedef enum usearch_metric_kind_t {
     usearch_metric_unknown_k = 0,
-    usearch_metric_cos_k,
-    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,
-    usearch_metric_tanimoto_k,
-    usearch_metric_sorensen_k,
+    usearch_metric_cos_k = 1,
+    usearch_metric_ip_k = 2,
+    usearch_metric_l2sq_k = 3,
+    usearch_metric_haversine_k = 4,
+    usearch_metric_divergence_k = 5,
+    usearch_metric_pearson_k = 6,
+    usearch_metric_jaccard_k = 7,
+    usearch_metric_hamming_k = 8,
+    usearch_metric_tanimoto_k = 9,
+    usearch_metric_sorensen_k = 10,
 } usearch_metric_kind_t;
 
 USEARCH_EXPORT typedef enum usearch_scalar_kind_t {
     usearch_scalar_unknown_k = 0,
-    usearch_scalar_f32_k,
-    usearch_scalar_f64_k,
-    usearch_scalar_f16_k,
-    usearch_scalar_i8_k,
-    usearch_scalar_b1_k,
+    usearch_scalar_f32_k = 1,
+    usearch_scalar_f64_k = 2,
+    usearch_scalar_f16_k = 3,
+    usearch_scalar_i8_k = 4,
+    usearch_scalar_b1_k = 5,
 } usearch_scalar_kind_t;
 
 USEARCH_EXPORT typedef struct usearch_init_options_t {

package/conanfile.py

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

package/include/usearch/index.hpp

@@ -11,7 +11,7 @@
 
 #define USEARCH_VERSION_MAJOR 2
 #define USEARCH_VERSION_MINOR 9
-#define USEARCH_VERSION_PATCH 0
+#define USEARCH_VERSION_PATCH 2
 
 // Inferring C++ version
 // https://stackoverflow.com/a/61552074
@@ -2543,8 +2543,8 @@ class index_gt {
         if (!next.reserve(expansion))
             return result.failed("Out of memory!");
 
-        result.cluster.member =
-            at(search_for_one_(query, metric, prefetch, entry_slot_, max_level_, level - 1, context));
+        result.cluster.member = at(search_for_one_(query, metric, prefetch, entry_slot_, max_level_,
+                                                   static_cast<level_t>(level - 1), context));
         result.cluster.distance = context.measure(query, result.cluster.member, metric);
 
         // Normalize stats
@@ -3422,7 +3422,7 @@ class index_gt {
         distance_t radius = context.measure(query, citerator_at(start_slot), metric);
         next.insert_reserved({-radius, static_cast<compressed_slot_t>(start_slot)});
         top.insert_reserved({radius, static_cast<compressed_slot_t>(start_slot)});
-        visits.set(start_slot);
+        visits.set(static_cast<compressed_slot_t>(start_slot));
 
         while (!next.empty()) {
 
@@ -3496,7 +3496,7 @@ class index_gt {
         distance_t radius = context.measure(query, citerator_at(start_slot), metric);
         next.insert_reserved({-radius, static_cast<compressed_slot_t>(start_slot)});
         top.insert_reserved({radius, static_cast<compressed_slot_t>(start_slot)});
-        visits.set(start_slot);
+        visits.set(static_cast<compressed_slot_t>(start_slot));
 
         while (!next.empty()) {
 

package/include/usearch/index_dense.hpp

@@ -199,7 +199,7 @@ inline index_dense_metadata_result_t index_dense_metadata_from_path(char const*
 
     // Check if it starts with 32-bit
     if (offset_if_u32 + sizeof(index_dense_head_buffer_t) < file_size) {
-        if (std::fseek(file.get(), offset_if_u32, SEEK_SET) != 0)
+        if (std::fseek(file.get(), static_cast<long>(offset_if_u32), SEEK_SET) != 0)
             return result.failed(std::strerror(errno));
         read = std::fread(result.head_buffer, sizeof(index_dense_head_buffer_t), 1, file.get());
         if (!read)
@@ -213,7 +213,7 @@ inline index_dense_metadata_result_t index_dense_metadata_from_path(char const*
 
     // Check if it starts with 64-bit
     if (offset_if_u64 + sizeof(index_dense_head_buffer_t) < file_size) {
-        if (std::fseek(file.get(), offset_if_u64, SEEK_SET) != 0)
+        if (std::fseek(file.get(), static_cast<long>(offset_if_u64), SEEK_SET) != 0)
             return result.failed(std::strerror(errno));
         read = std::fread(result.head_buffer, sizeof(index_dense_head_buffer_t), 1, file.get());
         if (!read)
@@ -929,8 +929,10 @@ class index_dense_gt {
             if (head.kind_compressed_slot != unum::usearch::scalar_kind<compressed_slot_t>())
                 return result.failed("Slot type doesn't match, consider rebuilding");
 
-            metric_ = metric_t(head.dimensions, head.kind_metric, head.kind_scalar);
             config_.multi = head.multi;
+            metric_ = metric_t(head.dimensions, head.kind_metric, head.kind_scalar);
+            cast_buffer_.resize(available_threads_.size() * metric_.bytes_per_vector());
+            casts_ = make_casts_(head.kind_scalar);
         }
 
         // Pull the actual proximity graph
@@ -1013,8 +1015,10 @@ class index_dense_gt {
             if (head.kind_compressed_slot != unum::usearch::scalar_kind<compressed_slot_t>())
                 return result.failed("Slot type doesn't match, consider rebuilding");
 
-            metric_ = metric_t(head.dimensions, head.kind_metric, head.kind_scalar);
             config_.multi = head.multi;
+            metric_ = metric_t(head.dimensions, head.kind_metric, head.kind_scalar);
+            cast_buffer_.resize(available_threads_.size() * metric_.bytes_per_vector());
+            casts_ = make_casts_(head.kind_scalar);
             offset += sizeof(buffer);
         }