usearch 2.25.0 → 2.25.1

package/README.md

@@ -51,7 +51,7 @@ Linux • macOS • Windows • iOS • Android • WebAssembly •
 - ✅ Simple and extensible [single C++11 header][usearch-header] __library__.
 - ✅ [Trusted](#integrations) by giants like Google and DBs like [ClickHouse][clickhouse-docs] & [DuckDB][duckdb-docs].
 - ✅ [SIMD][simd]-optimized and [user-defined metrics](#user-defined-functions) with JIT compilation.
-- ✅ Hardware-agnostic `f16` & `i8` - [half-precision & quarter-precision support](#memory-efficiency-downcasting-and-quantization).
+- ✅ Hardware-agnostic `bf16`, `e5m2`, & `i8` - [half-precision & quarter-precision support](#memory-efficiency-downcasting-and-quantization).
 - ✅ [View large indexes from disk](#serialization--serving-index-from-disk) without loading into RAM.
 - ✅ Heterogeneous lookups, renaming/relabeling, and on-the-fly deletions.
 - ✅ Binary Tanimoto and Sorensen coefficients for [Genomics and Chemistry applications](#usearch--rdkit--molecular-search).
@@ -138,7 +138,7 @@ The default storage/quantization level is hardware-dependant for efficiency, but
 index = Index(
     ndim=3, # Define the number of dimensions in input vectors
     metric='cos', # Choose 'l2sq', 'ip', 'haversine' or other metric, default = 'cos'
-    dtype='bf16', # Store as 'f64', 'f32', 'f16', 'i8', 'b1'..., default = None
+    dtype='bf16', # Store as 'f64', 'f32', 'bf16', 'f16', 'e5m2', 'e4m3', 'e3m2', 'e2m3', 'u8', 'i8', 'b1'..., default = None
     connectivity=16, # Optional: Limit number of neighbors per graph node
     expansion_add=128, # Optional: Control the recall of indexing
     expansion_search=64, # Optional: Control the quality of the search
@@ -251,7 +251,7 @@ assert!(
 Training a quantization model and dimension-reduction is a common approach to accelerate vector search.
 Those, however, are only sometimes reliable, can significantly affect the statistical properties of your data, and require regular adjustments if your distribution shifts.
 Instead, we have focused on high-precision arithmetic over low-precision downcasted vectors.
-The same index, and `add` and `search` operations will automatically down-cast or up-cast between `f64_t`, `f32_t`, `f16_t`, `i8_t`, and single-bit `b1x8_t` representations.
+The same index, and `add` and `search` operations will automatically down-cast or up-cast between `f64_t`, `f32_t`, `bf16_t`, `f16_t`, `e5m2_t`, `e4m3_t`, `e3m2_t`, `e2m3_t`, `u8_t`, `i8_t`, and single-bit `b1x8_t` representations.
 You can use the following command to check, if hardware acceleration is enabled:
 
 ```sh
@@ -261,7 +261,9 @@ $ python -c 'from usearch.index import Index; print(Index(ndim=166, metric="tani
 > ice
 ```
 
-In most cases, it's recommended to use half-precision floating-point numbers on modern hardware.
+In most cases, `bf16` is recommended for modern CPUs.
+For even smaller footprints, USearch supports IEEE & MX-compatible Float8 (`e5m2` and `e4m3`) and Float6 (`e3m2` and `e2m3`) formats.
+You can pass pre-quantized buffers from [NumKong](https://github.com/ashvardanian/numkong) with the explicit `dtype=` parameter on `add` and `search`, or let USearch handle the quantization internally from higher-precision inputs.
 When quantization is enabled, the "get"-like functions won't be able to recover the original data, so you may want to replicate the original vectors elsewhere.
 When quantizing to `i8_t` integers, note that it's only valid for cosine-like metrics.
 As part of the quantization process, the vectors are normalized to unit length and later scaled to [-127, 127] range to occupy the full 8-bit range.
@@ -479,46 +481,41 @@ The Haversine distance is available out of the box, but you can also define more
 from numba import cfunc, types, carray
 import math
 
-# Define the dimension as 2 for latitude and longitude
 ndim = 2
+semi_major, flattening = 6378137.0, 1 / 298.257223563
+semi_minor = (1 - flattening) * semi_major
+
+def vincenty_distance(first_ptr, second_ptr):
+    first, second = carray(first_ptr, ndim), carray(second_ptr, ndim)
+    lat1, lon1, lat2, lon2 = first[0], first[1], second[0], second[1]
+    diff_lon = lon2 - lon1
+    rlat1, rlat2 = math.atan((1 - flattening) * math.tan(lat1)), math.atan((1 - flattening) * math.tan(lat2))
+    sin_rlat1, cos_rlat1 = math.sin(rlat1), math.cos(rlat1)
+    sin_rlat2, cos_rlat2 = math.sin(rlat2), math.cos(rlat2)
+    lon_on_sphere = diff_lon
+    for _ in range(100):
+        sin_lon, cos_lon = math.sin(lon_on_sphere), math.cos(lon_on_sphere)
+        sin_ang = math.sqrt((cos_rlat2 * sin_lon) ** 2 + (cos_rlat1 * sin_rlat2 - sin_rlat1 * cos_rlat2 * cos_lon) ** 2)
+        if sin_ang == 0: return 0.0
+        cos_ang = sin_rlat1 * sin_rlat2 + cos_rlat1 * cos_rlat2 * cos_lon
+        ang = math.atan2(sin_ang, cos_ang)
+        sin_az = cos_rlat1 * cos_rlat2 * sin_lon / sin_ang
+        cos2_az = 1 - sin_az ** 2
+        cos2_mid = cos_ang - 2 * sin_rlat1 * sin_rlat2 / cos2_az if cos2_az != 0 else 0.0
+        corr = flattening / 16 * cos2_az * (4 + flattening * (4 - 3 * cos2_az))
+        prev = lon_on_sphere
+        lon_on_sphere = diff_lon + (1 - corr) * flattening * (
+            sin_az * (ang + corr * sin_ang * (cos2_mid + corr * cos_ang * (-1 + 2 * cos2_mid ** 2))))
+        if abs(lon_on_sphere - prev) <= 1e-12: break
+    else:
+        return float('nan')
+    u_sq = cos2_az * (semi_major ** 2 - semi_minor ** 2) / (semi_minor ** 2)
+    ca = 1 + u_sq / 16384 * (4096 + u_sq * (-768 + u_sq * (320 - 175 * u_sq)))
+    cb = u_sq / 1024 * (256 + u_sq * (-128 + u_sq * (74 - 47 * u_sq)))
+    delta = cb * sin_ang * (cos2_mid + cb / 4 * (cos_ang * (-1 + 2 * cos2_mid ** 2)
+        - cb / 6 * cos2_mid * (-3 + 4 * sin_ang ** 2) * (-3 + 4 * cos2_mid ** 2)))
+    return semi_minor * ca * (ang - delta) / 1000.0
 
-# Signature for the custom metric
-signature = types.float32(
-    types.CPointer(types.float32),
-    types.CPointer(types.float32))
-
-# WGS-84 ellipsoid parameters
-a = 6378137.0  # major axis in meters
-f = 1 / 298.257223563  # flattening
-b = (1 - f) * a  # minor axis
-
-def vincenty_distance(a_ptr, b_ptr):
-    a_array = carray(a_ptr, ndim)
-    b_array = carray(b_ptr, ndim)
-    lat1, lon1, lat2, lon2 = a_array[0], a_array[1], b_array[0], b_array[1]
-    L, U1, U2 = lon2 - lon1, math.atan((1 - f) * math.tan(lat1)), math.atan((1 - f) * math.tan(lat2))
-    sinU1, cosU1, sinU2, cosU2 = math.sin(U1), math.cos(U1), math.sin(U2), math.cos(U2)
-    lambda_, iterLimit = L, 100
-    while iterLimit > 0:
-        iterLimit -= 1
-        sinLambda, cosLambda = math.sin(lambda_), math.cos(lambda_)
-        sinSigma = math.sqrt((cosU2 * sinLambda) ** 2 + (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda) ** 2)
-        if sinSigma == 0: return 0.0  # Co-incident points
-        cosSigma, sigma = sinU1 * sinU2 + cosU1 * cosU2 * cosLambda, math.atan2(sinSigma, cosSigma)
-        sinAlpha, cos2Alpha = cosU1 * cosU2 * sinLambda / sinSigma, 1 - (cosU1 * cosU2 * sinLambda / sinSigma) ** 2
-        cos2SigmaM = cosSigma - 2 * sinU1 * sinU2 / cos2Alpha if not math.isnan(cosSigma - 2 * sinU1 * sinU2 / cos2Alpha) else 0  # Equatorial line
-        C = f / 16 * cos2Alpha * (4 + f * (4 - 3 * cos2Alpha))
-        lambda_, lambdaP = L + (1 - C) * f * (sinAlpha * (sigma + C * sinSigma * (cos2SigmaM + C * cosSigma * (-1 + 2 * cos2SigmaM ** 2)))), lambda_
-        if abs(lambda_ - lambdaP) <= 1e-12: break
-    if iterLimit == 0: return float('nan')  # formula failed to converge
-    u2 = cos2Alpha * (a ** 2 - b ** 2) / (b ** 2)
-    A = 1 + u2 / 16384 * (4096 + u2 * (-768 + u2 * (320 - 175 * u2)))
-    B = u2 / 1024 * (256 + u2 * (-128 + u2 * (74 - 47 * u2)))
-    deltaSigma = B * sinSigma * (cos2SigmaM + B / 4 * (cosSigma * (-1 + 2 * cos2SigmaM ** 2) - B / 6 * cos2SigmaM * (-3 + 4 * sinSigma ** 2) * (-3 + 4 * cos2SigmaM ** 2)))
-    s = b * A * (sigma - deltaSigma)
-    return s / 1000.0  # Distance in kilometers
-
-# Example usage:
 index = Index(ndim=ndim, metric=CompiledMetric(
     pointer=vincenty_distance.address,
     kind=MetricKind.Haversine,
@@ -547,13 +544,12 @@ index = Index(ndim=ndim, metric=CompiledMetric(
 ## Citations
 
 ```bibtex
-@software{Vardanian_USearch_2023,
+@software{Vardanian_USearch,
 doi = {10.5281/zenodo.7949416},
 author = {Vardanian, Ash},
 title = {{USearch by Unum Cloud}},
 url = {https://github.com/unum-cloud/USearch},
-version = {2.25.0},
-year = {2023},
-month = oct,
+version = {2.25.1},
+year = {2026},
 }
 ```

package/c/README.md

@@ -19,7 +19,7 @@ int main() {
     usearch_error_t error = NULL;
     usearch_init_options_t opts = {
         .metric_kind = usearch_metric_cos_k,
-        .scalar_kind = usearch_scalar_f16_k,
+        .scalar_kind = usearch_scalar_f16_k, // or f32_k, bf16_k, e5m2_k, e4m3_k, e3m2_k, e2m3_k, i8_k, u8_k
         .dimensions = dimensions,
         .expansion_add = 0, // for defaults
         .expansion_search = 0 // for defaults

package/c/test.c

@@ -448,6 +448,46 @@ void test_view(size_t const collection_size, size_t const dimensions) {
     printf("Test: View - PASSED\n");
 }
 
+void test_mini_float_quantizations(size_t const collection_size, size_t const dimensions) {
+    printf("Test: Mini-float quantizations... %zu vectors, %zu dimensions\n", collection_size, dimensions);
+    usearch_scalar_kind_t kinds[] = {
+        usearch_scalar_e5m2_k,
+        usearch_scalar_e4m3_k,
+        usearch_scalar_e3m2_k,
+        usearch_scalar_e2m3_k,
+    };
+    float* data = create_vectors(collection_size, dimensions);
+    usearch_key_t* keys = (usearch_key_t*)malloc(collection_size * sizeof(usearch_key_t));
+    float* distances = (float*)malloc(collection_size * sizeof(float));
+    expect(keys && distances, "Failed to allocate memory");
+
+    for (size_t k = 0; k < sizeof(kinds) / sizeof(kinds[0]); ++k) {
+        usearch_error_t error = NULL;
+        usearch_init_options_t opts = create_options(dimensions);
+        opts.quantization = kinds[k];
+        usearch_index_t index = usearch_init(&opts, &error);
+        expect(!error, error);
+        usearch_reserve(index, collection_size, &error);
+        expect(!error, error);
+        for (size_t i = 0; i < collection_size; ++i) {
+            usearch_add(index, (usearch_key_t)i, data + i * dimensions, usearch_scalar_f32_k, &error);
+            expect(!error, error);
+        }
+        expect_eq(usearch_size(index, &error), collection_size, error);
+        for (size_t i = 0; i < collection_size; ++i) {
+            size_t found =
+                usearch_search(index, data + i * dimensions, usearch_scalar_f32_k, 1, keys, distances, &error);
+            expect(!error, error);
+            expect(found >= 1, "Vector not found");
+        }
+        usearch_free(index, &error);
+    }
+    free(data);
+    free(keys);
+    free(distances);
+    printf("Test: Mini-float quantizations - PASSED\n");
+}
+
 int main(int argc, char const* argv[]) {
     install_crash_handlers();
     printf("Running tests...\n");
@@ -464,6 +504,7 @@ int main(int argc, char const* argv[]) {
             test_remove_vector(collection_sizes[index], dimensions[jdx]);
             test_save_load(collection_sizes[index], dimensions[jdx]);
             test_view(collection_sizes[index], dimensions[jdx]);
+            test_mini_float_quantizations(collection_sizes[index], dimensions[jdx]);
         }
     }
 

package/include/usearch/index.hpp

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

package/javascript/README.md

@@ -48,7 +48,7 @@ Customize your index with additional configuration options:
 const index = new usearch.Index({
   dimensions: 128,
   metric: 'ip',
-  quantization: 'f32',
+  quantization: 'f32', // or 'bf16', 'f16', 'e5m2', 'e4m3', 'e3m2', 'e2m3', 'u8', 'i8', 'b1'
   connectivity: 10,
   expansion_add: 5,
   expansion_search: 3,

package/javascript/usearch.test.js

@@ -1,23 +1,23 @@
-const nodeTest = require('node:test');
+const nodeTest = require("node:test");
 const realTest = nodeTest.test; // the original function
 
 function loggedTest(name, options, fn) {
   // The API has two call signatures:
   //   test(name, fn)
   //   test(name, options, fn)
-  if (typeof options === 'function') {
+  if (typeof options === "function") {
     fn = options;
     options = undefined;
   }
 
   // Wrap the body so we can log before / after
   const wrapped = async (t) => {
-    console.log('▶', name);
+    console.log("▶", name);
     try {
       await fn(t); // run the user’s test
-      console.log('✓', name);
+      console.log("✓", name);
     } catch (err) {
-      console.log('✖', name);
+      console.log("✖", name);
       throw err; // re-throw so the runner records the failure
     }
   };
@@ -30,43 +30,43 @@ function loggedTest(name, options, fn) {
 global.test = loggedTest;
 module.exports = loggedTest; // for completeness if this file is `require`d
 
-const assert = require('node:assert');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const usearch = require('./dist/cjs/usearch.js');
+const assert = require("node:assert");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const usearch = require("./dist/cjs/usearch.js");
 
 function assertAlmostEqual(actual, expected, tolerance = 1e-6) {
   const lowerBound = expected - tolerance;
   const upperBound = expected + tolerance;
   assert(
     actual >= lowerBound && actual <= upperBound,
-    `Expected ${actual} to be almost equal to ${expected}`
+    `Expected ${actual} to be almost equal to ${expected}`,
   );
 }
 
 const THREADS = 2;
 
-test('Single-entry operations', async (t) => {
-  await t.test('index info', () => {
-    const index = new usearch.Index(2, 'l2sq');
+test("Single-entry operations", async (t) => {
+  await t.test("index info", () => {
+    const index = new usearch.Index(2, "l2sq");
 
-    assert.equal(index.connectivity(), 16, 'connectivity should be 16');
-    assert.equal(index.dimensions(), 2, 'dimensions should be 2');
-    assert.equal(index.size(), 0, 'initial size should be 0');
+    assert.equal(index.connectivity(), 16, "connectivity should be 16");
+    assert.equal(index.dimensions(), 2, "dimensions should be 2");
+    assert.equal(index.size(), 0, "initial size should be 0");
   });
 
-  await t.test('add', () => {
-    const index = new usearch.Index(2, 'l2sq');
+  await t.test("add", () => {
+    const index = new usearch.Index(2, "l2sq");
 
     index.add(15n, new Float32Array([10, 20]));
     index.add(16n, new Float32Array([10, 25]));
 
-    assert.equal(index.size(), 2, 'size after adding elements should be 2');
+    assert.equal(index.size(), 2, "size after adding elements should be 2");
     assert.equal(
       index.contains(15),
       true,
-      'entry must be present after insertion'
+      "entry must be present after insertion",
     );
 
     const results = index.search(new Float32Array([13, 14]), 2);
@@ -74,17 +74,17 @@ test('Single-entry operations', async (t) => {
     assert.deepEqual(
       results.keys,
       new BigUint64Array([15n, 16n]),
-      'keys should be 15 and 16'
+      "keys should be 15 and 16",
     );
     assert.deepEqual(
       results.distances,
       new Float32Array([45, 130]),
-      'distances should be 45 and 130'
+      "distances should be 45 and 130",
     );
   });
 
-  await t.test('remove', () => {
-    const index = new usearch.Index(2, 'l2sq');
+  await t.test("remove", () => {
+    const index = new usearch.Index(2, "l2sq");
 
     index.add(15n, new Float32Array([10, 20]));
     index.add(16n, new Float32Array([10, 25]));
@@ -93,11 +93,11 @@ test('Single-entry operations', async (t) => {
 
     assert.equal(index.remove(15n), 1);
 
-    assert.equal(index.size(), 3, 'size after removing elements should be 3');
+    assert.equal(index.size(), 3, "size after removing elements should be 3");
     assert.equal(
       index.contains(15),
       false,
-      'entry must be absent after insertion'
+      "entry must be absent after insertion",
     );
 
     const results = index.search(new Float32Array([13, 14]), 2);
@@ -105,37 +105,37 @@ test('Single-entry operations', async (t) => {
     assert.deepEqual(
       results.keys,
       new BigUint64Array([16n, 25n]),
-      'keys should not include 15'
+      "keys should not include 15",
     );
   });
 });
 
-test('Batch operations', async (t) => {
-  await t.test('add', () => {
-    const indexBatch = new usearch.Index(2, 'l2sq');
+test("Batch operations", async (t) => {
+  await t.test("add", () => {
+    const indexBatch = new usearch.Index(2, "l2sq");
 
     const keys = [15n, 16n];
     const vectors = [new Float32Array([10, 20]), new Float32Array([10, 25])];
 
     indexBatch.add(keys, vectors);
-    assert.equal(indexBatch.size(), 2, 'size after adding batch should be 2');
+    assert.equal(indexBatch.size(), 2, "size after adding batch should be 2");
 
     const results = indexBatch.search(new Float32Array([13, 14]), 2);
 
     assert.deepEqual(
       results.keys,
       new BigUint64Array([15n, 16n]),
-      'keys should be 15 and 16'
+      "keys should be 15 and 16",
     );
     assert.deepEqual(
       results.distances,
       new Float32Array([45, 130]),
-      'distances should be 45 and 130'
+      "distances should be 45 and 130",
     );
   });
 
-  await t.test('remove', () => {
-    const indexBatch = new usearch.Index(2, 'l2sq');
+  await t.test("remove", () => {
+    const indexBatch = new usearch.Index(2, "l2sq");
 
     const keys = [15n, 16n, 25n, 26n];
     const vectors = [
@@ -147,53 +147,58 @@ test('Batch operations', async (t) => {
     indexBatch.add(keys, vectors);
 
     assert.deepEqual(indexBatch.remove([15n, 25n]), [1, 1]);
-    assert.equal(indexBatch.size(), 2, 'size after removing batch should be 2');
+    assert.equal(indexBatch.size(), 2, "size after removing batch should be 2");
 
     const results = indexBatch.search(new Float32Array([13, 14]), 2);
 
     assert.deepEqual(
       results.keys,
       new BigUint64Array([16n, 26n]),
-      'keys should not include 15 and 25'
+      "keys should not include 15 and 25",
     );
   });
 
-  await t.test('search', () => {
-    const indexBatch = new usearch.Index(3, 'l2sq');
+  await t.test("search", () => {
+    const indexBatch = new usearch.Index(3, "l2sq");
 
     const keys = [15n, 16n];
-    const vectors = [new Float32Array([10, 20, 30]), new Float32Array([10, 25, 35])];
+    const vectors = [
+      new Float32Array([10, 20, 30]),
+      new Float32Array([10, 25, 35]),
+    ];
 
     indexBatch.add(keys, vectors);
-    assert.equal(indexBatch.size(), 2, 'size after adding batch should be 2');
+    assert.equal(indexBatch.size(), 2, "size after adding batch should be 2");
+
+    const results = indexBatch.search(
+      [new Float32Array([13, 14, 15]), new Float32Array([13, 14, 15])],
+      2,
+    );
 
-    const results = indexBatch.search([new Float32Array([13, 14, 15]), new Float32Array([13, 14, 15])], 2);
-    
-    assert.equal(results.k, 2, 'k should be 2');
+    assert.equal(results.k, 2, "k should be 2");
 
     assert.deepEqual(
       results.counts,
-      new BigUint64Array([ 2n, 2n ]) ,
-      'counts should be 2 for both keys'
+      new BigUint64Array([2n, 2n]),
+      "counts should be 2 for both keys",
     );
 
     assert.deepEqual(
       results.keys,
       new BigUint64Array([15n, 16n, 15n, 16n]),
-      'keys should be 15 and 16'
+      "keys should be 15 and 16",
     );
     assert.deepEqual(
       results.distances,
-      new Float32Array( [ 270, 530, 270, 530 ]),
-      'distances should be 270 and 530'
+      new Float32Array([270, 530, 270, 530]),
+      "distances should be 270 and 530",
     );
   });
-
 });
 
-test('Expected results', () => {
+test("Expected results", () => {
   const index = new usearch.Index({
-    metric: 'l2sq',
+    metric: "l2sq",
     connectivity: 16,
     dimensions: 3,
   });
@@ -205,9 +210,9 @@ test('Expected results', () => {
   assertAlmostEqual(results.distances[0], new Float32Array([0]));
 });
 
-test('Multithread search returns same results', () => {
+test("Multithread search returns same results", () => {
   const index = new usearch.Index({
-    metric: 'l2sq',
+    metric: "l2sq",
     connectivity: 16,
     dimensions: 3,
   });
@@ -218,14 +223,14 @@ test('Multithread search returns same results', () => {
   const results_2 = index.search(
     new Float32Array([0.2, 0.6, 0.4]),
     10,
-    THREADS
+    THREADS,
   );
 
   assert.deepEqual(results_1.keys, results_2.keys);
   assertAlmostEqual(results_1.distances, results_2.distances);
 });
 
-test('Exact search', async (t) => {
+test("Exact search", async (t) => {
   const dataset = [
     new Float32Array([0.2, 0.6, 0.4]),
     new Float32Array([0.6, 0.6, 0.4]),
@@ -233,16 +238,16 @@ test('Exact search', async (t) => {
   const queries = new Float32Array([0.2, 0.6, 0.4]);
   const dimensions = 3;
   const count = 2;
-  const metric = 'l2sq';
+  const metric = "l2sq";
 
-  await t.test('Single core search', () => {
+  await t.test("Single core search", () => {
     const result = usearch.exactSearch(
       dataset,
       queries,
       dimensions,
       count,
       metric,
-      1 // threads
+      1, // threads
     );
 
     assert.deepEqual(result.keys, new BigUint64Array([0n, 1n]));
@@ -250,14 +255,14 @@ test('Exact search', async (t) => {
     assertAlmostEqual(new Float32Array([0.16]), result.distances[1]);
   });
 
-  await t.test('Multithreaded search', () => {
+  await t.test("Multithreaded search", () => {
     const result = usearch.exactSearch(
       dataset,
       queries,
       dimensions,
       count,
       metric,
-      THREADS // threads
+      THREADS, // threads
     );
 
     assert.deepEqual(result.keys, new BigUint64Array([0n, 1n]));
@@ -266,30 +271,30 @@ test('Exact search', async (t) => {
   });
 });
 
-test('Expected count()', async (t) => {
+test("Expected count()", async (t) => {
   const index = new usearch.Index({
-    metric: 'l2sq',
+    metric: "l2sq",
     connectivity: 16,
     dimensions: 3,
   });
   index.add(
     [42n, 43n],
-    [new Float32Array([0.2, 0.6, 0.4]), new Float32Array([0.2, 0.6, 0.4])]
+    [new Float32Array([0.2, 0.6, 0.4]), new Float32Array([0.2, 0.6, 0.4])],
   );
 
-  await t.test('Argument is a number', () => {
+  await t.test("Argument is a number", () => {
     assert.equal(1, index.count(43n));
   });
-  await t.test('Argument is a number (does not exist)', () => {
+  await t.test("Argument is a number (does not exist)", () => {
     assert.equal(0, index.count(44n));
   });
-  await t.test('Argument is an array', () => {
+  await t.test("Argument is an array", () => {
     assert.deepEqual([1, 1, 0], index.count([42n, 43n, 44n]));
   });
 });
 
-test('Operations with invalid values', () => {
-  const indexBatch = new usearch.Index(2, 'l2sq');
+test("Operations with invalid values", () => {
+  const indexBatch = new usearch.Index(2, "l2sq");
 
   const keys = [NaN, 16n];
   const vectors = [new Float32Array([10, 30]), new Float32Array([1, 5])];
@@ -301,10 +306,10 @@ test('Operations with invalid values', () => {
   assert.throws(() => indexBatch.search(NaN, 2));
 });
 
-test('Invalid operations', async (t) => {
-  await t.test('Add the same keys', () => {
+test("Invalid operations", async (t) => {
+  await t.test("Add the same keys", () => {
     const index = new usearch.Index({
-      metric: 'l2sq',
+      metric: "l2sq",
       connectivity: 16,
       dimensions: 3,
     });
@@ -312,9 +317,9 @@ test('Invalid operations', async (t) => {
     assert.throws(() => index.add(42n, new Float32Array([0.2, 0.6, 0.4])));
   });
 
-  await t.test('Batch add containing the same key', () => {
+  await t.test("Batch add containing the same key", () => {
     const index = new usearch.Index({
-      metric: 'l2sq',
+      metric: "l2sq",
       connectivity: 16,
       dimensions: 3,
     });
@@ -326,18 +331,18 @@ test('Invalid operations', async (t) => {
           [0.1, 0.6, 0.4],
           [0.2, 0.6, 0.4],
           [0.3, 0.6, 0.4],
-        ]
+        ],
       );
     });
   });
 });
 
-test('Serialization', async (t) => {
-  const indexPath = path.join(os.tmpdir(), 'usearch.test.index');
+test("Serialization", async (t) => {
+  const indexPath = path.join(os.tmpdir(), "usearch.test.index");
 
   t.beforeEach(() => {
     const index = new usearch.Index({
-      metric: 'l2sq',
+      metric: "l2sq",
       connectivity: 16,
       dimensions: 3,
     });
@@ -349,9 +354,9 @@ test('Serialization', async (t) => {
     fs.unlinkSync(indexPath);
   });
 
-  await t.test('load', () => {
+  await t.test("load", () => {
     const index = new usearch.Index({
-      metric: 'l2sq',
+      metric: "l2sq",
       connectivity: 16,
       dimensions: 3,
     });
@@ -359,7 +364,7 @@ test('Serialization', async (t) => {
     const results = index.search(
       new Float32Array([0.2, 0.6, 0.4]),
       10,
-      THREADS
+      THREADS,
     );
 
     assert.equal(index.size(), 1);
@@ -371,11 +376,11 @@ test('Serialization', async (t) => {
   // The following error in afterEach().
   // `error: "EBUSY: resource busy or locked, unlink`
   await t.test(
-    'view: Read data',
-    { skip: process.platform === 'win32' },
+    "view: Read data",
+    { skip: process.platform === "win32" },
     () => {
       const index = new usearch.Index({
-        metric: 'l2sq',
+        metric: "l2sq",
         connectivity: 16,
         dimensions: 3,
       });
@@ -385,15 +390,15 @@ test('Serialization', async (t) => {
       assert.equal(index.size(), 1);
       assert.deepEqual(results.keys, new BigUint64Array([42n]));
       assertAlmostEqual(results.distances[0], new Float32Array([0]));
-    }
+    },
   );
 
   await t.test(
-    'view: Invalid operations: add',
-    { skip: process.platform === 'win32' },
+    "view: Invalid operations: add",
+    { skip: process.platform === "win32" },
     () => {
       const index = new usearch.Index({
-        metric: 'l2sq',
+        metric: "l2sq",
         connectivity: 16,
         dimensions: 3,
       });
@@ -401,15 +406,15 @@ test('Serialization', async (t) => {
 
       // Can't add to an immutable index
       assert.throws(() => index.add(43n, new Float32Array([0.2, 0.6, 0.4])));
-    }
+    },
   );
 
   await t.test(
-    'view: Invalid operations: remove',
-    { skip: process.platform === 'win32' },
+    "view: Invalid operations: remove",
+    { skip: process.platform === "win32" },
     () => {
       const index = new usearch.Index({
-        metric: 'l2sq',
+        metric: "l2sq",
         connectivity: 16,
         dimensions: 3,
       });
@@ -417,6 +422,24 @@ test('Serialization', async (t) => {
 
       // Can't remove from an immutable index
       assert.throws(() => index.remove(42n));
-    }
+    },
   );
 });
+
+test("Mini-float quantization types", async (t) => {
+  for (const quantization of ["e5m2", "e4m3", "e3m2", "e2m3"]) {
+    await t.test(`add and search with ${quantization}`, () => {
+      const index = new usearch.Index({
+        metric: "cos",
+        dimensions: 64,
+        quantization: quantization,
+      });
+      const vector = new Float32Array(64);
+      for (let i = 0; i < 64; i++) vector[i] = i * 0.1;
+      index.add(1n, vector);
+
+      const results = index.search(vector, 1);
+      assert.equal(results.keys[0], 1n);
+    });
+  }
+});

package/package.json

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