diff --git a/benches/core/matrix.rs b/benches/core/matrix.rs index 3c483c35..8f3d6305 100644 --- a/benches/core/matrix.rs +++ b/benches/core/matrix.rs @@ -53,7 +53,7 @@ fn mat_div_scalar(b: &mut criterion::Criterion) { b.bench_function("mat_div_scalar", move |bh| { bh.iter(|| { let mut aa = a.clone(); - let mut b = aa.slice_mut((0, 0), (1000, 1000)); + let mut b = aa.view_mut((0, 0), (1000, 1000)); b /= n }) }); diff --git a/tests/core/conversion.rs b/tests/core/conversion.rs index 5374c399..096f235b 100644 --- a/tests/core/conversion.rs +++ b/tests/core/conversion.rs @@ -7,7 +7,7 @@ use na::{ RowVector5, RowVector6, Similarity3, Transform3, UnitQuaternion, Vector1, Vector2, Vector3, Vector4, Vector5, Vector6, }; -use na::{DMatrix, DMatrixSlice, DMatrixSliceMut, MatrixSlice, MatrixSliceMut}; +use na::{DMatrix, DMatrixView, DMatrixViewMut, MatrixView, MatrixViewMut}; use na::{U1, U3, U4}; use crate::proptest::*; @@ -266,24 +266,24 @@ fn matrix_slice_from_matrix_ref() { // Note: these have to be macros, and not functions, because the input type is different // across the different tests. Moreover, the output type depends on the stride of the input, // which is different for static and dynamic matrices. - macro_rules! dynamic_slice { + macro_rules! dynamic_view { ($mref:expr) => { - DMatrixSlice::<_>::from($mref) + DMatrixView::<_>::from($mref) }; } - macro_rules! dynamic_slice_mut { + macro_rules! dynamic_view_mut { ($mref:expr) => { - DMatrixSliceMut::<_>::from($mref) + DMatrixViewMut::<_>::from($mref) }; } - macro_rules! fixed_slice { + macro_rules! fixed_view { ($mref:expr) => { - MatrixSlice::<_, U3, U4, U1, U3>::from($mref) + MatrixView::<_, U3, U4, U1, U3>::from($mref) }; } - macro_rules! fixed_slice_mut { + macro_rules! fixed_view_mut { ($mref:expr) => { - MatrixSliceMut::<_, U3, U4, U1, U3>::from($mref) + MatrixViewMut::<_, U3, U4, U1, U3>::from($mref) }; } @@ -291,66 +291,66 @@ fn matrix_slice_from_matrix_ref() { // Self and RHS. See issue #674. Once this is implemented, we can remove `into_owned` // from the below tests. - // Construct slices from reference to a + // Construct views from reference to a { - assert_eq!(a, fixed_slice!(&a).into_owned()); - assert_eq!(d, dynamic_slice!(&a).into_owned()); + assert_eq!(a, fixed_view!(&a).into_owned()); + assert_eq!(d, dynamic_view!(&a).into_owned()); } - // Construct slices from mutable reference to a + // Construct views from mutable reference to a { let mut a_clone = a.clone(); - assert_eq!(a, fixed_slice!(&mut a_clone).into_owned()); - assert_eq!(d, dynamic_slice!(&mut a_clone).into_owned()); + assert_eq!(a, fixed_view!(&mut a_clone).into_owned()); + assert_eq!(d, dynamic_view!(&mut a_clone).into_owned()); } // Construct mutable slices from mutable reference to a { let mut a_clone = a.clone(); - assert_eq!(a, fixed_slice_mut!(&mut a_clone).into_owned()); - assert_eq!(d, dynamic_slice_mut!(&mut a_clone).into_owned()); + assert_eq!(a, fixed_view_mut!(&mut a_clone).into_owned()); + assert_eq!(d, dynamic_view_mut!(&mut a_clone).into_owned()); } // Construct slices from reference to d { - assert_eq!(a, fixed_slice!(&d).into_owned()); - assert_eq!(d, dynamic_slice!(&d).into_owned()); + assert_eq!(a, fixed_view!(&d).into_owned()); + assert_eq!(d, dynamic_view!(&d).into_owned()); } // Construct slices from mutable reference to d { let mut d_clone = a.clone(); - assert_eq!(a, fixed_slice!(&mut d_clone).into_owned()); - assert_eq!(d, dynamic_slice!(&mut d_clone).into_owned()); + assert_eq!(a, fixed_view!(&mut d_clone).into_owned()); + assert_eq!(d, dynamic_view!(&mut d_clone).into_owned()); } // Construct mutable slices from mutable reference to d { let mut d_clone = d.clone(); - assert_eq!(a, fixed_slice_mut!(&mut d_clone).into_owned()); - assert_eq!(d, dynamic_slice_mut!(&mut d_clone).into_owned()); + assert_eq!(a, fixed_view_mut!(&mut d_clone).into_owned()); + assert_eq!(d, dynamic_view_mut!(&mut d_clone).into_owned()); } // Construct slices from a slice of a { - let mut a_slice = fixed_slice!(&a); - assert_eq!(a, fixed_slice!(&a_slice).into_owned()); - assert_eq!(a, fixed_slice!(&mut a_slice).into_owned()); - assert_eq!(d, dynamic_slice!(&a_slice).into_owned()); - assert_eq!(d, dynamic_slice!(&mut a_slice).into_owned()); + let mut a_slice = fixed_view!(&a); + assert_eq!(a, fixed_view!(&a_slice).into_owned()); + assert_eq!(a, fixed_view!(&mut a_slice).into_owned()); + assert_eq!(d, dynamic_view!(&a_slice).into_owned()); + assert_eq!(d, dynamic_view!(&mut a_slice).into_owned()); } // Construct slices from a slice mut of a { // Need a clone of a here, so that we can both have a mutable borrow and compare equality let mut a_clone = a.clone(); - let mut a_slice = fixed_slice_mut!(&mut a_clone); + let mut a_slice = fixed_view_mut!(&mut a_clone); - assert_eq!(a, fixed_slice!(&a_slice).into_owned()); - assert_eq!(a, fixed_slice!(&mut a_slice).into_owned()); - assert_eq!(d, dynamic_slice!(&a_slice).into_owned()); - assert_eq!(d, dynamic_slice!(&mut a_slice).into_owned()); - assert_eq!(a, fixed_slice_mut!(&mut a_slice).into_owned()); - assert_eq!(d, dynamic_slice_mut!(&mut a_slice).into_owned()); + assert_eq!(a, fixed_view!(&a_slice).into_owned()); + assert_eq!(a, fixed_view!(&mut a_slice).into_owned()); + assert_eq!(d, dynamic_view!(&a_slice).into_owned()); + assert_eq!(d, dynamic_view!(&mut a_slice).into_owned()); + assert_eq!(a, fixed_view_mut!(&mut a_slice).into_owned()); + assert_eq!(d, dynamic_view_mut!(&mut a_slice).into_owned()); } } diff --git a/tests/core/matrix.rs b/tests/core/matrix.rs index 8a545e97..219845d4 100644 --- a/tests/core/matrix.rs +++ b/tests/core/matrix.rs @@ -1066,43 +1066,43 @@ fn partial_eq_different_types() { let static_mat = Matrix2x4::new(1, 2, 3, 4, 5, 6, 7, 8); let mut typenum_static_mat = OMatrix::, Const<4>>::zeros(); - let mut slice = typenum_static_mat.slice_mut((0, 0), (2, 4)); - slice += static_mat; + let mut view = typenum_static_mat.view_mut((0, 0), (2, 4)); + view += static_mat; - let fslice_of_dmat = dynamic_mat.fixed_slice::<2, 2>(0, 0); - let dslice_of_dmat = dynamic_mat.slice((0, 0), (2, 2)); - let fslice_of_smat = static_mat.fixed_slice::<2, 2>(0, 0); - let dslice_of_smat = static_mat.slice((0, 0), (2, 2)); + let fview_of_dmat = dynamic_mat.fixed_view::<2, 2>(0, 0); + let dview_of_dmat = dynamic_mat.view((0, 0), (2, 2)); + let fview_of_smat = static_mat.fixed_view::<2, 2>(0, 0); + let dview_of_smat = static_mat.view((0, 0), (2, 2)); assert_eq!(dynamic_mat, static_mat); assert_eq!(static_mat, dynamic_mat); - assert_eq!(dynamic_mat, slice); - assert_eq!(slice, dynamic_mat); + assert_eq!(dynamic_mat, view); + assert_eq!(view, dynamic_mat); - assert_eq!(static_mat, slice); - assert_eq!(slice, static_mat); + assert_eq!(static_mat, view); + assert_eq!(view, static_mat); - assert_eq!(fslice_of_dmat, dslice_of_dmat); - assert_eq!(dslice_of_dmat, fslice_of_dmat); + assert_eq!(fview_of_dmat, dview_of_dmat); + assert_eq!(dview_of_dmat, fview_of_dmat); - assert_eq!(fslice_of_dmat, fslice_of_smat); - assert_eq!(fslice_of_smat, fslice_of_dmat); + assert_eq!(fview_of_dmat, fview_of_smat); + assert_eq!(fview_of_smat, fview_of_dmat); - assert_eq!(fslice_of_dmat, dslice_of_smat); - assert_eq!(dslice_of_smat, fslice_of_dmat); + assert_eq!(fview_of_dmat, dview_of_smat); + assert_eq!(dview_of_smat, fview_of_dmat); - assert_eq!(dslice_of_dmat, fslice_of_smat); - assert_eq!(fslice_of_smat, dslice_of_dmat); + assert_eq!(dview_of_dmat, fview_of_smat); + assert_eq!(fview_of_smat, dview_of_dmat); - assert_eq!(dslice_of_dmat, dslice_of_smat); - assert_eq!(dslice_of_smat, dslice_of_dmat); + assert_eq!(dview_of_dmat, dview_of_smat); + assert_eq!(dview_of_smat, dview_of_dmat); - assert_eq!(fslice_of_smat, dslice_of_smat); - assert_eq!(dslice_of_smat, fslice_of_smat); + assert_eq!(fview_of_smat, dview_of_smat); + assert_eq!(dview_of_smat, fview_of_smat); - assert_ne!(dynamic_mat, dslice_of_smat); - assert_ne!(dslice_of_smat, dynamic_mat); + assert_ne!(dynamic_mat, dview_of_smat); + assert_ne!(dview_of_smat, dynamic_mat); // TODO - implement those comparisons // assert_ne!(static_mat, typenum_static_mat); diff --git a/tests/core/matrix_slice.rs b/tests/core/matrix_slice.rs index ada5297e..ce3a1c37 100644 --- a/tests/core/matrix_slice.rs +++ b/tests/core/matrix_slice.rs @@ -1,22 +1,22 @@ #![allow(non_snake_case)] use na::{ - DMatrix, DMatrixSlice, DMatrixSliceMut, Matrix2, Matrix2x3, Matrix2x4, Matrix2x6, Matrix3, - Matrix3x2, Matrix3x4, Matrix4x2, Matrix6x2, MatrixSlice2, MatrixSlice2x3, MatrixSlice2xX, - MatrixSlice3, MatrixSlice3x2, MatrixSliceMut2, MatrixSliceMut2x3, MatrixSliceMut2xX, - MatrixSliceMut3, MatrixSliceMut3x2, MatrixSliceMutXx3, MatrixSliceXx3, RowVector4, Vector3, + DMatrix, DMatrixView, DMatrixViewMut, Matrix2, Matrix2x3, Matrix2x4, Matrix2x6, Matrix3, + Matrix3x2, Matrix3x4, Matrix4x2, Matrix6x2, MatrixView2, MatrixView2x3, MatrixView2xX, + MatrixView3, MatrixView3x2, MatrixViewMut2, MatrixViewMut2x3, MatrixViewMut2xX, + MatrixViewMut3, MatrixViewMut3x2, MatrixViewMutXx3, MatrixViewXx3, RowVector4, Vector3, }; #[test] #[rustfmt::skip] -fn nested_fixed_slices() { +fn nested_fixed_views() { let a = Matrix3x4::new(11.0, 12.0, 13.0, 14.0, 21.0, 22.0, 23.0, 24.0, 31.0, 32.0, 33.0, 34.0); - let s1 = a.fixed_slice::<3, 3>(0, 1); // Simple slice. - let s2 = s1.fixed_slice::<2, 2>(1, 1); // Slice of slice. - let s3 = s1.fixed_slice_with_steps::<2, 2>((0, 0), (1, 1)); // Slice of slice with steps. + let s1 = a.fixed_view::<3, 3>(0, 1); // Simple view. + let s2 = s1.fixed_view::<2, 2>(1, 1); // View of view. + let s3 = s1.fixed_view_with_steps::<2, 2>((0, 0), (1, 1)); // View of view with steps. let expected_owned_s1 = Matrix3::new(12.0, 13.0, 14.0, 22.0, 23.0, 24.0, @@ -35,14 +35,14 @@ fn nested_fixed_slices() { #[test] #[rustfmt::skip] -fn nested_slices() { +fn nested_views() { let a = Matrix3x4::new(11.0, 12.0, 13.0, 14.0, 21.0, 22.0, 23.0, 24.0, 31.0, 32.0, 33.0, 34.0); - let s1 = a.slice((0, 1), (3, 3)); - let s2 = s1.slice((1, 1), (2, 2)); - let s3 = s1.slice_with_steps((0, 0), (2, 2), (1, 1)); + let s1 = a.view((0, 1), (3, 3)); + let s2 = s1.view((1, 1), (2, 2)); + let s3 = s1.view_with_steps((0, 0), (2, 2), (1, 1)); let expected_owned_s1 = DMatrix::from_row_slice(3, 3, &[ 12.0, 13.0, 14.0, 22.0, 23.0, 24.0, @@ -61,14 +61,14 @@ fn nested_slices() { #[test] #[rustfmt::skip] -fn slice_mut() { +fn view_mut() { let mut a = Matrix3x4::new(11.0, 12.0, 13.0, 14.0, 21.0, 22.0, 23.0, 24.0, 31.0, 32.0, 33.0, 34.0); { - // We modify `a` through the mutable slice. - let mut s1 = a.slice_with_steps_mut((0, 1), (2, 2), (1, 1)); + // We modify `a` through the mutable view. + let mut s1 = a.view_with_steps_mut((0, 1), (2, 2), (1, 1)); s1.fill(0.0); } @@ -81,7 +81,7 @@ fn slice_mut() { #[test] #[rustfmt::skip] -fn nested_row_slices() { +fn nested_row_views() { let a = Matrix6x2::new(11.0, 12.0, 21.0, 22.0, 31.0, 32.0, @@ -105,7 +105,7 @@ fn nested_row_slices() { #[test] #[rustfmt::skip] -fn row_slice_mut() { +fn row_view_mut() { let mut a = Matrix6x2::new(11.0, 12.0, 21.0, 22.0, 31.0, 32.0, @@ -113,7 +113,7 @@ fn row_slice_mut() { 51.0, 52.0, 61.0, 62.0); { - // We modify `a` through the mutable slice. + // We modify `a` through the mutable view. let mut s1 = a.rows_with_step_mut(1, 3, 1); s1.fill(0.0); } @@ -130,7 +130,7 @@ fn row_slice_mut() { #[test] #[rustfmt::skip] -fn nested_col_slices() { +fn nested_col_views() { let a = Matrix2x6::new(11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0); let s1 = a.fixed_columns::<4>(1); @@ -148,12 +148,12 @@ fn nested_col_slices() { #[test] #[rustfmt::skip] -fn col_slice_mut() { +fn col_view_mut() { let mut a = Matrix2x6::new(11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 21.0, 22.0, 23.0, 24.0, 25.0, 26.0); { - // We modify `a` through the mutable slice. + // We modify `a` through the mutable view. let mut s1 = a.columns_with_step_mut(1, 3, 1); s1.fill(0.0); } @@ -203,7 +203,7 @@ fn columns_range_pair() { #[test] #[rustfmt::skip] -fn new_slice() { +fn new_from_slice() { let data = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ]; @@ -214,13 +214,13 @@ fn new_slice() { let expected3x2 = Matrix3x2::from_column_slice(&data); { - let m2 = MatrixSlice2::from_slice(&data); - let m3 = MatrixSlice3::from_slice(&data); - let m2x3 = MatrixSlice2x3::from_slice(&data); - let m3x2 = MatrixSlice3x2::from_slice(&data); - let m2xX = MatrixSlice2xX::from_slice(&data, 3); - let mXx3 = MatrixSliceXx3::from_slice(&data, 2); - let mXxX = DMatrixSlice::from_slice(&data, 2, 3); + let m2 = MatrixView2::from_slice(&data); + let m3 = MatrixView3::from_slice(&data); + let m2x3 = MatrixView2x3::from_slice(&data); + let m3x2 = MatrixView3x2::from_slice(&data); + let m2xX = MatrixView2xX::from_slice(&data, 3); + let mXx3 = MatrixViewXx3::from_slice(&data, 2); + let mXxX = DMatrixView::from_slice(&data, 2, 3); assert!(m2.eq(&expected2)); assert!(m3.eq(&expected3)); @@ -234,7 +234,7 @@ fn new_slice() { #[test] #[rustfmt::skip] -fn new_slice_mut() { +fn new_from_slice_mut() { let data = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ]; @@ -252,31 +252,31 @@ fn new_slice_mut() { 9.0, 10.0, 11.0, 12.0 ]; let mut data_mut = data.clone(); - MatrixSliceMut2::from_slice(&mut data_mut).fill(0.0); + MatrixViewMut2::from_slice(&mut data_mut).fill(0.0); assert!(data_mut == expected2); let mut data_mut = data.clone(); - MatrixSliceMut3::from_slice(&mut data_mut).fill(0.0); + MatrixViewMut3::from_slice(&mut data_mut).fill(0.0); assert!(data_mut == expected3); let mut data_mut = data.clone(); - MatrixSliceMut2x3::from_slice(&mut data_mut).fill(0.0); + MatrixViewMut2x3::from_slice(&mut data_mut).fill(0.0); assert!(data_mut == expected2x3); let mut data_mut = data.clone(); - MatrixSliceMut3x2::from_slice(&mut data_mut).fill(0.0); + MatrixViewMut3x2::from_slice(&mut data_mut).fill(0.0); assert!(data_mut == expected3x2); let mut data_mut = data.clone(); - MatrixSliceMut2xX::from_slice(&mut data_mut, 3).fill(0.0); + MatrixViewMut2xX::from_slice(&mut data_mut, 3).fill(0.0); assert!(data_mut == expected2x3); let mut data_mut = data.clone(); - MatrixSliceMutXx3::from_slice(&mut data_mut, 2).fill(0.0); + MatrixViewMutXx3::from_slice(&mut data_mut, 2).fill(0.0); assert!(data_mut == expected2x3); let mut data_mut = data.clone(); - DMatrixSliceMut::from_slice(&mut data_mut, 2, 3).fill(0.0); + DMatrixViewMut::from_slice(&mut data_mut, 2, 3).fill(0.0); assert!(data_mut == expected2x3); } @@ -324,14 +324,14 @@ fn columns_with_step_out_of_bounds() { #[test] #[should_panic] -fn slice_out_of_bounds() { +fn view_out_of_bounds() { let a = Matrix3x4::::zeros(); - a.slice((1, 2), (3, 1)); + a.view((1, 2), (3, 1)); } #[test] #[should_panic] -fn slice_with_steps_out_of_bounds() { +fn view_with_steps_out_of_bounds() { let a = Matrix3x4::::zeros(); - a.slice_with_steps((1, 2), (2, 2), (0, 1)); + a.view_with_steps((1, 2), (2, 2), (0, 1)); }