usearch 0.9.7 → 0.11.0

package/python/lib.cpp

@@ -169,7 +169,7 @@ static std::unique_ptr<hash_index_py_t> make_hash_index( //
     return std::unique_ptr<hash_index_py_t>(new hash_index_py_t(config, bits));
 }
 
-static void add_one_to_index(punned_py_t& index, label_t label, py::buffer vector, bool copy) {
+static void add_one_to_index(punned_py_t& index, label_t label, py::buffer vector, bool copy, std::size_t) {
 
     py::buffer_info vector_info = vector.request();
     if (vector_info.ndim != 1)
@@ -191,9 +191,9 @@ static void add_one_to_index(punned_py_t& index, label_t label, py::buffer vecto
         index.add(label, reinterpret_cast<f8_bits_t const*>(vector_data), config);
     else if (vector_info.format == "e")
         index.add(label, reinterpret_cast<f16_bits_t const*>(vector_data), config);
-    else if (vector_info.format == "f")
+    else if (vector_info.format == "f" || vector_info.format == "f4" || vector_info.format == "<f4")
         index.add(label, reinterpret_cast<float const*>(vector_data), config);
-    else if (vector_info.format == "d")
+    else if (vector_info.format == "d" || vector_info.format == "f8" || vector_info.format == "<f8")
         index.add(label, reinterpret_cast<double const*>(vector_data), config);
     else
         throw std::invalid_argument("Incompatible scalars in the vector!");
@@ -201,7 +201,10 @@ static void add_one_to_index(punned_py_t& index, label_t label, py::buffer vecto
 
 static void add_many_to_index(                                 //
     punned_py_t& index, py::buffer labels, py::buffer vectors, //
-    bool copy, std::size_t threads = 0) {
+    bool copy, std::size_t threads) {
+
+    if (index.config().max_threads_add < threads)
+        throw std::invalid_argument("Can't use that many threads!");
 
     py::buffer_info labels_info = labels.request();
     py::buffer_info vectors_info = vectors.request();
@@ -232,7 +235,7 @@ static void add_many_to_index(                                 //
 
     // https://docs.python.org/3/library/struct.html#format-characters
     if (vectors_info.format == "c" || vectors_info.format == "b")
-        multithreaded(index.config().concurrency(), vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
+        multithreaded(threads, vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
             add_config_t config;
             config.store_vector = copy;
             config.thread = thread_idx;
@@ -242,7 +245,7 @@ static void add_many_to_index(                                 //
             index.add(label, vector, config);
         });
     else if (vectors_info.format == "e")
-        multithreaded(index.config().concurrency(), vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
+        multithreaded(threads, vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
             add_config_t config;
             config.store_vector = copy;
             config.thread = thread_idx;
@@ -251,8 +254,8 @@ static void add_many_to_index(                                 //
                 reinterpret_cast<f16_bits_t const*>(vectors_data + task_idx * vectors_info.strides[0]);
             index.add(label, vector, config);
         });
-    else if (vectors_info.format == "f")
-        multithreaded(index.config().concurrency(), vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
+    else if (vectors_info.format == "f" || vectors_info.format == "f4" || vectors_info.format == "<f4")
+        multithreaded(threads, vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
             add_config_t config;
             config.store_vector = copy;
             config.thread = thread_idx;
@@ -260,8 +263,8 @@ static void add_many_to_index(                                 //
             float const* vector = reinterpret_cast<float const*>(vectors_data + task_idx * vectors_info.strides[0]);
             index.add(label, vector, config);
         });
-    else if (vectors_info.format == "d")
-        multithreaded(index.config().concurrency(), vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
+    else if (vectors_info.format == "d" || vectors_info.format == "f8" || vectors_info.format == "<f8")
+        multithreaded(threads, vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
             add_config_t config;
             config.store_vector = copy;
             config.thread = thread_idx;
@@ -299,11 +302,11 @@ static py::tuple search_one_in_index(punned_py_t& index, py::buffer vector, std:
         count = index //
                     .search(reinterpret_cast<f16_bits_t const*>(vector_data), wanted, config)
                     .dump_to(&labels_py1d(0), &distances_py1d(0));
-    else if (vector_info.format == "f")
+    else if (vector_info.format == "f" || vector_info.format == "f4" || vector_info.format == "<f4")
         count = index //
                     .search(reinterpret_cast<float const*>(vector_data), wanted, config)
                     .dump_to(&labels_py1d(0), &distances_py1d(0));
-    else if (vector_info.format == "d")
+    else if (vector_info.format == "d" || vector_info.format == "f8" || vector_info.format == "<f8")
         count = index //
                     .search(reinterpret_cast<double const*>(vector_data), wanted, config)
                     .dump_to(&labels_py1d(0), &distances_py1d(0));
@@ -329,11 +332,15 @@ static py::tuple search_one_in_index(punned_py_t& index, py::buffer vector, std:
  *      2. matrix of distances,
  *      3. array with match counts.
  */
-static py::tuple search_many_in_index(punned_py_t& index, py::buffer vectors, std::size_t wanted, bool exact) {
+static py::tuple search_many_in_index( //
+    punned_py_t& index, py::buffer vectors, std::size_t wanted, bool exact, std::size_t threads) {
 
     if (wanted == 0)
         return py::tuple(3);
 
+    if (index.config().max_threads_add < threads)
+        throw std::invalid_argument("Can't use that many threads!");
+
     py::buffer_info vectors_info = vectors.request();
     if (vectors_info.ndim == 1)
         return search_one_in_index(index, vectors, wanted, exact);
@@ -355,7 +362,7 @@ static py::tuple search_many_in_index(punned_py_t& index, py::buffer vectors, st
 
     // https://docs.python.org/3/library/struct.html#format-characters
     if (vectors_info.format == "c" || vectors_info.format == "b")
-        multithreaded(index.config().concurrency(), vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
+        multithreaded(threads, vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
             search_config_t config;
             config.thread = thread_idx;
             config.exact = exact;
@@ -364,7 +371,7 @@ static py::tuple search_many_in_index(punned_py_t& index, py::buffer vectors, st
                 index.search(vector, wanted, config).dump_to(&labels_py2d(task_idx, 0), &distances_py2d(task_idx, 0)));
         });
     else if (vectors_info.format == "e")
-        multithreaded(index.config().concurrency(), vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
+        multithreaded(threads, vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
             search_config_t config;
             config.thread = thread_idx;
             config.exact = exact;
@@ -372,8 +379,8 @@ static py::tuple search_many_in_index(punned_py_t& index, py::buffer vectors, st
             counts_py1d(task_idx) = static_cast<Py_ssize_t>(
                 index.search(vector, wanted, config).dump_to(&labels_py2d(task_idx, 0), &distances_py2d(task_idx, 0)));
         });
-    else if (vectors_info.format == "f")
-        multithreaded(index.config().concurrency(), vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
+    else if (vectors_info.format == "f" || vectors_info.format == "f4" || vectors_info.format == "<f4")
+        multithreaded(threads, vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
             search_config_t config;
             config.thread = thread_idx;
             config.exact = exact;
@@ -381,8 +388,8 @@ static py::tuple search_many_in_index(punned_py_t& index, py::buffer vectors, st
             counts_py1d(task_idx) = static_cast<Py_ssize_t>(
                 index.search(vector, wanted, config).dump_to(&labels_py2d(task_idx, 0), &distances_py2d(task_idx, 0)));
         });
-    else if (vectors_info.format == "d")
-        multithreaded(index.config().concurrency(), vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
+    else if (vectors_info.format == "d" || vectors_info.format == "f8" || vectors_info.format == "<f8")
+        multithreaded(threads, vectors_count, [&](std::size_t thread_idx, std::size_t task_idx) {
             search_config_t config;
             config.thread = thread_idx;
             config.exact = exact;
@@ -405,6 +412,8 @@ template <typename index_at> void save_index(index_at const& index, std::string
 template <typename index_at> void load_index(index_at& index, std::string const& path) { index.load(path.c_str()); }
 template <typename index_at> void view_index(index_at& index, std::string const& path) { index.view(path.c_str()); }
 template <typename index_at> void clear_index(index_at& index) { index.clear(); }
+template <typename index_at> std::size_t get_expansion_add(index_at const &index) { return index.config().expansion_add; }
+template <typename index_at> std::size_t get_expansion_search(index_at const &index) { return index.config().expansion_search; }
 // clang-format on
 
 template <typename element_at> bool has_duplicates(element_at const* begin, element_at const* end) {
@@ -473,8 +482,12 @@ void hash_buffer(hash_index_py_t& index, py::buffer vector) {
         throw std::invalid_argument("Array elements must be 16, 32, or 64 bit hashable integers!");
 }
 
-PYBIND11_MODULE(index, m) {
-    m.doc() = "Unum USearch Python bindings";
+PYBIND11_MODULE(compiled, m) {
+    m.doc() = "Smaller & Faster Single-File Vector Search Engine from Unum";
+
+    m.attr("DEFAULT_CONNECTIVITY") = py::int_(default_connectivity());
+    m.attr("DEFAULT_EXPANSION_ADD") = py::int_(default_expansion_add());
+    m.attr("DEFAULT_EXPANSION_SEARCH") = py::int_(default_expansion_search());
 
     auto i = py::class_<punned_py_t>(m, "Index");
 
@@ -505,14 +518,16 @@ PYBIND11_MODULE(index, m) {
         py::arg("label"),         //
         py::arg("vector"),        //
         py::kw_only(),            //
-        py::arg("copy") = true    //
+        py::arg("copy") = true,   //
+        py::arg("threads") = 0    //
     );
 
     i.def(                               //
         "search", &search_many_in_index, //
         py::arg("query"),                //
         py::arg("count") = 10,           //
-        py::arg("exact") = false         //
+        py::arg("exact") = false,        //
+        py::arg("threads") = 0           //
     );
 
     i.def("__len__", &punned_py_t::size);
@@ -522,6 +537,10 @@ PYBIND11_MODULE(index, m) {
     i.def_property_readonly("capacity", &punned_py_t::capacity);
     i.def_property_readonly( //
         "dtype", [](punned_py_t const& index) -> std::string { return accuracy_name(index.accuracy()); });
+    i.def_property_readonly("memory_usage", &punned_py_t::memory_usage);
+
+    i.def_property("expansion_add", &get_expansion_add<punned_py_t>, &punned_py_t::change_expansion_add);
+    i.def_property("expansion_search", &get_expansion_search<punned_py_t>, &punned_py_t::change_expansion_search);
 
     i.def("save", &save_index<punned_py_t>, py::arg("path"));
     i.def("load", &load_index<punned_py_t>, py::arg("path"));

package/python/scripts/bench.py

@@ -142,7 +142,7 @@ def main(
             expansion_add=expansion_add,
             expansion_search=expansion_search,
             connectivity=connectivity,
-            metric_pointer=inner_product_f32.address,
+            metric=inner_product_f32.address,
         )
         bench_usearch(index, vectors_mat, queries_mat, neighbors_mat)
 
@@ -153,7 +153,7 @@ def main(
             expansion_add=expansion_add,
             expansion_search=expansion_search,
             connectivity=connectivity,
-            metric_pointer=cos_f8.address,
+            metric=cos_f8.address,
         )
         bench_usearch(index, vectors_mat, queries_mat, neighbors_mat)
     except ImportError:

package/python/scripts/test.py

@@ -86,7 +86,7 @@ def test_user_defined_function(ndim: int, size: int):
             c += a_array[i] * b_array[i]
         return c
 
-    index = Index(ndim=ndim, metric_pointer=python_dot.address)
+    index = Index(ndim=ndim, metric=python_dot.address)
 
     vectors = np.random.uniform(
         0, 0.3, (size, index.ndim)).astype(np.float32)

package/python/usearch/index.py

@@ -0,0 +1,298 @@
+# The purpose of this file is to provide Pythonic wrapper on top
+# the native precompiled CPython module. It improves compatibility
+# Python tooling, linters, and static analyzers. It also embeds JIT
+# into the primary `Index` class, connecting USearch with Numba.
+import os
+from math import sqrt
+from typing import Optional, Callable, Union
+
+import numpy as np
+
+from usearch.compiled import Index as _CompiledIndex
+from usearch.compiled import SetsIndex as _CompiledSetsIndex
+from usearch.compiled import HashIndex as _CompiledHashIndex
+from usearch.compiled import DEFAULT_CONNECTIVITY, DEFAULT_EXPANSION_ADD, DEFAULT_EXPANSION_SEARCH
+
+Triplet = tuple[np.ndarray, np.ndarray, np.ndarray]
+SetsIndex = _CompiledSetsIndex
+HashIndex = _CompiledHashIndex
+
+
+def results_to_list(results: Triplet, row: int) -> list[dict]:
+
+    count = results[2][row]
+    labels = results[0][row, :count]
+    distances = results[1][row, :count]
+    return [
+        {'label': int(label), 'distance': float(distance)}
+        for label, distance in zip(labels, distances)
+    ]
+
+
+def jit_metric(ndim: int, metric_name: str, accuracy: str = 'f32') -> Callable:
+
+    try:
+        from numba import cfunc, types, carray
+    except ImportError:
+        raise ModuleNotFoundError(
+            'To use JIT install Numba with `pip install numba`.'
+            'Alternatively, reinstall usearch with `pip install usearch[jit]`')
+
+    # Showcases how to use Numba to JIT-compile similarity measures for USearch.
+    # https://numba.readthedocs.io/en/stable/reference/jit-compilation.html#c-callbacks
+
+    if accuracy == 'f32':
+        signature = types.float32(
+            types.CPointer(types.float32),
+            types.CPointer(types.float32),
+            types.size_t, types.size_t)
+
+        if metric_name == 'ip':
+
+            def numba_ip(a, b, _n, _m):
+                a_array = carray(a, ndim)
+                b_array = carray(b, ndim)
+                ab = 0.0
+                for i in range(ndim):
+                    ab += a_array[i] * b_array[i]
+                return ab
+
+            return cfunc(numba_ip, signature)
+
+        if metric_name == 'cos':
+
+            def numba_cos(a, b, _n, _m):
+                a_array = carray(a, ndim)
+                b_array = carray(b, ndim)
+                ab = 0.0
+                a_sq = 0.0
+                b_sq = 0.0
+                for i in range(ndim):
+                    ab += a_array[i] * b_array[i]
+                    a_sq += a_array[i] * a_array[i]
+                    b_sq += b_array[i] * b_array[i]
+                return ab / (sqrt(a_sq) * sqrt(b_sq))
+
+            return cfunc(numba_cos, signature)
+
+        if metric_name == 'l2sq':
+
+            def numba_l2sq(a, b, _n, _m):
+                a_array = carray(a, ndim)
+                b_array = carray(b, ndim)
+                ab_delta_sq = 0.0
+                for i in range(ndim):
+                    ab_delta_sq += (a_array[i] - b_array[i]) * \
+                        (a_array[i] - b_array[i])
+                return ab_delta_sq
+
+            return cfunc(numba_l2sq, signature)
+
+    return None
+
+
+class Index:
+    """Fast JIT-compiled index for equi-dimensional embeddings.
+
+    Vector labels must be integers.
+    Vectors must have the same number of dimensions within the index.
+    Supports Inner Product, Cosine Distance, Ln measures
+    like the Euclidean metric, as well as automatic downcasting
+    and quantization.
+    """
+
+    def __init__(
+        self,
+        ndim: int,
+        dtype: str = 'f32',
+        metric: Union[str, int] = 'ip',
+        jit: bool = False,
+
+        connectivity: int = DEFAULT_CONNECTIVITY,
+        expansion_add: int = DEFAULT_EXPANSION_ADD,
+        expansion_search: int = DEFAULT_EXPANSION_SEARCH,
+        tune: bool = False,
+
+        path: Optional[os.PathLike] = None,
+        view: bool = False,
+    ) -> None:
+        """Construct the index and compiles the functions, if requested (expensive).
+
+        :param ndim: Number of vector dimensions
+        :type ndim: int
+        :param dtype: Scalar type for vectors, defaults to 'f32'
+        :type dtype: str, optional
+            Example: you can use the `f16` index with `f32` vectors,
+            which will be automatically downcasted.
+
+        :param metric: Distance function, defaults to 'ip'
+        :type metric: Union[str, int], optional
+            Name of distance function, or the address of the
+            Numba `cfunc` JIT-compiled object.
+
+        :param jit: Enable Numba to JIT compile the metric, defaults to False
+        :type jit: bool, optional
+            This can result in up-to 3x performance difference on very large vectors
+            and very recent hardware, as the Python module is compiled with high
+            compatibility in mind and avoids very fancy assembly instructions.
+
+        :param connectivity: Connections per node in HNSW, defaults to None
+        :type connectivity: Optional[int], optional
+            Hyper-parameter for the number of Graph connections
+            per layer of HNSW. The original paper calls it "M".
+            Optional, but can't be changed after construction.
+
+        :param expansion_add: Traversal depth on insertions, defaults to None
+        :type expansion_add: Optional[int], optional
+            Hyper-parameter for the search depth when inserting new
+            vectors. The original paper calls it "efConstruction".
+            Can be changed afterwards, as the `.expansion_add`.
+
+        :param expansion_search: Traversal depth on queries, defaults to None
+        :type expansion_search: Optional[int], optional
+            Hyper-parameter for the search depth when querying 
+            nearest neighbors. The original paper calls it "ef".
+            Can be changed afterwards, as the `.expansion_search`.
+
+        :param tune: Automatically adjusts hyper-parameters, defaults to False
+        :type tune: bool, optional
+
+        :param path: Where to store the index, defaults to None
+        :type path: Optional[os.PathLike], optional
+        :param view: Are we simply viewing an immutable index, defaults to False
+        :type view: bool, optional
+        """
+        if jit:
+            assert isinstance(metric, str), 'Name the metric to JIT'
+            self._metric_name = metric
+            self._metric_jit = jit_metric(
+                ndim=ndim,
+                metric_name=metric,
+                dtype=dtype,
+            )
+            self._metric_pointer = self._metric_jit.address if \
+                self._metric_jit else 0
+
+        elif isinstance(metric, int):
+            self._metric_name = ''
+            self._metric_jit = None
+            self._metric_pointer = metric
+
+        else:
+            if metric is None:
+                metric = 'ip'
+            assert isinstance(metric, str)
+            self._metric_name = metric
+            self._metric_jit = None
+            self._metric_pointer = 0
+
+        self._compiled = _CompiledIndex(
+            ndim=ndim,
+            metric=self._metric_name,
+            metric_pointer=self._metric_pointer,
+            dtype=dtype,
+            connectivity=connectivity,
+            expansion_add=expansion_add,
+            expansion_search=expansion_search,
+            tune=tune,
+        )
+
+        self.path = path
+        if path and os.path.exists(path):
+            if view:
+                self._compiled.view(path)
+            else:
+                self._compiled.load(path)
+
+    def add(
+            self, labels, vectors, *,
+            copy: bool = True, threads: int = 0):
+        """Inserts one or move vectors into the index.
+
+        For maximal performance the `labels` and `vectors`
+        should conform to the Python's "buffer protocol" spec.
+
+        To index a single entry: 
+            labels: int, vectors: np.ndarray.
+        To index many entries: 
+            labels: np.ndarray, vectors: np.ndarray.
+
+        When working with extremely large indexes, you may want to
+        pass `copy=False`, if you can guarantee the lifetime of the
+        primary vectors store during the process of construction.
+
+        :param labels: Unique identifier for passed vectors.
+        :type labels: Buffer
+        :param vectors: Collection of vectors.
+        :type vectors: Buffer
+        :param copy: Should the index store a copy of vectors, defaults to True
+        :type copy: bool, optional
+        :param threads: Optimal number of cores to use, defaults to 0
+        :type threads: int, optional
+        """
+        if isinstance(labels, np.ndarray):
+            labels = labels.astype(np.longlong)
+        self._compiled.add(labels, vectors, copy=copy, threads=threads)
+
+    def search(
+            self, vectors, k: int = 10, *,
+            threads: int = 0, exact: bool = False) -> Triplet:
+        return self._compiled.search(vectors, k, exact=exact, threads=threads)
+
+    def __len__(self) -> int:
+        return len(self._compiled)
+
+    @property
+    def size(self) -> int:
+        return self._compiled.size
+
+    @property
+    def ndim(self) -> int:
+        return self._compiled.ndim
+
+    @property
+    def dtype(self) -> str:
+        return self._compiled.dtype
+
+    @property
+    def connectivity(self) -> int:
+        return self._compiled.connectivity
+
+    @property
+    def capacity(self) -> int:
+        return self._compiled.capacity
+
+    @property
+    def memory_usage(self) -> int:
+        return self._compiled.memory_usage
+
+    @property
+    def expansion_add(self) -> int:
+        return self._compiled.expansion_add
+
+    @property
+    def expansion_search(self) -> int:
+        return self._compiled.expansion_search
+
+    @expansion_add.setter
+    def change_expansion_add(self, v: int):
+        self._compiled.expansion_add = v
+
+    @expansion_search.setter
+    def change_expansion_search(self, v: int):
+        self._compiled.expansion_search = v
+
+    def save(self, path: os.PathLike):
+        self._compiled.save(path)
+
+    def load(self, path: os.PathLike):
+        self._compiled.load(path)
+
+    def view(self, path: os.PathLike):
+        self._compiled.view(path)
+
+    def clear(self):
+        self._compiled.clear()
+
+    def remove(self, label: int):
+        pass

package/robin-map/.codecov.yml

@@ -0,0 +1,5 @@
+comment: off
+coverage:
+  status:
+    project: off
+    patch: off

package/robin-map/.github/workflows/ci.yml

@@ -0,0 +1,136 @@
+name: CI
+
+on: [push, pull_request, release]
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        config:
+        - {
+            name: linux-x64-gcc-7,
+            os: ubuntu-18.04,
+            cxx: g++-7,
+            cmake-build-type: Release
+          }
+        - {
+            name: linux-x64-gcc-7-no-exceptions,
+            os: ubuntu-18.04,
+            cxx: g++-7,
+            cxx-flags: -fno-exceptions,
+            cmake-build-type: Release
+          }
+        - {
+            name: linux-x64-clang-9,
+            os: ubuntu-18.04,
+            cxx: clang++-9,
+            cmake-build-type: Release
+          }
+        - {
+            name: macos-x64-gcc,
+            os:  macos-10.15,
+            cxx: g++,
+            cmake-build-type: Release
+          }
+        - {
+            name: macos-x64-clang,
+            os:  macos-10.15,
+            cxx: clang++,
+            cmake-build-type: Release
+          }
+        - {
+            name: linux-x64-clang-12-sanitize,
+            os: ubuntu-20.04,
+            cxx: clang++-12,
+            cxx-flags: "-fsanitize=address,undefined",
+            cmake-build-type: Release
+          }
+        - {
+            name: linux-x64-gcc-10-coverage,
+            os: ubuntu-20.04,
+            cxx: g++-10,
+            cxx-flags: --coverage,
+            gcov-tool: gcov-10,
+            cmake-build-type: Debug
+          }
+        - {
+            name: windows-x64-vs-2019,
+            os: windows-2019,
+            cmake-build-type: Release,
+            cmake-generator: Visual Studio 16 2019,
+            cmake-platform: x64,
+            vcpkg-triplet: x64-windows-static-md
+          }
+        - {
+            name: windows-x86-vs-2019,
+            os: windows-2019,
+            cmake-build-type: Release,
+            cmake-generator: Visual Studio 16 2019,
+            cmake-platform: Win32,
+            vcpkg-triplet: x86-windows-static-md
+          }
+        - {
+            name: windows-x64-vs-2022,
+            os: windows-2022,
+            cmake-build-type: Release,
+            cmake-generator: Visual Studio 17 2022,
+            cmake-platform: x64,
+            vcpkg-triplet: x64-windows-static-md
+          }
+        - {
+            name: windows-x86-vs-2022,
+            os: windows-2022,
+            cmake-build-type: Release,
+            cmake-generator: Visual Studio 17 2022,
+            cmake-platform: Win32,
+            vcpkg-triplet: x86-windows-static-md
+          }
+    name: ${{matrix.config.name}}
+    runs-on: ${{matrix.config.os}}
+    steps:
+    - uses: actions/checkout@v2
+
+    # Windows
+    - name: Install boost (Windows)
+      run: vcpkg install boost-test:${{matrix.config.vcpkg-triplet}}
+      if: runner.os == 'Windows'
+
+    - name: Configure CMake (Windows)
+      run: cmake -G "${{matrix.config.cmake-generator}}" -A ${{matrix.config.cmake-platform}} -DCMAKE_BUILD_TYPE=${{matrix.config.cmake-build-type}} -DCMAKE_TOOLCHAIN_FILE="$env:VCPKG_INSTALLATION_ROOT/scripts/buildsystems/vcpkg.cmake" -DVCPKG_TARGET_TRIPLET=${{matrix.config.vcpkg-triplet}} -S ${{github.workspace}}/tests -B ${{github.workspace}}/build
+      if: runner.os == 'Windows'
+
+    - name: Build (Windows)
+      run: cmake --build ${{github.workspace}}/build --config ${{matrix.config.cmake-build-type}} --verbose
+      if: runner.os == 'Windows'
+
+    - name: Test (Windows)
+      run: ${{github.workspace}}/build/${{matrix.config.cmake-build-type}}/tsl_robin_map_tests.exe
+      if: runner.os == 'Windows'
+
+    # Linux or macOS
+    - name: Install boost (Linux or macOS)
+      run: vcpkg install boost-test
+      if: runner.os == 'Linux' || runner.os == 'macOS'
+
+    - name: Configure CMake (Linux or macOS)
+      run: cmake -DCMAKE_BUILD_TYPE=${{matrix.config.cmake-build-type}} -DCMAKE_TOOLCHAIN_FILE="$VCPKG_INSTALLATION_ROOT/scripts/buildsystems/vcpkg.cmake" -S ${{github.workspace}}/tests -B ${{github.workspace}}/build
+      env:
+        CXX: ${{matrix.config.cxx}}
+        CXXFLAGS: ${{matrix.config.cxx-flags}}
+      if: runner.os == 'Linux' || runner.os == 'macOS'
+
+    - name: Build (Linux or macOS)
+      run: cmake --build ${{github.workspace}}/build --verbose
+      if: runner.os == 'Linux' || runner.os == 'macOS'
+
+    - name: Test (Linux or macOS)
+      run: ${{github.workspace}}/build/tsl_robin_map_tests
+      if: runner.os == 'Linux' || runner.os == 'macOS'
+
+    - name: Coverage
+      run: |
+        sudo apt-get install -y lcov
+        lcov -c -b ${{github.workspace}}/include -d ${{github.workspace}}/build -o ${{github.workspace}}/coverage.info --no-external --gcov-tool ${{matrix.config.gcov-tool}}
+        bash <(curl -s https://codecov.io/bash) -f ${{github.workspace}}/coverage.info
+      if: ${{matrix.config.name == 'linux-x64-gcc-10-coverage'}}