usearch 2.6.0 → 2.7.0

package/c/test.c

@@ -1,4 +1,3 @@
-#include <stdio.h>
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -6,24 +5,30 @@
 
 #include "usearch.h"
 
-#define ASSERT(must_be_true, message)           \
-    if (!(must_be_true)) {                      \
-        printf("Assert: %s\n", message);        \
-        exit(-1);                               \
+#define ASSERT(must_be_true, message)                                                                                  \
+    if (!(must_be_true)) {                                                                                             \
+        printf("Assert: %s\n", message);                                                                               \
+        exit(-1);                                                                                                      \
     }
 
-
-float* create_vectors(size_t count, size_t dimensions) {
+/**
+ * @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 idx = 0; idx < count * dimensions; ++idx)
-        data[idx] = (float)rand() / (float)RAND_MAX;
+    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 dimensions) {
+usearch_init_options_t create_options(size_t const dimensions) {
     usearch_init_options_t opts;
-    opts.connectivity = 2; // 32 in faiss
+    opts.connectivity = 3; // 32 in faiss
     opts.dimensions = dimensions;
     opts.expansion_add = 40;    // 40 in faiss
     opts.expansion_search = 16; // 10 in faiss
@@ -33,265 +38,303 @@ usearch_init_options_t create_options(size_t dimensions) {
     return opts;
 }
 
-void test_init(size_t collection_size, size_t dimensions) {
+/**
+ *  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...\n");
 
     // Init index
     usearch_error_t error = NULL;
     usearch_init_options_t opts = create_options(dimensions);
-    usearch_index_t idx = usearch_init(&opts, &error);
+    usearch_index_t index = usearch_init(&opts, &error);
     ASSERT(!error, error);
-    usearch_free(idx, &error);
+    usearch_free(index, &error);
     ASSERT(!error, error);
 
     // Init second time
-    idx = usearch_init(&opts, &error);
+    index = usearch_init(&opts, &error);
     ASSERT(!error, error);
 
-    ASSERT(usearch_size(idx, &error) == 0, error);
-    ASSERT(usearch_capacity(idx, &error) == 0, error);
-    ASSERT(usearch_dimensions(idx, &error) == dimensions, error);
-    ASSERT(usearch_connectivity(idx, &error) == opts.connectivity, 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(idx, collection_size, &error);
+    usearch_reserve(index, collection_size, &error);
     ASSERT(!error, error);
-    ASSERT(usearch_size(idx, &error) == 0, error);
-    ASSERT(usearch_capacity(idx, &error) == collection_size, error);
-    ASSERT(usearch_dimensions(idx, &error) == dimensions, error);
-    ASSERT(usearch_connectivity(idx, &error) == opts.connectivity, 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(idx, &error);
+    usearch_free(index, &error);
     ASSERT(!error, error);
 
     printf("Test: Index Initialization - PASSED\n");
 }
 
-void test_add_vector(size_t collection_size, size_t dimensions) {
+/**
+ *  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...\n");
 
     usearch_error_t error = NULL;
     usearch_init_options_t opts = create_options(dimensions);
-    usearch_index_t idx = usearch_init(&opts, &error);
-    usearch_reserve(idx, collection_size, &error);
+    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(idx, key, data + i * dimensions, usearch_scalar_f32_k, &error);
+        usearch_add(index, key, data + i * dimensions, usearch_scalar_f32_k, &error);
         ASSERT(!error, error);
     }
 
-    ASSERT(usearch_size(idx, &error) == collection_size, error);
-    ASSERT(usearch_capacity(idx, &error) == collection_size, 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(idx, key, &error), error);
+        ASSERT(usearch_contains(index, key, &error), error);
     }
-    ASSERT(!usearch_contains(idx, -1, &error), error); // Non existing key
+    ASSERT(!usearch_contains(index, -1, &error), error); // Non existing key
 
     free(data);
-    usearch_free(idx, &error);
+    usearch_free(index, &error);
     printf("Test: Add Vector - PASSED\n");
 }
 
-void test_find_vector(size_t collection_size, size_t dimensions) {
+/**
+ *  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...\n");
 
     usearch_error_t error = NULL;
     usearch_init_options_t opts = create_options(dimensions);
-    usearch_index_t idx = usearch_init(&opts, &error);
-    usearch_reserve(idx, collection_size, &error);
+    usearch_index_t index = usearch_init(&opts, &error);
+    usearch_reserve(index, collection_size, &error);
 
     // Create result buffers
-    int results_count = collection_size;
-    usearch_key_t* keys = (usearch_key_t*)malloc(results_count * sizeof(usearch_key_t));
-    float* distances = (float*)malloc(results_count * sizeof(float));
+    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(idx, key, data + i * dimensions, usearch_scalar_f32_k, &error);
+        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++) {
-        const void *query_vector = data + i * dimensions;
-        size_t found_count = usearch_search(idx, query_vector, usearch_scalar_f32_k, results_count, keys, distances, &error);
+        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 = results_count, "Vector is missing");
+        ASSERT(found_count >= 1 && found_count <= collection_size, "Vector is missing");
     }
 
     free(data);
     free(keys);
     free(distances);
-    usearch_free(idx, &error);
+    usearch_free(index, &error);
     printf("Test: Find Vector - PASSED\n");
 }
 
-void test_get_vector(size_t collection_size, size_t dimensions) {
+/**
+ *  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...\n");
 
     usearch_error_t error = NULL;
     usearch_init_options_t opts = create_options(dimensions);
     opts.multi = true;
-    usearch_index_t idx = usearch_init(&opts, &error);
-    usearch_reserve(idx, collection_size, &error);
+    usearch_index_t index = usearch_init(&opts, &error);
+    usearch_reserve(index, collection_size, &error);
 
     // Create result buffers
-    int results_count = collection_size;
-    float* vectors = (float*)malloc(results_count * dimensions * sizeof(float));
+    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(idx, key, data + i * dimensions, usearch_scalar_f32_k, &error);
+        usearch_add(index, key, data + i * dimensions, usearch_scalar_f32_k, &error);
         ASSERT(!error, error);
     }
 
     // Retrieve vectors from index
-    size_t count = usearch_get(idx, key, collection_size, vectors, usearch_scalar_f32_k, &error);
-    ASSERT(count == results_count, "Vector is missing");
+    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(idx, &error);
+    usearch_free(index, &error);
 
     printf("Test: Get Vector - PASSED\n");
 }
 
-void test_remove_vector(size_t collection_size, size_t dimensions) {
+/**
+ *  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...\n");
 
     usearch_error_t error = NULL;
     usearch_init_options_t opts = create_options(dimensions);
-    usearch_index_t idx = usearch_init(&opts, &error);
-    usearch_reserve(idx, collection_size, &error);
+    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(idx, key, data + i * dimensions, usearch_scalar_f32_k, &error);
+        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(idx, key, &error);
+        usearch_remove(index, key, &error);
         ASSERT(!error, "Currently, Remove is not supported");
     }
 
     free(data);
-    usearch_free(idx, &error);
+    usearch_free(index, &error);
     printf("Test: Remove Vector - PASSED\n");
 }
 
-void test_save_load(size_t collection_size, size_t dimensions) {
+/**
+ *  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...\n");
 
     usearch_error_t error = NULL;
     usearch_init_options_t opts = create_options(dimensions);
-    usearch_index_t idx = usearch_init(&opts, &error);
-    usearch_reserve(idx, collection_size, &error);
+    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(idx, key, data + i * dimensions, usearch_scalar_f32_k, &error);
+        usearch_add(index, key, data + i * dimensions, usearch_scalar_f32_k, &error);
         ASSERT(!error, error);
     }
 
     // Save and free the index
-    usearch_save(idx, "usearch_index.bin", &error);
+    usearch_save(index, "usearch_index.bin", &error);
     ASSERT(!error, error);
-    usearch_free(idx, &error);
+    usearch_free(index, &error);
     ASSERT(!error, error);
 
     // Reinit
-    idx = usearch_init(&opts, &error);
+    index = usearch_init(&opts, &error);
     ASSERT(!error, error);
-    ASSERT(usearch_size(idx, &error) == 0, error);
+    ASSERT(usearch_size(index, &error) == 0, error);
 
     // Load
-    usearch_load(idx, "usearch_index.bin", &error);
+    usearch_load(index, "usearch_index.bin", &error);
     ASSERT(!error, error);
-    ASSERT(usearch_size(idx, &error) == collection_size, error);
-    ASSERT(usearch_capacity(idx, &error) == collection_size, error);
-    ASSERT(usearch_dimensions(idx, &error) == dimensions, error);
-    ASSERT(usearch_connectivity(idx, &error) == opts.connectivity, 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);
 
     // Check vectors in the index
     for (size_t i = 0; i < collection_size; ++i) {
         usearch_key_t key = i;
-        ASSERT(usearch_contains(idx, key, &error), error);
+        ASSERT(usearch_contains(index, key, &error), error);
     }
 
     free(data);
-    usearch_free(idx, &error);
+    usearch_free(index, &error);
     printf("Test: Save/Load - PASSED\n");
 }
 
-void test_view(size_t collection_size, size_t dimensions) {
+/**
+ *  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...\n");
 
     usearch_error_t error = NULL;
     usearch_init_options_t opts = create_options(dimensions);
-    usearch_index_t idx = usearch_init(&opts, &error);
-    usearch_reserve(idx, collection_size, &error);
+    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(idx, key, data + i * dimensions, usearch_scalar_f32_k, &error);
+        usearch_add(index, key, data + i * dimensions, usearch_scalar_f32_k, &error);
         ASSERT(!error, error);
     }
 
     // Save and free the index
-    usearch_save(idx, "usearch_index.bin", &error);
+    usearch_save(index, "usearch_index.bin", &error);
     ASSERT(!error, error);
-    usearch_free(idx, &error);
+    usearch_free(index, &error);
     ASSERT(!error, error);
 
     // Reinit
-    idx = usearch_init(&opts, &error);
+    index = usearch_init(&opts, &error);
     ASSERT(!error, error);
 
     // View
-    usearch_view(idx, "usearch_index.bin", &error);
+    usearch_view(index, "usearch_index.bin", &error);
     ASSERT(!error, error);
 
     free(data);
-    usearch_free(idx, &error);
+    usearch_free(index, &error);
     printf("Test: View - PASSED\n");
 }
 
-int main() {
+int main(int argc, char const* argv[]) {
 
     size_t collection_sizes[] = {11, 512};
     size_t dimensions[] = {83, 1};
-    for (size_t idx = 0; idx < sizeof(collection_sizes) / sizeof(collection_sizes[0]); ++idx) {
+    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[idx], dimensions[jdx]);
-            test_add_vector(collection_sizes[idx], dimensions[jdx]);
-            test_find_vector(collection_sizes[idx], dimensions[jdx]);
-            test_get_vector(collection_sizes[idx], dimensions[jdx]);
-            test_remove_vector(collection_sizes[idx], dimensions[jdx]);
-            test_save_load(collection_sizes[idx], dimensions[jdx]);
-            test_view(collection_sizes[idx], dimensions[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

@@ -241,6 +241,48 @@ USEARCH_EXPORT size_t usearch_remove(usearch_index_t, usearch_key_t key, usearch
  */
 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

package/cmake/clipp.cmake

@@ -5,4 +5,3 @@ FetchContent_Declare(
     GIT_TAG v1.2.3
 )
 FetchContent_MakeAvailable(clipp)
-include_directories(${clipp_SOURCE_DIR}/include)

package/cmake/jemalloc.cmake

@@ -1,44 +1,35 @@
-
 include(ExternalProject)
 set(JEMALLOC_DISABLE_TLS)
 
-if(${USTORE_BUILD_SDK_PYTHON})
+if (${USTORE_BUILD_SDK_PYTHON})
     set(JEMALLOC_DISABLE_TLS --disable-initial-exec-tls)
-endif()
+endif ()
 
-if(${USTORE_REBUILD_JEMALLOC})
+if (${USTORE_REBUILD_JEMALLOC})
     set(JEMALLOC_PREFIX_DIR ${CMAKE_BINARY_DIR}/_deps/jemalloc)
     set(JEMALLOC_SRC_DIR ${JEMALLOC_PREFIX_DIR}/src/jemalloc)
     set(JEMALLOC_INSTALL_DIR ${JEMALLOC_PREFIX_DIR}/install)
     set(JEMALLOC_DEPENDENCY jemalloc)
 
-    ExternalProject_Add(jemalloc
+    ExternalProject_Add(
+        jemalloc
         GIT_REPOSITORY https://github.com/jemalloc/jemalloc.git
         GIT_TAG 5.3.0
         PREFIX ${JEMALLOC_PREFIX_DIR}
-        CONFIGURE_COMMAND echo Configuring jemalloc
-        && cd ${JEMALLOC_SRC_DIR}
-        && ./autogen.sh && ./configure
-        --prefix=${JEMALLOC_INSTALL_DIR} --enable-prof ${JEMALLOC_DISABLE_TLS} # --with-jemalloc-prefix=je_
-        BUILD_COMMAND echo Building jemalloc && cd ${JEMALLOC_SRC_DIR}
-        && make install_lib_static install_include
+        CONFIGURE_COMMAND
+            echo Configuring jemalloc && cd ${JEMALLOC_SRC_DIR} && ./autogen.sh && ./configure
+            --prefix=${JEMALLOC_INSTALL_DIR} --enable-prof ${JEMALLOC_DISABLE_TLS} # --with-jemalloc-prefix=je_
+        BUILD_COMMAND echo Building jemalloc && cd ${JEMALLOC_SRC_DIR} && make install_lib_static install_include
         INSTALL_COMMAND ""
         UPDATE_COMMAND ""
     )
 
-    # Create libjemalloc and libjemalloc_pic targets to be used as
-    # dependencies
+    # Create libjemalloc and libjemalloc_pic targets to be used as dependencies
     add_library(libjemalloc STATIC IMPORTED GLOBAL)
     add_library(libjemalloc_pic STATIC IMPORTED GLOBAL)
 
-    set_property(TARGET libjemalloc
-        PROPERTY IMPORTED_LOCATION
-        ${JEMALLOC_INSTALL_DIR}/lib/libjemalloc.a
-    )
-    set_property(TARGET libjemalloc_pic
-        PROPERTY IMPORTED_LOCATION
-        ${JEMALLOC_INSTALL_DIR}/lib/libjemalloc_pic.a
-    )
+    set_property(TARGET libjemalloc PROPERTY IMPORTED_LOCATION ${JEMALLOC_INSTALL_DIR}/lib/libjemalloc.a)
+    set_property(TARGET libjemalloc_pic PROPERTY IMPORTED_LOCATION ${JEMALLOC_INSTALL_DIR}/lib/libjemalloc_pic.a)
 
     link_libraries(-Wl,--no-as-needed)
     link_libraries(dl ${libjemalloc_pic})
@@ -49,30 +40,23 @@ if(${USTORE_REBUILD_JEMALLOC})
 
     include_directories(${JEMALLOC_SOURCE_DIR}/include)
 
-else()
-    find_path(JEMALLOC_ROOT_DIR
-        NAMES include/jemalloc/jemalloc.h
-    )
+else ()
+    find_path(JEMALLOC_ROOT_DIR NAMES include/jemalloc/jemalloc.h)
 
-    find_library(JEMALLOC_LIBRARIES
+    find_library(
+        JEMALLOC_LIBRARIES
         NAMES jemalloc
         HINTS ${JEMALLOC_ROOT_DIR}/lib
     )
 
-    find_path(JEMALLOC_INCLUDE_DIR
+    find_path(
+        JEMALLOC_INCLUDE_DIR
         NAMES jemalloc/jemalloc.h
         HINTS ${JEMALLOC_ROOT_DIR}/include
     )
 
     include(FindPackageHandleStandardArgs)
-    find_package_handle_standard_args(JeMalloc DEFAULT_MSG
-        JEMALLOC_LIBRARIES
-        JEMALLOC_INCLUDE_DIR
-    )
+    find_package_handle_standard_args(JeMalloc DEFAULT_MSG JEMALLOC_LIBRARIES JEMALLOC_INCLUDE_DIR)
 
-    mark_as_advanced(
-        JEMALLOC_ROOT_DIR
-        JEMALLOC_LIBRARIES
-        JEMALLOC_INCLUDE_DIR
-    )
-endif()
+    mark_as_advanced(JEMALLOC_ROOT_DIR JEMALLOC_LIBRARIES JEMALLOC_INCLUDE_DIR)
+endif ()

package/conanfile.py

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