Add exponential functions for Vector and Matrix structs

Author: wigging

Sources/MatrixModule/Exponential.swift

@@ -0,0 +1,72 @@
+/*
+Matrix extension for exponential functions.
+*/
+
+import Accelerate
+
+public protocol Exponential {
+    static func exp(a: Matrix<Self>) -> Matrix<Self>
+    static func exp2(a: Matrix<Self>) -> Matrix<Self>
+    static func expm1(a: Matrix<Self>) -> Matrix<Self>
+}
+
+extension Float: Exponential {
+    public static func exp(a: Matrix<Float>) -> Matrix<Float> {
+        var mat = Matrix(like: a)
+        vForce.exp(a.buffer, result: &mat.buffer)
+        return mat
+    }
+
+    public static func exp2(a: Matrix<Float>) -> Matrix<Float> {
+        var mat = Matrix(like: a)
+        vForce.exp2(a.buffer, result: &mat.buffer)
+        return mat
+    }
+
+    public static func expm1(a: Matrix<Float>) -> Matrix<Float> {
+        var mat = Matrix(like: a)
+        vForce.expm1(a.buffer, result: &mat.buffer)
+        return mat
+    }
+}
+
+extension Double: Exponential {
+    public static func exp(a: Matrix<Double>) -> Matrix<Double> {
+        var mat = Matrix(like: a)
+        vForce.exp(a.buffer, result: &mat.buffer)
+        return mat
+    }
+
+    public static func exp2(a: Matrix<Double>) -> Matrix<Double> {
+        var mat = Matrix(like: a)
+        vForce.exp2(a.buffer, result: &mat.buffer)
+        return mat
+    }
+
+    public static func expm1(a: Matrix<Double>) -> Matrix<Double> {
+        var mat = Matrix(like: a)
+        vForce.expm1(a.buffer, result: &mat.buffer)
+        return mat
+    }
+}
+
+extension Matrix where Scalar: Exponential {
+
+    /// Calculate the exponential for each matrix element.
+    /// - Returns: Element-wise exponential matrix.
+    public func exp() -> Matrix {
+        Scalar.exp(a: self)
+    }
+
+    /// Calculate 2 raised to the power of each matrix element.
+    /// - Returns: Element-wise 2 raised to the power matrix.
+    public func exp2() -> Matrix {
+        Scalar.exp2(a: self)
+    }
+
+    /// Calculate the exponential minus one of each matrix element.
+    /// - Returns: Element-wise exponential minus one matrix.
+    public func expm1() -> Matrix {
+        Scalar.expm1(a: self)
+    }
+}

Sources/VectorModule/Exponential.swift

@@ -0,0 +1,72 @@
+/*
+Vector extension for exponential functions.
+*/
+
+import Accelerate
+
+public protocol Exponential {
+    static func exp(a: Vector<Self>) -> Vector<Self>
+    static func exp2(a: Vector<Self>) -> Vector<Self>
+    static func expm1(a: Vector<Self>) -> Vector<Self>
+}
+
+extension Float: Exponential {
+    public static func exp(a: Vector<Float>) -> Vector<Float> {
+        var mat = Vector(like: a)
+        vForce.exp(a.buffer, result: &mat.buffer)
+        return mat
+    }
+
+    public static func exp2(a: Vector<Float>) -> Vector<Float> {
+        var mat = Vector(like: a)
+        vForce.exp2(a.buffer, result: &mat.buffer)
+        return mat
+    }
+
+    public static func expm1(a: Vector<Float>) -> Vector<Float> {
+        var mat = Vector(like: a)
+        vForce.expm1(a.buffer, result: &mat.buffer)
+        return mat
+    }
+}
+
+extension Double: Exponential {
+    public static func exp(a: Vector<Double>) -> Vector<Double> {
+        var mat = Vector(like: a)
+        vForce.exp(a.buffer, result: &mat.buffer)
+        return mat
+    }
+
+    public static func exp2(a: Vector<Double>) -> Vector<Double> {
+        var mat = Vector(like: a)
+        vForce.exp2(a.buffer, result: &mat.buffer)
+        return mat
+    }
+
+    public static func expm1(a: Vector<Double>) -> Vector<Double> {
+        var mat = Vector(like: a)
+        vForce.expm1(a.buffer, result: &mat.buffer)
+        return mat
+    }
+}
+
+extension Vector where Scalar: Exponential {
+
+    /// Calculate the exponential for each vector element.
+    /// - Returns: Element-wise exponential vector.
+    public func exp() -> Vector {
+        Scalar.exp(a: self)
+    }
+
+    /// Calculate 2 raised to the power of each vector element.
+    /// - Returns: Element-wise 2 raised to the power vector.
+    public func exp2() -> Vector {
+        Scalar.exp2(a: self)
+    }
+
+    /// Calculate the exponential minus one of each vector element.
+    /// - Returns: Element-wise exponential minus one vector.
+    public func expm1() -> Vector {
+        Scalar.expm1(a: self)
+    }
+}

Tests/MatrixTests.swift

@@ -146,6 +146,20 @@ struct MatrixTests {
         #expect(invB == [[-2, 1], [1.5, -0.5]])
     }
 
+    @Test func exponential() {
+        let a = Matrix<Float>([[1, 2], [3, 4]])
+        let b = Matrix<Double>([[1, 2], [3, 4]])
+
+        #expect(a.exp() == [[2.71828183, 7.3890561], [20.08553692, 54.59815003]])
+        #expect(b.exp().isApproximatelyEqual(to: [[2.71828, 7.38905], [20.08553, 54.59815]], relativeTolerance: 1e-4))
+
+        #expect(a.exp2() == [[2, 4], [8, 16]])
+        #expect(b.exp2() == [[2, 4], [8, 16]])
+
+        #expect(a.expm1().isApproximatelyEqual(to: [[1.71828, 6.38905], [19.08553, 53.59815]], relativeTolerance: 1e-4))
+        #expect(b.expm1().isApproximatelyEqual(to: [[1.71828, 6.38905], [19.08553, 53.59815]], relativeTolerance: 1e-4))
+    }
+
     @Test func integerArithmetic() {
         let k = 5
         let a = Matrix([[1, 2, 3], [4, 5, 6]])

Tests/VectorTests.swift

@@ -51,6 +51,20 @@ struct VectorTests {
         #expect(c.isApproximatelyEqual(to: d, absoluteTolerance: 0.001))
     }
 
+    @Test func exponential() {
+        let a = Vector<Float>([1, 2, 3, 4])
+        let b = Vector<Double>([1, 2, 3, 4])
+
+        #expect(a.exp() == [2.71828183, 7.3890561, 20.08553692, 54.59815003])
+        #expect(b.exp().isApproximatelyEqual(to: [2.71828, 7.38905, 20.08553, 54.59815], relativeTolerance: 1e-4))
+
+        #expect(a.exp2() == [2, 4, 8, 16])
+        #expect(b.exp2() == [2, 4, 8, 16])
+
+        #expect(a.expm1().isApproximatelyEqual(to: [1.71828, 6.38905, 19.08553, 53.59815], relativeTolerance: 1e-4))
+        #expect(b.expm1().isApproximatelyEqual(to: [1.71828, 6.38905, 19.08553, 53.59815], relativeTolerance: 1e-4))
+    }
+
     @Test func integerArithmetic() {
         let k = 5
         let a = Vector([1, 2, 3, 4, 5])