usearch 2.1.2 → 2.2.0

package/.github/workflows/prerelease.yml

@@ -74,8 +74,9 @@ jobs:
     name: Test Python
     runs-on: ${{ matrix.os }}
     strategy:
+      fail-fast: false
       matrix:
-        os: [ubuntu-20.04, macOS-11, windows-2022]
+        os: [ubuntu-22.04, macOS-11, windows-2022]
         python-version: ["3.11"]
 
     steps:
@@ -89,8 +90,16 @@ jobs:
         run: |
           python -m pip install --upgrade pip
           pip install pytest numpy
+      - name: Build locally on Ubuntu
+        run: |
+          export CC=/usr/bin/gcc-12
+          export CXX=/usr/bin/g++-12
+          export LD_LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/12/:$LD_LIBRARY_PATH
+          python -m pip install .
+        if: ${{ matrix.os == 'ubuntu-22.04' }}
       - name: Build locally
         run: python -m pip install .
+        if: ${{ matrix.os != 'ubuntu-22.04' }}
       - name: Test with PyTest
         run: pytest python/scripts/
 
@@ -99,8 +108,9 @@ jobs:
     name: Test Python 3.7
     runs-on: ${{ matrix.os }}
     strategy:
+      fail-fast: false
       matrix:
-        os: [ubuntu-20.04]
+        os: [ubuntu-22.04]
         python-version: ["3.7"]
 
     steps:
@@ -118,7 +128,12 @@ jobs:
           pip install pytest numpy
 
       - name: Build locally
-        run: python -m pip install .
+        run: |
+          export CC=/usr/bin/gcc-12
+          export CXX=/usr/bin/g++-12
+          export LD_LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/12/:$LD_LIBRARY_PATH
+          python -m pip install .
+        if: ${{ matrix.os == 'ubuntu-22.04' }}
 
       - name: Test with PyTest
         run: pytest python/scripts/

package/CMakeLists.txt

@@ -49,11 +49,26 @@ else()
     target_compile_features(${USEARCH_TARGET_NAME} INTERFACE cxx_std_11)
 endif()
 
+# Core compilation settings affecting "index.hpp"
 target_compile_definitions(
     ${USEARCH_TARGET_NAME}
     INTERFACE
     $<$<NOT:$<BOOL:${JSON_GlobalUDLs}>>:USEARCH_USE_OPENMP=0>
 )
+
+# Supplementary compilation settings affecting "index_plugins.hpp"
+target_compile_definitions(
+    ${USEARCH_TARGET_NAME}
+    INTERFACE
+    $<$<NOT:$<BOOL:${JSON_GlobalUDLs}>>:USEARCH_USE_NATIVE_F16=0>
+)
+
+target_compile_definitions(
+    ${USEARCH_TARGET_NAME}
+    INTERFACE
+    $<$<NOT:$<BOOL:${JSON_GlobalUDLs}>>:USEARCH_USE_SIMSIMD=0>
+)
+
 target_include_directories(
     ${USEARCH_TARGET_NAME}
     ${USEARCH_SYSTEM_INCLUDE} INTERFACE

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "usearch"
-version = "2.1.2"
+version = "2.2.0"
 authors = ["Ash Vardanian <1983160+ashvardanian@users.noreply.github.com>"]
 description = "Smaller & Faster Single-File Vector Search Engine from Unum"
 edition = "2021"

package/README.md

@@ -39,8 +39,8 @@ Linux • MacOS • Windows • iOS • Docker • WebAssembly
 <a href="https://pypi.org/project/usearch/"> <img alt="PyPI - Downloads" src="https://img.shields.io/pypi/dm/usearch?label=pypi%20downloads"> </a>
 <a href="https://www.npmjs.com/package/usearch"> <img alt="npm" src="https://img.shields.io/npm/dy/usearch?label=npm%20dowloads"> </a>
 <a href="https://crates.io/crates/usearch"> <img alt="Crates.io" src="https://img.shields.io/crates/d/usearch?label=crate%20downloads"> </a>
-<a href="https://www.nuget.org/packages/Cloud.Unum.USearch"> <img alt="Nuget" src="https://img.shields.io/nuget/dt/Cloud.Unum.USearch?style=social&label=NuGet"> </a>
-<a href="https://hub.docker.com/r/unum/usearch"> <img alt="Docker Pulls" src="https://img.shields.io/docker/pulls/unum/usearch?style=social&label=Docker"> </a>
+<a href="https://www.nuget.org/packages/Cloud.Unum.USearch"> <img alt="Nuget" src="https://img.shields.io/nuget/dt/Cloud.Unum.USearch?label=NuGet"> </a>
+<a href="https://hub.docker.com/r/unum/usearch"> <img alt="Docker Pulls" src="https://img.shields.io/docker/pulls/unum/usearch?label=Docker"> </a>
 <img alt="GitHub code size in bytes" src="https://img.shields.io/github/languages/code-size/unum-cloud/usearch">
 </div>
 

package/conanfile.py

@@ -4,7 +4,7 @@ from conans import ConanFile
 class USearchConan(ConanFile):
 
     name = 'USearch'
-    version = '2.1.2'
+    version = '2.2.0'
     license = 'Apache 2.0'
     url = 'https://github.com/unum-cloud/usearch'
     description = 'Smaller & Faster Single-File Vector Search Engine from Unum'

package/include/usearch/index_plugins.hpp

@@ -41,8 +41,10 @@
 #endif
 
 #if USEARCH_USE_SIMSIMD
+#if __linux__
 #include <simsimd/simsimd.h>
 #endif
+#endif
 
 namespace unum {
 namespace usearch {
@@ -127,7 +129,9 @@ enum class isa_kind_t {
     neon_k,
     sve_k,
     avx2_k,
+    avx2f16_k,
     avx512_k,
+    avx512f16_k,
 };
 
 enum class prefetching_kind_t {
@@ -193,6 +197,8 @@ inline char const* isa_name(isa_kind_t isa_kind) noexcept {
     case isa_kind_t::sve_k: return "sve";
     case isa_kind_t::avx2_k: return "avx2";
     case isa_kind_t::avx512_k: return "avx512";
+    case isa_kind_t::avx2f16_k: return "avx2+f16";
+    case isa_kind_t::avx512f16_k: return "avx512+f16";
     default: return "";
     }
 }
@@ -215,6 +221,13 @@ inline bool hardware_supports(isa_kind_t isa_kind) noexcept {
 #if defined(USEARCH_DEFINED_X86) && defined(USEARCH_DEFINED_GCC)
     __builtin_cpu_init();
     switch (isa_kind) {
+        // Half-precision is only supported in newer versions of GCC
+#if __GNUC__ > 11 || (__GNUC__ == 11 && __GNUC_MINOR__ >= 0)
+    case isa_kind_t::avx2f16_k: return __builtin_cpu_supports("avx2") && __builtin_cpu_supports("f16c");
+#endif
+#if __GNUC__ > 12 || (__GNUC__ == 12 && __GNUC_MINOR__ >= 0)
+    case isa_kind_t::avx512f16_k: return __builtin_cpu_supports("avx512f") && __builtin_cpu_supports("avx512fp16");
+#endif
     case isa_kind_t::avx2_k: return __builtin_cpu_supports("avx2");
     case isa_kind_t::avx512_k: return __builtin_cpu_supports("avx512f");
     default: return false;
@@ -600,9 +613,7 @@ class aligned_allocator_gt {
     using size_type = std::size_t;
     using pointer = element_at*;
     using const_pointer = element_at const*;
-    template <typename other_element_at> struct rebind {
-        using other = aligned_allocator_gt<other_element_at>;
-    };
+    template <typename other_element_at> struct rebind { using other = aligned_allocator_gt<other_element_at>; };
 
     constexpr std::size_t alignment() const { return alignment_ak; }
 
@@ -1384,25 +1395,58 @@ class metric_punned_t {
     // clang-format off
     static metric_punned_t ip_metric_f32_(std::size_t bytes_per_vector) {
         #if USEARCH_USE_SIMSIMD
-        if (hardware_supports(isa_kind_t::sve_k)) return {pun_stl_<f32_t>([=](f32_t const* a, f32_t const* b) { return simsimd_dot_f32_sve(a, b, bytes_per_vector / 4); }), bytes_per_vector, metric_kind_t::ip_k, scalar_kind_t::f32_k, isa_kind_t::sve_k};
+        #if SIMSIMD_TARGET_ARM_NEON
         if (hardware_supports(isa_kind_t::neon_k) && bytes_per_vector % 16 == 0) return {pun_stl_<f32_t>([=](f32_t const* a, f32_t const* b) { return simsimd_dot_f32x4_neon(a, b, bytes_per_vector / 4); }), bytes_per_vector, metric_kind_t::ip_k, scalar_kind_t::f32_k, isa_kind_t::neon_k};
+        #endif
+        #if SIMSIMD_TARGET_ARM_SVE
+        if (hardware_supports(isa_kind_t::sve_k)) return {pun_stl_<f32_t>([=](f32_t const* a, f32_t const* b) { return simsimd_dot_f32_sve(a, b, bytes_per_vector / 4); }), bytes_per_vector, metric_kind_t::ip_k, scalar_kind_t::f32_k, isa_kind_t::sve_k};
+        #endif
+        #if SIMSIMD_TARGET_X86_AVX2
         if (hardware_supports(isa_kind_t::avx2_k) && bytes_per_vector % 16 == 0) return {pun_stl_<f32_t>([=](f32_t const* a, f32_t const* b) { return simsimd_dot_f32x4_avx2(a, b, bytes_per_vector / 4); }), bytes_per_vector, metric_kind_t::ip_k, scalar_kind_t::f32_k, isa_kind_t::avx2_k};
         #endif
+        #endif
         return {to_stl_<metric_ip_gt<f32_t>>(bytes_per_vector), bytes_per_vector, metric_kind_t::ip_k, scalar_kind_t::f32_k, isa_kind_t::auto_k};
     }
 
     static metric_punned_t cos_metric_f16_(std::size_t bytes_per_vector) {
         #if USEARCH_USE_SIMSIMD
-        if (hardware_supports(isa_kind_t::avx512_k) && bytes_per_vector % 32 == 0) return {pun_stl_<simsimd_f16_t>([=](simsimd_f16_t const* a, simsimd_f16_t const* b) { return simsimd_cos_f16x16_avx512(a, b, bytes_per_vector / 2); }), bytes_per_vector, metric_kind_t::cos_k, scalar_kind_t::f16_k, isa_kind_t::avx512_k};
+        #if SIMSIMD_TARGET_X86_AVX512
+        if (hardware_supports(isa_kind_t::avx512f16_k) && bytes_per_vector % 32 == 0) return {pun_stl_<simsimd_f16_t>([=](simsimd_f16_t const* a, simsimd_f16_t const* b) { return simsimd_cos_f16x16_avx512(a, b, bytes_per_vector / 2); }), bytes_per_vector, metric_kind_t::cos_k, scalar_kind_t::f16_k, isa_kind_t::avx512f16_k};
+        #endif
+        #if SIMSIMD_TARGET_X86_AVX2
+        if (hardware_supports(isa_kind_t::avx2f16_k) && bytes_per_vector % 16 == 0) return {pun_stl_<simsimd_f16_t>([=](simsimd_f16_t const* a, simsimd_f16_t const* b) { return simsimd_cos_f16x8_avx2(a, b, bytes_per_vector / 2); }), bytes_per_vector, metric_kind_t::cos_k, scalar_kind_t::f16_k, isa_kind_t::avx2f16_k};
+        #endif
+        #if SIMSIMD_TARGET_ARM_NEON
         if (hardware_supports(isa_kind_t::neon_k) && bytes_per_vector % 8 == 0) return {pun_stl_<simsimd_f16_t>([=](simsimd_f16_t const* a, simsimd_f16_t const* b) { return simsimd_cos_f16x4_neon(a, b, bytes_per_vector / 2); }), bytes_per_vector, metric_kind_t::cos_k, scalar_kind_t::f16_k, isa_kind_t::neon_k};
         #endif
+        #if SIMSIMD_TARGET_ARM_SVE
+        if (hardware_supports(isa_kind_t::sve_k)) return {pun_stl_<simsimd_f16_t>([=](simsimd_f16_t const* a, simsimd_f16_t const* b) { return simsimd_cos_f16_sve(a, b, bytes_per_vector / 4); }), bytes_per_vector, metric_kind_t::cos_k, scalar_kind_t::f16_k, isa_kind_t::sve_k};
+        #endif
+        #endif
         return {to_stl_<metric_cos_gt<f16_t, f32_t>>(bytes_per_vector), bytes_per_vector, metric_kind_t::cos_k, scalar_kind_t::f16_k, isa_kind_t::auto_k};
     }
 
+    static metric_punned_t l2sq_metric_f16_(std::size_t bytes_per_vector) {
+        #if USEARCH_USE_SIMSIMD
+        #if SIMSIMD_TARGET_X86_AVX512
+        if (hardware_supports(isa_kind_t::avx512f16_k) && bytes_per_vector % 32 == 0) return {pun_stl_<simsimd_f16_t>([=](simsimd_f16_t const* a, simsimd_f16_t const* b) { return simsimd_l2sq_f16x16_avx512(a, b, bytes_per_vector / 2); }), bytes_per_vector, metric_kind_t::cos_k, scalar_kind_t::f16_k, isa_kind_t::avx512f16_k};
+        #endif
+        #if SIMSIMD_TARGET_X86_AVX2
+        if (hardware_supports(isa_kind_t::avx2f16_k) && bytes_per_vector % 16 == 0) return {pun_stl_<simsimd_f16_t>([=](simsimd_f16_t const* a, simsimd_f16_t const* b) { return simsimd_l2sq_f16x8_avx2(a, b, bytes_per_vector / 2); }), bytes_per_vector, metric_kind_t::cos_k, scalar_kind_t::f16_k, isa_kind_t::avx2f16_k};
+        #endif
+        #if SIMSIMD_TARGET_ARM_SVE
+        if (hardware_supports(isa_kind_t::sve_k)) return {pun_stl_<simsimd_f16_t>([=](simsimd_f16_t const* a, simsimd_f16_t const* b) { return simsimd_l2sq_f16_sve(a, b, bytes_per_vector / 4); }), bytes_per_vector, metric_kind_t::l2sq_k, scalar_kind_t::f16_k, isa_kind_t::sve_k};
+        #endif
+        #endif
+        return {to_stl_<metric_l2sq_gt<f16_t, f32_t>>(bytes_per_vector), bytes_per_vector, metric_kind_t::l2sq_k, scalar_kind_t::f16_k, isa_kind_t::auto_k};
+    }    
+
     static metric_punned_t cos_metric_i8_(std::size_t bytes_per_vector) {
         #if USEARCH_USE_SIMSIMD
+        #if SIMSIMD_TARGET_ARM_NEON
         if (hardware_supports(isa_kind_t::neon_k) && bytes_per_vector % 16 == 0) return {pun_stl_<int8_t>([=](int8_t const* a, int8_t const* b) { return simsimd_cos_i8x16_neon(a, b, bytes_per_vector); }), bytes_per_vector, metric_kind_t::cos_k, scalar_kind_t::i8_k, isa_kind_t::neon_k};
         #endif
+        #endif
         return {to_stl_<cos_i8_t>(bytes_per_vector), bytes_per_vector, metric_kind_t::cos_k, scalar_kind_t::i8_k, isa_kind_t::auto_k};
     }
 
@@ -1419,7 +1463,7 @@ class metric_punned_t {
     static metric_punned_t l2sq_metric_(std::size_t bytes_per_vector, scalar_kind_t scalar_kind) {
         switch (scalar_kind) {
         case scalar_kind_t::i8_k: return {to_stl_<l2sq_i8_t>(bytes_per_vector), bytes_per_vector, metric_kind_t::l2sq_k, scalar_kind_t::i8_k, isa_kind_t::auto_k};
-        case scalar_kind_t::f16_k: return {to_stl_<metric_l2sq_gt<f16_t, f32_t>>(bytes_per_vector), bytes_per_vector, metric_kind_t::l2sq_k, scalar_kind_t::f16_k, isa_kind_t::auto_k};
+        case scalar_kind_t::f16_k: return l2sq_metric_f16_(bytes_per_vector);
         case scalar_kind_t::f32_k: return {to_stl_<metric_l2sq_gt<f32_t>>(bytes_per_vector), bytes_per_vector, metric_kind_t::l2sq_k, scalar_kind_t::f32_k, isa_kind_t::auto_k};
         case scalar_kind_t::f64_k: return {to_stl_<metric_l2sq_gt<f64_t>>(bytes_per_vector), bytes_per_vector, metric_kind_t::l2sq_k, scalar_kind_t::f64_k, isa_kind_t::auto_k};
         default: return {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "usearch",
-    "version": "2.1.2",
+    "version": "2.2.0",
     "description": "Smaller & Faster Single-File Vector Search Engine from Unum",
     "author": "Ash Vardanian",
     "license": "Apache 2.0",

package/python/lib.cpp

@@ -957,6 +957,17 @@ PYBIND11_MODULE(compiled, m) {
           py::arg("metric_pointer") = 0                                    //
     );
 
+    m.def(
+        "hardware_acceleration",
+        [](scalar_kind_t scalar_kind, std::size_t dimensions, metric_kind_t metric_kind) -> bool {
+            return metric_t(dimensions, metric_kind, scalar_kind).isa_kind() != isa_kind_t::auto_k;
+        },
+        py::kw_only(),                                //
+        py::arg("dtype") = scalar_kind_t::f32_k,      //
+        py::arg("ndim") = 0,                          //
+        py::arg("metric_kind") = metric_kind_t::cos_k //
+    );
+
     auto i = py::class_<dense_index_py_t, std::shared_ptr<dense_index_py_t>>(m, "Index");
 
     i.def(py::init(&make_index),                                           //

package/python/usearch/index.py

@@ -29,6 +29,7 @@ from usearch.compiled import (
     index_dense_metadata_from_path as _index_dense_metadata_from_path,
     index_dense_metadata_from_buffer as _index_dense_metadata_from_buffer,
     exact_search as _exact_search,
+    hardware_acceleration as _hardware_acceleration,
 )
 
 # Precompiled symbols that will be exposed
@@ -72,9 +73,17 @@ NoneType = type(None)
 PathOrBuffer = Union[str, os.PathLike, bytes]
 
 
-def _normalize_dtype(dtype, metric: MetricKind = MetricKind.Cos) -> ScalarKind:
+def _normalize_dtype(
+    dtype,
+    ndim: int = 0,
+    metric: MetricKind = MetricKind.Cos,
+) -> ScalarKind:
     if dtype is None or dtype == "":
-        return ScalarKind.B1 if metric in MetricKindBitwise else ScalarKind.F32
+        if metric in MetricKindBitwise:
+            return ScalarKind.B1
+        if _hardware_acceleration(dtype=ScalarKind.F16, ndim=ndim, metric_kind=metric):
+            return ScalarKind.F16
+        return ScalarKind.F32
 
     if isinstance(dtype, ScalarKind):
         return dtype
@@ -491,8 +500,12 @@ class Index:
         :type dtype: Optional[DTypeLike], defaults to None
             For continuous metrics can be: f16, f32, f64, or i8.
             For bitwise metrics it's implementation-defined, and can't change.
+            If nothing is provided, the optimal data type is selected based on the metric
+            kind and hardware support.
             Example: you can use the `f16` index with `f32` vectors in Euclidean space,
-            which will be automatically downcasted.
+            which will be automatically downcasted. Moreover, if `dtype=None` is passed,
+            and hardware supports `f16` SIMD-instructions, this choice will be done for you.
+            You can later double-check the used representation with `index.dtype`.
 
         :param connectivity: Connections per node in HNSW
         :type connectivity: Optional[int], defaults to None
@@ -548,7 +561,7 @@ class Index:
             )
 
         # Validate, that the right scalar type is defined
-        dtype = _normalize_dtype(dtype, self._metric_kind)
+        dtype = _normalize_dtype(dtype, ndim, self._metric_kind)
         self._compiled = _CompiledIndex(
             ndim=ndim,
             dtype=dtype,

package/setup.py

@@ -7,10 +7,7 @@ from pybind11.setup_helpers import Pybind11Extension
 
 compile_args = []
 link_args = []
-macros_args = [
-    ("USEARCH_USE_NATIVE_F16", "0"),
-    ("USEARCH_USE_SIMSIMD", "0"),
-]
+macros_args = []
 
 if sys.platform == "linux":
     compile_args.append("-std=c++17")
@@ -18,6 +15,8 @@ if sys.platform == "linux":
     compile_args.append("-g")  # Simplify debugging
     compile_args.append("-Wno-unknown-pragmas")
 
+    macros_args.append(("USEARCH_USE_NATIVE_F16", "0"))
+    macros_args.append(("USEARCH_USE_SIMSIMD", "1"))
     macros_args.append(("USEARCH_USE_OPENMP", "1"))
     compile_args.append("-fopenmp")
     link_args.append("-lgomp")

package/simsimd/.github/workflows/prerelease.yml

@@ -21,8 +21,9 @@ jobs:
     name: Test Python
     runs-on: ${{ matrix.os }}
     strategy:
+      fail-fast: false
       matrix:
-        os: [ubuntu-20.04, macOS-11, windows-2022]
+        os: [ubuntu-22.04, macOS-11] # windows-2022
         python-version: ["3.11"]
 
     steps:
@@ -32,22 +33,52 @@ jobs:
         uses: actions/setup-python@v4
         with:
           python-version: ${{ matrix.python-version }}
+
+      - name: Set up Clang
+        run: brew install gcc@12
+        if: ${{ matrix.os == 'macOS-11' }}
+
+      - name: Set up MinGW
+        uses: egor-tensin/setup-mingw@v2
+        with:
+          platform: x64
+        if: ${{ matrix.os == 'windows-2022' }}
+        
       - name: Install dependencies
         run: |
           python -m pip install --no-cache-dir --upgrade pip
           pip install --no-cache-dir pytest
-      - name: Build locally
-        run: python -m pip install .
+          
+      - name: Build locally on Ubuntu
+        run: |
+          export CC=/usr/bin/gcc-12
+          export CXX=/usr/bin/g++-12
+          export LD_LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/12/:$LD_LIBRARY_PATH
+          python -m pip install .
+        if: ${{ matrix.os == 'ubuntu-22.04' }}
+
+      - name: Build locally on MacOS
+        run: |
+          export CC=/usr/local/bin/gcc-12
+          export CXX=/usr/local/bin/g++-12
+          python -m pip install .
+        if: ${{ matrix.os == 'macOS-11' }}
+
+      - name: Build locally on Windows
+        run: |
+          python -m pip install .
+        if: ${{ matrix.os == 'windows-2022' }}
+        
       - name: Test with PyTest
         run: pytest python/test.py
-
+        
 
   test_python_37:
     name: Test Python 3.7
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-20.04]
+        os: [ubuntu-22.04]
         python-version: ["3.7"]
 
     steps:
@@ -65,9 +96,11 @@ jobs:
           pip install --no-cache-dir pytest
 
       - name: Build locally
-        run: python -m pip install .
-
+        run: |
+          export CC=/usr/bin/gcc-12
+          export CXX=/usr/bin/g++-12
+          export LD_LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/12/:$LD_LIBRARY_PATH
+          python -m pip install .
+        
       - name: Test with PyTest
         run: pytest python/test.py
-
-

package/simsimd/.github/workflows/release.yml

@@ -29,7 +29,7 @@ jobs:
 
 
   rebase:
-    name: Rebase Development Branch
+    name: Rebase Dev. Branch
     needs: versioning
     runs-on: ubuntu-latest
     steps:
@@ -57,8 +57,7 @@ jobs:
     needs: versioning
     strategy:
       matrix:
-        os: [ubuntu-20.04, macOS-11, windows-2022]
-
+        os: [ubuntu-20.04, macOS-11] # windows-2022
     steps:
       - uses: actions/checkout@v3
         with:
@@ -66,20 +65,25 @@ jobs:
       - uses: actions/setup-python@v3
       
       - name: Setup Docker
-        if: matrix.os != 'windows-2022'
-        uses: crazy-max/ghaction-setup-docker@v1.0.0
-        with:
-          version: 23.0.1
-
+        if: matrix.os == 'ubuntu-20.04'
+        uses: docker-practice/actions-setup-docker@master
+        
       - name: Setup QEMU
-        if: matrix.os != 'windows-2022'
+        if: matrix.os == 'ubuntu-20.04'
         uses: docker/setup-qemu-action@v2.1.0
 
       - name: Install CIBuildWheel
         run: python -m pip install --no-cache-dir cibuildwheel
 
-      - name: Build wheels
+      - name: Build wheels on Ubuntu
+        run: python -m cibuildwheel
+        if: matrix.os == 'ubuntu-20.04'
+
+      - name: Build wheels on MacOS
         run: python -m cibuildwheel
+        env:
+          CIBW_ENVIRONMENT: CC=/usr/local/bin/gcc-12 CXX=/usr/local/bin/g++-12
+        if: matrix.os == 'macOS-11'
 
       - uses: actions/upload-artifact@v3
         with:
@@ -92,7 +96,7 @@ jobs:
     runs-on: ubuntu-20.04
     environment:
       name: pypi
-      url: https://pypi.org/p/stringzilla
+      url: https://pypi.org/p/simsimd
     permissions:
       id-token: write
 

package/simsimd/.vscode/settings.json

@@ -85,13 +85,17 @@
         "variant": "cpp",
         "__nullptr": "cpp",
         "unordered_set": "cpp",
-        "span": "cpp"
+        "span": "cpp",
+        "arm_neon.h": "c"
     },
     "cSpell.words": [
         "dtype",
         "dtypes",
         "kann",
+        "maccs",
+        "simd",
         "simsimd",
+        "tanimoto",
         "unsw"
     ]
 }

package/simsimd/CMakeLists.txt

@@ -34,14 +34,17 @@ endif()
 
 set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g -fsanitize=address")
 set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
+set(CMAKE_C_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g -fsanitize=address")
+set(CMAKE_C_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
 
 # List of all possible compiler IDs:
 # https://cmake.org/cmake/help/latest/variable/CMAKE_LANG_COMPILER_ID.html
 if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
 elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=native")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fmax-errors=1")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic -fmax-errors=1")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=native")
+    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pedantic -fmax-errors=1")
 elseif(CMAKE_CXX_COMPILER_ID STREQUAL "NVIDIA" OR CMAKE_CXX_COMPILER_ID STREQUAL "NVHPC")
     set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} --expt-relaxed-constexpr --extended-lambda")
     set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -gencode arch=compute_86,code=sm_86")