New abstractions in NDimensionalType: size, init, deriving. Testing factorization of element-wise op (subtracting for vectors & matrix). Added new setter.

rsebbe · rsebbe · commit 372d27a72f16 · 2019-05-27T09:48:15.000+02:00
diff --git a/NDimensionalType.swift b/NDimensionalType.swift
@@ -13,14 +13,26 @@ public protocol NDimensionalType: CustomStringConvertible {
 	associatedtype NativeIndexRange: Sequence where NativeIndexRange.Element == NativeIndex
 	var dimension: Int { get }
 	var shape: [Int] { get } // size is dimension
+	var size: NativeIndex { get }
+	
+	init(repeating value: Element, size: NativeIndex)
 	
 	// we don't define as vararg arrays, we let that up to the actual type to opt-out from array use (performance).
 	subscript(index: [Int]) -> Element { get set }
 	subscript(index: NativeIndex) -> Element { get set }
 	var indices: NativeIndexRange { get }
+	
+//	internal func deriving() -> Self
 }
 
 extension NDimensionalType {
+	// quickie to allocate result with same size as self.
+	internal func _deriving(_ prep: (Self) -> ()) -> Self {
+		let result = Self(repeating: .none, size: self.size)
+		prep(result)
+		return result
+	}
+	
 	private func recursiveDescription(index: [Int]) -> String {
 		var description = ""
 		let dimi = index.count
diff --git a/NMatrix.swift b/NMatrix.swift
@@ -28,7 +28,9 @@ public struct NMatrix<Element: NValue> : NStorageAccessible {
 	
 	public var rows: Int { return slice.row.rcount }
 	public var columns: Int { return slice.column.rcount }
-	public var size: (rows: Int, columns: Int) { return (rows, columns) }
+//	public var width: Int { return columns }
+//	public var height: Int { return rows }
+	public var size: NativeIndex { return (rows, columns) }
 	public var indices: NQuadraticIndexRange { return NQuadraticIndexRange(rows: rows, columns: columns) }
 	public var compact: Bool { return slice.compact }
 	
@@ -50,7 +52,7 @@ public struct NMatrix<Element: NValue> : NStorageAccessible {
 		let storage = Storage(allocatedCount: rows * columns, value: value)
 		self.init(storage: storage, slice: .default(rows: rows, columns: columns))
 	}
-	public init(repeating value: Element = .none, size: (Int, Int)) {
+	public init(repeating value: Element = .none, size: NativeIndex) {
 		self.init(repeating: value, rows: size.0, columns: size.1)
 	}
 	
@@ -68,6 +70,12 @@ public struct NMatrix<Element: NValue> : NStorageAccessible {
 			}
 		}
 	}
+	// init from row-major values (values.count = rows x columns)
+	public init(_ values: [Element], rows: Int, columns: Int) {
+		precondition(values.count == rows * columns)
+		self.init(rows: rows, columns: columns)
+		self.set(from: values)
+	}
 	
 	public func copy() -> NMatrix {
 		let result = NMatrix(rows: rows, columns: columns)
@@ -104,14 +112,6 @@ public struct NMatrix<Element: NValue> : NStorageAccessible {
 		}
 	}
 	
-	// quickie to allocate result with same size as self.
-	internal func _deriving(_ prep: (Matrix) -> ()) -> Matrix {
-		let result = Matrix(rows: rows, columns: columns)
-		prep(result)
-		return result
-	}
-	
-	
 	// Get row/column as vector
 	private func vector(row: Int) -> Vector {
 		let rslice = NResolvedSlice(start: slice.position(row, 0), count: columns, step: slice.column.rstep)
@@ -180,7 +180,7 @@ public struct NMatrix<Element: NValue> : NStorageAccessible {
 	public subscript(indexes: NMatrixi) -> Vector {
 		get {
 			precondition(indexes.columns == 2)
-			let result = Vector(size: indexes.size.rows)
+			let result = Vector(size: indexes.size.row)
 			for index in indexes.indices.row {
 				let selfindex = (indexes[index, 0], indexes[index, 1])
 				assert(selfindex.0 >= 0 && selfindex.0 < self.rows)
@@ -191,7 +191,7 @@ public struct NMatrix<Element: NValue> : NStorageAccessible {
 		}
 		nonmutating set {
 			precondition(indexes.columns == 2)
-			precondition(newValue.size == indexes.size.rows)
+			precondition(newValue.size == indexes.size.row)
 			for index in indexes.indices.row {
 				let selfindex = (indexes[index, 0], indexes[index, 1])
 				assert(selfindex.0 >= 0 && selfindex.0 < self.rows)
@@ -215,6 +215,7 @@ public struct NMatrix<Element: NValue> : NStorageAccessible {
 // TODO: These Vector / Matrix funcs are very similar. Could probably push that into NDimensionalType.
 extension NMatrix {
 	// Access
+	// Note: set API does not expose data range as NMatrix slicing is used for that
 	public func set(from: Matrix) {
 		for (pos, rpos) in zip(slice, from.slice) {
 			storage[pos] = from.storage[rpos]
@@ -231,6 +232,12 @@ extension NMatrix {
 			if mask[i] { self[i] = value }
 		}
 	}
+	public func set(from rowMajorValues: [Element]) {
+		precondition(rowMajorValues.count == rows * columns)
+		for (pos, rpos) in zip(slice, rowMajorValues.indices) {
+			storage[pos] = rowMajorValues[rpos]
+		}
+	}
 }
 
 extension NMatrix where Element: SignedNumeric, Element.Magnitude == Element {
diff --git a/NOps.swift b/NOps.swift
@@ -23,11 +23,25 @@ public enum ConvolutionDomain {
 	// case full // M+K-1
 }
 
+// MARK: - Generic Dimensional Type Ops (apply to Vector, Matrix, Tensor)
+// Typically element-wise operations that can be implemented in terms to linearized access (any dimensions).
+extension Numerics where Element: AccelerateFloatingPoint {
+	public static func subtract<DT: NStorageAccessible>(_ a: DT, _ b: DT, _ result: DT) where DT.Element == Element {
+		precondition(a.shape == b.shape && a.shape == result.shape)
+		
+		withLinearizedAccesses(a, b, result) { aacc, bacc, racc in
+			Element.mx_vsub(aacc.base, aacc.stride, bacc.base, bacc.stride, racc.base, racc.stride, numericCast(racc.count))
+		}
+	}
+	public static func subtract<DT: NStorageAccessible>(_ a: DT, _ b: DT) -> DT where DT.Element == Element { return a._deriving { subtract(a, b, $0) } }
+}
+
+
 // MARK: - Vector Ops
 extension Numerics where Element: AccelerateFloatingPoint {
 	/// Creation of vectors
-	public static func zeros(count: Int) -> Vector { return Vector(repeating: 0.0, count: count) }
-	public static func ones(count: Int) -> Vector { return NVector(repeating: 1.0, count: count) }
+	public static func zeros(count: Int) -> Vector { return Vector(repeating: 0.0, size: count) }
+	public static func ones(count: Int) -> Vector { return NVector(repeating: 1.0, size: count) }
 	public static func linspace(start: Element, stop: Element, count: Int, output: Vector) {
 		precondition(count == output.size)
 		precondition(count >= 2)
@@ -102,8 +116,8 @@ extension Numerics where Element: AccelerateFloatingPoint {
 		let afterstart = before+input.size
 		
 		output[before ..< afterstart] = input
-		output[0 ..< before] = NVector(repeating: input.first!, count: before)
-		output[afterstart ..< output.size] = NVector(repeating: input.last!, count: after)
+		output[0 ..< before] = NVector(repeating: input.first!, size: before)
+		output[afterstart ..< output.size] = NVector(repeating: input.last!, size: after)
 	}
 	
 	// Arithmetic
@@ -141,13 +155,13 @@ extension Numerics where Element: AccelerateFloatingPoint {
 	}
 	public static func multiply(_ a: Vector, _ b: Vector) -> Vector { return a._deriving { multiply(a, b, $0) } }
 	
-	public static func subtract(_ a: Vector, _ b: Vector, _ result: Vector) {
-		precondition(a.shape == b.shape && a.shape == result.shape)
-		withStorageAccess(a, b, result) { aacc, bacc, racc in
-			Element.mx_vsub(aacc.base, aacc.stride, bacc.base, bacc.stride, racc.base, racc.stride, numericCast(racc.count))
-		}
-	}
-	public static func subtract(_ a: Vector, _ b: Vector) -> Vector { return a._deriving { subtract(a, b, $0) } }
+//	public static func subtract(_ a: Vector, _ b: Vector, _ result: Vector) {
+//		precondition(a.shape == b.shape && a.shape == result.shape)
+//		withStorageAccess(a, b, result) { aacc, bacc, racc in
+//			Element.mx_vsub(aacc.base, aacc.stride, bacc.base, bacc.stride, racc.base, racc.stride, numericCast(racc.count))
+//		}
+//	}
+//	public static func subtract(_ a: Vector, _ b: Vector) -> Vector { return a._deriving { subtract(a, b, $0) } }
 	public static func add(_ a: Vector, _ b: Vector, _ result: Vector) {
 		precondition(a.shape == b.shape && a.shape == result.shape)
 		withStorageAccess(a, b, result) { aacc, bacc, racc in
@@ -270,6 +284,13 @@ extension NVector where Element: AccelerateFloatingPoint {
 extension Numerics where Element: AccelerateFloatingPoint {
 	public static func zeros(rows: Int, columns: Int) -> Matrix { return Matrix(repeating: 0.0, rows: rows, columns: columns) }
 	public static func ones(rows: Int, columns: Int) -> Matrix { return Matrix(repeating: 1.0, rows: rows, columns: columns) }
+//	public static func add(_ a: Vector, _ b: Vector, _ result: Vector) {
+//		precondition(a.shape == b.shape && a.shape == result.shape)
+//		withStorageAccess(a, b, result) { aacc, bacc, racc in
+//			Element.mx_vadd(aacc.base, aacc.stride, bacc.base, bacc.stride, racc.base, racc.stride, numericCast(racc.count))
+//		}
+//	}
+//	public static func add(_ a: Vector, _ b: Vector) -> Vector { return a._deriving { add(a, b, $0) } }
 	
 	public static func multiply(_ a: Matrix, _ b: Element, _ result: Matrix) {
 		precondition(a.shape == result.shape)
@@ -526,6 +547,10 @@ extension NMatrix where Element: AccelerateFloatingPoint {
 		return result
 	}
 	
+	// Matrix/Matric
+	public static func -(lhs: Matrix, rhs: Matrix) -> Matrix { return Numerics.subtract(lhs, rhs) }
+//	public static func +(lhs: Matrix, rhs: Matrix) -> Matrix { return Numerics.add(lhs, rhs) }
+	
 	// Matrix/Vector
 	public static func *(lhs: Matrix, rhs: Matrix) -> Matrix { return Numerics.multiply(lhs, rhs) }
 	public static func *(lhs: Matrix, rhs: Vector) -> Vector { return Numerics.multiply(lhs, rhs) }
diff --git a/NStorage.swift b/NStorage.swift
@@ -132,11 +132,17 @@ extension NStorage {
 		public let base: UnsafeMutablePointer<Element>
 		
 		// navigate relatively to the first element.
+		
+		// stride: storage distance (elements) between elements in successive row/column
 		public let stride: (row: Int, column: Int)
+		// count: number of rows / columns
 		public let count: (row: Int, column: Int)
 		// Note: QuadraticAccess's slice always starts at 0 (unlike Matrix's)
 		public var slice: NResolvedQuadraticSlice { return NResolvedQuadraticSlice(row: NResolvedSlice(start: 0, count: count.row, step: stride.row), column: NResolvedSlice(start: 0, count: count.column, step: stride.column)) }
 		
+		// shortcut for APIs that need this
+		public var rowBytes: Int { return stride.row * MemoryLayout<Element>.stride }
+		
 		public var compact: Bool { return stride.column == 1 && stride.row == count.column }
 		// points to the first element of row or columns
 		public func base(row: Int) -> UnsafeMutablePointer<Element> { return base + row * stride.row }
@@ -201,6 +207,7 @@ extension Numerics {
 		}
 	}
 	public static func withLinearizedAccesses<T: NStorageAccessible>(_ a: T, _ b: T, _ access: (Storage.LinearAccess, Storage.LinearAccess) -> Void) where T.Element == Element {
+		precondition(a.shape == b.shape)
 		a._withStorageAccess { aacc in
 			b._withStorageAccess { bacc in
 				let coalesce = aacc.compact && bacc.compact
@@ -210,6 +217,19 @@ extension Numerics {
 			}
 		}
 	}
+	public static func withLinearizedAccesses<T: NStorageAccessible>(_ a: T, _ b: T, _ c: T, _ access: (Storage.LinearAccess, Storage.LinearAccess, Storage.LinearAccess) -> Void) where T.Element == Element {
+		precondition(a.shape == b.shape && a.shape == c.shape)
+		a._withStorageAccess { aacc in
+			b._withStorageAccess { bacc in
+				c._withStorageAccess { cacc in
+					let coalesce = aacc.compact && bacc.compact && cacc.compact
+					for (alin, (blin, clin)) in zip(aacc.linearized(coalesce: coalesce), zip(bacc.linearized(coalesce: coalesce), cacc.linearized(coalesce: coalesce))) {
+						access(alin, blin, clin)
+					}
+				}
+			}
+		}
+	}
 	// MARK: - Storage/Value Stride
 	internal static func withAddresses<T: NStorageAccessible>(_ a: T, _ block: (_ pointer: UnsafeMutablePointer<Element>) -> Void) where T.Element == Element {
 		a._withStorageAccess { aacc in
diff --git a/NVector.swift b/NVector.swift
@@ -32,23 +32,23 @@ public struct NVector<Element: NValue> : NStorageAccessible {
 		//layout = l
 		slice = sl
 	}
-	public init(size: Int) {
-		let storage = Storage(allocatedCount: size)
-		self.init(storage: storage, slice: .default(count: size))
-	}
+//	public init(size: Int) {
+//		let storage = Storage(allocatedCount: size)
+//		self.init(storage: storage, slice: .default(count: size))
+//	}
 	public init(storage mem: Storage, count: Int) {
 		let slice = NResolvedSlice(start: 0, count: count, step: 1)
 		self.init(storage: mem, slice: slice)
 	}
-	public init(_ elements: [Element]) {
-		self.init(size: elements.count)
-		
+	public init(_ values: [Element]) {
+		self.init(size: values.count)
 		storage.withUnsafeAccess { access in
-			_ = UnsafeMutableBufferPointer(start: access.base, count: self.size).initialize(from: elements)
+			_ = UnsafeMutableBufferPointer(start: access.base, count: self.size).initialize(from: values)
 		}
 	}
-	public init(repeating value: Element, count: Int) {
-		self.init(size: count)
+	public init(repeating value: Element = .none, size: Int) {
+		let storage = Storage(allocatedCount: size)
+		self.init(storage: storage, slice: .default(count: size))
 		
 		storage.withUnsafeAccess { access in
 			_ = UnsafeMutableBufferPointer(start: access.base, count: self.size).initialize(repeating: value)
@@ -67,13 +67,6 @@ public struct NVector<Element: NValue> : NStorageAccessible {
 		return result
 	}
 	
-	// quickie to allocate result with same size as self.
-	internal func _deriving(_ prep: (Vector) -> ()) -> Vector {
-		let result = Vector(size: self.size)
-		prep(result)
-		return result
-	}
-	
 	// MARK: - Slicing -
 	public subscript(_ s: NSliceExpression) -> Vector {
 		get { return Vector(storage: storage, slice: s.resolve(within: slice)) }
@@ -144,11 +137,16 @@ public struct NVector<Element: NValue> : NStorageAccessible {
 extension NVector {
 	public func set(from: Vector) {
 		precondition(from.slice.rcount == slice.rcount)
-		
 		Numerics.withAddresses(from, self) { pfrom, pself in
 			pself.pointee = pfrom.pointee
 		}
 	}
+	public func set(from: [Element]) {
+		precondition(from.count == size)
+		for (i, j) in zip(self.indices, 0..<from.count) {
+			self[i] = from[j]
+		}
+	}
 	public func set(_ value: Element) {
 		for i in self.indices {
 			self[i] = value
