usearch 2.10.2 → 2.10.5

package/README.md

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

package/binding.gyp

@@ -0,0 +1,101 @@
+{
+    "targets": [
+        {
+            "target_name": "usearch",
+            "sources": ["javascript/lib.cpp"],
+            "cflags": [
+                "-fexceptions",
+                "-Wno-unknown-pragmas",
+                "-Wno-maybe-uninitialized",
+            ],
+            "cflags_cc": [
+                "-fexceptions",
+                "-Wno-unknown-pragmas",
+                "-Wno-maybe-uninitialized",
+                "-std=c++17",
+            ],
+            "include_dirs": [
+                "<!@(node -p \"require('node-addon-api').include\")",
+                "include",
+                "fp16/include",
+                "simsimd/include",
+            ],
+            "dependencies": ["<!(node -p \"require('node-addon-api').gyp\")"],
+            "xcode_settings": {
+                "GCC_ENABLE_CPP_EXCEPTIONS": "YES",
+                "CLANG_CXX_LIBRARY": "libc++",
+                "MACOSX_DEPLOYMENT_TARGET": "11.0",
+                "OTHER_CFLAGS": [
+                    "-arch arm64",
+                    "-arch x86_64"
+                ],
+                "OTHER_LDFLAGS": [
+                    "-arch arm64",
+                    "-arch x86_64" 
+                ]
+           },
+            "msvs_settings": {
+                "VCCLCompilerTool": {
+                    "ExceptionHandling": 1,
+                    "AdditionalOptions": ["-std:c++17"],
+                }
+            },
+            "conditions": [
+                [
+                    'OS=="linux"',
+                    {
+                        "cflags_cc": [
+                            '<!(if [ "$USEARCH_USE_OPENMP" = "1" ]; then echo \'-fopenmp\'; fi)',
+                        ],
+                        "ldflags": [
+                            '<!(if [ "$USEARCH_USE_OPENMP" = "1" ]; then echo \'-lgomp\'; fi)'
+                        ],
+                        "defines": [
+                            "USEARCH_USE_OPENMP=<!(echo ${USEARCH_USE_OPENMP:-0})",
+                            "USEARCH_USE_SIMSIMD=<!(echo ${USEARCH_USE_SIMSIMD:-1})",
+                            "USEARCH_USE_FP16LIB=<!(echo ${USEARCH_USE_FP16LIB:-1})",
+                            "SIMSIMD_TARGET_NEON=<!(echo ${SIMSIMD_TARGET_NEON:-1})",
+                            "SIMSIMD_TARGET_SVE=<!(echo ${SIMSIMD_TARGET_SVE:-1})",
+                            "SIMSIMD_TARGET_HASWELL=<!(echo ${SIMSIMD_TARGET_HASWELL:-1})",
+                            "SIMSIMD_TARGET_SKYLAKE=<!(echo ${SIMSIMD_TARGET_SKYLAKE:-1})",
+                            "SIMSIMD_TARGET_ICE=<!(echo ${SIMSIMD_TARGET_ICE:-1})",
+                            "SIMSIMD_TARGET_SAPPHIRE=<!(echo ${SIMSIMD_TARGET_SAPPHIRE:-1})",
+                        ],
+                    },
+                ],
+                [
+                    'OS=="mac"',
+                    {
+                        "defines": [
+                            "USEARCH_USE_OPENMP=<!(echo ${USEARCH_USE_OPENMP:-0})",
+                            "USEARCH_USE_SIMSIMD=<!(echo ${USEARCH_USE_SIMSIMD:-0})",
+                            "USEARCH_USE_FP16LIB=<!(echo ${USEARCH_USE_FP16LIB:-1})",
+                            "SIMSIMD_TARGET_NEON=<!(echo ${SIMSIMD_TARGET_NEON:-1})",
+                            "SIMSIMD_TARGET_SVE=<!(echo ${SIMSIMD_TARGET_SVE:-0})",
+                            "SIMSIMD_TARGET_HASWELL=<!(echo ${SIMSIMD_TARGET_HASWELL:-1})",
+                            "SIMSIMD_TARGET_SKYLAKE=<!(echo ${SIMSIMD_TARGET_SKYLAKE:-0})",
+                            "SIMSIMD_TARGET_ICE=<!(echo ${SIMSIMD_TARGET_ICE:-0})",
+                            "SIMSIMD_TARGET_SAPPHIRE=<!(echo ${SIMSIMD_TARGET_SAPPHIRE:-0})",
+                        ],
+                    },
+                ],
+                [
+                    'OS=="win"',
+                    {
+                        "defines": [
+                            "USEARCH_USE_OPENMP=0",
+                            "USEARCH_USE_SIMSIMD=0",
+                            "USEARCH_USE_FP16LIB=1",
+                            "SIMSIMD_TARGET_SKYLAKE=0",
+                            "SIMSIMD_TARGET_ICE=0",
+                            "SIMSIMD_TARGET_SAPPHIRE=0",
+                            "SIMSIMD_TARGET_SVE=0",
+                            "SIMSIMD_TARGET_HASWELL=0",
+                            "SIMSIMD_TARGET_NEON=0",
+                        ],
+                    },
+                ],
+            ],
+        }
+    ]
+}

package/c/CMakeLists.txt

@@ -0,0 +1,27 @@
+if (USEARCH_BUILD_TEST_C)
+    add_executable(test_c test.c lib.cpp)
+    setup_target(test_c)
+    include(CTest)
+    enable_testing()
+    add_test(NAME test_c COMMAND test_c)
+endif ()
+
+# This article discusses a better way to allow building either static or shared libraries:
+# https://alexreinking.com/blog/building-a-dual-shared-and-static-library-with-cmake.html
+if (USEARCH_BUILD_LIB_C)
+    add_library(usearch_c SHARED lib.cpp)
+    add_library(usearch_static_c STATIC lib.cpp)
+
+    # Set the compile options for the static library
+    if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        target_compile_options(usearch_static_c PRIVATE -static-libstdc++)
+        target_link_options(usearch_static_c PRIVATE -static-libstdc++)
+    elseif (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+        target_compile_options(usearch_static_c PRIVATE -static)
+        target_link_options(usearch_static_c PRIVATE -static)
+    endif ()
+
+    setup_target(usearch_c)
+    setup_target(usearch_static_c)
+
+endif ()

package/c/README.md

@@ -0,0 +1,34 @@
+# USearch for C
+
+## Installation
+
+The simplest form to integrate is to copy the contents of `usearch/c/` into your project.
+To build the library `libusearch_static_c` and `libusearch_c`, pass enable the `USEARCH_BUILD_LIB_C` CMake option:
+
+```bash
+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
+
+```c
+usearch_error_t error = NULL;
+usearch_init_options_t opts = create_options(dimensions);
+usearch_index_t index = usearch_init(&opts, &error);
+usearch_reserve(index, vectors_count, &error);
+
+float vector[dimensions] = {...};
+usearch_add(index, 42, &vector[0], usearch_scalar_f32_k, &error);
+
+ASSERT(!error, error);
+ASSERT(usearch_size(index, &error) == vectors_count, error);
+ASSERT(usearch_capacity(index, &error) == vectors_count, error);
+
+usearch_key_t found_keys[10];
+float found_distances[10];
+size_t found_count = usearch_search(index, &vector[0], usearch_scalar_f32_k, 10, &found_keys[0], &found_distances[0], &error);
+
+usearch_free(index, &error);
+```

package/c/lib.cpp

@@ -0,0 +1,362 @@
+#include <cassert>
+
+#include <usearch/index_dense.hpp>
+
+extern "C" {
+#include "usearch.h"
+}
+
+using namespace unum::usearch;
+using namespace unum;
+
+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::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++");
+
+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;
+    case usearch_metric_tanimoto_k: return metric_kind_t::tanimoto_k;
+    case usearch_metric_sorensen_k: return metric_kind_t::sorensen_k;
+    default: return metric_kind_t::unknown_k;
+    }
+}
+
+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;
+    case usearch_scalar_f16_k: return scalar_kind_t::f16_k;
+    case usearch_scalar_i8_k: return scalar_kind_t::i8_k;
+    case usearch_scalar_b1_k: return scalar_kind_t::b1x8_k;
+    default: return scalar_kind_t::unknown_k;
+    }
+}
+
+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);
+    case scalar_kind_t::f64_k: return index->add(key, (f64_t const*)vector);
+    case scalar_kind_t::f16_k: return index->add(key, (f16_t const*)vector);
+    case scalar_kind_t::i8_k: return index->add(key, (i8_t const*)vector);
+    case scalar_kind_t::b1x8_k: return index->add(key, (b1x8_t const*)vector);
+    default: return add_result_t{}.failed("Unknown scalar kind!");
+    }
+}
+
+std::size_t get_(index_dense_t* index, usearch_key_t key, size_t count, void* vector, scalar_kind_t kind) {
+    switch (kind) {
+    case scalar_kind_t::f32_k: return index->get(key, (f32_t*)vector, count);
+    case scalar_kind_t::f64_k: return index->get(key, (f64_t*)vector, count);
+    case scalar_kind_t::f16_k: return index->get(key, (f16_t*)vector, count);
+    case scalar_kind_t::i8_k: return index->get(key, (i8_t*)vector, count);
+    case scalar_kind_t::b1x8_k: return index->get(key, (b1x8_t*)vector, count);
+    default: return search_result_t().failed("Unknown scalar kind!");
+    }
+}
+
+search_result_t search_(index_dense_t* index, void const* vector, scalar_kind_t kind, size_t n) {
+    switch (kind) {
+    case scalar_kind_t::f32_k: return index->search((f32_t const*)vector, n);
+    case scalar_kind_t::f64_k: return index->search((f64_t const*)vector, n);
+    case scalar_kind_t::f16_k: return index->search((f16_t const*)vector, n);
+    case scalar_kind_t::i8_k: return index->search((i8_t const*)vector, n);
+    case scalar_kind_t::b1x8_k: return index->search((b1x8_t const*)vector, n);
+    default: return search_result_t().failed("Unknown scalar kind!");
+    }
+}
+
+extern "C" {
+
+USEARCH_EXPORT usearch_index_t usearch_init(usearch_init_options_t* options, usearch_error_t* error) {
+
+    assert(options && error && "Missing arguments");
+
+    index_dense_config_t config(options->connectivity, options->expansion_add, options->expansion_search);
+    config.multi = options->multi;
+    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)
+                         : metric_punned_t(options->dimensions,                               //
+                                           reinterpret_cast<std::uintptr_t>(options->metric), //
+                                           metric_punned_signature_t::array_array_k,          //
+                                           metric_kind, scalar_kind);
+    if (metric.missing()) {
+        *error = "Unknown metric kind!";
+        return NULL;
+    }
+
+    index_dense_t index = index_dense_t::make(metric, config);
+    index_dense_t* result_ptr = new index_dense_t(std::move(index));
+    if (!result_ptr || !*result_ptr)
+        *error = "Out of memory!";
+    return result_ptr;
+}
+
+USEARCH_EXPORT void usearch_free(usearch_index_t index, usearch_error_t*) {
+    delete reinterpret_cast<index_dense_t*>(index);
+}
+
+USEARCH_EXPORT size_t usearch_serialized_length(usearch_index_t index, usearch_error_t*) {
+    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 && "Missing arguments");
+    serialization_result_t result = reinterpret_cast<index_dense_t*>(index)->save(path);
+    if (!result)
+        *error = result.error.release();
+}
+
+USEARCH_EXPORT void usearch_load(usearch_index_t index, char const* path, usearch_error_t* 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();
+}
+
+USEARCH_EXPORT void usearch_view(usearch_index_t index, char const* path, usearch_error_t* 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();
+}
+
+USEARCH_EXPORT void usearch_metadata(char const* path, usearch_init_options_t* options, usearch_error_t* 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();
+
+    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 && "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)
+        *error = result.error.release();
+}
+
+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 && "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)
+        *error = result.error.release();
+}
+
+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 && "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)
+        *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 && "Missing arguments");
+    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();
+}
+
+USEARCH_EXPORT size_t usearch_capacity(usearch_index_t index, usearch_error_t*) {
+    return reinterpret_cast<index_dense_t*>(index)->capacity();
+}
+
+USEARCH_EXPORT size_t usearch_dimensions(usearch_index_t index, usearch_error_t*) {
+    return reinterpret_cast<index_dense_t*>(index)->dimensions();
+}
+
+USEARCH_EXPORT size_t usearch_connectivity(usearch_index_t index, usearch_error_t*) {
+    return reinterpret_cast<index_dense_t*>(index)->connectivity();
+}
+
+USEARCH_EXPORT void usearch_reserve(usearch_index_t index, size_t capacity, usearch_error_t* error) {
+    assert(index && error && "Missing arguments");
+    if (!reinterpret_cast<index_dense_t*>(index)->reserve(capacity))
+        *error = "Out of memory!";
+}
+
+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 && "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 && "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 && "Missing arguments");
+    return reinterpret_cast<index_dense_t*>(index)->count(key);
+}
+
+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 && "Missing arguments");
+    search_result_t result =
+        search_(reinterpret_cast<index_dense_t*>(index), vector, scalar_kind_to_cpp(kind), results_limit);
+    if (!result) {
+        *error = result.error.release();
+        return 0;
+    }
+
+    return result.dump_to(found_keys, found_distances);
+}
+
+USEARCH_EXPORT size_t usearch_get(                          //
+    usearch_index_t index, usearch_key_t key, size_t count, //
+    void* vectors, usearch_scalar_kind_t kind, usearch_error_t*) {
+
+    assert(index && vectors);
+    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) {
+
+    assert(index && error && "Missing arguments");
+    labeling_result_t result = reinterpret_cast<index_dense_t*>(index)->remove(key);
+    if (!result)
+        *error = result.error.release();
+    return result.completed;
+}
+
+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 && "Missing arguments");
+    labeling_result_t result = reinterpret_cast<index_dense_t*>(index)->rename(from, to);
+    if (!result)
+        *error = result.error.release();
+    return result.completed;
+}
+
+USEARCH_EXPORT usearch_distance_t usearch_distance(       //
+    void const* vector_first, void const* vector_second,  //
+    usearch_scalar_kind_t scalar_kind, size_t dimensions, //
+    usearch_metric_kind_t metric_kind, usearch_error_t* error) {
+
+    (void)error;
+    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);
+}
+
+USEARCH_EXPORT void usearch_exact_search(                             //
+    void const* dataset, size_t dataset_count, size_t dataset_stride, //
+    void const* queries, size_t queries_count, size_t queries_stride, //
+    usearch_scalar_kind_t scalar_kind, size_t dimensions,             //
+    usearch_metric_kind_t metric_kind, size_t count, size_t threads,  //
+    usearch_key_t* keys, size_t keys_stride,                          //
+    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;
+    exact_search_results_t result = search(                    //
+        (byte_t const*)dataset, dataset_count, dataset_stride, //
+        (byte_t const*)queries, queries_count, queries_stride, //
+        count, metric);
+
+    if (!result) {
+        *error = "Out of memory, allocating a temporary buffer for batch results";
+        return;
+    }
+
+    // Export results into the output buffer
+    for (std::size_t query_idx = 0; query_idx != queries_count; ++query_idx) {
+        auto query_result = result.at(query_idx);
+        auto query_keys = (usearch_key_t*)((byte_t*)keys + query_idx * keys_stride);
+        auto query_distances = (usearch_distance_t*)((byte_t*)distances + query_idx * distances_stride);
+        for (std::size_t i = 0; i != count; ++i)
+            query_keys[i] = static_cast<usearch_key_t>(query_result[i].offset),
+            query_distances[i] = static_cast<usearch_distance_t>(query_result[i].distance);
+    }
+}
+}