usearch 0.1.9 → 0.1.10

package/python/bench.py

@@ -1,60 +1,13 @@
 import datetime
 import numpy as np
+import fire
+
+from usearchh.io import load_matrix
 
 import faiss
 import usearch
 
 
-print('Welcome to basic kANN benchmark!')
-
-
-def read_matrix(filename: str, start_row: int = 0, count_rows: int = None):
-    """
-    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
-        arr = np.fromfile(
-            f, count=rows * cols, dtype=dtype,
-            offset=start_row * scalar_size * cols)
-    return arr.reshape(rows, cols)
-
-
-print('Will read datasets!')
-xb = read_matrix('datasets/wiki_1M/base.1M.fbin')
-xq = read_matrix('datasets/wiki_1M/query.public.100K.fbin')
-
-d = 256  # vector size
-M = 16
-efSearch = 32  # number of entry points (neighbors) we use on each layer
-efConstruction = 128  # number of entry points used on each layer
-labels = np.arange(xb.shape[0], dtype=np.longlong)
-print('Will benchmark algorithms!')
-
-
 def measure(f) -> float:
     a = datetime.datetime.now()
     f()
@@ -64,29 +17,46 @@ def measure(f) -> float:
     return c.seconds
 
 
-def construct_both() -> tuple:
+def bench_faiss(index, vectors: np.array, queries: np.array, neighbors: np.array):
+    dt = measure(lambda: index.add(vectors))
+    print(f'- FAISS: {vectors.shape[0]/dt:.2f} vectors/s')
 
-    index_meta = faiss.IndexHNSWFlat(d, M)
-    index_meta.hnsw.efSearch = efSearch
-    index_meta.hnsw.efConstruction = efConstruction
-    dt_meta = measure(lambda: index_meta.add(xb))
 
-    index_unum = usearch.Index(
-        dim=d,
-        expansion_add=efConstruction,
-        expansion_search=efSearch,
-        connectivity=M,
-    )
-    assert len(index_unum) == 0
-    dt_unum = measure(lambda: index_unum.add(labels, xb))
-    assert len(index_unum) == xb.shape[0]
+def bench_usearch(index, vectors: np.array, queries: np.array, neighbors: np.array):
+    labels = np.arange(vectors.shape[0], dtype=np.longlong)
+    assert len(index) == 0
+    dt = measure(lambda: index.add(labels, vectors))
+    assert len(index) == vectors.shape[0]
+    print(f'- USearch: {vectors.shape[0]/dt:.2f} vectors/s')
+
+
+def main(
+    vectors: str,
+    queries: str,
+    neighbors: str,
+    connectivity: int = 16,
+    expansion_add: int = 128,
+    expansion_search: int = 64,
+):
 
-    return dt_meta, dt_unum
+    vectors_mat = load_matrix(vectors)
+    queries_mat = load_matrix(queries)
+    neighbors_mat = load_matrix(neighbors)
+    dim = vectors_mat.shape[1]
+
+    index = faiss.IndexHNSWFlat(dim, connectivity)
+    index.hnsw.efSearch = expansion_search
+    index.hnsw.efConstruction = expansion_add
+    bench_faiss(index, vectors_mat, queries_mat, neighbors_mat)
+
+    index = usearch.Index(
+        ndim=dim,
+        expansion_add=expansion_add,
+        expansion_search=expansion_search,
+        connectivity=connectivity,
+    )
+    bench_usearch(index, vectors_mat, queries_mat, neighbors_mat)
 
 
-experiments = 10
-durations = [construct_both() for _ in range(experiments)]
-dt_meta = sum(x[0] for x in durations)
-dt_unum = sum(x[1] for x in durations)
-print(f'- FAISS vectors per second: {xb.shape[0]*experiments/dt_meta:.2f}')
-print(f'- USearch vectors per second: {xb.shape[0]*experiments/dt_unum:.2f}')
+if __name__ == '__main__':
+    fire.Fire(main)

package/python/lib.cpp

@@ -36,7 +36,8 @@ static native_index_t make_index(   //
     std::string const& metric,      //
     std::size_t connectivity,       //
     std::size_t expansion_add,      //
-    std::size_t expansion_search    //
+    std::size_t expansion_search,   //
+    std::size_t metric_uintptr      //
 ) {
 
     config_t config;
@@ -48,7 +49,11 @@ static native_index_t make_index(   //
     config.max_threads_search = std::thread::hardware_concurrency();
 
     accuracy_t accuracy = accuracy_from_name(scalar_type.c_str(), scalar_type.size());
-    return index_from_name<native_index_t>(metric.c_str(), metric.size(), dimensions, accuracy, config);
+    punned_metric_t metric_ptr = reinterpret_cast<punned_metric_t>(metric_uintptr);
+    if (metric_ptr)
+        return native_index_t::udf(dimensions, metric_ptr, accuracy, config);
+    else
+        return index_from_name<native_index_t>(metric.c_str(), metric.size(), dimensions, accuracy, config);
 }
 
 static void add_to_index(native_index_t& index, py::buffer labels, py::buffer vectors, bool copy) {
@@ -173,15 +178,16 @@ PYBIND11_MODULE(usearch, m) {
 
     auto i = py::class_<native_index_t>(m, "Index");
 
-    i.def(py::init(&make_index),                                             //
-          py::kw_only(),                                                     //
-          py::arg("dim"),                                                    //
-          py::arg("capacity") = 0,                                           //
-          py::arg("dtype") = std::string("f32"),                             //
-          py::arg("metric") = std::string("ip"),                             //
-          py::arg("connectivity") = config_t::connectivity_default_k,        //
-          py::arg("expansion_add") = config_t::expansion_add_default_k,      //
-          py::arg("expansion_search") = config_t::expansion_search_default_k //
+    i.def(py::init(&make_index),                                              //
+          py::kw_only(),                                                      //
+          py::arg("ndim"),                                                    //
+          py::arg("capacity") = 0,                                            //
+          py::arg("dtype") = std::string("f32"),                              //
+          py::arg("metric") = std::string("ip"),                              //
+          py::arg("connectivity") = config_t::connectivity_default_k,         //
+          py::arg("expansion_add") = config_t::expansion_add_default_k,       //
+          py::arg("expansion_search") = config_t::expansion_search_default_k, //
+          py::arg("metric_pointer") = 0                                       //
     );
 
     i.def(                     //

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

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,7 +158,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;
@@ -282,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 {
@@ -362,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;
 
@@ -456,6 +509,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 +534,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 +558,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};