Add vDSP_vsdivD

Author: ptoffy

README.md

@@ -56,6 +56,7 @@ The package is structured as follows:
         - [x] `vDSP_vminD` - Element-wise minimum of two vectors
         - [x] `vDSP_vmaxD` - Element-wise maximum of two vectors
         - [x] `vDSP_vdivD` - Divide two vectors
+        - [x] `vDSP_vsdivD` - Divide a vector by a scalar
         - [x] `vvpow` - Raise a vector to a power
         - [x] `vDSP_vclrD` - Clear a vector
         - [x] `vDSP_vfillD` - Fill a vector with a value

Sources/AccelerateLinux/VectorOps/VectorBasicOps.swift

@@ -482,6 +482,29 @@ public func vDSP_vdivD(
     }
 }
 
+/// Calculates the double-precision element-wise division of a vector and a scalar value, using the specified stride.
+/// - Parameters:
+///   - __A: The input vector, A.
+///   - __IA: The distance between the elements in the input vector.
+///   - __B: The scalar value, B.
+///   - __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_vsdivD(
+    _ __A: UnsafePointer<Double>,
+    _ __IA: vDSP_Stride,
+    _ __B: UnsafePointer<Double>,
+    _ __C: UnsafeMutablePointer<Double>,
+    _ __IC: vDSP_Stride,
+    _ __N: vDSP_Length
+) {
+    var i = 0
+    while i < __N {
+        __C[i * __IC] = __A[i * __IA] / __B.pointee
+        i += 1
+    }
+}
+
 /// Calculates the sine of each element in an array of double-precision values.
 /// - Parameters:
 ///   - y: The output array, y.

Tests/AccelerateLinuxTests/VectorTests/VectorBasicOpsTests.swift

@@ -396,6 +396,29 @@ struct VectorBasicOpsTests {
         #expect(c == [10.0, 10.0, 10.0, 10.0, 10.0])
     }
 
+    @Test("vDSP_vsdivD")
+    func vDSP_vsdivDTest() {
+        let stride = 1
+        let count = 5
+
+        let a: [Double] = [1, 2, 3, 4, 5]
+        let b: Double = 10
+
+        let c = [Double](unsafeUninitializedCapacity: count) {
+            buffer, initializedCount in
+
+            vDSP_vsdivD(
+                a, stride,
+                [b],
+                buffer.baseAddress!, stride,
+                vDSP_Length(count))
+
+            initializedCount = count
+        }
+
+        #expect(c == [0.1, 0.2, 0.3, 0.4, 0.5])
+    }
+
     @Test("vvsin")
     func vvsinTest() {
         let pi = Double.pi