usearch 2.6.1 → 2.7.1

package/CMakeLists.txt

@@ -1,21 +1,31 @@
 # This CMake file is heavily inspired by following `usearch` CMake:
 # https://github.com/nlohmann/json/blob/develop/CMakeLists.txt
 cmake_minimum_required(VERSION 3.1)
-project(usearch VERSION 0.6.0 LANGUAGES C CXX)
+project(
+    usearch
+    VERSION 0.6.0
+    LANGUAGES C CXX
+)
 
 # Determine if USearch is built as a subproject (using `add_subdirectory`) or if it is the main project
 set(USEARCH_IS_MAIN_PROJECT OFF)
 if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
     set(USEARCH_IS_MAIN_PROJECT ON)
-endif()
+endif ()
 
 # Options
 option(USEARCH_INSTALL "Install CMake targets" OFF)
-option(USEARCH_BUILD_TEST "Compile a native unit test in C++" ${USEARCH_IS_MAIN_PROJECT})
-option(USEARCH_BUILD_BENCHMARK "Compile a native benchmark in C++" ${USEARCH_IS_MAIN_PROJECT})
+
+option(USEARCH_USE_OPENMP "Use OpenMP for a thread pool" OFF)
+option(USEARCH_USE_SIMSIMD "Use SimSIMD hardware-accelerated metrics" OFF)
+option(USEARCH_USE_JEMALLOC "Use JeMalloc for faster memory allocations" OFF)
+option(USEARCH_USE_NATIVE_F16 "Use native half-precision types" OFF)
+
+option(USEARCH_BUILD_TEST_CPP "Compile a native unit test in C++" ${USEARCH_IS_MAIN_PROJECT})
+option(USEARCH_BUILD_BENCH_CPP "Compile a native benchmark in C++" ${USEARCH_IS_MAIN_PROJECT})
+option(USEARCH_BUILD_LIB_C "Compile a native library for the C 99 interface" OFF)
+option(USEARCH_BUILD_TEST_C "Compile a test for the C 99 interface" OFF)
 option(USEARCH_BUILD_WOLFRAM "Compile Wolfram Language bindings" OFF)
-option(USEARCH_BUILD_CLIB "Compile a native library for the C 99 interface" OFF)
-option(USEARCH_BUILD_CTEST "Compile a test for the C 99 interface" OFF)
 
 # Includes
 set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake ${CMAKE_MODULE_PATH})
@@ -28,17 +38,19 @@ endif ()
 
 # Configuration
 include(GNUInstallDirs)
-set(USEARCH_TARGET_NAME               ${PROJECT_NAME})
-set(USEARCH_CONFIG_INSTALL_DIR        "${CMAKE_INSTALL_DATADIR}/cmake/${PROJECT_NAME}" CACHE INTERNAL "")
-set(USEARCH_INCLUDE_INSTALL_DIR       "${CMAKE_INSTALL_INCLUDEDIR}")
-set(USEARCH_TARGETS_EXPORT_NAME       "${PROJECT_NAME}Targets")
-set(USEARCH_CMAKE_CONFIG_TEMPLATE     "cmake/config.cmake.in")
-set(USEARCH_CMAKE_CONFIG_DIR          "${CMAKE_CURRENT_BINARY_DIR}")
+set(USEARCH_TARGET_NAME ${PROJECT_NAME})
+set(USEARCH_CONFIG_INSTALL_DIR
+    "${CMAKE_INSTALL_DATADIR}/cmake/${PROJECT_NAME}"
+    CACHE INTERNAL ""
+)
+set(USEARCH_INCLUDE_INSTALL_DIR "${CMAKE_INSTALL_INCLUDEDIR}")
+set(USEARCH_TARGETS_EXPORT_NAME "${PROJECT_NAME}Targets")
+set(USEARCH_CMAKE_CONFIG_TEMPLATE "cmake/config.cmake.in")
+set(USEARCH_CMAKE_CONFIG_DIR "${CMAKE_CURRENT_BINARY_DIR}")
 set(USEARCH_CMAKE_VERSION_CONFIG_FILE "${USEARCH_CMAKE_CONFIG_DIR}/${PROJECT_NAME}ConfigVersion.cmake")
 set(USEARCH_CMAKE_PROJECT_CONFIG_FILE "${USEARCH_CMAKE_CONFIG_DIR}/${PROJECT_NAME}Config.cmake")
 set(USEARCH_CMAKE_PROJECT_TARGETS_FILE "${USEARCH_CMAKE_CONFIG_DIR}/${PROJECT_NAME}Targets.cmake")
-set(USEARCH_PKGCONFIG_INSTALL_DIR      "${CMAKE_INSTALL_DATADIR}/pkgconfig")
-
+set(USEARCH_PKGCONFIG_INSTALL_DIR "${CMAKE_INSTALL_DATADIR}/pkgconfig")
 
 # Define our header-only library
 add_library(${USEARCH_TARGET_NAME} INTERFACE)
@@ -46,66 +58,42 @@ add_library(${PROJECT_NAME}::${USEARCH_TARGET_NAME} ALIAS ${USEARCH_TARGET_NAME}
 set(USEARCH_INCLUDE_BUILD_DIR "${PROJECT_SOURCE_DIR}/include/")
 if (${CMAKE_VERSION} VERSION_LESS "3.8.0")
     target_compile_features(${USEARCH_TARGET_NAME} INTERFACE cxx_range_for)
-else()
+else ()
     target_compile_features(${USEARCH_TARGET_NAME} INTERFACE cxx_std_11)
-endif()
+endif ()
 
 # Core compilation settings affecting "index.hpp"
 target_compile_definitions(
-    ${USEARCH_TARGET_NAME}
-    INTERFACE
-    $<$<NOT:$<BOOL:${JSON_GlobalUDLs}>>:USEARCH_USE_OPENMP=0>
+    ${USEARCH_TARGET_NAME} INTERFACE $<$<NOT:$<BOOL:${USEARCH_USE_OPENMP}>>:USEARCH_USE_OPENMP=0>
 )
 
 # Supplementary compilation settings affecting "index_plugins.hpp"
 target_compile_definitions(
-    ${USEARCH_TARGET_NAME}
-    INTERFACE
-    $<$<NOT:$<BOOL:${JSON_GlobalUDLs}>>:USEARCH_USE_NATIVE_F16=0>
+    ${USEARCH_TARGET_NAME} INTERFACE $<$<NOT:$<BOOL:${USEARCH_USE_NATIVE_F16}>>:USEARCH_USE_NATIVE_F16=0>
 )
 
 target_compile_definitions(
-    ${USEARCH_TARGET_NAME}
-    INTERFACE
-    $<$<NOT:$<BOOL:${JSON_GlobalUDLs}>>:USEARCH_USE_SIMSIMD=0>
+    ${USEARCH_TARGET_NAME} INTERFACE $<$<NOT:$<BOOL:${USEARCH_USE_SIMSIMD}>>:USEARCH_USE_SIMSIMD=0>
 )
 
 target_include_directories(
-    ${USEARCH_TARGET_NAME}
-    ${USEARCH_SYSTEM_INCLUDE} INTERFACE
-    $<BUILD_INTERFACE:${USEARCH_INCLUDE_BUILD_DIR}>
-    $<INSTALL_INTERFACE:include>
+    ${USEARCH_TARGET_NAME} ${USEARCH_SYSTEM_INCLUDE} INTERFACE $<BUILD_INTERFACE:${USEARCH_INCLUDE_BUILD_DIR}>
+                                                               $<INSTALL_INTERFACE:include>
 )
 
 # Install a pkg-config file, so other tools can find this
-configure_file(
-    "${CMAKE_CURRENT_SOURCE_DIR}/cmake/pkg-config.pc.in"
-    "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc"
-)
+configure_file("${CMAKE_CURRENT_SOURCE_DIR}/cmake/pkg-config.pc.in" "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc")
 
-# Install a custom package version config file instead of
-# write_basic_package_version_file to ensure that it's architecture-independent
-# https://github.com/nlohmann/json/issues/1697
+# Install a custom package version config file instead of write_basic_package_version_file to ensure that it's
+# architecture-independent https://github.com/nlohmann/json/issues/1697
 include(CMakePackageConfigHelpers)
-configure_file(
-    "cmake/usearchConfigVersion.cmake.in"
-    ${USEARCH_CMAKE_VERSION_CONFIG_FILE}
-    @ONLY
-)
-configure_file(
-    ${USEARCH_CMAKE_CONFIG_TEMPLATE}
-    ${USEARCH_CMAKE_PROJECT_CONFIG_FILE}
-    @ONLY
-)
+configure_file("cmake/usearchConfigVersion.cmake.in" ${USEARCH_CMAKE_VERSION_CONFIG_FILE} @ONLY)
+configure_file(${USEARCH_CMAKE_CONFIG_TEMPLATE} ${USEARCH_CMAKE_PROJECT_CONFIG_FILE} @ONLY)
 
-if(USEARCH_INSTALL)
-    install(
-        DIRECTORY ${USEARCH_INCLUDE_BUILD_DIR}
-        DESTINATION ${USEARCH_INCLUDE_INSTALL_DIR}
-    )
-    install(
-        FILES ${USEARCH_CMAKE_PROJECT_CONFIG_FILE} ${USEARCH_CMAKE_VERSION_CONFIG_FILE}
-        DESTINATION ${USEARCH_CONFIG_INSTALL_DIR}
+if (USEARCH_INSTALL)
+    install(DIRECTORY ${USEARCH_INCLUDE_BUILD_DIR} DESTINATION ${USEARCH_INCLUDE_INSTALL_DIR})
+    install(FILES ${USEARCH_CMAKE_PROJECT_CONFIG_FILE} ${USEARCH_CMAKE_VERSION_CONFIG_FILE}
+            DESTINATION ${USEARCH_CONFIG_INSTALL_DIR}
     )
     export(
         TARGETS ${USEARCH_TARGET_NAME}
@@ -115,31 +103,194 @@ if(USEARCH_INSTALL)
     install(
         TARGETS ${USEARCH_TARGET_NAME}
         EXPORT ${USEARCH_TARGETS_EXPORT_NAME}
-        INCLUDES DESTINATION ${USEARCH_INCLUDE_INSTALL_DIR}
+        INCLUDES
+        DESTINATION ${USEARCH_INCLUDE_INSTALL_DIR}
     )
     install(
         EXPORT ${USEARCH_TARGETS_EXPORT_NAME}
         NAMESPACE ${PROJECT_NAME}::
         DESTINATION ${USEARCH_CONFIG_INSTALL_DIR}
     )
-    install(
-        FILES "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc"
-        DESTINATION ${USEARCH_PKGCONFIG_INSTALL_DIR}
+    install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc" DESTINATION ${USEARCH_PKGCONFIG_INSTALL_DIR})
+endif ()
+
+# Find required packages
+if (CMAKE_HOST_SYSTEM_NAME MATCHES "Darwin")
+    set(CMAKE_THREAD_LIBS_INIT "-lpthread")
+    set(CMAKE_HAVE_THREADS_LIBRARY 1)
+    set(CMAKE_USE_WIN32_THREADS_INIT 0)
+    set(CMAKE_USE_PTHREADS_INIT 1)
+    set(THREADS_PREFER_PTHREAD_FLAG ON)
+endif ()
+find_package(Threads REQUIRED)
+
+if (USEARCH_USE_OPENMP)
+    find_package(OpenMP REQUIRED)
+endif ()
+
+if (USEARCH_USE_JEMALLOC)
+    include(jemalloc)
+endif ()
+
+# Set default build type to Release
+if (NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE RelWithDebInfo)
+endif ()
+
+# Include directories
+set(USEARCH_HEADER_INCLUDES "${CMAKE_CURRENT_SOURCE_DIR}/include" "${CMAKE_CURRENT_SOURCE_DIR}/fp16/include"
+                            "${CMAKE_CURRENT_SOURCE_DIR}/simsimd/include"
+)
+
+# Function to setup target
+function (setup_target TARGET_NAME)
+    # Compiler-specific options List of all possible compiler IDs:
+    # https://cmake.org/cmake/help/latest/variable/CMAKE_LANG_COMPILER_ID.html
+    if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        target_compile_options(
+            ${TARGET_NAME}
+            PRIVATE $<$<CONFIG:RELEASE>:-O3>
+                    $<$<CONFIG:RELWITHDEBINFO>:-O3
+                    -g>
+                    $<$<CONFIG:DEBUG>:-g
+                    -fsanitize=address
+                    -fsanitize=leak
+                    -fsanitize=alignment
+                    -fsanitize=undefined
+                    >
+                    -ffast-math
+                    -fPIC
+                    -Wall
+                    -Wextra
+                    -Wno-conversion
+                    -Wno-unknown-pragmas
+                    -march=native
+                    -fmax-errors=1
+                    -pedantic
+                    -fdiagnostics-color=always
+                    -ftime-report
+        )
+        target_link_options(
+            ${TARGET_NAME}
+            PRIVATE
+            $<$<CONFIG:DEBUG>:-g
+            -fsanitize=address
+            -fsanitize=leak
+            -fsanitize=alignment
+            -fsanitize=undefined
+            >
+            -fPIC
+        )
+
+        if (USEARCH_USE_OPENMP)
+            target_link_libraries(${TARGET_NAME} PRIVATE OpenMP::OpenMP_CXX)
+        endif ()
+
+        if (CMAKE_HOST_SYSTEM_NAME MATCHES "Darwin")
+            target_link_libraries(${TARGET_NAME} PRIVATE Threads::Threads)
+        endif ()
+
+    elseif (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+        target_compile_options(
+            ${TARGET_NAME}
+            PRIVATE $<$<CONFIG:RELEASE>:-O3>
+                    $<$<CONFIG:RELWITHDEBINFO>:-O3
+                    -g>
+                    $<$<CONFIG:DEBUG>:-g
+                    -fsanitize=address
+                    -fsanitize=alignment
+                    -fsanitize=undefined
+                    >
+                    -ffast-math
+                    -fPIC
+                    -pedantic
+                    -Wfatal-errors
+                    # Don't complain if the for-loops were not vectorzied
+                    -Wpass-failed=transform-warning
+                    -fcolor-diagnostics
+                    -ftime-trace
+        )
+        target_link_options(
+            ${TARGET_NAME}
+            PRIVATE
+            $<$<CONFIG:DEBUG>:-g
+            -fsanitize=address
+            -fsanitize=alignment
+            -fsanitize=undefined
+            >
+            -fPIC
+        )
+
+        # Check if the compiler is AppleClang, and if not, add the leak sanitizer
+        if (CMAKE_HOST_SYSTEM_NAME MATCHES "Darwin")
+            # It's likely AppleClang Adjust options as needed for AppleClang
+        else ()
+            # It's likely LLVM Clang
+            target_compile_options(${TARGET_NAME} PRIVATE $<$<CONFIG:DEBUG>:-fsanitize=leak>)
+            target_link_options(${TARGET_NAME} PRIVATE $<$<CONFIG:DEBUG>:-fsanitize=leak>)
+        endif ()
+
+        if (USEARCH_USE_OPENMP)
+            target_link_libraries(${TARGET_NAME} PRIVATE OpenMP::OpenMP_CXX)
+        endif ()
+
+        if (CMAKE_HOST_SYSTEM_NAME MATCHES "Darwin")
+            target_link_libraries(
+                ${TARGET_NAME} PRIVATE "-framework CoreFoundation" "-framework Security" Threads::Threads
+            )
+        else ()
+            target_link_libraries(${TARGET_NAME} PRIVATE Threads::Threads)
+        endif ()
+
+    elseif (CMAKE_CXX_COMPILER_ID STREQUAL "NVIDIA" OR CMAKE_CXX_COMPILER_ID STREQUAL "NVHPC")
+        target_compile_options(${TARGET_NAME} PRIVATE $<$<CONFIG:RELEASE>:-O3>)
+        target_compile_definitions(${TARGET_NAME} PRIVATE --expt-relaxed-constexpr --extended-lambda)
+        set_property(SOURCE bench.cpp PROPERTY LANGUAGE CUDA)
+        set_target_properties(${TARGET_NAME} PROPERTIES POSITION_INDEPENDENT_CODE ON)
+        set_target_properties(${TARGET_NAME} PROPERTIES CUDA_ARCHITECTURES "86")
+
+    elseif (CMAKE_CXX_COMPILER_ID STREQUAL "IntelLLVM")
+        target_compile_options(${TARGET_NAME} PRIVATE -w -ferror-limit=1)
+
+    elseif (CMAKE_CXX_COMPILER_ID MATCHES "MSVC")
+        target_compile_options(
+            ${TARGET_NAME} PRIVATE $<$<CONFIG:DEBUG>:/DEBUG> $<$<CONFIG:RELEASE>:/O2> $<$<CONFIG:RELWITHDEBINFO>:/O2
+                                   /DEBUG>
+        )
+    endif ()
+
+    target_include_directories(${TARGET_NAME} PRIVATE ${USEARCH_HEADER_INCLUDES})
+    set_target_properties(${TARGET_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR})
+    set_target_properties(${TARGET_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR})
+    set_target_properties(${TARGET_NAME} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
+    set_target_properties(${TARGET_NAME} PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
+    set_target_properties(${TARGET_NAME} PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
+    set_target_properties(${TARGET_NAME} PROPERTIES CXX_STANDARD 17)
+
+    # Core compilation settings affecting "index.hpp"
+    target_compile_definitions(${TARGET_NAME} PRIVATE $<$<NOT:$<BOOL:${USEARCH_USE_OPENMP}>>:USEARCH_USE_OPENMP=0>)
+
+    # Supplementary compilation settings affecting "index_plugins.hpp"
+    target_compile_definitions(
+        ${TARGET_NAME} PRIVATE $<$<NOT:$<BOOL:${USEARCH_USE_NATIVE_F16}>>:USEARCH_USE_NATIVE_F16=0>
     )
-endif()
 
-if(${USEARCH_BUILD_TEST} OR ${USEARCH_BUILD_BENCHMARK})
+    target_compile_definitions(${TARGET_NAME} PRIVATE $<$<NOT:$<BOOL:${USEARCH_USE_SIMSIMD}>>:USEARCH_USE_SIMSIMD=0>)
+
+endfunction ()
+
+if (${USEARCH_BUILD_TEST_CPP} OR ${USEARCH_BUILD_BENCH_CPP})
     add_subdirectory(cpp)
-endif()
+endif ()
 
-if(${USEARCH_BUILD_WOLFRAM})
+if (${USEARCH_BUILD_WOLFRAM})
     add_subdirectory(wolfram)
-endif()
+endif ()
 
-if(${USEARCH_BUILD_WASM})
+if (${USEARCH_BUILD_WASM})
     add_subdirectory(wasm)
-endif()
+endif ()
 
-if (${USEARCH_BUILD_CLIB} OR ${USEARCH_BUILD_CTEST})
+if (${USEARCH_BUILD_LIB_C} OR ${USEARCH_BUILD_TEST_C})
     add_subdirectory(c)
-endif()
+endif ()

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "usearch"
-version = "2.6.1"
+version = "2.7.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

@@ -392,7 +392,7 @@ doi = {10.5281/zenodo.7949416},
 author = {Vardanian, Ash},
 title = {{USearch by Unum Cloud}},
 url = {https://github.com/unum-cloud/usearch},
-version = {2.6.1},
+version = {2.7.1},
 year = {2022},
 month = jun,
 }

package/binding.gyp

@@ -10,6 +10,7 @@
                 "simsimd/include",
             ],
             "dependencies": ["<!(node -p \"require('node-addon-api').gyp\")"],
+            "defines": ["USEARCH_USE_SIMSIMD=1"],
             "cflags": [
                 "-fexceptions",
                 "-Wno-unknown-pragmas",
@@ -19,7 +20,7 @@
                 "-fexceptions",
                 "-Wno-unknown-pragmas",
                 "-Wno-maybe-uninitialized",
-                "-std=c++11",
+                "-std=c++17",
             ],
             "xcode_settings": {
                 "GCC_ENABLE_CPP_EXCEPTIONS": "YES",
@@ -29,7 +30,7 @@
             "msvs_settings": {
                 "VCCLCompilerTool": {
                     "ExceptionHandling": 1,
-                    "AdditionalOptions": ["-std:c++11"],
+                    "AdditionalOptions": ["-std:c++17"],
                 }
             },
         }

package/build.gradle

@@ -96,27 +96,36 @@ publishing {
                 name = "USearch"
                 description = "Smaller & Faster Single-File Vector Search Engine from Unum"
                 url = "https://github.com/unum-cloud/usearch"
+
                 licenses {
                     license {
                         name = 'The Apache License, Version 2.0'
                         url = 'http://www.apache.org/licenses/LICENSE-2.0.txt'
                     }
                 }
+
+                scm {
+                    connection = 'scm:git:git://github.com/unum-cloud/usearch.git'
+                    developerConnection = 'scm:git:ssh://github.com/unum-cloud/usearch.git'
+                    url = 'https://github.com/unum-cloud/usearch'
+                }
+
             }
         }
     }
 
+
     // Publishing to GitHub is much easier ;)
-    // repositories {
-    //     maven {
-    //         name = "OSSRH"
-    //         url = "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
-    //         credentials {
-    //             username = System.getenv("MAVEN_USERNAME")
-    //             password = System.getenv("MAVEN_PASSWORD")
-    //         }
-    //     }
-    // }
+    repositories {
+        maven {
+            name = "OSSRH"
+            url = "https://s01.oss.sonatype.org/service/local/staging/deploy/maven2/"
+            credentials {
+                username = System.getenv("MAVEN_USERNAME")
+                password = System.getenv("MAVEN_PASSWORD")
+            }
+        }
+    }
 
     repositories {
         maven {

package/c/CMakeLists.txt

@@ -1,52 +1,25 @@
-
-
-set(USEARCH_PUNNED_INCLUDE_DIRS
-    "${CMAKE_CURRENT_SOURCE_DIR}/../include"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../fp16/include"
-    "${CMAKE_CURRENT_SOURCE_DIR}/../simsimd/include"
-    "${CMAKE_CURRENT_SOURCE_DIR}/"
-)
-
-# This article discusses a better way to allow building either static or shared libraries
+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_STATIC})
-    if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-        set(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -static-libstdc++")
-    elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-        set(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -static")
-    endif()
-
-    add_library(usearch_c STATIC "${CMAKE_CURRENT_SOURCE_DIR}/lib.cpp")
-else()
-    add_library(usearch_c SHARED "${CMAKE_CURRENT_SOURCE_DIR}/lib.cpp")
-endif()
-
-set_target_properties(usearch_c PROPERTIES POSITION_INDEPENDENT_CODE ON)
-set_target_properties(usearch_c PROPERTIES CXX_STANDARD 11)
-set_target_properties(usearch_c PROPERTIES C_STANDARD 99)
-
-target_include_directories(usearch_c PRIVATE ${USEARCH_PUNNED_INCLUDE_DIRS})
-set_target_properties(usearch_c PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
-set_target_properties(usearch_c PROPERTIES ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
-set_target_properties(usearch_c PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
-
-
-target_include_directories(usearch_c PRIVATE ${USEARCH_PUNNED_INCLUDE_DIRS})
+if (USEARCH_BUILD_LIB_C)
+    add_library(usearch_c SHARED lib.cpp)
+    add_library(usearch_static_c STATIC lib.cpp)
 
-if(${USEARCH_DEBUG_BUILD_ASAN})
-    # For ASAN in debug builds
-    target_link_libraries(usearch_c PRIVATE gcov)
-endif()
+    # Set the compile options for the static library
+    if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        target_compile_options(usearch_static_c PRIVATE -static-libstdc++)
+    elseif (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+        target_compile_options(usearch_static_c PRIVATE -static)
+    endif ()
 
-if(${USEARCH_USE_SIMSIMD})
-    target_compile_definitions(usearch_c PRIVATE USEARCH_USE_SIMSIMD=1)
-endif()
-if (${USEARCH_LOOKUP_LABEL})
-    target_compile_definitions(usearch_c PRIVATE USEARCH_LOOKUP_LABEL=1)
-endif()
+    setup_target(usearch_c)
+    setup_target(usearch_static_c)
 
-if(${USEARCH_BUILD_CTEST})
-    add_executable(test_c "${CMAKE_CURRENT_SOURCE_DIR}/test.c")
-    target_link_libraries(test_c usearch_c)
-    set_target_properties(test_c PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR})
-endif()
+endif ()

package/c/README.md

@@ -3,13 +3,13 @@
 ## Installation
 
 The simplest form to integrate is to copy the contents of `usearch/c/` into your project.
-To build the library `libusearch_c`, pass enable the `USEARCH_BUILD_CLIB` CMake option:
+To build the library `libusearch_static_c` and `libusearch_c`, pass enable the `USEARCH_BUILD_LIB_C` CMake option:
 
 ```bash
- cmake -DUSEARCH_BUILD_CLIB=1 -DUSEARCH_BUILD_CTEST=1 -DUSEARCH_BUILD_STATIC=0 -DUSEARCH_BUILD_TEST=0 -DUSEARCH_BUILD_BENCHMARK=0 ..
- ```
-
-You can choose between a static and dynamic library by setting `USEARCH_BUILD_STATIC`.
+cmake -B ./build -DUSEARCH_BUILD_LIB_C=1 -DUSEARCH_BUILD_TEST_C=1 -DUSEARCH_BUILD_TEST_CPP=0 -DUSEARCH_BUILD_BENCH_CPP=0
+make -C ./build
+./build/test_c
+```
 
 ## Quickstart
 

package/c/lib.cpp

@@ -87,15 +87,17 @@ USEARCH_EXPORT usearch_index_t usearch_init(usearch_init_options_t* options, use
     metric_kind_t metric_kind = to_native_metric(options->metric_kind);
     scalar_kind_t scalar_kind = to_native_scalar(options->quantization);
 
-    auto metric_lambda = [options](byte_t const* a, byte_t const* b) -> usearch_distance_t {
-        return options->metric((void const*)a, (void const*)b);
-    };
     metric_punned_t metric = //
-        options->metric ? metric_punned_t(metric_lambda, options->dimensions, metric_kind, scalar_kind)
-                        : metric_punned_t(options->dimensions, metric_kind, scalar_kind);
+        !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);
 
     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;
 }
 
@@ -235,8 +237,8 @@ USEARCH_EXPORT size_t usearch_remove(usearch_index_t index, usearch_key_t key, u
     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) {
+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);
     labeling_result_t result = reinterpret_cast<index_dense_t*>(index)->rename(from, to);
@@ -244,4 +246,47 @@ USEARCH_EXPORT size_t usearch_rename(usearch_index_t index, usearch_key_t from,
         *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, to_native_metric(metric_kind), to_native_scalar(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) {
+
+    metric_punned_t metric(dimensions, to_native_metric(metric_kind), to_native_scalar(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);
+    }
+}
 }