From 5384873018de1450272a91fd5c0fc445c023f696 Mon Sep 17 00:00:00 2001
From: Daniel Strobusch <1847260+dastrobu@users.noreply.github.com>
Date: Sat, 2 Apr 2022 17:15:44 +0200
Subject: [PATCH] expose data as UnsafeMutableBufferPointer

---
 Sources/NdArray/Equitable.swift              |  8 +-
 Sources/NdArray/Matrix.swift                 | 28 +++----
 Sources/NdArray/NdArray.swift                | 29 ++++---
 Sources/NdArray/NdArraySlice.swift           |  4 +-
 Sources/NdArray/Vector.swift                 | 22 +++---
 Sources/NdArray/VectorSequence.swift         |  6 +-
 Sources/NdArray/apply.swift                  |  4 +-
 Sources/NdArray/arithmetic.swift             | 82 ++++++++++----------
 Sources/NdArray/basic_functions.swift        |  8 +-
 Sources/NdArray/copy.swift                   |  2 +-
 Sources/NdArray/init.swift                   | 12 +--
 Sources/NdArray/reduce.swift                 |  4 +-
 Tests/NdArrayTests/VectorSequenceTests.swift |  3 +-
 13 files changed, 109 insertions(+), 103 deletions(-)

diff --git a/Sources/NdArray/Equitable.swift b/Sources/NdArray/Equitable.swift
index cd25a23..1c2aca8 100644
--- a/Sources/NdArray/Equitable.swift
+++ b/Sources/NdArray/Equitable.swift
@@ -24,8 +24,8 @@ extension NdArray: Equatable where T: Equatable {
         case 0:
             return true
         case 1:
-            var l = lhs.data
-            var r = rhs.data
+            var l = lhs.dataStart
+            var r = rhs.dataStart
             let ls = lhs.strides[0]
             let rs = rhs.strides[0]
             for _ in 0..<lhs.count {
@@ -37,8 +37,8 @@ extension NdArray: Equatable where T: Equatable {
             }
         default:
             if (lhs.isCContiguous && rhs.isCContiguous) || (lhs.isFContiguous && rhs.isFContiguous) {
-                var l = lhs.data
-                var r = rhs.data
+                var l = lhs.dataStart
+                var r = rhs.dataStart
                 for _ in 0..<lhs.count {
                     if l.pointee != r.pointee {
                         return false
diff --git a/Sources/NdArray/Matrix.swift b/Sources/NdArray/Matrix.swift
index 2161699..90d82f7 100644
--- a/Sources/NdArray/Matrix.swift
+++ b/Sources/NdArray/Matrix.swift
@@ -28,7 +28,7 @@ open class Matrix<T>: NdArray<T> {
             for i in 0..<rowCount {
                 let row = a[i]
                 precondition(row.count == colCount, "\(row.count) == \(colCount) at row \(i)")
-                memcpy(data + i * strides[0], row, colCount * MemoryLayout<T>.stride)
+                memcpy(dataStart + i * strides[0], row, colCount * MemoryLayout<T>.stride)
             }
         case .F:
             for i in 0..<rowCount {
@@ -36,7 +36,7 @@ open class Matrix<T>: NdArray<T> {
                 precondition(row.count == colCount, "\(row.count) == \(colCount) at row \(i)")
                 // manual memcopy for strided data
                 for j in 0..<colCount {
-                    data[i * strides[0] + j * strides[1]] = row[j]
+                    dataStart[i * strides[0] + j * strides[1]] = row[j]
                 }
             }
         }
@@ -177,7 +177,7 @@ public extension Matrix where T == Double {
         var lda: __CLPK_integer = __CLPK_integer(n)
         var ldb = __CLPK_integer(B.shape[0])
         var info: __CLPK_integer = 0
-        dgesv_(&n, &nrhs, A.data, &lda, &ipiv, B.data, &ldb, &info)
+        dgesv_(&n, &nrhs, A.dataStart, &lda, &ipiv, B.dataStart, &ldb, &info)
         if info != 0 {
             throw LapackError.dgesv(info)
         }
@@ -212,7 +212,7 @@ public extension Matrix where T == Double {
         // do optimal workspace query
         var lwork: __CLPK_integer = -1
         var work = [__CLPK_doublereal](repeating: 0.0, count: 1)
-        dgetri_(&n, A.data, &lda, &ipiv, &work, &lwork, &info)
+        dgetri_(&n, A.dataStart, &lda, &ipiv, &work, &lwork, &info)
         if info != 0 {
             throw LapackError.getri(info)
         }
@@ -222,7 +222,7 @@ public extension Matrix where T == Double {
         work = [__CLPK_doublereal](repeating: 0.0, count: Int(lwork))
 
         // do the inversion
-        dgetri_(&n, A.data, &lda, &ipiv, &work, &lwork, &info)
+        dgetri_(&n, A.dataStart, &lda, &ipiv, &work, &lwork, &info)
         if info != 0 {
             throw LapackError.getri(info)
         }
@@ -257,7 +257,7 @@ public extension Matrix where T == Double {
         // leading dimension is the number of rows in column major order
         var lda = __CLPK_integer(m)
         var info: __CLPK_integer = 0
-        dgetrf_(&m, &n, data, &lda, &ipiv, &info)
+        dgetrf_(&m, &n, dataStart, &lda, &ipiv, &info)
         if info != 0 {
             throw LapackError.getrf(info)
         }
@@ -336,7 +336,7 @@ public extension Matrix where T == Float {
         var lda: __CLPK_integer = __CLPK_integer(n)
         var ldb = __CLPK_integer(B.shape[0])
         var info: __CLPK_integer = 0
-        sgesv_(&n, &nrhs, A.data, &lda, &ipiv, B.data, &ldb, &info)
+        sgesv_(&n, &nrhs, A.dataStart, &lda, &ipiv, B.dataStart, &ldb, &info)
         if info != 0 {
             throw LapackError.dgesv(info)
         }
@@ -371,7 +371,7 @@ public extension Matrix where T == Float {
         // do optimal workspace query
         var lwork: __CLPK_integer = -1
         var work = [__CLPK_real](repeating: 0.0, count: 1)
-        sgetri_(&n, A.data, &lda, &ipiv, &work, &lwork, &info)
+        sgetri_(&n, A.dataStart, &lda, &ipiv, &work, &lwork, &info)
         if info != 0 {
             throw LapackError.getri(info)
         }
@@ -381,7 +381,7 @@ public extension Matrix where T == Float {
         work = [__CLPK_real](repeating: 0.0, count: Int(lwork))
 
         // do the inversion
-        sgetri_(&n, A.data, &lda, &ipiv, &work, &lwork, &info)
+        sgetri_(&n, A.dataStart, &lda, &ipiv, &work, &lwork, &info)
         if info != 0 {
             throw LapackError.getri(info)
         }
@@ -416,7 +416,7 @@ public extension Matrix where T == Float {
         // leading dimension is the number of rows in column major order
         var lda = __CLPK_integer(m)
         var info: __CLPK_integer = 0
-        sgetrf_(&m, &n, data, &lda, &ipiv, &info)
+        sgetrf_(&m, &n, dataStart, &lda, &ipiv, &info)
         if info != 0 {
             throw LapackError.getrf(info)
         }
@@ -448,7 +448,7 @@ public func * (A: Matrix<Double>, x: Vector<Double>) -> Vector<Double> {
     let lda: Int32 = Int32(a.shape[0])
     let incX: Int32 = Int32(x.strides[0])
     let incY: Int32 = Int32(y.strides[0])
-    cblas_dgemv(order, CblasNoTrans, m, n, 1, a.data, lda, x.data, incX, 0, y.data, incY)
+    cblas_dgemv(order, CblasNoTrans, m, n, 1, a.dataStart, lda, x.dataStart, incX, 0, y.dataStart, incY)
 
     return y
 }
@@ -481,7 +481,7 @@ public func * (A: Matrix<Double>, B: Matrix<Double>) -> Matrix<Double> {
     let lda: Int32 = Int32(a.shape[0])
     let ldb: Int32 = Int32(b.shape[0])
     let ldc: Int32 = Int32(c.shape[0])
-    cblas_dgemm(order, CblasNoTrans, CblasNoTrans, m, n, k, 1, a.data, lda, b.data, ldb, 0, c.data, ldc)
+    cblas_dgemm(order, CblasNoTrans, CblasNoTrans, m, n, k, 1, a.dataStart, lda, b.dataStart, ldb, 0, c.dataStart, ldc)
     return c
 }
 
@@ -510,7 +510,7 @@ public func * (A: Matrix<Float>, x: Vector<Float>) -> Vector<Float> {
     let lda: Int32 = Int32(a.shape[0])
     let incX: Int32 = Int32(x.strides[0])
     let incY: Int32 = Int32(y.strides[0])
-    cblas_sgemv(order, CblasNoTrans, m, n, 1, a.data, lda, x.data, incX, 0, y.data, incY)
+    cblas_sgemv(order, CblasNoTrans, m, n, 1, a.dataStart, lda, x.dataStart, incX, 0, y.dataStart, incY)
 
     return y
 }
@@ -544,6 +544,6 @@ public func * (A: Matrix<Float>, B: Matrix<Float>) -> Matrix<Float> {
     let lda: Int32 = Int32(a.shape[0])
     let ldb: Int32 = Int32(b.shape[0])
     let ldc: Int32 = Int32(c.shape[0])
-    cblas_sgemm(order, CblasNoTrans, CblasNoTrans, m, n, k, 1, a.data, lda, b.data, ldb, 0, c.data, ldc)
+    cblas_sgemm(order, CblasNoTrans, CblasNoTrans, m, n, k, 1, a.dataStart, lda, b.dataStart, ldb, 0, c.dataStart, ldc)
     return c
 }
diff --git a/Sources/NdArray/NdArray.swift b/Sources/NdArray/NdArray.swift
index 24a3ded..a9f571d 100644
--- a/Sources/NdArray/NdArray.swift
+++ b/Sources/NdArray/NdArray.swift
@@ -9,8 +9,13 @@ public enum Contiguous {
 open class NdArray<T>: CustomDebugStringConvertible,
     CustomStringConvertible {
 
-    /// data buffer
-    internal(set) public var data: UnsafeMutablePointer<T>
+    /// data buffer start
+    internal var dataStart: UnsafeMutablePointer<T>
+
+    /// data buffer for row data access
+    public var data: UnsafeMutableBufferPointer<T> {
+        UnsafeMutableBufferPointer(start: dataStart, count: count)
+    }
 
     /// length of the buffer
     internal var count: Int
@@ -53,7 +58,7 @@ open class NdArray<T>: CustomDebugStringConvertible,
     /// create a new array without initializing any memory
     public required init(empty count: Int = 0) {
         self.count = count
-        data = UnsafeMutablePointer<T>.allocate(capacity: count)
+        dataStart = UnsafeMutablePointer<T>.allocate(capacity: count)
         if count == 0 {
             shape = [0]
         } else {
@@ -95,7 +100,7 @@ open class NdArray<T>: CustomDebugStringConvertible,
         } else {
             self.owner = a.owner
         }
-        self.data = a.data
+        self.dataStart = a.dataStart
         self.count = a.count
         self.shape = a.shape
         self.strides = a.strides
@@ -104,7 +109,7 @@ open class NdArray<T>: CustomDebugStringConvertible,
 
     deinit {
         if ownsData {
-            data.deallocate()
+            dataStart.deallocate()
         }
     }
 
@@ -160,7 +165,7 @@ open class NdArray<T>: CustomDebugStringConvertible,
     /// create an 1D NdArray from a plain array
     public convenience init(_ a: [T]) {
         self.init(empty: a.count)
-        data.initialize(from: a, count: a.count)
+        dataStart.initialize(from: a, count: a.count)
     }
 
     /// create an 2D NdArray from a plain array
@@ -179,7 +184,7 @@ open class NdArray<T>: CustomDebugStringConvertible,
             for i in 0..<rowCount {
                 let row = a[i]
                 precondition(row.count == colCount, "\(row.count) == \(colCount) at row \(i)")
-                memcpy(data + i * strides[0], row, colCount * MemoryLayout<T>.stride)
+                memcpy(dataStart + i * strides[0], row, colCount * MemoryLayout<T>.stride)
             }
         case .F:
             for i in 0..<rowCount {
@@ -212,7 +217,7 @@ open class NdArray<T>: CustomDebugStringConvertible,
                 for j in 0..<jCount {
                     let aij = ai[j]
                     precondition(aij.count == kCount, "\(aij.count) == \(kCount) at index \(i), \(j)")
-                    memcpy(data + i * strides[0] + j * strides[1], aij, kCount * MemoryLayout<T>.stride)
+                    memcpy(dataStart + i * strides[0] + j * strides[1], aij, kCount * MemoryLayout<T>.stride)
                 }
             }
         case .F:
@@ -235,11 +240,11 @@ open class NdArray<T>: CustomDebugStringConvertible,
         if isEmpty {
             return []
         }
-        return Array(UnsafeBufferPointer(start: data, count: count))
+        return Array(UnsafeBufferPointer(start: dataStart, count: count))
     }
 
     public var debugDescription: String {
-        let address = String(format: "%p", Int(bitPattern: data))
+        let address = String(format: "%p", Int(bitPattern: dataStart))
         return "NdArray(shape: \(shape), strides: \(strides), data: \(address))"
     }
 
@@ -473,11 +478,11 @@ extension NdArray {
     /// - Returns: true if data regions of this array overlap with data region of the other array
     public func overlaps(_ other: NdArray<T>) -> Bool {
         // check if other starts within our memory
-        if other.data >= self.data && other.data < self.data + self.count {
+        if other.dataStart >= self.dataStart && other.dataStart < self.dataStart + self.count {
             return true
         }
         // check if our memory starts within other memory
-        if self.data >= other.data && self.data < other.data + other.count {
+        if self.dataStart >= other.dataStart && self.dataStart < other.dataStart + other.count {
             return true
         }
         return false
diff --git a/Sources/NdArray/NdArraySlice.swift b/Sources/NdArray/NdArraySlice.swift
index 9cb3d0a..4611fa6 100644
--- a/Sources/NdArray/NdArraySlice.swift
+++ b/Sources/NdArray/NdArraySlice.swift
@@ -28,7 +28,7 @@ internal class NdArraySlice<T>: NdArray<T> {
         super.init(a)
 
         let start = a.flatIndex(startIndex)
-        data = a.data + start
+        dataStart = a.dataStart + start
         count = a.len
     }
 
@@ -318,7 +318,7 @@ internal class NdArraySlice<T>: NdArray<T> {
     }
 
     public override var debugDescription: String {
-        let address = String(format: "%p", Int(bitPattern: data))
+        let address = String(format: "%p", Int(bitPattern: dataStart))
         var sliceDescription = sliceDescription.joined()
         if sliceDescription == "" {
             sliceDescription = "-"
diff --git a/Sources/NdArray/Vector.swift b/Sources/NdArray/Vector.swift
index fe234f9..5295ccb 100644
--- a/Sources/NdArray/Vector.swift
+++ b/Sources/NdArray/Vector.swift
@@ -18,7 +18,7 @@ open class Vector<T>: NdArray<T>, Sequence {
     /// create an 1D NdArray from a plain array
     public convenience init(_ a: [T]) {
         self.init(empty: a.count)
-        data.initialize(from: a, count: a.count)
+        dataStart.initialize(from: a, count: a.count)
     }
 
     public required convenience init(copy a: NdArray<T>) {
@@ -64,12 +64,12 @@ public extension Vector where T == Double {
             Precondition failed while trying to compute dot product for vectors from \(debugDescription) and \(y.debugDescription).
             """)
         let n = Int32(shape[0])
-        return cblas_ddot(n, data, Int32(strides[0]), y.data, Int32(y.strides[0]))
+        return cblas_ddot(n, dataStart, Int32(strides[0]), y.dataStart, Int32(y.strides[0]))
     }
 
     func norm2() -> T {
         let n = Int32(shape[0])
-        return cblas_dnrm2(n, data, Int32(strides[0]))
+        return cblas_dnrm2(n, dataStart, Int32(strides[0]))
     }
 
     func sort(order: SortOrder = .ascending) {
@@ -83,18 +83,18 @@ public extension Vector where T == Double {
         }
 
         if isContiguous {
-            vDSP_vsortD(data, n, sortOrder)
+            vDSP_vsortD(dataStart, n, sortOrder)
         } else {
             // make a copy sort it and copy back if array is not contiguous
             let cpy = Vector(copy: self)
-            vDSP_vsortD(cpy.data, n, sortOrder)
+            vDSP_vsortD(cpy.dataStart, n, sortOrder)
             self[[0...]] = cpy[[0...]]
         }
     }
 
     func reverse() {
         let n = vDSP_Length(shape[0])
-        vDSP_vrvrsD(data, strides[0], n)
+        vDSP_vrvrsD(dataStart, strides[0], n)
     }
 }
 
@@ -106,12 +106,12 @@ public extension Vector where T == Float {
             Precondition failed while trying to compute dot product for vectors from \(debugDescription) and \(y.debugDescription).
             """)
         let n = Int32(shape[0])
-        return cblas_sdot(n, data, Int32(strides[0]), y.data, Int32(y.strides[0]))
+        return cblas_sdot(n, dataStart, Int32(strides[0]), y.dataStart, Int32(y.strides[0]))
     }
 
     func norm2() -> T {
         let n = Int32(shape[0])
-        return cblas_snrm2(n, data, Int32(strides[0]))
+        return cblas_snrm2(n, dataStart, Int32(strides[0]))
     }
 
     func sort(order: SortOrder = .ascending) {
@@ -125,18 +125,18 @@ public extension Vector where T == Float {
         }
 
         if isContiguous {
-            vDSP_vsort(data, n, sortOrder)
+            vDSP_vsort(dataStart, n, sortOrder)
         } else {
             // make a copy sort it and copy back if array is not contiguous
             let cpy = Vector(copy: self)
-            vDSP_vsort(cpy.data, n, sortOrder)
+            vDSP_vsort(cpy.dataStart, n, sortOrder)
             self[[0...]] = cpy[[0...]]
         }
     }
 
     func reverse() {
         let n = vDSP_Length(shape[0])
-        vDSP_vrvrs(data, strides[0], n)
+        vDSP_vrvrs(dataStart, strides[0], n)
     }
 }
 
diff --git a/Sources/NdArray/VectorSequence.swift b/Sources/NdArray/VectorSequence.swift
index 258b1a0..9887b87 100644
--- a/Sources/NdArray/VectorSequence.swift
+++ b/Sources/NdArray/VectorSequence.swift
@@ -32,9 +32,9 @@ public extension Vector {
 
     func makeIterator() -> VectorIterator<T> {
         if isEmpty {
-            return VectorIterator(baseAddress: data, stride: 0, count: 0)
+            return VectorIterator(baseAddress: dataStart, stride: 0, count: 0)
         }
-        return VectorIterator(baseAddress: data, stride: strides[0], count: shape[0])
+        return VectorIterator(baseAddress: dataStart, stride: strides[0], count: shape[0])
     }
 
     /// - Returns: shape[0] or 0 if vector is empty
@@ -46,7 +46,7 @@ public extension Vector {
     /// If the vector is not contiguous, body is not called and nil is returned.
     func withContiguousStorageIfAvailable<R>(_ body: (UnsafeBufferPointer<T>) throws -> R) rethrows -> R? {
         if isContiguous {
-            return try body(UnsafeBufferPointer(start: data, count: count))
+            return try body(UnsafeBufferPointer(start: dataStart, count: count))
         } else {
             return nil
         }
diff --git a/Sources/NdArray/apply.swift b/Sources/NdArray/apply.swift
index f459f8b..7f63445 100644
--- a/Sources/NdArray/apply.swift
+++ b/Sources/NdArray/apply.swift
@@ -71,13 +71,13 @@ public extension NdArray {
     func apply(_ f: (T) throws -> T) rethrows {
         try apply1d(f1d: { n in
             let s = strides[0]
-            var p = data
+            var p = dataStart
             for _ in 0..<n {
                 p.initialize(to: try f(p.pointee))
                 p += s
             }
         }, fContiguous: { n in
-            var p = data
+            var p = dataStart
             for _ in 0..<n {
                 p.initialize(to: try f(p.pointee))
                 p += 1
diff --git a/Sources/NdArray/arithmetic.swift b/Sources/NdArray/arithmetic.swift
index 53faf9f..2f9d5ba 100644
--- a/Sources/NdArray/arithmetic.swift
+++ b/Sources/NdArray/arithmetic.swift
@@ -29,13 +29,13 @@ public extension NdArray where T: AdditiveArithmetic {
     func add(_ x: T) {
         apply1d(f1d: { n in
             let s = strides[0]
-            var p = data
+            var p = dataStart
             for _ in 0..<n {
                 p.initialize(to: p.pointee + x)
                 p += s
             }
         }, fContiguous: { n in
-            var p = data
+            var p = dataStart
             for _ in 0..<n {
                 p.initialize(to: p.pointee + x)
                 p += 1
@@ -53,8 +53,8 @@ public extension NdArray where T: AdditiveArithmetic {
             Precondition failed while trying to add \(x.debugDescription) to \(debugDescription).
             """)
         apply1d(other: x, f1d: { n in
-            var p = data
-            var px = x.data
+            var p = dataStart
+            var px = x.dataStart
             let s = strides[0]
             let sx = x.strides[0]
             for _ in 0..<n {
@@ -63,8 +63,8 @@ public extension NdArray where T: AdditiveArithmetic {
                 px += sx
             }
         }, fContiguous: { n in
-            var p = data
-            var px = x.data
+            var p = dataStart
+            var px = x.dataStart
             for _ in 0..<n {
                 p.initialize(to: p.pointee + px.pointee)
                 p += 1
@@ -83,8 +83,8 @@ public extension NdArray where T: AdditiveArithmetic {
             Precondition failed while trying to add \(x.debugDescription) to \(debugDescription).
             """)
         apply1d(other: x, f1d: { n in
-            var p = data
-            var px = x.data
+            var p = dataStart
+            var px = x.dataStart
             let s = strides[0]
             let sx = x.strides[0]
             for _ in 0..<n {
@@ -93,8 +93,8 @@ public extension NdArray where T: AdditiveArithmetic {
                 px += sx
             }
         }, fContiguous: { n in
-            var p = data
-            var px = x.data
+            var p = dataStart
+            var px = x.dataStart
             for _ in 0..<n {
                 p.initialize(to: p.pointee - px.pointee)
                 p += 1
@@ -122,13 +122,13 @@ public extension NdArray where T: Numeric {
     func multiply(by x: T) {
         apply1d(f1d: { n in
             let s = strides[0]
-            var p = data
+            var p = dataStart
             for _ in 0..<n {
                 p.initialize(to: p.pointee * x)
                 p += s
             }
         }, fContiguous: { n in
-            var p = data
+            var p = dataStart
             for _ in 0..<n {
                 p.initialize(to: p.pointee * x)
                 p += 1
@@ -154,11 +154,11 @@ public extension NdArray where T == Double {
         if isEmpty {
             return nil
         }
-        var r = data[0]
+        var r = dataStart[0]
         apply1d(f1d: { n in
-            vDSP_maxvD(data, strides[0], &r, vDSP_Length(n))
+            vDSP_maxvD(dataStart, strides[0], &r, vDSP_Length(n))
         }, fContiguous: { n in
-            vDSP_maxvD(data, 1, &r, vDSP_Length(n))
+            vDSP_maxvD(dataStart, 1, &r, vDSP_Length(n))
         }, fSlice: { s in
             r = Swift.max(r, s.max()!)
         })
@@ -172,9 +172,9 @@ public extension NdArray where T == Double {
         }
         var r = data[0]
         apply1d(f1d: { n in
-            vDSP_minvD(data, strides[0], &r, vDSP_Length(n))
+            vDSP_minvD(dataStart, strides[0], &r, vDSP_Length(n))
         }, fContiguous: { n in
-            vDSP_minvD(data, 1, &r, vDSP_Length(n))
+            vDSP_minvD(dataStart, 1, &r, vDSP_Length(n))
         }, fSlice: { s in
             r = Swift.min(r, s.min()!)
         })
@@ -190,9 +190,9 @@ public extension NdArray where T == Double {
             Precondition failed while trying to add \(x.debugDescription) to \(debugDescription).
             """)
         apply1d(other: x, f1d: { n in
-            cblas_daxpy(Int32(n), alpha, x.data, Int32(x.strides[0]), data, Int32(strides[0]))
+            cblas_daxpy(Int32(n), alpha, x.dataStart, Int32(x.strides[0]), dataStart, Int32(strides[0]))
         }, fContiguous: { n in
-            cblas_daxpy(Int32(n), alpha, x.data, 1, data, 1)
+            cblas_daxpy(Int32(n), alpha, x.dataStart, 1, dataStart, 1)
         }, fSlice: { s, o in
             s.add(alpha, o)
         })
@@ -207,9 +207,9 @@ public extension NdArray where T == Double {
             Precondition failed while trying to add \(x.debugDescription) to \(debugDescription).
             """)
         apply1d(other: x, f1d: { n in
-            catlas_daxpby(Int32(n), alpha, x.data, Int32(x.strides[0]), beta, data, Int32(strides[0]))
+            catlas_daxpby(Int32(n), alpha, x.dataStart, Int32(x.strides[0]), beta, dataStart, Int32(strides[0]))
         }, fContiguous: { n in
-            catlas_daxpby(Int32(n), alpha, x.data, 1, beta, data, 1)
+            catlas_daxpby(Int32(n), alpha, x.dataStart, 1, beta, dataStart, 1)
         }, fSlice: { s, o in
             s.add(alpha, o, beta)
         })
@@ -218,9 +218,9 @@ public extension NdArray where T == Double {
     /// in place multiplication by a scalar
     func multiply(by x: T) {
         apply1d(f1d: { n in
-            cblas_dscal(Int32(n), x, data, Int32(strides[0]))
+            cblas_dscal(Int32(n), x, dataStart, Int32(strides[0]))
         }, fContiguous: { n in
-            cblas_dscal(Int32(n), x, data, 1)
+            cblas_dscal(Int32(n), x, dataStart, 1)
         }, fSlice: { s in
             s *= x
         })
@@ -233,9 +233,9 @@ public extension NdArray where T == Double {
     /// set all values to a new constant value
     func set(_ alpha: T) {
         apply1d(f1d: { n in
-            catlas_dset(Int32(n), alpha, data, Int32(strides[0]))
+            catlas_dset(Int32(n), alpha, dataStart, Int32(strides[0]))
         }, fContiguous: { n in
-            catlas_dset(Int32(n), alpha, data, 1)
+            catlas_dset(Int32(n), alpha, dataStart, 1)
         }, fSlice: { s in
             s.set(alpha)
         })
@@ -245,9 +245,9 @@ public extension NdArray where T == Double {
     func sum() -> T {
         var r = T.zero
         apply1d(f1d: { n in
-            vDSP_sveD(data, strides[0], &r, vDSP_Length(n))
+            vDSP_sveD(dataStart, strides[0], &r, vDSP_Length(n))
         }, fContiguous: { n in
-            vDSP_sveD(data, 1, &r, vDSP_Length(n))
+            vDSP_sveD(dataStart, 1, &r, vDSP_Length(n))
         }, fSlice: { s in
             r += s.sum()
         })
@@ -264,9 +264,9 @@ public extension NdArray where T == Float {
         }
         var r = data[0]
         apply1d(f1d: { n in
-            vDSP_maxv(data, strides[0], &r, vDSP_Length(n))
+            vDSP_maxv(dataStart, strides[0], &r, vDSP_Length(n))
         }, fContiguous: { n in
-            vDSP_maxv(data, 1, &r, vDSP_Length(n))
+            vDSP_maxv(dataStart, 1, &r, vDSP_Length(n))
         }, fSlice: { s in
             r = Swift.max(r, s.max()!)
         })
@@ -280,9 +280,9 @@ public extension NdArray where T == Float {
         }
         var r = data[0]
         apply1d(f1d: { n in
-            vDSP_minv(data, strides[0], &r, vDSP_Length(n))
+            vDSP_minv(dataStart, strides[0], &r, vDSP_Length(n))
         }, fContiguous: { n in
-            vDSP_minv(data, 1, &r, vDSP_Length(n))
+            vDSP_minv(dataStart, 1, &r, vDSP_Length(n))
         }, fSlice: { s in
             r = Swift.min(r, s.min()!)
         })
@@ -298,9 +298,9 @@ public extension NdArray where T == Float {
             Precondition failed while trying to add \(x.debugDescription) to \(debugDescription).
             """)
         apply1d(other: x, f1d: { n in
-            cblas_saxpy(Int32(n), alpha, x.data, Int32(x.strides[0]), data, Int32(strides[0]))
+            cblas_saxpy(Int32(n), alpha, x.dataStart, Int32(x.strides[0]), dataStart, Int32(strides[0]))
         }, fContiguous: { n in
-            cblas_saxpy(Int32(n), alpha, x.data, 1, data, 1)
+            cblas_saxpy(Int32(n), alpha, x.dataStart, 1, dataStart, 1)
         }, fSlice: { s, o in
             s.add(alpha, o)
         })
@@ -315,9 +315,9 @@ public extension NdArray where T == Float {
             Precondition failed while trying to add \(x.debugDescription) to \(debugDescription).
             """)
         apply1d(other: x, f1d: { n in
-            catlas_saxpby(Int32(n), alpha, x.data, Int32(x.strides[0]), beta, data, Int32(strides[0]))
+            catlas_saxpby(Int32(n), alpha, x.dataStart, Int32(x.strides[0]), beta, dataStart, Int32(strides[0]))
         }, fContiguous: { n in
-            catlas_saxpby(Int32(n), alpha, x.data, 1, beta, data, 1)
+            catlas_saxpby(Int32(n), alpha, x.dataStart, 1, beta, dataStart, 1)
         }, fSlice: { s, o in
             s.add(alpha, o, beta)
         })
@@ -326,9 +326,9 @@ public extension NdArray where T == Float {
     /// in place multiplication by a scalar
     func multiply(by x: T) {
         apply1d(f1d: { n in
-            cblas_sscal(Int32(n), x, data, Int32(strides[0]))
+            cblas_sscal(Int32(n), x, dataStart, Int32(strides[0]))
         }, fContiguous: { n in
-            cblas_sscal(Int32(n), x, data, 1)
+            cblas_sscal(Int32(n), x, dataStart, 1)
         }, fSlice: { s in
             s *= x
         })
@@ -341,9 +341,9 @@ public extension NdArray where T == Float {
     /// set all values to a new constant value
     func set(_ alpha: T) {
         apply1d(f1d: { n in
-            catlas_sset(Int32(n), alpha, data, Int32(strides[0]))
+            catlas_sset(Int32(n), alpha, dataStart, Int32(strides[0]))
         }, fContiguous: { n in
-            catlas_sset(Int32(n), alpha, data, 1)
+            catlas_sset(Int32(n), alpha, dataStart, 1)
         }, fSlice: { s in
             s.set(alpha)
         })
@@ -353,9 +353,9 @@ public extension NdArray where T == Float {
     func sum() -> T {
         var r = T.zero
         apply1d(f1d: { n in
-            vDSP_sve(data, strides[0], &r, vDSP_Length(n))
+            vDSP_sve(dataStart, strides[0], &r, vDSP_Length(n))
         }, fContiguous: { n in
-            vDSP_sve(data, 1, &r, vDSP_Length(n))
+            vDSP_sve(dataStart, 1, &r, vDSP_Length(n))
         }, fSlice: { s in
             r += s.sum()
         })
diff --git a/Sources/NdArray/basic_functions.swift b/Sources/NdArray/basic_functions.swift
index 58f891a..40aac9d 100644
--- a/Sources/NdArray/basic_functions.swift
+++ b/Sources/NdArray/basic_functions.swift
@@ -18,9 +18,9 @@ public func abs<K: SignedNumeric, T: NdArray<K>>(_ a: T) -> T where K: Comparabl
 /// see ``vDSP_vabsD``.
 public func abs<T: NdArray<Double>>(_ a: T, out b: T) {
     a.apply1d(other: b, f1d: { _ in
-        vDSP_vabsD(a.data, a.strides[0], b.data, b.strides[0], vDSP_Length(a.shape[0]))
+        vDSP_vabsD(a.dataStart, a.strides[0], b.dataStart, b.strides[0], vDSP_Length(a.shape[0]))
     }, fContiguous: { n in
-        vDSP_vabsD(a.data, 1, b.data, 1, vDSP_Length(n))
+        vDSP_vabsD(a.dataStart, 1, b.dataStart, 1, vDSP_Length(n))
     }, fSlice: { ai, bi in
         abs(ai, out: bi)
     })
@@ -149,9 +149,9 @@ public func logb<T: NdArray<Double>>(_ a: T) -> T {
 /// see ``vDSP_vabsD``.
 public func abs<T: NdArray<Float>>(_ a: T, out b: T) {
     a.apply1d(other: b, f1d: { _ in
-        vDSP_vabs(a.data, a.strides[0], b.data, b.strides[0], vDSP_Length(a.shape[0]))
+        vDSP_vabs(a.dataStart, a.strides[0], b.dataStart, b.strides[0], vDSP_Length(a.shape[0]))
     }, fContiguous: { n in
-        vDSP_vabs(a.data, 1, b.data, 1, vDSP_Length(n))
+        vDSP_vabs(a.dataStart, 1, b.dataStart, 1, vDSP_Length(n))
     }, fSlice: { ai, bi in
         abs(ai, out: bi)
     })
diff --git a/Sources/NdArray/copy.swift b/Sources/NdArray/copy.swift
index fa23def..f54dbf8 100644
--- a/Sources/NdArray/copy.swift
+++ b/Sources/NdArray/copy.swift
@@ -19,7 +19,7 @@ public extension NdArray {
         if (isCContiguous && out.isCContiguous) ||
                (isFContiguous && out.isFContiguous) {
             // since buffers may overlap, use memmove instead of memcpy
-            memmove(out.data, data, count * MemoryLayout<T>.stride)
+            memmove(out.dataStart, dataStart, count * MemoryLayout<T>.stride)
         } else if overlaps(out) {
             // if memory overlaps and is not 1d aligned make an intermediate copy
             if out.isFContiguous {
diff --git a/Sources/NdArray/init.swift b/Sources/NdArray/init.swift
index a46680e..d1562a0 100644
--- a/Sources/NdArray/init.swift
+++ b/Sources/NdArray/init.swift
@@ -94,7 +94,7 @@ public extension NdArray where T == Double {
     static func range(from start: T, to stop: T, by step: T = 1) -> Self {
         let n = arange(start: start, stop: stop, step: step)
         let a = NdArray(empty: n)
-        vramp(start: start, step: step, data: a.data, n: n, vramp: vDSP_vrampD)
+        vramp(start: start, step: step, data: a.dataStart, n: n, vramp: vDSP_vrampD)
         let r = self.init(a)
         r.stealOwnership()
         return r
@@ -138,7 +138,7 @@ public extension NdArray where T == Double {
 
     static func repeating(_ x: T, count: Int) -> Self {
         let a = NdArray(empty: count)
-        catlas_dset(Int32(count), x, a.data, 1)
+        catlas_dset(Int32(count), x, a.dataStart, 1)
         let r = self.init(a)
         r.stealOwnership()
         return r
@@ -158,7 +158,7 @@ public extension NdArray where T == Float {
     static func range(from start: T, to stop: T, by step: T = 1) -> Self {
         let n = arange(start: start, stop: stop, step: step)
         let a = NdArray(empty: n)
-        vramp(start: start, step: step, data: a.data, n: n, vramp: vDSP_vramp)
+        vramp(start: start, step: step, data: a.dataStart, n: n, vramp: vDSP_vramp)
         let r = self.init(a)
         r.stealOwnership()
         return r
@@ -202,7 +202,7 @@ public extension NdArray where T == Float {
 
     static func repeating(_ x: T, count: Int) -> Self {
         let a = NdArray(empty: count)
-        catlas_sset(Int32(count), x, a.data, 1)
+        catlas_sset(Int32(count), x, a.dataStart, 1)
         let r = self.init(a)
         r.stealOwnership()
         return r
@@ -223,7 +223,7 @@ public extension NdArray where T == Int {
     static func range(from start: T, to stop: T, by step: T = 1) -> Self {
         let n = arange(start: Double(start), stop: Double(stop), step: Double(step))
         let a = self.init(empty: n)
-        var p = a.data
+        var p = a.dataStart
         for i in stride(from: start, to: stop, by: step) {
             p.initialize(to: i)
             p += 1
@@ -235,7 +235,7 @@ public extension NdArray where T == Int {
 
     static func zeros(_ count: Int) -> Self {
         let a = self.init(empty: count)
-        memset(a.data, 0, count * MemoryLayout<Int>.stride)
+        memset(a.dataStart, 0, count * MemoryLayout<Int>.stride)
         let r = self.init(a)
         r.stealOwnership()
         return r
diff --git a/Sources/NdArray/reduce.swift b/Sources/NdArray/reduce.swift
index a762440..2b73407 100644
--- a/Sources/NdArray/reduce.swift
+++ b/Sources/NdArray/reduce.swift
@@ -13,13 +13,13 @@ public extension NdArray {
         var r = initialResult
         try apply1d(f1d: { n in
             let s = strides[0]
-            var p = data
+            var p = dataStart
             for _ in 0..<n {
                 r = try nextPartialResult(r, p.pointee)
                 p += s
             }
         }, fContiguous: { n in
-            var p = data
+            var p = dataStart
             for _ in 0..<n {
                 r = try nextPartialResult(r, p.pointee)
                 p += 1
diff --git a/Tests/NdArrayTests/VectorSequenceTests.swift b/Tests/NdArrayTests/VectorSequenceTests.swift
index 02c7404..bbca591 100644
--- a/Tests/NdArrayTests/VectorSequenceTests.swift
+++ b/Tests/NdArrayTests/VectorSequenceTests.swift
@@ -59,7 +59,8 @@ class VectorSequenceTests: XCTestCase {
         let a = Vector<Int>([1, 2, 3])
         XCTAssertTrue(a.isContiguous)
         let r: Int? = a.withContiguousStorageIfAvailable {
-            XCTAssertEqual($0.baseAddress!, a.data)
+            XCTAssertEqual($0.baseAddress!, a.data.baseAddress!)
+            XCTAssertEqual($0.count, a.data.count)
             XCTAssertEqual($0.count, a.shape[0])
             return 42
         }