Simplify nalgebra conversion implementations

jturner314 · jturner314 · commit ceaa1ef01338 · 2018-12-09T20:17:56.000-05:00
diff --git a/src/convert_nalgebra_0_15.rs b/src/convert_nalgebra_0_15.rs
@@ -66,7 +66,7 @@ where
     /// ```
     fn from(slice: na::MatrixSlice<'a, A, R, na::U1, RStride, CStride>) -> ArrayView<'a, A, Ix1> {
         if slice.is_empty() {
-            ArrayView::from_shape(slice.shape().0, &[]).unwrap()
+            ArrayView::from(&[])
         } else {
             let dim = Dim(slice.shape().0);
             let strides = Dim(slice.strides().0);
@@ -77,8 +77,7 @@ where
             );
             dimension::max_abs_offset_check_overflow::<A, _>(&dim, &strides)
                 .expect("overflow converting `nalgebra::MatrixSlice` to `nalgebra::ArrayView`");
-            let ptr: *const A = slice.iter().next().unwrap();
-            unsafe { ArrayView::from_shape_ptr(dim.strides(strides), ptr) }
+            unsafe { ArrayView::from_shape_ptr(dim.strides(strides), slice.get_unchecked(0, 0)) }
         }
     }
 }
@@ -119,7 +118,7 @@ where
         mut slice: na::MatrixSliceMut<'a, A, R, na::U1, RStride, CStride>,
     ) -> ArrayViewMut<'a, A, Ix1> {
         if slice.is_empty() {
-            ArrayViewMut::from_shape(slice.shape().0, &mut []).unwrap()
+            ArrayViewMut::from(&mut [])
         } else {
             let dim = Dim(slice.shape().0);
             let strides = Dim(slice.strides().0);
@@ -139,8 +138,9 @@ where
             dimension::max_abs_offset_check_overflow::<A, _>(&dim, &strides).expect(
                 "overflow converting `nalgebra::MatrixSliceMut` to `nalgebra::ArrayViewMut`",
             );
-            let ptr: *mut A = slice.iter_mut().next().unwrap();
-            unsafe { ArrayViewMut::from_shape_ptr(dim.strides(strides), ptr) }
+            unsafe {
+                ArrayViewMut::from_shape_ptr(dim.strides(strides), slice.get_unchecked_mut(0, 0))
+            }
         }
     }
 }
@@ -225,8 +225,7 @@ where
             );
             dimension::max_abs_offset_check_overflow::<A, _>(&dim, &strides)
                 .expect("overflow converting `nalgebra::MatrixSlice` to `nalgebra::ArrayView`");
-            let ptr: *const A = slice.iter().next().unwrap();
-            unsafe { ArrayView::from_shape_ptr(dim.strides(strides), ptr) }
+            unsafe { ArrayView::from_shape_ptr(dim.strides(strides), slice.get_unchecked(0, 0)) }
         }
     }
 }
@@ -289,8 +288,9 @@ where
             dimension::max_abs_offset_check_overflow::<A, _>(&dim, &strides).expect(
                 "overflow converting `nalgebra::MatrixSliceMut` to `nalgebra::ArrayViewMut`",
             );
-            let ptr: *mut A = slice.iter_mut().next().unwrap();
-            unsafe { ArrayViewMut::from_shape_ptr(dim.strides(strides), ptr) }
+            unsafe {
+                ArrayViewMut::from_shape_ptr(dim.strides(strides), slice.get_unchecked_mut(0, 0))
+            }
         }
     }
 }
diff --git a/src/convert_nalgebra_0_16.rs b/src/convert_nalgebra_0_16.rs
@@ -66,7 +66,7 @@ where
     /// ```
     fn from(slice: na::MatrixSlice<'a, A, R, na::U1, RStride, CStride>) -> ArrayView<'a, A, Ix1> {
         if slice.is_empty() {
-            ArrayView::from_shape(slice.shape().0, &[]).unwrap()
+            ArrayView::from(&[])
         } else {
             let dim = Dim(slice.shape().0);
             let strides = Dim(slice.strides().0);
@@ -77,8 +77,7 @@ where
             );
             dimension::max_abs_offset_check_overflow::<A, _>(&dim, &strides)
                 .expect("overflow converting `nalgebra::MatrixSlice` to `nalgebra::ArrayView`");
-            let ptr: *const A = slice.iter().next().unwrap();
-            unsafe { ArrayView::from_shape_ptr(dim.strides(strides), ptr) }
+            unsafe { ArrayView::from_shape_ptr(dim.strides(strides), slice.get_unchecked(0, 0)) }
         }
     }
 }
@@ -119,7 +118,7 @@ where
         mut slice: na::MatrixSliceMut<'a, A, R, na::U1, RStride, CStride>,
     ) -> ArrayViewMut<'a, A, Ix1> {
         if slice.is_empty() {
-            ArrayViewMut::from_shape(slice.shape().0, &mut []).unwrap()
+            ArrayViewMut::from(&mut [])
         } else {
             let dim = Dim(slice.shape().0);
             let strides = Dim(slice.strides().0);
@@ -139,8 +138,9 @@ where
             dimension::max_abs_offset_check_overflow::<A, _>(&dim, &strides).expect(
                 "overflow converting `nalgebra::MatrixSliceMut` to `nalgebra::ArrayViewMut`",
             );
-            let ptr: *mut A = slice.iter_mut().next().unwrap();
-            unsafe { ArrayViewMut::from_shape_ptr(dim.strides(strides), ptr) }
+            unsafe {
+                ArrayViewMut::from_shape_ptr(dim.strides(strides), slice.get_unchecked_mut(0, 0))
+            }
         }
     }
 }
@@ -225,8 +225,7 @@ where
             );
             dimension::max_abs_offset_check_overflow::<A, _>(&dim, &strides)
                 .expect("overflow converting `nalgebra::MatrixSlice` to `nalgebra::ArrayView`");
-            let ptr: *const A = slice.iter().next().unwrap();
-            unsafe { ArrayView::from_shape_ptr(dim.strides(strides), ptr) }
+            unsafe { ArrayView::from_shape_ptr(dim.strides(strides), slice.get_unchecked(0, 0)) }
         }
     }
 }
@@ -289,8 +288,9 @@ where
             dimension::max_abs_offset_check_overflow::<A, _>(&dim, &strides).expect(
                 "overflow converting `nalgebra::MatrixSliceMut` to `nalgebra::ArrayViewMut`",
             );
-            let ptr: *mut A = slice.iter_mut().next().unwrap();
-            unsafe { ArrayViewMut::from_shape_ptr(dim.strides(strides), ptr) }
+            unsafe {
+                ArrayViewMut::from_shape_ptr(dim.strides(strides), slice.get_unchecked_mut(0, 0))
+            }
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ where`
`66`	`66`	/// ```
`67`	`67`	`fn from(slice: na::MatrixSlice<'a, A, R, na::U1, RStride, CStride>) -> ArrayView<'a, A, Ix1> {`
`68`	`68`	`if slice.is_empty() {`
`69`		`- ArrayView::from_shape(slice.shape().0, &[]).unwrap()`
	`69`	`+ ArrayView::from(&[])`
`70`	`70`	`} else {`
`71`	`71`	`let dim = Dim(slice.shape().0);`
`72`	`72`	`let strides = Dim(slice.strides().0);`
`@@ -77,8 +77,7 @@ where`
`77`	`77`	`);`
`78`	`78`	`dimension::max_abs_offset_check_overflow::<A, _>(&dim, &strides)`
`79`	`79`	.expect("overflow converting `nalgebra::MatrixSlice` to `nalgebra::ArrayView`");
`80`		`- let ptr: *const A = slice.iter().next().unwrap();`
`81`		`- unsafe { ArrayView::from_shape_ptr(dim.strides(strides), ptr) }`
	`80`	`+ unsafe { ArrayView::from_shape_ptr(dim.strides(strides), slice.get_unchecked(0, 0)) }`
`82`	`81`	`}`
`83`	`82`	`}`
`84`	`83`	`}`
`@@ -119,7 +118,7 @@ where`
`119`	`118`	`mut slice: na::MatrixSliceMut<'a, A, R, na::U1, RStride, CStride>,`
`120`	`119`	`) -> ArrayViewMut<'a, A, Ix1> {`
`121`	`120`	`if slice.is_empty() {`
`122`		`- ArrayViewMut::from_shape(slice.shape().0, &mut []).unwrap()`
	`121`	`+ ArrayViewMut::from(&mut [])`
`123`	`122`	`} else {`
`124`	`123`	`let dim = Dim(slice.shape().0);`
`125`	`124`	`let strides = Dim(slice.strides().0);`
`@@ -139,8 +138,9 @@ where`
`139`	`138`	`dimension::max_abs_offset_check_overflow::<A, _>(&dim, &strides).expect(`
`140`	`139`	"overflow converting `nalgebra::MatrixSliceMut` to `nalgebra::ArrayViewMut`",
`141`	`140`	`);`
`142`		`- let ptr: *mut A = slice.iter_mut().next().unwrap();`
`143`		`- unsafe { ArrayViewMut::from_shape_ptr(dim.strides(strides), ptr) }`
	`141`	`+ unsafe {`
	`142`	`+ ArrayViewMut::from_shape_ptr(dim.strides(strides), slice.get_unchecked_mut(0, 0))`
	`143`	`+ }`
`144`	`144`	`}`
`145`	`145`	`}`
`146`	`146`	`}`
`@@ -225,8 +225,7 @@ where`
`225`	`225`	`);`
`226`	`226`	`dimension::max_abs_offset_check_overflow::<A, _>(&dim, &strides)`
`227`	`227`	.expect("overflow converting `nalgebra::MatrixSlice` to `nalgebra::ArrayView`");
`228`		`- let ptr: *const A = slice.iter().next().unwrap();`
`229`		`- unsafe { ArrayView::from_shape_ptr(dim.strides(strides), ptr) }`
	`228`	`+ unsafe { ArrayView::from_shape_ptr(dim.strides(strides), slice.get_unchecked(0, 0)) }`
`230`	`229`	`}`
`231`	`230`	`}`
`232`	`231`	`}`
`@@ -289,8 +288,9 @@ where`
`289`	`288`	`dimension::max_abs_offset_check_overflow::<A, _>(&dim, &strides).expect(`
`290`	`289`	"overflow converting `nalgebra::MatrixSliceMut` to `nalgebra::ArrayViewMut`",
`291`	`290`	`);`
`292`		`- let ptr: *mut A = slice.iter_mut().next().unwrap();`
`293`		`- unsafe { ArrayViewMut::from_shape_ptr(dim.strides(strides), ptr) }`
	`291`	`+ unsafe {`
	`292`	`+ ArrayViewMut::from_shape_ptr(dim.strides(strides), slice.get_unchecked_mut(0, 0))`
	`293`	`+ }`
`294`	`294`	`}`
`295`	`295`	`}`
`296`	`296`	`}`