usearch 2.9.0 → 2.9.1

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

package/CONTRIBUTING.md

@@ -291,6 +291,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.1"
 authors = ["Ash Vardanian <1983160+ashvardanian@users.noreply.github.com>"]
 description = "Smaller & Faster Single-File Vector Search Engine from Unum"
 edition = "2021"

package/README.md

@@ -434,7 +434,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.1},
 year = {2023},
 month = oct,
 }

package/VERSION

@@ -1 +1 @@
-2.9.0
+2.9.1

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>
 
@@ -236,7 +236,13 @@ void test_save_load(size_t const collection_size, size_t const dimensions) {
 
     usearch_error_t error = NULL;
     usearch_init_options_t opts = create_options(dimensions);
-    usearch_index_t index = usearch_init(&opts, &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
@@ -248,23 +254,32 @@ void test_save_load(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);
 
+    // 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);
+    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) == opts.connectivity, error);
+    ASSERT(usearch_connectivity(index, &error) == weird_ops.connectivity, error);
 
     // Check vectors in the index
     for (size_t i = 0; i < collection_size; ++i) {
@@ -272,8 +287,27 @@ void test_save_load(size_t const collection_size, size_t const dimensions) {
         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(data);
+    free(keys);
+    free(distances);
     usearch_free(index, &error);
+
+    // Remove the file from disk
+    remove("tmp.usearch");
+
     printf("Test: Save/Load - PASSED\n");
 }
 
@@ -300,7 +334,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 +344,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);

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.1'
     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 1
 
 // 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);
         }
 

package/include/usearch/index_plugins.hpp

@@ -1006,10 +1006,11 @@ template <typename scalar_at = float, typename result_at = scalar_at> struct met
 #elif defined(USEARCH_DEFINED_GCC)
 #pragma GCC ivdep
 #endif
-        for (std::size_t i = 0; i != dim; ++i)
-            ab += result_t(a[i]) * result_t(b[i]), //
-                a2 += square<result_t>(a[i]),      //
-                b2 += square<result_t>(b[i]);
+        for (std::size_t i = 0; i != dim; ++i) {
+            result_t ai = static_cast<result_t>(a[i]);
+            result_t bi = static_cast<result_t>(b[i]);
+            ab += ai * bi, a2 += square(ai), b2 += square(bi);
+        }
 
         result_t result_if_zero[2][2];
         result_if_zero[0][0] = 1 - ab / (std::sqrt(a2) * std::sqrt(b2));
@@ -1036,8 +1037,11 @@ template <typename scalar_at = float, typename result_at = scalar_at> struct met
 #elif defined(USEARCH_DEFINED_GCC)
 #pragma GCC ivdep
 #endif
-        for (std::size_t i = 0; i != dim; ++i)
-            ab_deltas_sq += square(result_t(a[i]) - result_t(b[i]));
+        for (std::size_t i = 0; i != dim; ++i) {
+            result_t ai = static_cast<result_t>(a[i]);
+            result_t bi = static_cast<result_t>(b[i]);
+            ab_deltas_sq += square(ai - bi);
+        }
         return ab_deltas_sq;
     }
 };
@@ -1095,9 +1099,10 @@ template <typename scalar_at = std::uint64_t, typename result_at = float> struct
 #elif defined(USEARCH_DEFINED_GCC)
 #pragma GCC ivdep
 #endif
-        for (std::size_t i = 0; i != words; ++i)
-            and_count += std::bitset<bits_per_word_k>(a[i] & b[i]).count(),
-                or_count += std::bitset<bits_per_word_k>(a[i] | b[i]).count();
+        for (std::size_t i = 0; i != words; ++i) {
+            and_count += std::bitset<bits_per_word_k>(a[i] & b[i]).count();
+            or_count += std::bitset<bits_per_word_k>(a[i] | b[i]).count();
+        }
         return 1 - result_t(and_count) / or_count;
     }
 };
@@ -1126,9 +1131,10 @@ template <typename scalar_at = std::uint64_t, typename result_at = float> struct
 #elif defined(USEARCH_DEFINED_GCC)
 #pragma GCC ivdep
 #endif
-        for (std::size_t i = 0; i != words; ++i)
-            and_count += std::bitset<bits_per_word_k>(a[i] & b[i]).count(),
-                any_count += std::bitset<bits_per_word_k>(a[i]).count() + std::bitset<bits_per_word_k>(b[i]).count();
+        for (std::size_t i = 0; i != words; ++i) {
+            and_count += std::bitset<bits_per_word_k>(a[i] & b[i]).count();
+            any_count += std::bitset<bits_per_word_k>(a[i]).count() + std::bitset<bits_per_word_k>(b[i]).count();
+        }
         return 1 - 2 * result_t(and_count) / any_count;
     }
 };
@@ -1176,11 +1182,13 @@ template <typename scalar_at = float, typename result_at = float> struct metric_
 #pragma GCC ivdep
 #endif
         for (std::size_t i = 0; i != dim; ++i) {
-            a_sum += result_t(a[i]);
-            b_sum += result_t(b[i]);
-            ab_sum += result_t(a[i]) * result_t(b[i]);
-            a_sq_sum += result_t(a[i]) * result_t(a[i]);
-            b_sq_sum += result_t(b[i]) * result_t(b[i]);
+            result_t ai = static_cast<result_t>(a[i]);
+            result_t bi = static_cast<result_t>(b[i]);
+            a_sum += ai;
+            b_sum += bi;
+            ab_sum += ai * bi;
+            a_sq_sum += ai * ai;
+            b_sq_sum += bi * bi;
         }
         result_t denom = std::sqrt((dim * a_sq_sum - a_sum * a_sum) * (dim * b_sq_sum - b_sum * b_sum));
         result_t corr = (dim * ab_sum - a_sum * b_sum) / denom;
@@ -1197,7 +1205,7 @@ template <typename scalar_at = float, typename result_at = float> struct metric_
 
     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();
+        result_t epsilon = std::numeric_limits<result_t>::epsilon();
 #if USEARCH_USE_OPENMP
 #pragma omp simd reduction(+ : kld_pm, kld_qm)
 #elif defined(USEARCH_DEFINED_CLANG)
@@ -1206,9 +1214,11 @@ template <typename scalar_at = float, typename result_at = float> struct metric_
 #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);
+            result_t pi = static_cast<result_t>(p[i]);
+            result_t qi = static_cast<result_t>(q[i]);
+            result_t mi = (pi + qi) / 2 + epsilon;
+            kld_pm += pi * std::log((pi + epsilon) / mi);
+            kld_qm += qi * std::log((qi + epsilon) / mi);
         }
         return (kld_pm + kld_qm) / 2;
     }
@@ -1253,7 +1263,7 @@ struct l2sq_i8_t {
 #endif
         for (std::size_t i = 0; i != dim; i++)
             ab_deltas_sq += square(std::int16_t(a[i]) - std::int16_t(b[i]));
-        return ab_deltas_sq;
+        return static_cast<result_t>(ab_deltas_sq);
     }
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "usearch",
-    "version": "2.9.0",
+    "version": "2.9.1",
     "description": "Smaller & Faster Single-File Vector Search Engine from Unum",
     "author": "Ash Vardanian (https://ashvardanian.com/)",
     "license": "Apache 2.0",
@@ -34,7 +34,8 @@
     "exports": {
         ".": {
             "types": "./javascript/types/usearch.d.ts",
-            "require": "./javascript/usearch.js"
+            "require": "./javascript/usearch.js",
+            "import": "./javascript/usearch.js"
         },
         "./package.json": "./package.json"
     },

package/wasmer.toml

@@ -1,6 +1,6 @@
 [package]
 name="unum/usearch"
-version="2.9.0"
+version="2.9.1"
 description="Smaller & Faster Single-File Vector Search Engine from Unum"
 license="Apache-2.0"
 readme="README.md"