usearch 2.16.8 → 2.16.9

package/README.md

@@ -546,7 +546,7 @@ doi = {10.5281/zenodo.7949416},
 author = {Vardanian, Ash},
 title = {{USearch by Unum Cloud}},
 url = {https://github.com/unum-cloud/usearch},
-version = {2.16.8},
+version = {2.16.9},
 year = {2023},
 month = oct,
 }

package/include/usearch/index.hpp

@@ -9,7 +9,7 @@
 
 #define USEARCH_VERSION_MAJOR 2
 #define USEARCH_VERSION_MINOR 16
-#define USEARCH_VERSION_PATCH 8
+#define USEARCH_VERSION_PATCH 9
 
 // Inferring C++ version
 // https://stackoverflow.com/a/61552074

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "usearch",
-    "version": "2.16.8",
+    "version": "2.16.9",
     "description": "Smaller & Faster Single-File Vector Search Engine from Unum",
     "author": "Ash Vardanian (https://ashvardanian.com/)",
     "license": "Apache 2.0",

package/simsimd/CONTRIBUTING.md

@@ -6,6 +6,26 @@ To keep the quality of the code high, we have a set of [guidelines](https://gith
 - [How to organize branches?](https://github.com/unum-cloud/awesome/blob/main/Workflow.md#branches)
 - [How to style commits?](https://github.com/unum-cloud/awesome/blob/main/Workflow.md#commits)
 
+## Navigating the Codebase
+
+Primary kernels are implemented in header files under `include/simsimd/`:
+
+- `dot.h` - dot products for real and complex vectors.
+- `spatial.h` - spatial distances: L2, cosine distance.
+- `binary.h` - binary distances: Hamming, Jaccard, etc.
+- `probability.h` - probability metrics: KL-divergence, Jensen-Shannon, etc.
+- `sparse.h` - sparse distances: weighted and normal set intersections.
+- `curved.h` - bilinear forms for real and complex vectors, and Mahalanobis distance.
+
+Bindings to other languages are in the respective directories:
+
+- `python/lib.c` - Python bindings.
+- `javascript/lib.c` - JavaScript bindings.
+- `rust/lib.rs` - Rust bindings.
+- `swift/SimSIMD.swift` - Swift bindings.
+
+All tests, benchmarks, and examples are placed in the `scripts/` directory, if compatible with the toolchain of the implementation language.
+
 ## C and C++
 
 To rerun experiments utilize the following command:
@@ -63,6 +83,15 @@ cmake -D CMAKE_BUILD_TYPE=Release \
 cmake --build build_release --config Release
 ```
 
+When benchmarking, make sure to disable multi-threading in the BLAS library, as it may interfere with the results:
+
+```sh
+export OPENBLAS_NUM_THREADS=1 # for OpenBLAS
+export MKL_NUM_THREADS=1 # for Intel MKL
+export VECLIB_MAXIMUM_THREADS=1 # for Apple Accelerate
+export BLIS_NUM_THREADS=1 # for BLIS
+```
+
 ## Python
 
 Testing:
@@ -140,7 +169,6 @@ cibuildwheel --platform linux                   # works on any OS and builds all
 cibuildwheel --platform linux --archs x86_64    # 64-bit x86, the most common on desktop and servers
 cibuildwheel --platform linux --archs aarch64   # 64-bit Arm for mobile devices, Apple M-series, and AWS Graviton
 cibuildwheel --platform linux --archs i686      # 32-bit Linux
-cibuildwheel --platform linux --archs s390x     # emulating big-endian IBM Z
 cibuildwheel --platform macos                   # works only on MacOS
 cibuildwheel --platform windows                 # works only on Windows
 ```
@@ -168,35 +196,65 @@ open target/criterion/report/index.html
 
 ## JavaScript
 
-If you don't have NPM installed:
+### NodeJS
+
+If you don't have the environment configured, here are the [installation options](https://github.com/nvm-sh/nvm?tab=readme-ov-file#install--update-script) with different tools:
+
+```sh
+wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash # Linux
+curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.1/install.sh | bash  # MacOS
+```
+
+Install dependencies:
 
 ```sh
-wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
 nvm install 20
+npm install -g typescript           # Install the TypeScript compiler globally
+npm install --save-dev @types/node  # Install the Node.js type definitions as a dev dependency
 ```
 
 Testing and benchmarking:
 
 ```sh
-npm install -g typescript
-npm run build-js
-npm test
-npm run bench
+npm run build-js                    # Build the JavaScript code using TypeScript configurations
+npm test                            # Run the test suite
+npm run bench                       # Run the benchmark script
 ```
 
-Running with Deno:
+### Deno
+
+If you don't have the environment configured, here are [installation options](https://docs.deno.com/runtime/getting_started/installation/) with different tools:
+
+```sh
+wget -qO- https://deno.land/x/install/install.sh | sh # Linux
+curl -fsSL https://deno.land/install.sh | sh          # MacOS
+irm https://deno.land/install.ps1 | iex               # Windows
+```
+
+Testing:
 
 ```sh
 deno test --allow-read
 ```
 
-Running with Bun:
+### Bun
+
+If you don't have the environment configured, here are the [installation options](https://bun.sh/docs/installation) with different tools:
+
+```sh
+wget -qO- https://bun.sh/install | bash   # for Linux
+curl -fsSL https://bun.sh/install | bash  # for macOS and WSL
+```
+
+Testing:
 
 ```sh
-npm install -g bun
-bun test
+bun install
+bun test ./scripts/test.mjs
 ```
 
+... wouldn't work for now.
+
 ## Swift
 
 ```sh
@@ -239,4 +297,3 @@ cd golang
 go test # To test
 go test -run=^$ -bench=. -benchmem # To benchmark
 ```
-

package/simsimd/Cargo.lock

@@ -496,7 +496,7 @@ dependencies = [
 
 [[package]]
 name = "simsimd"
-version = "6.0.5"
+version = "6.2.3"
 dependencies = [
  "cc",
  "criterion",

package/simsimd/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "simsimd"
 description = "Portable mixed-precision BLAS-like vector math library for x86 and ARM"
-version = "6.0.5"
+version = "6.2.3"
 edition = "2021"
 license = "Apache-2.0"
 authors = ["Ash Vardanian <1983160+ashvardanian@users.noreply.github.com>"]

package/simsimd/README.md

@@ -9,7 +9,7 @@ The rare few that support minimal mixed precision, run only on one platform, and
 SimSIMD provides an alternative.
 1️⃣ SimSIMD functions are practically as fast as `memcpy`.
 2️⃣ Unlike BLAS, most kernels are designed for mixed-precision and bit-level operations.
-3️⃣ SimSIMD [compiles to more platforms than NumPy (105 vs 35)][compatibility] and has more backends than most BLAS implementations, and more high-level interfaces than most libraries.
+3️⃣ SimSIMD often [ships more binaries than NumPy][compatibility] and has more backends than most BLAS implementations, and more high-level interfaces than most libraries.
 
 [benchmarks]: https://ashvardanian.com/posts/simsimd-faster-scipy
 [compatibility]: https://pypi.org/project/simsimd/#files
@@ -42,7 +42,7 @@ SimSIMD provides an alternative.
 
 ## Features
 
-__SimSIMD__ (Arabic: "سيمسيم دي") is a mixed-precision math library of __over 200 SIMD-optimized kernels__ extensively used in AI, Search, and DBMS workloads.
+__SimSIMD__ (Arabic: "سيمسيم دي") is a mixed-precision math library of __over 350 SIMD-optimized kernels__ extensively used in AI, Search, and DBMS workloads.
 Named after the iconic ["Open Sesame"](https://en.wikipedia.org/wiki/Open_sesame) command that opened doors to treasure in _Ali Baba and the Forty Thieves_, SimSimd can help you 10x the cost-efficiency of your computational pipelines.
 Implemented distance functions include:
 
@@ -92,17 +92,196 @@ You can learn more about the technical implementation details in the following b
 
 ## Benchmarks
 
-For reference, we use 1536-dimensional vectors, like the embeddings produced by the OpenAI Ada API.
-Comparing the serial code throughput produced by GCC 12 to hand-optimized kernels in SimSIMD, we see the following single-core improvements for the two most common vector-vector similarity metrics - the Cosine similarity and the Euclidean distance:
+<table style="width: 100%; text-align: center; table-layout: fixed;">
+  <colgroup>
+    <col style="width: 33%;">
+    <col style="width: 33%;">
+    <col style="width: 33%;">
+  </colgroup>
+  <tr>
+    <th align="center">NumPy</th>
+    <th align="center">C 99</th>
+    <th align="center">SimSIMD</th>
+  </tr>
+  <!-- Cosine distances with different precision levels -->
+  <tr>
+    <td colspan="4" align="center">cosine distances between 1536d vectors in <code>int8</code></td>
+  </tr>
+  <tr>
+    <td align="center"> <!-- scipy.spatial.distance.cosine -->
+      🚧 overflows<br/>
+    </td>
+    <td align="center"> <!-- serial -->
+      <span style="color:#ABABAB;">x86:</span> <b>10,548,600</b> ops/s<br/>
+      <span style="color:#ABABAB;">arm:</span> <b>11,379,300</b> ops/s
+    </td>
+    <td align="center"> <!-- simsimd -->
+      <span style="color:#ABABAB;">x86:</span> <b>16,151,800</b> ops/s<br/>
+      <span style="color:#ABABAB;">arm:</span> <b>13,524,000</b> ops/s
+    </td>
+  </tr>
+  <tr>
+    <td colspan="4" align="center">cosine distances between 1536d vectors in <code>bfloat16</code></td>
+  </tr>
+  <tr>
+    <td align="center"> <!-- scipy.spatial.distance.cosine -->
+      🚧 not supported<br/>
+    </td>
+    <td align="center"> <!-- serial -->
+      <span style="color:#ABABAB;">x86:</span> <b>119,835</b> ops/s<br/>
+      <span style="color:#ABABAB;">arm:</span> <b>403,909</b> ops/s
+    </td>
+    <td align="center"> <!-- simsimd -->
+      <span style="color:#ABABAB;">x86:</span> <b>9,738,540</b> ops/s<br/>
+      <span style="color:#ABABAB;">arm:</span> <b>4,881,900</b> ops/s
+    </td>
+  </tr>
+  <tr>
+    <td colspan="4" align="center">cosine distances between 1536d vectors in <code>float16</code></td>
+  </tr>
+  <tr>
+    <td align="center"> <!-- scipy.spatial.distance.cosine -->
+      <span style="color:#ABABAB;">x86:</span> <b>40,481</b> ops/s<br/>
+      <span style="color:#ABABAB;">arm:</span> <b>21,451</b> ops/s
+    </td>
+    <td align="center"> <!-- serial -->
+      <span style="color:#ABABAB;">x86:</span> <b>501,310</b> ops/s<br/>
+      <span style="color:#ABABAB;">arm:</span> <b>871,963</b> ops/s
+    </td>
+    <td align="center"> <!-- simsimd -->
+      <span style="color:#ABABAB;">x86:</span> <b>7,627,600</b> ops/s<br/>
+      <span style="color:#ABABAB;">arm:</span> <b>3,316,810</b> ops/s
+    </td>
+  </tr>
+  <tr>
+    <td colspan="4" align="center">cosine distances between 1536d vectors in <code>float32</code></td>
+  </tr>
+  <tr>
+    <td align="center"> <!-- scipy.spatial.distance.cosine -->
+      <span style="color:#ABABAB;">x86:</span> <b>253,902</b> ops/s<br/>
+      <span style="color:#ABABAB;">arm:</span> <b>46,394</b> ops/s
+    </td>
+    <td align="center"> <!-- serial -->
+      <span style="color:#ABABAB;">x86:</span> <b>882,484</b> ops/s<br/>
+      <span style="color:#ABABAB;">arm:</span> <b>399,661</b> ops/s
+    </td>
+    <td align="center"> <!-- simsimd -->
+      <span style="color:#ABABAB;">x86:</span> <b>8,202,910</b> ops/s<br/>
+      <span style="color:#ABABAB;">arm:</span> <b>3,400,620</b> ops/s
+    </td>
+  </tr>
+  <tr>
+    <td colspan="4" align="center">cosine distances between 1536d vectors in <code>float64</code></td>
+  </tr>
+  <tr>
+    <td align="center"> <!-- scipy.spatial.distance.cosine -->
+      <span style="color:#ABABAB;">x86:</span> <b>212,421</b> ops/s<br/>
+      <span style="color:#ABABAB;">arm:</span> <b>52,904</b> ops/s
+    </td>
+    <td align="center"> <!-- serial -->
+      <span style="color:#ABABAB;">x86:</span> <b>839,301</b> ops/s<br/>
+      <span style="color:#ABABAB;">arm:</span> <b>837,126</b> ops/s
+    </td>
+    <td align="center"> <!-- simsimd -->
+      <span style="color:#ABABAB;">x86:</span> <b>1,538,530</b> ops/s<br/>
+      <span style="color:#ABABAB;">arm:</span> <b>1,678,920</b> ops/s
+    </td>
+  </tr>
+
+  <!-- Euclidean distance with different precision level -->
+  <tr>
+    <td colspan="4" align="center">eculidean distance between 1536d vectors in <code>int8</code></td>
+  </tr>
+  <tr>
+    <td align="center"> <!-- scipy.spatial.distance.sqeuclidean -->
+      <span style="color:#ABABAB;">x86:</span> <b>252,113</b> ops/s<br/>
+      <span style="color:#ABABAB;">arm:</span> <b>177,443</b> ops/s
+    </td>
+    <td align="center"> <!-- serial -->
+      <span style="color:#ABABAB;">x86:</span> <b>6,690,110</b> ops/s<br/>
+      <span style="color:#ABABAB;">arm:</span> <b>4,114,160</b> ops/s
+    </td>
+    <td align="center"> <!-- simsimd -->
+      <span style="color:#ABABAB;">x86:</span> <b>18,989,000</b> ops/s<br/>
+      <span style="color:#ABABAB;">arm:</span> <b>18,878,200</b> ops/s
+    </td>
+  </tr>
+  <tr>
+    <td colspan="4" align="center">eculidean distance between 1536d vectors in <code>bfloat16</code></td>
+  </tr>
+  <tr>
+    <td align="center"> <!-- scipy.spatial.distance.sqeuclidean -->
+      🚧 not supported<br/>
+    </td>
+    <td align="center"> <!-- serial -->
+      <span style="color:#ABABAB;">x86:</span> <b>119,842</b> ops/s<br/>
+      <span style="color:#ABABAB;">arm:</span> <b>1,049,230</b> ops/s
+    </td>
+    <td align="center"> <!-- simsimd -->
+      <span style="color:#ABABAB;">x86:</span> <b>9,727,210</b> ops/s<br/>
+      <span style="color:#ABABAB;">arm:</span> <b>4,233,420</b> ops/s
+    </td>
+  </tr>
+  <tr>
+    <td colspan="4" align="center">eculidean distance between 1536d vectors in <code>float16</code></td>
+  </tr>
+  <tr>
+    <td align="center"> <!-- scipy.spatial.distance.sqeuclidean -->
+      <span style="color:#ABABAB;">x86:</span> <b>54,621</b> ops/s<br/>
+      <span style="color:#ABABAB;">arm:</span> <b>71,793</b> ops/s
+    </td>
+    <td align="center"> <!-- serial -->
+      <span style="color:#ABABAB;">x86:</span> <b>196,413</b> ops/s<br/>
+      <span style="color:#ABABAB;">arm:</span> <b>911,370</b> ops/s
+    </td>
+    <td align="center"> <!-- simsimd -->
+      <span style="color:#ABABAB;">x86:</span> <b>19,466,800</b> ops/s<br/>
+      <span style="color:#ABABAB;">arm:</span> <b>3,522,760</b> ops/s
+    </td>
+  </tr>
+  <tr>
+    <td colspan="4" align="center">eculidean distance between 1536d vectors in <code>float32</code></td>
+  </tr>
+  <tr>
+    <td align="center"> <!-- scipy.spatial.distance.sqeuclidean -->
+      <span style="color:#ABABAB;">x86:</span> <b>424,944</b> ops/s<br/>
+      <span style="color:#ABABAB;">arm:</span> <b>292,629</b> ops/s
+    </td>
+    <td align="center"> <!-- serial -->
+      <span style="color:#ABABAB;">x86:</span> <b>1,295,210</b> ops/s<br/>
+      <span style="color:#ABABAB;">arm:</span> <b>1,055,940</b> ops/s
+    </td>
+    <td align="center"> <!-- simsimd -->
+      <span style="color:#ABABAB;">x86:</span> <b>8,924,100</b> ops/s<br/>
+      <span style="color:#ABABAB;">arm:</span> <b>3,602,650</b> ops/s
+    </td>
+  </tr>
+  <tr>
+    <td colspan="4" align="center">eculidean distance between 1536d vectors in <code>float64</code></td>
+  </tr>
+  <tr>
+    <td align="center"> <!-- scipy.spatial.distance.sqeuclidean -->
+      <span style="color:#ABABAB;">x86:</span> <b>334,929</b> ops/s<br/>
+      <span style="color:#ABABAB;">arm:</span> <b>237,505</b> ops/s
+    </td>
+    <td align="center"> <!-- serial -->
+      <span style="color:#ABABAB;">x86:</span> <b>1,215,190</b> ops/s<br/>
+      <span style="color:#ABABAB;">arm:</span> <b>905,782</b> ops/s
+    </td>
+    <td align="center"> <!-- simsimd -->
+      <span style="color:#ABABAB;">x86:</span> <b>1,701,740</b> ops/s<br/>
+      <span style="color:#ABABAB;">arm:</span> <b>1,735,840</b> ops/s
+    </td>
+  </tr>
+  <!-- Bilinear forms -->
+  <!-- Sparse set intersections -->
+</table>
 
-| Type       |                  Apple M2 Pro |            Intel Sapphire Rapids |                  AWS Graviton 4 |
-| :--------- | ----------------------------: | -------------------------------: | ------------------------------: |
-| `float64`  | 18.5 → 28.8 GB/s <br/> + 56 % |    21.9 → 41.4 GB/s <br/> + 89 % |   20.7 → 41.3 GB/s <br/> + 99 % |
-| `float32`  | 9.2 → 29.6 GB/s <br/> + 221 % |   10.9 → 95.8 GB/s <br/> + 779 % |   4.9 → 41.9 GB/s <br/> + 755 % |
-| `float16`  | 4.6 → 14.6 GB/s <br/> + 217 % | 3.1 → 108.4 GB/s <br/> + 3,397 % |   5.4 → 39.3 GB/s <br/> + 627 % |
-| `bfloat16` | 4.6 → 26.3 GB/s <br/> + 472 % |   0.8 → 59.5 GB/s <br/> +7,437 % | 2.5 → 29.9 GB/s <br/> + 1,096 % |
-| `int8`     | 25.8 → 47.1 GB/s <br/> + 83 % |    33.1 → 65.3 GB/s <br/> + 97 % |   35.2 → 43.5 GB/s <br/> + 24 % |
-| `uint8`    |                               |   32.5 → 66.5 GB/s <br/> + 105 % |                                 |
+> For benchmarks we mostly use 1536-dimensional vectors, like the embeddings produced by the OpenAI Ada API.
+> The code was compiled with GCC 12, using glibc v2.35.
+> The benchmarks performed on Arm-based Graviton3 AWS `c7g` instances and `r7iz` Intel Sapphire Rapids.
+> Most modern Arm-based 64-bit CPUs will have similar relative speedups.
+> Variance withing x86 CPUs will be larger.
 
 Similar speedups are often observed even when compared to BLAS and LAPACK libraries underlying most numerical computing libraries, including NumPy and SciPy in Python.
 Broader benchmarking results:
@@ -162,10 +341,22 @@ dist = simsimd.cosine(vec1, vec2, "int8")
 dist = simsimd.cosine(vec1, vec2, "float16")
 dist = simsimd.cosine(vec1, vec2, "float32")
 dist = simsimd.cosine(vec1, vec2, "float64")
-dist = simsimd.hamming(vec1, vec2, "bit8")
+dist = simsimd.hamming(vec1, vec2, "bin8")
+```
+
+Binary distance functions are computed at a bit-level.
+Meaning a vector of 10x 8-bit integers will be treated as a sequence of 80 individual bits or dimensions.
+This differs from NumPy, that can't handle smaller-than-byte types, but you can still avoid the `bin8` argument by reinterpreting the vector as booleans:
+
+```py
+vec1 = np.random.randint(2, size=80).astype(np.uint8).packbits().view(np.bool_)
+vec2 = np.random.randint(2, size=80).astype(np.uint8).packbits().view(np.bool_)
+hamming_distance = simsimd.hamming(vec1, vec2)
+jaccard_distance = simsimd.jaccard(vec1, vec2)
 ```
 
 With other frameworks, like PyTorch, one can get a richer type-system than NumPy, but the lack of good CPython interoperability makes it hard to pass data without copies.
+Here is an example of using SimSIMD with PyTorch to compute the cosine similarity between two `bfloat16` vectors:
 
 ```py
 import numpy as np
@@ -181,7 +372,7 @@ torch.randn(8, out=vec2)
 
 # Both libs will look into the same memory buffers and report the same results
 dist_slow = 1 - torch.nn.functional.cosine_similarity(vec1, vec2, dim=0)
-dist_fast = simsimd.cosine(buf1, buf2, "bf16")
+dist_fast = simsimd.cosine(buf1, buf2, "bfloat16")
 ```
 
 It also allows using SimSIMD for half-precision complex numbers, which NumPy does not support.
@@ -254,9 +445,9 @@ distances: DistancesTensor = simsimd.cdist(matrix1, matrix2, metric="cosine")
 distances_array: np.ndarray = np.array(distances, copy=True)                    # now managed by NumPy
 ```
 
-### Elementwise Kernels
+### Element-wise Kernels
 
-SimSIMD also provides mixed-precision elementwise kernels, where the input vectors and the output have the same numeric type, but the intermediate accumulators are of a higher precision.
+SimSIMD also provides mixed-precision element-wise kernels, where the input vectors and the output have the same numeric type, but the intermediate accumulators are of a higher precision.
 
 ```py
 import numpy as np
@@ -591,9 +782,9 @@ const binaryVectorB = toBinary(vectorB);
 const distance = hamming(binaryVectorA, binaryVectorB);
 ```
 
-## Using SimSIMD in Sift
+## Using SimSIMD in Swift
 
-To install, simply add the following dependency to you `Package.swift`:
+To install, simply add the following dependency to your `Package.swift`:
 
 ```swift
 dependencies: [
@@ -677,23 +868,29 @@ To override compilation settings and switch between runtime and compile-time dis
 #include <simsimd/simsimd.h>
 
 int main() {
+    simsimd_i8_t i8[1536];
+    simsimd_i8_t u8[1536];
     simsimd_f64_t f64s[1536];
     simsimd_f32_t f32s[1536];
     simsimd_f16_t f16s[1536];
-    simsimd_i8_t i8[1536];
+    simsimd_bf16_t bf16s[1536];
     simsimd_distance_t distance;
 
     // Cosine distance between two vectors
     simsimd_cos_i8(i8s, i8s, 1536, &distance);
+    simsimd_cos_u8(u8s, u8s, 1536, &distance);
     simsimd_cos_f16(f16s, f16s, 1536, &distance);
     simsimd_cos_f32(f32s, f32s, 1536, &distance);
     simsimd_cos_f64(f64s, f64s, 1536, &distance);
+    simsimd_cos_bf16(bf16s, bf16s, 1536, &distance);
     
     // Euclidean distance between two vectors
     simsimd_l2sq_i8(i8s, i8s, 1536, &distance);
+    simsimd_l2sq_u8(u8s, u8s, 1536, &distance);
     simsimd_l2sq_f16(f16s, f16s, 1536, &distance);
     simsimd_l2sq_f32(f32s, f32s, 1536, &distance);
     simsimd_l2sq_f64(f64s, f64s, 1536, &distance);
+    simsimd_l2sq_bf16(bf16s, bf16s, 1536, &distance);
 
     return 0;
 }
@@ -705,25 +902,41 @@ int main() {
 #include <simsimd/simsimd.h>
 
 int main() {
-    simsimd_f64_t f64s[1536];
-    simsimd_f32_t f32s[1536];
+    // SimSIMD provides "sized" type-aliases without relying on `stdint.h`
+    simsimd_i8_t i8[1536];
+    simsimd_i8_t u8[1536];
     simsimd_f16_t f16s[1536];
-    simsimd_distance_t distance;
-
-    // Inner product between two vectors
-    simsimd_dot_f16(f16s, f16s, 1536, &distance);
-    simsimd_dot_f32(f32s, f32s, 1536, &distance);
-    simsimd_dot_f64(f64s, f64s, 1536, &distance);
+    simsimd_f32_t f32s[1536];
+    simsimd_f64_t f64s[1536];
+    simsimd_bf16_t bf16s[1536];
+    simsimd_distance_t product;
+
+    // Inner product between two real vectors
+    simsimd_dot_i8(i8s, i8s, 1536, &product);
+    simsimd_dot_u8(u8s, u8s, 1536, &product);
+    simsimd_dot_f16(f16s, f16s, 1536, &product);
+    simsimd_dot_f32(f32s, f32s, 1536, &product);
+    simsimd_dot_f64(f64s, f64s, 1536, &product);
+    simsimd_dot_bf16(bf16s, bf16s, 1536, &product);
+
+    // SimSIMD provides complex types with `real` and `imag` fields
+    simsimd_f64c_t f64s[768];
+    simsimd_f32c_t f32s[768];
+    simsimd_f16c_t f16s[768];
+    simsimd_bf16c_t bf16s[768];
+    simsimd_distance_t products[2]; // real and imaginary parts
 
     // Complex inner product between two vectors
-    simsimd_dot_f16c(f16s, f16s, 1536, &distance);
-    simsimd_dot_f32c(f32s, f32s, 1536, &distance);
-    simsimd_dot_f64c(f64s, f64s, 1536, &distance);
+    simsimd_dot_f16c(f16cs, f16cs, 768, &products[0]);
+    simsimd_dot_f32c(f32cs, f32cs, 768, &products[0]);
+    simsimd_dot_f64c(f64cs, f64cs, 768, &products[0]);
+    simsimd_dot_bf16c(bf16cs, bf16cs, 768, &products[0]);
 
     // Complex conjugate inner product between two vectors
-    simsimd_vdot_f16c(f16s, f16s, 1536, &distance);
-    simsimd_vdot_f32c(f32s, f32s, 1536, &distance);
-    simsimd_vdot_f64c(f64s, f64s, 1536, &distance);
+    simsimd_vdot_f16c(f16cs, f16cs, 768, &products[0]);
+    simsimd_vdot_f32c(f32cs, f32cs, 768, &products[0]);
+    simsimd_vdot_f64c(f64cs, f64cs, 768, &products[0]);
+    simsimd_vdot_bf16c(bf16cs, bf16cs, 768, &products[0]);
     return 0;
 }
 ```
@@ -751,17 +964,17 @@ int main() {
     simsimd_f64_t f64s[1536];
     simsimd_f32_t f32s[1536];
     simsimd_f16_t f16s[1536];
-    simsimd_distance_t distance;
+    simsimd_distance_t divergence;
 
     // Jensen-Shannon divergence between two vectors
-    simsimd_js_f16(f16s, f16s, 1536, &distance);
-    simsimd_js_f32(f32s, f32s, 1536, &distance);
-    simsimd_js_f64(f64s, f64s, 1536, &distance);
+    simsimd_js_f16(f16s, f16s, 1536, &divergence);
+    simsimd_js_f32(f32s, f32s, 1536, &divergence);
+    simsimd_js_f64(f64s, f64s, 1536, &divergence);
 
     // Kullback-Leibler divergence between two vectors
-    simsimd_kl_f16(f16s, f16s, 1536, &distance);
-    simsimd_kl_f32(f32s, f32s, 1536, &distance);
-    simsimd_kl_f64(f64s, f64s, 1536, &distance);
+    simsimd_kl_f16(f16s, f16s, 1536, &divergence);
+    simsimd_kl_f32(f32s, f32s, 1536, &divergence);
+    simsimd_kl_f64(f64s, f64s, 1536, &divergence);
     return 0;
 }
 ```