usearch 0.13.0 → 0.15.0

package/python/usearch/index.py

@@ -4,28 +4,60 @@
 # into the primary `Index` class, connecting USearch with Numba.
 import os
 from math import sqrt
-from typing import Optional, Callable, Union, NamedTuple, List
+from typing import Optional, Callable, Union, NamedTuple, List, Iterable
 
 import numpy as np
 
 from usearch.compiled import Index as _CompiledIndex
-from usearch.compiled import SetsIndex as _CompiledSetsIndex
-from usearch.compiled import BitsIndex as _CompiledBitsIndex
+from usearch.compiled import SparseIndex as _CompiledSetsIndex
 
-from usearch.compiled import MetricKind
+from usearch.compiled import MetricKind, ScalarKind
 from usearch.compiled import (
     DEFAULT_CONNECTIVITY,
     DEFAULT_EXPANSION_ADD,
     DEFAULT_EXPANSION_SEARCH,
+
+    USES_OPENMP,
+    USES_SIMSIMD,
 )
 
-BitwiseMetricKind = (
-    MetricKind.BitwiseHamming,
-    MetricKind.BitwiseTanimoto,
-    MetricKind.BitwiseSorensen,
+MetricKindBitwise = (
+    MetricKind.Hamming,
+    MetricKind.Tanimoto,
+    MetricKind.Sorensen,
 )
 
-SetsIndex = _CompiledSetsIndex
+SparseIndex = _CompiledSetsIndex
+
+Label = np.longlong
+
+
+def _normalize_dtype(dtype) -> ScalarKind:
+    if dtype is None:
+        return ScalarKind.F32
+    if isinstance(dtype, ScalarKind):
+        return dtype
+
+    if isinstance(dtype, str):
+        _normalize = {
+            'f64': ScalarKind.F64,
+            'f32': ScalarKind.F32,
+            'f16': ScalarKind.F16,
+            'f8': ScalarKind.F8,
+            'b1': ScalarKind.B1,
+        }
+        return _normalize[dtype.lower()]
+
+    if not isinstance(dtype, ScalarKind):
+        _normalize = {
+            np.float64: ScalarKind.F64,
+            np.float32: ScalarKind.F32,
+            np.float16: ScalarKind.F16,
+            np.int8: ScalarKind.F8,
+        }
+        return _normalize[dtype]
+
+    return dtype
 
 
 class Matches(NamedTuple):
@@ -65,83 +97,15 @@ class Matches(NamedTuple):
             for label, distance in zip(labels, distances)
         ]
 
+    def recall_first(self, expected: np.ndarray) -> float:
+        best_matches = self.labels if not self.is_batch else self.labels[:, 0]
+        return np.sum(best_matches == expected) / len(expected)
+
     def __repr__(self) -> str:
         return f'usearch.Matches({self.total_matches})' if self.is_batch else \
             f'usearch.Matches({self.total_matches} across {self.batch_size} queries)'
 
 
-def jit_metric(ndim: int, metric: MetricKind, dtype: 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 dtype == 'f32':
-        signature = types.float32(
-            types.CPointer(types.float32),
-            types.CPointer(types.float32),
-            types.uint64, types.uint64)
-
-        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 1 - ab
-
-            return numba_ip
-
-        if metric == MetricKind.Cos:
-
-            @cfunc(signature)
-            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]
-                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 numba_cos
-
-        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 = 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 numba_l2sq
-
-    return None
-
-
 class Index:
     """Fast JIT-compiled vector-search index for dense equi-dimensional embeddings.
 
@@ -155,7 +119,7 @@ class Index:
     def __init__(
         self,
         ndim: int,
-        metric: Union[MetricKind, Callable] = MetricKind.IP,
+        metric: Union[MetricKind, Callable, str] = MetricKind.IP,
         dtype: Optional[str] = None,
         jit: bool = False,
 
@@ -173,11 +137,11 @@ class Index:
         :type ndim: int
 
         :param metric: Distance function, defaults to MetricKind.IP
-        :type metric: Union[MetricKind, Callable], optional
+        :type metric: Union[MetricKind, Callable, str], optional
             Kind of the distance function, or the Numba `cfunc` JIT-compiled object.
             Possible `MetricKind` values: IP, Cos, L2sq, Haversine, Pearson,
-            BitwiseHamming, BitwiseTanimoto, BitwiseSorensen.
-            Not every kind is JIT-able. For Jaccard distance, use `SetsIndex`.
+            Hamming, Tanimoto, Sorensen.
+            Not every kind is JIT-able. For Jaccard distance, use `SparseIndex`.
 
         :param dtype: Scalar type for internal vector storage, defaults to None
         :type dtype: str, optional
@@ -221,6 +185,18 @@ class Index:
 
         if metric is None:
             metric = MetricKind.IP
+        elif isinstance(metric, str):
+            _normalize = {
+                'cos': MetricKind.Cos,
+                'ip': MetricKind.IP,
+                'l2_sq': MetricKind.L2sq,
+                'haversine': MetricKind.Haversine,
+                'perason': MetricKind.Pearson,
+                'hamming': MetricKind.Hamming,
+                'tanimoto': MetricKind.Tanimoto,
+                'sorensen': MetricKind.Sorensen,
+            }
+            metric = _normalize[metric.lower()]
 
         if isinstance(metric, Callable):
             self._metric_kind = MetricKind.Unknown
@@ -229,10 +205,18 @@ class Index:
 
         elif isinstance(metric, MetricKind):
             if jit:
+
+                try:
+                    from usearch.numba import jit
+                except ImportError:
+                    raise ModuleNotFoundError(
+                        'To use JIT install Numba with `pip install numba`.'
+                        'Alternatively, reinstall usearch with `pip install usearch[jit]`')
+
                 self._metric_kind = metric
-                self._metric_jit = jit_metric(
+                self._metric_jit = jit(
                     ndim=ndim,
-                    metric_kind=metric,
+                    metric=metric,
                     dtype=dtype,
                 )
                 self._metric_pointer = self._metric_jit.address if \
@@ -245,27 +229,22 @@ class Index:
             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,
-            )
+        if metric in MetricKindBitwise:
+            assert dtype is None or dtype == ScalarKind.B1
+            dtype = ScalarKind.B1
         else:
-            if dtype is None:
-                dtype = 'f32'
-            self._compiled = _CompiledIndex(
-                ndim=ndim,
-                metric=self._metric_kind,
-                metric_pointer=self._metric_pointer,
-                dtype=dtype,
-                connectivity=connectivity,
-                expansion_add=expansion_add,
-                expansion_search=expansion_search,
-                tune=tune,
-            )
+            dtype = _normalize_dtype(dtype)
+
+        self._compiled = _CompiledIndex(
+            ndim=ndim,
+            metric=self._metric_kind,
+            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):
@@ -276,7 +255,7 @@ class Index:
 
     def add(
             self, labels, vectors, *,
-            copy: bool = True, threads: int = 0):
+            copy: bool = True, threads: int = 0) -> Union[int, np.ndarray]:
         """Inserts one or move vectors into the index.
 
         For maximal performance the `labels` and `vectors`
@@ -291,7 +270,7 @@ class Index:
         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.
+        :param labels: Unique identifier for passed vectors, optional
         :type labels: Buffer
         :param vectors: Collection of vectors.
         :type vectors: Buffer
@@ -299,6 +278,9 @@ class Index:
         :type copy: bool, optional
         :param threads: Optimal number of cores to use, defaults to 0
         :type threads: int, optional
+
+        :return: Inserted label or labels
+        :type: Union[int, np.ndarray]
         """
         assert isinstance(vectors, np.ndarray), 'Expects a NumPy array'
         assert vectors.ndim == 1 or vectors.ndim == 2, 'Expects a matrix or vector'
@@ -314,11 +296,12 @@ class Index:
                 labels = start_id
         if isinstance(labels, np.ndarray):
             labels = labels.astype(np.longlong)
+        elif isinstance(labels, Iterable):
+            labels = np.array(labels, dtype=np.longlong)
 
         self._compiled.add(labels, vectors, copy=copy, threads=threads)
 
-        if generate_labels:
-            return labels
+        return labels
 
     def search(
             self, vectors, k: int = 10, *,
@@ -343,8 +326,24 @@ class Index:
         )
         return Matches(*tuple_)
 
+    @property
+    def specs(self) -> dict:
+        return {
+            'Class': 'usearch.Index',
+            'Connectivity': self.connectivity,
+            'Size': self.size,
+            'Dimensions': self.ndim,
+            'Expansion@Add': self.expansion_add,
+            'Expansion@Search': self.expansion_search,
+            'OpenMP': USES_OPENMP,
+            'SimSIMD': USES_SIMSIMD,
+            'JIT': self.jit,
+            'DType': self.dtype,
+            'Path': self.path,
+        }
+
     def __len__(self) -> int:
-        return len(self._compiled)
+        return self._compiled.__len__()
 
     @property
     def jit(self) -> bool:
@@ -363,7 +362,7 @@ class Index:
         return self._metric_kind
 
     @property
-    def dtype(self) -> str:
+    def dtype(self) -> ScalarKind:
         return self._compiled.dtype
 
     @property
@@ -387,11 +386,11 @@ class Index:
         return self._compiled.expansion_search
 
     @expansion_add.setter
-    def change_expansion_add(self, v: int):
+    def expansion_add(self, v: int):
         self._compiled.expansion_add = v
 
     @expansion_search.setter
-    def change_expansion_search(self, v: int):
+    def expansion_search(self, v: int):
         self._compiled.expansion_search = v
 
     def save(self, path: os.PathLike):
@@ -406,5 +405,27 @@ class Index:
     def clear(self):
         self._compiled.clear()
 
-    def remove(self, label: int):
-        pass
+    @property
+    def labels(self) -> np.ndarray:
+        return self._compiled.labels
+
+    def get_vectors(
+            self,
+            labels: np.ndarray,
+            dtype: ScalarKind = ScalarKind.F32) -> np.ndarray:
+
+        dtype = _normalize_dtype(dtype)
+        return np.vstack([self._compiled.__getitem__(l, dtype) for l in labels])
+
+    @property
+    def vectors(self) -> np.ndarray:
+        return self.get_vectors(self.labels)
+
+    def __delitem__(self, label: int):
+        raise NotImplementedError()
+
+    def __contains__(self, label: int) -> bool:
+        return self._compiled.__contains__(label)
+
+    def __getitem__(self, label: int) -> np.ndarray:
+        return self._compiled.__getitem__(label)

package/python/usearch/io.py

@@ -7,7 +7,7 @@ def load_matrix(
         filename: str,
         start_row: int = 0, count_rows: int = None,
         view: bool = False) -> np.ndarray:
-    """Read *.ibin, *.hbin, *.fbin, *.dbin files with matrixes.
+    """Read *.ibin, *.bbib, *.hbin, *.fbin, *.dbin files with matrices.
 
     :param filename: path to the matrix file
     :param start_row: start reading vectors from this index
@@ -31,6 +31,9 @@ def load_matrix(
     elif filename.endswith('.ibin'):
         dtype = np.int32
         scalar_size = 4
+    elif filename.endswith('.bbin'):
+        dtype = np.int8
+        scalar_size = 1
     else:
         raise Exception('Unknown file type')
 
@@ -49,7 +52,7 @@ def load_matrix(
 
 
 def save_matrix(vectors: np.ndarray, filename: str):
-    """Write *.ibin, *.hbin, *.fbin, *.dbin files with matrixes.
+    """Write *.ibin, *.bbib, *.hbin, *.fbin, *.dbin files with matrices.
 
     :param vectors: the matrix to serialize
     :type vectors: numpy.ndarray
@@ -65,6 +68,8 @@ def save_matrix(vectors: np.ndarray, filename: str):
         dtype = np.float16
     elif filename.endswith('.ibin'):
         dtype = np.int32
+    elif filename.endswith('.bbin'):
+        dtype = np.int8
     else:
         raise Exception('Unknown file type')
 

package/python/usearch/join.py

@@ -0,0 +1,100 @@
+from collections import deque
+
+import numpy as np
+from numba import njit
+
+from index import Index, Matches, Label
+
+
+class bidict(dict):
+
+    def __init__(self, *args, **kwargs):
+        super(bidict, self).__init__(*args, **kwargs)
+        self.inverse = {}
+        for key, value in self.items():
+            self.inverse.setdefault(value, []).append(key)
+
+    def __setitem__(self, key, value):
+        if key in self:
+            self.inverse[self[key]].remove(key)
+        super(bidict, self).__setitem__(key, value)
+        self.inverse.setdefault(value, []).append(key)
+
+    def __delitem__(self, key):
+        self.inverse.setdefault(self[key], []).remove(key)
+        if self[key] in self.inverse and not self.inverse[self[key]]:
+            del self.inverse[self[key]]
+        super(bidict, self).__delitem__(key)
+
+
+@njit
+def index_in_array(array: np.ndarray, item: Label) -> int:
+    for idx, val in np.ndenumerate(array):
+        if val == item:
+            return idx
+
+    return len(array)
+
+
+def semantic_join(a: Index, b: Index, resolution: int = 10) -> bidict:
+    """Performs a Semantic Join, matching one entry from `a` with 
+    one entry from `b`, converging towards a Stable Marriage.
+    Assuming the collections can be different in size, classical solution
+    doesn't provide 
+
+    :param resolution: Approximate matches per member to consider, defaults to 10
+    :type resolution: int, optional
+    :return: Bidirectional mapping from men to women and `.inverse`
+    :rtype: bidict
+    """
+
+    men, women = (a, b) if len(a) > len(b) else (b, a)
+    matches = bidict()
+
+    men_vectors = np.vstack(men[i] for i in range(len(men)))
+    women_vectors = np.vstack(women[i] for i in range(len(women)))
+
+    man_count_proposed = np.zeros(len(men))
+    man_to_women_preferences: Matches = men.search(women_vectors, resolution)
+    woman_to_men_preferences: Matches = women.search(men_vectors, resolution)
+
+    # A nice optimization is to prioritize free men by the quality of their
+    # best remaining variant. TODO: Replace with `heapq`
+    free_men = deque(range(len(men)))
+
+    idle_cycles: int = 0
+    hopeless_men_count = len(men) - len(women)
+    while len(free_men) > hopeless_men_count:
+
+        # In the worst case scenario we may need to match more candidates for every
+        # remaining man. This, however, may drastically increase the runtime.
+        if len(free_men) == idle_cycles:
+            break
+
+        man: Label = free_men.popleft()
+        count_proposals = man_count_proposed[man]
+        if count_proposals == man_to_women_preferences.counts[man]:
+            free_men.append(man)
+            idle_cycles += 1
+            continue
+
+        woman: Label = man_to_women_preferences.labels[man, count_proposals]
+        man_count_proposed[man] += 1
+
+        if woman not in matches.inverse:
+            matches[man] = woman
+
+        else:
+            her_preferences = woman_to_men_preferences.labels[woman, :]
+            husband: Label = matches.inverse[woman]
+            husband_rank = index_in_array(her_preferences, husband)
+            challenger_rank = index_in_array(her_preferences, man)
+            if challenger_rank < husband_rank:
+                del matches[husband]
+                free_men.append(husband)
+                matches[man] = woman
+
+            else:
+                free_men.append(man)
+
+    return matches

package/python/usearch/numba.py

@@ -0,0 +1,101 @@
+# 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.
+from math import sqrt
+from typing import Callable
+
+import numpy as np
+from numba import cfunc, types, carray
+
+from usearch.compiled import MetricKind
+
+
+signature_f16args = types.float32(types.CPointer(
+    types.float16), types.CPointer(types.float16))
+
+signature_f32args = types.float32(types.CPointer(
+    types.float32), types.CPointer(types.float32))
+
+signature_f64args = types.float32(types.CPointer(
+    types.float64), types.CPointer(types.float64))
+
+
+def jit(ndim: int,
+        metric: MetricKind = MetricKind.Cos,
+        dtype: np.generic = np.float32) -> Callable:
+    """JIT-compiles a distance metric specifically tuned for the target hardware
+    and number of dimensions.
+
+    Uses Numba `cfunc` functionality, annotating it with Numba `types` instead 
+    of `ctypes` to support half-precision.
+    https://numba.readthedocs.io/en/stable/reference/jit-compilation.html#c-callbacks
+    """
+    normalize_dtype = {
+        # Half-precision is still unsupported
+        # https://github.com/numba/numba/issues/4402
+        # 'f16': np.float16,
+        'f32': np.float32,
+        'f64': np.float64,
+    }
+    if dtype in normalize_dtype.keys():
+        dtype = normalize_dtype[dtype]
+    if dtype not in normalize_dtype.values():
+        return None
+
+    scalar_kind_to_accumulator_type = {
+        np.float16: types.float32,
+        np.float32: types.float32,
+        np.float64: types.float64,
+    }
+    accumulator = scalar_kind_to_accumulator_type[dtype]
+
+    def numba_ip(a, b):
+        a_array = carray(a, ndim)
+        b_array = carray(b, ndim)
+        ab = accumulator(0)
+        for i in range(ndim):
+            ab += a_array[i] * b_array[i]
+        return types.float32(1 - ab)
+
+    def numba_cos(a, b):
+        a_array = carray(a, ndim)
+        b_array = carray(b, ndim)
+        ab = accumulator(0)
+        a_sq = accumulator(0)
+        b_sq = accumulator(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]
+        a_norm = sqrt(a_sq)
+        b_norm = sqrt(b_sq)
+        if a_norm == 0 and b_norm == 0:
+            return types.float32(0)
+        elif a_norm == 0 or b_norm == 0 or ab == 0:
+            return types.float32(1)
+        else:
+            return types.float32(1 - ab / (a_norm * b_norm))
+
+    def numba_l2sq(a, b):
+        a_array = carray(a, ndim)
+        b_array = carray(b, ndim)
+        ab_delta_sq = accumulator(0)
+        for i in range(ndim):
+            ab_delta_sq += (a_array[i] - b_array[i]) * \
+                (a_array[i] - b_array[i])
+        return types.float32(ab_delta_sq)
+
+    scalar_kind_to_signature = {
+        np.float16: signature_f16args,
+        np.float32: signature_f32args,
+        np.float64: signature_f64args,
+    }
+
+    metric_kind_to_function = {
+        MetricKind.IP: numba_ip,
+        MetricKind.Cos: numba_cos,
+        MetricKind.L2sq: numba_l2sq,
+    }
+
+    return cfunc(scalar_kind_to_signature[dtype])(metric_kind_to_function[metric])

package/rust/lib.cpp

@@ -62,7 +62,7 @@ void Index::save(rust::Str path) const { index_->save(std::string(path).c_str())
 void Index::load(rust::Str path) const { index_->load(std::string(path).c_str()); }
 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()); }
+scalar_kind_t accuracy(rust::Str quant) { return scalar_kind_from_name(quant.data(), quant.size()); }
 
 std::unique_ptr<Index> wrap(punned_t&& index) {
     std::unique_ptr<punned_t> punned_ptr;
@@ -72,26 +72,39 @@ std::unique_ptr<Index> wrap(punned_t&& index) {
     return result;
 }
 
-index_config_t config(size_t connectivity, size_t exp_add, size_t exp_search) {
+index_config_t config(size_t connectivity) {
     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();
     return result;
 }
 
-std::unique_ptr<Index> new_ip(size_t dims, rust::Str quant, size_t connectivity, size_t exp_add, size_t exp_search) {
-    return wrap(punned_t::ip(dims, accuracy(quant), config(connectivity, exp_add, exp_search)));
+metric_kind_t rust_to_cpp_metric(MetricKind value) {
+    switch (value) {
+    case MetricKind::IP: return metric_kind_t::ip_k;
+    case MetricKind::L2Sq: return metric_kind_t::l2sq_k;
+    case MetricKind::Cos: return metric_kind_t::cos_k;
+    case MetricKind::Pearson: return metric_kind_t::pearson_k;
+    case MetricKind::Haversine: return metric_kind_t::haversine_k;
+    case MetricKind::Hamming: return metric_kind_t::hamming_k;
+    case MetricKind::Tanimoto: return metric_kind_t::tanimoto_k;
+    case MetricKind::Sorensen: return metric_kind_t::sorensen_k;
+    default: return metric_kind_t::unknown_k;
+    }
 }
 
-std::unique_ptr<Index> new_l2sq(size_t dims, rust::Str quant, size_t connectivity, size_t exp_add, size_t exp_search) {
-    return wrap(punned_t::l2sq(dims, accuracy(quant), config(connectivity, exp_add, exp_search)));
+scalar_kind_t rust_to_cpp_scalar(ScalarKind value) {
+    switch (value) {
+    case ScalarKind::F8: return scalar_kind_t::f8_k;
+    case ScalarKind::F16: return scalar_kind_t::f16_k;
+    case ScalarKind::F32: return scalar_kind_t::f32_k;
+    case ScalarKind::F64: return scalar_kind_t::f64_k;
+    case ScalarKind::B1: return scalar_kind_t::b1x8_k;
+    default: return scalar_kind_t::unknown_k;
+    }
 }
 
-std::unique_ptr<Index> new_cos(size_t dims, rust::Str quant, size_t connectivity, size_t exp_add, size_t exp_search) {
-    return wrap(punned_t::cos(dims, accuracy(quant), config(connectivity, exp_add, exp_search)));
-}
-
-std::unique_ptr<Index> new_haversine(rust::Str quant, size_t connectivity, size_t exp_add, size_t exp_search) {
-    return wrap(punned_t::haversine(accuracy(quant), config(connectivity, exp_add, exp_search)));
+std::unique_ptr<Index> new_index(IndexOptions const& options) {
+    return wrap(punned_t::make(options.dimensions, rust_to_cpp_metric(options.metric), config(options.connectivity),
+                               rust_to_cpp_scalar(options.quantization), options.expansion_add,
+                               options.expansion_search));
 }