usearch 2.9.2 → 2.10.0

package/c/test.c

@@ -1,382 +0,0 @@
-#include <errno.h>
-#include <stdio.h> // `remove`
-#include <stdlib.h>
-#include <sys/stat.h>
-
-#include "usearch.h"
-
-#define ASSERT(must_be_true, message)                                                                                  \
-    if (!(must_be_true)) {                                                                                             \
-        printf("Assert: %s\n", message);                                                                               \
-        exit(-1);                                                                                                      \
-    }
-
-/**
- * @brief Creates and initializes vectors with random float values.
- *
- * @param count The number of vectors.
- * @param dimensions The number of dimensions per vector.
- * @return A pointer to the first element of the vectors, that must be @b free-ed afterwards.
- */
-float* create_vectors(size_t const count, size_t const dimensions) {
-    float* data = (float*)malloc(count * dimensions * sizeof(float));
-    ASSERT(data, "Failed to allocate memory");
-    for (size_t index = 0; index < count * dimensions; ++index)
-        data[index] = (float)rand() / (float)RAND_MAX;
-    return data;
-}
-
-usearch_init_options_t create_options(size_t const dimensions) {
-    usearch_init_options_t opts;
-    opts.connectivity = 3; // 32 in faiss
-    opts.dimensions = dimensions;
-    opts.expansion_add = 40;    // 40 in faiss
-    opts.expansion_search = 16; // 10 in faiss
-    opts.metric_kind = usearch_metric_ip_k;
-    opts.metric = NULL;
-    opts.quantization = usearch_scalar_f32_k;
-    opts.multi = false;
-    return opts;
-}
-
-/**
- *  This test is designed to verify the initialization of the index with specific dimensions and ensures that the
- *  associated properties are set correctly. It initializes the index twice, checking for errors at each step, and
- *  performs a reserve operation to pre-allocate space in the index, verifying the correct settings of size, capacity,
- *  dimensions, and connectivity after each operation.
- */
-void test_init(size_t const collection_size, size_t const dimensions) {
-    printf("Test: Index Initialization... %zu vectors, %zu dimensions \n", collection_size, dimensions);
-
-    // Init index
-    usearch_error_t error = NULL;
-    usearch_init_options_t opts = create_options(dimensions);
-    usearch_index_t index = usearch_init(&opts, &error);
-    ASSERT(!error, error);
-    usearch_free(index, &error);
-    ASSERT(!error, error);
-
-    // Init second time
-    index = usearch_init(&opts, &error);
-    ASSERT(!error, error);
-
-    ASSERT(usearch_size(index, &error) == 0, error);
-    ASSERT(usearch_capacity(index, &error) == 0, error);
-    ASSERT(usearch_dimensions(index, &error) == dimensions, error);
-    ASSERT(usearch_connectivity(index, &error) == opts.connectivity, error);
-
-    // Reserve
-    usearch_reserve(index, collection_size, &error);
-    ASSERT(!error, error);
-    ASSERT(usearch_size(index, &error) == 0, 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_free(index, &error);
-    ASSERT(!error, error);
-
-    printf("Test: Index Initialization - PASSED\n");
-}
-
-/**
- *  This test validates the addition of vectors to the index. It initializes the index and reserves space for vectors.
- *  It then iteratively adds vectors to the index and checks if the index contains the added vectors by verifying the
- *  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... %zu vectors, %zu dimensions \n", 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);
-
-    // 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);
-        ASSERT(!error, error);
-    }
-
-    ASSERT(usearch_size(index, &error) == collection_size, error);
-    ASSERT(usearch_capacity(index, &error) == collection_size, 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);
-    }
-    ASSERT(!usearch_contains(index, -1, &error), error); // Non existing key
-
-    free(data);
-    usearch_free(index, &error);
-    printf("Test: Add Vector - PASSED\n");
-}
-
-/**
- *  This test ensures that vectors added to the index can be correctly found. It initializes the index, reserves space,
- *  and adds vectors. It then performs a search query for each added vector to ensure that the vectors are correctly
- *  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... %zu vectors, %zu dimensions \n", 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);
-
-    // 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");
-
-    // 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);
-        ASSERT(!error, error);
-    }
-
-    // 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);
-    printf("Test: Find Vector - PASSED\n");
-}
-
-/**
- *  This test checks the ability of the index to handle multiple vectors associated with the same key. It initializes
- *  the index with the multi-option enabled, reserves space, and adds multiple vectors with the same key. The test then
- *  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... %zu vectors, %zu dimensions \n", collection_size, dimensions);
-
-    usearch_error_t error = NULL;
-    usearch_init_options_t opts = create_options(dimensions);
-    opts.multi = true;
-    usearch_index_t index = usearch_init(&opts, &error);
-    usearch_reserve(index, collection_size, &error);
-
-    // Create result buffers
-    float* vectors = (float*)malloc(collection_size * dimensions * sizeof(float));
-    ASSERT(vectors, "Failed to allocate memory");
-
-    // Add multiple vectors with SAME key
-    usearch_key_t const key = 1;
-    float* data = create_vectors(collection_size, dimensions);
-    for (size_t i = 0; i < collection_size; i++) {
-        usearch_add(index, key, data + i * dimensions, usearch_scalar_f32_k, &error);
-        ASSERT(!error, error);
-    }
-
-    // Retrieve vectors from index
-    size_t found_count = usearch_get(index, key, collection_size, vectors, usearch_scalar_f32_k, &error);
-    ASSERT(found_count == collection_size, "Vector is missing");
-
-    free(vectors);
-    free(data);
-    usearch_free(index, &error);
-
-    printf("Test: Get Vector - PASSED\n");
-}
-
-/**
- *  This test ensures that vectors can be successfully removed from the index. It initializes the index, reserves space,
- *  and adds vectors. It then iteratively removes each vector from the index and checks for errors. However, note that
- *  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... %zu vectors, %zu dimensions \n", 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);
-
-    // 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);
-        ASSERT(!error, error);
-    }
-
-    // Remove the vectors
-    for (size_t i = 0; i < collection_size; i++) {
-        usearch_key_t key = i;
-        usearch_remove(index, key, &error);
-        ASSERT(!error, "Currently, Remove is not supported");
-    }
-
-    free(data);
-    usearch_free(index, &error);
-    printf("Test: Remove Vector - PASSED\n");
-}
-
-/**
- *  This test validates the save and load functionality of the index. It initializes the index, reserves space, and adds
- *  vectors. The index is then saved to a file and freed. A new index is initialized, and the previously saved index is
- *  loaded into it. The test then validates the loaded index properties and ensures that it contains all the vectors
- *  from the saved index.
- */
-void test_save_load(size_t const collection_size, size_t const dimensions) {
-    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_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);
-        }
-
-        // Save and free the index
-        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
-    {
-
-        usearch_index_t index = usearch_init(&opts, &error);
-        ASSERT(!error, error);
-        ASSERT(usearch_size(index, &error) == 0, 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);
-
-    // Remove the file from disk
-    remove("tmp.usearch");
-    printf("Test: Save/Load - PASSED\n");
-}
-
-/**
- *  This test is designed to validate the view functionality of the index. It initializes the index, reserves space, and
- *  adds vectors. The index is then saved to a file and freed. A new index is initialized and a view is created from the
- *  saved index file. The test is mainly focused on ensuring that no errors occur during these operations, but it does
- *  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... %zu vectors, %zu dimensions \n", 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);
-
-    // 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);
-        ASSERT(!error, error);
-    }
-
-    // Save and free the index
-    usearch_save(index, "tmp.usearch", &error);
-    ASSERT(!error, error);
-    usearch_free(index, &error);
-    ASSERT(!error, error);
-
-    // Reinit
-    index = usearch_init(&opts, &error);
-    ASSERT(!error, error);
-
-    // View
-    usearch_view(index, "tmp.usearch", &error);
-    ASSERT(!error, error);
-
-    free(data);
-    usearch_free(index, &error);
-    printf("Test: View - PASSED\n");
-}
-
-int main(int argc, char const* argv[]) {
-
-    size_t collection_sizes[] = {11, 512};
-    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]);
-            test_add_vector(collection_sizes[index], dimensions[jdx]);
-            test_find_vector(collection_sizes[index], dimensions[jdx]);
-            test_get_vector(collection_sizes[index], dimensions[jdx]);
-            test_remove_vector(collection_sizes[index], dimensions[jdx]);
-            test_save_load(collection_sizes[index], dimensions[jdx]);
-            test_view(collection_sizes[index], dimensions[jdx]);
-        }
-    }
-
-    (void)argc;
-    (void)argv;
-    return 0;
-}

package/c/usearch.h

@@ -1,311 +0,0 @@
-#ifndef UNUM_USEARCH_H
-#define UNUM_USEARCH_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef USEARCH_EXPORT
-#if defined(_WIN32) && !defined(__MINGW32__)
-#define USEARCH_EXPORT __declspec(dllexport)
-#else
-#define USEARCH_EXPORT
-#endif
-#endif
-
-#include <stdbool.h> // `bool`
-#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;
-USEARCH_EXPORT typedef float usearch_distance_t;
-
-/**
- *  @brief  Pointer to a null-terminated error message.
- *          Returned error messages @b don't need to be deallocated.
- */
-USEARCH_EXPORT typedef char const* usearch_error_t;
-
-/**
- *  @brief  Type-punned callback for "metrics" or "distance functions",
- *          that accepts pointers to two vectors and measures their @b dis-similarity.
- */
-USEARCH_EXPORT typedef usearch_distance_t (*usearch_metric_t)(void const*, void const*);
-
-/**
- *  @brief  Enumerator for the most common kinds of `usearch_metric_t`.
- *          Those are supported out of the box, with SIMD-optimizations for most common hardware.
- */
-USEARCH_EXPORT typedef enum usearch_metric_kind_t {
-    usearch_metric_unknown_k = 0,
-    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 = 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 {
-    /**
-     *  @brief The metric kind used for distance calculation between vectors.
-     */
-    usearch_metric_kind_t metric_kind;
-    /**
-     *  @brief The @b optional custom distance metric function used for distance calculation between vectors.
-     *  If the `metric_kind` is set to `usearch_metric_unknown_k`, this function pointer mustn't be `NULL`.
-     */
-    usearch_metric_t metric;
-    /**
-     *  @brief The scalar kind used for quantization of vector data during indexing.
-     */
-    usearch_scalar_kind_t quantization;
-    /**
-     *  @brief The number of dimensions in the vectors to be indexed.
-     *  Must be defined for most metrics, but can be avoided for `usearch_metric_haversine_k`.
-     */
-    size_t dimensions;
-    /**
-     *  @brief The @b optional connectivity parameter that limits connections-per-node in graph.
-     */
-    size_t connectivity;
-    /**
-     *  @brief The @b optional expansion factor used for index construction when adding vectors.
-     */
-    size_t expansion_add;
-    /**
-     *  @brief The @b optional expansion factor used for index construction during search operations.
-     */
-    size_t expansion_search;
-    /**
-     *  @brief When set allows multiple vectors to map to the same key.
-     */
-    bool multi;
-} usearch_init_options_t;
-
-/**
- *  @brief Initializes a new instance of the index.
- *  @param options Pointer to the `usearch_init_options_t` structure containing initialization options.
- *  @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 usearch_index_t usearch_init(usearch_init_options_t* options, usearch_error_t* error);
-
-/**
- *  @brief Frees the resources associated with the index.
- *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
- */
-USEARCH_EXPORT void usearch_free(usearch_index_t, usearch_error_t* error);
-
-/**
- *  @brief Reports expected file size after serialization.
- *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
- */
-USEARCH_EXPORT size_t usearch_serialized_length(usearch_index_t, usearch_error_t* error);
-
-/**
- *  @brief Saves the index to a file.
- *  @param[in] path The file path where the index will be saved.
- *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
- */
-USEARCH_EXPORT void usearch_save(usearch_index_t, char const* path, usearch_error_t* error);
-
-/**
- *  @brief Loads the index from a file.
- *  @param[in] path The file path from where the index will be loaded.
- *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
- */
-USEARCH_EXPORT void usearch_load(usearch_index_t, char const* path, usearch_error_t* error);
-
-/**
- *  @brief Creates a view of the index from a file without copying it into memory.
- *  @param[in] path The file path from where the view will be created.
- *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
- */
-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.
- *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
- */
-USEARCH_EXPORT void usearch_save_buffer(usearch_index_t, void* buffer, size_t length, usearch_error_t* error);
-
-/**
- *  @brief Loads the index from an in-memory buffer.
- *  @param[in] buffer The in-memory continuous buffer from where the index will be loaded.
- *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
- */
-USEARCH_EXPORT void usearch_load_buffer(usearch_index_t, void const* buffer, size_t length, usearch_error_t* error);
-
-/**
- *  @brief Creates a view of the index from an in-memory buffer without copying it into memory.
- *  @param[in] buffer The in-memory continuous buffer from where the view will be created.
- *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
- */
-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);
-USEARCH_EXPORT size_t usearch_connectivity(usearch_index_t, usearch_error_t* error);
-
-/**
- *  @brief Reserves memory for a specified number of incoming vectors.
- *  @param[in] capacity The desired total capacity including current size.
- *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
- */
-USEARCH_EXPORT void usearch_reserve(usearch_index_t, size_t capacity, usearch_error_t* error);
-
-/**
- *  @brief Adds a vector with a key to the index.
- *  @param[in] key The key associated with the vector.
- *  @param[in] vector Pointer to the vector data.
- *  @param[in] vector_kind The scalar type used in the vector data.
- *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
- */
-USEARCH_EXPORT void usearch_add(        //
-    usearch_index_t, usearch_key_t key, //
-    void const* vector, usearch_scalar_kind_t vector_kind, usearch_error_t* error);
-
-/**
- *  @brief Checks if the index contains a vector with a specific key.
- *  @param[in] key The key to be checked.
- *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
- *  @return `true` if the index contains the vector with the given key, `false` otherwise.
- */
-USEARCH_EXPORT bool usearch_contains(usearch_index_t, usearch_key_t, usearch_error_t* error);
-
-/**
- *  @brief Counts the number of entries in the index under a specific key.
- *  @param[in] key The key to be checked.
- *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
- *  @return Number of vectors found under that key.
- */
-USEARCH_EXPORT size_t usearch_count(usearch_index_t, usearch_key_t, usearch_error_t* error);
-
-/**
- *  @brief Performs k-Approximate Nearest Neighbors (kANN) Search for closest vectors to query.
- *  @param[in] query_vector Pointer to the query vector data.
- *  @param[in] query_kind The scalar type used in the query vector data.
- *  @param[in] count Upper bound on the number of neighbors to search, the "k" in "kANN".
- *  @param[out] keys Output buffer for up to `count` nearest neighbors keys.
- *  @param[out] distances Output buffer for up to `count` distances to nearest neighbors.
- *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
- *  @return Number of found matches.
- */
-USEARCH_EXPORT size_t usearch_search(                           //
-    usearch_index_t,                                            //
-    void const* query_vector, usearch_scalar_kind_t query_kind, //
-    size_t count, usearch_key_t* keys, usearch_distance_t* distances, usearch_error_t* error);
-
-/**
- *  @brief Retrieves the vector associated with the given key from the index.
- *  @param[in] key The key of the vector to retrieve.
- *  @param[out] vector Pointer to the memory where the vector data will be copied.
- *  @param[in] count Number of vectors that can be fitted into `vector` for multi-vector entries.
- *  @param[in] vector_kind The scalar type used in the vector data.
- *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
- *  @return Number of vectors found under that name and exported to `vector`.
- */
-USEARCH_EXPORT size_t usearch_get(                    //
-    usearch_index_t, usearch_key_t key, size_t count, //
-    void* vector, usearch_scalar_kind_t vector_kind, usearch_error_t* error);
-
-/**
- *  @brief Removes the vector associated with the given key from the index.
- *  @param[in] key The key of the vector to be removed.
- *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
- *  @return Number of vectors found under that name and dropped from the index.
- */
-USEARCH_EXPORT size_t usearch_remove(usearch_index_t, usearch_key_t key, usearch_error_t* error);
-
-/**
- *  @brief Renames the vector to map to a different key.
- *  @param[in] from The key of the vector to be renamed.
- *  @param[in] to New key for found entry.
- *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
- *  @return Number of vectors found under that name and renamed.
- */
-USEARCH_EXPORT size_t usearch_rename(usearch_index_t, usearch_key_t from, usearch_key_t to, usearch_error_t* error);
-
-/**
- *  @brief Computes the distance between two equi-dimensional vectors.
- *  @param[in] vector_first The first vector for comparison.
- *  @param[in] vector_second The second vector for comparison.
- *  @param[in] scalar_kind The scalar type used in the vectors.
- *  @param[in] dimensions The number of dimensions in each vector.
- *  @param[in] metric_kind The metric kind used for distance calculation between vectors.
- *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
- *  @return Distance between given vectors.
- */
-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);
-
-/**
- *  @brief Multi-threaded exact nearest neighbors search for equi-dimensional vectors.
- *  @param[in] dataset Pointer to the first scalar of the dataset matrix.
- *  @param[in] queries Pointer to the first scalar of the queries matrix.
- *  @param[in] dataset_size Number of vectors in the `dataset`.
- *  @param[in] queries_size Number of vectors in the `queries` set.
- *  @param[in] dataset_stride Number of bytes between starts of consecutive vectors in `dataset`.
- *  @param[in] queries_stride Number of bytes between starts of consecutive vectors in `queries`.
- *  @param[in] scalar_kind The scalar type used in the vectors.
- *  @param[in] dimensions The number of dimensions in each vector.
- *  @param[in] metric_kind The metric kind used for distance calculation between vectors.
- *  @param[in] count Upper bound on the number of neighbors to search, the "k" in "kANN".
- *  @param[in] threads Upper bound for the number of CPU threads to use.
- *  @param[out] keys Output buffer for up to `count` nearest neighbors keys.
- *  @param[out] distances Output buffer for up to `count` distances to nearest neighbors.
- *  @param[out] error Pointer to a string where the error message will be stored, if an error occurs.
- *  @return Number of found matches.
- */
-USEARCH_EXPORT void usearch_exact_search(                            //
-    void const* dataset, size_t dataset_size, size_t dataset_stride, //
-    void const* queries, size_t queries_size, 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);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif // UNUM_USEARCH_H