usearch 0.2.3 → 0.2.4

package/python/bench.py

@@ -12,30 +12,50 @@ from usearch.io import load_matrix
 
 def measure(f) -> float:
     a = time.time_ns()
-    f()
+    result = f()
     b = time.time_ns()
     c = b - a
     secs = c / (10 ** 9)
     print(f'- Took: {secs:.2f} seconds')
-    return secs
+    return secs, result
 
 
 def bench_faiss(index, vectors: np.array, queries: np.array, neighbors: np.array):
-    dt = measure(lambda: index.add(vectors))
-    print(f'- Performance: {vectors.shape[0]/dt:.2f} vectors/s')
+    dt, _ = measure(lambda: index.add(vectors))
+    print(f'- Performance: {vectors.shape[0]/dt:.2f} insertions/s')
+
+    dt, results = measure(lambda: index.search(queries, neighbors.shape[1]))
+    print(f'- Performance: {queries.shape[0]/dt:.2f} queries/s')
+
+    recall_at_one = 0.0
+    matches = results[1]
+    for i in range(queries.shape[0]):
+        recall_at_one += neighbors[i, 0] in matches[i, :]
+    recall_at_one /= queries.shape[0]
+    print(f'- Recall@1: {recall_at_one * 100:.2f} %')
 
 
 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))
+    dt, _ = measure(lambda: index.add(labels, vectors))
     assert len(index) == vectors.shape[0]
-    print(f'- Performance: {vectors.shape[0]/dt:.2f} vectors/s')
+    print(f'- Performance: {vectors.shape[0]/dt:.2f} insertions/s')
+
+    dt, results = measure(lambda: index.search(queries, neighbors.shape[1]))
+    print(f'- Performance: {queries.shape[0]/dt:.2f} queries/s')
 
+    recall_at_one = 0.0
+    matches = results[0]
+    for i in range(queries.shape[0]):
+        recall_at_one += neighbors[i, 0] in matches[i, :]
+    recall_at_one /= queries.shape[0]
+    print(f'- Recall@1: {recall_at_one * 100:.2f} %')
 
 # 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_f32 = types.float32(
     types.CPointer(types.float32),
     types.CPointer(types.float32),
@@ -85,7 +105,7 @@ def main(
     )
     bench_usearch(index, vectors_mat, queries_mat, neighbors_mat)
 
-    print('USearch: HNSW + Numba JIT + Half Precision')
+    print('USearch: HNSW + Half Precision')
     index = Index(
         ndim=dim,
         dtype='f16',
@@ -95,6 +115,16 @@ def main(
     )
     bench_usearch(index, vectors_mat, queries_mat, neighbors_mat)
 
+    print('USearch: HNSW + Quarter Precision')
+    index = Index(
+        ndim=dim,
+        dtype='f8',
+        expansion_add=expansion_add,
+        expansion_search=expansion_search,
+        connectivity=connectivity,
+    )
+    bench_usearch(index, vectors_mat, queries_mat, neighbors_mat)
+
     print('FAISS: HNSW')
     index = IndexHNSWFlat(dim, connectivity)
     index.hnsw.efSearch = expansion_search

package/python/lib.cpp

@@ -145,9 +145,9 @@ static void add_one_to_index(native_index_t& index, label_t label, py::buffer ve
     if (vector_info.ndim != 1)
         throw std::invalid_argument("Expects a vector, not a higher-rank tensor!");
 
-    ssize_t vector_dimensions = vector_info.shape[0];
+    Py_ssize_t vector_dimensions = vector_info.shape[0];
     char const* vector_data = reinterpret_cast<char const*>(vector_info.ptr);
-    if (vector_dimensions != static_cast<ssize_t>(index.dimensions()))
+    if (vector_dimensions != static_cast<Py_ssize_t>(index.dimensions()))
         throw std::invalid_argument("The number of vector dimensions doesn't match!");
 
     if (index.size() + 1 >= index.capacity())
@@ -180,10 +180,10 @@ static void add_many_to_index(                                    //
     if (vectors_info.ndim != 2)
         throw std::invalid_argument("Expects a matrix of vectors to add!");
 
-    ssize_t labels_count = labels_info.shape[0];
-    ssize_t vectors_count = vectors_info.shape[0];
-    ssize_t vectors_dimensions = vectors_info.shape[1];
-    if (vectors_dimensions != static_cast<ssize_t>(index.dimensions()))
+    Py_ssize_t labels_count = labels_info.shape[0];
+    Py_ssize_t vectors_count = vectors_info.shape[0];
+    Py_ssize_t vectors_dimensions = vectors_info.shape[1];
+    if (vectors_dimensions != static_cast<Py_ssize_t>(index.dimensions()))
         throw std::invalid_argument("The number of vector dimensions doesn't match!");
 
     if (labels_count != vectors_count)
@@ -222,13 +222,13 @@ static void add_many_to_index(                                    //
 static py::tuple search_one_in_index(native_index_t& index, py::buffer vector, std::size_t wanted) {
 
     py::buffer_info vector_info = vector.request();
-    ssize_t vector_dimensions = vector_info.shape[0];
+    Py_ssize_t vector_dimensions = vector_info.shape[0];
     char const* vector_data = reinterpret_cast<char const*>(vector_info.ptr);
-    if (vector_dimensions != static_cast<ssize_t>(index.dimensions()))
+    if (vector_dimensions != static_cast<Py_ssize_t>(index.dimensions()))
         throw std::invalid_argument("The number of vector dimensions doesn't match!");
 
-    py::array_t<label_t> labels_py(static_cast<ssize_t>(wanted));
-    py::array_t<distance_t> distances_py(static_cast<ssize_t>(wanted));
+    py::array_t<label_t> labels_py(static_cast<Py_ssize_t>(wanted));
+    py::array_t<distance_t> distances_py(static_cast<Py_ssize_t>(wanted));
     std::size_t count{};
     auto labels_py1d = labels_py.mutable_unchecked<1>();
     auto distances_py1d = distances_py.mutable_unchecked<1>();
@@ -246,8 +246,8 @@ static py::tuple search_one_in_index(native_index_t& index, py::buffer vector, s
     else
         throw std::invalid_argument("Incompatible scalars in the query vector!");
 
-    labels_py.resize(py_shape_t{static_cast<ssize_t>(count)});
-    distances_py.resize(py_shape_t{static_cast<ssize_t>(count)});
+    labels_py.resize(py_shape_t{static_cast<Py_ssize_t>(count)});
+    distances_py.resize(py_shape_t{static_cast<Py_ssize_t>(count)});
 
     py::tuple results(3);
     results[0] = labels_py;
@@ -276,14 +276,14 @@ static py::tuple search_many_in_index(native_index_t& index, py::buffer vectors,
     if (vectors_info.ndim != 2)
         throw std::invalid_argument("Expects a matrix of vectors to add!");
 
-    ssize_t vectors_count = vectors_info.shape[0];
-    ssize_t vectors_dimensions = vectors_info.shape[1];
+    Py_ssize_t vectors_count = vectors_info.shape[0];
+    Py_ssize_t vectors_dimensions = vectors_info.shape[1];
     char const* vectors_data = reinterpret_cast<char const*>(vectors_info.ptr);
-    if (vectors_dimensions != static_cast<ssize_t>(index.dimensions()))
+    if (vectors_dimensions != static_cast<Py_ssize_t>(index.dimensions()))
         throw std::invalid_argument("The number of vector dimensions doesn't match!");
 
-    py::array_t<label_t> labels_py({vectors_count, static_cast<ssize_t>(wanted)});
-    py::array_t<distance_t> distances_py({vectors_count, static_cast<ssize_t>(wanted)});
+    py::array_t<label_t> labels_py({vectors_count, static_cast<Py_ssize_t>(wanted)});
+    py::array_t<distance_t> distances_py({vectors_count, static_cast<Py_ssize_t>(wanted)});
     py::array_t<Py_ssize_t> counts_py(vectors_count);
     auto labels_py2d = labels_py.mutable_unchecked<2>();
     auto distances_py2d = distances_py.mutable_unchecked<2>();
@@ -364,8 +364,8 @@ inline std::uint64_t hash(std::uint64_t v) noexcept {
 template <typename scalar_at>
 inline void hash_typed_buffer(hash_index_w_meta_t& index, py::buffer_info const& vector_info) noexcept {
     char const* vector_data = reinterpret_cast<char const*>(vector_info.ptr);
-    ssize_t vector_dimensions = vector_info.shape[0];
-    ssize_t vector_stride = vector_info.strides[0];
+    Py_ssize_t vector_dimensions = vector_info.shape[0];
+    Py_ssize_t vector_stride = vector_info.strides[0];
     std::memset(index.buffer_.data(), 0, index.words_ * sizeof(hash_word_t));
 
     for (std::size_t i = 0; i != static_cast<std::size_t>(vector_dimensions); ++i) {
@@ -477,10 +477,10 @@ PYBIND11_MODULE(index, m) {
             validate_set(set);
             auto proxy = set.unchecked<1>();
             auto view = set_view_t{proxy.data(0), static_cast<std::size_t>(proxy.shape(0))};
-            auto labels_py = py::array_t<label_t>(py_shape_t{static_cast<ssize_t>(count)});
+            auto labels_py = py::array_t<label_t>(py_shape_t{static_cast<Py_ssize_t>(count)});
             auto labels_proxy = labels_py.mutable_unchecked<1>();
             auto found = index.search(view, count, &labels_proxy(0), nullptr, 0);
-            labels_py.resize(py_shape_t{static_cast<ssize_t>(found)});
+            labels_py.resize(py_shape_t{static_cast<Py_ssize_t>(found)});
             return labels_py;
         },
         py::arg("set"),       //
@@ -527,10 +527,10 @@ PYBIND11_MODULE(index, m) {
             if (index.size() + 1 >= index.capacity())
                 index.reserve(ceil2(index.size() + 1));
             hash_buffer(index, array);
-            auto labels_py = py::array_t<label_t>(py_shape_t{static_cast<ssize_t>(count)});
+            auto labels_py = py::array_t<label_t>(py_shape_t{static_cast<Py_ssize_t>(count)});
             auto labels_proxy = labels_py.mutable_unchecked<1>();
             auto found = index.search(index.buffer(), count, &labels_proxy(0), nullptr, 0);
-            labels_py.resize(py_shape_t{static_cast<ssize_t>(found)});
+            labels_py.resize(py_shape_t{static_cast<Py_ssize_t>(found)});
             return labels_py;
         },
         py::arg("array"),     //

package/python/test.py

@@ -1,51 +1,93 @@
+import pytest
 import numpy as np
 
+
 from usearch.index import Index, SetsIndex
-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
+dimensions = [13, 99, 100, 256]
+sizes = [1, 2, 100]
+types = ['f32', 'f16', 'f8', 'f64']
+
+
+@pytest.mark.parametrize('ndim', dimensions)
+@pytest.mark.parametrize('dtype', types)
+def test_cos(ndim: int, dtype: str):
+    index = Index(ndim=ndim, metric='cos', dtype=dtype)
+    vector = np.random.uniform(0, 0.7, (index.ndim)).astype(np.float32)
+    index.add(42, vector)
+    matches, distances, count = index.search(vector, 10)
+
+    assert len(matches) == count
+    assert len(distances) == count
+    assert count == 1
+    assert matches[0] == 42
+    assert distances[0] == pytest.approx(0, abs=1e-3)
+
+
+@pytest.mark.parametrize('ndim', dimensions)
+@pytest.mark.parametrize('size', sizes)
+@pytest.mark.parametrize('dtype', types)
+def test_cos_batch(ndim: int, size: int, dtype: str):
+    index = Index(ndim=ndim, metric='cos', dtype=dtype)
+
+    vectors = np.random.uniform(
+        0, 0.3, (size, index.ndim)).astype(np.float32)
+    labels = np.array(range(size), dtype=np.longlong)
+
+    index.add(labels, vectors)
+    matches, distances, count = index.search(vectors, 10)
+
+    assert matches.shape[0] == distances.shape[0]
+    assert count.shape[0] == size
+
+
+@pytest.mark.parametrize('ndim', dimensions)
+@pytest.mark.parametrize('size', sizes)
+def test_user_defined_function(ndim: int, size: int):
+
+    try:
+        from numba import cfunc, types, carray
+    except ImportError:
+        return
+
+    # 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)
 
-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 = Index(ndim=ndim, metric_pointer=python_dot.address)
 
-@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
+    vectors = np.random.uniform(
+        0, 0.3, (size, index.ndim)).astype(np.float32)
+    labels = np.array(range(size), dtype=np.longlong)
 
+    index.add(labels, vectors)
+    matches, distances, count = index.search(vectors, 10)
 
-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)
+    assert matches.shape[0] == distances.shape[0]
+    assert count.shape[0] == size
 
-index_udf = 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)
 
+def test_sets():
 
-index = Index(ndim=96)
-index.add(labels, vectors, copy=True)
-assert index.ndim == count_dimensions
-assert index.capacity >= count_vectors
-assert len(index) == count_vectors
+    index = SetsIndex()
+    index.add(10, np.array([10, 12, 15], dtype=np.uint32))
+    index.add(11, np.array([11, 12, 15, 16], dtype=np.uint32))
+    results = index.search(np.array([12, 15], dtype=np.uint32), 20)
 
-results = index.search(vectors, 10)
-print('found', results[0].shape, results[1].shape, results[2].shape)
+    # assert list(results) == [10, 11]
 
 
-index_sets = 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)
+if __name__ == '__main__':
+    pass

package/simsimd/include/simsimd/simsimd.h

@@ -56,30 +56,6 @@ inline static simsimd_f32_t simsimd_dot_f32sve(simsimd_f32_t const* a, simsimd_f
 #endif
 }
 
-inline static simsimd_f16_t simsimd_dot_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 ab_vec = svdupq_n_f16(0, 0, 0, 0, 0, 0, 0, 0);
-    svbool_t pg_vec = svwhilelt_b16(i, d);
-    simsimd_f16_t const* a = (simsimd_f16_t const*)(a_enum);
-    simsimd_f16_t const* b = (simsimd_f16_t const*)(b_enum);
-    do {
-        svfloat16_t a_vec = svld1_f16(pg_vec, (float16_t const*)a + i);
-        svfloat16_t b_vec = svld1_f16(pg_vec, (float16_t const*)b + i);
-        ab_vec = svmla_f16_x(pg_vec, ab_vec, a_vec, b_vec);
-        i += svcnth();
-        pg_vec = svwhilelt_b16(i, d);
-    } while (svptest_any(svptrue_b16(), pg_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;
-#endif
-}
-
 inline static simsimd_f32_t simsimd_cos_f32sve(simsimd_f32_t const* a, simsimd_f32_t const* b, size_t d) {
 #if defined(__ARM_FEATURE_SVE)
     size_t i = 0;
@@ -176,7 +152,7 @@ inline static simsimd_f32_t simsimd_dot_f32x4neon(simsimd_f32_t const* a, simsim
 #if defined(__ARM_NEON)
     float32x4_t ab_vec = vdupq_n_f32(0);
     for (size_t i = 0; i != d; i += 4)
-        ab_vec = vmlaq_f32(ab_vec, vld1q_f32(a + i), vld1q_f32(b + i));
+        ab_vec = vfmaq_f32(ab_vec, vld1q_f32(a + i), vld1q_f32(b + i));
     return vaddvq_f32(ab_vec);
 #else
     (void)a, (void)b, (void)d;
@@ -184,16 +160,23 @@ inline static simsimd_f32_t simsimd_dot_f32x4neon(simsimd_f32_t const* a, simsim
 #endif
 }
 
-inline static simsimd_f16_t simsimd_dot_f16x8neon(simsimd_f16_t const* a, simsimd_f16_t const* b, size_t d) {
+inline static simsimd_f32_t simsimd_cos_f16x4neon(simsimd_f16_t const* a, simsimd_f16_t const* b, size_t d) {
 #if defined(__ARM_NEON)
-    // There is no half-precision FMA, only bfloat16, so we must manually multiply and add.
-    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)));
-    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;
+    float32x4_t ab_vec = vdupq_n_f32(0);
+    float32x4_t a2_vec = vdupq_n_f32(0);
+    float32x4_t b2_vec = vdupq_n_f32(0);
+    for (size_t i = 0; i != d; i += 4) {
+        float32x4_t a_vec = vcvt_f32_f16(vld1_f16((float16_t const*)a + i));
+        float32x4_t b_vec = vcvt_f32_f16(vld1_f16((float16_t const*)b + i));
+        // vfmaq_f32(a, b, c) == vaddq_f32(vmulq_f32(b, c), a)
+        ab_vec = vfmaq_f32(ab_vec, a_vec, b_vec);
+        a2_vec = vfmaq_f32(a2_vec, a_vec, a_vec);
+        b2_vec = vfmaq_f32(b2_vec, b_vec, b_vec);
+    }
+    simsimd_f32_t ab = vaddvq_f32(ab_vec);
+    simsimd_f32_t a2 = vaddvq_f32(a2_vec);
+    simsimd_f32_t b2 = vaddvq_f32(b2_vec);
+    return ab / (sqrt(a2) * sqrt(b2));
 #else
     (void)a, (void)b, (void)d;
     return 0;
@@ -255,15 +238,22 @@ inline static simsimd_f32_t simsimd_dot_f32x4avx2(simsimd_f32_t const* a, simsim
 #endif
 }
 
-inline static simsimd_f32_t simsimd_dot_f16x16avx512(simsimd_f16_t const* a, simsimd_f16_t const* b, size_t d) {
+inline static simsimd_f32_t simsimd_cos_f16x16avx512(simsimd_f16_t const* a, simsimd_f16_t const* b, size_t d) {
 #if defined(__AVX512F__)
     __m512 ab_vec = _mm512_set1_ps(0);
-    for (size_t i = 0; i != d; i += 16)
-        ab_vec = _mm512_fmadd_ps(                     //
-            _mm512_cvtxph_ps(_mm256_loadu_ph(a + i)), //
-            _mm512_cvtxph_ps(_mm256_loadu_ph(b + i)), //
-            ab_vec);
-    return _mm512_reduce_add_ps(ab_vec);
+    __m512 a2_vec = _mm512_set1_ps(0);
+    __m512 b2_vec = _mm512_set1_ps(0);
+    for (size_t i = 0; i != d; i += 16) {
+        __m512 a_vec = _mm512_cvtxph_ps(_mm256_loadu_ph(a + i));
+        __m512 b_vec = _mm512_cvtxph_ps(_mm256_loadu_ph(b + i));
+        ab_vec = _mm512_fmadd_ps(a_vec, b_vec, ab_vec);
+        a2_vec = _mm512_fmadd_ps(a_vec, a_vec, a2_vec);
+        b2_vec = _mm512_fmadd_ps(b_vec, b_vec, b2_vec);
+    }
+    simsimd_f32_t ab = _mm512_reduce_add_ps(ab_vec);
+    simsimd_f32_t a2 = _mm512_reduce_add_ps(a2_vec);
+    simsimd_f32_t b2 = _mm512_reduce_add_ps(b2_vec);
+    return ab / (sqrt(a2) * sqrt(b2));
 #else
     (void)a, (void)b, (void)d;
     return 0;

package/src/advanced.hpp

@@ -174,6 +174,29 @@ class f8_bits_t {
 
 inline f16_bits_t::f16_bits_t(f8_bits_t v) noexcept : f16_bits_t(float(v)) {}
 
+struct cos_f8_t {
+    punned_distance_t operator()(f8_bits_t const* a, f8_bits_t const* b, std::size_t n) const noexcept {
+        std::int32_t ab{}, a2{}, b2{};
+        for (std::size_t i = 0; i != n; i++) {
+            std::int16_t ai{a[i]};
+            std::int16_t bi{b[i]};
+            ab += ai * bi;
+            a2 += square(ai);
+            b2 += square(bi);
+        }
+        return 1.f - ab / (std::sqrt(a2) * std::sqrt(b2));
+    }
+};
+
+struct l2sq_f8_t {
+    punned_distance_t operator()(f8_bits_t const* a, f8_bits_t const* b, std::size_t n) const noexcept {
+        std::int32_t ab_deltas_sq{};
+        for (std::size_t i = 0; i != n; i++)
+            ab_deltas_sq += square(std::int16_t(a[i]) - std::int16_t(b[i]));
+        return ab_deltas_sq;
+    }
+};
+
 struct uuid_t {
     std::uint8_t octets[16];
 };
@@ -495,7 +518,11 @@ class auto_index_gt {
 
   private:
     static index_t* aligned_index_alloc() noexcept {
+#if defined(WINDOWS)
+        return (index_t*)_aligned_malloc(64, 64 * divide_round_up<64>(sizeof(index_t)));
+#else
         return (index_t*)aligned_alloc(64, 64 * divide_round_up<64>(sizeof(index_t)));
+#endif
     }
 
     static void aligned_index_free(index_t* raw) noexcept { free(raw); }
@@ -652,43 +679,40 @@ class auto_index_gt {
         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) {
+    static metric_and_meta_t cos_metric_f16(std::size_t dimensions) {
         (void)dimensions;
 #if defined(USEARCH_USE_SIMD)
 #if defined(__x86_64__)
-        if (dimensions % 32 == 0)
+        if (dimensions % 16 == 0)
             return {
                 pun_metric<simsimd_f16_t>([](simsimd_f16_t const* a, simsimd_f16_t const* b, size_t d) noexcept {
-                    return 1.f - simsimd_dot_f16x16avx512(a, b, d);
+                    return 1.f - simsimd_cos_f16x16avx512(a, b, d);
                 }),
                 isa_t::avx512_k,
             };
 #elif defined(__aarch64__)
-        if (supports_arm_sve())
-            return {
-                pun_metric<simsimd_f16_t>([](simsimd_f16_t const* a, simsimd_f16_t const* b, size_t d) noexcept {
-                    return 1.f - simsimd_dot_f16sve(a, b, d);
-                }),
-                isa_t::sve_k,
-            };
-        if (dimensions % 8 == 0)
+        if (dimensions % 4 == 0)
             return {
                 pun_metric<simsimd_f16_t>([](simsimd_f16_t const* a, simsimd_f16_t const* b, size_t d) noexcept {
-                    return 1.f - simsimd_dot_f16x8neon(a, b, d);
+                    return 1.f - simsimd_cos_f16x4neon(a, b, d);
                 }),
                 isa_t::neon_k,
             };
 #endif
 #endif
-        return {pun_metric<f16_bits_t>(ip_gt<f16_bits_t, f32_t>{}), isa_t::auto_k};
+        return {pun_metric<f16_bits_t>(cos_gt<f16_bits_t, f32_t>{}), isa_t::auto_k};
     }
 
     static metric_and_meta_t ip_metric(std::size_t dimensions, accuracy_t accuracy) {
         switch (accuracy) {
-            // The tow most common numeric types for the most common metric have  afew optimized versions:
-        case accuracy_t::f16_k: return ip_metric_f16(dimensions);
-        case accuracy_t::f32_k: return ip_metric_f32(dimensions);
-        case accuracy_t::f8_k: return {pun_metric<f8_bits_t>(ip_gt<f8_bits_t, f32_t>{}), isa_t::auto_k};
+        case accuracy_t::f32_k:
+            // The two most common numeric types for the most common metric have optimized versions
+            return ip_metric_f32(dimensions);
+        case accuracy_t::f16_k:
+            // Dot-product accumulates error, Cosine-distance normalizes it
+            return cos_metric_f16(dimensions);
+
+        case accuracy_t::f8_k: return {pun_metric<f8_bits_t>(cos_f8_t{}), isa_t::auto_k};
         case accuracy_t::f64_k: return {pun_metric<f64_t>(ip_gt<f64_t>{}), isa_t::auto_k};
         default: return {};
         }
@@ -696,7 +720,7 @@ class auto_index_gt {
 
     static metric_and_meta_t l2_metric(std::size_t, accuracy_t accuracy) {
         switch (accuracy) {
-        case accuracy_t::f8_k: return {pun_metric<f8_bits_t>(l2sq_gt<f8_bits_t, f32_t>{}), isa_t::auto_k};
+        case accuracy_t::f8_k: return {pun_metric<f8_bits_t>(l2sq_f8_t{}), isa_t::auto_k};
         case accuracy_t::f16_k: return {pun_metric<f16_bits_t>(l2sq_gt<f16_bits_t, f32_t>{}), isa_t::auto_k};
         case accuracy_t::f32_k: return {pun_metric<f32_t>(l2sq_gt<f32_t>{}), isa_t::auto_k};
         case accuracy_t::f64_k: return {pun_metric<f64_t>(l2sq_gt<f64_t>{}), isa_t::auto_k};
@@ -704,10 +728,10 @@ class auto_index_gt {
         }
     }
 
-    static metric_and_meta_t cos_metric(std::size_t, accuracy_t accuracy) {
+    static metric_and_meta_t cos_metric(std::size_t dimensions, accuracy_t accuracy) {
         switch (accuracy) {
-        case accuracy_t::f8_k: return {pun_metric<f8_bits_t>(cos_gt<f8_bits_t, f32_t>{}), isa_t::auto_k};
-        case accuracy_t::f16_k: return {pun_metric<f16_bits_t>(cos_gt<f16_bits_t, f32_t>{}), isa_t::auto_k};
+        case accuracy_t::f8_k: return {pun_metric<f8_bits_t>(cos_f8_t{}), isa_t::auto_k};
+        case accuracy_t::f16_k: return cos_metric_f16(dimensions);
         case accuracy_t::f32_k: return {pun_metric<f32_t>(cos_gt<f32_t>{}), isa_t::auto_k};
         case accuracy_t::f64_k: return {pun_metric<f64_t>(cos_gt<f64_t>{}), isa_t::auto_k};
         default: return {};

package/src/bench.cpp

@@ -400,7 +400,7 @@ struct args_t {
     bool quantize_f16 = false;
     bool quantize_f8 = false;
 
-    bool metric_ip = true;
+    bool metric_ip = false;
     bool metric_l2 = false;
     bool metric_cos = false;
     bool metric_haversine = false;
@@ -408,23 +408,19 @@ struct args_t {
 
 template <typename index_at, typename dataset_at> //
 index_at type_punned_index_for_metric(dataset_at& dataset, args_t const& args, config_t config, accuracy_t accuracy) {
-    if (args.metric_ip) {
-        std::printf("-- Metric: Inner Product\n");
-        return index_at::ip(dataset.dimensions(), accuracy, config);
-    }
     if (args.metric_l2) {
         std::printf("-- Metric: Euclidean\n");
         return index_at::l2(dataset.dimensions(), accuracy, config);
-    }
-    if (args.metric_cos) {
+    } else if (args.metric_cos) {
         std::printf("-- Metric: Angular\n");
         return index_at::cos(dataset.dimensions(), accuracy, config);
-    }
-    if (args.metric_haversine) {
+    } else if (args.metric_haversine) {
         std::printf("-- Metric: Haversine\n");
         return index_at::haversine(accuracy, config);
+    } else {
+        std::printf("-- Metric: Inner Product\n");
+        return index_at::ip(dataset.dimensions(), accuracy, config);
     }
-    throw std::invalid_argument("Unknown metric!");
 }
 
 template <typename index_at, typename dataset_at> //
@@ -472,16 +468,16 @@ template <typename neighbor_id_at, typename dataset_at> //
 void run_big_or_small(dataset_at& dataset, args_t const& args, config_t config) {
     if (args.native) {
         if (args.metric_cos) {
-            std::printf("-- Metric: Inner Product\n");
-            run_typed<index_gt<ip_gt<float>, std::size_t, neighbor_id_at>>(dataset, args, config);
+            std::printf("-- Metric: Angular\n");
+            run_typed<index_gt<cos_gt<float>, std::size_t, neighbor_id_at>>(dataset, args, config);
         } else if (args.metric_l2) {
             std::printf("-- Metric: Euclidean\n");
             run_typed<index_gt<l2sq_gt<float>, std::size_t, neighbor_id_at>>(dataset, args, config);
         } else if (args.metric_haversine) {
-            std::printf("-- Metric: Angular\n");
+            std::printf("-- Metric: Haversine\n");
             run_typed<index_gt<haversine_gt<float>, std::size_t, neighbor_id_at>>(dataset, args, config);
         } else {
-            std::printf("-- Metric: Haversine\n");
+            std::printf("-- Metric: Inner Product\n");
             run_typed<index_gt<ip_gt<float>, std::size_t, neighbor_id_at>>(dataset, args, config);
         }
     } else