usearch 0.2.2 → 0.2.4

package/python/bench.py

@@ -1,33 +1,75 @@
-import datetime
+import time
 import numpy as np
 import fire
 
-import faiss
-import usearch
-
-import struct
 import numpy as np
+from numba import cfunc, types, carray
+
+from faiss import IndexHNSWFlat, IndexIVFPQ
+from usearch.index import Index
+from usearch.io import load_matrix
+
 
 def measure(f) -> float:
-    a = datetime.datetime.now()
-    f()
-    b = datetime.datetime.now()
+    a = time.time_ns()
+    result = f()
+    b = time.time_ns()
     c = b - a
-    print(f'Took: {c.seconds:.2f} seconds')
-    return c.seconds
+    secs = c / (10 ** 9)
+    print(f'- Took: {secs:.2f} seconds')
+    return secs, result
 
 
 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')
+    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'- USearch: {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),
+    types.size_t, types.size_t)
+
+
+@cfunc(signature_f32)
+def inner_product_f32(a, b, n, m):
+    a_array = carray(a, n)
+    b_array = carray(b, n)
+    c = types.float32(0)
+    for i in range(n):
+        c += a_array[i] * b_array[i]
+    return types.float32(1 - c)
 
 
 def main(
@@ -44,31 +86,61 @@ def main(
     neighbors_mat = load_matrix(neighbors)
     dim = vectors_mat.shape[1]
 
-    # Test FAISS
-    index = faiss.IndexHNSWFlat(dim, connectivity)
+    print('USearch: HNSW')
+    index = Index(
+        ndim=dim,
+        expansion_add=expansion_add,
+        expansion_search=expansion_search,
+        connectivity=connectivity,
+    )
+    bench_usearch(index, vectors_mat, queries_mat, neighbors_mat)
+
+    print('USearch: HNSW + Numba JIT')
+    index = Index(
+        ndim=dim,
+        expansion_add=expansion_add,
+        expansion_search=expansion_search,
+        connectivity=connectivity,
+        metric_pointer=inner_product_f32.address,
+    )
+    bench_usearch(index, vectors_mat, queries_mat, neighbors_mat)
+
+    print('USearch: HNSW + Half Precision')
+    index = Index(
+        ndim=dim,
+        dtype='f16',
+        expansion_add=expansion_add,
+        expansion_search=expansion_search,
+        connectivity=connectivity,
+    )
+    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
     index.hnsw.efConstruction = expansion_add
     bench_faiss(index, vectors_mat, queries_mat, neighbors_mat)
 
-    # Test FAISS with default Product Quantization
+    print('FAISS: HNSW + IVFPQ')
     nlist = 10000  # Number of inverted lists (number of partitions or cells).
     nsegment = 16  # Number of segments for PQ (number of subquantizers).
     nbit = 8       # Number of bits to encode each segment.
-    coarse_quantizer = faiss.IndexHNSWFlat(dim, connectivity)
-    index = faiss.IndexIVFPQ(coarse_quantizer, dim, nlist, nsegment, nbit)
+    coarse_quantizer = IndexHNSWFlat(dim, connectivity)
+    index = IndexIVFPQ(coarse_quantizer, dim, nlist, nsegment, nbit)
     index.train(vectors_mat)
     index.nprobe = 10
     bench_faiss(index, vectors_mat, queries_mat, neighbors_mat)
 
-    # Test USearch `Index`
-    index = usearch.Index(
-        ndim=dim,
-        expansion_add=expansion_add,
-        expansion_search=expansion_search,
-        connectivity=connectivity,
-    )
-    bench_usearch(index, vectors_mat, queries_mat, neighbors_mat)
-
 
 if __name__ == '__main__':
     fire.Fire(main)

package/python/lib.cpp

@@ -59,6 +59,25 @@ struct hash_index_w_meta_t : public hash_index_t {
     span_gt<hash_word_t const> buffer() const noexcept { return {buffer_.data(), buffer_.size()}; }
 };
 
+template <typename scalar_at> punned_stateful_metric_t udf(std::size_t metric_uintptr) {
+    return [metric_uintptr](byte_t const* a_bytes, byte_t const* b_bytes, std::size_t n, std::size_t m) -> distance_t {
+        using metric_t = punned_distance_t (*)(scalar_at const*, scalar_at const*, std::size_t, std::size_t);
+        metric_t metric_ptr = reinterpret_cast<metric_t>(metric_uintptr);
+        scalar_at const* a = reinterpret_cast<scalar_at const*>(a_bytes);
+        scalar_at const* b = reinterpret_cast<scalar_at const*>(b_bytes);
+        return metric_ptr(a, b, n / sizeof(scalar_at), m / sizeof(scalar_at));
+    };
+}
+
+punned_stateful_metric_t udf(std::size_t metric_uintptr, accuracy_t accuracy) {
+    switch (accuracy) {
+    case accuracy_t::f8_k: return udf<f8_bits_t>(metric_uintptr);
+    case accuracy_t::f16_k: return udf<f16_bits_t>(metric_uintptr);
+    case accuracy_t::f32_k: return udf<f32_t>(metric_uintptr);
+    case accuracy_t::f64_k: return udf<f64_t>(metric_uintptr);
+    }
+}
+
 static native_index_t make_index(   //
     std::size_t dimensions,         //
     std::size_t capacity,           //
@@ -79,9 +98,8 @@ 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());
-    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);
+    if (metric_uintptr)
+        return native_index_t::udf(dimensions, udf(metric_uintptr, accuracy), accuracy, config);
     else
         return index_from_name<native_index_t>(metric.c_str(), metric.size(), dimensions, accuracy, config);
 }
@@ -127,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())
@@ -146,7 +164,9 @@ static void add_one_to_index(native_index_t& index, label_t label, py::buffer ve
         throw std::invalid_argument("Incompatible scalars in the vector!");
 }
 
-static void add_many_to_index(native_index_t& index, py::buffer labels, py::buffer vectors, bool copy) {
+static void add_many_to_index(                                    //
+    native_index_t& index, py::buffer labels, py::buffer vectors, //
+    bool copy, std::size_t threads = 0) {
 
     py::buffer_info labels_info = labels.request();
     py::buffer_info vectors_info = vectors.request();
@@ -160,10 +180,10 @@ static void add_many_to_index(native_index_t& index, py::buffer labels, py::buff
     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)
@@ -202,13 +222,13 @@ static void add_many_to_index(native_index_t& index, py::buffer labels, py::buff
 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>();
@@ -226,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;
@@ -256,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>();
@@ -344,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) {
@@ -393,7 +413,8 @@ PYBIND11_MODULE(index, m) {
         py::arg("labels"),         //
         py::arg("vectors"),        //
         py::kw_only(),             //
-        py::arg("copy") = true     //
+        py::arg("copy") = true,    //
+        py::arg("threads") = 0     //
     );
 
     i.def(                        //
@@ -415,6 +436,8 @@ PYBIND11_MODULE(index, m) {
     i.def_property_readonly("ndim", &native_index_t::dimensions);
     i.def_property_readonly("connectivity", &native_index_t::connectivity);
     i.def_property_readonly("capacity", &native_index_t::capacity);
+    i.def_property_readonly( //
+        "dtype", [](native_index_t const& index) -> std::string { return accuracy_name(index.accuracy()); });
 
     i.def("save", &save_index<native_index_t>, py::arg("path"));
     i.def("load", &load_index<native_index_t>, py::arg("path"));
@@ -454,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"),       //
@@ -504,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/setup.py

@@ -1,13 +1,20 @@
 import os
 import sys
-from setuptools import setup, find_packages
+from setuptools import setup
 from pybind11.setup_helpers import Pybind11Extension
 
 
 compile_args = ['-std=c++11', '-O3']
+link_args = []
+
+if sys.platform == 'linux':
+    compile_args.append('-fopenmp')
+    link_args.append('-lgomp')
 
 if sys.platform == 'darwin':
-    compile_args.append('-mmacosx-version-min=10.13')
+    # MacOS 10.15 orhigher is needed for `aligned_alloc` support.
+    # https://github.com/unum-cloud/usearch/actions/runs/4975434891/jobs/8902603392
+    compile_args.append('-mmacosx-version-min=10.15')
 
 if sys.platform == 'win32':
     compile_args = ['/std:c++14', '/O2']
@@ -17,7 +24,8 @@ ext_modules = [
     Pybind11Extension(
         'usearch.index',
         ['python/lib.cpp'],
-        extra_compile_args=compile_args
+        extra_compile_args=compile_args,
+        extra_link_args=link_args,
     ),
 ]
 

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;