usearch 2.8.2 → 2.8.4

package/simsimd/.vscode/tasks.json

@@ -1,23 +0,0 @@
-{
-    "version": "2.0.0",
-    "tasks": [
-        {
-            "label": "Build Benchmark: Debug",
-            "command": "cmake -DCMAKE_BUILD_TYPE=Debug -DSIMSIMD_BUILD_BENCHMARKS=1 -B ./build_debug && make -j 2 -C ./build_debug",
-            "args": [],
-            "type": "shell"
-        },
-        {
-            "label": "Build Test: Debug",
-            "command": "cmake -DCMAKE_BUILD_TYPE=Debug -B ./build && make test py_simsimd -C ./build",
-            "args": [],
-            "type": "shell"
-        },
-        {
-            "label": "Build Benchmark: Release",
-            "command": "cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo -DSIMSIMD_BUILD_BENCHMARKS=1 -B ./build_release && make -j 2 -C ./build_release",
-            "args": [],
-            "type": "shell"
-        }
-    ]
-}

package/simsimd/go.mod

@@ -1,3 +0,0 @@
-module github.com/ashvardanian/simsimd
-
-go 1.19

package/simsimd/golang/bench_test.go

@@ -1,40 +0,0 @@
-package simsimd
-
-import (
-	"math"
-	"math/rand"
-	"testing"
-)
-
-func cosineSimilarity(a, b []float32) float32 {
-	var dotProduct float32
-	var normA, normB float32
-	for i := range a {
-		dotProduct += a[i] * b[i]
-		normA += a[i] * a[i]
-		normB += b[i] * b[i]
-	}
-	return dotProduct / (float32(math.Sqrt(float64(normA))) * float32(math.Sqrt(float64(normB))))
-}
-
-func generateRandomVector(dim int) []float32 {
-	vec := make([]float32, dim)
-	for i := range vec {
-		vec[i] = rand.Float32()
-	}
-	return vec
-}
-
-func BenchmarkCosineSimilarityNative(b *testing.B) {
-    first, second := generateRandomVector(1536), generateRandomVector(1536)
-    for i := 0; i < b.N; i++ {
-        cosineSimilarity(first, second)
-    }
-}
-
-func BenchmarkCosineSimilaritySIMD(b *testing.B) {
-    first, second := generateRandomVector(1536), generateRandomVector(1536)
-    for i := 0; i < b.N; i++ {
-        CosineF32(first, second)
-    }
-}

package/simsimd/golang/simsimd.go

@@ -1,47 +0,0 @@
-package simsimd
-
-/*
-#cgo CFLAGS: -O3
-#cgo LDFLAGS: -O3 -L.
-#include "../simsimd/simsimd.h"
-#include <stdlib.h>
-
-inline static simsimd_f32_t cosine_i8(simsimd_i8_t const* a, simsimd_i8_t const* b, simsimd_size_t d) { return simsimd_metric_punned(simsimd_metric_cosine_k, simsimd_datatype_i8_k, simsimd_cap_any_k)(a, b, d, d); }
-inline static simsimd_f32_t cosine_f32(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t d) { return simsimd_neon_f32_cos(a, b, d); }
-inline static simsimd_f32_t inner_i8(simsimd_i8_t const* a, simsimd_i8_t const* b, simsimd_size_t d) { return simsimd_metric_punned(simsimd_metric_inner_k, simsimd_datatype_i8_k, simsimd_cap_any_k)(a, b, d, d); }
-inline static simsimd_f32_t inner_f32(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t d) { return simsimd_metric_punned(simsimd_metric_inner_k, simsimd_datatype_f32_k, simsimd_cap_any_k)(a, b, d, d); }
-inline static simsimd_f32_t sqeuclidean_i8(simsimd_i8_t const* a, simsimd_i8_t const* b, simsimd_size_t d) { return simsimd_metric_punned(simsimd_metric_sqeuclidean_k, simsimd_datatype_i8_k, simsimd_cap_any_k)(a, b, d, d); }
-inline static simsimd_f32_t sqeuclidean_f32(simsimd_f32_t const* a, simsimd_f32_t const* b, simsimd_size_t d) { return simsimd_metric_punned(simsimd_metric_sqeuclidean_k, simsimd_datatype_f32_k, simsimd_cap_any_k)(a, b, d, d); }
-*/
-import "C"
-
-
-// CosineI8 computes the cosine similarity between two i8 vectors using the most suitable SIMD instruction set available.
-func CosineI8(a, b []int8) float32 {
-	return float32(C.cosine_i8((*C.simsimd_i8_t)(&a[0]), (*C.simsimd_i8_t)(&b[0]), C.simsimd_size_t(len(a))))
-}
-
-// CosineF32 computes the cosine similarity between two i8 vectors using the most suitable SIMD instruction set available.
-func CosineF32(a, b []float32) float32 {
-	return float32(C.cosine_f32((*C.simsimd_f32_t)(&a[0]), (*C.simsimd_f32_t)(&b[0]), C.simsimd_size_t(len(a))))
-}
-
-// InnerI8 computes the inner-product similarity between two i8 vectors using the most suitable SIMD instruction set available.
-func InnerI8(a, b []int8) float32 {
-	return float32(C.inner_i8((*C.simsimd_i8_t)(&a[0]), (*C.simsimd_i8_t)(&b[0]), C.simsimd_size_t(len(a))))
-}
-
-// InnerF32 computes the inner-product similarity between two i8 vectors using the most suitable SIMD instruction set available.
-func InnerF32(a, b []float32) float32 {
-	return float32(C.inner_f32((*C.simsimd_f32_t)(&a[0]), (*C.simsimd_f32_t)(&b[0]), C.simsimd_size_t(len(a))))
-}
-
-// SqEuclideanI8 computes the squared euclidean similarity between two i8 vectors using the most suitable SIMD instruction set available.
-func SqEuclideanI8(a, b []int8) float32 {
-	return float32(C.sqeuclidean_i8((*C.simsimd_i8_t)(&a[0]), (*C.simsimd_i8_t)(&b[0]), C.simsimd_size_t(len(a))))
-}
-
-// SqEuclideanF32 computes the squared euclidean similarity between two i8 vectors using the most suitable SIMD instruction set available.
-func SqEuclideanF32(a, b []float32) float32 {
-	return float32(C.sqeuclidean_f32((*C.simsimd_f32_t)(&a[0]), (*C.simsimd_f32_t)(&b[0]), C.simsimd_size_t(len(a))))
-}

package/simsimd/golang/unit_test.go

@@ -1,40 +0,0 @@
-package simsimd
-
-import (
-	"math"
-	"testing"
-)
-
-func TestCosineI8(t *testing.T) {
-	a := []int8{1, 0}
-	b := []int8{0, 1}
-
-	result := CosineI8(a, b)
-	expected := float32(1.0) // Cosine similarity of orthogonal vectors is 0
-	if math.Abs(float64(result-expected)) > 1e-3 {
-		t.Errorf("Expected %v, got %v", expected, result)
-	}
-}
-
-func TestCosineF32(t *testing.T) {
-	a := []float32{1, 0}
-	b := []float32{0, 1}
-
-	result := CosineF32(a, b)
-	expected := float32(1.0) // Cosine similarity of orthogonal vectors is 0
-	if math.Abs(float64(result-expected)) > 1e-3 {
-		t.Errorf("Expected %v, got %v", expected, result)
-	}
-}
-
-func TestVectorLengthMismatch(t *testing.T) {
-	defer func() {
-		if r := recover(); r == nil {
-			t.Errorf("The code did not panic")
-		}
-	}()
-
-	a := []int8{1, 0}
-	b := []int8{0}
-	_ = CosineI8(a, b) // This should panic
-}

package/simsimd/pyproject.toml

@@ -1,42 +0,0 @@
-[build-system]
-requires = ["setuptools>=42", "wheel", "numpy"]
-build-backend = "setuptools.build_meta"
-
-[tool.pytest.ini_options]
-minversion = "6.0"
-addopts = ["-ra", "--showlocals", "--strict-markers", "--strict-config"]
-xfail_strict = true
-filterwarnings = ["error"]
-
-[tool.cibuildwheel]
-test-requires = ["pytest", "pytest-repeat", "scipy"]
-test-command = "pytest {project}/python/test.py -s -x"
-build-verbosity = 0
-skip = ["*musllinux*", "*i686*", "pp*", "cp36-*", "cp37-*"]
-
-[tool.cibuildwheel.linux]
-before-build = [
-    "rm -rf {project}/build",
-]
-manylinux-x86_64-image = "manylinux_2_28"
-manylinux-aarch64-image = "manylinux_2_28"
-
-archs = ["x86_64", "aarch64"]
-before-all = [
-    "yum install -y glibc-devel wget python3-devel"
-]
-repair-wheel-command = "auditwheel repair --lib-sdir . -w {dest_dir} {wheel}"
-
-[tool.cibuildwheel.macos]
-before-build = [
-    "rm -rf {project}/build",
-]
-archs = ["x86_64", "arm64"]
-repair-wheel-command = "delocate-wheel --require-archs {delocate_archs} -w {dest_dir} -v {wheel}"
-
-[tool.cibuildwheel.windows]
-before-build = [
-   "rd /s /q {project}\\build || echo Done",
-]
-archs = ["x86", "AMD64"]
-skip = ["*win32*", "pp*"]

package/simsimd/python/bench.ipynb

@@ -1,187 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "import scipy as sp\n",
-    "import simsimd as simd"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "simsimd_f = simd.cosine\n",
-    "conventional_f = sp.spatial.distance.cosine"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "count = 1000 # Common number of documents in a batch\n",
-    "ndim = 1536 # OpenAI Ada v2 embeddings API returns 1536-dim vectors\n",
-    "A = np.random.randn(count, ndim).astype(np.float32)\n",
-    "B = np.random.randn(count, ndim).astype(np.float32)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "16.3 ms ± 3.84 ms per loop (mean ± std. dev. of 10 runs, 1 loop each)\n"
-     ]
-    }
-   ],
-   "source": [
-    "%%timeit -n 1 -r 10\n",
-    "result_np = [conventional_f(A[i], B[i]) for i in range(count)]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "437 µs ± 15.6 µs per loop (mean ± std. dev. of 10 runs, 1 loop each)\n"
-     ]
-    }
-   ],
-   "source": [
-    "%%timeit -n 1 -r 10\n",
-    "result_simd = simsimd_f(A, B)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "A = np.random.randn(count, ndim).astype(np.float16)\n",
-    "B = np.random.randn(count, ndim).astype(np.float16)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "36.7 ms ± 843 µs per loop (mean ± std. dev. of 10 runs, 1 loop each)\n"
-     ]
-    }
-   ],
-   "source": [
-    "%%timeit -n 1 -r 10\n",
-    "result_np = [conventional_f(A[i], B[i]) for i in range(count)]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "437 µs ± 7.61 µs per loop (mean ± std. dev. of 10 runs, 1 loop each)\n"
-     ]
-    }
-   ],
-   "source": [
-    "%%timeit -n 1 -r 10\n",
-    "result_simd = simsimd_f(A, B)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "A = np.random.randint(-100, 100, (count, ndim), np.int8)\n",
-    "B = np.random.randint(-100, 100, (count, ndim), np.int8)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "12.4 ms ± 493 µs per loop (mean ± std. dev. of 10 runs, 1 loop each)\n"
-     ]
-    }
-   ],
-   "source": [
-    "%%timeit -n 1 -r 10\n",
-    "result_np = [conventional_f(A[i], B[i]) for i in range(count)]"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "63.6 µs ± 3.27 µs per loop (mean ± std. dev. of 10 runs, 1 loop each)\n"
-     ]
-    }
-   ],
-   "source": [
-    "%%timeit -n 1 -r 10\n",
-    "result_simd = simsimd_f(A, B)"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "base",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.11"
-  },
-  "orig_nbformat": 4
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}

package/simsimd/python/bench.py

@@ -1,268 +0,0 @@
-import timeit
-import argparse
-
-import numpy as np
-import scipy.spatial.distance as spd
-import scipy.special as scs
-import simsimd as simd
-
-# Argument parsing
-parser = argparse.ArgumentParser(description="Benchmark SimSIMD vs. SciPy")
-parser.add_argument(
-    "--n", type=int, default=1000, help="Number of vectors (default: 1000)"
-)
-parser.add_argument(
-    "--ndim", type=int, default=1536, help="Number of dimensions (default: 1536)"
-)
-args = parser.parse_args()
-
-count = args.n
-ndim = args.ndim
-
-
-# Benchmark function
-def benchmark(func, A, B, count=1):
-    start_time = timeit.default_timer()
-    func(A, B)
-    end_time = timeit.default_timer()
-    return (end_time - start_time) / count
-
-
-def wrap_rowwise(conventional_func):
-    def wrapped(A, B):
-        for i in range(A.shape[0]):
-            conventional_func(A[i], B[i])
-
-    return wrapped
-
-
-print()
-print("# Benchmarking SimSIMD vs. SciPy")
-print()
-
-print("- Vector dimensions:", ndim)
-print("- Vectors count:", count)
-
-try:
-    caps = [cap for cap, enabled in simd.get_capabilities().items() if enabled]
-    print("- Hardware capabilities:", ", ".join(caps))
-
-    deps: dict = np.show_config(mode="dicts").get("Build Dependencies")
-    print("- NumPy BLAS dependency:", deps["blas"]["name"])
-    print("- NumPy LAPACK dependency:", deps["lapack"]["name"])
-
-except:
-    pass
-
-count = 1000
-ndim = 1536
-
-generators = {
-    np.float32: lambda: np.random.randn(count, ndim).astype(np.float32),
-    np.float16: lambda: np.random.randn(count, ndim).astype(np.float16),
-    np.int8: lambda: np.random.randint(-100, 100, (count, ndim), np.int8),
-    np.uint8: lambda: np.packbits(
-        np.random.randint(0, 2, (count, ndim), np.uint8), axis=0
-    ),
-}
-
-dtype_names = {
-    np.float32: "f32",
-    np.float16: "f16",
-    np.int8: "i8",
-    np.uint8: "b8",
-}
-
-
-print()
-print("## Between 2 Vectors, Batch Size: 1")
-print()
-
-# Table headers
-print(
-    "| Datatype | Method                |                Ops/s |        SimSIMD Ops/s | SimSIMD Improvement |"
-)
-print(
-    "| :------- | :-------------------- | -------------------: | -------------------: | ------------------: |"
-)
-
-# Benchmark functions
-funcs = [
-    ("scipy.cosine", spd.cosine, simd.cosine, [np.float32, np.float16, np.int8]),
-    (
-        "scipy.sqeuclidean",
-        spd.sqeuclidean,
-        simd.sqeuclidean,
-        [np.float32, np.float16, np.int8],
-    ),
-    ("numpy.inner", np.inner, simd.inner, [np.float32, np.float16, np.int8]),
-    (
-        "scipy.jensenshannon",
-        spd.jensenshannon,
-        simd.jensenshannon,
-        [np.float32, np.float16],
-    ),
-    (
-        "scipy.kl_div",
-        scs.kl_div,
-        simd.kullbackleibler,
-        [np.float32, np.float16],
-    ),
-    ("scipy.hamming", spd.hamming, simd.hamming, [np.uint8]),
-    ("scipy.jaccard", spd.jaccard, simd.jaccard, [np.uint8]),
-]
-
-
-for name, conventional_func, simd_func, dtypes in funcs:
-    for dtype in dtypes:
-        A = generators[dtype]()
-        B = generators[dtype]()
-
-        conventional_time = benchmark(wrap_rowwise(conventional_func), A, B, count)
-        simd_time = benchmark(wrap_rowwise(simd_func), A, B, count)
-
-        conventional_ops = 1 / conventional_time
-        simd_ops = 1 / simd_time
-        improvement = conventional_time / simd_time
-
-        func_name = "`{}`".format(name)
-        dtype_name = "`{}`".format(dtype_names[dtype])
-        print(
-            f"| {dtype_name:8} | {func_name:21} | {conventional_ops:20,.0f} | {simd_ops:20,.0f} | {improvement:17.2f} x |"
-        )
-
-print()
-
-
-print("## Between 2 Vectors, Batch Size: {:,}".format(count))
-print()
-
-# Table headers
-print(
-    "| Datatype | Method                |                Ops/s |        SimSIMD Ops/s | SimSIMD Improvement |"
-)
-print(
-    "| :------- | :-------------------- | -------------------: | -------------------: | ------------------: |"
-)
-
-# Benchmark functions
-funcs = [
-    ("scipy.cosine", spd.cosine, simd.cosine, [np.float32, np.float16, np.int8]),
-    (
-        "scipy.sqeuclidean",
-        spd.sqeuclidean,
-        simd.sqeuclidean,
-        [np.float32, np.float16, np.int8],
-    ),
-    ("numpy.inner", np.inner, simd.inner, [np.float32, np.float16, np.int8]),
-    (
-        "scipy.jensenshannon",
-        spd.jensenshannon,
-        simd.jensenshannon,
-        [np.float32, np.float16],
-    ),
-    (
-        "scipy.kl_div",
-        scs.kl_div,
-        simd.kullbackleibler,
-        [np.float32, np.float16],
-    ),
-    ("scipy.hamming", spd.hamming, simd.hamming, [np.uint8]),
-    ("scipy.jaccard", spd.jaccard, simd.jaccard, [np.uint8]),
-]
-
-
-for name, conventional_func, simd_func, dtypes in funcs:
-    for dtype in dtypes:
-        A = generators[dtype]()
-        B = generators[dtype]()
-
-        conventional_time = benchmark(wrap_rowwise(conventional_func), A, B, count)
-        simd_time = benchmark(simd_func, A, B, count)
-
-        conventional_ops = 1 / conventional_time
-        simd_ops = 1 / simd_time
-        improvement = conventional_time / simd_time
-
-        func_name = "`{}`".format(name)
-        dtype_name = "`{}`".format(dtype_names[dtype])
-        print(
-            f"| {dtype_name:8} | {func_name:21} | {conventional_ops:20,.0f} | {simd_ops:20,.0f} | {improvement:17.2f} x |"
-        )
-
-print()
-
-
-# Benchmark functions for cdist
-print()
-print("## Between All Pairs of Vectors (`cdist`), Batch Size: {:,}".format(count))
-print()
-
-
-cdist_funcs = [
-    (
-        "scipy.cosine",
-        lambda A, B: spd.cdist(A, B, "cosine"),
-        lambda A, B: simd.cdist(A, B, "cosine"),
-        [np.float32, np.float16, np.int8],
-    ),
-    (
-        "scipy.sqeuclidean",
-        lambda A, B: spd.cdist(A, B, "sqeuclidean"),
-        lambda A, B: simd.cdist(A, B, "sqeuclidean"),
-        [np.float32, np.float16, np.int8],
-    ),
-    (
-        "numpy.inner",
-        lambda A, B: 1 - np.dot(A, B.T),
-        lambda A, B: simd.cdist(A, B, "inner"),
-        [np.float32, np.float16, np.int8],
-    ),
-    (
-        "scipy.jensenshannon",
-        lambda A, B: spd.cdist(A, B, "jensenshannon"),
-        lambda A, B: simd.cdist(A, B, "jensenshannon"),
-        [np.float32, np.float16],
-    ),
-    (
-        "scipy.hamming",
-        lambda A, B: spd.cdist(A, B, "hamming"),
-        lambda A, B: simd.cdist(A, B, "hamming"),
-        [np.uint8],
-    ),
-    (
-        "scipy.jaccard",
-        lambda A, B: spd.cdist(A, B, "jaccard"),
-        lambda A, B: simd.cdist(A, B, "jaccard"),
-        [np.uint8],
-    ),
-]
-
-
-# Table headers
-print(
-    "| Datatype | Method                |                Ops/s |        SimSIMD Ops/s | SimSIMD Improvement |"
-)
-print(
-    "| :------- | :-------------------- | -------------------: | -------------------: | ------------------: |"
-)
-
-for name, conventional_func, simd_func, dtypes in cdist_funcs:
-    for dtype in dtypes:
-        A = generators[dtype]()
-        B = generators[dtype]()
-
-        conventional_time = benchmark(conventional_func, A, B)
-        simd_time = benchmark(simd_func, A, B)
-
-        conventional_ops = count**2 / conventional_time
-        simd_ops = count**2 / simd_time
-        improvement = conventional_time / simd_time
-
-        func_name = "`{}`".format(name)
-        dtype_name = "`{}`".format(dtype_names[dtype])
-        print(
-            f"| {dtype_name:8} | {func_name:21} | {conventional_ops:20,.0f} | {simd_ops:20,.0f} | {improvement:17.2f} x |"
-        )
-
-print()