usearch 0.2.3 → 0.4.0

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/rust/lib.cpp

@@ -9,7 +9,9 @@ using native_index_t = typename Index::native_index_t;
 Index::Index(std::shared_ptr<native_index_t> index) : index_(index) {}
 
 void Index::add_in_thread(uint32_t label, rust::Slice<float const> vector, size_t thread) const {
-    index_->add(label, vector.data(), thread, true);
+    add_config_t config;
+    config.thread = thread;
+    index_->add(label, vector.data(), config);
 }
 
 Matches Index::search_in_thread(rust::Slice<float const> vector, size_t count, size_t thread) const {
@@ -18,7 +20,9 @@ Matches Index::search_in_thread(rust::Slice<float const> vector, size_t count, s
     results.distances.reserve(count);
     for (size_t i = 0; i != count; ++i)
         results.labels.push_back(0), results.distances.push_back(0);
-    results.count = index_->search(vector.data(), count, results.labels.data(), results.distances.data(), thread);
+    search_config_t config;
+    config.thread = thread;
+    results.count = index_->search(vector.data(), count, results.labels.data(), results.distances.data(), config);
     results.labels.truncate(results.count);
     results.distances.truncate(results.count);
     return results;

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];
 };
@@ -446,21 +469,21 @@ class auto_index_gt {
     void reserve(std::size_t capacity) { index_->reserve(capacity); }
 
     // clang-format off
-    void add(label_t label, f16_bits_t const* vector) { return add(label, vector, true, casts_.from_f16); }
-    void add(label_t label, f32_t const* vector) { return add(label, vector, true, casts_.from_f32); }
-    void add(label_t label, f64_t const* vector) { return add(label, vector, true, casts_.from_f64); }
+    void add(label_t label, f16_bits_t const* vector) { return add(label, vector, casts_.from_f16); }
+    void add(label_t label, f32_t const* vector) { return add(label, vector, casts_.from_f32); }
+    void add(label_t label, f64_t const* vector) { return add(label, vector, casts_.from_f64); }
 
-    void add(label_t label, f16_bits_t const* vector, std::size_t thread, bool copy) { return add(label, vector, thread, copy, casts_.from_f16); }
-    void add(label_t label, f32_t const* vector, std::size_t thread, bool copy) { return add(label, vector, thread, copy, casts_.from_f32); }
-    void add(label_t label, f64_t const* vector, std::size_t thread, bool copy) { return add(label, vector, thread, copy, casts_.from_f64); }
+    void add(label_t label, f16_bits_t const* vector, add_config_t config) { return add(label, vector, config, casts_.from_f16); }
+    void add(label_t label, f32_t const* vector, add_config_t config) { return add(label, vector, config, casts_.from_f32); }
+    void add(label_t label, f64_t const* vector, add_config_t config) { return add(label, vector, config, casts_.from_f64); }
 
     std::size_t search(f16_bits_t const* vector, std::size_t wanted, label_t* matches, distance_t* distances) const { return search(vector, wanted, matches, distances, casts_.from_f16); }
     std::size_t search(f32_t const* vector, std::size_t wanted, label_t* matches, distance_t* distances) const { return search(vector, wanted, matches, distances, casts_.from_f32); }
     std::size_t search(f64_t const* vector, std::size_t wanted, label_t* matches, distance_t* distances) const { return search(vector, wanted, matches, distances, casts_.from_f64); }
 
-    std::size_t search(f16_bits_t const* vector, std::size_t wanted, label_t* matches, distance_t* distances, std::size_t thread) const { return search(vector, wanted, matches, distances, thread, casts_.from_f16); }
-    std::size_t search(f32_t const* vector, std::size_t wanted, label_t* matches, distance_t* distances, std::size_t thread) const { return search(vector, wanted, matches, distances, thread, casts_.from_f32); }
-    std::size_t search(f64_t const* vector, std::size_t wanted, label_t* matches, distance_t* distances, std::size_t thread) const { return search(vector, wanted, matches, distances, thread, casts_.from_f64); }
+    std::size_t search(f16_bits_t const* vector, std::size_t wanted, label_t* matches, distance_t* distances, search_config_t config) const { return search(vector, wanted, matches, distances, config, casts_.from_f16); }
+    std::size_t search(f32_t const* vector, std::size_t wanted, label_t* matches, distance_t* distances, search_config_t config) const { return search(vector, wanted, matches, distances, config, casts_.from_f32); }
+    std::size_t search(f64_t const* vector, std::size_t wanted, label_t* matches, distance_t* distances, search_config_t config) const { return search(vector, wanted, matches, distances, config, casts_.from_f64); }
 
     static auto_index_gt ip(std::size_t dimensions, accuracy_t accuracy = accuracy_t::f16_k, config_t config = {}) { return make(dimensions, accuracy, ip_metric(dimensions, accuracy), make_casts(accuracy), config); }
     static auto_index_gt l2(std::size_t dimensions, accuracy_t accuracy = accuracy_t::f16_k, config_t config = {}) { return make(dimensions, accuracy, l2_metric(dimensions, accuracy), make_casts(accuracy), config); }
@@ -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); }
@@ -522,38 +549,40 @@ class auto_index_gt {
     }
 
     template <typename scalar_at>
-    void add(label_t label, scalar_at const* vector, std::size_t thread, bool copy, cast_t const& cast) {
+    void add(label_t label, scalar_at const* vector, add_config_t config, cast_t const& cast) {
         byte_t const* vector_data = reinterpret_cast<byte_t const*>(vector);
         std::size_t vector_bytes = dimensions_ * sizeof(scalar_at);
 
-        byte_t* casted_data = cast_buffer_.data() + casted_vector_bytes_ * thread;
+        byte_t* casted_data = cast_buffer_.data() + casted_vector_bytes_ * config.thread;
         bool casted = cast(vector_data, casted_vector_bytes_, casted_data);
         if (casted)
-            vector_data = casted_data, vector_bytes = casted_vector_bytes_, copy = true;
+            vector_data = casted_data, vector_bytes = casted_vector_bytes_, config.store_vector = true;
 
-        index_->add(label, {vector_data, vector_bytes}, thread, copy);
+        index_->add(label, {vector_data, vector_bytes}, config);
     }
 
     template <typename scalar_at>
     std::size_t search(                              //
         scalar_at const* vector, std::size_t wanted, //
         label_t* matches, distance_t* distances,     //
-        std::size_t thread, cast_t const& cast) const {
+        search_config_t config, cast_t const& cast) const {
 
         byte_t const* vector_data = reinterpret_cast<byte_t const*>(vector);
         std::size_t vector_bytes = dimensions_ * sizeof(scalar_at);
 
-        byte_t* casted_data = cast_buffer_.data() + casted_vector_bytes_ * thread;
+        byte_t* casted_data = cast_buffer_.data() + casted_vector_bytes_ * config.thread;
         bool casted = cast(vector_data, casted_vector_bytes_, casted_data);
         if (casted)
             vector_data = casted_data, vector_bytes = casted_vector_bytes_;
 
-        return index_->search({vector_data, vector_bytes}, wanted, matches, distances, thread);
+        return index_->search({vector_data, vector_bytes}, wanted, matches, distances, config);
     }
 
-    template <typename scalar_at> void add(label_t label, scalar_at const* vector, bool copy, cast_t const& cast) {
+    template <typename scalar_at> void add(label_t label, scalar_at const* vector, cast_t const& cast) {
         thread_lock_t lock = thread_lock();
-        return add(label, vector, lock.thread_id, copy, cast);
+        add_config_t config;
+        config.thread = lock.thread_id;
+        return add(label, vector, config, cast);
     }
 
     template <typename scalar_at>
@@ -562,7 +591,9 @@ class auto_index_gt {
         label_t* matches, distance_t* distances,     //
         cast_t const& cast) const {
         thread_lock_t lock = thread_lock();
-        return search(vector, wanted, matches, distances, lock.thread_id, cast);
+        search_config_t config;
+        config.thread = lock.thread_id;
+        return search(vector, wanted, matches, distances, config, cast);
     }
 
     static auto_index_gt make(                            //
@@ -652,43 +683,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 +724,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 +732,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

@@ -43,6 +43,7 @@ using namespace unum::usearch;
 using namespace unum;
 
 using vector_id_t = std::uint32_t;
+using vector_view_t = span_gt<float const>;
 
 template <typename element_at>
 std::size_t offset_of(element_at const* begin, element_at const* end, element_at v) noexcept {
@@ -271,12 +272,14 @@ struct running_stats_printer_t {
 template <typename index_at, typename vector_id_at, typename real_at>
 void index_many(index_at& native, std::size_t n, vector_id_at const* ids, real_at const* vectors, std::size_t dims) {
 
-    using span_t = span_gt<float const>;
     running_stats_printer_t printer{n, "Indexing"};
 
 #pragma omp parallel for schedule(static, 32)
     for (std::size_t i = 0; i < n; ++i) {
-        native.add(ids[i], span_t{vectors + dims * i, dims}, omp_get_thread_num(), true);
+        add_config_t config;
+        config.thread = omp_get_thread_num();
+        config.store_vector = true;
+        native.add(ids[i], vector_view_t{vectors + dims * i, dims}, config);
         printer.progress++;
         if (omp_get_thread_num() == 0)
             printer.refresh();
@@ -284,18 +287,20 @@ void index_many(index_at& native, std::size_t n, vector_id_at const* ids, real_a
 }
 
 template <typename index_at, typename vector_id_at, typename real_at>
-void search_many(index_at& native, std::size_t n, real_at const* vectors, std::size_t dims, std::size_t wanted,
-                 vector_id_at* ids, real_at* distances) {
+void search_many( //
+    index_at& native, std::size_t n, real_at const* vectors, std::size_t dims, std::size_t wanted, vector_id_at* ids,
+    real_at* distances) {
 
-    using span_t = span_gt<float const>;
     running_stats_printer_t printer{n, "Search"};
 
 #pragma omp parallel for schedule(static, 32)
     for (std::size_t i = 0; i < n; ++i) {
-        native.search(                                //
-            span_t{vectors + dims * i, dims}, wanted, //
-            ids + wanted * i, distances + wanted * i, //
-            omp_get_thread_num());
+        search_config_t config;
+        config.thread = omp_get_thread_num();
+        native.search(                                       //
+            vector_view_t{vectors + dims * i, dims}, wanted, //
+            ids + wanted * i, distances + wanted * i,        //
+            config);
         printer.progress++;
         if (omp_get_thread_num() == 0)
             printer.refresh();
@@ -400,7 +405,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 +413,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 +473,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

package/swift/Index+Sugar.swift

@@ -5,6 +5,7 @@
 //  Created by Ashot Vardanian on 5/11/23.
 //
 
+@available(iOS 13, macOS 10.15, tvOS 13.0, watchOS 6.0, *)
 extension Index {
 
     public func add(label: UInt32, vector: ArraySlice<Float32>) -> () {

package/swift/Test.swift

@@ -8,6 +8,7 @@
 import Foundation
 import USearch
 
+@available(iOS 13, macOS 10.15, tvOS 13.0, watchOS 6.0, *)
 func testUnit() throws {
     let index = Index.l2(dimensions: 4, connectivity: 8)
     let vectorA: [Float32] = [0.3, 0.5, 1.2, 1.4]