usearch 2.21.4 → 2.25.1

package/numkong/swift/Matrix.swift

@@ -0,0 +1,1388 @@
+//  Matrix.swift
+//  NumKong
+//
+//  Created by Ash Vardanian on March 14, 2026.
+//
+
+import CNumKong
+
+/// Errors thrown by matrix operations.
+public enum NumKongMatrixError: Error {
+    /// The matrix has zero or negative rows/cols.
+    case invalidDimensions
+    /// The row stride is smaller than `cols * MemoryLayout<Element>.stride`.
+    case invalidStride
+    /// The output matrix shape does not match the expected dimensions.
+    case outputShapeMismatch
+    /// The vector depth (cols) of the two matrices differs.
+    case depthMismatch
+    /// The requested row window exceeds matrix bounds.
+    case rowWindowOutOfBounds
+    /// The packed buffer size returned by the kernel is zero.
+    case packedBufferTooSmall
+}
+
+/// Non-owning, immutable view over a row-major matrix stored in contiguous memory.
+public struct MatrixView<Element> {
+    public let baseAddress: UnsafePointer<Element>
+    public let rows: Int
+    public let cols: Int
+    public let rowStrideBytes: Int
+
+    @inlinable
+    public init(
+        baseAddress: UnsafePointer<Element>,
+        rows: Int,
+        cols: Int,
+        rowStrideBytes: Int? = nil
+    ) {
+        self.baseAddress = baseAddress
+        self.rows = rows
+        self.cols = cols
+        self.rowStrideBytes = rowStrideBytes ?? cols * MemoryLayout<Element>.stride
+    }
+}
+
+/// Non-owning, mutable view over a row-major matrix stored in contiguous memory.
+public struct MatrixSpan<Element> {
+    public let baseAddress: UnsafeMutablePointer<Element>
+    public let rows: Int
+    public let cols: Int
+    public let rowStrideBytes: Int
+
+    @inlinable
+    public init(
+        baseAddress: UnsafeMutablePointer<Element>,
+        rows: Int,
+        cols: Int,
+        rowStrideBytes: Int? = nil
+    ) {
+        self.baseAddress = baseAddress
+        self.rows = rows
+        self.cols = cols
+        self.rowStrideBytes = rowStrideBytes ?? cols * MemoryLayout<Element>.stride
+    }
+}
+
+// MARK: - Deprecated Aliases
+
+@available(*, deprecated, renamed: "MatrixView")
+public typealias Matrix = MatrixView
+
+@available(*, deprecated, renamed: "MatrixSpan")
+public typealias MutableMatrix = MatrixSpan
+
+// MARK: - PackedMatrix
+
+/// Owns a kernel-optimized packed copy of a matrix for batch distance computations.
+public final class PackedMatrix<Element>: @unchecked Sendable {
+    public let rows: Int
+    public let cols: Int
+    public let byteCount: Int
+
+    @usableFromInline
+    let rawPointer: UnsafeMutableRawPointer
+
+    @usableFromInline
+    init(rows: Int, cols: Int, byteCount: Int, rawPointer: UnsafeMutableRawPointer) {
+        self.rows = rows
+        self.cols = cols
+        self.byteCount = byteCount
+        self.rawPointer = rawPointer
+    }
+
+    deinit {
+        rawPointer.deallocate()
+    }
+
+    /// Provides read-only access to the underlying packed bytes.
+    @inlinable
+    public var rawBuffer: UnsafeRawBufferPointer {
+        UnsafeRawBufferPointer(start: rawPointer, count: byteCount)
+    }
+}
+
+// MARK: - Validation
+
+@usableFromInline
+func _nkValidateMatrixView<Element>(_ matrix: MatrixView<Element>) throws {
+    guard matrix.rows > 0 && matrix.cols > 0 else {
+        throw NumKongMatrixError.invalidDimensions
+    }
+    let minStride = matrix.cols * MemoryLayout<Element>.stride
+    guard matrix.rowStrideBytes >= minStride else {
+        throw NumKongMatrixError.invalidStride
+    }
+}
+
+@usableFromInline
+func _nkValidateMatrixSpan<Element>(_ matrix: MatrixSpan<Element>) throws {
+    guard matrix.rows > 0 && matrix.cols > 0 else {
+        throw NumKongMatrixError.invalidDimensions
+    }
+    let minStride = matrix.cols * MemoryLayout<Element>.stride
+    guard matrix.rowStrideBytes >= minStride else {
+        throw NumKongMatrixError.invalidStride
+    }
+}
+
+// MARK: - Dots Protocol
+
+/// Element type that supports batch dot-product matrix operations.
+public protocol NumKongDotsMatrixElement {
+    associatedtype DotsOutput
+
+    static func _nk_dots_packed_size(_ n: Int, _ k: Int) -> Int
+    static func _nk_dots_pack(
+        _ b: UnsafePointer<Self>, _ n: Int, _ k: Int, _ bStride: Int, _ packed: UnsafeMutableRawPointer)
+    static func _nk_dots_packed(
+        _ a: UnsafePointer<Self>,
+        _ bPacked: UnsafeRawPointer,
+        _ c: UnsafeMutablePointer<DotsOutput>,
+        _ m: Int,
+        _ n: Int,
+        _ k: Int,
+        _ aStride: Int,
+        _ cStride: Int
+    )
+    static func _nk_dots_symmetric(
+        _ vectors: UnsafePointer<Self>,
+        _ result: UnsafeMutablePointer<DotsOutput>,
+        _ nVectors: Int,
+        _ depth: Int,
+        _ stride: Int,
+        _ resultStride: Int,
+        _ rowStart: Int,
+        _ rowCount: Int
+    )
+}
+
+// MARK: - Spatials Protocol
+
+/// Element type that supports batch angular and Euclidean matrix operations.
+public protocol NumKongSpatialsMatrixElement: NumKongDotsMatrixElement {
+    associatedtype SpatialOutput
+
+    static func _nk_angulars_packed(
+        _ a: UnsafePointer<Self>,
+        _ bPacked: UnsafeRawPointer,
+        _ result: UnsafeMutablePointer<SpatialOutput>,
+        _ rows: Int,
+        _ cols: Int,
+        _ depth: Int,
+        _ aStride: Int,
+        _ rStride: Int
+    )
+    static func _nk_euclideans_packed(
+        _ a: UnsafePointer<Self>,
+        _ bPacked: UnsafeRawPointer,
+        _ result: UnsafeMutablePointer<SpatialOutput>,
+        _ rows: Int,
+        _ cols: Int,
+        _ depth: Int,
+        _ aStride: Int,
+        _ rStride: Int
+    )
+    static func _nk_angulars_symmetric(
+        _ vectors: UnsafePointer<Self>,
+        _ result: UnsafeMutablePointer<SpatialOutput>,
+        _ nVectors: Int,
+        _ depth: Int,
+        _ stride: Int,
+        _ resultStride: Int,
+        _ rowStart: Int,
+        _ rowCount: Int
+    )
+    static func _nk_euclideans_symmetric(
+        _ vectors: UnsafePointer<Self>,
+        _ result: UnsafeMutablePointer<SpatialOutput>,
+        _ nVectors: Int,
+        _ depth: Int,
+        _ stride: Int,
+        _ resultStride: Int,
+        _ rowStart: Int,
+        _ rowCount: Int
+    )
+}
+
+// MARK: - Sets Protocol
+
+/// Element type that supports batch Hamming and Jaccard matrix operations.
+public protocol NumKongSetsMatrixElement: NumKongDotsMatrixElement {
+    associatedtype HammingOutput
+    associatedtype JaccardOutput
+
+    static func _nk_hammings_packed(
+        _ a: UnsafePointer<Self>,
+        _ bPacked: UnsafeRawPointer,
+        _ result: UnsafeMutablePointer<HammingOutput>,
+        _ rows: Int,
+        _ cols: Int,
+        _ depth: Int,
+        _ aStride: Int,
+        _ rStride: Int
+    )
+    static func _nk_hammings_symmetric(
+        _ vectors: UnsafePointer<Self>,
+        _ result: UnsafeMutablePointer<HammingOutput>,
+        _ nVectors: Int,
+        _ depth: Int,
+        _ stride: Int,
+        _ resultStride: Int,
+        _ rowStart: Int,
+        _ rowCount: Int
+    )
+    static func _nk_jaccards_packed(
+        _ a: UnsafePointer<Self>,
+        _ bPacked: UnsafeRawPointer,
+        _ result: UnsafeMutablePointer<JaccardOutput>,
+        _ rows: Int,
+        _ cols: Int,
+        _ depth: Int,
+        _ aStride: Int,
+        _ rStride: Int
+    )
+    static func _nk_jaccards_symmetric(
+        _ vectors: UnsafePointer<Self>,
+        _ result: UnsafeMutablePointer<JaccardOutput>,
+        _ nVectors: Int,
+        _ depth: Int,
+        _ stride: Int,
+        _ resultStride: Int,
+        _ rowStart: Int,
+        _ rowCount: Int
+    )
+}
+
+// MARK: - PackedMatrix Packing
+
+extension PackedMatrix where Element: NumKongDotsMatrixElement {
+    /// Packs the given matrix view into a kernel-optimized layout for batch dot products.
+    public convenience init(packing matrix: MatrixView<Element>) throws {
+        try _nkValidateMatrixView(matrix)
+        let bytes = Element._nk_dots_packed_size(matrix.rows, matrix.cols)
+        guard bytes > 0 else { throw NumKongMatrixError.packedBufferTooSmall }
+        let ptr = UnsafeMutableRawPointer.allocate(byteCount: bytes, alignment: 64)
+        Element._nk_dots_pack(matrix.baseAddress, matrix.rows, matrix.cols, matrix.rowStrideBytes, ptr)
+        self.init(rows: matrix.rows, cols: matrix.cols, byteCount: bytes, rawPointer: ptr)
+    }
+}
+
+// MARK: - Dots Functions
+
+/// Computes dot products between each row of `a` and every row packed in `bPacked`.
+@inlinable
+public func dots_packed<Element: NumKongDotsMatrixElement>(
+    _ a: MatrixView<Element>,
+    _ bPacked: PackedMatrix<Element>,
+    _ result: inout MatrixSpan<Element.DotsOutput>
+) throws {
+    try _nkValidateMatrixView(a)
+    try _nkValidateMatrixSpan(result)
+
+    guard a.cols == bPacked.cols else { throw NumKongMatrixError.depthMismatch }
+    guard result.rows == a.rows && result.cols == bPacked.rows else {
+        throw NumKongMatrixError.outputShapeMismatch
+    }
+
+    Element._nk_dots_packed(
+        a.baseAddress,
+        UnsafeRawPointer(bPacked.rawPointer),
+        result.baseAddress,
+        a.rows,
+        bPacked.rows,
+        a.cols,
+        a.rowStrideBytes,
+        result.rowStrideBytes
+    )
+}
+
+/// Computes the symmetric dot-product matrix for all row pairs in `vectors`.
+@inlinable
+public func dots_symmetric<Element: NumKongDotsMatrixElement>(
+    _ vectors: MatrixView<Element>,
+    _ result: inout MatrixSpan<Element.DotsOutput>,
+    rowStart: Int = 0,
+    rowCount: Int? = nil
+) throws {
+    try _nkValidateMatrixView(vectors)
+    try _nkValidateMatrixSpan(result)
+
+    guard result.rows == vectors.rows && result.cols == vectors.rows else {
+        throw NumKongMatrixError.outputShapeMismatch
+    }
+
+    let count = rowCount ?? (vectors.rows - rowStart)
+    guard rowStart >= 0 && count >= 0 && rowStart + count <= vectors.rows else {
+        throw NumKongMatrixError.rowWindowOutOfBounds
+    }
+
+    Element._nk_dots_symmetric(
+        vectors.baseAddress,
+        result.baseAddress,
+        vectors.rows,
+        vectors.cols,
+        vectors.rowStrideBytes,
+        result.rowStrideBytes,
+        rowStart,
+        count
+    )
+}
+
+// MARK: - Spatials Functions
+
+/// Computes angular distances between each row of `a` and every row packed in `bPacked`.
+@inlinable
+public func angulars_packed<Element: NumKongSpatialsMatrixElement>(
+    _ a: MatrixView<Element>,
+    _ bPacked: PackedMatrix<Element>,
+    _ result: inout MatrixSpan<Element.SpatialOutput>
+) throws {
+    try _nkValidateMatrixView(a)
+    try _nkValidateMatrixSpan(result)
+
+    guard a.cols == bPacked.cols else { throw NumKongMatrixError.depthMismatch }
+    guard result.rows == a.rows && result.cols == bPacked.rows else {
+        throw NumKongMatrixError.outputShapeMismatch
+    }
+
+    Element._nk_angulars_packed(
+        a.baseAddress,
+        UnsafeRawPointer(bPacked.rawPointer),
+        result.baseAddress,
+        a.rows,
+        bPacked.rows,
+        a.cols,
+        a.rowStrideBytes,
+        result.rowStrideBytes
+    )
+}
+
+/// Computes Euclidean distances between each row of `a` and every row packed in `bPacked`.
+@inlinable
+public func euclideans_packed<Element: NumKongSpatialsMatrixElement>(
+    _ a: MatrixView<Element>,
+    _ bPacked: PackedMatrix<Element>,
+    _ result: inout MatrixSpan<Element.SpatialOutput>
+) throws {
+    try _nkValidateMatrixView(a)
+    try _nkValidateMatrixSpan(result)
+
+    guard a.cols == bPacked.cols else { throw NumKongMatrixError.depthMismatch }
+    guard result.rows == a.rows && result.cols == bPacked.rows else {
+        throw NumKongMatrixError.outputShapeMismatch
+    }
+
+    Element._nk_euclideans_packed(
+        a.baseAddress,
+        UnsafeRawPointer(bPacked.rawPointer),
+        result.baseAddress,
+        a.rows,
+        bPacked.rows,
+        a.cols,
+        a.rowStrideBytes,
+        result.rowStrideBytes
+    )
+}
+
+/// Computes the symmetric angular-distance matrix for all row pairs in `vectors`.
+@inlinable
+public func angulars_symmetric<Element: NumKongSpatialsMatrixElement>(
+    _ vectors: MatrixView<Element>,
+    _ result: inout MatrixSpan<Element.SpatialOutput>,
+    rowStart: Int = 0,
+    rowCount: Int? = nil
+) throws {
+    try _nkValidateMatrixView(vectors)
+    try _nkValidateMatrixSpan(result)
+
+    guard result.rows == vectors.rows && result.cols == vectors.rows else {
+        throw NumKongMatrixError.outputShapeMismatch
+    }
+
+    let count = rowCount ?? (vectors.rows - rowStart)
+    guard rowStart >= 0 && count >= 0 && rowStart + count <= vectors.rows else {
+        throw NumKongMatrixError.rowWindowOutOfBounds
+    }
+
+    Element._nk_angulars_symmetric(
+        vectors.baseAddress,
+        result.baseAddress,
+        vectors.rows,
+        vectors.cols,
+        vectors.rowStrideBytes,
+        result.rowStrideBytes,
+        rowStart,
+        count
+    )
+}
+
+/// Computes the symmetric Euclidean-distance matrix for all row pairs in `vectors`.
+@inlinable
+public func euclideans_symmetric<Element: NumKongSpatialsMatrixElement>(
+    _ vectors: MatrixView<Element>,
+    _ result: inout MatrixSpan<Element.SpatialOutput>,
+    rowStart: Int = 0,
+    rowCount: Int? = nil
+) throws {
+    try _nkValidateMatrixView(vectors)
+    try _nkValidateMatrixSpan(result)
+
+    guard result.rows == vectors.rows && result.cols == vectors.rows else {
+        throw NumKongMatrixError.outputShapeMismatch
+    }
+
+    let count = rowCount ?? (vectors.rows - rowStart)
+    guard rowStart >= 0 && count >= 0 && rowStart + count <= vectors.rows else {
+        throw NumKongMatrixError.rowWindowOutOfBounds
+    }
+
+    Element._nk_euclideans_symmetric(
+        vectors.baseAddress,
+        result.baseAddress,
+        vectors.rows,
+        vectors.cols,
+        vectors.rowStrideBytes,
+        result.rowStrideBytes,
+        rowStart,
+        count
+    )
+}
+
+// MARK: - Sets Functions
+
+/// Computes Hamming distances between each row of `a` and every row packed in `bPacked`.
+@inlinable
+public func hammings_packed<Element: NumKongSetsMatrixElement>(
+    _ a: MatrixView<Element>,
+    _ bPacked: PackedMatrix<Element>,
+    _ result: inout MatrixSpan<Element.HammingOutput>
+) throws {
+    try _nkValidateMatrixView(a)
+    try _nkValidateMatrixSpan(result)
+
+    guard a.cols == bPacked.cols else { throw NumKongMatrixError.depthMismatch }
+    guard result.rows == a.rows && result.cols == bPacked.rows else {
+        throw NumKongMatrixError.outputShapeMismatch
+    }
+
+    Element._nk_hammings_packed(
+        a.baseAddress,
+        UnsafeRawPointer(bPacked.rawPointer),
+        result.baseAddress,
+        a.rows,
+        bPacked.rows,
+        a.cols,
+        a.rowStrideBytes,
+        result.rowStrideBytes
+    )
+}
+
+/// Computes the symmetric Hamming-distance matrix for all row pairs in `vectors`.
+@inlinable
+public func hammings_symmetric<Element: NumKongSetsMatrixElement>(
+    _ vectors: MatrixView<Element>,
+    _ result: inout MatrixSpan<Element.HammingOutput>,
+    rowStart: Int = 0,
+    rowCount: Int? = nil
+) throws {
+    try _nkValidateMatrixView(vectors)
+    try _nkValidateMatrixSpan(result)
+
+    guard result.rows == vectors.rows && result.cols == vectors.rows else {
+        throw NumKongMatrixError.outputShapeMismatch
+    }
+
+    let count = rowCount ?? (vectors.rows - rowStart)
+    guard rowStart >= 0 && count >= 0 && rowStart + count <= vectors.rows else {
+        throw NumKongMatrixError.rowWindowOutOfBounds
+    }
+
+    Element._nk_hammings_symmetric(
+        vectors.baseAddress,
+        result.baseAddress,
+        vectors.rows,
+        vectors.cols,
+        vectors.rowStrideBytes,
+        result.rowStrideBytes,
+        rowStart,
+        count
+    )
+}
+
+/// Computes Jaccard distances between each row of `a` and every row packed in `bPacked`.
+@inlinable
+public func jaccards_packed<Element: NumKongSetsMatrixElement>(
+    _ a: MatrixView<Element>,
+    _ bPacked: PackedMatrix<Element>,
+    _ result: inout MatrixSpan<Element.JaccardOutput>
+) throws {
+    try _nkValidateMatrixView(a)
+    try _nkValidateMatrixSpan(result)
+
+    guard a.cols == bPacked.cols else { throw NumKongMatrixError.depthMismatch }
+    guard result.rows == a.rows && result.cols == bPacked.rows else {
+        throw NumKongMatrixError.outputShapeMismatch
+    }
+
+    Element._nk_jaccards_packed(
+        a.baseAddress,
+        UnsafeRawPointer(bPacked.rawPointer),
+        result.baseAddress,
+        a.rows,
+        bPacked.rows,
+        a.cols,
+        a.rowStrideBytes,
+        result.rowStrideBytes
+    )
+}
+
+/// Computes the symmetric Jaccard-distance matrix for all row pairs in `vectors`.
+@inlinable
+public func jaccards_symmetric<Element: NumKongSetsMatrixElement>(
+    _ vectors: MatrixView<Element>,
+    _ result: inout MatrixSpan<Element.JaccardOutput>,
+    rowStart: Int = 0,
+    rowCount: Int? = nil
+) throws {
+    try _nkValidateMatrixView(vectors)
+    try _nkValidateMatrixSpan(result)
+
+    guard result.rows == vectors.rows && result.cols == vectors.rows else {
+        throw NumKongMatrixError.outputShapeMismatch
+    }
+
+    let count = rowCount ?? (vectors.rows - rowStart)
+    guard rowStart >= 0 && count >= 0 && rowStart + count <= vectors.rows else {
+        throw NumKongMatrixError.rowWindowOutOfBounds
+    }
+
+    Element._nk_jaccards_symmetric(
+        vectors.baseAddress,
+        result.baseAddress,
+        vectors.rows,
+        vectors.cols,
+        vectors.rowStrideBytes,
+        result.rowStrideBytes,
+        rowStart,
+        count
+    )
+}
+
+// MARK: - Kernel Bindings: Float32
+
+extension Float32: NumKongDotsMatrixElement {
+    public typealias DotsOutput = Float64
+
+    public static func _nk_dots_packed_size(_ n: Int, _ k: Int) -> Int {
+        Int(nk_dots_packed_size_f32(UInt64(n), UInt64(k)))
+    }
+
+    public static func _nk_dots_pack(
+        _ b: UnsafePointer<Float32>, _ n: Int, _ k: Int, _ bStride: Int, _ packed: UnsafeMutableRawPointer
+    ) {
+        nk_dots_pack_f32(b, UInt64(n), UInt64(k), UInt64(bStride), packed)
+    }
+
+    public static func _nk_dots_packed(
+        _ a: UnsafePointer<Float32>, _ bPacked: UnsafeRawPointer, _ c: UnsafeMutablePointer<Float64>, _ m: Int,
+        _ n: Int, _ k: Int, _ aStride: Int, _ cStride: Int
+    ) {
+        nk_dots_packed_f32(a, bPacked, c, UInt64(m), UInt64(n), UInt64(k), UInt64(aStride), UInt64(cStride))
+    }
+
+    public static func _nk_dots_symmetric(
+        _ vectors: UnsafePointer<Float32>, _ result: UnsafeMutablePointer<Float64>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        nk_dots_symmetric_f32(
+            vectors, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+}
+
+extension Float32: NumKongSpatialsMatrixElement {
+    public typealias SpatialOutput = Float64
+
+    public static func _nk_angulars_packed(
+        _ a: UnsafePointer<Float32>, _ bPacked: UnsafeRawPointer, _ result: UnsafeMutablePointer<Float64>, _ rows: Int,
+        _ cols: Int, _ depth: Int, _ aStride: Int, _ rStride: Int
+    ) {
+        nk_angulars_packed_f32(
+            a, bPacked, result, UInt64(rows), UInt64(cols), UInt64(depth), UInt64(aStride), UInt64(rStride))
+    }
+
+    public static func _nk_euclideans_packed(
+        _ a: UnsafePointer<Float32>, _ bPacked: UnsafeRawPointer, _ result: UnsafeMutablePointer<Float64>, _ rows: Int,
+        _ cols: Int, _ depth: Int, _ aStride: Int, _ rStride: Int
+    ) {
+        nk_euclideans_packed_f32(
+            a, bPacked, result, UInt64(rows), UInt64(cols), UInt64(depth), UInt64(aStride), UInt64(rStride))
+    }
+
+    public static func _nk_angulars_symmetric(
+        _ vectors: UnsafePointer<Float32>, _ result: UnsafeMutablePointer<Float64>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        nk_angulars_symmetric_f32(
+            vectors, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+
+    public static func _nk_euclideans_symmetric(
+        _ vectors: UnsafePointer<Float32>, _ result: UnsafeMutablePointer<Float64>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        nk_euclideans_symmetric_f32(
+            vectors, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+}
+
+// MARK: - Kernel Bindings: Float64
+
+extension Float64: NumKongDotsMatrixElement {
+    public typealias DotsOutput = Float64
+
+    public static func _nk_dots_packed_size(_ n: Int, _ k: Int) -> Int {
+        Int(nk_dots_packed_size_f64(UInt64(n), UInt64(k)))
+    }
+
+    public static func _nk_dots_pack(
+        _ b: UnsafePointer<Float64>, _ n: Int, _ k: Int, _ bStride: Int, _ packed: UnsafeMutableRawPointer
+    ) {
+        nk_dots_pack_f64(b, UInt64(n), UInt64(k), UInt64(bStride), packed)
+    }
+
+    public static func _nk_dots_packed(
+        _ a: UnsafePointer<Float64>, _ bPacked: UnsafeRawPointer, _ c: UnsafeMutablePointer<Float64>, _ m: Int,
+        _ n: Int, _ k: Int, _ aStride: Int, _ cStride: Int
+    ) {
+        nk_dots_packed_f64(a, bPacked, c, UInt64(m), UInt64(n), UInt64(k), UInt64(aStride), UInt64(cStride))
+    }
+
+    public static func _nk_dots_symmetric(
+        _ vectors: UnsafePointer<Float64>, _ result: UnsafeMutablePointer<Float64>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        nk_dots_symmetric_f64(
+            vectors, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+}
+
+extension Float64: NumKongSpatialsMatrixElement {
+    public typealias SpatialOutput = Float64
+
+    public static func _nk_angulars_packed(
+        _ a: UnsafePointer<Float64>, _ bPacked: UnsafeRawPointer, _ result: UnsafeMutablePointer<Float64>, _ rows: Int,
+        _ cols: Int, _ depth: Int, _ aStride: Int, _ rStride: Int
+    ) {
+        nk_angulars_packed_f64(
+            a, bPacked, result, UInt64(rows), UInt64(cols), UInt64(depth), UInt64(aStride), UInt64(rStride))
+    }
+
+    public static func _nk_euclideans_packed(
+        _ a: UnsafePointer<Float64>, _ bPacked: UnsafeRawPointer, _ result: UnsafeMutablePointer<Float64>, _ rows: Int,
+        _ cols: Int, _ depth: Int, _ aStride: Int, _ rStride: Int
+    ) {
+        nk_euclideans_packed_f64(
+            a, bPacked, result, UInt64(rows), UInt64(cols), UInt64(depth), UInt64(aStride), UInt64(rStride))
+    }
+
+    public static func _nk_angulars_symmetric(
+        _ vectors: UnsafePointer<Float64>, _ result: UnsafeMutablePointer<Float64>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        nk_angulars_symmetric_f64(
+            vectors, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+
+    public static func _nk_euclideans_symmetric(
+        _ vectors: UnsafePointer<Float64>, _ result: UnsafeMutablePointer<Float64>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        nk_euclideans_symmetric_f64(
+            vectors, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+}
+
+// MARK: - Kernel Bindings: Int8
+
+extension Int8: NumKongDotsMatrixElement {
+    public typealias DotsOutput = Int32
+
+    public static func _nk_dots_packed_size(_ n: Int, _ k: Int) -> Int {
+        Int(nk_dots_packed_size_i8(UInt64(n), UInt64(k)))
+    }
+
+    public static func _nk_dots_pack(
+        _ b: UnsafePointer<Int8>, _ n: Int, _ k: Int, _ bStride: Int, _ packed: UnsafeMutableRawPointer
+    ) {
+        nk_dots_pack_i8(b, UInt64(n), UInt64(k), UInt64(bStride), packed)
+    }
+
+    public static func _nk_dots_packed(
+        _ a: UnsafePointer<Int8>, _ bPacked: UnsafeRawPointer, _ c: UnsafeMutablePointer<Int32>, _ m: Int, _ n: Int,
+        _ k: Int, _ aStride: Int, _ cStride: Int
+    ) {
+        nk_dots_packed_i8(a, bPacked, c, UInt64(m), UInt64(n), UInt64(k), UInt64(aStride), UInt64(cStride))
+    }
+
+    public static func _nk_dots_symmetric(
+        _ vectors: UnsafePointer<Int8>, _ result: UnsafeMutablePointer<Int32>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        nk_dots_symmetric_i8(
+            vectors, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+}
+
+extension Int8: NumKongSpatialsMatrixElement {
+    public typealias SpatialOutput = Float32
+
+    public static func _nk_angulars_packed(
+        _ a: UnsafePointer<Int8>, _ bPacked: UnsafeRawPointer, _ result: UnsafeMutablePointer<Float32>, _ rows: Int,
+        _ cols: Int, _ depth: Int, _ aStride: Int, _ rStride: Int
+    ) {
+        nk_angulars_packed_i8(
+            a, bPacked, result, UInt64(rows), UInt64(cols), UInt64(depth), UInt64(aStride), UInt64(rStride))
+    }
+
+    public static func _nk_euclideans_packed(
+        _ a: UnsafePointer<Int8>, _ bPacked: UnsafeRawPointer, _ result: UnsafeMutablePointer<Float32>, _ rows: Int,
+        _ cols: Int, _ depth: Int, _ aStride: Int, _ rStride: Int
+    ) {
+        nk_euclideans_packed_i8(
+            a, bPacked, result, UInt64(rows), UInt64(cols), UInt64(depth), UInt64(aStride), UInt64(rStride))
+    }
+
+    public static func _nk_angulars_symmetric(
+        _ vectors: UnsafePointer<Int8>, _ result: UnsafeMutablePointer<Float32>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        nk_angulars_symmetric_i8(
+            vectors, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+
+    public static func _nk_euclideans_symmetric(
+        _ vectors: UnsafePointer<Int8>, _ result: UnsafeMutablePointer<Float32>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        nk_euclideans_symmetric_i8(
+            vectors, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+}
+
+// MARK: - Kernel Bindings: UInt8
+
+extension UInt8: NumKongDotsMatrixElement {
+    public typealias DotsOutput = UInt32
+
+    public static func _nk_dots_packed_size(_ n: Int, _ k: Int) -> Int {
+        Int(nk_dots_packed_size_u8(UInt64(n), UInt64(k)))
+    }
+
+    public static func _nk_dots_pack(
+        _ b: UnsafePointer<UInt8>, _ n: Int, _ k: Int, _ bStride: Int, _ packed: UnsafeMutableRawPointer
+    ) {
+        nk_dots_pack_u8(b, UInt64(n), UInt64(k), UInt64(bStride), packed)
+    }
+
+    public static func _nk_dots_packed(
+        _ a: UnsafePointer<UInt8>, _ bPacked: UnsafeRawPointer, _ c: UnsafeMutablePointer<UInt32>, _ m: Int, _ n: Int,
+        _ k: Int, _ aStride: Int, _ cStride: Int
+    ) {
+        nk_dots_packed_u8(a, bPacked, c, UInt64(m), UInt64(n), UInt64(k), UInt64(aStride), UInt64(cStride))
+    }
+
+    public static func _nk_dots_symmetric(
+        _ vectors: UnsafePointer<UInt8>, _ result: UnsafeMutablePointer<UInt32>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        nk_dots_symmetric_u8(
+            vectors, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+}
+
+extension UInt8: NumKongSpatialsMatrixElement {
+    public typealias SpatialOutput = Float32
+
+    public static func _nk_angulars_packed(
+        _ a: UnsafePointer<UInt8>, _ bPacked: UnsafeRawPointer, _ result: UnsafeMutablePointer<Float32>, _ rows: Int,
+        _ cols: Int, _ depth: Int, _ aStride: Int, _ rStride: Int
+    ) {
+        nk_angulars_packed_u8(
+            a, bPacked, result, UInt64(rows), UInt64(cols), UInt64(depth), UInt64(aStride), UInt64(rStride))
+    }
+
+    public static func _nk_euclideans_packed(
+        _ a: UnsafePointer<UInt8>, _ bPacked: UnsafeRawPointer, _ result: UnsafeMutablePointer<Float32>, _ rows: Int,
+        _ cols: Int, _ depth: Int, _ aStride: Int, _ rStride: Int
+    ) {
+        nk_euclideans_packed_u8(
+            a, bPacked, result, UInt64(rows), UInt64(cols), UInt64(depth), UInt64(aStride), UInt64(rStride))
+    }
+
+    public static func _nk_angulars_symmetric(
+        _ vectors: UnsafePointer<UInt8>, _ result: UnsafeMutablePointer<Float32>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        nk_angulars_symmetric_u8(
+            vectors, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+
+    public static func _nk_euclideans_symmetric(
+        _ vectors: UnsafePointer<UInt8>, _ result: UnsafeMutablePointer<Float32>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        nk_euclideans_symmetric_u8(
+            vectors, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+}
+
+// MARK: - Kernel Bindings: Float16
+
+#if !arch(x86_64)
+@available(macOS 11.0, iOS 14.0, tvOS 14.0, watchOS 7.0, *)
+extension Float16: NumKongDotsMatrixElement {
+    public typealias DotsOutput = Float32
+
+    public static func _nk_dots_packed_size(_ n: Int, _ k: Int) -> Int {
+        Int(nk_dots_packed_size_f16(UInt64(n), UInt64(k)))
+    }
+
+    public static func _nk_dots_pack(
+        _ b: UnsafePointer<Float16>, _ n: Int, _ k: Int, _ bStride: Int, _ packed: UnsafeMutableRawPointer
+    ) {
+        let cPtr = UnsafeRawPointer(b).assumingMemoryBound(to: nk_f16_t.self)
+        nk_dots_pack_f16(cPtr, UInt64(n), UInt64(k), UInt64(bStride), packed)
+    }
+
+    public static func _nk_dots_packed(
+        _ a: UnsafePointer<Float16>, _ bPacked: UnsafeRawPointer, _ c: UnsafeMutablePointer<Float32>, _ m: Int,
+        _ n: Int, _ k: Int, _ aStride: Int, _ cStride: Int
+    ) {
+        let cPtr = UnsafeRawPointer(a).assumingMemoryBound(to: nk_f16_t.self)
+        nk_dots_packed_f16(cPtr, bPacked, c, UInt64(m), UInt64(n), UInt64(k), UInt64(aStride), UInt64(cStride))
+    }
+
+    public static func _nk_dots_symmetric(
+        _ vectors: UnsafePointer<Float16>, _ result: UnsafeMutablePointer<Float32>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        let cPtr = UnsafeRawPointer(vectors).assumingMemoryBound(to: nk_f16_t.self)
+        nk_dots_symmetric_f16(
+            cPtr, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+}
+
+@available(macOS 11.0, iOS 14.0, tvOS 14.0, watchOS 7.0, *)
+extension Float16: NumKongSpatialsMatrixElement {
+    public typealias SpatialOutput = Float32
+
+    public static func _nk_angulars_packed(
+        _ a: UnsafePointer<Float16>, _ bPacked: UnsafeRawPointer, _ result: UnsafeMutablePointer<Float32>, _ rows: Int,
+        _ cols: Int, _ depth: Int, _ aStride: Int, _ rStride: Int
+    ) {
+        let cPtr = UnsafeRawPointer(a).assumingMemoryBound(to: nk_f16_t.self)
+        nk_angulars_packed_f16(
+            cPtr, bPacked, result, UInt64(rows), UInt64(cols), UInt64(depth), UInt64(aStride), UInt64(rStride))
+    }
+
+    public static func _nk_euclideans_packed(
+        _ a: UnsafePointer<Float16>, _ bPacked: UnsafeRawPointer, _ result: UnsafeMutablePointer<Float32>, _ rows: Int,
+        _ cols: Int, _ depth: Int, _ aStride: Int, _ rStride: Int
+    ) {
+        let cPtr = UnsafeRawPointer(a).assumingMemoryBound(to: nk_f16_t.self)
+        nk_euclideans_packed_f16(
+            cPtr, bPacked, result, UInt64(rows), UInt64(cols), UInt64(depth), UInt64(aStride), UInt64(rStride))
+    }
+
+    public static func _nk_angulars_symmetric(
+        _ vectors: UnsafePointer<Float16>, _ result: UnsafeMutablePointer<Float32>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        let cPtr = UnsafeRawPointer(vectors).assumingMemoryBound(to: nk_f16_t.self)
+        nk_angulars_symmetric_f16(
+            cPtr, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+
+    public static func _nk_euclideans_symmetric(
+        _ vectors: UnsafePointer<Float16>, _ result: UnsafeMutablePointer<Float32>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        let cPtr = UnsafeRawPointer(vectors).assumingMemoryBound(to: nk_f16_t.self)
+        nk_euclideans_symmetric_f16(
+            cPtr, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+}
+#endif
+
+// MARK: - Kernel Bindings: Minifloats
+
+extension BFloat16: NumKongDotsMatrixElement {
+    public typealias DotsOutput = Float32
+
+    public static func _nk_dots_packed_size(_ n: Int, _ k: Int) -> Int {
+        Int(nk_dots_packed_size_bf16(UInt64(n), UInt64(k)))
+    }
+
+    public static func _nk_dots_pack(
+        _ b: UnsafePointer<BFloat16>, _ n: Int, _ k: Int, _ bStride: Int, _ packed: UnsafeMutableRawPointer
+    ) {
+        let cPtr = UnsafeRawPointer(b).assumingMemoryBound(to: nk_bf16_t.self)
+        nk_dots_pack_bf16(cPtr, UInt64(n), UInt64(k), UInt64(bStride), packed)
+    }
+
+    public static func _nk_dots_packed(
+        _ a: UnsafePointer<BFloat16>, _ bPacked: UnsafeRawPointer, _ c: UnsafeMutablePointer<Float32>, _ m: Int,
+        _ n: Int, _ k: Int, _ aStride: Int, _ cStride: Int
+    ) {
+        let cPtr = UnsafeRawPointer(a).assumingMemoryBound(to: nk_bf16_t.self)
+        nk_dots_packed_bf16(cPtr, bPacked, c, UInt64(m), UInt64(n), UInt64(k), UInt64(aStride), UInt64(cStride))
+    }
+
+    public static func _nk_dots_symmetric(
+        _ vectors: UnsafePointer<BFloat16>, _ result: UnsafeMutablePointer<Float32>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        let cPtr = UnsafeRawPointer(vectors).assumingMemoryBound(to: nk_bf16_t.self)
+        nk_dots_symmetric_bf16(
+            cPtr, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+}
+
+extension BFloat16: NumKongSpatialsMatrixElement {
+    public typealias SpatialOutput = Float32
+
+    public static func _nk_angulars_packed(
+        _ a: UnsafePointer<BFloat16>, _ bPacked: UnsafeRawPointer, _ result: UnsafeMutablePointer<Float32>, _ rows: Int,
+        _ cols: Int, _ depth: Int, _ aStride: Int, _ rStride: Int
+    ) {
+        let cPtr = UnsafeRawPointer(a).assumingMemoryBound(to: nk_bf16_t.self)
+        nk_angulars_packed_bf16(
+            cPtr, bPacked, result, UInt64(rows), UInt64(cols), UInt64(depth), UInt64(aStride), UInt64(rStride))
+    }
+
+    public static func _nk_euclideans_packed(
+        _ a: UnsafePointer<BFloat16>, _ bPacked: UnsafeRawPointer, _ result: UnsafeMutablePointer<Float32>, _ rows: Int,
+        _ cols: Int, _ depth: Int, _ aStride: Int, _ rStride: Int
+    ) {
+        let cPtr = UnsafeRawPointer(a).assumingMemoryBound(to: nk_bf16_t.self)
+        nk_euclideans_packed_bf16(
+            cPtr, bPacked, result, UInt64(rows), UInt64(cols), UInt64(depth), UInt64(aStride), UInt64(rStride))
+    }
+
+    public static func _nk_angulars_symmetric(
+        _ vectors: UnsafePointer<BFloat16>, _ result: UnsafeMutablePointer<Float32>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        let cPtr = UnsafeRawPointer(vectors).assumingMemoryBound(to: nk_bf16_t.self)
+        nk_angulars_symmetric_bf16(
+            cPtr, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+
+    public static func _nk_euclideans_symmetric(
+        _ vectors: UnsafePointer<BFloat16>, _ result: UnsafeMutablePointer<Float32>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        let cPtr = UnsafeRawPointer(vectors).assumingMemoryBound(to: nk_bf16_t.self)
+        nk_euclideans_symmetric_bf16(
+            cPtr, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+}
+
+extension E4M3: NumKongDotsMatrixElement {
+    public typealias DotsOutput = Float32
+
+    public static func _nk_dots_packed_size(_ n: Int, _ k: Int) -> Int {
+        Int(nk_dots_packed_size_e4m3(UInt64(n), UInt64(k)))
+    }
+
+    public static func _nk_dots_pack(
+        _ b: UnsafePointer<E4M3>, _ n: Int, _ k: Int, _ bStride: Int, _ packed: UnsafeMutableRawPointer
+    ) {
+        let cPtr = UnsafeRawPointer(b).assumingMemoryBound(to: nk_e4m3_t.self)
+        nk_dots_pack_e4m3(cPtr, UInt64(n), UInt64(k), UInt64(bStride), packed)
+    }
+
+    public static func _nk_dots_packed(
+        _ a: UnsafePointer<E4M3>, _ bPacked: UnsafeRawPointer, _ c: UnsafeMutablePointer<Float32>, _ m: Int, _ n: Int,
+        _ k: Int, _ aStride: Int, _ cStride: Int
+    ) {
+        let cPtr = UnsafeRawPointer(a).assumingMemoryBound(to: nk_e4m3_t.self)
+        nk_dots_packed_e4m3(cPtr, bPacked, c, UInt64(m), UInt64(n), UInt64(k), UInt64(aStride), UInt64(cStride))
+    }
+
+    public static func _nk_dots_symmetric(
+        _ vectors: UnsafePointer<E4M3>, _ result: UnsafeMutablePointer<Float32>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        let cPtr = UnsafeRawPointer(vectors).assumingMemoryBound(to: nk_e4m3_t.self)
+        nk_dots_symmetric_e4m3(
+            cPtr, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+}
+
+extension E4M3: NumKongSpatialsMatrixElement {
+    public typealias SpatialOutput = Float32
+
+    public static func _nk_angulars_packed(
+        _ a: UnsafePointer<E4M3>, _ bPacked: UnsafeRawPointer, _ result: UnsafeMutablePointer<Float32>, _ rows: Int,
+        _ cols: Int, _ depth: Int, _ aStride: Int, _ rStride: Int
+    ) {
+        let cPtr = UnsafeRawPointer(a).assumingMemoryBound(to: nk_e4m3_t.self)
+        nk_angulars_packed_e4m3(
+            cPtr, bPacked, result, UInt64(rows), UInt64(cols), UInt64(depth), UInt64(aStride), UInt64(rStride))
+    }
+
+    public static func _nk_euclideans_packed(
+        _ a: UnsafePointer<E4M3>, _ bPacked: UnsafeRawPointer, _ result: UnsafeMutablePointer<Float32>, _ rows: Int,
+        _ cols: Int, _ depth: Int, _ aStride: Int, _ rStride: Int
+    ) {
+        let cPtr = UnsafeRawPointer(a).assumingMemoryBound(to: nk_e4m3_t.self)
+        nk_euclideans_packed_e4m3(
+            cPtr, bPacked, result, UInt64(rows), UInt64(cols), UInt64(depth), UInt64(aStride), UInt64(rStride))
+    }
+
+    public static func _nk_angulars_symmetric(
+        _ vectors: UnsafePointer<E4M3>, _ result: UnsafeMutablePointer<Float32>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        let cPtr = UnsafeRawPointer(vectors).assumingMemoryBound(to: nk_e4m3_t.self)
+        nk_angulars_symmetric_e4m3(
+            cPtr, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+
+    public static func _nk_euclideans_symmetric(
+        _ vectors: UnsafePointer<E4M3>, _ result: UnsafeMutablePointer<Float32>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        let cPtr = UnsafeRawPointer(vectors).assumingMemoryBound(to: nk_e4m3_t.self)
+        nk_euclideans_symmetric_e4m3(
+            cPtr, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+}
+
+extension E5M2: NumKongDotsMatrixElement {
+    public typealias DotsOutput = Float32
+
+    public static func _nk_dots_packed_size(_ n: Int, _ k: Int) -> Int {
+        Int(nk_dots_packed_size_e5m2(UInt64(n), UInt64(k)))
+    }
+
+    public static func _nk_dots_pack(
+        _ b: UnsafePointer<E5M2>, _ n: Int, _ k: Int, _ bStride: Int, _ packed: UnsafeMutableRawPointer
+    ) {
+        let cPtr = UnsafeRawPointer(b).assumingMemoryBound(to: nk_e5m2_t.self)
+        nk_dots_pack_e5m2(cPtr, UInt64(n), UInt64(k), UInt64(bStride), packed)
+    }
+
+    public static func _nk_dots_packed(
+        _ a: UnsafePointer<E5M2>, _ bPacked: UnsafeRawPointer, _ c: UnsafeMutablePointer<Float32>, _ m: Int, _ n: Int,
+        _ k: Int, _ aStride: Int, _ cStride: Int
+    ) {
+        let cPtr = UnsafeRawPointer(a).assumingMemoryBound(to: nk_e5m2_t.self)
+        nk_dots_packed_e5m2(cPtr, bPacked, c, UInt64(m), UInt64(n), UInt64(k), UInt64(aStride), UInt64(cStride))
+    }
+
+    public static func _nk_dots_symmetric(
+        _ vectors: UnsafePointer<E5M2>, _ result: UnsafeMutablePointer<Float32>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        let cPtr = UnsafeRawPointer(vectors).assumingMemoryBound(to: nk_e5m2_t.self)
+        nk_dots_symmetric_e5m2(
+            cPtr, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+}
+
+extension E5M2: NumKongSpatialsMatrixElement {
+    public typealias SpatialOutput = Float32
+
+    public static func _nk_angulars_packed(
+        _ a: UnsafePointer<E5M2>, _ bPacked: UnsafeRawPointer, _ result: UnsafeMutablePointer<Float32>, _ rows: Int,
+        _ cols: Int, _ depth: Int, _ aStride: Int, _ rStride: Int
+    ) {
+        let cPtr = UnsafeRawPointer(a).assumingMemoryBound(to: nk_e5m2_t.self)
+        nk_angulars_packed_e5m2(
+            cPtr, bPacked, result, UInt64(rows), UInt64(cols), UInt64(depth), UInt64(aStride), UInt64(rStride))
+    }
+
+    public static func _nk_euclideans_packed(
+        _ a: UnsafePointer<E5M2>, _ bPacked: UnsafeRawPointer, _ result: UnsafeMutablePointer<Float32>, _ rows: Int,
+        _ cols: Int, _ depth: Int, _ aStride: Int, _ rStride: Int
+    ) {
+        let cPtr = UnsafeRawPointer(a).assumingMemoryBound(to: nk_e5m2_t.self)
+        nk_euclideans_packed_e5m2(
+            cPtr, bPacked, result, UInt64(rows), UInt64(cols), UInt64(depth), UInt64(aStride), UInt64(rStride))
+    }
+
+    public static func _nk_angulars_symmetric(
+        _ vectors: UnsafePointer<E5M2>, _ result: UnsafeMutablePointer<Float32>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        let cPtr = UnsafeRawPointer(vectors).assumingMemoryBound(to: nk_e5m2_t.self)
+        nk_angulars_symmetric_e5m2(
+            cPtr, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+
+    public static func _nk_euclideans_symmetric(
+        _ vectors: UnsafePointer<E5M2>, _ result: UnsafeMutablePointer<Float32>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        let cPtr = UnsafeRawPointer(vectors).assumingMemoryBound(to: nk_e5m2_t.self)
+        nk_euclideans_symmetric_e5m2(
+            cPtr, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+}
+
+extension E2M3: NumKongDotsMatrixElement {
+    public typealias DotsOutput = Float32
+
+    public static func _nk_dots_packed_size(_ n: Int, _ k: Int) -> Int {
+        Int(nk_dots_packed_size_e2m3(UInt64(n), UInt64(k)))
+    }
+
+    public static func _nk_dots_pack(
+        _ b: UnsafePointer<E2M3>, _ n: Int, _ k: Int, _ bStride: Int, _ packed: UnsafeMutableRawPointer
+    ) {
+        let cPtr = UnsafeRawPointer(b).assumingMemoryBound(to: nk_e2m3_t.self)
+        nk_dots_pack_e2m3(cPtr, UInt64(n), UInt64(k), UInt64(bStride), packed)
+    }
+
+    public static func _nk_dots_packed(
+        _ a: UnsafePointer<E2M3>, _ bPacked: UnsafeRawPointer, _ c: UnsafeMutablePointer<Float32>, _ m: Int, _ n: Int,
+        _ k: Int, _ aStride: Int, _ cStride: Int
+    ) {
+        let cPtr = UnsafeRawPointer(a).assumingMemoryBound(to: nk_e2m3_t.self)
+        nk_dots_packed_e2m3(cPtr, bPacked, c, UInt64(m), UInt64(n), UInt64(k), UInt64(aStride), UInt64(cStride))
+    }
+
+    public static func _nk_dots_symmetric(
+        _ vectors: UnsafePointer<E2M3>, _ result: UnsafeMutablePointer<Float32>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        let cPtr = UnsafeRawPointer(vectors).assumingMemoryBound(to: nk_e2m3_t.self)
+        nk_dots_symmetric_e2m3(
+            cPtr, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+}
+
+extension E2M3: NumKongSpatialsMatrixElement {
+    public typealias SpatialOutput = Float32
+
+    public static func _nk_angulars_packed(
+        _ a: UnsafePointer<E2M3>, _ bPacked: UnsafeRawPointer, _ result: UnsafeMutablePointer<Float32>, _ rows: Int,
+        _ cols: Int, _ depth: Int, _ aStride: Int, _ rStride: Int
+    ) {
+        let cPtr = UnsafeRawPointer(a).assumingMemoryBound(to: nk_e2m3_t.self)
+        nk_angulars_packed_e2m3(
+            cPtr, bPacked, result, UInt64(rows), UInt64(cols), UInt64(depth), UInt64(aStride), UInt64(rStride))
+    }
+
+    public static func _nk_euclideans_packed(
+        _ a: UnsafePointer<E2M3>, _ bPacked: UnsafeRawPointer, _ result: UnsafeMutablePointer<Float32>, _ rows: Int,
+        _ cols: Int, _ depth: Int, _ aStride: Int, _ rStride: Int
+    ) {
+        let cPtr = UnsafeRawPointer(a).assumingMemoryBound(to: nk_e2m3_t.self)
+        nk_euclideans_packed_e2m3(
+            cPtr, bPacked, result, UInt64(rows), UInt64(cols), UInt64(depth), UInt64(aStride), UInt64(rStride))
+    }
+
+    public static func _nk_angulars_symmetric(
+        _ vectors: UnsafePointer<E2M3>, _ result: UnsafeMutablePointer<Float32>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        let cPtr = UnsafeRawPointer(vectors).assumingMemoryBound(to: nk_e2m3_t.self)
+        nk_angulars_symmetric_e2m3(
+            cPtr, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+
+    public static func _nk_euclideans_symmetric(
+        _ vectors: UnsafePointer<E2M3>, _ result: UnsafeMutablePointer<Float32>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        let cPtr = UnsafeRawPointer(vectors).assumingMemoryBound(to: nk_e2m3_t.self)
+        nk_euclideans_symmetric_e2m3(
+            cPtr, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+}
+
+extension E3M2: NumKongDotsMatrixElement {
+    public typealias DotsOutput = Float32
+
+    public static func _nk_dots_packed_size(_ n: Int, _ k: Int) -> Int {
+        Int(nk_dots_packed_size_e3m2(UInt64(n), UInt64(k)))
+    }
+
+    public static func _nk_dots_pack(
+        _ b: UnsafePointer<E3M2>, _ n: Int, _ k: Int, _ bStride: Int, _ packed: UnsafeMutableRawPointer
+    ) {
+        let cPtr = UnsafeRawPointer(b).assumingMemoryBound(to: nk_e3m2_t.self)
+        nk_dots_pack_e3m2(cPtr, UInt64(n), UInt64(k), UInt64(bStride), packed)
+    }
+
+    public static func _nk_dots_packed(
+        _ a: UnsafePointer<E3M2>, _ bPacked: UnsafeRawPointer, _ c: UnsafeMutablePointer<Float32>, _ m: Int, _ n: Int,
+        _ k: Int, _ aStride: Int, _ cStride: Int
+    ) {
+        let cPtr = UnsafeRawPointer(a).assumingMemoryBound(to: nk_e3m2_t.self)
+        nk_dots_packed_e3m2(cPtr, bPacked, c, UInt64(m), UInt64(n), UInt64(k), UInt64(aStride), UInt64(cStride))
+    }
+
+    public static func _nk_dots_symmetric(
+        _ vectors: UnsafePointer<E3M2>, _ result: UnsafeMutablePointer<Float32>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        let cPtr = UnsafeRawPointer(vectors).assumingMemoryBound(to: nk_e3m2_t.self)
+        nk_dots_symmetric_e3m2(
+            cPtr, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+}
+
+extension E3M2: NumKongSpatialsMatrixElement {
+    public typealias SpatialOutput = Float32
+
+    public static func _nk_angulars_packed(
+        _ a: UnsafePointer<E3M2>, _ bPacked: UnsafeRawPointer, _ result: UnsafeMutablePointer<Float32>, _ rows: Int,
+        _ cols: Int, _ depth: Int, _ aStride: Int, _ rStride: Int
+    ) {
+        let cPtr = UnsafeRawPointer(a).assumingMemoryBound(to: nk_e3m2_t.self)
+        nk_angulars_packed_e3m2(
+            cPtr, bPacked, result, UInt64(rows), UInt64(cols), UInt64(depth), UInt64(aStride), UInt64(rStride))
+    }
+
+    public static func _nk_euclideans_packed(
+        _ a: UnsafePointer<E3M2>, _ bPacked: UnsafeRawPointer, _ result: UnsafeMutablePointer<Float32>, _ rows: Int,
+        _ cols: Int, _ depth: Int, _ aStride: Int, _ rStride: Int
+    ) {
+        let cPtr = UnsafeRawPointer(a).assumingMemoryBound(to: nk_e3m2_t.self)
+        nk_euclideans_packed_e3m2(
+            cPtr, bPacked, result, UInt64(rows), UInt64(cols), UInt64(depth), UInt64(aStride), UInt64(rStride))
+    }
+
+    public static func _nk_angulars_symmetric(
+        _ vectors: UnsafePointer<E3M2>, _ result: UnsafeMutablePointer<Float32>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        let cPtr = UnsafeRawPointer(vectors).assumingMemoryBound(to: nk_e3m2_t.self)
+        nk_angulars_symmetric_e3m2(
+            cPtr, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+
+    public static func _nk_euclideans_symmetric(
+        _ vectors: UnsafePointer<E3M2>, _ result: UnsafeMutablePointer<Float32>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        let cPtr = UnsafeRawPointer(vectors).assumingMemoryBound(to: nk_e3m2_t.self)
+        nk_euclideans_symmetric_e3m2(
+            cPtr, UInt64(nVectors), UInt64(depth), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+}
+
+// MARK: - Kernel Bindings: U1x8 Dots
+
+extension U1x8: NumKongDotsMatrixElement {
+    public typealias DotsOutput = UInt32
+
+    public static func _nk_dots_packed_size(_ n: Int, _ k: Int) -> Int {
+        Int(nk_dots_packed_size_u1(UInt64(n), UInt64(k * 8)))
+    }
+
+    public static func _nk_dots_pack(
+        _ b: UnsafePointer<U1x8>, _ n: Int, _ k: Int, _ bStride: Int, _ packed: UnsafeMutableRawPointer
+    ) {
+        let cPtr = UnsafeRawPointer(b).assumingMemoryBound(to: nk_u1x8_t.self)
+        nk_dots_pack_u1(cPtr, UInt64(n), UInt64(k * 8), UInt64(bStride), packed)
+    }
+
+    public static func _nk_dots_packed(
+        _ a: UnsafePointer<U1x8>, _ bPacked: UnsafeRawPointer, _ c: UnsafeMutablePointer<UInt32>, _ m: Int, _ n: Int,
+        _ k: Int, _ aStride: Int, _ cStride: Int
+    ) {
+        let cPtr = UnsafeRawPointer(a).assumingMemoryBound(to: nk_u1x8_t.self)
+        nk_dots_packed_u1(cPtr, bPacked, c, UInt64(m), UInt64(n), UInt64(k * 8), UInt64(aStride), UInt64(cStride))
+    }
+
+    public static func _nk_dots_symmetric(
+        _ vectors: UnsafePointer<U1x8>, _ result: UnsafeMutablePointer<UInt32>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        let cPtr = UnsafeRawPointer(vectors).assumingMemoryBound(to: nk_u1x8_t.self)
+        nk_dots_symmetric_u1(
+            cPtr, UInt64(nVectors), UInt64(depth * 8), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+}
+
+// MARK: - Kernel Bindings: U1x8 Sets
+
+extension U1x8: NumKongSetsMatrixElement {
+    public typealias HammingOutput = UInt32
+    public typealias JaccardOutput = Float32
+
+    public static func _nk_hammings_packed(
+        _ a: UnsafePointer<U1x8>, _ bPacked: UnsafeRawPointer, _ result: UnsafeMutablePointer<UInt32>, _ rows: Int,
+        _ cols: Int, _ depth: Int, _ aStride: Int, _ rStride: Int
+    ) {
+        let cPtr = UnsafeRawPointer(a).assumingMemoryBound(to: nk_u1x8_t.self)
+        nk_hammings_packed_u1(
+            cPtr, bPacked, result, UInt64(rows), UInt64(cols), UInt64(depth * 8), UInt64(aStride), UInt64(rStride))
+    }
+
+    public static func _nk_hammings_symmetric(
+        _ vectors: UnsafePointer<U1x8>, _ result: UnsafeMutablePointer<UInt32>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        let cPtr = UnsafeRawPointer(vectors).assumingMemoryBound(to: nk_u1x8_t.self)
+        nk_hammings_symmetric_u1(
+            cPtr, UInt64(nVectors), UInt64(depth * 8), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+
+    public static func _nk_jaccards_packed(
+        _ a: UnsafePointer<U1x8>, _ bPacked: UnsafeRawPointer, _ result: UnsafeMutablePointer<Float32>, _ rows: Int,
+        _ cols: Int, _ depth: Int, _ aStride: Int, _ rStride: Int
+    ) {
+        let cPtr = UnsafeRawPointer(a).assumingMemoryBound(to: nk_u1x8_t.self)
+        nk_jaccards_packed_u1(
+            cPtr, bPacked, result, UInt64(rows), UInt64(cols), UInt64(depth * 8), UInt64(aStride), UInt64(rStride))
+    }
+
+    public static func _nk_jaccards_symmetric(
+        _ vectors: UnsafePointer<U1x8>, _ result: UnsafeMutablePointer<Float32>, _ nVectors: Int, _ depth: Int,
+        _ stride: Int, _ resultStride: Int, _ rowStart: Int, _ rowCount: Int
+    ) {
+        let cPtr = UnsafeRawPointer(vectors).assumingMemoryBound(to: nk_u1x8_t.self)
+        nk_jaccards_symmetric_u1(
+            cPtr, UInt64(nVectors), UInt64(depth * 8), UInt64(stride), result, UInt64(resultStride), UInt64(rowStart),
+            UInt64(rowCount))
+    }
+}