usearch 0.22.3 → 1.1.0

package/simsimd/python/test.c

@@ -0,0 +1,109 @@
+#include <stdio.h>
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+#include "simsimd/simsimd.h"
+
+#define stringify_value_m(a) stringify_m(a)
+#define stringify_m(a) #a
+#define concat_m(A, B) A##B
+#define macro_concat_m(A, B) concat_m(A, B)
+#define pyinit_f_m macro_concat_m(PyInit_, SIMDSIMD_PYTHON_MODULE_NAME)
+
+char const* names[14] = {
+    "dot_f32_sve",    "cos_f32_sve",      "l2sq_f32_sve",       "cos_f32x4_avx2",        "cos_f32x4_neon",
+    "dot_f32x4_neon", "cos_f16x4_neon",   "cos_f16x16_avx512",  "l2sq_f16_sve",          "cos_i8x16_neon",
+    "dot_i8x16_avx2", "hamming_b1x8_sve", "hamming_b1x128_sve", "hamming_b1x128_avx512",
+};
+void* callables[14] = {NULL};
+
+void assign(size_t idx, void* function) { callables[idx] = function; }
+
+typedef simsimd_f32_t (*function_f32_t)(simsimd_f32_t*, simsimd_f32_t*, size_t);
+typedef simsimd_f32_t (*function_f32x16_t)(simsimd_f16_t*, simsimd_f16_t*, size_t);
+typedef simsimd_f16_t (*function_f16_t)(simsimd_f16_t*, simsimd_f16_t*, size_t);
+typedef simsimd_f32_t (*function_fi8_t)(int8_t*, int8_t*, size_t);
+typedef int32_t (*function_i8_t)(int8_t*, int8_t*, size_t);
+typedef size_t (*function_ui8_t)(uint8_t*, uint8_t*, size_t);
+
+int main(int argc, char* argv[]) {
+    Py_Initialize();
+    PyObject* module = PyImport_ImportModule("simsimd");
+    PyErr_Print();
+    if (module == NULL)
+        return -1;
+
+    PyObject* dictionary = PyModule_GetDict(module);
+    PyObject *key, *value;
+    Py_ssize_t pos = 0;
+
+    size_t idx = 0;
+    while (PyDict_Next(dictionary, &pos, &key, &value)) {
+        if (PyCapsule_CheckExact(value)) {
+            char const* name = PyCapsule_GetName(value);
+            void* pointer = PyCapsule_GetPointer(value, NULL);
+            assign(idx, pointer);
+            ++idx;
+        }
+    }
+
+    size_t d = 3;
+    {
+        simsimd_f32_t a[] = {1, 2, 3};
+        simsimd_f32_t b[] = {4, 5, 6};
+        for (idx = 0; idx < 6; ++idx) {
+            function_f32_t function = (function_f32_t)callables[idx];
+            simsimd_f32_t result = function(a, b, d);
+            printf("%f\n", result);
+        }
+    }
+
+    {
+        simsimd_f16_t a[] = {1, 2, 3};
+        simsimd_f16_t b[] = {4, 5, 6};
+        function_f32x16_t function = (function_f32x16_t)callables[6];
+        simsimd_f32_t result = function(a, b, d);
+        printf("%f\n", result);
+        function = (function_f32x16_t)callables[7];
+        result = function(a, b, d);
+        printf("%f\n", result);
+    }
+
+    {
+        simsimd_f16_t a[] = {1, 2, 3};
+        simsimd_f16_t b[] = {4, 5, 6};
+        function_f16_t function = (function_f16_t)callables[8];
+        simsimd_f16_t result = function(a, b, d);
+        printf("%i\n", result);
+    }
+
+    {
+        int8_t a[] = {1, 2, 3};
+        int8_t b[] = {4, 5, 6};
+        function_fi8_t function = (function_fi8_t)callables[9];
+        simsimd_f32_t result = function(a, b, d);
+        printf("%f\n", result);
+    }
+
+    {
+        int8_t a[] = {1, 2, 3};
+        int8_t b[] = {4, 5, 6};
+        function_i8_t function = (function_i8_t)callables[10];
+        int32_t result = function(a, b, d);
+        printf("%i\n", result);
+    }
+
+    {
+        uint8_t a[] = {1, 2, 3};
+        uint8_t b[] = {4, 5, 6};
+        for (idx = 11; idx < 14; ++idx) {
+            function_ui8_t function = (function_ui8_t)callables[idx];
+            size_t result = function(a, b, d);
+            printf("%zu\n", result);
+        }
+    }
+    
+    Py_DECREF(module);
+    return 0;
+}

package/simsimd/python/test.py

@@ -0,0 +1,23 @@
+import simsimd as sisi
+
+
+def test_non_null():
+    assert sisi.to_int(sisi.dot_f32_sve) != 0
+    assert sisi.to_int(sisi.dot_f32x4_neon) != 0
+    assert sisi.to_int(sisi.cos_f32_sve) != 0
+    assert sisi.to_int(sisi.cos_f16_sve) != 0
+    assert sisi.to_int(sisi.cos_f16x4_neon) != 0
+    assert sisi.to_int(sisi.cos_i8x16_neon) != 0
+    assert sisi.to_int(sisi.cos_f32x4_neon) != 0
+    assert sisi.to_int(sisi.cos_f16x16_avx512) != 0
+    assert sisi.to_int(sisi.cos_f32x4_avx2) != 0
+    assert sisi.to_int(sisi.l2sq_f32_sve) != 0
+    assert sisi.to_int(sisi.l2sq_f16_sve) != 0
+    assert sisi.to_int(sisi.hamming_b1x8_sve) != 0
+    assert sisi.to_int(sisi.hamming_b1x128_sve) != 0
+    assert sisi.to_int(sisi.hamming_b1x128_avx512) != 0
+    assert sisi.to_int(sisi.tanimoto_b1x8_naive) != 0
+    assert sisi.to_int(sisi.tanimoto_maccs_naive) != 0
+    assert sisi.to_int(sisi.tanimoto_maccs_neon) != 0
+    assert sisi.to_int(sisi.tanimoto_maccs_sve) != 0
+    assert sisi.to_int(sisi.tanimoto_maccs_avx512) != 0

package/simsimd/setup.py

@@ -0,0 +1,44 @@
+import os
+from os.path import dirname
+from setuptools import setup, Extension
+
+__version__ = open("VERSION", "r").read().strip()
+__lib_name__ = "simsimd"
+
+
+this_directory = os.path.abspath(dirname(__file__))
+with open(os.path.join(this_directory, "README.md"), "r", encoding="utf8") as f:
+    long_description = f.read()
+
+"-march=armv8.2-a+sve"
+"-march=sapphirerapids"
+
+setup(
+    name=__lib_name__,
+    version=__version__,
+    author="Ashot Vardanian",
+    author_email="1983160+ashvardanian@users.noreply.github.com",
+    url="https://github.com/ashvardanian/simsimd",
+    description="SIMD-accelerated similarity measures for x86 and Arm",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    license="Apache-2.0",
+    classifiers=[
+        "Development Status :: 5 - Production/Stable",
+        "Natural Language :: English",
+        "Intended Audience :: Developers",
+        "Intended Audience :: Information Technology",
+        "License :: OSI Approved :: Apache Software License",
+        "Operating System :: Linux",
+        "Programming Language :: C",
+        "Programming Language :: Python :: Implementation :: CPython",
+    ],
+    ext_modules=[
+        Extension(
+            "simsimd",
+            sources=["python/python.c"],
+            include_dirs=["include"],
+        )
+    ],
+    zip_safe=False,
+)

package/swift/Index+Sugar.swift

@@ -2,98 +2,150 @@
 //  Index+Sugar.swift
 //
 //
-//  Created by Ashot Vardanian on 5/11/23.
+//  Created by Ash Vardanian on 5/11/23.
 //
 
 @available(iOS 13, macOS 10.15, tvOS 13.0, watchOS 6.0, *)
 extension USearchIndex {
-    public typealias Label = USearchLabel
+    public typealias Key = USearchKey
     public typealias Metric = USearchMetric
     public typealias Scalar = USearchScalar
-    
+
     /// Adds a labeled vector to the index.
-    /// - Parameter label: Unique identifer for that object.
+    /// - Parameter key: Unique identifer for that object.
     /// - Parameter vector: Single-precision vector.
     /// - Throws: If runs out of memory.
-    public func add(label: USearchLabel, vector: ArraySlice<Float32>) {
+    public func add(key: USearchKey, vector: ArraySlice<Float32>) {
         vector.withContiguousStorageIfAvailable {
-            addSingle(label: label, vector: $0.baseAddress!)
+            addSingle(key: key, vector: $0.baseAddress!)
         }
     }
 
-    
+    /// Adds a labeled vector to the index.
+    /// - Parameter key: Unique identifer for that object.
+    /// - Parameter vector: Single-precision vector.
+    /// - Throws: If runs out of memory.
+    public func add(key: USearchKey, vector: Array<Float32>) {
+        add(key: key, vector: vector[...])
+    }
+
     /// Approximate nearest neighbors search.
     /// - Parameter vector: Single-precision query vector.
     /// - Parameter count: Upper limit on the number of matches to retrieve.
     /// - Returns: Labels and distances to closest approximate matches in decreasing similarity order.
     /// - Throws: If runs out of memory.
-    public func search(vector: ArraySlice<Float32>, count: Int) -> ([Label], [Float]) {
-        var matches: [Label] = Array(repeating: 0, count: count)
+    public func search(vector: ArraySlice<Float32>, count: Int) -> ([Key], [Float]) {
+        var matches: [Key] = Array(repeating: 0, count: count)
         var distances: [Float] = Array(repeating: 0, count: count)
         let results = vector.withContiguousStorageIfAvailable {
-            searchSingle(vector: $0.baseAddress!, count: CUnsignedInt(count), labels: &matches, distances: &distances)
+            searchSingle(vector: $0.baseAddress!, count: CUnsignedInt(count), keys: &matches, distances: &distances)
         }
         matches.removeLast(count - Int(results!))
         distances.removeLast(count - Int(results!))
         return (matches, distances)
     }
 
+    /// Approximate nearest neighbors search.
+    /// - Parameter vector: Single-precision query vector.
+    /// - Parameter count: Upper limit on the number of matches to retrieve.
+    /// - Returns: Labels and distances to closest approximate matches in decreasing similarity order.
+    /// - Throws: If runs out of memory.
+    public func search(vector: Array<Float32>, count: Int) -> ([Key], [Float]) {
+        return search(vector: vector[...], count: count)
+    }
+
     /// Adds a labeled vector to the index.
-    /// - Parameter label: Unique identifer for that object.
+    /// - Parameter key: Unique identifer for that object.
     /// - Parameter vector: Double-precision vector.
     /// - Throws: If runs out of memory.
-    public func add(label: Label, vector: ArraySlice<Float64>) {
+    public func add(key: Key, vector: ArraySlice<Float64>) {
         vector.withContiguousStorageIfAvailable {
-            addDouble(label: label, vector: $0.baseAddress!)
+            addDouble(key: key, vector: $0.baseAddress!)
         }
     }
-    
+
+    /// Adds a labeled vector to the index.
+    /// - Parameter key: Unique identifer for that object.
+    /// - Parameter vector: Double-precision vector.
+    /// - Throws: If runs out of memory.
+    public func add(key: Key, vector: Array<Float64>) {
+        add(key: key, vector: vector[...])
+    }
+
     /// Approximate nearest neighbors search.
     /// - Parameter vector: Double-precision query vector.
     /// - Parameter count: Upper limit on the number of matches to retrieve.
     /// - Returns: Labels and distances to closest approximate matches in decreasing similarity order.
     /// - Throws: If runs out of memory.
-    public func search(vector: ArraySlice<Float64>, count: Int) -> ([Label], [Float]) {
-        var matches: [Label] = Array(repeating: 0, count: count)
+    public func search(vector: ArraySlice<Float64>, count: Int) -> ([Key], [Float]) {
+        var matches: [Key] = Array(repeating: 0, count: count)
         var distances: [Float] = Array(repeating: 0, count: count)
         let results = vector.withContiguousStorageIfAvailable {
-            searchDouble(vector: $0.baseAddress!, count: CUnsignedInt(count), labels: &matches, distances: &distances)
+            searchDouble(vector: $0.baseAddress!, count: CUnsignedInt(count), keys: &matches, distances: &distances)
         }
         matches.removeLast(count - Int(results!))
         distances.removeLast(count - Int(results!))
         return (matches, distances)
     }
 
+    /// Approximate nearest neighbors search.
+    /// - Parameter vector: Double-precision query vector.
+    /// - Parameter count: Upper limit on the number of matches to retrieve.
+    /// - Returns: Labels and distances to closest approximate matches in decreasing similarity order.
+    /// - Throws: If runs out of memory.
+    public func search(vector: Array<Float64>, count: Int) -> ([Key], [Float]) {
+        search(vector: vector[...], count: count)
+    }
+
     #if arch(arm64)
 
         /// Adds a labeled vector to the index.
-        /// - Parameter label: Unique identifer for that object.
+        /// - Parameter key: Unique identifer for that object.
         /// - Parameter vector: Half-precision vector.
         /// - Throws: If runs out of memory.
         @available(macOS 11.0, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
-        public func add(label: Label, vector: ArraySlice<Float16>) {
+        public func add(key: Key, vector: ArraySlice<Float16>) {
             vector.withContiguousStorageIfAvailable { buffer in
-                addHalf(label: label, vector: buffer.baseAddress!)
+                addHalf(key: key, vector: buffer.baseAddress!)
             }
         }
 
+        /// Adds a labeled vector to the index.
+        /// - Parameter key: Unique identifer for that object.
+        /// - Parameter vector: Half-precision vector.
+        /// - Throws: If runs out of memory.
+        @available(macOS 11.0, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
+        public func add(key: Key, vector: Array<Float16>) {
+            add(key: key, vector: vector[...])
+        }
+
         /// Approximate nearest neighbors search.
         /// - Parameter vector: Half-precision query vector.
         /// - Parameter count: Upper limit on the number of matches to retrieve.
         /// - Returns: Labels and distances to closest approximate matches in decreasing similarity order.
         /// - Throws: If runs out of memory.
         @available(macOS 11.0, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
-        public func search(vector: ArraySlice<Float16>, count: Int) -> ([Label], [Float]) {
-            var matches: [Label] = Array(repeating: 0, count: count)
+        public func search(vector: ArraySlice<Float16>, count: Int) -> ([Key], [Float]) {
+            var matches: [Key] = Array(repeating: 0, count: count)
             var distances: [Float] = Array(repeating: 0, count: count)
             let results = vector.withContiguousStorageIfAvailable {
-                searchHalf(vector: $0.baseAddress!, count: CUnsignedInt(count), labels: &matches, distances: &distances)
+                searchHalf(vector: $0.baseAddress!, count: CUnsignedInt(count), keys: &matches, distances: &distances)
             }
             matches.removeLast(count - Int(results!))
             distances.removeLast(count - Int(results!))
             return (matches, distances)
         }
 
+        /// Approximate nearest neighbors search.
+        /// - Parameter vector: Half-precision query vector.
+        /// - Parameter count: Upper limit on the number of matches to retrieve.
+        /// - Returns: Labels and distances to closest approximate matches in decreasing similarity order.
+        /// - Throws: If runs out of memory.
+        @available(macOS 11.0, iOS 14.0, watchOS 7.0, tvOS 14.0, *)
+        public func search(vector: Array<Float16>, count: Int) -> ([Key], [Float]) {
+            search(vector: vector[...], count: count)
+        }
+
     #endif
 
     /// Number of vectors in the index.

package/swift/README.md

@@ -12,9 +12,33 @@ https://github.com/unum-cloud/usearch
 let index = Index.l2sq(dimensions: 3, connectivity: 8)
 let vectorA: [Float32] = [0.3, 0.5, 1.2]
 let vectorB: [Float32] = [0.4, 0.2, 1.2]
-index.add(label: 42, vector: vectorA[...])
-index.add(label: 43, vector: vectorB[...])
+index.add(key: 42, vector: vectorA[...])
+index.add(key: 43, vector: vectorB[...])
 
 let results = index.search(vector: vectorA[...], count: 10)
 assert(results.0[0] == 42)
 ```
+
+If using in a SwiftUI application, make sure to annulate the void responses:
+
+```swift
+import SwiftUI
+import USearch
+
+@main
+struct USearchMobileApp: App {
+    var body: some Scene {
+        WindowGroup {
+            let index = USearchIndex.make(metric: .IP, dimensions: 2, connectivity: 16, quantization: .F32)
+            let _ = index.reserve(10)
+            let coordiantes: Array<Float32> = [40.177200, 44.503490]
+            let _ = index.add(key: 10, vector: coordiantes[...])            
+            VStack {
+                Text("USearch index contains \(index.length) vectors")
+                Spacer()
+            }
+
+        }
+    }
+}
+```

package/swift/Test.swift

@@ -1,25 +1,37 @@
 //
 //  File.swift
-//  
 //
-//  Created by Ashot Vardanian on 5/11/23.
+//
+//  Created by Ash Vardanian on 5/11/23.
 //
 
 import Foundation
-import XCTest
 import USearch
+import XCTest
 
 @available(iOS 13, macOS 10.15, tvOS 13.0, watchOS 6.0, *)
 class Test: XCTestCase {
     func testUnit() throws {
-        let index = USearchIndex.make(metric:USearchMetric.l2sq, dimensions: 4, connectivity: 8, quantization:USearchScalar.F32)
+        let index = USearchIndex.make(metric: USearchMetric.l2sq, dimensions: 4, connectivity: 8, quantization: USearchScalar.F32)
         let vectorA: [Float32] = [0.3, 0.5, 1.2, 1.4]
         let vectorB: [Float32] = [0.4, 0.2, 1.2, 1.1]
         index.reserve(2)
-        index.add(label: 42, vector: vectorA[...])
-        index.add(label: 43, vector: vectorB[...])
         
-        let results = index.search(vector: vectorA[...], count: 10)
+        // Adding a slice
+        index.add(key: 42, vector: vectorA[...])
+        
+        // Adding a vector
+        index.add(key: 43, vector: vectorB)
+        
+        let results = index.search(vector: vectorA, count: 10)
         assert(results.0[0] == 42)
+        
+        assert(index.contains(key: 42))
+        assert(index.count(key: 42) == 1)
+        assert(index.count(key: 49) == 0)
+        index.rename(from: 42, to: 49)
+        assert(index.count(key: 49) == 1)
+        index.remove(key: 49)
+        assert(index.count(key: 49) == 0)
     }
 }

package/swift/USearch.swift

@@ -1,8 +1,8 @@
 //
 //  File.swift
-//  
 //
-//  Created by Ashot Vardanian on 5/11/23.
+//
+//  Created by Ash Vardanian on 5/11/23.
 //
 
 @_exported import USearchObjective

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+    "typedocOptions": {
+        "entryPoints": [
+            "javascript/usearch.d.ts"
+        ],
+        "out": "docs"
+    }
+}

package/wasm/CMakeLists.txt

@@ -13,3 +13,4 @@ set(USEARCH_PUNNED_INCLUDE_DIRS
 add_executable(index lib.cpp)
 target_include_directories(index PRIVATE ${USEARCH_PUNNED_INCLUDE_DIRS})
 set_target_properties(index PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/wasm)
+set_target_properties(index PROPERTIES CXX_STANDARD 11)

package/wasmer.toml

@@ -1,6 +1,6 @@
 [package]
 name="unum/usearch"
-version="0.22.3"
+version="1.1.0"
 description="Smaller & Faster Single-File Vector Search Engine from Unum"
 license="Apache-2.0"
 readme="README.md"

package/wolfram/CMakeLists.txt

@@ -15,3 +15,4 @@ target_link_libraries(usearchWFM WSTP::STATIC_LIBRARY)
 
 # Set the output name of the library to be compatible with Wolfram Language
 set_target_properties(usearchWFM PROPERTIES PREFIX "" OUTPUT_NAME "usearchWFM")
+set_target_properties(usearchWFM PROPERTIES CXX_STANDARD 11)

package/wolfram/lib.cpp

@@ -1,27 +1,25 @@
 #include "WolframLibrary.h"
-#include <usearch/index_punned_dense.hpp>
+#include <usearch/index_dense.hpp>
 
 using namespace unum::usearch;
 
-using metric_t = index_punned_dense_metric_t;
-using distance_t = punned_distance_t;
-using index_t = punned_small_t;
+using distance_t = distance_punned_t;
+using index_t = index_dense_t;
 using vector_view_t = span_gt<float>;
 
 using add_result_t = typename index_t::add_result_t;
 using search_result_t = typename index_t::search_result_t;
-using label_t = typename index_t::label_t;
-using id_t = typename index_t::id_t;
+using key_t = typename index_t::key_t;
 
 EXTERN_C DLLEXPORT int WolframLibrary_initialize(WolframLibraryData libData) { return LIBRARY_NO_ERROR; }
 EXTERN_C DLLEXPORT void WolframLibrary_uninitialize(WolframLibraryData libData) { return; }
 
 EXTERN_C DLLEXPORT int IndexCreate(WolframLibraryData libData, mint Argc, MArgument* Args, MArgument Res) {
     index_config_t config;
-    char* accuracy_cstr = nullptr;
+    char* quantization_cstr = nullptr;
     char* metric_cstr = nullptr;
     try {
-        accuracy_cstr = MArgument_getUTF8String(Args[1]);
+        quantization_cstr = MArgument_getUTF8String(Args[1]);
         metric_cstr = MArgument_getUTF8String(Args[0]);
         std::size_t dimensions = static_cast<std::size_t>(MArgument_getInteger(Args[2]));
         std::size_t capacity = static_cast<std::size_t>(MArgument_getInteger(Args[3]));
@@ -29,9 +27,9 @@ EXTERN_C DLLEXPORT int IndexCreate(WolframLibraryData libData, mint Argc, MArgum
         config.expansion_add = static_cast<std::size_t>(MArgument_getInteger(Args[5]));
         config.expansion_search = static_cast<std::size_t>(MArgument_getInteger(Args[6]));
 
-        scalar_kind_t accuracy = scalar_kind_from_name(accuracy_cstr, std::strlen(accuracy_cstr));
+        scalar_kind_t quantization = scalar_kind_from_name(quantization_cstr, std::strlen(quantization_cstr));
         metric_kind_t metric_kind = metric_from_name(metric_cstr, std::strlen(metric_cstr));
-        index_t index = make_punned<index_t>(metric_kind, dimensions, accuracy, config);
+        index_t index = make_punned<index_t>(metric_kind, dimensions, quantization, config);
         index.reserve(capacity);
 
         index_t* result_ptr = new index_t(std::move(index));
@@ -41,7 +39,7 @@ EXTERN_C DLLEXPORT int IndexCreate(WolframLibraryData libData, mint Argc, MArgum
         return LIBRARY_FUNCTION_ERROR;
     }
 
-    libData->UTF8String_disown(accuracy_cstr);
+    libData->UTF8String_disown(quantization_cstr);
     libData->UTF8String_disown(metric_cstr);
     return LIBRARY_NO_ERROR;
 }
@@ -119,12 +117,12 @@ EXTERN_C DLLEXPORT int IndexAdd(WolframLibraryData libData, mint Argc, MArgument
     index_t* c_ptr = (index_t*)MArgument_getUTF8String(Args[0]);
     float* vector_data = nullptr;
     try {
-        int label = MArgument_getInteger(Args[1]);
+        int key = MArgument_getInteger(Args[1]);
         MTensor tens = MArgument_getMTensor(Args[2]);
         std::size_t len = libData->MTensor_getFlattenedLength(tens);
         vector_data = (float*)libData->MTensor_getRealData(tens);
         vector_view_t vector_span = vector_view_t{vector_data, len};
-        c_ptr->add(label, vector_span);
+        c_ptr->add(key, vector_span);
     } catch (...) {
         return LIBRARY_FUNCTION_ERROR;
     }

package/golang/usearch.h

@@ -1,9 +0,0 @@
-#pragma once
-#include <stdlib.h>
-
-typedef struct {
-    int* Labels;
-    float* Distances;
-    int Len;
-    char* Error;
-} SearchResults;

package/golang/usearch_par_test.go

@@ -1,40 +0,0 @@
-package usearch
-
-import (
-	"sync"
-	"testing"
-)
-
-func TestParallelism(t *testing.T) {
-	totalInserts := 3000
-	ind := NewIndex(DefaultConfig(128))
-	defer ind.Destroy()
-
-	var v0 = make([]float32, 128)
-	v0[0] = 4.4
-	var wg sync.WaitGroup
-	ind.Reserve(totalInserts)
-
-	// second thread
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-		var v1 = make([]float32, 128)
-		for l := 0; l < totalInserts/2; l++ {
-			ind.Add(10000+l, v1)
-		}
-	}()
-
-	for l := 0; l < totalInserts/2; l++ {
-		ind.Add(l, v0)
-	}
-	wg.Wait()
-	if ind.Len() != totalInserts {
-		t.Errorf("wrong length: expected %d, got %d", totalInserts, ind.Len())
-	}
-
-	res := ind.Search(v0[:], 10)
-	if len(res) != 10 {
-		t.Errorf("wrong search result length: expected %d, got %d", 10, len(res))
-	}
-}