usearch 2.8.7 → 2.8.8

package/python/scripts/join.py

@@ -1,155 +0,0 @@
-"""
-wget -nc https://huggingface.co/datasets/unum-cloud/ann-cc-3m/resolve/main/clip_images.fbin -P datasets/cc_3M/
-wget -nc https://huggingface.co/datasets/unum-cloud/ann-cc-3m/resolve/main/clip_texts.fbin -P datasets/cc_3M/
-wget -nc https://huggingface.co/datasets/unum-cloud/ann-cc-3m/resolve/main/images.fbin -P datasets/cc_3M/
-wget -nc https://huggingface.co/datasets/unum-cloud/ann-cc-3m/resolve/main/texts.fbin -P datasets/cc_3M/
-wget -nc https://huggingface.co/datasets/unum-cloud/ann-cc-3m/resolve/main/uform_english_images.fbin -P datasets/cc_3M/
-wget -nc https://huggingface.co/datasets/unum-cloud/ann-cc-3m/resolve/main/uform_english_texts.fbin -P datasets/cc_3M/
-wget -nc https://huggingface.co/datasets/unum-cloud/ann-cc-3m/resolve/main/clipbigg_images.fbin -P datasets/cc_3M/
-wget -nc https://huggingface.co/datasets/unum-cloud/ann-cc-3m/resolve/main/clipbigg_texts.fbin -P datasets/cc_3M/
-wget -nc https://huggingface.co/datasets/unum-cloud/ann-arxiv-2m/resolve/main/e5base_abstract.fbin -P datasets/arxiv_2M/
-wget -nc https://huggingface.co/datasets/unum-cloud/ann-arxiv-2m/resolve/main/e5base_title.fbin -P datasets/arxiv_2M/
-rm -rf datasets/cc_3M/*.usearch datasets/arxiv_2M/*.usearch
-python python/scripts/join.py
-"""
-from numpy import dot
-from numpy.linalg import norm
-from tqdm import tqdm
-from simsimd import cos_f32x4_neon, to_int
-
-from usearch.index import Index, MetricKind, CompiledMetric, MetricSignature
-from usearch.io import load_matrix
-from usearch.eval import measure_seconds
-
-count = 10
-exact = False
-batch_size = 1024 * 4
-max_elements = 1000000
-
-a_name = "cc_3M/texts"
-b_name = "cc_3M/images"
-
-a_mat = load_matrix(f"datasets/{a_name}.fbin", view=True)
-b_mat = load_matrix(f"datasets/{b_name}.fbin", view=True)
-
-a_mat = a_mat[:max_elements]
-b_mat = b_mat[:max_elements]
-
-print(f"Loaded two datasets of shape: {a_mat.shape}, {b_mat.shape}")
-print("--------------------------------------")
-print("---------------Indexing---------------")
-print("--------------------------------------")
-
-metric = CompiledMetric(
-    pointer=to_int(cos_f32x4_neon),
-    kind=MetricKind.Cos,
-    signature=MetricSignature.ArrayArraySize,
-)
-
-a = Index(
-    a_mat.shape[1],
-    metric=metric,
-    path=f"datasets/{a_name}-{max_elements}.f32.usearch",
-    dtype="f32",
-)
-b = Index(
-    b_mat.shape[1],
-    metric=metric,
-    path=f"datasets/{b_name}-{max_elements}.f32.usearch",
-    dtype="f32",
-)
-
-if len(a) != a_mat.shape[0]:
-    a.clear()
-    a.add(None, a_mat, log=True, batch_size=batch_size)
-    a.save()
-
-if len(b) != b_mat.shape[0]:
-    b.clear()
-    b.add(None, b_mat, log=True, batch_size=batch_size)
-    b.save()
-
-
-print(
-    f"Loaded two indexes of size: {len(a):,} for {a_name} and {len(b):,} for {b_name}"
-)
-min_elements = min(len(a), len(b))
-
-run_diagnostics = input("Would you like to run diagnostics? [Y/n]: ")
-if len(run_diagnostics) == 0 or run_diagnostics.lower() == "y":
-    print("--------------------------------------")
-    print("-------------Diagnostics--------------")
-    print("--------------------------------------")
-
-    mean_similarity = 0.0
-    mean_recovered_similarity = 0.0
-
-    for i in tqdm(range(min_elements), desc="Pairwise Similarity"):
-        a_vec = a_mat[i]
-        b_vec = b_mat[i]
-        cos_similarity = dot(a_vec, b_vec) / (norm(a_vec) * norm(b_vec))
-        mean_similarity += cos_similarity
-
-        a_vec = a[i]
-        b_vec = b[i]
-        cos_similarity = dot(a_vec, b_vec) / (norm(a_vec) * norm(b_vec))
-        mean_recovered_similarity += cos_similarity
-
-    mean_similarity /= min_elements
-    mean_recovered_similarity /= min_elements
-    print(
-        f"Average vector similarity is {mean_similarity:.4f} in original dataset, "
-        f"and {mean_recovered_similarity:.4f} in recovered state in index"
-    )
-
-    dt = measure_seconds
-    args = dict(
-        count=count,
-        batch_size=batch_size,
-        log=True,
-        exact=exact,
-    )
-
-    secs, a_self_recall = dt(lambda: a.search(a.vectors, **args).recall(a.keys))
-    print(
-        "Self-recall @{} of {} index: {:.2f}%, took {:.2f}s".format(
-            count, a_name, a_self_recall * 100, secs
-        )
-    )
-
-    secs, b_self_recall = dt(lambda: b.search(b.vectors, **args).recall(b.keys))
-    print(
-        "Self-recall @{} of {} index: {:.2f}%, took {:.2f}s".format(
-            count, b_name, b_self_recall * 100, secs
-        )
-    )
-
-    secs, ab_recall = dt(lambda: b.search(a.vectors, **args).recall(b.keys))
-    print(
-        "Cross-recall @{} of {} in {}: {:.2f}%, took {:.2f}s".format(
-            count, a_name, b_name, ab_recall * 100, secs
-        )
-    )
-
-    secs, ba_recall = dt(lambda: a.search(b.vectors, **args).recall(a.keys))
-    print(
-        "Cross-recall @{} of {} in {}: {:.2f}%, took {:.2f}s".format(
-            count, b_name, a_name, ba_recall * 100, secs
-        )
-    )
-
-
-print("--------------------------------------")
-print("-----------------Join-----------------")
-print("--------------------------------------")
-
-secs, bimapping = measure_seconds(lambda: a.join(b, max_proposals=100))
-mapping_size = len(bimapping)
-recall = 0
-for i, j in bimapping.items():
-    recall += i == j
-
-recall *= 100.0 / min_elements
-print(
-    f"Took {secs:.2f}s to find {mapping_size:,} pairings with {recall:.2f}% being exact"
-)

package/python/scripts/test_index.py

@@ -1,247 +0,0 @@
-import os
-
-import pytest
-import numpy as np
-
-from usearch.io import load_matrix, save_matrix
-from usearch.eval import random_vectors
-from usearch.index import search
-
-from usearch.index import (
-    Index,
-    MetricKind,
-    ScalarKind,
-    Match,
-    Matches,
-    BatchMatches,
-    Clustering,
-)
-from usearch.index import (
-    DEFAULT_CONNECTIVITY,
-)
-
-
-ndims = [3, 97, 256]
-batch_sizes = [1, 11, 77]
-quantizations = [
-    ScalarKind.F32,
-    ScalarKind.F64,
-    ScalarKind.F16,
-    ScalarKind.I8,
-]
-dtypes = [np.float32, np.float64, np.float16]
-threads = 2
-
-connectivity_options = [3, 13, 50, DEFAULT_CONNECTIVITY]
-continuous_metrics = [MetricKind.Cos, MetricKind.L2sq]
-hash_metrics = [
-    MetricKind.Hamming,
-    MetricKind.Tanimoto,
-    MetricKind.Sorensen,
-]
-
-
-@pytest.mark.parametrize("ndim", [3, 97, 256])
-@pytest.mark.parametrize("metric", [MetricKind.Cos, MetricKind.L2sq])
-@pytest.mark.parametrize("batch_size", [1, 7, 1024])
-@pytest.mark.parametrize("quantization", [ScalarKind.F32, ScalarKind.I8])
-@pytest.mark.parametrize("dtype", [np.float32, np.float64, np.float16])
-def test_index_initialization_and_addition(
-    ndim, metric, quantization, dtype, batch_size
-):
-    index = Index(ndim=ndim, metric=metric, dtype=quantization, multi=False)
-    keys = np.arange(batch_size)
-    vectors = random_vectors(count=batch_size, ndim=ndim, dtype=dtype)
-    index.add(keys, vectors, threads=threads)
-    assert len(index) == batch_size
-
-
-@pytest.mark.parametrize("ndim", [3, 97, 256])
-@pytest.mark.parametrize("metric", [MetricKind.Cos, MetricKind.L2sq])
-@pytest.mark.parametrize("batch_size", [1, 7, 1024])
-@pytest.mark.parametrize("quantization", [ScalarKind.F32, ScalarKind.I8])
-@pytest.mark.parametrize("dtype", [np.float32, np.float64, np.float16])
-def test_index_retrieval(ndim, metric, quantization, dtype, batch_size):
-    index = Index(ndim=ndim, metric=metric, dtype=quantization, multi=False)
-    keys = np.arange(batch_size)
-    vectors = random_vectors(count=batch_size, ndim=ndim, dtype=dtype)
-    index.add(keys, vectors, threads=threads)
-    vectors_retrived = np.vstack(index.get(keys, dtype))
-    assert np.allclose(vectors_retrived, vectors, atol=0.1)
-
-
-@pytest.mark.parametrize("ndim", [3, 97, 256])
-@pytest.mark.parametrize("metric", [MetricKind.Cos, MetricKind.L2sq])
-@pytest.mark.parametrize("batch_size", [1, 7, 1024])
-@pytest.mark.parametrize("quantization", [ScalarKind.F32, ScalarKind.I8])
-@pytest.mark.parametrize("dtype", [np.float32, np.float64, np.float16])
-def test_index_search(ndim, metric, quantization, dtype, batch_size):
-    index = Index(ndim=ndim, metric=metric, dtype=quantization, multi=False)
-    keys = np.arange(batch_size)
-    vectors = random_vectors(count=batch_size, ndim=ndim, dtype=dtype)
-    index.add(keys, vectors, threads=threads)
-
-    if batch_size == 1:
-        matches: Matches = index.search(vectors, 10, threads=threads)
-        assert matches.keys.ndim == 1
-        assert matches.keys.shape[0] == matches.distances.shape[0]
-        assert len(matches) == batch_size
-        assert np.all(np.sort(index.keys) == np.sort(keys))
-
-    else:
-        matches: BatchMatches = index.search(vectors, 10, threads=threads)
-        assert matches.keys.ndim == 2
-        assert matches.keys.shape[0] == matches.distances.shape[0]
-        assert len(matches) == batch_size
-        assert np.all(np.sort(index.keys) == np.sort(keys))
-
-
-@pytest.mark.parametrize("batch_size", [1, 7, 1024])
-def test_index_duplicates(batch_size):
-    ndim = 8
-    index = Index(ndim=ndim, multi=False)
-    keys = np.arange(batch_size)
-    vectors = random_vectors(count=batch_size, ndim=ndim)
-    index.add(keys, vectors, threads=threads)
-    with pytest.raises(Exception):
-        index.add(keys, vectors, threads=threads)
-
-    index = Index(ndim=ndim, multi=True)
-    keys = np.arange(batch_size)
-    vectors = random_vectors(count=batch_size, ndim=ndim)
-    index.add(keys, vectors, threads=threads)
-    index.add(keys, vectors, threads=threads)
-    assert len(index) == batch_size * 2
-
-    two_per_key = index.get(keys)
-    assert np.vstack(two_per_key).shape == (2 * batch_size, ndim)
-
-
-@pytest.mark.parametrize("batch_size", [1, 7, 1024])
-def test_index_stats(batch_size):
-    ndim = 8
-    index = Index(ndim=ndim, multi=False)
-    keys = np.arange(batch_size)
-    vectors = random_vectors(count=batch_size, ndim=ndim)
-    index.add(keys, vectors, threads=threads)
-
-    assert index.max_level >= 0
-    assert index.stats.nodes >= batch_size
-    assert index.levels_stats[0].nodes == batch_size
-    assert index.level_stats(0).nodes == batch_size
-
-    assert index.levels_stats[index.max_level].nodes > 0
-
-
-@pytest.mark.parametrize("ndim", [1, 3, 8, 32, 256, 4096])
-@pytest.mark.parametrize("batch_size", [0, 1, 7, 1024])
-@pytest.mark.parametrize("quantization", [ScalarKind.F32, ScalarKind.I8])
-def test_index_save_load_restore_copy(ndim, quantization, batch_size):
-    index = Index(ndim=ndim, dtype=quantization, multi=False)
-
-    if batch_size > 0:
-        keys = np.arange(batch_size)
-        vectors = random_vectors(count=batch_size, ndim=ndim)
-        index.add(keys, vectors, threads=threads)
-
-    index.save("tmp.usearch")
-    index.clear()
-    assert len(index) == 0
-    assert os.path.exists("tmp.usearch")
-
-    index.load("tmp.usearch")
-    assert len(index) == batch_size
-    if batch_size > 0:
-        assert len(index[0].flatten()) == ndim
-
-    index_meta = Index.metadata("tmp.usearch")
-    assert index_meta is not None
-
-    index = Index.restore("tmp.usearch", view=False)
-    assert len(index) == batch_size
-    if batch_size > 0:
-        assert len(index[0].flatten()) == ndim
-
-    copied_index = index.copy()
-    assert len(copied_index) == len(index)
-    if batch_size > 0:
-        assert np.allclose(
-            np.vstack(copied_index.get(keys)), np.vstack(index.get(keys))
-        )
-
-    # Perform the same operations in RAM, without touching the filesystem
-    serialized_index = index.save()
-    deserialized_metadata = Index.metadata(serialized_index)
-    assert deserialized_metadata is not None
-
-    deserialized_index = Index.restore(serialized_index)
-    assert len(deserialized_index) == len(index)
-    assert set(np.array(deserialized_index.keys)) == set(np.array(index.keys))
-    if batch_size > 0:
-        assert np.allclose(
-            np.vstack(deserialized_index.get(keys)), np.vstack(index.get(keys))
-        )
-
-    deserialized_index.reset()
-    index.reset()
-    os.remove("tmp.usearch")
-
-
-@pytest.mark.parametrize("batch_size", [32])
-def test_index_contains_remove_rename(batch_size):
-    if batch_size <= 1:
-        return
-
-    ndim = 8
-    index = Index(ndim=ndim, multi=False)
-    keys = np.arange(batch_size)
-    vectors = random_vectors(count=batch_size, ndim=ndim)
-
-    index.add(keys, vectors, threads=threads)
-    assert np.all(index.contains(keys))
-    assert np.all(index.count(keys) == np.ones(batch_size))
-
-    removed_keys = keys[: batch_size // 2]
-    remaining_keys = keys[batch_size // 2 :]
-    index.remove(removed_keys)
-    assert len(index) == (len(keys) - len(removed_keys))
-    assert np.sum(index.contains(keys)) == len(remaining_keys)
-    assert np.sum(index.count(keys)) == len(remaining_keys)
-    assert np.sum(index.count(removed_keys)) == 0
-
-    assert keys[0] not in index
-    assert keys[-1] in index
-
-    renamed_counts = index.rename(removed_keys, removed_keys)
-    assert np.sum(index.count(renamed_counts)) == 0
-
-    renamed_counts = index.rename(remaining_keys, removed_keys)
-    assert np.sum(index.count(removed_keys)) == len(index)
-
-
-@pytest.mark.parametrize("ndim", [3, 97, 256])
-@pytest.mark.parametrize("metric", [MetricKind.Cos, MetricKind.L2sq])
-@pytest.mark.parametrize("batch_size", [500, 1024])
-@pytest.mark.parametrize("quantization", [ScalarKind.F32, ScalarKind.I8])
-@pytest.mark.parametrize("dtype", [np.float32, np.float64, np.float16])
-def test_index_clustering(ndim, metric, quantization, dtype, batch_size):
-    index = Index(ndim=ndim, metric=metric, dtype=quantization, multi=False)
-    keys = np.arange(batch_size)
-    vectors = random_vectors(count=batch_size, ndim=ndim, dtype=dtype)
-    index.add(keys, vectors, threads=threads)
-
-    clusters: Clustering = index.cluster(vectors=vectors, threads=threads)
-    assert len(clusters.matches.keys) == batch_size
-
-    # If no argument is provided, we cluster the present entries
-    clusters: Clustering = index.cluster(threads=threads)
-    assert len(clusters.matches.keys) == batch_size
-
-    # If no argument is provided, we cluster the present entries
-    clusters: Clustering = index.cluster(keys=keys[:50], threads=threads)
-    assert len(clusters.matches.keys) == 50
-
-    # If no argument is provided, we cluster the present entries
-    clusters: Clustering = index.cluster(min_count=3, max_count=10, threads=threads)
-    unique_clusters = set(clusters.matches.keys.flatten().tolist())
-    assert len(unique_clusters) >= 3 and len(unique_clusters) <= 10

package/python/scripts/test_jit.py

@@ -1,231 +0,0 @@
-import pytest
-import numpy as np
-
-from usearch.eval import random_vectors
-
-from usearch.index import (
-    Index,
-    MetricKind,
-    MetricSignature,
-    CompiledMetric,
-)
-
-dimensions = [3, 97, 256]
-batch_sizes = [1, 77]
-
-
-@pytest.mark.parametrize("ndim", dimensions)
-@pytest.mark.parametrize("batch_size", batch_sizes)
-def test_index_numba(ndim: int, batch_size: int):
-    try:
-        from numba import cfunc, types, carray
-    except ImportError:
-        return
-
-    # Showcases how to use Numba to JIT-compile similarity measures for USearch.
-    # https://numba.readthedocs.io/en/stable/reference/jit-compilation.html#c-callbacks
-    signature_two_args = types.float32(
-        types.CPointer(types.float32),
-        types.CPointer(types.float32),
-    )
-    signature_three_args = types.float32(
-        types.CPointer(types.float32),
-        types.CPointer(types.float32),
-        types.uint64,
-    )
-    signature_four_args = types.float32(
-        types.CPointer(types.float32),
-        types.uint64,
-        types.CPointer(types.float32),
-        types.uint64,
-    )
-
-    @cfunc(signature_two_args)
-    def python_inner_product_two_args(a, b):
-        a_array = carray(a, ndim)
-        b_array = carray(b, ndim)
-        c = 0.0
-        for i in range(ndim):
-            c += a_array[i] * b_array[i]
-        return 1 - c
-
-    @cfunc(signature_three_args)
-    def python_inner_product_three_args(a, b, ndim):
-        a_array = carray(a, ndim)
-        b_array = carray(b, ndim)
-        c = 0.0
-        for i in range(ndim):
-            c += a_array[i] * b_array[i]
-        return 1 - c
-
-    functions = [
-        python_inner_product_two_args,
-        python_inner_product_three_args,
-    ]
-    signatures = [
-        MetricSignature.ArrayArray,
-        MetricSignature.ArrayArraySize,
-    ]
-    for function, signature in zip(functions, signatures):
-        metric = CompiledMetric(
-            pointer=function.address,
-            kind=MetricKind.IP,
-            signature=signature,
-        )
-        index = Index(ndim=ndim, metric=metric)
-
-        keys = np.arange(batch_size)
-        vectors = random_vectors(count=batch_size, ndim=ndim)
-
-        index.add(keys, vectors)
-        matches = index.search(vectors, 10)
-        assert len(matches) == batch_size
-
-
-@pytest.mark.parametrize("ndim", dimensions[-1:])
-@pytest.mark.parametrize("batch_size", batch_sizes[-1:])
-def test_index_cppyy(ndim: int, batch_size: int):
-    try:
-        import cppyy
-        import cppyy.ll
-    except ImportError:
-        return
-
-    cppyy.cppdef(
-        """
-    float inner_product_two_args(float *a, float *b) {
-        float result = 0;
-    #pragma unroll
-        for (size_t i = 0; i != ndim; ++i)
-            result += a[i] * b[i];
-        return 1 - result;
-    }
-    
-    float inner_product_three_args(float *a, float *b, size_t n) {
-        float result = 0;
-        for (size_t i = 0; i != n; ++i)
-            result += a[i] * b[i];
-        return 1 - result;
-    }
-    
-    float inner_product_four_args(float *a, size_t an, float *b, size_t) {
-        float result = 0;
-        for (size_t i = 0; i != an; ++i)
-            result += a[i] * b[i];
-        return 1 - result;
-    }
-    """.replace(
-            "ndim", str(ndim)
-        )
-    )
-
-    functions = [
-        cppyy.gbl.inner_product_two_args,
-        cppyy.gbl.inner_product_three_args,
-        # cppyy.gbl.inner_product_four_args,
-    ]
-    signatures = [
-        MetricSignature.ArrayArray,
-        MetricSignature.ArrayArraySize,
-        # MetricSignature.ArraySizeArraySize,
-    ]
-    for function, signature in zip(functions, signatures):
-        metric = CompiledMetric(
-            pointer=cppyy.ll.addressof(function),
-            kind=MetricKind.IP,
-            signature=signature,
-        )
-        index = Index(ndim=ndim, metric=metric)
-
-        keys = np.arange(batch_size)
-        vectors = random_vectors(count=batch_size, ndim=ndim)
-
-        index.add(keys, vectors)
-        matches = index.search(vectors, 10)
-        assert len(matches) == batch_size
-
-
-@pytest.mark.parametrize("ndim", [8])
-@pytest.mark.parametrize("batch_size", batch_sizes)
-def test_index_peachpy(ndim: int, batch_size: int):
-    try:
-        from peachpy import (
-            Argument,
-            ptr,
-            float_,
-            const_float_,
-        )
-        from peachpy.x86_64 import (
-            abi,
-            Function,
-            uarch,
-            isa,
-            GeneralPurposeRegister64,
-            LOAD,
-            YMMRegister,
-            VSUBPS,
-            VADDPS,
-            VHADDPS,
-            VMOVUPS,
-            VFMADD231PS,
-            VPERM2F128,
-            VXORPS,
-            RETURN,
-        )
-    except ImportError:
-        return
-
-    a = Argument(ptr(const_float_), name="a")
-    b = Argument(ptr(const_float_), name="b")
-
-    with Function(
-        "InnerProduct", (a, b), float_, target=uarch.default + isa.avx + isa.avx2
-    ) as asm_function:
-        # Request two 64-bit general-purpose registers for addresses
-        reg_a, reg_b = GeneralPurposeRegister64(), GeneralPurposeRegister64()
-        LOAD.ARGUMENT(reg_a, a)
-        LOAD.ARGUMENT(reg_b, b)
-
-        # Load the vectors
-        ymm_a = YMMRegister()
-        ymm_b = YMMRegister()
-        VMOVUPS(ymm_a, [reg_a])
-        VMOVUPS(ymm_b, [reg_b])
-
-        # Prepare the accumulator
-        ymm_c = YMMRegister()
-        ymm_one = YMMRegister()
-        VXORPS(ymm_c, ymm_c, ymm_c)
-        VXORPS(ymm_one, ymm_one, ymm_one)
-
-        # Accumulate A and B product into C
-        VFMADD231PS(ymm_c, ymm_a, ymm_b)
-
-        # Reduce the contents of a YMM register
-        ymm_c_permuted = YMMRegister()
-        VPERM2F128(ymm_c_permuted, ymm_c, ymm_c, 1)
-        VADDPS(ymm_c, ymm_c, ymm_c_permuted)
-        VHADDPS(ymm_c, ymm_c, ymm_c)
-        VHADDPS(ymm_c, ymm_c, ymm_c)
-
-        # Negate the values, to go from "similarity" to "distance"
-        VSUBPS(ymm_c, ymm_one, ymm_c)
-
-        # A common convention is to return floats in XMM registers
-        RETURN(ymm_c.as_xmm)
-
-    python_function = asm_function.finalize(abi.detect()).encode().load()
-    metric = CompiledMetric(
-        pointer=python_function.loader.code_address,
-        kind=MetricKind.IP,
-        signature=MetricSignature.ArrayArray,
-    )
-    index = Index(ndim=ndim, metric=metric)
-
-    keys = np.arange(batch_size)
-    vectors = random_vectors(count=batch_size, ndim=ndim)
-
-    index.add(keys, vectors)
-    matches, distances, count = index.search(vectors, 10)
-    assert matches.shape[0] == distances.shape[0]
-    assert count.shape[0] == batch_size

package/python/scripts/test_sparse.py

@@ -1,32 +0,0 @@
-import pytest
-import numpy as np
-
-from usearch.index import (
-    Index,
-    MetricKind,
-    ScalarKind,
-)
-
-
-@pytest.mark.parametrize("bits", [7, 97, 256, 4097])
-@pytest.mark.parametrize("metric", [MetricKind.Tanimoto])
-@pytest.mark.parametrize("connectivity", [3, 13, 50])
-@pytest.mark.parametrize("batch_size", [3, 77])
-def test_bitwise_index(
-    bits: int,
-    metric: MetricKind,
-    connectivity: int,
-    batch_size: int,
-):
-    index = Index(ndim=bits, metric=metric, connectivity=connectivity)
-
-    keys = np.arange(batch_size)
-    byte_vectors = np.random.randint(2, size=(batch_size, bits))
-    bit_vectors = np.packbits(byte_vectors, axis=1)
-
-    index.add(keys, bit_vectors)
-
-    byte_vectors_retrieved = np.vstack(index.get(keys, ScalarKind.B1))
-    assert np.all(byte_vectors_retrieved == bit_vectors)
-
-    index.search(bit_vectors, 10)