usearch 0.1.9 → 0.2.0

package/.vscode/settings.json

@@ -100,9 +100,15 @@
         "version": "cpp"
     },
     "cSpell.words": [
+        "astype",
+        "dtype",
         "equidimensional",
+        "hashable",
         "jaccard",
+        "longlong",
+        "memmap",
         "ndim",
+        "preprocess",
         "simsimd",
         "usearch"
     ],

package/CMakeLists.txt

@@ -7,6 +7,10 @@ set(CMAKE_CXX_EXTENSIONS NO)
 
 option(USEARCH_USE_JEMALLOC "Use JeMalloc for Faster Memory Allocations" OFF)
 option(USEARCH_USE_OPENMP "Use OpenMP for a thread pool" OFF)
+option(USEARCH_USE_SIMD "Use SIMD hardware acceleration" OFF)
+
+option(USEARCH_BUILD_BENCHMARK "Compile a native benchmark in C++" ON)
+option(USEARCH_BUILD_WOLFRAM "Compile Wolfram Language bindings" OFF)
 
 # Make "Release" by default
 if(NOT CMAKE_BUILD_TYPE)
@@ -42,7 +46,6 @@ elseif(CMAKE_CXX_COMPILER_ID STREQUAL "NVIDIA" OR CMAKE_CXX_COMPILER_ID STREQUAL
 elseif(CMAKE_CXX_COMPILER_ID STREQUAL "IntelLLVM")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -w")
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -ferror-limit=1")
-
 endif()
 
 if(APPLE)
@@ -52,6 +55,7 @@ if(APPLE)
     set(CMAKE_USE_PTHREADS_INIT 1)
     set(THREADS_PREFER_PTHREAD_FLAG ON)
 endif()
+
 find_package(Threads REQUIRED)
 
 if(${USEARCH_USE_OPENMP})
@@ -62,11 +66,13 @@ endif()
 if(${USEARCH_USE_JEMALLOC})
     include("${CMAKE_CURRENT_SOURCE_DIR}/cmake/jemalloc.cmake")
 endif()
+
 include("${CMAKE_CURRENT_SOURCE_DIR}/cmake/clipp.cmake")
 
 include_directories("${CMAKE_CURRENT_SOURCE_DIR}/include")
 include_directories("${CMAKE_CURRENT_SOURCE_DIR}/fp16/include")
 include_directories("${CMAKE_CURRENT_SOURCE_DIR}/simsimd/include")
+include_directories("${CMAKE_CURRENT_SOURCE_DIR}/src")
 
 # Define our header-only library.
 add_library(usearch INTERFACE)
@@ -74,11 +80,23 @@ target_sources(usearch INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/include/usearch/us
 target_include_directories(usearch INTERFACE "${CMAKE_CURRENT_SOURCE_DIR}/include")
 
 # Define the targets
-add_executable(bench src/bench.cpp)
-target_link_libraries(bench PRIVATE Threads::Threads)
-if(${USEARCH_USE_OPENMP})
-    target_link_libraries(bench PRIVATE ${OPENMP_LIBRARIES})
-endif()
-if(${USEARCH_USE_JEMALLOC})
-    target_link_libraries(bench PRIVATE ${JEMALLOC_LIBRARIES})
+if(${USEARCH_BUILD_BENCHMARK})
+    add_executable(bench src/bench.cpp)
+    target_link_libraries(bench PRIVATE Threads::Threads)
+
+    if(${USEARCH_USE_SIMD})
+        target_compile_definitions(bench PRIVATE USEARCH_USE_SIMD=1)
+    endif()
+
+    if(${USEARCH_USE_OPENMP})
+        target_link_libraries(bench PRIVATE ${OPENMP_LIBRARIES})
+    endif()
+
+    if(${USEARCH_USE_JEMALLOC})
+        target_link_libraries(bench PRIVATE ${JEMALLOC_LIBRARIES})
+    endif()
 endif()
+
+if(${USEARCH_BUILD_WOLFRAM})
+    add_subdirectory(wolfram)
+endif()

package/CMakeListsInstructions.md

@@ -13,16 +13,22 @@ git submodule update --init --recursive
 ```sh
 cmake -B ./build_release \
     -DCMAKE_BUILD_TYPE=Release \
+    -DUSEARCH_USE_SIMD=1 \
     -DUSEARCH_USE_OPENMP=1 \
     -DUSEARCH_USE_JEMALLOC=1 && \
     make -C ./build_release -j
 
-# To benchmark:
+# To benchmark in C++:
 ./build_release/bench \
     --vectors datasets/wiki_1M/base.1M.fbin \
     --queries datasets/wiki_1M/query.public.100K.fbin \
-    --neighbors datasets/wiki_1M/groundtruth.public.100K.ibin \
-    --ip
+    --neighbors datasets/wiki_1M/groundtruth.public.100K.ibin
+
+# To benchmark in Python:
+python python/bench.py \
+    --vectors datasets/wiki_1M/base.1M.fbin \
+    --queries datasets/wiki_1M/query.public.100K.fbin \
+    --neighbors datasets/wiki_1M/groundtruth.public.100K.ibin
 ```
 
 ### MacOS
@@ -32,15 +38,10 @@ brew install libomp llvm
 cmake \
     -DCMAKE_C_COMPILER="/opt/homebrew/opt/llvm/bin/clang" \
     -DCMAKE_CXX_COMPILER="/opt/homebrew/opt/llvm/bin/clang++" \
+    -DUSEARCH_USE_SIMD=1 \
+    -DUSEARCH_USE_OPENMP=1 \
      -B ./build_release && \
-    make -C ./build_release -j
-
-# To benchmark:
-./build_release/bench \
-    --vectors datasets/wiki_1M/base.1M.fbin \
-    --queries datasets/wiki_1M/query.public.100K.fbin \
-    --neighbors datasets/wiki_1M/groundtruth.public.100K.ibin \
-    --ip     
+    make -C ./build_release -j 
 ```
 
 ### Python
@@ -48,13 +49,6 @@ cmake \
 ```sh
 pip install -e .
 python python/test.py
-
-# To benchmark:
-python python/bench.py \
-    --vectors datasets/wiki_1M/base.1M.fbin \
-    --queries datasets/wiki_1M/query.public.100K.fbin \
-    --neighbors datasets/wiki_1M/groundtruth.public.100K.ibin \
-    --ip 
 ```
 
 ### JavaScript
@@ -113,24 +107,45 @@ brew install --cask wolfram-engine
 
 ### Datasets
 
-### Evaluation
+BigANN benchmark is a good starting point, if you are searching for large collections of high-dimensional vectors.
+Those often come with precomputed ground-truth neighbors, which is handy for recall evaluation.
+
+| Dataset                         | Scalar Type | Dimensions | Metric |  Size  |
+| :------------------------------ | :---------: | :--------: | :----: | :----: |
+| [Microsoft SPACEV][spacev]      |    int8     |    100     |   L2   | 93 GB  |
+| [Microsoft Turing-ANNS][turing] |   float32   |    100     |   L2   | 373 GB |
+| [Yandex Deep1B][deep]           |   float32   |     96     |   L2   | 358 GB |
+| [Yandex Text-to-Image][t2i]     |   float32   |    200     |  Cos   | 750 GB |
 
-Yandex Text-to-Image embeddings.
+Luckily, smaller samples of those datasets are available.
+
+[spacev]: https://github.com/microsoft/SPTAG/tree/main/datasets/SPACEV1B
+[turing]: https://learning2hash.github.io/publications/microsoftturinganns1B/
+[t2i]: https://research.yandex.com/blog/benchmarks-for-billion-scale-similarity-search
+[deep]: https://research.yandex.com/blog/benchmarks-for-billion-scale-similarity-search
+
+### Yandex Deep1B
+
+There is a 10M subset available.
 
 ```sh
-export path_vectors=datasets/t2i_1M/base.1M.fbin
-export path_queries=datasets/t2i_1M/query.public.100K.fbin
-export path_neighbors=datasets/t2i_1M/groundtruth.public.100K.ibin
-./build_release/bench
+mkdir -p datasets/deep/ && \
+    wget -nc https://storage.yandexcloud.net/yandex-research/ann-datasets/DEEP/base.1B.fbin -P datasets/deep_1B/ &&
+    wget -nc https://storage.yandexcloud.net/yandex-research/ann-datasets/DEEP/base.10M.fbin -P datasets/deep_1B/ &&
+    wget -nc https://storage.yandexcloud.net/yandex-research/ann-datasets/DEEP/query.public.10K.fbin -P datasets/deep_1B/ &&
+    wget -nc https://storage.yandexcloud.net/yandex-research/ann-datasets/DEEP/groundtruth.public.10K.ibin -P datasets/deep_1B/
 ```
 
-Wikipedia UForm embeddings.
+### Yandex Text-to-Image
+
+There is a 1M subset available.
 
 ```sh
-export path_vectors=datasets/wiki_1M/base.1M.fbin
-export path_queries=datasets/wiki_1M/query.public.100K.fbin 
-export path_neighbors=datasets/wiki_1M/groundtruth.public.100K.ibin
-./build_release/bench
+mkdir -p datasets/t2i/ && \
+    wget -nc https://storage.yandexcloud.net/yandex-research/ann-datasets/T2I/base.1B.fbin -P datasets/t2i_1B/ &&
+    wget -nc https://storage.yandexcloud.net/yandex-research/ann-datasets/T2I/base.1M.fbin -P datasets/t2i_1B/ &&
+    wget -nc https://storage.yandexcloud.net/yandex-research/ann-datasets/T2I/query.public.100K.fbin -P datasets/t2i_1B/ &&
+    wget -nc https://storage.yandexcloud.net/yandex-research/ann-datasets/T2I/groundtruth.public.100K.ibin -P datasets/t2i_1B/
 ```
 
 ### Profiling
@@ -139,9 +154,10 @@ With `perf`:
 
 ```sh
 # Pass environment variables with `-E`, and `-d` for details
-sudo -E perf stat -d ./build_release/bench
-sudo -E perf mem -d ./build_release/bench
+sudo -E perf stat -d ./build_release/bench ...
+sudo -E perf mem -d ./build_release/bench ...
 # Sample on-CPU functions for the specified command, at 1 Kilo Hertz:
-sudo -E perf record -F 1000 ./build_release/bench
-perf record -d -e arm_spe// -- ./build_release/bench
+sudo -E perf record -F 1000 ./build_release/bench ...
+perf record -d -e arm_spe// -- ./build_release/bench ..
 ```
+

package/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "usearch"
-version = "0.1.9"
+version = "0.2.0"
 authors = ["Ashot Vardanian <1983160+ashvardanian@users.noreply.github.com>"]
-description = "The Mighty Tiny Vector Search Engine with Automatic Quantization and Hardware Acceleration"
+description = "Smaller & Faster Single-File Vector Search Engine from Unum"
 edition = "2021"
 license = "Apache-2.0"
 publish = true

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -1,7 +1,7 @@
 <h1 align="center">USearch</h1>
 <h3 align="center">
-C++11 Single Header Vector Search<br/>
-Compact, yet Powerful<br/>
+Smaller & Faster Single-File<br/>
+Vector Search Engine<br/>
 </h3>
 <br/>
 
@@ -27,20 +27,20 @@ Compact, yet Powerful<br/>
   - [x] Hardware-accelerated [`ashvardanian/simsimd`](https://github.com/ashvardanian/simsimd). 
 - [x] Variable dimensionality vectors.
 - [x] Don't copy vectors if not needed.
-- [x] Bring your threads.
+- [x] [Bring your threads](#bring-your-threads), like OpenMP.
 - [x] Multiple vectors per label.
 - [x] [Python](#python) bindings: `pip install usearch`.
 - [x] [JavaScript](#java) bindings: `npm install usearch`.
 - [x] [Rust](#rust) bindings: `cargo add usearch`.
 - [x] [Java](#java) bindings: `cloud.unum:usearch` on GitHub.
 - [ ] GoLang bindings.
-- [ ] Wolfram language bindings.
+- [x] Wolfram language bindings.
 - [x] For Linux: GCC, Clang.
 - [x] For MacOS: Apple Clang.
 - [ ] For Windows.
 - [ ] Multi-index lookups in Python.
 - [ ] Thread-safe `reserve`.
-- [ ] Distributed construction.
+- [ ] Distributed construction with MPI.
 - [x] AI + Vector Search = Semantic Search.
 
 [usearch-header]: https://github.com/unum-cloud/usearch/blob/main/include/usearch/usearch.hpp
@@ -80,12 +80,11 @@ Constructing a vector index is a memory-intensive task.
 Depending on your configuration parameters, part of the memory will be allocated towards copies of vectors, and another part to the Small World Graph, common to NSW-like algorithms.
 Choosing the right data-structures and numeric types can have profound implications on both.
 
----
+![USearch uint40_t support](assets/usearch-neighbor-types.png)
 
 Internally, some point "label" is mapped into an integer identifier for every stored vector.
 Most implementations hard-code it to `uint32_t`, as people rarely store more than 4 Billion vectors.
 But when they do, software becomes unusable.
-
 Others hard-code it to `uint64_t`, which hardly space-efficient.
 We added a tiny class - `uint40_t`, that should be enough for collections up to 1 Trillion vectors.
 
@@ -94,17 +93,24 @@ We added a tiny class - `uint40_t`, that should be enough for collections up to
 To construct a large index one may use a beefy RAM-optimized machine, like the AWS `u-24tb1.metal` instances with 24 TB of RAM.
 Those are, however, pricy, and would cost you over $200/hour.
 
+|          |   To Build    |    To Serve    |
+| :------- | :-----------: | :------------: |
+| Instance | u-24tb1.metal | is4gen.8xlarge |
+| Price    |   ~ $200/h    |    ~$4.5/h     |
+| RAM      |     24 TB     |     192 GB     |
+| SSD      |      EBS      |     30 TB      |
+
 You wouldn't want to have them running all the time.
 So, if you are working on large datasets, but don't need the in-RAM throughput, you can simply view an existing dataset from disk, without ever loading it fully into memory.
 
-Construct on large machines, deploy on the cheap ones.
+> Construct on large machines, deploy on the cheap ones.
 
 ### Quantize on the Fly
 
 Most modern CPU have at least partial support for `half`-precision `f16_t` arithmetic.
 USearch supports automatic down-casting and up-casting between `f32_t`, `f16_t`, `f64_t`, and `i8q100_t` representations.
 
-Making vectors smaller will help pack more of them in-memory, while also increasing performance on CPUs implementing native support for target type.
+> Making vectors smaller will help pack more of them in-memory, while also increasing performance on CPUs implementing native support for target type.
 
 ## Performance
 
@@ -213,14 +219,23 @@ import numpy as np
 import usearch
 
 index = usearch.Index(
-    dim=256, # Define the number of dimensions in input vectors
+    ndim=256, # Define the number of dimensions in input vectors
     metric='cos', # Choose the "metric" or "distance", default = 'ip', optional
-    dtype='f16', # Quantize to 'f16' or 'i8q100' if needed, default = 'f32', optional
+    dtype='f32', # Quantize to 'f16' or 'i8q100' if needed, default = 'f32', optional
     connectivity=16, # How frequent should the connections in the graph be, optional
     expansion_add=128, # Control the recall of indexing, optional
     expansion_search=64, # Control the quality of search, optional
 )
 
+vector = np.random.uniform(0, 0.3, (index.ndim)).astype(np.float32)
+index.add(42, vector)
+matches, distances, count = index.search(vector, 10)
+```
+
+Same can be done with batches, rather than single entries.
+Under the hood, worker threads will be spawned, to parallelize the procedure.
+
+```py
 n = 100
 labels = np.array(range(n), dtype=np.longlong)
 vectors = np.random.uniform(0, 0.3, (n, index.ndim)).astype(np.float32)
@@ -228,9 +243,6 @@ vectors = np.random.uniform(0, 0.3, (n, index.ndim)).astype(np.float32)
 # You can avoid copying the data
 # Handy when build 1B+ indexes of memory-mapped files
 index.add(labels, vectors, copy=True)
-assert len(index) == n
-
-# You can search a batch at once
 matches, distances, counts = index.search(vectors, 10)
 ```
 
@@ -395,21 +407,20 @@ from PIL import Image
 
 server = ucall.Server()
 model = uform.get_model('unum-cloud/uform-vl-multilingual')
-index = usearch.Index(dim=256)
+index = usearch.Index(ndim=256)
 
 @server
 def add(label: int, photo: Image.Image):
     image = model.preprocess_image(photo)
     vector = model.encode_image(image).detach().numpy()
-    labels = np.array([label], dtype=np.longlong)
-    index.add(labels, vector, copy=True)
+    index.add(label, vector.flatten(), copy=True)
 
 @server
 def search(query: str) -> np.ndarray:
     tokens = model.preprocess_text(query)
     vector = model.encode_text(tokens).detach().numpy()
-    neighbors = index.search(vector, 3)
-    return neighbors[0][:neighbors[2][0]]
+    neighbors, _, _ = index.search(vector.flatten(), 3)
+    return neighbors
 
 server.run()
 ```

package/VERSION

@@ -1 +1 @@
-0.1.9
+0.2.0

package/build.gradle

@@ -90,7 +90,7 @@ publishing {
 
             pom {
                 name = "USearch"
-                description = "The Mighty Tiny Vector Search Engine with Automatic Quantization and Hardware Acceleration"
+                description = "Smaller & Faster Single-File Vector Search Engine from Unum"
                 url = "https://github.com/unum-cloud/usearch"
                 licenses {
                     license {

package/include/usearch/usearch.hpp

@@ -136,6 +136,30 @@ template <typename scalar_at> struct l2_squared_gt {
     }
 };
 
+/**
+ *  @brief  Hamming distance computes the number of differing elements in
+ *          two arrays. An example would be a chess board.
+ */
+template <typename scalar_at> struct hamming_gt {
+    using scalar_t = scalar_at;
+    using result_type = std::size_t;
+
+    inline std::size_t operator()(scalar_t const* a, scalar_t const* b, std::size_t elements,
+                                  std::size_t = 0) const noexcept {
+        std::size_t matches{};
+#if defined(__GNUC__)
+#pragma GCC ivdep
+#elif defined(__clang__)
+#pragma clang loop vectorize(enable)
+#elif defined(_OPENMP)
+#pragma omp simd reduction(+ : matches)
+#endif
+        for (std::size_t i = 0; i != elements; ++i)
+            matches += a[i] != b[i];
+        return matches;
+    }
+};
+
 /**
  *  @brief  Hamming distance computes the number of differing bits in
  *          two arrays of integers. An example would be a textual document,
@@ -315,8 +339,9 @@ class max_heap_gt {
     bool empty() const noexcept { return !size_; }
     std::size_t size() const noexcept { return size_; }
     std::size_t capacity() const noexcept { return capacity_; }
+    /// @brief  Selects the largest element in the heap.
+    /// @return Reference to the stored element.
     element_t const& top() const noexcept { return elements_[0]; }
-    element_t const& max() const noexcept { return elements_[0]; }
 
     void clear() noexcept {
         while (size_) {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "usearch",
-    "version": "0.1.9",
-    "description": "The Mighty Tiny Vector Search Engine with Automatic Quantization and Hardware Acceleration",
+    "version": "0.2.0",
+    "description": "Smaller & Faster Single-File Vector Search Engine from Unum",
     "author": "Ashot Vardanian",
     "license": "Apache 2.0",
     "repository": {