usearch 0.1.8 → 0.1.10

package/python/test.py

@@ -2,19 +2,44 @@ import numpy as np
 
 import usearch
 
-count_vectors = 100
-count_dimensions = 96
+from numba import cfunc, types, carray
+
+# Showcases how to use Numba to JIT-compile similarity measures for USearch.
+# https://numba.readthedocs.io/en/stable/reference/jit-compilation.html#c-callbacks
+
+signature = types.float32(
+    types.CPointer(types.float32),
+    types.CPointer(types.float32),
+    types.size_t, types.size_t)
+
+
+@cfunc(signature)
+def python_dot(a, b, n, m):
+    a_array = carray(a, n)
+    b_array = carray(b, n)
+    c = 0.0
+    for i in range(n):
+        c += a_array[i] * b_array[i]
+    return c
 
-index = usearch.Index(dim=96)
-print(index)
 
+count_vectors = 100
+count_dimensions = 96
 vectors = np.random.uniform(
     0, 0.3, (count_vectors, count_dimensions)).astype(np.float32)
 labels = np.array(range(count_vectors), dtype=np.longlong)
-print('will insert', labels.shape, vectors.shape)
 
+index_udf = usearch.Index(ndim=96, metric_pointer=python_dot.address)
+index_udf.add(labels, vectors, copy=True)
+results = index_udf.search(vectors, 10)
+print('found', results[0].shape, results[1].shape, results[2].shape)
+
+
+index = usearch.Index(ndim=96)
 index.add(labels, vectors, copy=True)
+assert index.ndim == count_dimensions
+assert index.capacity >= count_vectors
+assert len(index) == count_vectors
 
-print('will search')
 results = index.search(vectors, 10)
 print('found', results[0].shape, results[1].shape, results[2].shape)

package/python/usearch/client.py

@@ -0,0 +1,34 @@
+import numpy as np
+from ucall.client import Client
+
+
+class IndexClient:
+
+    def __init__(self, uri: str = '127.0.0.1', port: int = 8545, use_http: bool = True) -> None:
+        self.client = Client(uri=uri, port=port, use_http=use_http)
+
+    def add(self, labels: np.array, vectors: np.array):
+        if isinstance(labels, int):
+            return self.client.add_one(label=labels, vectors=vectors)
+        else:
+            return self.client.add_many(labels=labels, vectors=vectors)
+
+    def search(self, vectors: np.array, count: int) -> tuple[np.array, np.array, np.array]:
+        matches = []
+        distances = []
+        counts = []
+        # return self.client.search_one(vectors=vectors, count=count)
+        return matches, distances, counts
+
+    def __len__(self):
+        return self.client.size()
+
+    @property
+    def ndim(self):
+        return self.client.ndim()
+
+    def capacity(self):
+        return self.client.capacity()
+
+    def connectivity(self):
+        return self.client.connectivity()

package/python/usearch/io.py

@@ -0,0 +1,67 @@
+import struct
+import numpy as np
+
+
+def load_matrix(filename: str, start_row: int = 0, count_rows: int = None, view: bool = False):
+    """
+    Read *.ibin, *.hbin, *.fbin, *.dbin files with matrixes.
+    Args:
+        :param filename (str): path to the matrix file
+        :param start_row (int): start reading vectors from this index
+        :param count_rows (int): number of vectors to read. If None, read all vectors
+    Returns:
+        Parsed matrix (numpy.ndarray)
+    """
+    dtype = np.float32
+    scalar_size = 4
+    if filename.endswith('.fbin'):
+        dtype = np.float32
+        scalar_size = 4
+    elif filename.endswith('.dbin'):
+        dtype = np.float64
+        scalar_size = 8
+    elif filename.endswith('.hbin'):
+        dtype = np.float16
+        scalar_size = 2
+    elif filename.endswith('.ibin'):
+        dtype = np.int32
+        scalar_size = 4
+    else:
+        raise Exception('Unknown file type')
+
+    with open(filename, 'rb') as f:
+        rows, cols = np.fromfile(f, count=2, dtype=np.int32)
+        rows = (rows - start_row) if count_rows is None else count_rows
+        row_offset = start_row * scalar_size * cols
+
+        if view:
+            return np.memmap(f, dtype=dtype, mode='r', offset=8+row_offset, shape=(rows, cols))
+        else:
+            return np.fromfile(f, count=rows * cols, dtype=dtype, offset=row_offset).reshape(rows, cols)
+
+
+def save_matrix(vecs: np.array, filename: str):
+    """
+    Write *.ibin, *.hbin, *.fbin, *.dbin files with matrixes.
+    Args:
+        :param vecs (numpy.array): the matrix to serialize
+        :param filename (str): path to the matrix file
+    """
+    dtype = np.float32
+    if filename.endswith('.fbin'):
+        dtype = np.float32
+    elif filename.endswith('.dbin'):
+        dtype = np.float64
+    elif filename.endswith('.hbin'):
+        dtype = np.float16
+    elif filename.endswith('.ibin'):
+        dtype = np.int32
+    else:
+        raise Exception('Unknown file type')
+
+    assert len(vecs.shape) == 2, 'Input array must have 2 dimensions'
+    with open(filename, 'wb') as f:
+        nvecs, dim = vecs.shape
+        f.write(struct.pack('<i', nvecs))
+        f.write(struct.pack('<i', dim))
+        vecs.astype(dtype).flatten().tofile(f)

package/python/usearch/server.py

@@ -0,0 +1,51 @@
+import ucall.rich_posix as ucall
+import usearch
+
+import fire
+import numpy as np
+from PIL import Image
+
+
+def serve(ndim: int, metric: str = 'ip'):
+
+    server = ucall.Server()
+    index = usearch.Index(ndim=ndim, metric=metric)
+
+    @server
+    def add_one(label: int, vector: np.array):
+        labels = np.array([label], dtype=np.longlong)
+        vectors = vector.reshape(vector.shape[0], 1)
+        index.add(labels, vectors, copy=True)
+
+    @server
+    def add_many(labels: np.array, vectors: np.array):
+        labels = labels.astype(np.longlong)
+        index.add(labels, vectors, copy=True)
+
+    @server
+    def search_one(vector: np.array, count: int) -> np.ndarray:
+        vectors = vector.reshape(vector.shape[0], 1)
+        results = index.search(vectors, 3)
+        return results[0][:results[2][0]]
+
+    @server
+    def size() -> int:
+        return len(index)
+
+    @server
+    def ndim() -> int:
+        return index.ndim
+
+    @server
+    def capacity() -> int:
+        return index.capacity()
+
+    @server
+    def connectivity() -> int:
+        return index.connectivity()
+
+    server.run()
+
+
+if __name__ == '__main__':
+    fire(serve)

package/setup.py

@@ -32,7 +32,7 @@ setup(
     version=__version__,
     packages=find_packages(),
 
-    description='The Mighty Tiny Vector Search Engine with Automatic Quantization and Hardware Acceleration',
+    description='Smaller & Faster Single-File Vector Search Engine from Unum',
     long_description=long_description,
     long_description_content_type='text/markdown',
     license='Apache-2.0',

package/simsimd/.vscode/settings.json

@@ -62,12 +62,14 @@
         "stop_token": "cpp",
         "streambuf": "cpp",
         "thread": "cpp",
-        "typeinfo": "cpp"
+        "typeinfo": "cpp",
+        "complex": "cpp"
     },
     "cSpell.words": [
         "dtype",
         "dtypes",
         "kann",
+        "simsimd",
         "unsw"
     ]
 }

package/simsimd/include/simsimd/simsimd.h

@@ -70,7 +70,10 @@ inline static simsimd_f16_t simsimd_dot_f16sve(simsimd_f16_t const* a_enum, sims
         i += svcnth();
         pg_vec = svwhilelt_b16(i, d);
     } while (svptest_any(svptrue_b16(), pg_vec));
-    return static_cast<simsimd_f16_t>(svaddv_f16(svptrue_b16(), ab_vec));
+    float16_t f16 = svaddv_f16(svptrue_b16(), ab_vec);
+    simsimd_f16_t i16;
+    memcpy(&i16, &f16, sizeof(i16));
+    return i16;
 #else
     (void)a_enum, (void)b_enum, (void)d;
     return 0;
@@ -103,7 +106,7 @@ inline static simsimd_f32_t simsimd_cos_f32sve(simsimd_f32_t const* a, simsimd_f
 #endif
 }
 
-inline static simsimd_f32_t simsimd_euclidean_f32sve(simsimd_f32_t const* a, simsimd_f32_t const* b, size_t d) {
+inline static simsimd_f32_t simsimd_l2sq_f32sve(simsimd_f32_t const* a, simsimd_f32_t const* b, size_t d) {
 #if defined(__ARM_FEATURE_SVE)
     size_t i = 0;
     svfloat32_t d2_vec = svdupq_n_f32(0.f, 0.f, 0.f, 0.f);
@@ -124,8 +127,7 @@ inline static simsimd_f32_t simsimd_euclidean_f32sve(simsimd_f32_t const* a, sim
 #endif
 }
 
-inline static simsimd_f16_t simsimd_euclidean_f16sve( //
-    simsimd_f16_t const* a_enum, simsimd_f16_t const* b_enum, size_t d) {
+inline static simsimd_f16_t simsimd_l2sq_f16sve(simsimd_f16_t const* a_enum, simsimd_f16_t const* b_enum, size_t d) {
 #if defined(__ARM_FEATURE_SVE)
     size_t i = 0;
     svfloat16_t d2_vec = svdupq_n_f16(0, 0, 0, 0, 0, 0, 0, 0);
@@ -140,8 +142,10 @@ inline static simsimd_f16_t simsimd_euclidean_f16sve( //
         i += svcnth();
         pg_vec = svwhilelt_b16(i, d);
     } while (svptest_any(svptrue_b16(), pg_vec));
-    simsimd_f16_t d2 = svaddv_f16(svptrue_b16(), d2_vec);
-    return static_cast<simsimd_f16_t>(sqrt(d2));
+    float16_t f16 = svaddv_f16(svptrue_b16(), d2_vec);
+    simsimd_f16_t i16;
+    memcpy(&i16, &f16, sizeof(i16));
+    return i16;
 #else
     (void)a_enum, (void)b_enum, (void)d;
     return 0;
@@ -186,7 +190,10 @@ inline static simsimd_f16_t simsimd_dot_f16x8neon(simsimd_f16_t const* a, simsim
     float16x8_t ab_vec = vdupq_n_f16(0);
     for (size_t i = 0; i != d; i += 8)
         ab_vec = vaddq_f16(ab_vec, vmulq_f16(vld1q_f16((float16_t const*)a + i), vld1q_f16((float16_t const*)b + i)));
-    return vaddvq_f32(vcvt_f32_f16(vget_high_f16(ab_vec))) + vaddvq_f32(vcvt_f32_f16(vget_low_f16(ab_vec)));
+    float16_t f16 = vaddvq_f32(vcvt_f32_f16(vget_high_f16(ab_vec))) + vaddvq_f32(vcvt_f32_f16(vget_low_f16(ab_vec)));
+    simsimd_f16_t i16;
+    memcpy(&i16, &f16, sizeof(i16));
+    return i16;
 #else
     (void)a, (void)b, (void)d;
     return 0;

package/src/advanced.hpp

@@ -7,8 +7,14 @@
 #include <sys/auxv.h>
 #endif
 
+#if defined(__aarch64__)
+#include <arm_fp16.h>
+#endif
+
 #include <fp16/fp16.h>
+#if defined(USEARCH_USE_SIMD)
 #include <simsimd/simsimd.h>
+#endif
 
 #include <usearch/usearch.hpp>
 
@@ -39,6 +45,27 @@ template <typename at> inline at clamp(at v, at lo, at hi) noexcept {
 class i8q100_converted_t;
 class f16_converted_t;
 
+inline float f16_to_f32(std::uint16_t u16) noexcept {
+#if defined(__aarch64__)
+    __fp16 f16;
+    std::memcpy(&f16, &u16, sizeof(std::uint16_t));
+    return float(f16);
+#else
+    return fp16_ieee_to_fp32_value(u16);
+#endif
+}
+
+inline std::uint16_t f32_to_f16(float f32) noexcept {
+#if defined(__aarch64__)
+    __fp16 f16 = __fp16(f32);
+    std::uint16_t u16;
+    std::memcpy(&u16, &f16, sizeof(std::uint16_t));
+    return u16;
+#else
+    return fp16_ieee_from_fp32_value(f32);
+#endif
+}
+
 class f16_converted_t {
     std::uint16_t uint16_{};
 
@@ -49,11 +76,11 @@ class f16_converted_t {
     inline f16_converted_t(f16_converted_t const&) = default;
     inline f16_converted_t& operator=(f16_converted_t const&) = default;
 
-    inline operator float() const noexcept { return fp16_ieee_to_fp32_value(uint16_); }
+    inline operator float() const noexcept { return f16_to_f32(uint16_); }
 
     inline f16_converted_t(i8q100_converted_t) noexcept;
-    inline f16_converted_t(float v) noexcept : uint16_(fp16_ieee_from_fp32_value(v)) {}
-    inline f16_converted_t(double v) noexcept : uint16_(fp16_ieee_from_fp32_value(v)) {}
+    inline f16_converted_t(float v) noexcept : uint16_(f32_to_f16(v)) {}
+    inline f16_converted_t(double v) noexcept : uint16_(f32_to_f16(v)) {}
 
     inline f16_converted_t operator+(f16_converted_t other) const noexcept { return {float(*this) + float(other)}; }
     inline f16_converted_t operator-(f16_converted_t other) const noexcept { return {float(*this) - float(other)}; }
@@ -69,22 +96,22 @@ class f16_converted_t {
     inline f16_converted_t operator/(double other) const noexcept { return {float(*this) / other}; }
 
     inline f16_converted_t& operator+=(float v) noexcept {
-        uint16_ = fp16_ieee_from_fp32_value(v + fp16_ieee_to_fp32_value(uint16_));
+        uint16_ = f32_to_f16(v + f16_to_f32(uint16_));
         return *this;
     }
 
     inline f16_converted_t& operator-=(float v) noexcept {
-        uint16_ = fp16_ieee_from_fp32_value(v - fp16_ieee_to_fp32_value(uint16_));
+        uint16_ = f32_to_f16(v - f16_to_f32(uint16_));
         return *this;
     }
 
     inline f16_converted_t& operator*=(float v) noexcept {
-        uint16_ = fp16_ieee_from_fp32_value(v * fp16_ieee_to_fp32_value(uint16_));
+        uint16_ = f32_to_f16(v * f16_to_f32(uint16_));
         return *this;
     }
 
     inline f16_converted_t& operator/=(float v) noexcept {
-        uint16_ = fp16_ieee_from_fp32_value(v / fp16_ieee_to_fp32_value(uint16_));
+        uint16_ = f32_to_f16(v / f16_to_f32(uint16_));
         return *this;
     }
 };
@@ -102,6 +129,10 @@ class i8q100_converted_t {
     inline operator float() const noexcept { return float(int8_) / 100.f; }
     inline operator f16_converted_t() const noexcept { return float(int8_) / 100.f; }
     inline operator double() const noexcept { return double(int8_) / 100.0; }
+    inline operator std::int8_t() const noexcept { return int8_; }
+    inline operator std::int16_t() const noexcept { return int8_; }
+    inline operator std::int32_t() const noexcept { return int8_; }
+    inline operator std::int64_t() const noexcept { return int8_; }
 
     inline i8q100_converted_t(float v) noexcept
         : int8_(usearch::clamp<std::int8_t>(static_cast<std::int8_t>(v * 100.f), -100, 100)) {}
@@ -127,17 +158,17 @@ void multithreaded(std::size_t threads, std::size_t tasks, callback_at&& callbac
     }
 
     std::vector<std::thread> threads_pool;
-    std::size_t tasks_per_thread = threads / tasks + (threads % tasks) != 0;
-    for (std::size_t thread = 0; thread != threads; ++thread) {
+    std::size_t tasks_per_thread = (tasks / threads) + ((tasks % threads) != 0);
+    for (std::size_t thread_idx = 0; thread_idx != threads; ++thread_idx) {
         threads_pool.emplace_back([=]() {
-            for (std::size_t task_idx = thread * tasks_per_thread;
-                 task_idx < std::min(tasks, thread * tasks_per_thread + tasks_per_thread); ++task_idx)
-                callback(thread, task_idx);
+            for (std::size_t task_idx = thread_idx * tasks_per_thread;
+                 task_idx < std::min(tasks, thread_idx * tasks_per_thread + tasks_per_thread); ++task_idx)
+                callback(thread_idx, task_idx);
         });
     }
 
-    for (std::size_t thread = 0; thread != threads; ++thread)
-        threads_pool[thread].join();
+    for (std::size_t thread_idx = 0; thread_idx != threads; ++thread_idx)
+        threads_pool[thread_idx].join();
 }
 
 /**
@@ -172,6 +203,16 @@ enum class accuracy_t {
     i8q100_k,
 };
 
+inline char const* accuracy_name(accuracy_t accuracy) noexcept {
+    switch (accuracy) {
+    case accuracy_t::f32_k: return "f32";
+    case accuracy_t::f16_k: return "f16";
+    case accuracy_t::f64_k: return "f64";
+    case accuracy_t::i8q100_k: return "i8q100";
+    default: return "";
+    }
+}
+
 inline bool str_equals(char const* begin, std::size_t len, char const* other_begin) noexcept {
     std::size_t other_len = strlen(other_begin);
     return len == other_len && strncmp(begin, other_begin, len) == 0;
@@ -217,13 +258,14 @@ enum class isa_t {
     avx512_k,
 };
 
-inline char const* isa(isa_t isa) noexcept {
+inline char const* isa_name(isa_t isa) noexcept {
     switch (isa) {
     case isa_t::auto_k: return "auto";
     case isa_t::neon_k: return "neon";
     case isa_t::sve_k: return "sve";
     case isa_t::avx2_k: return "avx2";
     case isa_t::avx512_k: return "avx512";
+    default: return "";
     }
 }
 
@@ -271,9 +313,25 @@ template <> struct cast_gt<f16_converted_t, f16_converted_t> {
     bool operator()(byte_t const*, std::size_t, byte_t*) noexcept { return false; }
 };
 
+struct ip_i8q100_converted_t {
+    float operator()(i8q100_converted_t const* a, i8q100_converted_t const* b, std::size_t d) const noexcept {
+        std::int64_t ab = 0;
+#if defined(__GNUC__)
+#pragma GCC ivdep
+#elif defined(__clang__)
+#pragma clang loop vectorize(enable)
+#elif defined(_OPENMP)
+#pragma omp simd reduction(+ : ab)
+#endif
+        for (std::size_t i = 0; i < d; ++i)
+            ab += std::int16_t(a[i]) * std::int16_t(b[i]);
+        return 1.f - ab / 10000.f;
+    }
+};
+
 /**
  *  @brief  Oversimplified type-punned index for equidimensional floating-point
- *          vectors with automatic down-casting and isa acceleration.
+ *          vectors with automatic down-casting and hardware acceleration.
  */
 template <typename label_at = std::int64_t, typename id_at = std::uint32_t> //
 class auto_index_gt {
@@ -351,6 +409,12 @@ class auto_index_gt {
     static auto_index_gt haversine(accuracy_t accuracy = accuracy_t::f32_k, config_t config = {}) { return make(2, accuracy, haversine_metric(accuracy), make_casts(accuracy), config); }
     // clang-format on
 
+    static auto_index_gt udf(                                    //
+        std::size_t dimensions, punned_stateful_metric_t metric, //
+        accuracy_t accuracy = accuracy_t::f32_k, config_t config = {}) {
+        return make(dimensions, accuracy, {metric, isa_t::auto_k}, make_casts(accuracy), config);
+    }
+
     auto_index_gt fork() const {
         auto_index_gt result;
 
@@ -445,7 +509,8 @@ class auto_index_gt {
     }
 
     static metric_and_meta_t ip_metric_f32(std::size_t dimensions) {
-#if 0
+        (void)dimensions;
+#if defined(USEARCH_USE_SIMD)
 #if defined(__x86_64__)
         if (dimensions % 4 == 0)
             return {
@@ -458,7 +523,7 @@ class auto_index_gt {
         if (supports_arm_sve())
             return {
                 pun_metric<simsimd_f32_t>([](simsimd_f32_t const* a, simsimd_f32_t const* b, size_t d) noexcept {
-                return 1 - simsimd_dot_f32sve(a, b, d);
+                    return 1 - simsimd_dot_f32sve(a, b, d);
                 }),
                 isa_t::sve_k,
             };
@@ -475,7 +540,8 @@ class auto_index_gt {
     }
 
     static metric_and_meta_t ip_metric_f16(std::size_t dimensions) {
-#if 0
+        (void)dimensions;
+#if defined(USEARCH_USE_SIMD)
 #if defined(__x86_64__)
 #elif defined(__aarch64__)
         if (supports_arm_sve())
@@ -499,7 +565,7 @@ class auto_index_gt {
 
     static metric_and_meta_t ip_metric(std::size_t dimensions, accuracy_t accuracy) {
         switch (accuracy) {
-        case accuracy_t::i8q100_k: return {};
+        case accuracy_t::i8q100_k: return {pun_metric<i8q100_converted_t>(ip_i8q100_converted_t{}), isa_t::auto_k};
         case accuracy_t::f16_k: return ip_metric_f16(dimensions);
         case accuracy_t::f32_k: return ip_metric_f32(dimensions);
         case accuracy_t::f64_k: return {pun_metric<f64_t>(ip_gt<f64_t>{}), isa_t::auto_k};

package/src/bench.cpp

@@ -26,6 +26,8 @@
 using namespace unum::usearch;
 using namespace unum;
 
+using vector_id_t = std::uint32_t;
+
 template <typename element_at>
 std::size_t offset_of(element_at const* begin, element_at const* end, element_at v) noexcept {
     auto iterator = begin;
@@ -295,8 +297,10 @@ void run_type_punned(dataset_at& dataset, args_t const& args, config_t config) {
     if (args.quantize_i8)
         accuracy = accuracy_t::i8q100_k;
 
+    std::printf("-- Accuracy: %s\n", accuracy_name(accuracy));
+
     index_at index{type_punned_index_for_metric<index_at>(dataset, args, config, accuracy)};
-    std::printf("- Hardware acceleration: %s\n", isa(index.acceleration()));
+    std::printf("- Hardware acceleration: %s\n", isa_name(index.acceleration()));
     std::printf("-- Will benchmark in-memory\n");
 
     single_shot(dataset, index, true);
@@ -342,6 +346,34 @@ void run_big_or_small(dataset_at& dataset, args_t const& args, config_t config)
         run_type_punned<auto_index_gt<std::size_t, neighbor_id_at>>(dataset, args, config);
 }
 
+void report_expected_losses(persisted_dataset_gt<float, vector_id_t> const& dataset) {
+
+    auto vec1 = dataset.vector(0);
+    auto vec2 = dataset.query(0);
+    std::vector<f16_converted_t> vec1f16(dataset.dimensions());
+    std::vector<f16_converted_t> vec2f16(dataset.dimensions());
+    std::transform(vec1, vec1 + dataset.dimensions(), vec1f16.data(), [](float v) { return v; });
+    std::transform(vec2, vec2 + dataset.dimensions(), vec2f16.data(), [](float v) { return v; });
+    std::vector<i8q100_converted_t> vec1i8(dataset.dimensions());
+    std::vector<i8q100_converted_t> vec2i8(dataset.dimensions());
+    std::transform(vec1, vec1 + dataset.dimensions(), vec1i8.data(), [](float v) { return v; });
+    std::transform(vec2, vec2 + dataset.dimensions(), vec2i8.data(), [](float v) { return v; });
+
+#if 0
+    auto ip_default = ip_gt<float>{}(vec1, vec2, dataset.dimensions());
+    auto ip_sve = 1.f - simsimd_dot_f32sve(vec1, vec2, dataset.dimensions());
+    auto ip_neon = 1.f - simsimd_dot_f32x4neon(vec1, vec2, dataset.dimensions());
+    auto ip_f16 = ip_gt<f16_converted_t>{}(vec1f16.data(), vec2f16.data(), dataset.dimensions());
+    auto ip_f16sve = 1.f - simsimd_dot_f16sve((simsimd_f16_t const*)vec1f16.data(),
+                                              (simsimd_f16_t const*)vec2f16.data(), dataset.dimensions());
+    auto ip_f16neon = 1.f - simsimd_dot_f16x8neon((simsimd_f16_t const*)vec1f16.data(),
+                                                  (simsimd_f16_t const*)vec2f16.data(), dataset.dimensions());
+    auto ip_i8 = ip_i8q100_converted_t{}(vec1i8.data(), vec2i8.data(), dataset.dimensions());
+
+    exit(0);
+#endif
+}
+
 int main(int argc, char** argv) {
 
     // Print backtrace if something goes wrong.
@@ -391,8 +423,6 @@ int main(int argc, char** argv) {
     std::printf("-- Query vectors path: %s\n", args.path_queries.c_str());
     std::printf("-- Ground truth neighbors path: %s\n", args.path_neighbors.c_str());
 
-    using vector_id_t = std::uint32_t;
-
     persisted_dataset_gt<float, vector_id_t> dataset{
         args.path_vectors.c_str(),
         args.path_queries.c_str(),
@@ -410,6 +440,11 @@ int main(int argc, char** argv) {
     config.max_threads_add = config.max_threads_search = args.threads;
     config.max_elements = dataset.vectors_count();
 
+    std::printf("- Index: \n");
+    std::printf("-- Connectivity: %zu\n", config.connectivity);
+    std::printf("-- Expansion @ Add: %zu\n", config.expansion_add);
+    std::printf("-- Expansion @ Search: %zu\n", config.expansion_search);
+
     if (args.big)
         run_big_or_small<uint40_t>(dataset, args, config);
     else

package/wolfram/CMakeLists.txt

@@ -0,0 +1,17 @@
+
+if(NOT WOLFRAM_PATH)
+    set(WOLFRAM_PATH "/usr/local/Wolfram/Mathematica")
+endif()
+
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${WOLFRAM_PATH}/SystemFiles/Links/WSTP/DeveloperKit/Linux-x86-64/CompilerAdditions/")
+include(WSTP)
+include_directories("${WOLFRAM_PATH}/SystemFiles/IncludeFiles/C/")
+link_directories("${WOLFRAM_PATH}/SystemFiles/Libraries/Linux-x86-64/")
+
+add_library(usearchWFM SHARED lib.cpp)
+
+# Link against the Wolfram LibraryLink library
+target_link_libraries(usearchWFM WSTP::STATIC_LIBRARY)
+
+# Set the output name of the library to be compatible with Wolfram Language
+set_target_properties(usearchWFM PROPERTIES PREFIX "" OUTPUT_NAME "usearchWFM")