M-Labs/nalgebra
3
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Replace slice->view in tests and benches

Browse Source
This commit is contained in:
Andreas Longva 2022-11-14 15:16:23 +01:00
parent 234d61faa2
commit 6c8947ccc0
4 changed files with 101 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
benches/core/matrix.rs
View File

@ -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
})
});

70
tests/core/conversion.rs
View File

@ -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());
}
}

48
tests/core/matrix.rs
View File

@ -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::<u8, Const<1024>, 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);

82
tests/core/matrix_slice.rs
View File

@ -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::<f32>::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::<f32>::zeros();
a.slice_with_steps((1, 2), (2, 2), (0, 1));
a.view_with_steps((1, 2), (2, 2), (0, 1));
}