usearch 2.11.1 → 2.13.1

package/simsimd/rust/lib.rs

@@ -87,10 +87,17 @@ extern "C" {
     fn simsimd_kl_f64(a: *const f64, b: *const f64, c: usize, d: *mut Distance);
 
     fn simsimd_uses_neon() -> i32;
+    fn simsimd_uses_neon_f16() -> i32;
+    fn simsimd_uses_neon_bf16() -> i32;
+    fn simsimd_uses_neon_i8() -> i32;
     fn simsimd_uses_sve() -> i32;
+    fn simsimd_uses_sve_f16() -> i32;
+    fn simsimd_uses_sve_bf16() -> i32;
+    fn simsimd_uses_sve_i8() -> i32;
     fn simsimd_uses_haswell() -> i32;
     fn simsimd_uses_skylake() -> i32;
     fn simsimd_uses_ice() -> i32;
+    fn simsimd_uses_genoa() -> i32;
     fn simsimd_uses_sapphire() -> i32;
 }
 
@@ -100,18 +107,42 @@ pub struct f16(u16);
 
 impl f16 {}
 
-/// The `capabilties` module provides functions for detecting the hardware features
+/// The `capabilities` module provides functions for detecting the hardware features
 /// available on the current system.
-pub mod capabilties {
+pub mod capabilities {
 
     pub fn uses_neon() -> bool {
         unsafe { crate::simsimd_uses_neon() != 0 }
     }
 
+    pub fn uses_neon_f16() -> bool {
+        unsafe { crate::simsimd_uses_neon_f16() != 0 }
+    }
+
+    pub fn uses_neon_bf16() -> bool {
+        unsafe { crate::simsimd_uses_neon_bf16() != 0 }
+    }
+
+    pub fn uses_neon_i8() -> bool {
+        unsafe { crate::simsimd_uses_neon_i8() != 0 }
+    }
+
     pub fn uses_sve() -> bool {
         unsafe { crate::simsimd_uses_sve() != 0 }
     }
 
+    pub fn uses_sve_f16() -> bool {
+        unsafe { crate::simsimd_uses_sve_f16() != 0 }
+    }
+
+    pub fn uses_sve_bf16() -> bool {
+        unsafe { crate::simsimd_uses_sve_bf16() != 0 }
+    }
+
+    pub fn uses_sve_i8() -> bool {
+        unsafe { crate::simsimd_uses_sve_i8() != 0 }
+    }
+
     pub fn uses_haswell() -> bool {
         unsafe { crate::simsimd_uses_haswell() != 0 }
     }
@@ -124,6 +155,10 @@ pub mod capabilties {
         unsafe { crate::simsimd_uses_ice() != 0 }
     }
 
+    pub fn uses_genoa() -> bool {
+        unsafe { crate::simsimd_uses_genoa() != 0 }
+    }
+
     pub fn uses_sapphire() -> bool {
         unsafe { crate::simsimd_uses_sapphire() != 0 }
     }
@@ -552,11 +587,12 @@ mod tests {
 
     #[test]
     fn test_hardware_features_detection() {
-        let uses_arm = capabilties::uses_neon() || capabilties::uses_sve();
-        let uses_x86 = capabilties::uses_haswell()
-            || capabilties::uses_skylake()
-            || capabilties::uses_ice()
-            || capabilties::uses_sapphire();
+        let uses_arm = capabilities::uses_neon() || capabilities::uses_sve();
+        let uses_x86 = capabilities::uses_haswell()
+            || capabilities::uses_skylake()
+            || capabilities::uses_ice()
+            || capabilities::uses_genoa()
+            || capabilities::uses_sapphire();
 
         // The CPU can't simultaneously support ARM and x86 SIMD extensions
         if uses_arm {
@@ -566,12 +602,13 @@ mod tests {
             assert!(!uses_arm);
         }
 
-        println!("- uses_neon: {}", capabilties::uses_neon());
-        println!("- uses_sve: {}", capabilties::uses_sve());
-        println!("- uses_haswell: {}", capabilties::uses_haswell());
-        println!("- uses_skylake: {}", capabilties::uses_skylake());
-        println!("- uses_ice: {}", capabilties::uses_ice());
-        println!("- uses_sapphire: {}", capabilties::uses_sapphire());
+        println!("- uses_neon: {}", capabilities::uses_neon());
+        println!("- uses_sve: {}", capabilities::uses_sve());
+        println!("- uses_haswell: {}", capabilities::uses_haswell());
+        println!("- uses_skylake: {}", capabilities::uses_skylake());
+        println!("- uses_ice: {}", capabilities::uses_ice());
+        println!("- uses_genoa: {}", capabilities::uses_genoa());
+        println!("- uses_sapphire: {}", capabilities::uses_sapphire());
     }
 
     //

package/simsimd/swift/source/SimSIMD.swift

@@ -0,0 +1,123 @@
+import CSimSIMD
+
+public protocol SimSIMD {
+    static var dataType: simsimd_datatype_t { get }
+    static var cosine: simsimd_metric_punned_t { get }
+    static var dotProduct: simsimd_metric_punned_t { get }
+    static var squaredEuclidean: simsimd_metric_punned_t { get }
+}
+
+extension Int8: SimSIMD {
+    public static let dataType = simsimd_datatype_i8_k
+    public static let cosine = find(kind: simsimd_metric_cosine_k, dataType: dataType)
+    public static let dotProduct = find(kind: simsimd_metric_dot_k, dataType: dataType)
+    public static let squaredEuclidean = find(kind: simsimd_metric_sqeuclidean_k, dataType: dataType)
+}
+
+@available(macOS 11.0, iOS 14.0, tvOS 14.0, watchOS 7.0, *)
+extension Float16: SimSIMD {
+    public static let dataType = simsimd_datatype_f16_k
+    public static let cosine = find(kind: simsimd_metric_cosine_k, dataType: dataType)
+    public static let dotProduct = find(kind: simsimd_metric_dot_k, dataType: dataType)
+    public static let squaredEuclidean = find(kind: simsimd_metric_sqeuclidean_k, dataType: dataType)
+}
+
+extension Float32: SimSIMD {
+    public static let dataType = simsimd_datatype_f32_k
+    public static let cosine = find(kind: simsimd_metric_cosine_k, dataType: dataType)
+    public static let dotProduct = find(kind: simsimd_metric_inner_k, dataType: dataType)
+    public static let squaredEuclidean = find(kind: simsimd_metric_sqeuclidean_k, dataType: dataType)
+}
+
+extension Float64: SimSIMD {
+    public static let dataType = simsimd_datatype_f64_k
+    public static let cosine = find(kind: simsimd_metric_cosine_k, dataType: dataType)
+    public static let dotProduct = find(kind: simsimd_metric_dot_k, dataType: dataType)
+    public static let squaredEuclidean = find(kind: simsimd_metric_sqeuclidean_k, dataType: dataType)
+}
+
+extension SimSIMD {
+    @inlinable @inline(__always)
+    public static func cosine<A, B>(_ a: A, _ b: B) -> Double? where A: Sequence, B: Sequence, A.Element == Self, B.Element == Self {
+        perform(cosine, a: a, b: b)
+    }
+
+    @inlinable @inline(__always)
+    public static func dot<A, B>(_ a: A, _ b: B) -> Double? where A: Sequence, B: Sequence, A.Element == Self, B.Element == Self {
+        perform(dotProduct, a: a, b: b)
+    }
+
+    @inlinable @inline(__always)
+    public static func sqeuclidean<A, B>(_ a: A, _ b: B) -> Double? where A: Sequence, B: Sequence, A.Element == Self, B.Element == Self {
+        perform(squaredEuclidean, a: a, b: b)
+    }
+}
+
+extension RandomAccessCollection where Element: SimSIMD {
+    @inlinable @inline(__always)
+    public func cosine<B>(_ b: B) -> Double? where B: Sequence, B.Element == Element {
+        Element.cosine(self, b)
+    }
+
+    @inlinable @inline(__always)
+    public func dot<B>(_ b: B) -> Double? where B: Sequence, B.Element == Element {
+        Element.dot(self, b)
+    }
+
+    @inlinable @inline(__always)
+    public func sqeuclidean<B>(_ b: B) -> Double? where B: Sequence, B.Element == Element {
+        Element.sqeuclidean(self, b)
+    }
+}
+
+@inlinable @inline(__always)
+func perform<A, B>(_ metric: simsimd_metric_punned_t, a: A, b: B) -> Double? where A: Sequence, B: Sequence, A.Element == B.Element {
+    var distance: simsimd_distance_t = 0
+    let result = a.withContiguousStorageIfAvailable { a in
+        b.withContiguousStorageIfAvailable { b in
+            guard a.count > 0 && a.count == b.count else { return false }
+            metric(a.baseAddress, b.baseAddress, .init(a.count), &distance)
+            return true
+        }
+    }
+    guard result == true else { return nil }
+    return distance
+}
+
+public typealias Capabilities = simsimd_capability_t
+
+extension simsimd_capability_t: OptionSet, CustomStringConvertible {
+    public var description: String {
+        var components: [String] = []
+        if contains(.neon) { components.append(".neon") }
+        if contains(.sve) { components.append(".sve") }
+        if contains(.sve2) { components.append(".sve2") }
+        if contains(.haswell) { components.append(".haswell") }
+        if contains(.skylake) { components.append(".skylake") }
+        if contains(.ice) { components.append(".ice") }
+        if contains(.sapphire) { components.append(".sapphire") }
+        if contains(.genoa) { components.append(".genoa") }
+        return "[\(components.joined(separator: ", "))]"
+    }
+
+    public static let available = simsimd_capabilities()
+
+    public static let any = simsimd_cap_any_k
+    public static let neon = simsimd_cap_neon_k
+    public static let sve = simsimd_cap_sve_k
+    public static let sve2 = simsimd_cap_sve2_k
+    public static let haswell = simsimd_cap_haswell_k
+    public static let skylake = simsimd_cap_skylake_k
+    public static let ice = simsimd_cap_ice_k
+    public static let sapphire = simsimd_cap_sapphire_k
+    public static let genoa = simsimd_cap_genoa_k
+}
+
+@inline(__always)
+private func find(kind: simsimd_metric_kind_t, dataType: simsimd_datatype_t) -> simsimd_metric_punned_t {
+    var output: simsimd_metric_punned_t?
+    var used = simsimd_capability_t.any
+    simsimd_find_metric_punned(kind, dataType, .available, .any, &output, &used)
+    guard let output else { fatalError("Could not find function \(kind) for \(dataType)") }
+    return output
+}

package/simsimd/swift/tests/SimSIMDTests.swift

@@ -0,0 +1,92 @@
+import SimSIMD
+import XCTest
+
+class SimSIMDTests: XCTestCase {
+    override class func setUp() {
+        print("Capabilities: \(Capabilities.available)")
+    }
+
+    func testCosineInt8() throws {
+        let a: [Int8] = [3, 97, 127]
+        let b: [Int8] = [3, 97, 127]
+        let result = try XCTUnwrap(a.cosine(b))
+        XCTAssertEqual(result, 0.00012027938, accuracy: 0.01)
+    }
+
+    func testCosineFloat16() throws {
+        let a: [Float16] = [1.0, 2.0, 3.0]
+        let b: [Float16] = [1.0, 2.0, 3.0]
+        let result = try XCTUnwrap(a.cosine(b))
+        XCTAssertEqual(result, 0.004930496, accuracy: 0.01)
+    }
+
+    func testCosineFloat32() throws {
+        let a: [Float32] = [1.0, 2.0, 3.0]
+        let b: [Float32] = [1.0, 2.0, 3.0]
+        let result = try XCTUnwrap(a.cosine(b))
+        XCTAssertEqual(result, 0.004930496, accuracy: 0.01)
+    }
+
+    func testCosineFloat64() throws {
+        let a: [Float64] = [1.0, 2.0, 3.0]
+        let b: [Float64] = [1.0, 2.0, 3.0]
+        let result = try XCTUnwrap(a.cosine(b))
+        XCTAssertEqual(result, 0.004930496, accuracy: 0.01)
+    }
+
+    func testInnerInt8() throws {
+        let a: [Int8] = [1, 2, 3]
+        let b: [Int8] = [4, 5, 6]
+        let result = try XCTUnwrap(a.dot(b))
+        XCTAssertEqual(result, 0.029403687, accuracy: 0.01)
+    }
+
+    func testDotFloat16() throws {
+        let a: [Float16] = [1.0, 2.0, 3.0]
+        let b: [Float16] = [4.0, 5.0, 6.0]
+        let result = try XCTUnwrap(a.dot(b))
+        XCTAssertEqual(result, 32.0, accuracy: 0.01)
+    }
+
+    func testDotFloat32() throws {
+        let a: [Float32] = [1.0, 2.0, 3.0]
+        let b: [Float32] = [4.0, 5.0, 6.0]
+        let result = try XCTUnwrap(a.dot(b))
+        XCTAssertEqual(result, 32.0, accuracy: 0.01)
+    }
+
+    func testDotFloat64() throws {
+        let a: [Float64] = [1.0, 2.0, 3.0]
+        let b: [Float64] = [4.0, 5.0, 6.0]
+        let result = try XCTUnwrap(a.dot(b))
+        XCTAssertEqual(result, 32.0, accuracy: 0.01)
+    }
+
+    func testSqeuclideanInt8() throws {
+        let a: [Int8] = [1, 2, 3]
+        let b: [Int8] = [4, 5, 6]
+        let result = try XCTUnwrap(a.sqeuclidean(b))
+        XCTAssertEqual(result, 27.0, accuracy: 0.01)
+    }
+
+    func testSqeuclideanFloat16() throws {
+        let a: [Float16] = [1.0, 2.0, 3.0]
+        let b: [Float16] = [4.0, 5.0, 6.0]
+        let result = try XCTUnwrap(a.sqeuclidean(b))
+        XCTAssertEqual(result, 27.0, accuracy: 0.01)
+    }
+
+    func testSqeuclideanFloat32() throws {
+        let a: [Float32] = [1.0, 2.0, 3.0]
+        let b: [Float32] = [4.0, 5.0, 6.0]
+        let result = try XCTUnwrap(a.sqeuclidean(b))
+        XCTAssertEqual(result, 27.0, accuracy: 0.01)
+    }
+
+    func testSqeuclideanFloat64() throws {
+        let a: [Float64] = [1.0, 2.0, 3.0]
+        let b: [Float64] = [4.0, 5.0, 6.0]
+        let result = try XCTUnwrap(a.sqeuclidean(b))
+        XCTAssertEqual(result, 27.0, accuracy: 0.01)
+    }
+}

package/simsimd/.releaserc

@@ -1,87 +0,0 @@
-{
-    "branches": [
-        "main"
-    ],
-    "debug": true,
-    "ci": true,
-    "dryRun": false,
-    "plugins": [
-        [
-            "@semantic-release/commit-analyzer",
-            {
-                "preset": "eslint",
-                "releaseRules": [
-                    {
-                        "tag": "Break",
-                        "release": "major"
-                    },
-                    {
-                        "tag": "Add",
-                        "release": "minor"
-                    },
-                    {
-                        "tag": "Improve",
-                        "release": "patch"
-                    },
-                    {
-                        "tag": "Make",
-                        "release": "patch"
-                    },
-                    {
-                        "tag": "Refactor",
-                        "release": false
-                    }
-                ]
-            }
-        ],
-        [
-            "@semantic-release/release-notes-generator",
-            {
-                "preset": "eslint",
-                "releaseRules": [
-                    {
-                        "tag": "Break",
-                        "release": "major"
-                    },
-                    {
-                        "tag": "Add",
-                        "release": "minor"
-                    },
-                    {
-                        "tag": "Improve",
-                        "release": "patch"
-                    },
-                    {
-                        "tag": "Make",
-                        "release": "patch"
-                    },
-                    {
-                        "tag": "Refactor",
-                        "release": false
-                    }
-                ]
-            }
-        ],
-        "@semantic-release/github",
-        [
-            "@semantic-release/exec",
-            {
-                "prepareCmd": "bash .github/workflows/update_version.sh '${nextRelease.version}'"
-            }
-        ],
-        [
-            "@semantic-release/git",
-            {
-                "assets": [
-                    "VERSION",
-                    "package.json",
-                    "Cargo.toml",
-                    "Cargo.lock",
-                    "CMakeLists.txt",
-                    "include/simsimd/simsimd.h"
-                ],
-                "message": "Build: Released ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
-            }
-        ]
-    ]
-}