Add vDSP_vaddD, vDSP_vsubD

Author: ptoffy

README.md

@@ -50,8 +50,8 @@ The package is structured as follows:
     - `BasicOps` - Basic vector operations:
         - [x] `vDSP_maxvD` - Find the maximum value in a vector
         - [x] `vDSP_minvD` - Find the minimum value in a vector
-        - [ ] `vDSP_vaddD` - Add two vectors
-        - [ ] `vDSP_vsubD` - Subtract two vectors
+        - [x] `vDSP_vaddD` - Add two vectors
+        - [x] `vDSP_vsubD` - Subtract two vectors
         - [ ] `vDSP_vmulD` - Multiply two vectors
         - [ ] `vvpow` - Raise a vector to a power
         - [ ] `vDSP_vclrD` - Clear a vector

Sources/AccelerateLinux/VectorOps/VectorBasicOps.swift

@@ -16,8 +16,10 @@ public func vDSP_maxvD(
 ) {
     __C.pointee = -Double.infinity
     guard __N > 0 else { return }
-    for i in 1..<__N {
+    var i = 1
+    while i < __N {
         __C.pointee = max(__C.pointee, __A[Int(i) * __I])
+        i += 1
     }
 }
 
@@ -35,8 +37,60 @@ public func vDSP_minvD(
 ) {
     __C.pointee = Double.infinity
     guard __N > 0 else { return }
-    for i in 1..<__N {
+    var i = 1
+    while i < __N {
         __C.pointee = min(__C.pointee, __A[Int(i) * __I])
+        i += 1
+    }
+}
+
+/// Calculates the double-precision element-wise sum of two vectors, using the specified stride.
+/// - Parameters:
+///   - __A: The first input vector, A.
+///   - __IA: The distance between the elements in the first input vector.
+///   - __B: The second input vector, B.
+///   - __IB: The distance between the elements in the second input vector.
+///   - __C: The output vector, C.
+///   - __IC: The distance between the elements in the output vector.
+///   - __N: The number of elements that the function processes.
+public func vDSP_vaddD(
+    _ __A: UnsafePointer<Double>,
+    _ __IA: vDSP_Stride,
+    _ __B: UnsafePointer<Double>,
+    _ __IB: vDSP_Stride,
+    _ __C: UnsafeMutablePointer<Double>,
+    _ __IC: vDSP_Stride,
+    _ __N: vDSP_Length
+) {
+    var i = 0
+    while i < __N {
+        __C[Int(i) * __IC] = __A[Int(i) * __IA] + __B[Int(i) * __IB]
+        i += 1
+    }
+}
+
+/// Calculates the double-precision element-wise subtraction of two vectors, using the specified stride.
+/// - Parameters:
+///   - __B: The first input vector, B.
+///   - __IB: The distance between the elements in the first input vector.
+///   - __A: The second input vector, A.
+///   - __IA: The distance between the elements in the second input vector.
+///   - __C: The output vector, C.
+///   - __IC: The distance between the elements in the output vector.
+///   - __N: The number of elements that the function processes.
+public func vDSP_vsubD(
+    _ __B: UnsafePointer<Double>,
+    _ __IB: vDSP_Stride,
+    _ __A: UnsafePointer<Double>,
+    _ __IA: vDSP_Stride,
+    _ __C: UnsafeMutablePointer<Double>,
+    _ __IC: vDSP_Stride,
+    _ __N: vDSP_Length
+) {
+    var i = 0
+    while i < __N {
+        __C[Int(i) * __IC] = __A[Int(i) * __IA] - __B[Int(i) * __IB]
+        i += 1
     }
 }
 #endif

Tests/AccelerateLinuxTests/VectorTests/VectorBasicOpsTests.swift

@@ -47,4 +47,57 @@ struct VectorBasicOpsTests {
         vDSP_minvD(a, stride, &c, n)
         #expect(c == Double.infinity)
     }
+
+    // https://developer.apple.com/documentation/accelerate/1449910-vdsp_vaddd
+    @Test("vaddD")
+    func vDSP_vaddDTest() {
+        let stride = 1
+        let count = 5
+
+        let a: [Double] = [1, 2, 3, 4, 5]
+        let b: [Double] = [10, 20, 30, 40, 50]
+
+        let c = [Double](unsafeUninitializedCapacity: count) { buffer, initializedCount in
+            vDSP_vaddD(
+                a,
+                stride,
+                b,
+                stride,
+                buffer.baseAddress!,
+                stride,
+                vDSP_Length(count)
+            )
+            initializedCount = count
+        }
+
+        #expect(c == [11.0, 22.0, 33.0, 44.0, 55.0])
+    }
+
+    // https://developer.apple.com/documentation/accelerate/1449743-vdsp_vsubd
+    @Test("vsubD")
+    func vDSP_vsubDTest() {
+        let stride = 1
+        let count = 5
+
+        let a: [Double] = [10, 20, 30, 40, 50]
+        let b: [Double] = [1, 2, 3, 4, 5]
+
+        let c = [Double](unsafeUninitializedCapacity: count) {
+            buffer, initializedCount in
+
+            vDSP_vsubD(
+                b,
+                stride,
+                a,
+                stride,
+                buffer.baseAddress!,
+                stride,
+                vDSP_Length(count)
+            )
+
+            initializedCount = count
+        }
+
+        #expect(c == [9.0, 18.0, 27.0, 36.0, 45.0])
+    }
 }