usearch 0.1.9 → 0.2.0

package/python/test.py

@@ -2,14 +2,40 @@ import numpy as np
 
 import usearch
 
+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
+
+
 count_vectors = 100
 count_dimensions = 96
-
-index = usearch.Index(dim=96)
 vectors = np.random.uniform(
     0, 0.3, (count_vectors, count_dimensions)).astype(np.float32)
 labels = np.array(range(count_vectors), dtype=np.longlong)
 
+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
@@ -17,3 +43,10 @@ assert len(index) == count_vectors
 
 results = index.search(vectors, 10)
 print('found', results[0].shape, results[1].shape, results[2].shape)
+
+
+index_sets = usearch.SetsIndex()
+index_sets.add(10, np.array([10, 12, 15], dtype=np.uint32))
+index_sets.add(11, np.array([11, 12, 15, 16], dtype=np.uint32))
+results = index_sets.search(np.array([12, 15], dtype=np.uint32), 20)
+print(results)

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

@@ -1,5 +1,6 @@
 #pragma once
 #include <functional>
+#include <stdexcept> // `std::invalid_argument`
 #include <thread>
 #include <vector>
 
@@ -7,8 +8,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 +46,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 +77,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 +97,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 +130,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,7 +159,7 @@ 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 = tasks / threads + (tasks % threads) != 0;
+    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_idx * tasks_per_thread;
@@ -198,7 +230,7 @@ inline accuracy_t accuracy_from_name(char const* name, std::size_t len) {
     else if (str_equals(name, len, "i8q100"))
         accuracy = accuracy_t::i8q100_k;
     else
-        throw std::runtime_error("Unknown type, choose: f32, f16, f64, i8q100");
+        throw std::invalid_argument("Unknown type, choose: f32, f16, f64, i8q100");
     return accuracy;
 }
 
@@ -206,16 +238,24 @@ template <typename index_at>
 inline index_at index_from_name( //
     char const* name, std::size_t len, std::size_t dimensions, accuracy_t accuracy, config_t const& config) {
 
-    if (str_equals(name, len, "l2_sq") || str_equals(name, len, "euclidean_sq"))
+    if (str_equals(name, len, "l2_sq") || str_equals(name, len, "euclidean_sq")) {
+        if (dimensions == 0)
+            throw std::invalid_argument("The number of dimensions must be positive");
         return index_at::l2(dimensions, accuracy, config);
-    else if (str_equals(name, len, "ip") || str_equals(name, len, "inner") || str_equals(name, len, "dot"))
+    } else if (str_equals(name, len, "ip") || str_equals(name, len, "inner") || str_equals(name, len, "dot")) {
+        if (dimensions == 0)
+            throw std::invalid_argument("The number of dimensions must be positive");
         return index_at::ip(dimensions, accuracy, config);
-    else if (str_equals(name, len, "cos") || str_equals(name, len, "angular"))
+    } else if (str_equals(name, len, "cos") || str_equals(name, len, "angular")) {
+        if (dimensions == 0)
+            throw std::invalid_argument("The number of dimensions must be positive");
         return index_at::cos(dimensions, accuracy, config);
-    else if (str_equals(name, len, "haversine"))
+    } else if (str_equals(name, len, "haversine")) {
+        if (dimensions != 2 && dimensions != 0)
+            throw std::invalid_argument("The number of dimensions must be equal to two");
         return index_at::haversine(accuracy, config);
-    else
-        throw std::runtime_error("Unknown distance, choose: l2_sq, ip, cos, hamming, jaccard");
+    } else
+        throw std::invalid_argument("Unknown distance, choose: l2_sq, ip, cos, hamming, jaccard");
     return {};
 }
 
@@ -282,9 +322,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 {
@@ -336,6 +392,7 @@ class auto_index_gt {
     std::size_t connectivity() const noexcept { return index_->connectivity(); }
     std::size_t size() const noexcept { return index_->size(); }
     std::size_t capacity() const noexcept { return index_->capacity(); }
+    void clear() noexcept { return index_->clear(); }
 
     isa_t acceleration() const noexcept { return acceleration_; }
     std::size_t concurrency() const noexcept {
@@ -362,6 +419,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;
 
@@ -456,6 +519,8 @@ class auto_index_gt {
     }
 
     static metric_and_meta_t ip_metric_f32(std::size_t dimensions) {
+        (void)dimensions;
+#if defined(USEARCH_USE_SIMD)
 #if defined(__x86_64__)
         if (dimensions % 4 == 0)
             return {
@@ -479,11 +544,14 @@ class auto_index_gt {
                 }),
                 isa_t::neon_k,
             };
+#endif
 #endif
         return {pun_metric<f32_t>(ip_gt<f32_t>{}), isa_t::auto_k};
     }
 
     static metric_and_meta_t ip_metric_f16(std::size_t dimensions) {
+        (void)dimensions;
+#if defined(USEARCH_USE_SIMD)
 #if defined(__x86_64__)
 #elif defined(__aarch64__)
         if (supports_arm_sve())
@@ -500,13 +568,14 @@ class auto_index_gt {
                 }),
                 isa_t::neon_k,
             };
+#endif
 #endif
         return {pun_metric<f16_converted_t>(ip_gt<f16_converted_t>{}), isa_t::auto_k};
     }
 
     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;
@@ -344,6 +346,46 @@ 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_alternative_setups() {
+    using set_member_t = std::uint32_t;
+    using sets_index_t = index_gt<jaccard_gt<set_member_t>, std::size_t, std::uint32_t, set_member_t>;
+    set_member_t set_a[] = {10, 12, 15};
+    set_member_t set_b[] = {11, 12, 15, 16};
+    sets_index_t index;
+    index.reserve(100);
+    index.add(10, span_gt<set_member_t const>{&set_a[0], 3});
+    index.add(11, span_gt<set_member_t const>{&set_b[0], 4});
+    exit(0);
+}
+
+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.
@@ -393,8 +435,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(),
@@ -405,6 +445,9 @@ int main(int argc, char** argv) {
     std::printf("-- Queries count: %zu\n", dataset.queries_count());
     std::printf("-- Neighbors per query: %zu\n", dataset.neighborhood_size());
 
+    report_alternative_setups();
+    report_expected_losses(dataset);
+
     config_t config;
     config.connectivity = args.connectivity;
     config.expansion_add = args.expansion_add;

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")