usearch 2.21.4 → 2.25.1

package/numkong/swift/Scalar.swift

@@ -0,0 +1,741 @@
+//  Scalar.swift
+//  NumKong
+//
+//  Created by Ash Vardanian on March 14, 2026.
+//
+
+import CNumKong
+
+// MARK: - Spatial Protocols
+
+/// A type that can compute SIMD-accelerated dot products with output type widening.
+public protocol NumKongDot {
+    associatedtype DotOutput
+    static func dot<A, B>(_ a: A, _ b: B) -> DotOutput?
+    where A: Sequence, B: Sequence, A.Element == Self, B.Element == Self
+}
+
+/// A type that can compute SIMD-accelerated angular (cosine) distances.
+public protocol NumKongAngular {
+    associatedtype AngularOutput
+    static func angular<A, B>(_ a: A, _ b: B) -> AngularOutput?
+    where A: Sequence, B: Sequence, A.Element == Self, B.Element == Self
+}
+
+/// A type that can compute SIMD-accelerated squared Euclidean distances.
+public protocol NumKongSqEuclidean {
+    associatedtype SqEuclideanOutput
+    static func sqeuclidean<A, B>(_ a: A, _ b: B) -> SqEuclideanOutput?
+    where A: Sequence, B: Sequence, A.Element == Self, B.Element == Self
+}
+
+/// A type that can compute SIMD-accelerated Euclidean distances.
+public protocol NumKongEuclidean {
+    associatedtype EuclideanOutput
+    static func euclidean<A, B>(_ a: A, _ b: B) -> EuclideanOutput?
+    where A: Sequence, B: Sequence, A.Element == Self, B.Element == Self
+}
+
+/// Convenience alias for types supporting all four spatial distance metrics.
+public typealias NumKongSpatial = NumKongDot & NumKongAngular & NumKongEuclidean & NumKongSqEuclidean
+
+// MARK: - Built-in Scalars
+
+extension Float64: NumKongDot {
+    public typealias DotOutput = Float64
+
+    @inlinable @inline(__always)
+    public static func dot<A, B>(_ a: A, _ b: B) -> Float64?
+    where A: Sequence, B: Sequence, A.Element == Float64, B.Element == Float64 {
+        _nkWithDensePair(a, b) { ap, bp, n in
+            var result: Float64 = 0
+            nk_dot_f64(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension Float64: NumKongAngular {
+    public typealias AngularOutput = Float64
+
+    @inlinable @inline(__always)
+    public static func angular<A, B>(_ a: A, _ b: B) -> Float64?
+    where A: Sequence, B: Sequence, A.Element == Float64, B.Element == Float64 {
+        _nkWithDensePair(a, b) { ap, bp, n in
+            var result: Float64 = 0
+            nk_angular_f64(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension Float64: NumKongEuclidean {
+    public typealias EuclideanOutput = Float64
+
+    @inlinable @inline(__always)
+    public static func euclidean<A, B>(_ a: A, _ b: B) -> Float64?
+    where A: Sequence, B: Sequence, A.Element == Float64, B.Element == Float64 {
+        _nkWithDensePair(a, b) { ap, bp, n in
+            var result: Float64 = 0
+            nk_euclidean_f64(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension Float64: NumKongSqEuclidean {
+    public typealias SqEuclideanOutput = Float64
+
+    @inlinable @inline(__always)
+    public static func sqeuclidean<A, B>(_ a: A, _ b: B) -> Float64?
+    where A: Sequence, B: Sequence, A.Element == Float64, B.Element == Float64 {
+        _nkWithDensePair(a, b) { ap, bp, n in
+            var result: Float64 = 0
+            nk_sqeuclidean_f64(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension Float32: NumKongDot {
+    public typealias DotOutput = Float64
+
+    @inlinable @inline(__always)
+    public static func dot<A, B>(_ a: A, _ b: B) -> Float64?
+    where A: Sequence, B: Sequence, A.Element == Float32, B.Element == Float32 {
+        _nkWithDensePair(a, b) { ap, bp, n in
+            var result: Float64 = 0
+            nk_dot_f32(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension Float32: NumKongAngular {
+    public typealias AngularOutput = Float64
+
+    @inlinable @inline(__always)
+    public static func angular<A, B>(_ a: A, _ b: B) -> Float64?
+    where A: Sequence, B: Sequence, A.Element == Float32, B.Element == Float32 {
+        _nkWithDensePair(a, b) { ap, bp, n in
+            var result: Float64 = 0
+            nk_angular_f32(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension Float32: NumKongEuclidean {
+    public typealias EuclideanOutput = Float64
+
+    @inlinable @inline(__always)
+    public static func euclidean<A, B>(_ a: A, _ b: B) -> Float64?
+    where A: Sequence, B: Sequence, A.Element == Float32, B.Element == Float32 {
+        _nkWithDensePair(a, b) { ap, bp, n in
+            var result: Float64 = 0
+            nk_euclidean_f32(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension Float32: NumKongSqEuclidean {
+    public typealias SqEuclideanOutput = Float64
+
+    @inlinable @inline(__always)
+    public static func sqeuclidean<A, B>(_ a: A, _ b: B) -> Float64?
+    where A: Sequence, B: Sequence, A.Element == Float32, B.Element == Float32 {
+        _nkWithDensePair(a, b) { ap, bp, n in
+            var result: Float64 = 0
+            nk_sqeuclidean_f32(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+// Float16 is a type-level absence on x86_64 — the compiler rejects it before
+// @available runtime checks apply, so we need a compile-time arch guard.
+// See: https://github.com/unum-cloud/USearch/pull/739
+#if !arch(x86_64)
+@available(macOS 11.0, iOS 14.0, tvOS 14.0, watchOS 7.0, *)
+extension Float16: NumKongDot {
+    public typealias DotOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func dot<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == Float16, B.Element == Float16 {
+        _nkWithDensePair(a, b) { ap, bp, n in
+            let aPtr = UnsafeRawPointer(ap).assumingMemoryBound(to: nk_f16_t.self)
+            let bPtr = UnsafeRawPointer(bp).assumingMemoryBound(to: nk_f16_t.self)
+            var result: Float32 = 0
+            nk_dot_f16(aPtr, bPtr, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+@available(macOS 11.0, iOS 14.0, tvOS 14.0, watchOS 7.0, *)
+extension Float16: NumKongAngular {
+    public typealias AngularOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func angular<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == Float16, B.Element == Float16 {
+        _nkWithDensePair(a, b) { ap, bp, n in
+            let aPtr = UnsafeRawPointer(ap).assumingMemoryBound(to: nk_f16_t.self)
+            let bPtr = UnsafeRawPointer(bp).assumingMemoryBound(to: nk_f16_t.self)
+            var result: Float32 = 0
+            nk_angular_f16(aPtr, bPtr, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+@available(macOS 11.0, iOS 14.0, tvOS 14.0, watchOS 7.0, *)
+extension Float16: NumKongEuclidean {
+    public typealias EuclideanOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func euclidean<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == Float16, B.Element == Float16 {
+        _nkWithDensePair(a, b) { ap, bp, n in
+            let aPtr = UnsafeRawPointer(ap).assumingMemoryBound(to: nk_f16_t.self)
+            let bPtr = UnsafeRawPointer(bp).assumingMemoryBound(to: nk_f16_t.self)
+            var result: Float32 = 0
+            nk_euclidean_f16(aPtr, bPtr, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+@available(macOS 11.0, iOS 14.0, tvOS 14.0, watchOS 7.0, *)
+extension Float16: NumKongSqEuclidean {
+    public typealias SqEuclideanOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func sqeuclidean<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == Float16, B.Element == Float16 {
+        _nkWithDensePair(a, b) { ap, bp, n in
+            let aPtr = UnsafeRawPointer(ap).assumingMemoryBound(to: nk_f16_t.self)
+            let bPtr = UnsafeRawPointer(bp).assumingMemoryBound(to: nk_f16_t.self)
+            var result: Float32 = 0
+            nk_sqeuclidean_f16(aPtr, bPtr, UInt64(n), &result)
+            return result
+        }
+    }
+}
+#endif  // !arch(x86_64)
+
+extension Int8: NumKongDot {
+    public typealias DotOutput = Int32
+
+    @inlinable @inline(__always)
+    public static func dot<A, B>(_ a: A, _ b: B) -> Int32?
+    where A: Sequence, B: Sequence, A.Element == Int8, B.Element == Int8 {
+        _nkWithDensePair(a, b) { ap, bp, n in
+            var result: Int32 = 0
+            nk_dot_i8(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension Int8: NumKongAngular {
+    public typealias AngularOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func angular<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == Int8, B.Element == Int8 {
+        _nkWithDensePair(a, b) { ap, bp, n in
+            var result: Float32 = 0
+            nk_angular_i8(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension Int8: NumKongEuclidean {
+    public typealias EuclideanOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func euclidean<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == Int8, B.Element == Int8 {
+        _nkWithDensePair(a, b) { ap, bp, n in
+            var result: Float32 = 0
+            nk_euclidean_i8(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension Int8: NumKongSqEuclidean {
+    public typealias SqEuclideanOutput = UInt32
+
+    @inlinable @inline(__always)
+    public static func sqeuclidean<A, B>(_ a: A, _ b: B) -> UInt32?
+    where A: Sequence, B: Sequence, A.Element == Int8, B.Element == Int8 {
+        _nkWithDensePair(a, b) { ap, bp, n in
+            var result: UInt32 = 0
+            nk_sqeuclidean_i8(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension UInt8: NumKongDot {
+    public typealias DotOutput = UInt32
+
+    @inlinable @inline(__always)
+    public static func dot<A, B>(_ a: A, _ b: B) -> UInt32?
+    where A: Sequence, B: Sequence, A.Element == UInt8, B.Element == UInt8 {
+        _nkWithDensePair(a, b) { ap, bp, n in
+            var result: UInt32 = 0
+            nk_dot_u8(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension UInt8: NumKongAngular {
+    public typealias AngularOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func angular<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == UInt8, B.Element == UInt8 {
+        _nkWithDensePair(a, b) { ap, bp, n in
+            var result: Float32 = 0
+            nk_angular_u8(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension UInt8: NumKongEuclidean {
+    public typealias EuclideanOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func euclidean<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == UInt8, B.Element == UInt8 {
+        _nkWithDensePair(a, b) { ap, bp, n in
+            var result: Float32 = 0
+            nk_euclidean_u8(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension UInt8: NumKongSqEuclidean {
+    public typealias SqEuclideanOutput = UInt32
+
+    @inlinable @inline(__always)
+    public static func sqeuclidean<A, B>(_ a: A, _ b: B) -> UInt32?
+    where A: Sequence, B: Sequence, A.Element == UInt8, B.Element == UInt8 {
+        _nkWithDensePair(a, b) { ap, bp, n in
+            var result: UInt32 = 0
+            nk_sqeuclidean_u8(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+// MARK: - Minifloat Scalars
+
+extension BFloat16: NumKongDot {
+    public typealias DotOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func dot<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == BFloat16, B.Element == BFloat16 {
+        _nkWithDensePairRebound(a, b, to: nk_bf16_t.self) { ap, bp, n in
+            var result: Float32 = 0
+            nk_dot_bf16(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension BFloat16: NumKongAngular {
+    public typealias AngularOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func angular<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == BFloat16, B.Element == BFloat16 {
+        _nkWithDensePairRebound(a, b, to: nk_bf16_t.self) { ap, bp, n in
+            var result: Float32 = 0
+            nk_angular_bf16(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension BFloat16: NumKongEuclidean {
+    public typealias EuclideanOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func euclidean<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == BFloat16, B.Element == BFloat16 {
+        _nkWithDensePairRebound(a, b, to: nk_bf16_t.self) { ap, bp, n in
+            var result: Float32 = 0
+            nk_euclidean_bf16(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension BFloat16: NumKongSqEuclidean {
+    public typealias SqEuclideanOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func sqeuclidean<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == BFloat16, B.Element == BFloat16 {
+        _nkWithDensePairRebound(a, b, to: nk_bf16_t.self) { ap, bp, n in
+            var result: Float32 = 0
+            nk_sqeuclidean_bf16(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension E4M3: NumKongDot {
+    public typealias DotOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func dot<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == E4M3, B.Element == E4M3 {
+        _nkWithDensePairRebound(a, b, to: nk_e4m3_t.self) { ap, bp, n in
+            var result: Float32 = 0
+            nk_dot_e4m3(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension E4M3: NumKongAngular {
+    public typealias AngularOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func angular<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == E4M3, B.Element == E4M3 {
+        _nkWithDensePairRebound(a, b, to: nk_e4m3_t.self) { ap, bp, n in
+            var result: Float32 = 0
+            nk_angular_e4m3(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension E4M3: NumKongEuclidean {
+    public typealias EuclideanOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func euclidean<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == E4M3, B.Element == E4M3 {
+        _nkWithDensePairRebound(a, b, to: nk_e4m3_t.self) { ap, bp, n in
+            var result: Float32 = 0
+            nk_euclidean_e4m3(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension E4M3: NumKongSqEuclidean {
+    public typealias SqEuclideanOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func sqeuclidean<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == E4M3, B.Element == E4M3 {
+        _nkWithDensePairRebound(a, b, to: nk_e4m3_t.self) { ap, bp, n in
+            var result: Float32 = 0
+            nk_sqeuclidean_e4m3(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension E5M2: NumKongDot {
+    public typealias DotOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func dot<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == E5M2, B.Element == E5M2 {
+        _nkWithDensePairRebound(a, b, to: nk_e5m2_t.self) { ap, bp, n in
+            var result: Float32 = 0
+            nk_dot_e5m2(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension E5M2: NumKongAngular {
+    public typealias AngularOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func angular<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == E5M2, B.Element == E5M2 {
+        _nkWithDensePairRebound(a, b, to: nk_e5m2_t.self) { ap, bp, n in
+            var result: Float32 = 0
+            nk_angular_e5m2(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension E5M2: NumKongEuclidean {
+    public typealias EuclideanOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func euclidean<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == E5M2, B.Element == E5M2 {
+        _nkWithDensePairRebound(a, b, to: nk_e5m2_t.self) { ap, bp, n in
+            var result: Float32 = 0
+            nk_euclidean_e5m2(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension E5M2: NumKongSqEuclidean {
+    public typealias SqEuclideanOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func sqeuclidean<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == E5M2, B.Element == E5M2 {
+        _nkWithDensePairRebound(a, b, to: nk_e5m2_t.self) { ap, bp, n in
+            var result: Float32 = 0
+            nk_sqeuclidean_e5m2(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension E2M3: NumKongDot {
+    public typealias DotOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func dot<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == E2M3, B.Element == E2M3 {
+        _nkWithDensePairRebound(a, b, to: nk_e2m3_t.self) { ap, bp, n in
+            var result: Float32 = 0
+            nk_dot_e2m3(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension E2M3: NumKongAngular {
+    public typealias AngularOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func angular<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == E2M3, B.Element == E2M3 {
+        _nkWithDensePairRebound(a, b, to: nk_e2m3_t.self) { ap, bp, n in
+            var result: Float32 = 0
+            nk_angular_e2m3(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension E2M3: NumKongEuclidean {
+    public typealias EuclideanOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func euclidean<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == E2M3, B.Element == E2M3 {
+        _nkWithDensePairRebound(a, b, to: nk_e2m3_t.self) { ap, bp, n in
+            var result: Float32 = 0
+            nk_euclidean_e2m3(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension E2M3: NumKongSqEuclidean {
+    public typealias SqEuclideanOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func sqeuclidean<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == E2M3, B.Element == E2M3 {
+        _nkWithDensePairRebound(a, b, to: nk_e2m3_t.self) { ap, bp, n in
+            var result: Float32 = 0
+            nk_sqeuclidean_e2m3(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension E3M2: NumKongDot {
+    public typealias DotOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func dot<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == E3M2, B.Element == E3M2 {
+        _nkWithDensePairRebound(a, b, to: nk_e3m2_t.self) { ap, bp, n in
+            var result: Float32 = 0
+            nk_dot_e3m2(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension E3M2: NumKongAngular {
+    public typealias AngularOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func angular<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == E3M2, B.Element == E3M2 {
+        _nkWithDensePairRebound(a, b, to: nk_e3m2_t.self) { ap, bp, n in
+            var result: Float32 = 0
+            nk_angular_e3m2(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension E3M2: NumKongEuclidean {
+    public typealias EuclideanOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func euclidean<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == E3M2, B.Element == E3M2 {
+        _nkWithDensePairRebound(a, b, to: nk_e3m2_t.self) { ap, bp, n in
+            var result: Float32 = 0
+            nk_euclidean_e3m2(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+extension E3M2: NumKongSqEuclidean {
+    public typealias SqEuclideanOutput = Float32
+
+    @inlinable @inline(__always)
+    public static func sqeuclidean<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == E3M2, B.Element == E3M2 {
+        _nkWithDensePairRebound(a, b, to: nk_e3m2_t.self) { ap, bp, n in
+            var result: Float32 = 0
+            nk_sqeuclidean_e3m2(ap, bp, UInt64(n), &result)
+            return result
+        }
+    }
+}
+
+// MARK: - U1x8 Dot
+
+extension U1x8: NumKongDot {
+    public typealias DotOutput = UInt32
+
+    @inlinable @inline(__always)
+    public static func dot<A, B>(_ a: A, _ b: B) -> UInt32?
+    where A: Sequence, B: Sequence, A.Element == U1x8, B.Element == U1x8 {
+        _nkWithDensePair(a, b) { ap, bp, n in
+            let aPtr = UnsafeRawPointer(ap).assumingMemoryBound(to: nk_u1x8_t.self)
+            let bPtr = UnsafeRawPointer(bp).assumingMemoryBound(to: nk_u1x8_t.self)
+            var result: UInt32 = 0
+            nk_dot_u1(aPtr, bPtr, UInt64(n * 8), &result)
+            return result
+        }
+    }
+}
+
+// MARK: - Set Protocols
+
+/// A type that can compute SIMD-accelerated Hamming distances over bit sets.
+public protocol NumKongHamming {
+    associatedtype HammingOutput
+    static func hamming<A, B>(_ a: A, _ b: B) -> HammingOutput?
+    where A: Sequence, B: Sequence, A.Element == Self, B.Element == Self
+}
+
+/// A type that can compute SIMD-accelerated Jaccard distances over bit sets.
+public protocol NumKongJaccard {
+    associatedtype JaccardOutput
+    static func jaccard<A, B>(_ a: A, _ b: B) -> JaccardOutput?
+    where A: Sequence, B: Sequence, A.Element == Self, B.Element == Self
+}
+
+// MARK: - U1x8 Sets
+
+extension U1x8: NumKongHamming {
+    @inlinable @inline(__always)
+    public static func hamming<A, B>(_ a: A, _ b: B) -> UInt32?
+    where A: Sequence, B: Sequence, A.Element == U1x8, B.Element == U1x8 {
+        _nkWithDensePair(a, b) { ap, bp, n in
+            let aPtr = UnsafeRawPointer(ap).assumingMemoryBound(to: nk_u1x8_t.self)
+            let bPtr = UnsafeRawPointer(bp).assumingMemoryBound(to: nk_u1x8_t.self)
+            var result: UInt32 = 0
+            nk_hamming_u1(aPtr, bPtr, UInt64(n * 8), &result)
+            return result
+        }
+    }
+}
+
+extension U1x8: NumKongJaccard {
+    @inlinable @inline(__always)
+    public static func jaccard<A, B>(_ a: A, _ b: B) -> Float32?
+    where A: Sequence, B: Sequence, A.Element == U1x8, B.Element == U1x8 {
+        _nkWithDensePair(a, b) { ap, bp, n in
+            let aPtr = UnsafeRawPointer(ap).assumingMemoryBound(to: nk_u1x8_t.self)
+            let bPtr = UnsafeRawPointer(bp).assumingMemoryBound(to: nk_u1x8_t.self)
+            var result: Float32 = 0
+            nk_jaccard_u1(aPtr, bPtr, UInt64(n * 8), &result)
+            return result
+        }
+    }
+}
+
+// MARK: - Collection Extensions
+
+extension RandomAccessCollection where Element: NumKongDot {
+    /// Computes the SIMD-accelerated dot product with another sequence.
+    @inlinable @inline(__always)
+    public func dot<B>(_ b: B) -> Element.DotOutput?
+    where B: Sequence, B.Element == Element {
+        Element.dot(self, b)
+    }
+}
+
+extension RandomAccessCollection where Element: NumKongAngular {
+    /// Computes the SIMD-accelerated angular (cosine) distance to another sequence.
+    @inlinable @inline(__always)
+    public func angular<B>(_ b: B) -> Element.AngularOutput?
+    where B: Sequence, B.Element == Element {
+        Element.angular(self, b)
+    }
+}
+
+extension RandomAccessCollection where Element: NumKongEuclidean {
+    /// Computes the SIMD-accelerated Euclidean distance to another sequence.
+    @inlinable @inline(__always)
+    public func euclidean<B>(_ b: B) -> Element.EuclideanOutput?
+    where B: Sequence, B.Element == Element {
+        Element.euclidean(self, b)
+    }
+}
+
+extension RandomAccessCollection where Element: NumKongSqEuclidean {
+    /// Computes the SIMD-accelerated squared Euclidean distance to another sequence.
+    @inlinable @inline(__always)
+    public func sqeuclidean<B>(_ b: B) -> Element.SqEuclideanOutput?
+    where B: Sequence, B.Element == Element {
+        Element.sqeuclidean(self, b)
+    }
+}
+
+extension RandomAccessCollection where Element: NumKongHamming {
+    /// Computes the SIMD-accelerated Hamming distance to another sequence.
+    @inlinable @inline(__always)
+    public func hamming<B>(_ b: B) -> Element.HammingOutput?
+    where B: Sequence, B.Element == Element {
+        Element.hamming(self, b)
+    }
+}
+
+extension RandomAccessCollection where Element: NumKongJaccard {
+    /// Computes the SIMD-accelerated Jaccard distance to another sequence.
+    @inlinable @inline(__always)
+    public func jaccard<B>(_ b: B) -> Element.JaccardOutput?
+    where B: Sequence, B.Element == Element {
+        Element.jaccard(self, b)
+    }
+}