dnrops
/
Surge
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added convenience helper functions for wrapping `…InPlace` functions with value-semantics

This commit is contained in:
Vincent Esche 2019-09-25 01:48:51 +02:00
parent 1f2093a189
commit 75369fea1a
3 changed files with 87 additions and 204 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

147
Sources/Surge/Arithmetic/Arithmetic.swift
View File

@ -20,18 +20,21 @@
import Accelerate
@inline(__always)
func withArray<T, S>(from sequence: S, _ closure: (inout [T]) -> ()) -> [T] where S: Sequence, S.Element == T {
var array = Array(sequence)
closure(&array)
return array
}
// MARK: - Addition
public func add<L: UnsafeMemoryAccessible>(_ lhs: L, _ rhs: Float) -> [Float] where L.Element == Float {
var results = Array(lhs)
addInPlace(&results, rhs)
return results
return withArray(from: lhs) { addInPlace(&$0, rhs) }
}
public func add<L: UnsafeMemoryAccessible>(_ lhs: L, _ rhs: Double) -> [Double] where L.Element == Double {
var results = Array(lhs)
addInPlace(&results, rhs)
return results
return withArray(from: lhs) { addInPlace(&$0, rhs) }
}
public func + <L: UnsafeMemoryAccessible>(lhs: L, rhs: Float) -> [Float] where L.Element == Float {
@ -107,15 +110,11 @@ public func .+= <L: UnsafeMutableMemoryAccessible, R: UnsafeMemoryAccessible>(lh
// MARK: - Subtraction
public func sub<L: UnsafeMemoryAccessible>(_ lhs: L, _ rhs: Float) -> [Float] where L.Element == Float {
var results = Array(lhs)
subInPlace(&results, rhs)
return results
return withArray(from: lhs) { subInPlace(&$0, rhs) }
}
public func sub<L: UnsafeMemoryAccessible>(_ lhs: L, _ rhs: Double) -> [Double] where L.Element == Double {
var results = Array(lhs)
subInPlace(&results, rhs)
return results
return withArray(from: lhs) { subInPlace(&$0, rhs) }
}
public func - <L: UnsafeMemoryAccessible>(lhs: L, rhs: Float) -> [Float] where L.Element == Float {
@ -183,15 +182,11 @@ public func .-= <L: UnsafeMutableMemoryAccessible, R: UnsafeMemoryAccessible>(lh
// MARK: - Element-wise Multiply Addition
func elmuladd<L: UnsafeMemoryAccessible, R: UnsafeMemoryAccessible>(_ lhs: L, _ rhs: R, _ alpha: Float) -> [Float] where L.Element == Float, R.Element == Float {
var results = Array(lhs)
elmuladdInPlace(&results, rhs, alpha)
return results
return withArray(from: lhs) { elmuladdInPlace(&$0, rhs, alpha) }
}
func elmuladd<L: UnsafeMemoryAccessible, R: UnsafeMemoryAccessible>(_ lhs: L, _ rhs: R, _ alpha: Double) -> [Double] where L.Element == Double, R.Element == Double {
var results = Array(lhs)
elmuladdInPlace(&results, rhs, alpha)
return results
return withArray(from: lhs) { elmuladdInPlace(&$0, rhs, alpha) }
}
// MARK: - Element-wise Multiply Addition: In Place
@ -217,15 +212,11 @@ func elmuladdInPlace<L: UnsafeMutableMemoryAccessible, R: UnsafeMemoryAccessible
// MARK: - Multiplication
public func mul<L: UnsafeMemoryAccessible>(_ lhs: L, _ rhs: Float) -> [Float] where L.Element == Float {
var results = Array(lhs)
mulInPlace(&results, rhs)
return results
return withArray(from: lhs) { mulInPlace(&$0, rhs) }
}
public func mul<L: UnsafeMemoryAccessible>(_ lhs: L, _ rhs: Double) -> [Double] where L.Element == Double {
var results = Array(lhs)
mulInPlace(&results, rhs)
return results
return withArray(from: lhs) { mulInPlace(&$0, rhs) }
}
public func * <L: UnsafeMemoryAccessible>(lhs: L, rhs: Float) -> [Float] where L.Element == Float {
@ -263,15 +254,11 @@ public func *=<L: UnsafeMutableMemoryAccessible>(lhs: inout L, rhs: Double) wher
// MARK: - Element-wise Multiplication
public func elmul<L: UnsafeMemoryAccessible, R: UnsafeMemoryAccessible>(_ lhs: L, _ rhs: R) -> [Float] where L.Element == Float, R.Element == Float {
var results = Array(lhs)
elmulInPlace(&results, rhs)
return results
return withArray(from: lhs) { elmulInPlace(&$0, rhs) }
}
public func elmul<L: UnsafeMemoryAccessible, R: UnsafeMemoryAccessible>(_ lhs: L, _ rhs: R) -> [Double] where L.Element == Double, R.Element == Double {
var results = Array(lhs)
elmulInPlace(&results, rhs)
return results
return withArray(from: lhs) { elmulInPlace(&$0, rhs) }
}
public func .* <L: UnsafeMemoryAccessible, R: UnsafeMemoryAccessible>(lhs: L, rhs: R) -> [Float] where L.Element == Float, R.Element == Float {
@ -313,15 +300,11 @@ public func .*= <L: UnsafeMutableMemoryAccessible, R: UnsafeMemoryAccessible>(lh
// MARK: - Division
public func div<L: UnsafeMemoryAccessible>(_ lhs: L, _ rhs: Float) -> [Float] where L.Element == Float {
var results = Array(lhs)
divInPlace(&results, rhs)
return results
return withArray(from: lhs) { divInPlace(&$0, rhs) }
}
public func div<L: UnsafeMemoryAccessible>(_ lhs: L, _ rhs: Double) -> [Double] where L.Element == Double {
var results = Array(lhs)
divInPlace(&results, rhs)
return results
return withArray(from: lhs) { divInPlace(&$0, rhs) }
}
public func / <L: UnsafeMemoryAccessible>(lhs: L, rhs: Float) -> [Float] where L.Element == Float {
@ -359,15 +342,11 @@ public func /=<L: UnsafeMutableMemoryAccessible>(lhs: inout L, rhs: Double) wher
// MARK: - Element-wise Division
public func div<L: UnsafeMemoryAccessible, R: UnsafeMemoryAccessible>(_ lhs: L, _ rhs: R) -> [Float] where L.Element == Float, R.Element == Float {
var results = Array(lhs)
eldivInPlace(&results, rhs)
return results
return withArray(from: lhs) { eldivInPlace(&$0, rhs) }
}
public func div<L: UnsafeMemoryAccessible, R: UnsafeMemoryAccessible>(_ lhs: L, _ rhs: R) -> [Double] where L.Element == Double, R.Element == Double {
var results = Array(lhs)
eldivInPlace(&results, rhs)
return results
return withArray(from: lhs) { eldivInPlace(&$0, rhs) }
}
public func ./ <L: UnsafeMemoryAccessible, R: UnsafeMemoryAccessible>(lhs: L, rhs: R) -> [Float] where L.Element == Float, R.Element == Float {
@ -410,16 +389,12 @@ public func ./= <L: UnsafeMutableMemoryAccessible, R: UnsafeMemoryAccessible>(lh
/// - Warning: Allocates a temporary array from `rhs` via `Array(repeating: rhs, count: lhs.count)`.
public func mod<L: UnsafeMemoryAccessible>(_ lhs: L, _ rhs: Float) -> [Float] where L.Element == Float {
var results = Array(lhs)
modInPlace(&results, rhs)
return results
return withArray(from: lhs) { modInPlace(&$0, rhs) }
}
/// - Warning: Allocates a temporary array from `rhs` via `Array(repeating: rhs, count: lhs.count)`.
public func mod<L: UnsafeMemoryAccessible>(_ lhs: L, _ rhs: Double) -> [Double] where L.Element == Double {
var results = Array(lhs)
modInPlace(&results, rhs)
return results
return withArray(from: lhs) { modInPlace(&$0, rhs) }
}
/// - Warning: Allocates a temporary array from `rhs` via `Array(repeating: rhs, count: lhs.count)`.
@ -464,16 +439,12 @@ public func .%= <L: UnsafeMutableMemoryAccessible>(lhs: inout L, rhs: Double) wh
/// - Warning: does not support memory stride (assumes stride is 1).
public func mod<L: UnsafeMemoryAccessible, R: UnsafeMemoryAccessible>(_ lhs: L, _ rhs: R) -> [Float] where L.Element == Float, R.Element == Float {
var results = Array(lhs)
modInPlace(&results, rhs)
return results
return withArray(from: lhs) { modInPlace(&$0, rhs) }
}
/// - Warning: does not support memory stride (assumes stride is 1).
public func mod<L: UnsafeMemoryAccessible, R: UnsafeMemoryAccessible>(_ lhs: L, _ rhs: R) -> [Double] where L.Element == Double, R.Element == Double {
var results = Array(lhs)
modInPlace(&results, rhs)
return results
return withArray(from: lhs) { modInPlace(&$0, rhs) }
}
public func .% <L: UnsafeMemoryAccessible, R: UnsafeMemoryAccessible>(lhs: L, rhs: R) -> [Float] where L.Element == Float, R.Element == Float {
@ -520,16 +491,12 @@ public func .%= <L: UnsafeMutableMemoryAccessible, R: UnsafeMemoryAccessible>(lh
/// - Warning: does not support memory stride (assumes stride is 1).
public func remainder<L: UnsafeMemoryAccessible, R: UnsafeMemoryAccessible>(_ lhs: L, _ rhs: R) -> [Float] where L.Element == Float, R.Element == Float {
var results = Array(lhs)
remainderInPlace(&results, rhs)
return results
return withArray(from: lhs) { remainderInPlace(&$0, rhs) }
}
/// - Warning: does not support memory stride (assumes stride is 1).
public func remainder<L: UnsafeMemoryAccessible, R: UnsafeMemoryAccessible>(_ lhs: L, _ rhs: R) -> [Double] where L.Element == Double, R.Element == Double {
var results = Array(lhs)
remainderInPlace(&results, rhs)
return results
return withArray(from: lhs) { remainderInPlace(&$0, rhs) }
}
// MARK: - Remainder: In Place
@ -560,16 +527,12 @@ func remainderInPlace<L: UnsafeMutableMemoryAccessible, R: UnsafeMemoryAccessibl
/// - Warning: does not support memory stride (assumes stride is 1).
public func exp<X: UnsafeMemoryAccessible>(_ lhs: X) -> [Float] where X.Element == Float {
var results = Array(lhs)
expInPlace(&results)
return results
return withArray(from: lhs) { expInPlace(&$0) }
}
/// - Warning: does not support memory stride (assumes stride is 1).
public func exp<X: UnsafeMemoryAccessible>(_ lhs: X) -> [Double] where X.Element == Double {
var results = Array(lhs)
expInPlace(&results)
return results
return withArray(from: lhs) { expInPlace(&$0) }
}
// MARK: - Exponential: In Place
@ -596,16 +559,12 @@ func expInPlace<X: UnsafeMutableMemoryAccessible>(_ lhs: inout X) where X.Elemen
/// - Warning: does not support memory stride (assumes stride is 1).
public func exp2<X: UnsafeMemoryAccessible>(_ lhs: X) -> [Float] where X.Element == Float {
var results = Array(lhs)
exp2InPlace(&results)
return results
return withArray(from: lhs) { exp2InPlace(&$0) }
}
/// - Warning: does not support memory stride (assumes stride is 1).
public func exp2<X: UnsafeMemoryAccessible>(_ lhs: X) -> [Double] where X.Element == Double {
var results = Array(lhs)
exp2InPlace(&results)
return results
return withArray(from: lhs) { exp2InPlace(&$0) }
}
// MARK: - Square Exponentiation: In Place
@ -632,30 +591,22 @@ func exp2InPlace<X: UnsafeMutableMemoryAccessible>(_ lhs: inout X) where X.Eleme
/// - Warning: does not support memory stride (assumes stride is 1).
public func pow<X: UnsafeMemoryAccessible, Y: UnsafeMemoryAccessible>(_ lhs: X, _ rhs: Y) -> [Float] where X.Element == Float, Y.Element == Float {
var results = Array(lhs)
powInPlace(&results, rhs)
return results
return withArray(from: lhs) { powInPlace(&$0, rhs) }
}
/// - Warning: does not support memory stride (assumes stride is 1).
public func pow<X: UnsafeMemoryAccessible, Y: UnsafeMemoryAccessible>(_ lhs: X, _ rhs: Y) -> [Double] where X.Element == Double, Y.Element == Double {
var results = Array(lhs)
powInPlace(&results, rhs)
return results
return withArray(from: lhs) { powInPlace(&$0, rhs) }
}
/// - Warning: Allocates a temporary array from `rhs` via `Array(repeating: rhs, count: lhs.count)`.
public func pow<X: UnsafeMemoryAccessible>(_ lhs: X, _ rhs: Float) -> [Float] where X.Element == Float {
var results = Array(lhs)
powInPlace(&results, rhs)
return results
return withArray(from: lhs) { powInPlace(&$0, rhs) }
}
/// - Warning: Allocates a temporary array from `rhs` via `Array(repeating: rhs, count: lhs.count)`.
public func pow<X: UnsafeMemoryAccessible>(_ lhs: X, _ rhs: Double) -> [Double] where X.Element == Double {
var results = Array(lhs)
powInPlace(&results, rhs)
return results
return withArray(from: lhs) { powInPlace(&$0, rhs) }
}
// MARK: - Power: In Place
@ -701,15 +652,11 @@ func powInPlace<X: UnsafeMutableMemoryAccessible>(_ lhs: inout X, _ rhs: Double)
//// MARK: - Square
public func sq<L: UnsafeMemoryAccessible>(_ lhs: L) -> [Float] where L.Element == Float {
var results = Array(lhs)
sqInPlace(&results)
return results
return withArray(from: lhs) { sqInPlace(&$0) }
}
public func sq<L: UnsafeMemoryAccessible>(_ lhs: L) -> [Double] where L.Element == Double {
var results = Array(lhs)
sqInPlace(&results)
return results
return withArray(from: lhs) { sqInPlace(&$0) }
}
// MARK: - Square: In Place
@ -732,9 +679,14 @@ public func sqInPlace<L: UnsafeMutableMemoryAccessible>(_ lhs: inout L) where L.
///
/// - Warning: does not support memory stride (assumes stride is 1).
public func sqrt<C: UnsafeMemoryAccessible>(_ lhs: C) -> [Float] where C.Element == Float {
var results = Array(lhs)
sqrtInPlace(&results)
return results
return withArray(from: lhs) { sqrtInPlace(&$0) }
}
/// Elemen-wise square root.
///
/// - Warning: does not support memory stride (assumes stride is 1).
public func sqrt<C: UnsafeMemoryAccessible>(_ lhs: C) -> [Double] where C.Element == Double {
return withArray(from: lhs) { sqrtInPlace(&$0) }
}
/// Elemen-wise square root with custom output storage.
@ -750,15 +702,6 @@ public func sqrt<MI: UnsafeMemoryAccessible, MO: UnsafeMutableMemoryAccessible>(
}
}
/// Elemen-wise square root.
///
/// - Warning: does not support memory stride (assumes stride is 1).
public func sqrt<C: UnsafeMemoryAccessible>(_ lhs: C) -> [Double] where C.Element == Double {
var results = Array(lhs)
sqrtInPlace(&results)
return results
}
/// Elemen-wise square root with custom output storage.
///
/// - Warning: does not support memory stride (assumes stride is 1).

41
Sources/Surge/Linear Algebra/Matrix.swift
View File

@ -264,22 +264,21 @@ public func ==<T> (lhs: Matrix<T>, rhs: Matrix<T>) -> Bool {
return lhs.rows == rhs.rows && lhs.columns == rhs.columns && lhs.grid == rhs.grid
}
@inline(__always)
func withMatrix<Scalar>(from matrix: Matrix<Scalar>, _ closure: (inout Matrix<Scalar>) -> ()) -> Matrix<Scalar> {
var copy = matrix
closure(&copy)
return copy
}
// MARK: - Addition
public func add(_ lhs: Matrix<Float>, _ rhs: Matrix<Float>) -> Matrix<Float> {
var result = lhs
result += rhs
return result
return withMatrix(from: lhs) { addInPlace(&$0, rhs) }
}
public func add(_ lhs: Matrix<Double>, _ rhs: Matrix<Double>) -> Matrix<Double> {
var result = lhs
result += rhs
return result
return withMatrix(from: lhs) { addInPlace(&$0, rhs) }
}
public func + (lhs: Matrix<Float>, rhs: Matrix<Float>) -> Matrix<Float> {
@ -311,17 +310,11 @@ public func += (lhs: inout Matrix<Double>, rhs: Matrix<Double>) {
// MARK: - Subtraction
public func sub(_ lhs: Matrix<Float>, _ rhs: Matrix<Float>) -> Matrix<Float> {
var result = lhs
result -= rhs
return result
return withMatrix(from: lhs) { subInPlace(&$0, rhs) }
}
public func sub(_ lhs: Matrix<Double>, _ rhs: Matrix<Double>) -> Matrix<Double> {
var result = lhs
result -= rhs
return result
return withMatrix(from: lhs) { subInPlace(&$0, rhs) }
}
public func - (lhs: Matrix<Float>, rhs: Matrix<Float>) -> Matrix<Float> {
@ -353,19 +346,11 @@ public func -= (lhs: inout Matrix<Double>, rhs: Matrix<Double>) {
// MARK: - Multiply Addition
func muladd(_ lhs: Matrix<Float>, _ rhs: Matrix<Float>, _ alpha: Float) -> Matrix<Float> {
var result = lhs
muladdInPlace(&result, rhs, alpha)
return result
return withMatrix(from: lhs) { muladdInPlace(&$0, rhs, alpha) }
}
func muladd(_ lhs: Matrix<Double>, _ rhs: Matrix<Double>, _ alpha: Double) -> Matrix<Double> {
var result = lhs
muladdInPlace(&result, rhs, alpha)
return result
return withMatrix(from: lhs) { muladdInPlace(&$0, rhs, alpha) }
}
// MARK: - Multiply Addition: In Place

103
Sources/Surge/Linear Algebra/Vector.swift
View File

@ -105,18 +105,21 @@ public func ==<T> (lhs: Vector<T>, rhs: Vector<T>) -> Bool {
return lhs.scalars == rhs.scalars
}
@inline(__always)
func withVector<Scalar>(from vector: Vector<Scalar>, _ closure: (inout Vector<Scalar>) -> ()) -> Vector<Scalar> {
var copy = vector
closure(&copy)
return copy
}
// MARK: - Addition
public func add(_ lhs: Vector<Float>, _ rhs: Vector<Float>) -> Vector<Float> {
var result = lhs
addInPlace(&result, rhs)
return result
return withVector(from: lhs) { addInPlace(&$0, rhs) }
}
public func add(_ lhs: Vector<Double>, _ rhs: Vector<Double>) -> Vector<Double> {
var result = lhs
addInPlace(&result, rhs)
return result
return withVector(from: lhs) { addInPlace(&$0, rhs) }
}
public func + (lhs: Vector<Float>, rhs: Vector<Float>) -> Vector<Float> {
@ -128,15 +131,11 @@ public func + (lhs: Vector<Double>, rhs: Vector<Double>) -> Vector<Double> {
}
public func add(_ lhs: Vector<Float>, _ rhs: Float) -> Vector<Float> {
var result = lhs
addInPlace(&result, rhs)
return result
return withVector(from: lhs) { addInPlace(&$0, rhs) }
}
public func add(_ lhs: Vector<Double>, _ rhs: Double) -> Vector<Double> {
var result = lhs
addInPlace(&result, rhs)
return result
return withVector(from: lhs) { addInPlace(&$0, rhs) }
}
public func + (lhs: Vector<Float>, rhs: Float) -> Vector<Float> {
@ -188,15 +187,11 @@ public func += (lhs: inout Vector<Double>, rhs: Double) {
// MARK: - Subtraction
public func sub(_ lhs: Vector<Float>, _ rhs: Vector<Float>) -> Vector<Float> {
var result = lhs
subInPlace(&result, rhs)
return result
return withVector(from: lhs) { subInPlace(&$0, rhs) }
}
public func sub(_ lhs: Vector<Double>, _ rhs: Vector<Double>) -> Vector<Double> {
var result = lhs
subInPlace(&result, rhs)
return result
return withVector(from: lhs) { subInPlace(&$0, rhs) }
}
public func - (lhs: Vector<Float>, rhs: Vector<Float>) -> Vector<Float> {
@ -208,15 +203,11 @@ public func - (lhs: Vector<Double>, rhs: Vector<Double>) -> Vector<Double> {
}
public func sub(_ lhs: Vector<Float>, _ rhs: Float) -> Vector<Float> {
var result = lhs
subInPlace(&result, rhs)
return result
return withVector(from: lhs) { subInPlace(&$0, rhs) }
}
public func sub(_ lhs: Vector<Double>, _ rhs: Double) -> Vector<Double> {
var result = lhs
subInPlace(&result, rhs)
return result
return withVector(from: lhs) { subInPlace(&$0, rhs) }
}
public func - (lhs: Vector<Float>, rhs: Float) -> Vector<Float> {
@ -268,15 +259,11 @@ public func -= (lhs: inout Vector<Double>, rhs: Double) {
// MARK: - Multiply Addition
public func muladd(_ lhs: Vector<Float>, _ rhs: Vector<Float>, _ alpha: Float) -> Vector<Float> {
var result = lhs
muladdInPlace(&result, rhs, alpha)
return result
return withVector(from: lhs) { muladdInPlace(&$0, rhs, alpha) }
}
public func muladd(_ lhs: Vector<Double>, _ rhs: Vector<Double>, _ alpha: Double) -> Vector<Double> {
var result = lhs
muladdInPlace(&result, rhs, alpha)
return result
return withVector(from: lhs) { muladdInPlace(&$0, rhs, alpha) }
}
// MARK: - Multiply Addition: In Place
@ -296,15 +283,11 @@ func muladdInPlace(_ lhs: inout Vector<Double>, _ rhs: Vector<Double>, _ alpha:
// MARK: - Multiplication
public func mul(_ lhs: Vector<Float>, _ rhs: Float) -> Vector<Float> {
var result = lhs
mulInPlace(&result, rhs)
return result
return withVector(from: lhs) { mulInPlace(&$0, rhs) }
}
public func mul(_ lhs: Vector<Double>, _ rhs: Double) -> Vector<Double> {
var result = lhs
mulInPlace(&result, rhs)
return result
return withVector(from: lhs) { mulInPlace(&$0, rhs) }
}
public func * (lhs: Vector<Float>, rhs: Float) -> Vector<Float> {
@ -388,15 +371,11 @@ public func *= (lhs: inout Vector<Double>, rhs: Double) {
// MARK: - Division
public func div(_ lhs: Vector<Float>, _ rhs: Float) -> Vector<Float> {
var result = lhs
divInPlace(&result, rhs)
return result
return withVector(from: lhs) { divInPlace(&$0, rhs) }
}
public func div(_ lhs: Vector<Double>, _ rhs: Double) -> Vector<Double> {
var result = lhs
divInPlace(&result, rhs)
return result
return withVector(from: lhs) { divInPlace(&$0, rhs) }
}
public func / (lhs: Vector<Double>, rhs: Double) -> Vector<Double> {
@ -428,19 +407,11 @@ public func /= (lhs: inout Vector<Double>, rhs: Double) {
// MARK: - Element-wise Multiplication
public func elmul(_ lhs: Vector<Double>, _ rhs: Vector<Double>) -> Vector<Double> {
precondition(lhs.dimensions == rhs.dimensions, "Vector dimensions not compatible with element-wise multiplication")
var result = lhs
elmulInPlace(&result, rhs)
return result
return withVector(from: lhs) { elmulInPlace(&$0, rhs) }
}
public func elmul(_ lhs: Vector<Float>, _ rhs: Vector<Float>) -> Vector<Float> {
precondition(lhs.dimensions == rhs.dimensions, "Vector dimensions not compatible with element-wise multiplication")
var result = lhs
elmulInPlace(&result, rhs)
return result
return withVector(from: lhs) { elmulInPlace(&$0, rhs) }
}
public func .* (lhs: Vector<Float>, rhs: Vector<Float>) -> Vector<Float> {
@ -476,19 +447,11 @@ public func .*= (lhs: inout Vector<Double>, rhs: Vector<Double>) {
// MARK: - Element-wise Division
public func eldiv(_ lhs: Vector<Double>, _ rhs: Vector<Double>) -> Vector<Double> {
precondition(lhs.dimensions == rhs.dimensions, "Vector dimensions not compatible with element-wise division")
var result = lhs
eldivInPlace(&result, rhs)
return result
return withVector(from: lhs) { eldivInPlace(&$0, rhs) }
}
public func eldiv(_ lhs: Vector<Float>, _ rhs: Vector<Float>) -> Vector<Float> {
precondition(lhs.dimensions == rhs.dimensions, "Vector dimensions not compatible with element-wise division")
var result = lhs
eldivInPlace(&result, rhs)
return result
return withVector(from: lhs) { eldivInPlace(&$0, rhs) }
}
public func ./ (lhs: Vector<Double>, rhs: Vector<Double>) -> Vector<Double> {
@ -547,15 +510,11 @@ public func • (lhs: Vector<Float>, rhs: Vector<Float>) -> Float {
// MARK: - Power
public func pow(_ lhs: Vector<Double>, _ rhs: Double) -> Vector<Double> {
var result = lhs
powInPlace(&result, rhs)
return result
return withVector(from: lhs) { powInPlace(&$0, rhs) }
}
public func pow(_ lhs: Vector<Float>, _ rhs: Float) -> Vector<Float> {
var result = lhs
powInPlace(&result, rhs)
return result
return withVector(from: lhs) { powInPlace(&$0, rhs) }
}
// MARK: - Power: In Place
@ -571,15 +530,11 @@ func powInPlace(_ lhs: inout Vector<Float>, _ rhs: Float) {
// MARK: - Exponential
public func exp(_ lhs: Vector<Double>) -> Vector<Double> {
var result = lhs
expInPlace(&result)
return result
return withVector(from: lhs) { expInPlace(&$0) }
}
public func exp(_ lhs: Vector<Float>) -> Vector<Float> {
var result = lhs
expInPlace(&result)
return result
return withVector(from: lhs) { expInPlace(&$0) }
}
// MARK: - Exponential: In Place