Add vDSP_vmulD and vvpow

Author: ptoffy

README.md

@@ -52,8 +52,8 @@ The package is structured as follows:
         - [x] `vDSP_minvD` - Find the minimum value in a vector
         - [x] `vDSP_vaddD` - Add two vectors
         - [x] `vDSP_vsubD` - Subtract two vectors
-        - [ ] `vDSP_vmulD` - Multiply two vectors
-        - [ ] `vvpow` - Raise a vector to a power
+        - [x] `vDSP_vmulD` - Multiply two vectors
+        - [x] `vvpow` - Raise a vector to a power
         - [ ] `vDSP_vclrD` - Clear a vector
         - [ ] `vDSP_vfillD` - Fill a vector with a value
         - [ ] `vDSP_vabsD` - Absolute value of a vector

Sources/AccelerateLinux/VectorOps/VectorBasicOps.swift

@@ -1,6 +1,7 @@
 #if canImport(Accelerate)
 @_exported import Accelerate
 #else
+import FoundationEssentials
 
 /// Calculates the double-precision maximum value of a vector.
 /// - Parameters:
@@ -93,4 +94,61 @@ public func vDSP_vsubD(
         i += 1
     }
 }
+
+/// Calculates the double-precision element-wise product 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_vmulD(
+    _ __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
+    }
+}
+
+/// Raises each element in an array to the power of the corresponding element in a second array of double-precision values.
+/// - Parameters:
+///   - _: The output array, z.
+///   - _: The exponent input array, y.
+///   - _: The base input array, x.
+///   - _: The number of elements in the arrays.
+public func vvpow(
+    _ z: UnsafeMutablePointer<Double>,
+    _ y: UnsafePointer<Double>,
+    _ x: UnsafePointer<Double>,
+    _ n: UnsafePointer<Int32>
+) {
+    // Exponentiation by squaring
+    func expBySquaring(_ b: Double, elevatedTo n: Double) -> Double {
+        func aux(_ y: Double, _ b: Double, _ n: Double) -> Double {
+            switch n {
+            case let x where x < 0: aux(y, 1 / b, -n)
+            case 0: y
+            case let x where x.truncatingRemainder(dividingBy: 2) == 0: aux(y, b * b, n / 2)
+            default: aux(b * y, b * b, (n - 1) / 2)
+            }
+        }
+        return aux(1, b, n)
+    }
+
+    var i = 0
+    while i < n.pointee {
+        z[i] = expBySquaring(x[i], elevatedTo: y[i])
+        i += 1
+    }
+}
 #endif

Tests/AccelerateLinuxTests/VectorTests/VectorBasicOpsTests.swift

@@ -86,12 +86,9 @@ struct VectorBasicOpsTests {
             buffer, initializedCount in
 
             vDSP_vsubD(
-                b,
-                stride,
-                a,
-                stride,
-                buffer.baseAddress!,
-                stride,
+                b, stride,
+                a, stride,
+                buffer.baseAddress!, stride,
                 vDSP_Length(count)
             )
 
@@ -100,4 +97,37 @@ struct VectorBasicOpsTests {
 
         #expect(c == [9.0, 18.0, 27.0, 36.0, 45.0])
     }
+
+    // https://developer.apple.com/documentation/accelerate/1450138-vdsp_vmuld
+    @Test("vmulD")
+    func vDSP_vmulDTest() {
+        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_vmulD(
+                a, stride,
+                b, stride,
+                buffer.baseAddress!, stride,
+                vDSP_Length(count)
+            )
+            initializedCount = count
+        }
+
+        #expect(c == [10.0, 40.0, 90.0, 160.0, 250.0])
+    }
+
+    @Test("vvpow")
+    func vvpowTest() {
+        var x: [Double] = [3, 2, 10, 6]
+        var y: [Double] = [2, 4, 3, 2]
+        var z = [Double](repeating: 0, count: x.count)
+        var n = Int32(x.count)
+
+        vvpow(&z, &y, &x, &n)
+        #expect(z == [9.0, 16.0, 1000.0, 36.0])
+    }
 }