usearch 0.11.0 → 0.12.0

package/python/scripts/test.py

@@ -1,31 +1,71 @@
+import os
 import pytest
 import numpy as np
 
-from usearch.io import load_matrix
-from usearch.index import Index, SetsIndex
+from usearch.io import load_matrix, save_matrix
+from usearch.index import Index, SetsIndex, MetricKind
+
 
 dimensions = [13, 99, 100, 256]
-sizes = [1, 2, 100]
-index_types = ['f64', 'f32', 'f16', 'f8']
-numpy_types = [np.float64, np.float32, np.float16, np.byte]
-connectivities = [3, 13, 50]
+batch_sizes = [1, 2, 100]
+index_types = ['f32', 'f64', 'f16', 'f8']
+numpy_types = [np.float32, np.float64, np.float16, np.byte]
+connectivity_options = [3, 13, 50]
+jit_options = [False]
+continuous_metrics = [
+    MetricKind.Cos,
+    MetricKind.L2sq,
+]
+hash_metrics = [
+    MetricKind.BitwiseHamming,
+    MetricKind.BitwiseTanimoto,
+    MetricKind.BitwiseSorensen,
+]
+
+
+@pytest.mark.parametrize('rows', batch_sizes)
+@pytest.mark.parametrize('cols', dimensions)
+def test_serializing_fbin_matrix(rows: int, cols: int):
+    original = np.random.rand(rows, cols).astype(np.float32)
+    save_matrix(original, 'tmp.fbin')
+    reconstructed = load_matrix('tmp.fbin')
+    assert np.allclose(original, reconstructed)
+    os.remove('tmp.fbin')
+
+
+@pytest.mark.parametrize('rows', batch_sizes)
+@pytest.mark.parametrize('cols', dimensions)
+def test_serializing_ibin_matrix(rows: int, cols: int):
+    original = np.random.randint(0, rows+1, size=(rows, cols)).astype(np.int32)
+    save_matrix(original, 'tmp.ibin')
+    reconstructed = load_matrix('tmp.ibin')
+    assert np.allclose(original, reconstructed)
+    os.remove('tmp.ibin')
 
 
 @pytest.mark.parametrize('ndim', dimensions)
+@pytest.mark.parametrize('metric', continuous_metrics)
 @pytest.mark.parametrize('index_type', index_types)
 @pytest.mark.parametrize('numpy_type', numpy_types)
-@pytest.mark.parametrize('connectivity', connectivities)
-def test_l2sq(ndim: int, index_type: str, numpy_type: str, connectivity: int):
+@pytest.mark.parametrize('connectivity', connectivity_options)
+@pytest.mark.parametrize('jit', jit_options)
+def test_index(
+        ndim: int, metric: MetricKind,
+        index_type: str, numpy_type: str,
+        connectivity: int, jit: bool):
+
     index = Index(
-        metric='l2sq',
+        metric=metric,
         ndim=ndim,
         dtype=index_type,
         connectivity=connectivity,
+        jit=jit,
     )
     assert index.ndim == ndim
     assert index.connectivity == connectivity
 
-    vector = np.random.uniform(0, 0.7, (index.ndim)).astype(numpy_type)
+    limit = 0.7 if numpy_type != np.byte else 70
+    vector = np.random.uniform(0, limit, (index.ndim)).astype(numpy_type)
     index.add(42, vector)
     matches, distances, count = index.search(vector, 10)
 
@@ -45,25 +85,31 @@ def test_l2sq(ndim: int, index_type: str, numpy_type: str, connectivity: int):
 
 
 @pytest.mark.parametrize('ndim', dimensions)
-@pytest.mark.parametrize('size', sizes)
+@pytest.mark.parametrize('metric', continuous_metrics)
+@pytest.mark.parametrize('batch_size', batch_sizes)
 @pytest.mark.parametrize('index_type', index_types)
 @pytest.mark.parametrize('numpy_type', numpy_types)
-def test_l2sq_batch(ndim: int, size: int, index_type: str, numpy_type: str):
-    index = Index(ndim=ndim, metric='l2sq', dtype=index_type)
+def test_index_batch(
+        ndim: int, metric: MetricKind,
+        batch_size: int, index_type: str, numpy_type: str):
 
-    vectors = np.random.uniform(0, 0.7, (size, index.ndim)).astype(numpy_type)
-    labels = np.array(range(size), dtype=np.longlong)
+    index = Index(ndim=ndim, metric=metric, dtype=index_type)
+
+    limit = 0.7 if numpy_type != np.byte else 70
+    vectors = np.random.uniform(
+        0, limit, (batch_size, index.ndim)).astype(numpy_type)
+    labels = np.array(range(batch_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
+    assert count.shape[0] == batch_size
 
 
 @pytest.mark.parametrize('ndim', dimensions)
-@pytest.mark.parametrize('size', sizes)
-def test_user_defined_function(ndim: int, size: int):
+@pytest.mark.parametrize('batch_size', batch_sizes)
+def test_index_udf(ndim: int, batch_size: int):
 
     try:
         from numba import cfunc, types, carray
@@ -86,27 +132,40 @@ def test_user_defined_function(ndim: int, size: int):
             c += a_array[i] * b_array[i]
         return c
 
-    index = Index(ndim=ndim, metric=python_dot.address)
+    index = Index(ndim=ndim, metric=python_dot)
 
     vectors = np.random.uniform(
-        0, 0.3, (size, index.ndim)).astype(np.float32)
-    labels = np.array(range(size), dtype=np.longlong)
+        0, 0.3, (batch_size, index.ndim)).astype(np.float32)
+    labels = np.array(range(batch_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
+    assert count.shape[0] == batch_size
 
 
-def test_sets():
+@pytest.mark.parametrize('connectivity', connectivity_options)
+def test_sets_index(connectivity: int):
 
-    index = SetsIndex()
+    index = SetsIndex(connectivity=connectivity)
     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), 10)
-    # assert list(results) == [10, 11]
+    results = index.search(np.array([12, 15], dtype=np.uint32), 10)
+    assert list(results) == [10, 11]
+
+
+@pytest.mark.parametrize('bits', dimensions)
+@pytest.mark.parametrize('metric', hash_metrics)
+@pytest.mark.parametrize('connectivity', connectivity_options)
+@pytest.mark.parametrize('batch_size', batch_sizes)
+def test_hash_index(bits: int, metric: MetricKind, connectivity: int, batch_size: int):
+
+    index = Index(ndim=bits, metric=metric, connectivity=connectivity)
 
+    bit_vectors = np.random.randint(2, size=(batch_size, bits))
+    bit_vectors = np.packbits(bit_vectors, axis=1)
+    labels = np.array(range(batch_size), dtype=np.longlong)
 
-if __name__ == '__main__':
-    pass
+    index.add(labels, bit_vectors)
+    index.search(bit_vectors, 10)

package/python/usearch/client.py

@@ -1,8 +1,10 @@
-from typing import Union, Optional
+from typing import Union, Optional, List
 
 import numpy as np
 from ucall.client import Client
 
+from usearch.index import Matches
+
 
 def _vector_to_ascii(vector: np.ndarray) -> Optional[str]:
     if vector.dtype != np.int8 and vector.dtype != np.uint8 and vector.dtype != np.byte:
@@ -18,9 +20,6 @@ def _vector_to_ascii(vector: np.ndarray) -> Optional[str]:
     return ascii
 
 
-Triplet = tuple[np.ndarray, np.ndarray, np.ndarray]
-
-
 class IndexClient:
 
     def __init__(
@@ -53,8 +52,8 @@ class IndexClient:
         else:
             return self.add_many(labels, vectors)
 
-    def search_one(self, vector: np.ndarray, count: int) -> Triplet:
-        matches: list[dict] = []
+    def search_one(self, vector: np.ndarray, count: int) -> Matches:
+        matches: List[dict] = []
         vector = vector.flatten()
         ascii = _vector_to_ascii(vector)
         if ascii:
@@ -75,9 +74,9 @@ class IndexClient:
 
         return labels, distances, counts
 
-    def search_many(self, vectors: np.ndarray, count: int) -> Triplet:
+    def search_many(self, vectors: np.ndarray, count: int) -> Matches:
         batch_size: int = vectors.shape[0]
-        list_of_matches: list[list[dict]] = self.client.search_many(
+        list_of_matches: List[List[dict]] = self.client.search_many(
             vectors=vectors, count=count)
 
         labels = np.array((batch_size, count), dtype=np.uint32)
@@ -91,7 +90,7 @@ class IndexClient:
 
         return labels, distances, counts
 
-    def search(self, vectors: np.ndarray, count: int) -> Triplet:
+    def search(self, vectors: np.ndarray, count: int) -> Matches:
         if vectors.ndim == 1 or (vectors.ndim == 2 and vectors.shape[0] == 1):
             return self.search_one(vectors, count)
         else:

package/python/usearch/index.py

@@ -4,21 +4,37 @@
 # into the primary `Index` class, connecting USearch with Numba.
 import os
 from math import sqrt
-from typing import Optional, Callable, Union
+from typing import Optional, Callable, Union, NamedTuple, List
 
 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
+from usearch.compiled import BitsIndex as _CompiledBitsIndex
+
+from usearch.compiled import MetricKind
+from usearch.compiled import (
+    DEFAULT_CONNECTIVITY,
+    DEFAULT_EXPANSION_ADD,
+    DEFAULT_EXPANSION_SEARCH,
+)
+
+BitwiseMetricKind = (
+    MetricKind.BitwiseHamming,
+    MetricKind.BitwiseTanimoto,
+    MetricKind.BitwiseSorensen,
+)
 
-Triplet = tuple[np.ndarray, np.ndarray, np.ndarray]
 SetsIndex = _CompiledSetsIndex
-HashIndex = _CompiledHashIndex
 
 
-def results_to_list(results: Triplet, row: int) -> list[dict]:
+class Matches(NamedTuple):
+    labels: np.ndarray
+    distances: np.ndarray
+    counts: np.ndarray
+
+
+def list_matches(results: Matches, row: int) -> List[dict]:
 
     count = results[2][row]
     labels = results[0][row, :count]
@@ -29,7 +45,7 @@ def results_to_list(results: Triplet, row: int) -> list[dict]:
     ]
 
 
-def jit_metric(ndim: int, metric_name: str, accuracy: str = 'f32') -> Callable:
+def jit_metric(ndim: int, metric: MetricKind, dtype: str = 'f32') -> Callable:
 
     try:
         from numba import cfunc, types, carray
@@ -41,26 +57,28 @@ def jit_metric(ndim: int, metric_name: str, accuracy: str = 'f32') -> Callable:
     # 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':
+    if dtype == 'f32':
         signature = types.float32(
             types.CPointer(types.float32),
             types.CPointer(types.float32),
             types.size_t, types.size_t)
 
-        if metric_name == 'ip':
+        if metric == MetricKind.IP:
 
+            @cfunc(signature)
             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 1 - ab
 
-            return cfunc(numba_ip, signature)
+            return numba_ip
 
-        if metric_name == 'cos':
+        if metric == MetricKind.Cos:
 
+            @cfunc(signature)
             def numba_cos(a, b, _n, _m):
                 a_array = carray(a, ndim)
                 b_array = carray(b, ndim)
@@ -71,28 +89,36 @@ def jit_metric(ndim: int, metric_name: str, accuracy: str = 'f32') -> Callable:
                     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))
+                a_norm = sqrt(a_sq)
+                b_norm = sqrt(b_sq)
+                if a_norm == 0 and b_norm == 0:
+                    return 0
+                elif a_norm == 0 or b_norm == 0 or ab == 0:
+                    return 1
+                else:
+                    return 1 - ab / (a_norm * b_norm)
 
-            return cfunc(numba_cos, signature)
+            return numba_cos
 
-        if metric_name == 'l2sq':
+        if metric == MetricKind.L2sq:
 
+            @cfunc(signature)
             def numba_l2sq(a, b, _n, _m):
                 a_array = carray(a, ndim)
                 b_array = carray(b, ndim)
-                ab_delta_sq = 0.0
+                ab_delta_sq = types.float32(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 numba_l2sq
 
     return None
 
 
 class Index:
-    """Fast JIT-compiled index for equi-dimensional embeddings.
+    """Fast JIT-compiled vector-search index for dense equi-dimensional embeddings.
 
     Vector labels must be integers.
     Vectors must have the same number of dimensions within the index.
@@ -104,8 +130,8 @@ class Index:
     def __init__(
         self,
         ndim: int,
-        dtype: str = 'f32',
-        metric: Union[str, int] = 'ip',
+        metric: Union[MetricKind, Callable] = MetricKind.IP,
+        dtype: Optional[str] = None,
         jit: bool = False,
 
         connectivity: int = DEFAULT_CONNECTIVITY,
@@ -120,16 +146,21 @@ class Index:
 
         :param ndim: Number of vector dimensions
         :type ndim: int
-        :param dtype: Scalar type for vectors, defaults to 'f32'
+
+        :param metric: Distance function, defaults to MetricKind.IP
+        :type metric: Union[MetricKind, Callable], optional
+            Kind of the distance function, or the Numba `cfunc` JIT-compiled object.
+            Possible `MetricKind` values: IP, Cosine, L2sq, Haversine, 
+            Hamming, Tanimoto, Sorensen.
+            Not every kind is JIT-able.
+
+        :param dtype: Scalar type for internal vector storage, defaults to None
         :type dtype: str, optional
-            Example: you can use the `f16` index with `f32` vectors,
+            For continuous metrics can be: f16, f32, f64, or f8.
+            For bitwise metrics it's implementation-defined, and can't change.
+            Example: you can use the `f16` index with `f32` vectors in Euclidean space,
             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
@@ -162,40 +193,54 @@ class Index:
         :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(
+
+        if metric is None:
+            metric = MetricKind.IP
+
+        if isinstance(metric, Callable):
+            self._metric_kind = MetricKind.Unknown
+            self._metric_jit = metric
+            self._metric_pointer = int(metric.address)
+
+        elif isinstance(metric, MetricKind):
+            if jit:
+                self._metric_kind = metric
+                self._metric_jit = jit_metric(
+                    ndim=ndim,
+                    metric_kind=metric,
+                    dtype=dtype,
+                )
+                self._metric_pointer = self._metric_jit.address if \
+                    self._metric_jit else 0
+            else:
+                self._metric_kind = metric
+                self._metric_jit = None
+                self._metric_pointer = 0
+        else:
+            raise ValueError(
+                'The `metric` must be Numba callback or a `MetricKind`')
+
+        if metric in BitwiseMetricKind:
+            self._compiled = _CompiledBitsIndex(
+                bits=ndim,
+                metric=self._metric_kind,
+                connectivity=connectivity,
+                expansion_add=expansion_add,
+                expansion_search=expansion_search,
+            )
+        else:
+            if dtype is None:
+                dtype = 'f32'
+            self._compiled = _CompiledIndex(
                 ndim=ndim,
-                metric_name=metric,
+                metric=self._metric_kind,
+                metric_pointer=self._metric_pointer,
                 dtype=dtype,
+                connectivity=connectivity,
+                expansion_add=expansion_add,
+                expansion_search=expansion_search,
+                tune=tune,
             )
-            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):
@@ -230,18 +275,56 @@ class Index:
         :param threads: Optimal number of cores to use, defaults to 0
         :type threads: int, optional
         """
+        assert isinstance(vectors, np.ndarray), 'Expects a NumPy array'
+        assert vectors.ndim == 1 or vectors.ndim == 2, 'Expects a matrix or vector'
+        is_batch = vectors.ndim == 2
+        generate_labels = labels is None
+
+        # If no `labels` were provided, generate some
+        if generate_labels:
+            start_id = len(self._compiled)
+            if is_batch:
+                labels = np.arange(start_id, start_id + vectors.shape[0])
+            else:
+                labels = start_id
         if isinstance(labels, np.ndarray):
             labels = labels.astype(np.longlong)
+
         self._compiled.add(labels, vectors, copy=copy, threads=threads)
 
+        if generate_labels:
+            return labels
+
     def search(
             self, vectors, k: int = 10, *,
-            threads: int = 0, exact: bool = False) -> Triplet:
-        return self._compiled.search(vectors, k, exact=exact, threads=threads)
+            threads: int = 0, exact: bool = False) -> Matches:
+        """Performs approximate nearest neighbors search for one or more queries.
+
+        :param vectors: Query vector or vectors.
+        :type vectors: Buffer
+        :param k: Upper limit on the number of matches to find, defaults to 10
+        :type k: int, optional
+
+        :param threads: Optimal number of cores to use, defaults to 0
+        :type threads: int, optional
+        :param exact: Perform exhaustive linear-time exact search, defaults to False
+        :type exact: bool, optional
+        :return: Approximate matches for one or more queries
+        :rtype: Matches
+        """
+        tuple_ = self._compiled.search(
+            vectors, k,
+            exact=exact, threads=threads,
+        )
+        return Matches(*tuple_)
 
     def __len__(self) -> int:
         return len(self._compiled)
 
+    @property
+    def jit(self) -> bool:
+        return self._metric_jit is not None
+
     @property
     def size(self) -> int:
         return self._compiled.size

package/python/usearch/server.py

@@ -4,20 +4,10 @@
 import os
 import argparse
 import numpy as np
+from typing import List
 
 from ucall.rich_posix import Server
-from usearch.index import Index
-
-Triplet = tuple[np.ndarray, np.ndarray, np.ndarray]
-
-
-def _results_to_json(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)]
+from usearch.index import Index, list_matches
 
 
 def _ascii_to_vector(string: str) -> np.ndarray:
@@ -78,16 +68,16 @@ def serve(
         index.add(labels, vectors, threads=threads)
 
     @server
-    def search_one(vector: np.ndarray, count: int) -> list[dict]:
+    def search_one(vector: np.ndarray, count: int) -> List[dict]:
         print('search', vector, count)
         vectors = vector.reshape(vector.shape[0], 1)
         results = index.search(vectors, count)
-        return _results_to_json(results, 0)
+        return list_matches(results, 0)
 
     @server
-    def search_many(vectors: np.ndarray, count: int) -> list[list[dict]]:
+    def search_many(vectors: np.ndarray, count: int) -> List[List[dict]]:
         results = index.search(vectors, count)
-        return [_results_to_json(results, i) for i in range(vectors.shape[0])]
+        return [list_matches(results, i) for i in range(vectors.shape[0])]
 
     @server
     def add_ascii(label: int, string: str):

package/rust/lib.cpp

@@ -5,44 +5,50 @@ using namespace unum::usearch;
 using namespace unum;
 
 using punned_t = typename Index::punned_t;
+using add_result_t = typename punned_t::add_result_t;
+using search_result_t = typename punned_t::search_result_t;
+using serialization_result_t = typename punned_t::serialization_result_t;
 
-Index::Index(std::shared_ptr<punned_t> index) : index_(index) {}
+Index::Index(std::unique_ptr<punned_t> index) : index_(std::move(index)) {}
 
 void Index::add_in_thread(uint32_t label, rust::Slice<float const> vector, size_t thread) const {
     add_config_t config;
     config.thread = thread;
-    index_->add(label, vector.data(), config);
+    index_->add(label, vector.data(), config).error.raise();
 }
 
 Matches Index::search_in_thread(rust::Slice<float const> vector, size_t count, size_t thread) const {
-    Matches results;
-    results.labels.reserve(count);
-    results.distances.reserve(count);
+    Matches matches;
+    matches.labels.reserve(count);
+    matches.distances.reserve(count);
     for (size_t i = 0; i != count; ++i)
-        results.labels.push_back(0), results.distances.push_back(0);
+        matches.labels.push_back(0), matches.distances.push_back(0);
     search_config_t config;
     config.thread = thread;
-    results.count =
-        index_->search(vector.data(), count, config).dump_to(results.labels.data(), results.distances.data());
-    results.labels.truncate(results.count);
-    results.distances.truncate(results.count);
-    return results;
+    search_result_t result = index_->search(vector.data(), count, config);
+    result.error.raise();
+    matches.count = result.dump_to(matches.labels.data(), matches.distances.data());
+    matches.labels.truncate(matches.count);
+    matches.distances.truncate(matches.count);
+    return matches;
 }
 
 void Index::add(uint32_t label, rust::Slice<float const> vector) const {
-    index_->add(label, vector.data()); //
+    index_->add(label, vector.data()).error.raise();
 }
 
 Matches Index::search(rust::Slice<float const> vector, size_t count) const {
-    Matches results;
-    results.labels.reserve(count);
-    results.distances.reserve(count);
+    Matches matches;
+    matches.labels.reserve(count);
+    matches.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).dump_to(results.labels.data(), results.distances.data());
-    results.labels.truncate(results.count);
-    results.distances.truncate(results.count);
-    return results;
+        matches.labels.push_back(0), matches.distances.push_back(0);
+    search_result_t result = index_->search(vector.data(), count);
+    result.error.raise();
+    matches.count = result.dump_to(matches.labels.data(), matches.distances.data());
+    matches.labels.truncate(matches.count);
+    matches.distances.truncate(matches.count);
+    return matches;
 }
 
 void Index::reserve(size_t capacity) const { index_->reserve(capacity); }
@@ -59,12 +65,15 @@ void Index::view(rust::Str path) const { index_->view(std::string(path).c_str())
 accuracy_t accuracy(rust::Str quant) { return accuracy_from_name(quant.data(), quant.size()); }
 
 std::unique_ptr<Index> wrap(punned_t&& index) {
-    std::shared_ptr<punned_t> native = std::make_shared<punned_t>(std::move(index));
-    return std::unique_ptr<Index>(new Index(native));
+    std::unique_ptr<punned_t> punned_ptr;
+    punned_ptr.reset(new punned_t(std::move(index)));
+    std::unique_ptr<Index> result;
+    result.reset(new Index(std::move(punned_ptr)));
+    return result;
 }
 
-config_t config(size_t connectivity, size_t exp_add, size_t exp_search) {
-    config_t result;
+index_config_t config(size_t connectivity, size_t exp_add, size_t exp_search) {
+    index_config_t result;
     result.connectivity = connectivity ? connectivity : default_connectivity();
     result.expansion_add = exp_add ? exp_add : default_expansion_add();
     result.expansion_search = exp_search ? exp_search : default_expansion_search();