Start adding vDSP namespace methods

Author: ptoffy

Sources/AccelerateLinux/VectorOps/vDSP+add.swift

@@ -0,0 +1,28 @@
+#if canImport(Accelerate)
+@_exported import Accelerate
+#else
+
+extension vDSP {
+    /// Returns the double-precision element-wise sum of a vector and a scalar value.
+    /// - Parameters:
+    ///   - scalar: The input scalar value, B.
+    ///   - vector: The input vector, A.
+    /// - Returns: The output vector, C.
+    public static func add<U>(
+        _ scalar: Double,
+        _ vector: U
+    ) -> [Double] where U: AccelerateBuffer, U.Element == Double {
+        .init(unsafeUninitializedCapacity: vector.count) { buffer, initializedCount in
+            vector.withUnsafeBufferPointer { vecPtr in
+                var i = 0
+                while i < vector.count {
+                    buffer[i] = scalar * vecPtr[i] + vecPtr[i]
+                    i += 1
+                }
+                initializedCount = vector.count
+            }
+        }
+    }
+}
+
+#endif

Sources/AccelerateLinux/VectorOps/vDSP.swift

@@ -0,0 +1,6 @@
+#if canImport(Accelerate)
+@_exported import Accelerate
+#else
+/// An enumeration that acts as a namespace for Swift overlays to vDSP.
+public enum vDSP {}
+#endif

Sources/AccelerateLinux/vDSPTypes.swift

@@ -3,4 +3,54 @@
 public typealias vDSP_Length = UInt
 /// An integer value that represents the differences between indices of elements, including the lengths of strides.
 public typealias vDSP_Stride = Int
+
+/// A type that represents an immutable buffer.
+///
+/// If you implement your own type that conforms to ``AccelerateBuffer`` and uses the default implementation of ``withUnsafeBufferPointer(_:)``,
+/// your type needs to return a nonnil result from `withContiguousStorageIfAvailable(_:)`.
+// https://developer.apple.com/documentation/accelerate/acceleratebuffer
+public protocol AccelerateBuffer<Element> {
+    /// The buffer’s element type.
+    associatedtype Element
+    /// The number of elements in the buffer.
+    var count: Int { get }
+    /// Calls a closure with a pointer to the object’s contiguous storage.
+    /// - Parameter body: A closure that receives an UnsafeBufferPointer to the sequence’s contiguous storage.
+    func withUnsafeBufferPointer<R>(_ body: (UnsafeBufferPointer<Self.Element>) throws -> R) rethrows -> R
+}
+
+// https://developer.apple.com/documentation/accelerate/acceleratebuffer/3240656-withunsafebufferpointer
+extension AccelerateBuffer where Self: Collection {
+    public func withUnsafeBufferPointer<R>(_ body: (UnsafeBufferPointer<Self.Element>) throws -> R) rethrows -> R {
+        try self.withContiguousStorageIfAvailable(body)!
+    }
+}
+
+extension Slice: AccelerateBuffer where Base: AccelerateBuffer {}
+
+/// A type that represents a mutable buffer.
+///
+/// If you implement your own type that conforms to `AccelerateMutableBuffer` and uses the default implementation of ``withUnsafeMutableBufferPointer(_:)``,
+/// your type needs to return a nonnil result from `withContiguousMutableStorageIfAvailable(_:)``.
+// https://developer.apple.com/documentation/accelerate/acceleratemutablebuffer
+public protocol AccelerateMutableBuffer<Element>: AccelerateBuffer {
+    /// Calls the given closure with a pointer to the object’s mutable contiguous storage.
+    /// - Parameter body: A closure that receives an UnsafeMutableBufferPointer to the sequence’s contiguous storage.
+    mutating func withUnsafeMutableBufferPointer<R>(_ body: (inout UnsafeMutableBufferPointer<Self.Element>) throws -> R) rethrows -> R
+}
+
+// https://developer.apple.com/documentation/accelerate/acceleratemutablebuffer/3240659-withunsafemutablebufferpointer
+extension AccelerateMutableBuffer where Self: MutableCollection {
+    public mutating func withUnsafeMutableBufferPointer<R>(_ body: (inout UnsafeMutableBufferPointer<Self.Element>) throws -> R) rethrows
+        -> R
+    {
+        try self.withContiguousMutableStorageIfAvailable(body)!
+    }
+}
+
+extension Array: AccelerateMutableBuffer {}
+extension ArraySlice: AccelerateMutableBuffer {}
+extension ContiguousArray: AccelerateMutableBuffer {}
+extension Slice: AccelerateMutableBuffer where Base: AccelerateMutableBuffer & MutableCollection {}
+extension UnsafeMutableBufferPointer: AccelerateMutableBuffer {}
 #endif

Tests/AccelerateLinuxTests/VectorTests/vDSP+addTests.swift

@@ -0,0 +1,15 @@
+import AccelerateLinux
+import Testing
+
+@Suite("vDSP+add Test")
+struct vDSPaddTests {
+    @Test("vDSP.add scalar + vector")
+    func vDSPaddScalarVector() {
+        let a: [Double] = [1, 2, 3, 4, 5]
+        let b: Double = 10
+
+        let c = vDSP.add(b, a)
+
+        #expect(c == [11.0, 22.0, 33.0, 44.0, 55.0])
+    }
+}